]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/fat/misc.c
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)
10 #include <linux/iversion.h>
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.
20 void __fat_fs_error(struct super_block
*sb
, int report
, const char *fmt
, ...)
22 struct fat_mount_options
*opts
= &MSDOS_SB(sb
)->options
;
30 fat_msg(sb
, KERN_ERR
, "error, %pV", &vaf
);
34 if (opts
->errors
== FAT_ERRORS_PANIC
)
35 panic("FAT-fs (%s): fs panic from previous error\n", sb
->s_id
);
36 else if (opts
->errors
== FAT_ERRORS_RO
&& !sb_rdonly(sb
)) {
37 sb
->s_flags
|= SB_RDONLY
;
38 fat_msg(sb
, KERN_ERR
, "Filesystem has been set read-only");
41 EXPORT_SYMBOL_GPL(__fat_fs_error
);
44 * fat_msg() - print preformated FAT specific messages. Every thing what is
45 * not fat_fs_error() should be fat_msg().
47 void fat_msg(struct super_block
*sb
, const char *level
, const char *fmt
, ...)
55 printk("%sFAT-fs (%s): %pV\n", level
, sb
->s_id
, &vaf
);
59 /* Flushes the number of free clusters on FAT32 */
60 /* XXX: Need to write one per FSINFO block. Currently only writes 1 */
61 int fat_clusters_flush(struct super_block
*sb
)
63 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
64 struct buffer_head
*bh
;
65 struct fat_boot_fsinfo
*fsinfo
;
70 bh
= sb_bread(sb
, sbi
->fsinfo_sector
);
72 fat_msg(sb
, KERN_ERR
, "bread failed in fat_clusters_flush");
76 fsinfo
= (struct fat_boot_fsinfo
*)bh
->b_data
;
78 if (!IS_FSINFO(fsinfo
)) {
79 fat_msg(sb
, KERN_ERR
, "Invalid FSINFO signature: "
80 "0x%08x, 0x%08x (sector = %lu)",
81 le32_to_cpu(fsinfo
->signature1
),
82 le32_to_cpu(fsinfo
->signature2
),
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
);
97 * fat_chain_add() adds a new cluster to the chain of clusters represented
100 int fat_chain_add(struct inode
*inode
, int new_dclus
, int nr_cluster
)
102 struct super_block
*sb
= inode
->i_sb
;
103 struct msdos_sb_info
*sbi
= MSDOS_SB(sb
);
104 int ret
, new_fclus
, last
;
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).
110 last
= new_fclus
= 0;
111 if (MSDOS_I(inode
)->i_start
) {
114 ret
= fat_get_cluster(inode
, FAT_ENT_EOF
, &fclus
, &dclus
);
117 new_fclus
= fclus
+ 1;
121 /* add new one to the last of the cluster chain */
123 struct fat_entry fatent
;
125 fatent_init(&fatent
);
126 ret
= fat_ent_read(inode
, &fatent
, last
);
128 int wait
= inode_needs_sync(inode
);
129 ret
= fat_ent_write(inode
, &fatent
, new_dclus
, wait
);
130 fatent_brelse(&fatent
);
135 * FIXME:Although we can add this cache, fat_cache_add() is
136 * assuming to be called after linear search with fat_cache_id.
138 // fat_cache_add(inode, new_fclus, new_dclus);
140 MSDOS_I(inode
)->i_start
= new_dclus
;
141 MSDOS_I(inode
)->i_logstart
= new_dclus
;
143 * Since generic_write_sync() synchronizes regular files later,
144 * we sync here only directories.
146 if (S_ISDIR(inode
->i_mode
) && IS_DIRSYNC(inode
)) {
147 ret
= fat_sync_inode(inode
);
151 mark_inode_dirty(inode
);
153 if (new_fclus
!= (inode
->i_blocks
>> (sbi
->cluster_bits
- 9))) {
154 fat_fs_error(sb
, "clusters badly computed (%d != %llu)",
156 (llu
)(inode
->i_blocks
>> (sbi
->cluster_bits
- 9)));
157 fat_cache_inval_inode(inode
);
159 inode
->i_blocks
+= nr_cluster
<< (sbi
->cluster_bits
- 9);
165 * The epoch of FAT timestamp is 1980.
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)
174 #define SECS_PER_MIN 60
175 #define SECS_PER_HOUR (60 * 60)
176 #define SECS_PER_DAY (SECS_PER_HOUR * 24)
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)
183 /* Linear day numbers of the respective 1sts in non-leap years. */
184 static long days_in_year
[] = {
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,
189 static inline int fat_tz_offset(struct msdos_sb_info
*sbi
)
191 return (sbi
->options
.tz_set
?
192 -sbi
->options
.time_offset
:
193 sys_tz
.tz_minuteswest
) * SECS_PER_MIN
;
196 /* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */
197 void fat_time_fat2unix(struct msdos_sb_info
*sbi
, struct timespec64
*ts
,
198 __le16 __time
, __le16 __date
, u8 time_cs
)
200 u16 time
= le16_to_cpu(__time
), date
= le16_to_cpu(__date
);
202 long day
, leap_day
, month
, year
;
205 month
= max(1, (date
>> 5) & 0xf);
206 day
= max(1, date
& 0x1f) - 1;
208 leap_day
= (year
+ 3) / 4;
209 if (year
> YEAR_2100
) /* 2100 isn't leap year */
211 if (IS_LEAP_YEAR(year
) && month
> 2)
214 second
= (time
& 0x1f) << 1;
215 second
+= ((time
>> 5) & 0x3f) * SECS_PER_MIN
;
216 second
+= (time
>> 11) * SECS_PER_HOUR
;
217 second
+= (time64_t
)(year
* 365 + leap_day
218 + days_in_year
[month
] + day
219 + DAYS_DELTA
) * SECS_PER_DAY
;
221 second
+= fat_tz_offset(sbi
);
224 ts
->tv_sec
= second
+ (time_cs
/ 100);
225 ts
->tv_nsec
= (time_cs
% 100) * 10000000;
232 /* Convert linear UNIX date to a FAT time/date pair. */
233 void fat_time_unix2fat(struct msdos_sb_info
*sbi
, struct timespec64
*ts
,
234 __le16
*time
, __le16
*date
, u8
*time_cs
)
237 time64_to_tm(ts
->tv_sec
, -fat_tz_offset(sbi
), &tm
);
239 /* FAT can only support year between 1980 to 2107 */
240 if (tm
.tm_year
< 1980 - 1900) {
242 *date
= cpu_to_le16((0 << 9) | (1 << 5) | 1);
247 if (tm
.tm_year
> 2107 - 1900) {
248 *time
= cpu_to_le16((23 << 11) | (59 << 5) | 29);
249 *date
= cpu_to_le16((127 << 9) | (12 << 5) | 31);
255 /* from 1900 -> from 1980 */
259 /* 0~59 -> 0~29(2sec counts) */
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
);
265 *time_cs
= (ts
->tv_sec
& 1) * 100 + ts
->tv_nsec
/ 10000000;
267 EXPORT_SYMBOL_GPL(fat_time_unix2fat
);
269 static inline struct timespec64
fat_timespec64_trunc_2secs(struct timespec64 ts
)
271 return (struct timespec64
){ ts
.tv_sec
& ~1ULL, 0 };
274 * truncate the various times with appropriate granularity:
281 * vfat - 10 milliseconds
282 * atime - 24 hours (00:00:00 in local timezone)
284 int fat_truncate_time(struct inode
*inode
, struct timespec64
*now
, int flags
)
286 struct msdos_sb_info
*sbi
= MSDOS_SB(inode
->i_sb
);
287 struct timespec64 ts
;
289 if (inode
->i_ino
== MSDOS_ROOT_INO
)
294 ts
= current_time(inode
);
297 if (flags
& S_ATIME
) {
299 time64_t seconds
= now
->tv_sec
- fat_tz_offset(sbi
);
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
;
306 inode
->i_atime
= (struct timespec64
){ seconds
, 0 };
308 if (flags
& S_CTIME
) {
309 if (sbi
->options
.isvfat
)
310 inode
->i_ctime
= timespec64_trunc(*now
, 10000000);
312 inode
->i_ctime
= fat_timespec64_trunc_2secs(*now
);
315 inode
->i_mtime
= fat_timespec64_trunc_2secs(*now
);
319 EXPORT_SYMBOL_GPL(fat_truncate_time
);
321 int fat_update_time(struct inode
*inode
, struct timespec64
*now
, int flags
)
323 int iflags
= I_DIRTY_TIME
;
326 if (inode
->i_ino
== MSDOS_ROOT_INO
)
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
))
337 iflags
|= I_DIRTY_SYNC
;
338 __mark_inode_dirty(inode
, iflags
);
341 EXPORT_SYMBOL_GPL(fat_update_time
);
343 int fat_sync_bhs(struct buffer_head
**bhs
, int nr_bhs
)
347 for (i
= 0; i
< nr_bhs
; i
++)
348 write_dirty_buffer(bhs
[i
], 0);
350 for (i
= 0; i
< nr_bhs
; i
++) {
351 wait_on_buffer(bhs
[i
]);
352 if (!err
&& !buffer_uptodate(bhs
[i
]))