1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Written 1992,1993 by Werner Almesberger |
4 | * 22/11/2000 - Fixed fat_date_unix2dos for dates earlier than 01/01/1980 |
5 | * and date_dos2unix for date==0 by Igor Zhbanov(bsg@uniyar.ac.ru) |
6 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. |
7 | */ |
8 | |
9 | #include <linux/time.h> |
10 | #include <linux/fs.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/buffer_head.h> |
13 | #include <linux/blk_types.h> |
14 | |
15 | #include "exfat_raw.h" |
16 | #include "exfat_fs.h" |
17 | |
18 | /* |
19 | * exfat_fs_error reports a file system problem that might indicate fa data |
20 | * corruption/inconsistency. Depending on 'errors' mount option the |
21 | * panic() is called, or error message is printed FAT and nothing is done, |
22 | * or filesystem is remounted read-only (default behavior). |
23 | * In case the file system is remounted read-only, it can be made writable |
24 | * again by remounting it. |
25 | */ |
26 | void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...) |
27 | { |
28 | struct exfat_mount_options *opts = &EXFAT_SB(sb)->options; |
29 | va_list args; |
30 | struct va_format vaf; |
31 | |
32 | if (report) { |
33 | va_start(args, fmt); |
34 | vaf.fmt = fmt; |
35 | vaf.va = &args; |
36 | exfat_err(sb, "error, %pV" , &vaf); |
37 | va_end(args); |
38 | } |
39 | |
40 | if (opts->errors == EXFAT_ERRORS_PANIC) { |
41 | panic(fmt: "exFAT-fs (%s): fs panic from previous error\n" , |
42 | sb->s_id); |
43 | } else if (opts->errors == EXFAT_ERRORS_RO && !sb_rdonly(sb)) { |
44 | sb->s_flags |= SB_RDONLY; |
45 | exfat_err(sb, "Filesystem has been set read-only" ); |
46 | } |
47 | } |
48 | |
49 | #define SECS_PER_MIN (60) |
50 | #define TIMEZONE_SEC(x) ((x) * 15 * SECS_PER_MIN) |
51 | |
52 | static void exfat_adjust_tz(struct timespec64 *ts, u8 tz_off) |
53 | { |
54 | if (tz_off <= 0x3F) |
55 | ts->tv_sec -= TIMEZONE_SEC(tz_off); |
56 | else /* 0x40 <= (tz_off & 0x7F) <=0x7F */ |
57 | ts->tv_sec += TIMEZONE_SEC(0x80 - tz_off); |
58 | } |
59 | |
60 | static inline int exfat_tz_offset(struct exfat_sb_info *sbi) |
61 | { |
62 | if (sbi->options.sys_tz) |
63 | return -sys_tz.tz_minuteswest; |
64 | return sbi->options.time_offset; |
65 | } |
66 | |
67 | /* Convert a EXFAT time/date pair to a UNIX date (seconds since 1 1 70). */ |
68 | void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, |
69 | u8 tz, __le16 time, __le16 date, u8 time_cs) |
70 | { |
71 | u16 t = le16_to_cpu(time); |
72 | u16 d = le16_to_cpu(date); |
73 | |
74 | ts->tv_sec = mktime64(year: 1980 + (d >> 9), mon: d >> 5 & 0x000F, day: d & 0x001F, |
75 | hour: t >> 11, min: (t >> 5) & 0x003F, sec: (t & 0x001F) << 1); |
76 | |
77 | |
78 | /* time_cs field represent 0 ~ 199cs(1990 ms) */ |
79 | if (time_cs) { |
80 | ts->tv_sec += time_cs / 100; |
81 | ts->tv_nsec = (time_cs % 100) * 10 * NSEC_PER_MSEC; |
82 | } else |
83 | ts->tv_nsec = 0; |
84 | |
85 | if (tz & EXFAT_TZ_VALID) |
86 | /* Adjust timezone to UTC0. */ |
87 | exfat_adjust_tz(ts, tz_off: tz & ~EXFAT_TZ_VALID); |
88 | else |
89 | ts->tv_sec -= exfat_tz_offset(sbi) * SECS_PER_MIN; |
90 | } |
91 | |
92 | /* Convert linear UNIX date to a EXFAT time/date pair. */ |
93 | void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, |
94 | u8 *tz, __le16 *time, __le16 *date, u8 *time_cs) |
95 | { |
96 | struct tm tm; |
97 | u16 t, d; |
98 | |
99 | time64_to_tm(totalsecs: ts->tv_sec, offset: 0, result: &tm); |
100 | t = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec >> 1); |
101 | d = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday; |
102 | |
103 | *time = cpu_to_le16(t); |
104 | *date = cpu_to_le16(d); |
105 | |
106 | /* time_cs field represent 0 ~ 199cs(1990 ms) */ |
107 | if (time_cs) |
108 | *time_cs = (tm.tm_sec & 1) * 100 + |
109 | ts->tv_nsec / (10 * NSEC_PER_MSEC); |
110 | |
111 | /* |
112 | * Record 00h value for OffsetFromUtc field and 1 value for OffsetValid |
113 | * to indicate that local time and UTC are the same. |
114 | */ |
115 | *tz = EXFAT_TZ_VALID; |
116 | } |
117 | |
118 | /* |
119 | * The timestamp for access_time has double seconds granularity. |
120 | * (There is no 10msIncrement field for access_time unlike create/modify_time) |
121 | * atime also has only a 2-second resolution. |
122 | */ |
123 | void exfat_truncate_atime(struct timespec64 *ts) |
124 | { |
125 | ts->tv_sec = round_down(ts->tv_sec, 2); |
126 | ts->tv_nsec = 0; |
127 | } |
128 | |
129 | void exfat_truncate_inode_atime(struct inode *inode) |
130 | { |
131 | struct timespec64 atime = inode_get_atime(inode); |
132 | |
133 | exfat_truncate_atime(ts: &atime); |
134 | inode_set_atime_to_ts(inode, ts: atime); |
135 | } |
136 | |
137 | u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type) |
138 | { |
139 | int i; |
140 | u8 *c = (u8 *)data; |
141 | |
142 | for (i = 0; i < len; i++, c++) { |
143 | if (unlikely(type == CS_DIR_ENTRY && (i == 2 || i == 3))) |
144 | continue; |
145 | chksum = ((chksum << 15) | (chksum >> 1)) + *c; |
146 | } |
147 | return chksum; |
148 | } |
149 | |
150 | u32 exfat_calc_chksum32(void *data, int len, u32 chksum, int type) |
151 | { |
152 | int i; |
153 | u8 *c = (u8 *)data; |
154 | |
155 | for (i = 0; i < len; i++, c++) { |
156 | if (unlikely(type == CS_BOOT_SECTOR && |
157 | (i == 106 || i == 107 || i == 112))) |
158 | continue; |
159 | chksum = ((chksum << 31) | (chksum >> 1)) + *c; |
160 | } |
161 | return chksum; |
162 | } |
163 | |
164 | void exfat_update_bh(struct buffer_head *bh, int sync) |
165 | { |
166 | set_buffer_uptodate(bh); |
167 | mark_buffer_dirty(bh); |
168 | |
169 | if (sync) |
170 | sync_dirty_buffer(bh); |
171 | } |
172 | |
173 | int exfat_update_bhs(struct buffer_head **bhs, int nr_bhs, int sync) |
174 | { |
175 | int i, err = 0; |
176 | |
177 | for (i = 0; i < nr_bhs; i++) { |
178 | set_buffer_uptodate(bhs[i]); |
179 | mark_buffer_dirty(bh: bhs[i]); |
180 | if (sync) |
181 | write_dirty_buffer(bh: bhs[i], REQ_SYNC); |
182 | } |
183 | |
184 | for (i = 0; i < nr_bhs && sync; i++) { |
185 | wait_on_buffer(bh: bhs[i]); |
186 | if (!err && !buffer_uptodate(bh: bhs[i])) |
187 | err = -EIO; |
188 | } |
189 | return err; |
190 | } |
191 | |
192 | void exfat_chain_set(struct exfat_chain *ec, unsigned int dir, |
193 | unsigned int size, unsigned char flags) |
194 | { |
195 | ec->dir = dir; |
196 | ec->size = size; |
197 | ec->flags = flags; |
198 | } |
199 | |
200 | void exfat_chain_dup(struct exfat_chain *dup, struct exfat_chain *ec) |
201 | { |
202 | return exfat_chain_set(ec: dup, dir: ec->dir, size: ec->size, flags: ec->flags); |
203 | } |
204 | |