Commit 343800e7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/hirofumi/fatfs-2.6 

* git://git.kernel.org/pub/scm/linux/kernel/git/hirofumi/fatfs-2.6:
  fat: Fix statfs->f_namelen
  fat: Replace all printk with fat_msg()
  fat: Add fat_msg() function for preformated FAT messages
  fat: Convert fat_fs_error to use %pV
  fat: Fix possible null deref in fat_cache_add()
  fat: use new setup() for ->dir_ops too
parents f4e0bcf0 f68e542f

fs/fat/cache.c

+7 −0
Original line number Diff line number Diff line
@@ -151,6 +151,13 @@ static void fat_cache_add(struct inode *inode, struct fat_cache_id *new) 
			spin_unlock(&MSDOS_I(inode)->cache_lru_lock);



			tmp = fat_cache_alloc(inode);

			if (!tmp) {

				spin_lock(&MSDOS_I(inode)->cache_lru_lock);

				MSDOS_I(inode)->nr_caches--;

				spin_unlock(&MSDOS_I(inode)->cache_lru_lock);

				return;

			}



			spin_lock(&MSDOS_I(inode)->cache_lru_lock);

			cache = fat_cache_merge(inode, new);

			if (cache != NULL) {

fs/fat/dir.c

+17 −15
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ next: 


	*bh = sb_bread(sb, phys);

	if (*bh == NULL) {

		printk(KERN_ERR "FAT: Directory bread(block %llu) failed\n",

		fat_msg(sb, KERN_ERR, "Directory bread(block %llu) failed",

		       (llu)phys);

		/* skip this block */

		*pos = (iblock + 1) << sb->s_blocksize_bits;
@@ -136,9 +136,10 @@ static inline int fat_get_entry(struct inode *dir, loff_t *pos, 
 * but ignore that right now.

 * Ahem... Stack smashing in ring 0 isn't fun. Fixed.

 */

static int uni16_to_x8(unsigned char *ascii, const wchar_t *uni, int len,

		       int uni_xlate, struct nls_table *nls)

static int uni16_to_x8(struct super_block *sb, unsigned char *ascii,

		       const wchar_t *uni, int len, struct nls_table *nls)

{

	int uni_xlate = MSDOS_SB(sb)->options.unicode_xlate;

	const wchar_t *ip;

	wchar_t ec;

	unsigned char *op;
@@ -166,7 +167,7 @@ static int uni16_to_x8(unsigned char *ascii, const wchar_t *uni, int len, 
	}



	if (unlikely(*ip)) {

		printk(KERN_WARNING "FAT: filename was truncated while "

		fat_msg(sb, KERN_WARNING, "filename was truncated while "

			"converting.");

	}
@@ -174,15 +175,15 @@ static int uni16_to_x8(unsigned char *ascii, const wchar_t *uni, int len, 
	return (op - ascii);

}



static inline int fat_uni_to_x8(struct msdos_sb_info *sbi, const wchar_t *uni,

static inline int fat_uni_to_x8(struct super_block *sb, const wchar_t *uni,

				unsigned char *buf, int size)

{

	struct msdos_sb_info *sbi = MSDOS_SB(sb);

	if (sbi->options.utf8)

		return utf16s_to_utf8s(uni, FAT_MAX_UNI_CHARS,

				UTF16_HOST_ENDIAN, buf, size);

	else

		return uni16_to_x8(buf, uni, size, sbi->options.unicode_xlate,

				   sbi->nls_io);

		return uni16_to_x8(sb, buf, uni, size, sbi->nls_io);

}



static inline int
@@ -419,7 +420,7 @@ parse_record: 


		/* Compare shortname */

		bufuname[last_u] = 0x0000;

		len = fat_uni_to_x8(sbi, bufuname, bufname, sizeof(bufname));

		len = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));

		if (fat_name_match(sbi, name, name_len, bufname, len))

			goto found;
@@ -428,7 +429,7 @@ parse_record: 
			int size = PATH_MAX - FAT_MAX_UNI_SIZE;



			/* Compare longname */

			len = fat_uni_to_x8(sbi, unicode, longname, size);

			len = fat_uni_to_x8(sb, unicode, longname, size);

			if (fat_name_match(sbi, name, name_len, longname, len))

				goto found;

		}
@@ -545,7 +546,7 @@ parse_record: 
		if (nr_slots) {

			void *longname = unicode + FAT_MAX_UNI_CHARS;

			int size = PATH_MAX - FAT_MAX_UNI_SIZE;

			int len = fat_uni_to_x8(sbi, unicode, longname, size);

			int len = fat_uni_to_x8(sb, unicode, longname, size);



			fill_name = longname;

			fill_len = len;
@@ -621,7 +622,7 @@ parse_record: 


	if (isvfat) {

		bufuname[j] = 0x0000;

		i = fat_uni_to_x8(sbi, bufuname, bufname, sizeof(bufname));

		i = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));

	}

	if (nr_slots) {

		/* hack for fat_ioctl_filldir() */
@@ -979,6 +980,7 @@ static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots) 


int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)

{

	struct super_block *sb = dir->i_sb;

	struct msdos_dir_entry *de;

	struct buffer_head *bh;

	int err = 0, nr_slots;
@@ -1013,8 +1015,8 @@ int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo) 
		 */

		err = __fat_remove_entries(dir, sinfo->slot_off, nr_slots);

		if (err) {

			printk(KERN_WARNING

			       "FAT: Couldn't remove the long name slots\n");

			fat_msg(sb, KERN_WARNING,

			       "Couldn't remove the long name slots");

		}

	}
@@ -1265,7 +1267,7 @@ int fat_add_entries(struct inode *dir, void *slots, int nr_slots, 
		if (sbi->fat_bits != 32)

			goto error;

	} else if (MSDOS_I(dir)->i_start == 0) {

		printk(KERN_ERR "FAT: Corrupted directory (i_pos %lld)\n",

		fat_msg(sb, KERN_ERR, "Corrupted directory (i_pos %lld)",

		       MSDOS_I(dir)->i_pos);

		err = -EIO;

		goto error;

fs/fat/fat.h

+8 −7
Original line number Diff line number Diff line
@@ -319,19 +319,20 @@ extern struct inode *fat_build_inode(struct super_block *sb, 
			struct msdos_dir_entry *de, loff_t i_pos);

extern int fat_sync_inode(struct inode *inode);

extern int fat_fill_super(struct super_block *sb, void *data, int silent,

			const struct inode_operations *fs_dir_inode_ops,

			  int isvfat, void (*setup)(struct super_block *));



extern int fat_flush_inodes(struct super_block *sb, struct inode *i1,

		            struct inode *i2);

/* fat/misc.c */

extern void

__fat_fs_error(struct super_block *s, int report, const char *fmt, ...)

__fat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

	__attribute__ ((format (printf, 3, 4))) __cold;

#define fat_fs_error(sb, fmt, args...)		\

	__fat_fs_error(sb, 1, fmt , ## args)

#define fat_fs_error_ratelimit(sb, fmt, args...) \

	__fat_fs_error(sb, __ratelimit(&MSDOS_SB(sb)->ratelimit), fmt , ## args)

void fat_msg(struct super_block *sb, const char *level, const char *fmt, ...)

	__attribute__ ((format (printf, 3, 4))) __cold;

#define fat_fs_error(s, fmt, args...)		\

	__fat_fs_error(s, 1, fmt , ## args)

#define fat_fs_error_ratelimit(s, fmt, args...) \

	__fat_fs_error(s, __ratelimit(&MSDOS_SB(s)->ratelimit), fmt , ## args)

extern int fat_clusters_flush(struct super_block *sb);

extern int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster);

extern void fat_time_fat2unix(struct msdos_sb_info *sbi, struct timespec *ts,

fs/fat/fatent.c

+2 −2
Original line number Diff line number Diff line
@@ -95,7 +95,7 @@ static int fat12_ent_bread(struct super_block *sb, struct fat_entry *fatent, 
err_brelse:

	brelse(bhs[0]);

err:

	printk(KERN_ERR "FAT: FAT read failed (blocknr %llu)\n", (llu)blocknr);

	fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)", (llu)blocknr);

	return -EIO;

}
@@ -108,7 +108,7 @@ static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent, 
	fatent->fat_inode = MSDOS_SB(sb)->fat_inode;

	fatent->bhs[0] = sb_bread(sb, blocknr);

	if (!fatent->bhs[0]) {

		printk(KERN_ERR "FAT: FAT read failed (blocknr %llu)\n",

		fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)",

		       (llu)blocknr);

		return -EIO;

	}

fs/fat/inode.c

+36 −38
Original line number Diff line number Diff line
@@ -581,7 +581,8 @@ static int fat_statfs(struct dentry *dentry, struct kstatfs *buf) 
	buf->f_bavail = sbi->free_clusters;

	buf->f_fsid.val[0] = (u32)id;

	buf->f_fsid.val[1] = (u32)(id >> 32);

	buf->f_namelen = sbi->options.isvfat ? FAT_LFN_LEN : 12;

	buf->f_namelen =

		(sbi->options.isvfat ? FAT_LFN_LEN : 12) * NLS_MAX_CHARSET_SIZE;



	return 0;

}
@@ -619,8 +620,8 @@ retry: 


	bh = sb_bread(sb, i_pos >> sbi->dir_per_block_bits);

	if (!bh) {

		printk(KERN_ERR "FAT: unable to read inode block "

		       "for updating (i_pos %lld)\n", i_pos);

		fat_msg(sb, KERN_ERR, "unable to read inode block "

		       "for updating (i_pos %lld)", i_pos);

		return -EIO;

	}

	spin_lock(&sbi->inode_hash_lock);
@@ -976,8 +977,8 @@ static const match_table_t vfat_tokens = { 
	{Opt_err, NULL}

};



static int parse_options(char *options, int is_vfat, int silent, int *debug,

			 struct fat_mount_options *opts)

static int parse_options(struct super_block *sb, char *options, int is_vfat,

			 int silent, int *debug, struct fat_mount_options *opts)

{

	char *p;

	substring_t args[MAX_OPT_ARGS];
@@ -1168,15 +1169,15 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug, 


		/* obsolete mount options */

		case Opt_obsolate:

			printk(KERN_INFO "FAT: \"%s\" option is obsolete, "

			       "not supported now\n", p);

			fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "

			       "not supported now", p);

			break;

		/* unknown option */

		default:

			if (!silent) {

				printk(KERN_ERR

				       "FAT: Unrecognized mount option \"%s\" "

				       "or missing value\n", p);

				fat_msg(sb, KERN_ERR,

				       "Unrecognized mount option \"%s\" "

				       "or missing value", p);

			}

			return -EINVAL;

		}
@@ -1185,7 +1186,7 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug, 
out:

	/* UTF-8 doesn't provide FAT semantics */

	if (!strcmp(opts->iocharset, "utf8")) {

		printk(KERN_ERR "FAT: utf8 is not a recommended IO charset"

		fat_msg(sb, KERN_ERR, "utf8 is not a recommended IO charset"

		       " for FAT filesystems, filesystem will be "

		       "case sensitive!\n");

	}
@@ -1238,8 +1239,7 @@ static int fat_read_root(struct inode *inode) 
/*

 * Read the super block of an MS-DOS FS.

 */

int fat_fill_super(struct super_block *sb, void *data, int silent,

		   const struct inode_operations *fs_dir_inode_ops, int isvfat,

int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,

		   void (*setup)(struct super_block *))

{

	struct inode *root_inode = NULL, *fat_inode = NULL;
@@ -1268,11 +1268,10 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	sb->s_magic = MSDOS_SUPER_MAGIC;

	sb->s_op = &fat_sops;

	sb->s_export_op = &fat_export_ops;

	sbi->dir_ops = fs_dir_inode_ops;

	ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,

			     DEFAULT_RATELIMIT_BURST);



	error = parse_options(data, isvfat, silent, &debug, &sbi->options);

	error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options);

	if (error)

		goto out_fail;
@@ -1282,20 +1281,20 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	sb_min_blocksize(sb, 512);

	bh = sb_bread(sb, 0);

	if (bh == NULL) {

		printk(KERN_ERR "FAT: unable to read boot sector\n");

		fat_msg(sb, KERN_ERR, "unable to read boot sector");

		goto out_fail;

	}



	b = (struct fat_boot_sector *) bh->b_data;

	if (!b->reserved) {

		if (!silent)

			printk(KERN_ERR "FAT: bogus number of reserved sectors\n");

			fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");

		brelse(bh);

		goto out_invalid;

	}

	if (!b->fats) {

		if (!silent)

			printk(KERN_ERR "FAT: bogus number of FAT structure\n");

			fat_msg(sb, KERN_ERR, "bogus number of FAT structure");

		brelse(bh);

		goto out_invalid;

	}
@@ -1308,7 +1307,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	media = b->media;

	if (!fat_valid_media(media)) {

		if (!silent)

			printk(KERN_ERR "FAT: invalid media value (0x%02x)\n",

			fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",

			       media);

		brelse(bh);

		goto out_invalid;
@@ -1318,7 +1317,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	    || (logical_sector_size < 512)

	    || (logical_sector_size > 4096)) {

		if (!silent)

			printk(KERN_ERR "FAT: bogus logical sector size %u\n",

			fat_msg(sb, KERN_ERR, "bogus logical sector size %u",

			       logical_sector_size);

		brelse(bh);

		goto out_invalid;
@@ -1326,15 +1325,15 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	sbi->sec_per_clus = b->sec_per_clus;

	if (!is_power_of_2(sbi->sec_per_clus)) {

		if (!silent)

			printk(KERN_ERR "FAT: bogus sectors per cluster %u\n",

			fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",

			       sbi->sec_per_clus);

		brelse(bh);

		goto out_invalid;

	}



	if (logical_sector_size < sb->s_blocksize) {

		printk(KERN_ERR "FAT: logical sector size too small for device"

		       " (logical sector size = %u)\n", logical_sector_size);

		fat_msg(sb, KERN_ERR, "logical sector size too small for device"

		       " (logical sector size = %u)", logical_sector_size);

		brelse(bh);

		goto out_fail;

	}
@@ -1342,14 +1341,14 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
		brelse(bh);



		if (!sb_set_blocksize(sb, logical_sector_size)) {

			printk(KERN_ERR "FAT: unable to set blocksize %u\n",

			fat_msg(sb, KERN_ERR, "unable to set blocksize %u",

			       logical_sector_size);

			goto out_fail;

		}

		bh = sb_bread(sb, 0);

		if (bh == NULL) {

			printk(KERN_ERR "FAT: unable to read boot sector"

			       " (logical sector size = %lu)\n",

			fat_msg(sb, KERN_ERR, "unable to read boot sector"

			       " (logical sector size = %lu)",

			       sb->s_blocksize);

			goto out_fail;

		}
@@ -1385,16 +1384,16 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 


		fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);

		if (fsinfo_bh == NULL) {

			printk(KERN_ERR "FAT: bread failed, FSINFO block"

			       " (sector = %lu)\n", sbi->fsinfo_sector);

			fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"

			       " (sector = %lu)", sbi->fsinfo_sector);

			brelse(bh);

			goto out_fail;

		}



		fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;

		if (!IS_FSINFO(fsinfo)) {

			printk(KERN_WARNING "FAT: Invalid FSINFO signature: "

			       "0x%08x, 0x%08x (sector = %lu)\n",

			fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "

			       "0x%08x, 0x%08x (sector = %lu)",

			       le32_to_cpu(fsinfo->signature1),

			       le32_to_cpu(fsinfo->signature2),

			       sbi->fsinfo_sector);
@@ -1415,8 +1414,8 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	sbi->dir_entries = get_unaligned_le16(&b->dir_entries);

	if (sbi->dir_entries & (sbi->dir_per_block - 1)) {

		if (!silent)

			printk(KERN_ERR "FAT: bogus directroy-entries per block"

			       " (%u)\n", sbi->dir_entries);

			fat_msg(sb, KERN_ERR, "bogus directroy-entries per block"

			       " (%u)", sbi->dir_entries);

		brelse(bh);

		goto out_invalid;

	}
@@ -1438,7 +1437,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);

	if (total_clusters > MAX_FAT(sb)) {

		if (!silent)

			printk(KERN_ERR "FAT: count of clusters too big (%u)\n",

			fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",

			       total_clusters);

		brelse(bh);

		goto out_invalid;
@@ -1471,7 +1470,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	sprintf(buf, "cp%d", sbi->options.codepage);

	sbi->nls_disk = load_nls(buf);

	if (!sbi->nls_disk) {

		printk(KERN_ERR "FAT: codepage %s not found\n", buf);

		fat_msg(sb, KERN_ERR, "codepage %s not found", buf);

		goto out_fail;

	}
@@ -1479,7 +1478,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	if (sbi->options.isvfat) {

		sbi->nls_io = load_nls(sbi->options.iocharset);

		if (!sbi->nls_io) {

			printk(KERN_ERR "FAT: IO charset %s not found\n",

			fat_msg(sb, KERN_ERR, "IO charset %s not found",

			       sbi->options.iocharset);

			goto out_fail;

		}
@@ -1503,7 +1502,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
	insert_inode_hash(root_inode);

	sb->s_root = d_alloc_root(root_inode);

	if (!sb->s_root) {

		printk(KERN_ERR "FAT: get root inode failed\n");

		fat_msg(sb, KERN_ERR, "get root inode failed");

		goto out_fail;

	}
@@ -1512,8 +1511,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, 
out_invalid:

	error = -EINVAL;

	if (!silent)

		printk(KERN_INFO "VFS: Can't find a valid FAT filesystem"

		       " on dev %s.\n", sb->s_id);

		fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");



out_fail:

	if (fat_inode)

CRA Git | Maintained and supported by SUSTech CRA and CCSE