]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/fat/misc.c | |
3 | * | |
4 | * Written 1992,1993 by Werner Almesberger | |
5 | * 22/11/2000 - Fixed fat_date_unix2dos for dates earlier than 01/01/1980 | |
6 | * and date_dos2unix for date==0 by Igor Zhbanov(bsg@uniyar.ac.ru) | |
7 | */ | |
8 | ||
9e975dae | 9 | #include "fat.h" |
6bb885ec | 10 | #include <linux/iversion.h> |
1da177e4 LT |
11 | |
12 | /* | |
85c78591 DK |
13 | * fat_fs_error reports a file system problem that might indicate fa data |
14 | * corruption/inconsistency. Depending on 'errors' mount option the | |
15 | * panic() is called, or error message is printed FAT and nothing is done, | |
16 | * or filesystem is remounted read-only (default behavior). | |
17 | * In case the file system is remounted read-only, it can be made writable | |
18 | * again by remounting it. | |
1da177e4 | 19 | */ |
2c8a5ffb | 20 | void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...) |
1da177e4 | 21 | { |
2c8a5ffb | 22 | struct fat_mount_options *opts = &MSDOS_SB(sb)->options; |
1da177e4 | 23 | va_list args; |
2c8a5ffb | 24 | struct va_format vaf; |
1da177e4 | 25 | |
aaa04b48 | 26 | if (report) { |
aaa04b48 | 27 | va_start(args, fmt); |
2c8a5ffb OR |
28 | vaf.fmt = fmt; |
29 | vaf.va = &args; | |
e68e96d2 | 30 | fat_msg(sb, KERN_ERR, "error, %pV", &vaf); |
aaa04b48 | 31 | va_end(args); |
aaa04b48 | 32 | } |
1da177e4 | 33 | |
85c78591 | 34 | if (opts->errors == FAT_ERRORS_PANIC) |
2c8a5ffb | 35 | panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id); |
bc98a42c | 36 | else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) { |
1751e8a6 | 37 | sb->s_flags |= SB_RDONLY; |
e68e96d2 | 38 | fat_msg(sb, KERN_ERR, "Filesystem has been set read-only"); |
1da177e4 LT |
39 | } |
40 | } | |
aaa04b48 | 41 | EXPORT_SYMBOL_GPL(__fat_fs_error); |
1da177e4 | 42 | |
81ac21d3 OR |
43 | /** |
44 | * fat_msg() - print preformated FAT specific messages. Every thing what is | |
45 | * not fat_fs_error() should be fat_msg(). | |
46 | */ | |
47 | void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...) | |
48 | { | |
49 | struct va_format vaf; | |
50 | va_list args; | |
51 | ||
52 | va_start(args, fmt); | |
53 | vaf.fmt = fmt; | |
54 | vaf.va = &args; | |
55 | printk("%sFAT-fs (%s): %pV\n", level, sb->s_id, &vaf); | |
56 | va_end(args); | |
57 | } | |
58 | ||
1da177e4 LT |
59 | /* Flushes the number of free clusters on FAT32 */ |
60 | /* XXX: Need to write one per FSINFO block. Currently only writes 1 */ | |
ed248b29 | 61 | int fat_clusters_flush(struct super_block *sb) |
1da177e4 LT |
62 | { |
63 | struct msdos_sb_info *sbi = MSDOS_SB(sb); | |
64 | struct buffer_head *bh; | |
65 | struct fat_boot_fsinfo *fsinfo; | |
66 | ||
306790f7 | 67 | if (!is_fat32(sbi)) |
ed248b29 | 68 | return 0; |
1da177e4 LT |
69 | |
70 | bh = sb_bread(sb, sbi->fsinfo_sector); | |
71 | if (bh == NULL) { | |
869f58c0 | 72 | fat_msg(sb, KERN_ERR, "bread failed in fat_clusters_flush"); |
ed248b29 | 73 | return -EIO; |
1da177e4 LT |
74 | } |
75 | ||
76 | fsinfo = (struct fat_boot_fsinfo *)bh->b_data; | |
77 | /* Sanity check */ | |
78 | if (!IS_FSINFO(fsinfo)) { | |
869f58c0 OR |
79 | fat_msg(sb, KERN_ERR, "Invalid FSINFO signature: " |
80 | "0x%08x, 0x%08x (sector = %lu)", | |
1da177e4 LT |
81 | le32_to_cpu(fsinfo->signature1), |
82 | le32_to_cpu(fsinfo->signature2), | |
83 | sbi->fsinfo_sector); | |
84 | } else { | |
85 | if (sbi->free_clusters != -1) | |
86 | fsinfo->free_clusters = cpu_to_le32(sbi->free_clusters); | |
87 | if (sbi->prev_free != -1) | |
88 | fsinfo->next_cluster = cpu_to_le32(sbi->prev_free); | |
89 | mark_buffer_dirty(bh); | |
1da177e4 LT |
90 | } |
91 | brelse(bh); | |
ed248b29 OH |
92 | |
93 | return 0; | |
1da177e4 LT |
94 | } |
95 | ||
96 | /* | |
97 | * fat_chain_add() adds a new cluster to the chain of clusters represented | |
98 | * by inode. | |
99 | */ | |
100 | int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster) | |
101 | { | |
102 | struct super_block *sb = inode->i_sb; | |
103 | struct msdos_sb_info *sbi = MSDOS_SB(sb); | |
104 | int ret, new_fclus, last; | |
105 | ||
106 | /* | |
107 | * We must locate the last cluster of the file to add this new | |
108 | * one (new_dclus) to the end of the link list (the FAT). | |
109 | */ | |
110 | last = new_fclus = 0; | |
111 | if (MSDOS_I(inode)->i_start) { | |
112 | int fclus, dclus; | |
113 | ||
114 | ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus); | |
115 | if (ret < 0) | |
116 | return ret; | |
117 | new_fclus = fclus + 1; | |
118 | last = dclus; | |
119 | } | |
120 | ||
121 | /* add new one to the last of the cluster chain */ | |
122 | if (last) { | |
123 | struct fat_entry fatent; | |
124 | ||
125 | fatent_init(&fatent); | |
126 | ret = fat_ent_read(inode, &fatent, last); | |
127 | if (ret >= 0) { | |
128 | int wait = inode_needs_sync(inode); | |
129 | ret = fat_ent_write(inode, &fatent, new_dclus, wait); | |
130 | fatent_brelse(&fatent); | |
131 | } | |
132 | if (ret < 0) | |
133 | return ret; | |
c39540c6 R |
134 | /* |
135 | * FIXME:Although we can add this cache, fat_cache_add() is | |
136 | * assuming to be called after linear search with fat_cache_id. | |
137 | */ | |
1da177e4 LT |
138 | // fat_cache_add(inode, new_fclus, new_dclus); |
139 | } else { | |
140 | MSDOS_I(inode)->i_start = new_dclus; | |
141 | MSDOS_I(inode)->i_logstart = new_dclus; | |
142 | /* | |
2f3d675b JK |
143 | * Since generic_write_sync() synchronizes regular files later, |
144 | * we sync here only directories. | |
1da177e4 LT |
145 | */ |
146 | if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode)) { | |
147 | ret = fat_sync_inode(inode); | |
148 | if (ret) | |
149 | return ret; | |
150 | } else | |
151 | mark_inode_dirty(inode); | |
152 | } | |
153 | if (new_fclus != (inode->i_blocks >> (sbi->cluster_bits - 9))) { | |
85c78591 | 154 | fat_fs_error(sb, "clusters badly computed (%d != %llu)", |
c3302931 OH |
155 | new_fclus, |
156 | (llu)(inode->i_blocks >> (sbi->cluster_bits - 9))); | |
1da177e4 LT |
157 | fat_cache_inval_inode(inode); |
158 | } | |
159 | inode->i_blocks += nr_cluster << (sbi->cluster_bits - 9); | |
160 | ||
161 | return 0; | |
162 | } | |
163 | ||
7decd1cb OH |
164 | /* |
165 | * The epoch of FAT timestamp is 1980. | |
166 | * : bits : value | |
167 | * date: 0 - 4: day (1 - 31) | |
168 | * date: 5 - 8: month (1 - 12) | |
169 | * date: 9 - 15: year (0 - 127) from 1980 | |
170 | * time: 0 - 4: sec (0 - 29) 2sec counts | |
171 | * time: 5 - 10: min (0 - 59) | |
172 | * time: 11 - 15: hour (0 - 23) | |
173 | */ | |
174 | #define SECS_PER_MIN 60 | |
175 | #define SECS_PER_HOUR (60 * 60) | |
176 | #define SECS_PER_DAY (SECS_PER_HOUR * 24) | |
7decd1cb OH |
177 | /* days between 1.1.70 and 1.1.80 (2 leap days) */ |
178 | #define DAYS_DELTA (365 * 10 + 2) | |
179 | /* 120 (2100 - 1980) isn't leap year */ | |
180 | #define YEAR_2100 120 | |
181 | #define IS_LEAP_YEAR(y) (!((y) & 3) && (y) != YEAR_2100) | |
182 | ||
1da177e4 | 183 | /* Linear day numbers of the respective 1sts in non-leap years. */ |
f423420c | 184 | static long days_in_year[] = { |
7decd1cb OH |
185 | /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */ |
186 | 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, | |
1da177e4 LT |
187 | }; |
188 | ||
d9f4d942 FS |
189 | static inline int fat_tz_offset(struct msdos_sb_info *sbi) |
190 | { | |
191 | return (sbi->options.tz_set ? | |
192 | -sbi->options.time_offset : | |
193 | sys_tz.tz_minuteswest) * SECS_PER_MIN; | |
194 | } | |
195 | ||
7decd1cb | 196 | /* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */ |
f423420c | 197 | void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec64 *ts, |
7decd1cb | 198 | __le16 __time, __le16 __date, u8 time_cs) |
1da177e4 | 199 | { |
7decd1cb | 200 | u16 time = le16_to_cpu(__time), date = le16_to_cpu(__date); |
f423420c AB |
201 | time64_t second; |
202 | long day, leap_day, month, year; | |
1da177e4 | 203 | |
7decd1cb OH |
204 | year = date >> 9; |
205 | month = max(1, (date >> 5) & 0xf); | |
206 | day = max(1, date & 0x1f) - 1; | |
207 | ||
208 | leap_day = (year + 3) / 4; | |
209 | if (year > YEAR_2100) /* 2100 isn't leap year */ | |
210 | leap_day--; | |
211 | if (IS_LEAP_YEAR(year) && month > 2) | |
212 | leap_day++; | |
213 | ||
214 | second = (time & 0x1f) << 1; | |
215 | second += ((time >> 5) & 0x3f) * SECS_PER_MIN; | |
216 | second += (time >> 11) * SECS_PER_HOUR; | |
f423420c | 217 | second += (time64_t)(year * 365 + leap_day |
7decd1cb OH |
218 | + days_in_year[month] + day |
219 | + DAYS_DELTA) * SECS_PER_DAY; | |
220 | ||
d9f4d942 | 221 | second += fat_tz_offset(sbi); |
7decd1cb OH |
222 | |
223 | if (time_cs) { | |
224 | ts->tv_sec = second + (time_cs / 100); | |
225 | ts->tv_nsec = (time_cs % 100) * 10000000; | |
226 | } else { | |
227 | ts->tv_sec = second; | |
228 | ts->tv_nsec = 0; | |
229 | } | |
1da177e4 LT |
230 | } |
231 | ||
7decd1cb | 232 | /* Convert linear UNIX date to a FAT time/date pair. */ |
f423420c | 233 | void fat_time_unix2fat(struct msdos_sb_info *sbi, struct timespec64 *ts, |
7decd1cb | 234 | __le16 *time, __le16 *date, u8 *time_cs) |
1da177e4 | 235 | { |
1d81a181 | 236 | struct tm tm; |
d9f4d942 | 237 | time64_to_tm(ts->tv_sec, -fat_tz_offset(sbi), &tm); |
1da177e4 | 238 | |
1d81a181 Z |
239 | /* FAT can only support year between 1980 to 2107 */ |
240 | if (tm.tm_year < 1980 - 1900) { | |
7decd1cb OH |
241 | *time = 0; |
242 | *date = cpu_to_le16((0 << 9) | (1 << 5) | 1); | |
243 | if (time_cs) | |
244 | *time_cs = 0; | |
245 | return; | |
246 | } | |
1d81a181 | 247 | if (tm.tm_year > 2107 - 1900) { |
7decd1cb OH |
248 | *time = cpu_to_le16((23 << 11) | (59 << 5) | 29); |
249 | *date = cpu_to_le16((127 << 9) | (12 << 5) | 31); | |
250 | if (time_cs) | |
251 | *time_cs = 199; | |
252 | return; | |
253 | } | |
7decd1cb | 254 | |
1d81a181 Z |
255 | /* from 1900 -> from 1980 */ |
256 | tm.tm_year -= 80; | |
257 | /* 0~11 -> 1~12 */ | |
258 | tm.tm_mon++; | |
259 | /* 0~59 -> 0~29(2sec counts) */ | |
260 | tm.tm_sec >>= 1; | |
1da177e4 | 261 | |
1d81a181 Z |
262 | *time = cpu_to_le16(tm.tm_hour << 11 | tm.tm_min << 5 | tm.tm_sec); |
263 | *date = cpu_to_le16(tm.tm_year << 9 | tm.tm_mon << 5 | tm.tm_mday); | |
7decd1cb OH |
264 | if (time_cs) |
265 | *time_cs = (ts->tv_sec & 1) * 100 + ts->tv_nsec / 10000000; | |
266 | } | |
267 | EXPORT_SYMBOL_GPL(fat_time_unix2fat); | |
1da177e4 | 268 | |
6bb885ec FS |
269 | static inline struct timespec64 fat_timespec64_trunc_2secs(struct timespec64 ts) |
270 | { | |
271 | return (struct timespec64){ ts.tv_sec & ~1ULL, 0 }; | |
272 | } | |
273 | /* | |
274 | * truncate the various times with appropriate granularity: | |
275 | * root inode: | |
276 | * all times always 0 | |
277 | * all other inodes: | |
278 | * mtime - 2 seconds | |
279 | * ctime | |
280 | * msdos - 2 seconds | |
281 | * vfat - 10 milliseconds | |
282 | * atime - 24 hours (00:00:00 in local timezone) | |
283 | */ | |
284 | int fat_truncate_time(struct inode *inode, struct timespec64 *now, int flags) | |
285 | { | |
286 | struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); | |
287 | struct timespec64 ts; | |
288 | ||
289 | if (inode->i_ino == MSDOS_ROOT_INO) | |
290 | return 0; | |
291 | ||
292 | if (now == NULL) { | |
293 | now = &ts; | |
294 | ts = current_time(inode); | |
295 | } | |
296 | ||
297 | if (flags & S_ATIME) { | |
298 | /* to localtime */ | |
299 | time64_t seconds = now->tv_sec - fat_tz_offset(sbi); | |
300 | s32 remainder; | |
301 | ||
302 | div_s64_rem(seconds, SECS_PER_DAY, &remainder); | |
303 | /* to day boundary, and back to unix time */ | |
304 | seconds = seconds + fat_tz_offset(sbi) - remainder; | |
305 | ||
306 | inode->i_atime = (struct timespec64){ seconds, 0 }; | |
307 | } | |
308 | if (flags & S_CTIME) { | |
309 | if (sbi->options.isvfat) | |
310 | inode->i_ctime = timespec64_trunc(*now, 10000000); | |
311 | else | |
312 | inode->i_ctime = fat_timespec64_trunc_2secs(*now); | |
313 | } | |
314 | if (flags & S_MTIME) | |
315 | inode->i_mtime = fat_timespec64_trunc_2secs(*now); | |
316 | ||
317 | return 0; | |
318 | } | |
319 | EXPORT_SYMBOL_GPL(fat_truncate_time); | |
320 | ||
321 | int fat_update_time(struct inode *inode, struct timespec64 *now, int flags) | |
322 | { | |
323 | int iflags = I_DIRTY_TIME; | |
324 | bool dirty = false; | |
325 | ||
326 | if (inode->i_ino == MSDOS_ROOT_INO) | |
327 | return 0; | |
328 | ||
329 | fat_truncate_time(inode, now, flags); | |
330 | if (flags & S_VERSION) | |
331 | dirty = inode_maybe_inc_iversion(inode, false); | |
332 | if ((flags & (S_ATIME | S_CTIME | S_MTIME)) && | |
333 | !(inode->i_sb->s_flags & SB_LAZYTIME)) | |
334 | dirty = true; | |
335 | ||
336 | if (dirty) | |
337 | iflags |= I_DIRTY_SYNC; | |
338 | __mark_inode_dirty(inode, iflags); | |
339 | return 0; | |
340 | } | |
341 | EXPORT_SYMBOL_GPL(fat_update_time); | |
342 | ||
1da177e4 LT |
343 | int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs) |
344 | { | |
5b00226d | 345 | int i, err = 0; |
1da177e4 | 346 | |
9cb569d6 | 347 | for (i = 0; i < nr_bhs; i++) |
2a222ca9 | 348 | write_dirty_buffer(bhs[i], 0); |
9cb569d6 | 349 | |
1da177e4 LT |
350 | for (i = 0; i < nr_bhs; i++) { |
351 | wait_on_buffer(bhs[i]); | |
0edd55fa | 352 | if (!err && !buffer_uptodate(bhs[i])) |
1da177e4 LT |
353 | err = -EIO; |
354 | } | |
355 | return err; | |
356 | } |