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 
9 #include "fat.h"
10 
11 /*
12  * fat_fs_error reports a file system problem that might indicate fa data
13  * corruption/inconsistency. Depending on 'errors' mount option the
14  * panic() is called, or error message is printed FAT and nothing is done,
15  * or filesystem is remounted read-only (default behavior).
16  * In case the file system is remounted read-only, it can be made writable
17  * again by remounting it.
18  */
__fat_fs_error(struct super_block * sb,int report,const char * fmt,...)19 void __fat_fs_error(struct super_block *sb, int report, const char *fmt, ...)
20 {
21 	struct fat_mount_options *opts = &MSDOS_SB(sb)->options;
22 	va_list args;
23 	struct va_format vaf;
24 
25 	if (report) {
26 		va_start(args, fmt);
27 		vaf.fmt = fmt;
28 		vaf.va = &args;
29 		fat_msg(sb, KERN_ERR, "error, %pV", &vaf);
30 		va_end(args);
31 	}
32 
33 	if (opts->errors == FAT_ERRORS_PANIC)
34 		panic("FAT-fs (%s): fs panic from previous error\n", sb->s_id);
35 	else if (opts->errors == FAT_ERRORS_RO && !sb_rdonly(sb)) {
36 		sb->s_flags |= SB_RDONLY;
37 		fat_msg(sb, KERN_ERR, "Filesystem has been set read-only");
38 	}
39 }
40 EXPORT_SYMBOL_GPL(__fat_fs_error);
41 
42 /**
43  * fat_msg() - print preformated FAT specific messages. Every thing what is
44  * not fat_fs_error() should be fat_msg().
45  */
fat_msg(struct super_block * sb,const char * level,const char * fmt,...)46 void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...)
47 {
48 	struct va_format vaf;
49 	va_list args;
50 
51 	va_start(args, fmt);
52 	vaf.fmt = fmt;
53 	vaf.va = &args;
54 	printk("%sFAT-fs (%s): %pV\n", level, sb->s_id, &vaf);
55 	va_end(args);
56 }
57 
58 /* Flushes the number of free clusters on FAT32 */
59 /* XXX: Need to write one per FSINFO block.  Currently only writes 1 */
fat_clusters_flush(struct super_block * sb)60 int fat_clusters_flush(struct super_block *sb)
61 {
62 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
63 	struct buffer_head *bh;
64 	struct fat_boot_fsinfo *fsinfo;
65 
66 	if (sbi->fat_bits != 32)
67 		return 0;
68 
69 	bh = sb_bread(sb, sbi->fsinfo_sector);
70 	if (bh == NULL) {
71 		fat_msg(sb, KERN_ERR, "bread failed in fat_clusters_flush");
72 		return -EIO;
73 	}
74 
75 	fsinfo = (struct fat_boot_fsinfo *)bh->b_data;
76 	/* Sanity check */
77 	if (!IS_FSINFO(fsinfo)) {
78 		fat_msg(sb, KERN_ERR, "Invalid FSINFO signature: "
79 		       "0x%08x, 0x%08x (sector = %lu)",
80 		       le32_to_cpu(fsinfo->signature1),
81 		       le32_to_cpu(fsinfo->signature2),
82 		       sbi->fsinfo_sector);
83 	} else {
84 		if (sbi->free_clusters != -1)
85 			fsinfo->free_clusters = cpu_to_le32(sbi->free_clusters);
86 		if (sbi->prev_free != -1)
87 			fsinfo->next_cluster = cpu_to_le32(sbi->prev_free);
88 		mark_buffer_dirty(bh);
89 	}
90 	brelse(bh);
91 
92 	return 0;
93 }
94 
95 /*
96  * fat_chain_add() adds a new cluster to the chain of clusters represented
97  * by inode.
98  */
fat_chain_add(struct inode * inode,int new_dclus,int nr_cluster)99 int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster)
100 {
101 	struct super_block *sb = inode->i_sb;
102 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
103 	int ret, new_fclus, last;
104 
105 	/*
106 	 * We must locate the last cluster of the file to add this new
107 	 * one (new_dclus) to the end of the link list (the FAT).
108 	 */
109 	last = new_fclus = 0;
110 	if (MSDOS_I(inode)->i_start) {
111 		int fclus, dclus;
112 
113 		ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus);
114 		if (ret < 0)
115 			return ret;
116 		new_fclus = fclus + 1;
117 		last = dclus;
118 	}
119 
120 	/* add new one to the last of the cluster chain */
121 	if (last) {
122 		struct fat_entry fatent;
123 
124 		fatent_init(&fatent);
125 		ret = fat_ent_read(inode, &fatent, last);
126 		if (ret >= 0) {
127 			int wait = inode_needs_sync(inode);
128 			ret = fat_ent_write(inode, &fatent, new_dclus, wait);
129 			fatent_brelse(&fatent);
130 		}
131 		if (ret < 0)
132 			return ret;
133 		/*
134 		 * FIXME:Although we can add this cache, fat_cache_add() is
135 		 * assuming to be called after linear search with fat_cache_id.
136 		 */
137 //		fat_cache_add(inode, new_fclus, new_dclus);
138 	} else {
139 		MSDOS_I(inode)->i_start = new_dclus;
140 		MSDOS_I(inode)->i_logstart = new_dclus;
141 		/*
142 		 * Since generic_write_sync() synchronizes regular files later,
143 		 * we sync here only directories.
144 		 */
145 		if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode)) {
146 			ret = fat_sync_inode(inode);
147 			if (ret)
148 				return ret;
149 		} else
150 			mark_inode_dirty(inode);
151 	}
152 	if (new_fclus != (inode->i_blocks >> (sbi->cluster_bits - 9))) {
153 		fat_fs_error(sb, "clusters badly computed (%d != %llu)",
154 			     new_fclus,
155 			     (llu)(inode->i_blocks >> (sbi->cluster_bits - 9)));
156 		fat_cache_inval_inode(inode);
157 	}
158 	inode->i_blocks += nr_cluster << (sbi->cluster_bits - 9);
159 
160 	return 0;
161 }
162 
163 /*
164  * The epoch of FAT timestamp is 1980.
165  *     :  bits :     value
166  * date:  0 -  4: day	(1 -  31)
167  * date:  5 -  8: month	(1 -  12)
168  * date:  9 - 15: year	(0 - 127) from 1980
169  * time:  0 -  4: sec	(0 -  29) 2sec counts
170  * time:  5 - 10: min	(0 -  59)
171  * time: 11 - 15: hour	(0 -  23)
172  */
173 #define SECS_PER_MIN	60
174 #define SECS_PER_HOUR	(60 * 60)
175 #define SECS_PER_DAY	(SECS_PER_HOUR * 24)
176 /* days between 1.1.70 and 1.1.80 (2 leap days) */
177 #define DAYS_DELTA	(365 * 10 + 2)
178 /* 120 (2100 - 1980) isn't leap year */
179 #define YEAR_2100	120
180 #define IS_LEAP_YEAR(y)	(!((y) & 3) && (y) != YEAR_2100)
181 
182 /* Linear day numbers of the respective 1sts in non-leap years. */
183 static long days_in_year[] = {
184 	/* Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct  Nov  Dec */
185 	0,   0,  31,  59,  90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0,
186 };
187 
188 /* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */
fat_time_fat2unix(struct msdos_sb_info * sbi,struct timespec64 * ts,__le16 __time,__le16 __date,u8 time_cs)189 void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec64 *ts,
190 		       __le16 __time, __le16 __date, u8 time_cs)
191 {
192 	u16 time = le16_to_cpu(__time), date = le16_to_cpu(__date);
193 	time64_t second;
194 	long day, leap_day, month, year;
195 
196 	year  = date >> 9;
197 	month = max(1, (date >> 5) & 0xf);
198 	day   = max(1, date & 0x1f) - 1;
199 
200 	leap_day = (year + 3) / 4;
201 	if (year > YEAR_2100)		/* 2100 isn't leap year */
202 		leap_day--;
203 	if (IS_LEAP_YEAR(year) && month > 2)
204 		leap_day++;
205 
206 	second =  (time & 0x1f) << 1;
207 	second += ((time >> 5) & 0x3f) * SECS_PER_MIN;
208 	second += (time >> 11) * SECS_PER_HOUR;
209 	second += (time64_t)(year * 365 + leap_day
210 		   + days_in_year[month] + day
211 		   + DAYS_DELTA) * SECS_PER_DAY;
212 
213 	if (!sbi->options.tz_set)
214 		second += sys_tz.tz_minuteswest * SECS_PER_MIN;
215 	else
216 		second -= sbi->options.time_offset * SECS_PER_MIN;
217 
218 	if (time_cs) {
219 		ts->tv_sec = second + (time_cs / 100);
220 		ts->tv_nsec = (time_cs % 100) * 10000000;
221 	} else {
222 		ts->tv_sec = second;
223 		ts->tv_nsec = 0;
224 	}
225 }
226 
227 /* Convert linear UNIX date to a FAT time/date pair. */
fat_time_unix2fat(struct msdos_sb_info * sbi,struct timespec64 * ts,__le16 * time,__le16 * date,u8 * time_cs)228 void fat_time_unix2fat(struct msdos_sb_info *sbi, struct timespec64 *ts,
229 		       __le16 *time, __le16 *date, u8 *time_cs)
230 {
231 	struct tm tm;
232 	time64_to_tm(ts->tv_sec,
233 		   (sbi->options.tz_set ? sbi->options.time_offset :
234 		   -sys_tz.tz_minuteswest) * SECS_PER_MIN, &tm);
235 
236 	/*  FAT can only support year between 1980 to 2107 */
237 	if (tm.tm_year < 1980 - 1900) {
238 		*time = 0;
239 		*date = cpu_to_le16((0 << 9) | (1 << 5) | 1);
240 		if (time_cs)
241 			*time_cs = 0;
242 		return;
243 	}
244 	if (tm.tm_year > 2107 - 1900) {
245 		*time = cpu_to_le16((23 << 11) | (59 << 5) | 29);
246 		*date = cpu_to_le16((127 << 9) | (12 << 5) | 31);
247 		if (time_cs)
248 			*time_cs = 199;
249 		return;
250 	}
251 
252 	/* from 1900 -> from 1980 */
253 	tm.tm_year -= 80;
254 	/* 0~11 -> 1~12 */
255 	tm.tm_mon++;
256 	/* 0~59 -> 0~29(2sec counts) */
257 	tm.tm_sec >>= 1;
258 
259 	*time = cpu_to_le16(tm.tm_hour << 11 | tm.tm_min << 5 | tm.tm_sec);
260 	*date = cpu_to_le16(tm.tm_year << 9 | tm.tm_mon << 5 | tm.tm_mday);
261 	if (time_cs)
262 		*time_cs = (ts->tv_sec & 1) * 100 + ts->tv_nsec / 10000000;
263 }
264 EXPORT_SYMBOL_GPL(fat_time_unix2fat);
265 
fat_sync_bhs(struct buffer_head ** bhs,int nr_bhs)266 int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs)
267 {
268 	int i, err = 0;
269 
270 	for (i = 0; i < nr_bhs; i++)
271 		write_dirty_buffer(bhs[i], 0);
272 
273 	for (i = 0; i < nr_bhs; i++) {
274 		wait_on_buffer(bhs[i]);
275 		if (!err && !buffer_uptodate(bhs[i]))
276 			err = -EIO;
277 	}
278 	return err;
279 }
280