1 /*
2  *  linux/fs/fat/inode.c
3  *
4  *  Written 1992,1993 by Werner Almesberger
5  *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
6  *  Rewritten for the constant inumbers support by Al Viro
7  *
8  *  Fixes:
9  *
10  *  	Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
11  */
12 
13 #include <linux/module.h>
14 #include <linux/msdos_fs.h>
15 #include <linux/nls.h>
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/errno.h>
19 #include <linux/string.h>
20 #include <linux/bitops.h>
21 #include <linux/major.h>
22 #include <linux/blkdev.h>
23 #include <linux/fs.h>
24 #include <linux/stat.h>
25 #include <linux/locks.h>
26 #include <linux/fat_cvf.h>
27 #include <linux/slab.h>
28 #include <linux/smp_lock.h>
29 
30 #include <asm/uaccess.h>
31 #include <asm/unaligned.h>
32 
33 extern struct cvf_format default_cvf;
34 
35 /* #define FAT_PARANOIA 1 */
36 #define DEBUG_LEVEL 0
37 #ifdef FAT_DEBUG
38 #  define PRINTK(x) printk x
39 #else
40 #  define PRINTK(x)
41 #endif
42 #if (DEBUG_LEVEL >= 1)
43 #  define PRINTK1(x) printk x
44 #else
45 #  define PRINTK1(x)
46 #endif
47 
48 /*
49  * New FAT inode stuff. We do the following:
50  *	a) i_ino is constant and has nothing with on-disk location.
51  *	b) FAT manages its own cache of directory entries.
52  *	c) *This* cache is indexed by on-disk location.
53  *	d) inode has an associated directory entry, all right, but
54  *		it may be unhashed.
55  *	e) currently entries are stored within struct inode. That should
56  *		change.
57  *	f) we deal with races in the following way:
58  *		1. readdir() and lookup() do FAT-dir-cache lookup.
59  *		2. rename() unhashes the F-d-c entry and rehashes it in
60  *			a new place.
61  *		3. unlink() and rmdir() unhash F-d-c entry.
62  *		4. fat_write_inode() checks whether the thing is unhashed.
63  *			If it is we silently return. If it isn't we do bread(),
64  *			check if the location is still valid and retry if it
65  *			isn't. Otherwise we do changes.
66  *		5. Spinlock is used to protect hash/unhash/location check/lookup
67  *		6. fat_clear_inode() unhashes the F-d-c entry.
68  *		7. lookup() and readdir() do igrab() if they find a F-d-c entry
69  *			and consider negative result as cache miss.
70  */
71 
72 #define FAT_HASH_BITS	8
73 #define FAT_HASH_SIZE	(1UL << FAT_HASH_BITS)
74 #define FAT_HASH_MASK	(FAT_HASH_SIZE-1)
75 static struct list_head fat_inode_hashtable[FAT_HASH_SIZE];
76 spinlock_t fat_inode_lock = SPIN_LOCK_UNLOCKED;
77 
fat_hash_init(void)78 void fat_hash_init(void)
79 {
80 	int i;
81 	for(i = 0; i < FAT_HASH_SIZE; i++) {
82 		INIT_LIST_HEAD(&fat_inode_hashtable[i]);
83 	}
84 }
85 
fat_hash(struct super_block * sb,loff_t i_pos)86 static inline unsigned long fat_hash(struct super_block *sb, loff_t i_pos)
87 {
88 	unsigned long tmp = (unsigned long)i_pos | (unsigned long) sb;
89 	tmp = tmp + (tmp >> FAT_HASH_BITS) + (tmp >> FAT_HASH_BITS * 2);
90 	return tmp & FAT_HASH_MASK;
91 }
92 
fat_attach(struct inode * inode,loff_t i_pos)93 void fat_attach(struct inode *inode, loff_t i_pos)
94 {
95 	spin_lock(&fat_inode_lock);
96 	MSDOS_I(inode)->i_pos = i_pos;
97 	list_add(&MSDOS_I(inode)->i_fat_hash,
98 		fat_inode_hashtable + fat_hash(inode->i_sb, i_pos));
99 	spin_unlock(&fat_inode_lock);
100 }
101 
fat_detach(struct inode * inode)102 void fat_detach(struct inode *inode)
103 {
104 	spin_lock(&fat_inode_lock);
105 	MSDOS_I(inode)->i_pos = 0;
106 	list_del(&MSDOS_I(inode)->i_fat_hash);
107 	INIT_LIST_HEAD(&MSDOS_I(inode)->i_fat_hash);
108 	spin_unlock(&fat_inode_lock);
109 }
110 
fat_iget(struct super_block * sb,loff_t i_pos)111 struct inode *fat_iget(struct super_block *sb, loff_t i_pos)
112 {
113 	struct list_head *p = fat_inode_hashtable + fat_hash(sb, i_pos);
114 	struct list_head *walk;
115 	struct msdos_inode_info *i;
116 	struct inode *inode = NULL;
117 
118 	spin_lock(&fat_inode_lock);
119 	list_for_each(walk, p) {
120 		i = list_entry(walk, struct msdos_inode_info, i_fat_hash);
121 		if (i->i_fat_inode->i_sb != sb)
122 			continue;
123 		if (i->i_pos != i_pos)
124 			continue;
125 		inode = igrab(i->i_fat_inode);
126 		if (inode)
127 			break;
128 	}
129 	spin_unlock(&fat_inode_lock);
130 	return inode;
131 }
132 
133 static void fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de);
134 
fat_build_inode(struct super_block * sb,struct msdos_dir_entry * de,loff_t i_pos,int * res)135 struct inode *fat_build_inode(struct super_block *sb,
136 			struct msdos_dir_entry *de, loff_t i_pos, int *res)
137 {
138 	struct inode *inode;
139 	*res = 0;
140 	inode = fat_iget(sb, i_pos);
141 	if (inode)
142 		goto out;
143 	inode = new_inode(sb);
144 	*res = -ENOMEM;
145 	if (!inode)
146 		goto out;
147 	*res = 0;
148 	inode->i_ino = iunique(sb, MSDOS_ROOT_INO);
149 	fat_fill_inode(inode, de);
150 	fat_attach(inode, i_pos);
151 	insert_inode_hash(inode);
152 out:
153 	return inode;
154 }
155 
fat_delete_inode(struct inode * inode)156 void fat_delete_inode(struct inode *inode)
157 {
158 	if (!is_bad_inode(inode)) {
159 		lock_kernel();
160 		inode->i_size = 0;
161 		fat_truncate(inode);
162 		unlock_kernel();
163 	}
164 	clear_inode(inode);
165 }
166 
fat_clear_inode(struct inode * inode)167 void fat_clear_inode(struct inode *inode)
168 {
169 	if (is_bad_inode(inode))
170 		return;
171 	lock_kernel();
172 	spin_lock(&fat_inode_lock);
173 	fat_cache_inval_inode(inode);
174 	list_del(&MSDOS_I(inode)->i_fat_hash);
175 	spin_unlock(&fat_inode_lock);
176 	unlock_kernel();
177 }
178 
fat_put_super(struct super_block * sb)179 void fat_put_super(struct super_block *sb)
180 {
181 	if (MSDOS_SB(sb)->cvf_format->cvf_version) {
182 		dec_cvf_format_use_count_by_version(MSDOS_SB(sb)->cvf_format->cvf_version);
183 		MSDOS_SB(sb)->cvf_format->unmount_cvf(sb);
184 	}
185 	if (MSDOS_SB(sb)->fat_bits == 32) {
186 		fat_clusters_flush(sb);
187 	}
188 	fat_cache_inval_dev(sb->s_dev);
189 	set_blocksize (sb->s_dev,BLOCK_SIZE);
190 	if (MSDOS_SB(sb)->nls_disk) {
191 		unload_nls(MSDOS_SB(sb)->nls_disk);
192 		MSDOS_SB(sb)->nls_disk = NULL;
193 		MSDOS_SB(sb)->options.codepage = 0;
194 	}
195 	if (MSDOS_SB(sb)->nls_io) {
196 		unload_nls(MSDOS_SB(sb)->nls_io);
197 		MSDOS_SB(sb)->nls_io = NULL;
198 	}
199 	/*
200 	 * Note: the iocharset option might have been specified
201 	 * without enabling nls_io, so check for it here.
202 	 */
203 	if (MSDOS_SB(sb)->options.iocharset) {
204 		kfree(MSDOS_SB(sb)->options.iocharset);
205 		MSDOS_SB(sb)->options.iocharset = NULL;
206 	}
207 }
208 
209 
parse_options(char * options,int * fat,int * debug,struct fat_mount_options * opts,char * cvf_format,char * cvf_options)210 static int parse_options(char *options,int *fat, int *debug,
211 			 struct fat_mount_options *opts,
212 			 char *cvf_format, char *cvf_options)
213 {
214 	char *this_char,*value,save,*savep;
215 	char *p;
216 	int ret = 1, len;
217 
218 	opts->name_check = 'n';
219 	opts->conversion = 'b';
220 	opts->fs_uid = current->uid;
221 	opts->fs_gid = current->gid;
222 	opts->fs_umask = current->fs->umask;
223 	opts->quiet = opts->sys_immutable = opts->dotsOK = opts->showexec = 0;
224 	opts->codepage = 0;
225 	opts->nocase = 0;
226 	opts->shortname = 0;
227 	opts->utf8 = 0;
228 	opts->iocharset = NULL;
229 	*debug = *fat = 0;
230 
231 	if (!options)
232 		goto out;
233 	save = 0;
234 	savep = NULL;
235 	for (this_char = strtok(options,","); this_char;
236 	     this_char = strtok(NULL,",")) {
237 		if ((value = strchr(this_char,'=')) != NULL) {
238 			save = *value;
239 			savep = value;
240 			*value++ = 0;
241 		}
242 		if (!strcmp(this_char,"check") && value) {
243 			if (value[0] && !value[1] && strchr("rns",*value))
244 				opts->name_check = *value;
245 			else if (!strcmp(value,"relaxed"))
246 				opts->name_check = 'r';
247 			else if (!strcmp(value,"normal"))
248 				opts->name_check = 'n';
249 			else if (!strcmp(value,"strict"))
250 				opts->name_check = 's';
251 			else ret = 0;
252 		}
253 		else if (!strcmp(this_char,"conv") && value) {
254 			if (value[0] && !value[1] && strchr("bta",*value))
255 				opts->conversion = *value;
256 			else if (!strcmp(value,"binary"))
257 				opts->conversion = 'b';
258 			else if (!strcmp(value,"text"))
259 				opts->conversion = 't';
260 			else if (!strcmp(value,"auto"))
261 				opts->conversion = 'a';
262 			else ret = 0;
263 		}
264 		else if (!strcmp(this_char,"dots")) {
265 			opts->dotsOK = 1;
266 		}
267 		else if (!strcmp(this_char,"nocase")) {
268 			opts->nocase = 1;
269 		}
270 		else if (!strcmp(this_char,"nodots")) {
271 			opts->dotsOK = 0;
272 		}
273 		else if (!strcmp(this_char,"showexec")) {
274 			opts->showexec = 1;
275 		}
276 		else if (!strcmp(this_char,"dotsOK") && value) {
277 			if (!strcmp(value,"yes")) opts->dotsOK = 1;
278 			else if (!strcmp(value,"no")) opts->dotsOK = 0;
279 			else ret = 0;
280 		}
281 		else if (!strcmp(this_char,"uid")) {
282 			if (!value || !*value) ret = 0;
283 			else {
284 				opts->fs_uid = simple_strtoul(value,&value,0);
285 				if (*value) ret = 0;
286 			}
287 		}
288 		else if (!strcmp(this_char,"gid")) {
289 			if (!value || !*value) ret= 0;
290 			else {
291 				opts->fs_gid = simple_strtoul(value,&value,0);
292 				if (*value) ret = 0;
293 			}
294 		}
295 		else if (!strcmp(this_char,"umask")) {
296 			if (!value || !*value) ret = 0;
297 			else {
298 				opts->fs_umask = simple_strtoul(value,&value,8);
299 				if (*value) ret = 0;
300 			}
301 		}
302 		else if (!strcmp(this_char,"debug")) {
303 			if (value) ret = 0;
304 			else *debug = 1;
305 		}
306 		else if (!strcmp(this_char,"fat")) {
307 			if (!value || !*value) ret = 0;
308 			else {
309 				*fat = simple_strtoul(value,&value,0);
310 				if (*value || (*fat != 12 && *fat != 16 &&
311 					       *fat != 32))
312 					ret = 0;
313 			}
314 		}
315 		else if (!strcmp(this_char,"quiet")) {
316 			if (value) ret = 0;
317 			else opts->quiet = 1;
318 		}
319 		else if (!strcmp(this_char,"blocksize")) {
320 			printk("FAT: blocksize option is obsolete, "
321 			       "not supported now\n");
322 		}
323 		else if (!strcmp(this_char,"sys_immutable")) {
324 			if (value) ret = 0;
325 			else opts->sys_immutable = 1;
326 		}
327 		else if (!strcmp(this_char,"codepage") && value) {
328 			opts->codepage = simple_strtoul(value,&value,0);
329 			if (*value) ret = 0;
330 			else printk ("MSDOS FS: Using codepage %d\n",
331 					opts->codepage);
332 		}
333 		else if (!strcmp(this_char,"iocharset") && value) {
334 			p = value;
335 			while (*value && *value != ',')
336 				value++;
337 			len = value - p;
338 			if (len) {
339 				char *buffer;
340 
341 				if (opts->iocharset != NULL) {
342 					kfree(opts->iocharset);
343 					opts->iocharset = NULL;
344 				}
345 				buffer = kmalloc(len + 1, GFP_KERNEL);
346 				if (buffer != NULL) {
347 					opts->iocharset = buffer;
348 					memcpy(buffer, p, len);
349 					buffer[len] = 0;
350 					printk("MSDOS FS: IO charset %s\n", buffer);
351 				} else
352 					ret = 0;
353 			}
354 		}
355 		else if (!strcmp(this_char,"cvf_format")) {
356 			if (!value)
357 				return 0;
358 			strncpy(cvf_format,value,20);
359 		}
360 		else if (!strcmp(this_char,"cvf_options")) {
361 			if (!value)
362 				return 0;
363 			strncpy(cvf_options,value,100);
364 		}
365 
366 		if (this_char != options) *(this_char-1) = ',';
367 		if (value) *savep = save;
368 		if (ret == 0)
369 			break;
370 	}
371 out:
372 	return ret;
373 }
374 
fat_read_root(struct inode * inode)375 static void fat_read_root(struct inode *inode)
376 {
377 	struct super_block *sb = inode->i_sb;
378 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
379 	int nr;
380 
381 	INIT_LIST_HEAD(&MSDOS_I(inode)->i_fat_hash);
382 	MSDOS_I(inode)->i_pos = 0;
383 	MSDOS_I(inode)->i_fat_inode = inode;
384 	inode->i_uid = sbi->options.fs_uid;
385 	inode->i_gid = sbi->options.fs_gid;
386 	inode->i_version = ++event;
387 	inode->i_generation = 0;
388 	inode->i_mode = (S_IRWXUGO & ~sbi->options.fs_umask) | S_IFDIR;
389 	inode->i_op = sbi->dir_ops;
390 	inode->i_fop = &fat_dir_operations;
391 	if (sbi->fat_bits == 32) {
392 		MSDOS_I(inode)->i_start = sbi->root_cluster;
393 		if ((nr = MSDOS_I(inode)->i_start) != 0) {
394 			while (nr != -1) {
395 				inode->i_size += 1 << sbi->cluster_bits;
396 				if (!(nr = fat_access(sb, nr, -1))) {
397 					printk("Directory %ld: bad FAT\n",
398 					       inode->i_ino);
399 					break;
400 				}
401 			}
402 		}
403 	} else {
404 		MSDOS_I(inode)->i_start = 0;
405 		inode->i_size = sbi->dir_entries * sizeof(struct msdos_dir_entry);
406 	}
407 	inode->i_blksize = 1 << sbi->cluster_bits;
408 	inode->i_blocks = ((inode->i_size + inode->i_blksize - 1)
409 			   & ~(inode->i_blksize - 1)) >> 9;
410 	MSDOS_I(inode)->i_logstart = 0;
411 	MSDOS_I(inode)->mmu_private = inode->i_size;
412 
413 	MSDOS_I(inode)->i_attrs = 0;
414 	inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
415 	MSDOS_I(inode)->i_ctime_ms = 0;
416 	inode->i_nlink = fat_subdirs(inode)+2;
417 }
418 
419 /*
420  * a FAT file handle with fhtype 3 is
421  *  0/  i_ino - for fast, reliable lookup if still in the cache
422  *  1/  i_generation - to see if i_ino is still valid
423  *          bit 0 == 0 iff directory
424  *  2/  i_pos(8-39) - if ino has changed, but still in cache
425  *  3/  i_pos(4-7)|i_logstart - to semi-verify inode found at i_pos
426  *  4/  i_pos(0-3)|parent->i_logstart - maybe used to hunt for the file on disc
427  *
428  * Hack for NFSv2: Maximum FAT entry number is 28bits and maximum
429  * i_pos is 40bits (blocknr(32) + dir offset(8)), so two 4bits
430  * of i_logstart is used to store the directory entry offset.
431  */
fat_fh_to_dentry(struct super_block * sb,__u32 * fh,int len,int fhtype,int parent)432 struct dentry *fat_fh_to_dentry(struct super_block *sb, __u32 *fh,
433 				int len, int fhtype, int parent)
434 {
435 	struct inode *inode = NULL;
436 	struct list_head *lp;
437 	struct dentry *result;
438 
439 	if (fhtype != 3)
440 		return ERR_PTR(-ESTALE);
441 	if (len < 5)
442 		return ERR_PTR(-ESTALE);
443 	/* We cannot find the parent,
444 	   It better just *be* there */
445 	if (parent)
446 		return ERR_PTR(-ESTALE);
447 
448 	inode = iget(sb, fh[0]);
449 	if (!inode || is_bad_inode(inode) || inode->i_generation != fh[1]) {
450 		if (inode)
451 			iput(inode);
452 		inode = NULL;
453 	}
454 	if (!inode) {
455 		loff_t i_pos;
456 		int i_logstart = fh[3] & 0x0fffffff;
457 
458 		i_pos = (loff_t)fh[2] << 8;
459 		i_pos |= ((fh[3] >> 24) & 0xf0) | (fh[4] >> 28);
460 
461 		/* try 2 - see if i_pos is in F-d-c
462 		 * require i_logstart to be the same
463 		 * Will fail if you truncate and then re-write
464 		 */
465 
466 		inode = fat_iget(sb, i_pos);
467 		if (inode && MSDOS_I(inode)->i_logstart != i_logstart) {
468 			iput(inode);
469 			inode = NULL;
470 		}
471 	}
472 	if (!inode) {
473 		/* For now, do nothing
474 		 * What we could do is:
475 		 * follow the file starting at fh[4], and record
476 		 * the ".." entry, and the name of the fh[2] entry.
477 		 * The follow the ".." file finding the next step up.
478 		 * This way we build a path to the root of
479 		 * the tree. If this works, we lookup the path and so
480 		 * get this inode into the cache.
481 		 * Finally try the fat_iget lookup again
482 		 * If that fails, then weare totally out of luck
483 		 * But all that is for another day
484 		 */
485 	}
486 	if (!inode)
487 		return ERR_PTR(-ESTALE);
488 
489 
490 	/* now to find a dentry.
491 	 * If possible, get a well-connected one
492 	 *
493 	 * Given the way that we found the inode, it *MUST* be
494 	 * well-connected, but it is easiest to just copy the
495 	 * code.
496 	 */
497 	spin_lock(&dcache_lock);
498 	for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) {
499 		result = list_entry(lp,struct dentry, d_alias);
500 		if (! (result->d_flags & DCACHE_NFSD_DISCONNECTED)) {
501 			dget_locked(result);
502 			result->d_vfs_flags |= DCACHE_REFERENCED;
503 			spin_unlock(&dcache_lock);
504 			iput(inode);
505 			return result;
506 		}
507 	}
508 	spin_unlock(&dcache_lock);
509 	result = d_alloc_root(inode);
510 	if (result == NULL) {
511 		iput(inode);
512 		return ERR_PTR(-ENOMEM);
513 	}
514 	result->d_op = sb->s_root->d_op;
515 	result->d_flags |= DCACHE_NFSD_DISCONNECTED;
516 	return result;
517 }
518 
fat_dentry_to_fh(struct dentry * de,__u32 * fh,int * lenp,int needparent)519 int fat_dentry_to_fh(struct dentry *de, __u32 *fh, int *lenp, int needparent)
520 {
521 	int len = *lenp;
522 	struct inode *inode =  de->d_inode;
523 	u32 ipos_h, ipos_m, ipos_l;
524 
525 	if (len < 5)
526 		return 255; /* no room */
527 
528 	ipos_h = MSDOS_I(inode)->i_pos >> 8;
529 	ipos_m = (MSDOS_I(inode)->i_pos & 0xf0) << 24;
530 	ipos_l = (MSDOS_I(inode)->i_pos & 0x0f) << 28;
531 	*lenp = 5;
532 	fh[0] = inode->i_ino;
533 	fh[1] = inode->i_generation;
534 	fh[2] = ipos_h;
535 	fh[3] = ipos_m | MSDOS_I(inode)->i_logstart;
536 	fh[4] = ipos_l | MSDOS_I(de->d_parent->d_inode)->i_logstart;
537 	return 3;
538 }
539 
540 static struct super_operations fat_sops = {
541 	write_inode:	fat_write_inode,
542 	delete_inode:	fat_delete_inode,
543 	put_super:	fat_put_super,
544 	statfs:		fat_statfs,
545 	clear_inode:	fat_clear_inode,
546 
547 	read_inode:	make_bad_inode,
548 	fh_to_dentry:	fat_fh_to_dentry,
549 	dentry_to_fh:	fat_dentry_to_fh,
550 };
551 
552 /*
553  * Read the super block of an MS-DOS FS.
554  *
555  * Note that this may be called from vfat_read_super
556  * with some fields already initialized.
557  */
558 struct super_block *
fat_read_super(struct super_block * sb,void * data,int silent,struct inode_operations * fs_dir_inode_ops)559 fat_read_super(struct super_block *sb, void *data, int silent,
560 		struct inode_operations *fs_dir_inode_ops)
561 {
562 	struct inode *root_inode;
563 	struct buffer_head *bh;
564 	struct fat_boot_sector *b;
565 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
566 	char *p;
567 	int logical_sector_size, hard_blksize, fat_clusters = 0;
568 	unsigned int total_sectors, rootdir_sectors;
569 	int fat32, debug, error, fat, cp;
570 	struct fat_mount_options opts;
571 	char buf[50];
572 	int i;
573 	char cvf_format[21];
574 	char cvf_options[101];
575 
576 	cvf_format[0] = '\0';
577 	cvf_options[0] = '\0';
578 	sbi->cvf_format = NULL;
579 	sbi->private_data = NULL;
580 
581 	sbi->dir_ops = fs_dir_inode_ops;
582 
583 	sb->s_maxbytes = MAX_NON_LFS;
584 	sb->s_op = &fat_sops;
585 
586 	hard_blksize = get_hardsect_size(sb->s_dev);
587 	if (!hard_blksize)
588 		hard_blksize = 512;
589 
590 	opts.isvfat = sbi->options.isvfat;
591 	if (!parse_options((char *) data, &fat, &debug, &opts,
592 			   cvf_format, cvf_options))
593 		goto out_fail;
594 	/* N.B. we should parse directly into the sb structure */
595 	memcpy(&(sbi->options), &opts, sizeof(struct fat_mount_options));
596 
597 	fat_cache_init();
598 
599 	sb->s_blocksize = hard_blksize;
600 	set_blocksize(sb->s_dev, hard_blksize);
601 	bh = sb_bread(sb, 0);
602 	if (bh == NULL) {
603 		printk("FAT: unable to read boot sector\n");
604 		goto out_fail;
605 	}
606 
607 /*
608  * The DOS3 partition size limit is *not* 32M as many people think.
609  * Instead, it is 64K sectors (with the usual sector size being
610  * 512 bytes, leading to a 32M limit).
611  *
612  * DOS 3 partition managers got around this problem by faking a
613  * larger sector size, ie treating multiple physical sectors as
614  * a single logical sector.
615  *
616  * We can accommodate this scheme by adjusting our cluster size,
617  * fat_start, and data_start by an appropriate value.
618  *
619  * (by Drew Eckhardt)
620  */
621 
622 
623 	b = (struct fat_boot_sector *) bh->b_data;
624 	logical_sector_size =
625 		CF_LE_W(get_unaligned((unsigned short *) &b->sector_size));
626 	if (!logical_sector_size
627 	    || (logical_sector_size & (logical_sector_size - 1))) {
628 		printk("FAT: bogus logical sector size %d\n",
629 		       logical_sector_size);
630 		brelse(bh);
631 		goto out_invalid;
632 	}
633 
634 	sbi->cluster_size = b->cluster_size;
635 	if (!sbi->cluster_size
636 	    || (sbi->cluster_size & (sbi->cluster_size - 1))) {
637 		printk("FAT: bogus cluster size %d\n", sbi->cluster_size);
638 		brelse(bh);
639 		goto out_invalid;
640 	}
641 
642 	if (logical_sector_size < hard_blksize) {
643 		printk("FAT: logical sector size too small for device"
644 		       " (logical sector size = %d)\n", logical_sector_size);
645 		brelse(bh);
646 		goto out_invalid;
647 	}
648 
649 	sbi->cluster_bits = ffs(logical_sector_size * sbi->cluster_size) - 1;
650 	sbi->fats = b->fats;
651 	sbi->fat_start = CF_LE_W(b->reserved);
652 	sbi->prev_free = 0;
653 	if (!b->fat_length && b->fat32_length) {
654 		struct fat_boot_fsinfo *fsinfo;
655 		struct buffer_head *fsinfo_bh;
656 		int fsinfo_block, fsinfo_offset;
657 
658 		/* Must be FAT32 */
659 		fat32 = 1;
660 		sbi->fat_length = CF_LE_L(b->fat32_length);
661 		sbi->root_cluster = CF_LE_L(b->root_cluster);
662 
663 		sbi->fsinfo_sector = CF_LE_W(b->info_sector);
664 		/* MC - if info_sector is 0, don't multiply by 0 */
665 		if (sbi->fsinfo_sector == 0)
666 			sbi->fsinfo_sector = 1;
667 
668 		fsinfo_block =
669 			(sbi->fsinfo_sector * logical_sector_size) / hard_blksize;
670 		fsinfo_offset =
671 			(sbi->fsinfo_sector * logical_sector_size) % hard_blksize;
672 		fsinfo_bh = bh;
673 		if (fsinfo_block != 0) {
674 			fsinfo_bh = sb_bread(sb, fsinfo_block);
675 			if (fsinfo_bh == NULL) {
676 				printk("FAT: bread failed, FSINFO block"
677 				       " (blocknr = %d)\n", fsinfo_block);
678 				brelse(bh);
679 				goto out_invalid;
680 			}
681 		}
682 		fsinfo = (struct fat_boot_fsinfo *)&fsinfo_bh->b_data[fsinfo_offset];
683 		if (!IS_FSINFO(fsinfo)) {
684 			printk("FAT: Did not find valid FSINFO signature.\n"
685 			       "Found signature1 0x%x signature2 0x%x sector=%ld.\n",
686 			       CF_LE_L(fsinfo->signature1),
687 			       CF_LE_L(fsinfo->signature2),
688 			       sbi->fsinfo_sector);
689 		} else {
690 			sbi->free_clusters = CF_LE_L(fsinfo->free_clusters);
691 			sbi->prev_free = CF_LE_L(fsinfo->next_cluster);
692 		}
693 
694 		if (fsinfo_block != 0)
695 			brelse(fsinfo_bh);
696 	} else {
697 		fat32 = 0;
698 		sbi->fat_length = CF_LE_W(b->fat_length);
699 		sbi->root_cluster = 0;
700 		sbi->free_clusters = -1; /* Don't know yet */
701 	}
702 
703 	sbi->dir_per_block = logical_sector_size / sizeof(struct msdos_dir_entry);
704 	sbi->dir_per_block_bits = ffs(sbi->dir_per_block) - 1;
705 
706 	sbi->dir_start = sbi->fat_start + sbi->fats * sbi->fat_length;
707 	sbi->dir_entries =
708 		CF_LE_W(get_unaligned((unsigned short *)&b->dir_entries));
709 	rootdir_sectors = sbi->dir_entries
710 		* sizeof(struct msdos_dir_entry) / logical_sector_size;
711 	sbi->data_start = sbi->dir_start + rootdir_sectors;
712 	total_sectors = CF_LE_W(get_unaligned((unsigned short *)&b->sectors));
713 	if (total_sectors == 0)
714 		total_sectors = CF_LE_L(b->total_sect);
715 	sbi->clusters = (total_sectors - sbi->data_start) / sbi->cluster_size;
716 
717 	error = 0;
718 	if (!error) {
719 		sbi->fat_bits = fat32 ? 32 :
720 			(fat ? fat :
721 			 (sbi->clusters > MSDOS_FAT12 ? 16 : 12));
722 		fat_clusters =
723 			sbi->fat_length * logical_sector_size * 8 / sbi->fat_bits;
724 		error = !sbi->fats || (sbi->dir_entries & (sbi->dir_per_block - 1))
725 			|| sbi->clusters + 2 > fat_clusters + MSDOS_MAX_EXTRA
726 			|| logical_sector_size < 512
727 			|| PAGE_CACHE_SIZE < logical_sector_size
728 			|| !b->secs_track || !b->heads;
729 	}
730 	brelse(bh);
731 
732 	if (error)
733 		goto out_invalid;
734 
735 	sb->s_blocksize = logical_sector_size;
736 	sb->s_blocksize_bits = ffs(logical_sector_size) - 1;
737 	set_blocksize(sb->s_dev, sb->s_blocksize);
738 	sbi->cvf_format = &default_cvf;
739 	if (!strcmp(cvf_format, "none"))
740 		i = -1;
741 	else
742 		i = detect_cvf(sb,cvf_format);
743 	if (i >= 0)
744 		error = cvf_formats[i]->mount_cvf(sb, cvf_options);
745 	if (error || debug) {
746 		/* The MSDOS_CAN_BMAP is obsolete, but left just to remember */
747 		printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
748 		       "uid=%d,gid=%d,umask=%03o%s]\n",
749 		       sbi->fat_bits,opts.name_check,
750 		       opts.conversion,opts.fs_uid,opts.fs_gid,opts.fs_umask,
751 		       MSDOS_CAN_BMAP(sbi) ? ",bmap" : "");
752 		printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%ld,ds=%ld,de=%d,data=%ld,"
753 		       "se=%u,ts=%u,ls=%d,rc=%ld,fc=%u]\n",
754 		       b->media, sbi->cluster_size, sbi->fats,
755 		       sbi->fat_start, sbi->fat_length, sbi->dir_start,
756 		       sbi->dir_entries, sbi->data_start,
757 		       CF_LE_W(get_unaligned((unsigned short *)&b->sectors)),
758 		       CF_LE_L(b->total_sect), logical_sector_size,
759 		       sbi->root_cluster, sbi->free_clusters);
760 		printk ("hard sector size = %d\n", hard_blksize);
761 	}
762 	if (i < 0)
763 		if (sbi->clusters + 2 > fat_clusters)
764 			sbi->clusters = fat_clusters - 2;
765 	if (error)
766 		goto out_invalid;
767 
768 	sb->s_magic = MSDOS_SUPER_MAGIC;
769 	/* set up enough so that it can read an inode */
770 	init_MUTEX(&sbi->fat_lock);
771 
772 	cp = opts.codepage ? opts.codepage : 437;
773 	sprintf(buf, "cp%d", cp);
774 	sbi->nls_disk = load_nls(buf);
775 	if (! sbi->nls_disk) {
776 		/* Fail only if explicit charset specified */
777 		if (opts.codepage != 0)
778 			goto out_fail;
779 		sbi->options.codepage = 0; /* already 0?? */
780 		sbi->nls_disk = load_nls_default();
781 	}
782 
783 	sbi->nls_io = NULL;
784 	if (sbi->options.isvfat && !opts.utf8) {
785 		p = opts.iocharset ? opts.iocharset : CONFIG_NLS_DEFAULT;
786 		sbi->nls_io = load_nls(p);
787 		if (! sbi->nls_io)
788 			/* Fail only if explicit charset specified */
789 			if (opts.iocharset)
790 				goto out_unload_nls;
791 	}
792 	if (! sbi->nls_io)
793 		sbi->nls_io = load_nls_default();
794 
795 	root_inode = new_inode(sb);
796 	if (!root_inode)
797 		goto out_unload_nls;
798 	root_inode->i_ino = MSDOS_ROOT_INO;
799 	fat_read_root(root_inode);
800 	insert_inode_hash(root_inode);
801 	sb->s_root = d_alloc_root(root_inode);
802 	if (!sb->s_root)
803 		goto out_no_root;
804 	if(i >= 0) {
805 		sbi->cvf_format = cvf_formats[i];
806 		++cvf_format_use_count[i];
807 	}
808 	return sb;
809 
810 out_no_root:
811 	printk("FAT: get root inode failed\n");
812 	iput(root_inode);
813 	unload_nls(sbi->nls_io);
814 out_unload_nls:
815 	unload_nls(sbi->nls_disk);
816 	goto out_fail;
817 out_invalid:
818 	if (!silent) {
819 		printk("VFS: Can't find a valid FAT filesystem on dev %s.\n",
820 			kdevname(sb->s_dev));
821 	}
822 out_fail:
823 	if (opts.iocharset) {
824 		printk("FAT: freeing iocharset=%s\n", opts.iocharset);
825 		kfree(opts.iocharset);
826 	}
827 	if(sbi->private_data)
828 		kfree(sbi->private_data);
829 	sbi->private_data = NULL;
830 
831 	return NULL;
832 }
833 
fat_statfs(struct super_block * sb,struct statfs * buf)834 int fat_statfs(struct super_block *sb,struct statfs *buf)
835 {
836 	int free,nr;
837 
838 	if (MSDOS_SB(sb)->cvf_format &&
839 	    MSDOS_SB(sb)->cvf_format->cvf_statfs)
840 		return MSDOS_SB(sb)->cvf_format->cvf_statfs(sb,buf,
841 						sizeof(struct statfs));
842 
843 	lock_fat(sb);
844 	if (MSDOS_SB(sb)->free_clusters != -1)
845 		free = MSDOS_SB(sb)->free_clusters;
846 	else {
847 		free = 0;
848 		for (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++)
849 			if (!fat_access(sb,nr,-1)) free++;
850 		MSDOS_SB(sb)->free_clusters = free;
851 	}
852 	unlock_fat(sb);
853 	buf->f_type = sb->s_magic;
854 	buf->f_bsize = 1 << MSDOS_SB(sb)->cluster_bits;
855 	buf->f_blocks = MSDOS_SB(sb)->clusters;
856 	buf->f_bfree = free;
857 	buf->f_bavail = free;
858 	buf->f_namelen = MSDOS_SB(sb)->options.isvfat ? 260 : 12;
859 	return 0;
860 }
861 
is_exec(char * extension)862 static int is_exec(char *extension)
863 {
864 	char *exe_extensions = "EXECOMBAT", *walk;
865 
866 	for (walk = exe_extensions; *walk; walk += 3)
867 		if (!strncmp(extension, walk, 3))
868 			return 1;
869 	return 0;
870 }
871 
fat_writepage(struct page * page)872 static int fat_writepage(struct page *page)
873 {
874 	return block_write_full_page(page,fat_get_block);
875 }
fat_readpage(struct file * file,struct page * page)876 static int fat_readpage(struct file *file, struct page *page)
877 {
878 	return block_read_full_page(page,fat_get_block);
879 }
fat_prepare_write(struct file * file,struct page * page,unsigned from,unsigned to)880 static int fat_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
881 {
882 	return cont_prepare_write(page,from,to,fat_get_block,
883 		&MSDOS_I(page->mapping->host)->mmu_private);
884 }
_fat_bmap(struct address_space * mapping,long block)885 static int _fat_bmap(struct address_space *mapping, long block)
886 {
887 	return generic_block_bmap(mapping,block,fat_get_block);
888 }
889 static struct address_space_operations fat_aops = {
890 	readpage: fat_readpage,
891 	writepage: fat_writepage,
892 	sync_page: block_sync_page,
893 	prepare_write: fat_prepare_write,
894 	commit_write: generic_commit_write,
895 	bmap: _fat_bmap
896 };
897 
898 /* doesn't deal with root inode */
fat_fill_inode(struct inode * inode,struct msdos_dir_entry * de)899 static void fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
900 {
901 	struct super_block *sb = inode->i_sb;
902 	struct msdos_sb_info *sbi = MSDOS_SB(sb);
903 	int nr;
904 
905 	INIT_LIST_HEAD(&MSDOS_I(inode)->i_fat_hash);
906 	MSDOS_I(inode)->i_pos = 0;
907 	MSDOS_I(inode)->i_fat_inode = inode;
908 	inode->i_uid = sbi->options.fs_uid;
909 	inode->i_gid = sbi->options.fs_gid;
910 	inode->i_version = ++event;
911 	inode->i_generation = CURRENT_TIME;
912 
913 	if ((de->attr & ATTR_DIR) && !IS_FREE(de->name)) {
914 		inode->i_generation &= ~1;
915 		inode->i_mode = MSDOS_MKMODE(de->attr,S_IRWXUGO &
916 		    ~sbi->options.fs_umask) | S_IFDIR;
917 		inode->i_op = sbi->dir_ops;
918 		inode->i_fop = &fat_dir_operations;
919 
920 		MSDOS_I(inode)->i_start = CF_LE_W(de->start);
921 		if (sbi->fat_bits == 32)
922 			MSDOS_I(inode)->i_start |= (CF_LE_W(de->starthi) << 16);
923 
924 		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
925 		inode->i_nlink = fat_subdirs(inode);
926 		    /* includes .., compensating for "self" */
927 #ifdef DEBUG
928 		if (!inode->i_nlink) {
929 			printk("directory %d: i_nlink == 0\n",inode->i_ino);
930 			inode->i_nlink = 1;
931 		}
932 #endif
933 		if ((nr = MSDOS_I(inode)->i_start) != 0)
934 			while (nr != -1) {
935 				inode->i_size += 1 << sbi->cluster_bits;
936 				if (!(nr = fat_access(sb, nr, -1))) {
937 					printk("Directory %ld: bad FAT\n",
938 					    inode->i_ino);
939 					break;
940 				}
941 			}
942 		MSDOS_I(inode)->mmu_private = inode->i_size;
943 	} else { /* not a directory */
944 		inode->i_generation |= 1;
945 		inode->i_mode = MSDOS_MKMODE(de->attr,
946 		    ((sbi->options.showexec &&
947 		       !is_exec(de->ext))
948 		    	? S_IRUGO|S_IWUGO : S_IRWXUGO)
949 		    & ~sbi->options.fs_umask) | S_IFREG;
950 		MSDOS_I(inode)->i_start = CF_LE_W(de->start);
951 		if (sbi->fat_bits == 32)
952 			MSDOS_I(inode)->i_start |= (CF_LE_W(de->starthi) << 16);
953 
954 		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
955 		inode->i_size = CF_LE_L(de->size);
956 	        inode->i_op = &fat_file_inode_operations;
957 	        inode->i_fop = &fat_file_operations;
958 		inode->i_mapping->a_ops = &fat_aops;
959 		MSDOS_I(inode)->mmu_private = inode->i_size;
960 	}
961 	if(de->attr & ATTR_SYS)
962 		if (sbi->options.sys_immutable)
963 			inode->i_flags |= S_IMMUTABLE;
964 	MSDOS_I(inode)->i_attrs = de->attr & ATTR_UNUSED;
965 	/* this is as close to the truth as we can get ... */
966 	inode->i_blksize = 1 << sbi->cluster_bits;
967 	inode->i_blocks = ((inode->i_size + inode->i_blksize - 1)
968 			   & ~(inode->i_blksize - 1)) >> 9;
969 	inode->i_mtime = inode->i_atime =
970 		date_dos2unix(CF_LE_W(de->time),CF_LE_W(de->date));
971 	inode->i_ctime =
972 		MSDOS_SB(sb)->options.isvfat
973 		? date_dos2unix(CF_LE_W(de->ctime),CF_LE_W(de->cdate))
974 		: inode->i_mtime;
975 	MSDOS_I(inode)->i_ctime_ms = de->ctime_ms;
976 }
977 
fat_write_inode(struct inode * inode,int wait)978 void fat_write_inode(struct inode *inode, int wait)
979 {
980 	struct super_block *sb = inode->i_sb;
981 	struct buffer_head *bh;
982 	struct msdos_dir_entry *raw_entry;
983 	loff_t i_pos;
984 
985 retry:
986 	i_pos = MSDOS_I(inode)->i_pos;
987 	if (inode->i_ino == MSDOS_ROOT_INO || !i_pos) {
988 		return;
989 	}
990 	lock_kernel();
991 	if (!(bh = fat_bread(sb, i_pos >> MSDOS_SB(sb)->dir_per_block_bits))) {
992 		printk("dev = %s, i_pos = %llu\n", kdevname(inode->i_dev), i_pos);
993 		fat_fs_panic(sb, "msdos_write_inode: unable to read i-node block");
994 		unlock_kernel();
995 		return;
996 	}
997 	spin_lock(&fat_inode_lock);
998 	if (i_pos != MSDOS_I(inode)->i_pos) {
999 		spin_unlock(&fat_inode_lock);
1000 		fat_brelse(sb, bh);
1001 		unlock_kernel();
1002 		goto retry;
1003 	}
1004 
1005 	raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
1006 	    [i_pos & (MSDOS_SB(sb)->dir_per_block - 1)];
1007 	if (S_ISDIR(inode->i_mode)) {
1008 		raw_entry->attr = ATTR_DIR;
1009 		raw_entry->size = 0;
1010 	}
1011 	else {
1012 		raw_entry->attr = ATTR_NONE;
1013 		raw_entry->size = CT_LE_L(inode->i_size);
1014 	}
1015 	raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
1016 	    MSDOS_I(inode)->i_attrs;
1017 	raw_entry->start = CT_LE_W(MSDOS_I(inode)->i_logstart);
1018 	raw_entry->starthi = CT_LE_W(MSDOS_I(inode)->i_logstart >> 16);
1019 	fat_date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
1020 	raw_entry->time = CT_LE_W(raw_entry->time);
1021 	raw_entry->date = CT_LE_W(raw_entry->date);
1022 	if (MSDOS_SB(sb)->options.isvfat) {
1023 		fat_date_unix2dos(inode->i_ctime,&raw_entry->ctime,&raw_entry->cdate);
1024 		raw_entry->ctime_ms = MSDOS_I(inode)->i_ctime_ms;
1025 		raw_entry->ctime = CT_LE_W(raw_entry->ctime);
1026 		raw_entry->cdate = CT_LE_W(raw_entry->cdate);
1027 	}
1028 	spin_unlock(&fat_inode_lock);
1029 	fat_mark_buffer_dirty(sb, bh);
1030 	fat_brelse(sb, bh);
1031 	unlock_kernel();
1032 }
1033 
1034 
fat_notify_change(struct dentry * dentry,struct iattr * attr)1035 int fat_notify_change(struct dentry * dentry, struct iattr * attr)
1036 {
1037 	struct super_block *sb = dentry->d_sb;
1038 	struct inode *inode = dentry->d_inode;
1039 	int error;
1040 
1041 	/* FAT cannot truncate to a longer file */
1042 	if (attr->ia_valid & ATTR_SIZE) {
1043 		if (attr->ia_size > inode->i_size)
1044 			return -EPERM;
1045 	}
1046 
1047 	error = inode_change_ok(inode, attr);
1048 	if (error)
1049 		return MSDOS_SB(sb)->options.quiet ? 0 : error;
1050 
1051 	if (((attr->ia_valid & ATTR_UID) &&
1052 	     (attr->ia_uid != MSDOS_SB(sb)->options.fs_uid)) ||
1053 	    ((attr->ia_valid & ATTR_GID) &&
1054 	     (attr->ia_gid != MSDOS_SB(sb)->options.fs_gid)) ||
1055 	    ((attr->ia_valid & ATTR_MODE) &&
1056 	     (attr->ia_mode & ~MSDOS_VALID_MODE)))
1057 		error = -EPERM;
1058 
1059 	if (error)
1060 		return MSDOS_SB(sb)->options.quiet ? 0 : error;
1061 
1062 	error = inode_setattr(inode, attr);
1063 	if (error)
1064 		return error;
1065 
1066 	if (S_ISDIR(inode->i_mode))
1067 		inode->i_mode |= S_IXUGO;
1068 
1069 	inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
1070 	    & ~MSDOS_SB(sb)->options.fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) &
1071 	    ~MSDOS_SB(sb)->options.fs_umask;
1072 	return 0;
1073 }
1074 MODULE_LICENSE("GPL");
1075