patch-2.1.60 linux/fs/fat/inode.c

• Lines: 490
• Date: Thu Oct 23 14:00:15 1997
• Orig file: v2.1.59/linux/fs/fat/inode.c
• Orig date: Sun Jul 27 12:11:00 1997

diff -u --recursive --new-file v2.1.59/linux/fs/fat/inode.c linux/fs/fat/inode.c
@@ -5,10 +5,13 @@
  *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
  */
 
+#define ASC_LINUX_VERSION(V, P, S)	(((V) * 65536) + ((P) * 256) + (S))
+#include <linux/version.h>
 #define __NO_VERSION__
 #include <linux/module.h>
 
 #include <linux/msdos_fs.h>
+#include <linux/nls.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
@@ -18,14 +21,24 @@
 #include <linux/fs.h>
 #include <linux/stat.h>
 #include <linux/locks.h>
+#include <linux/malloc.h>
 
 #include "msbuffer.h"
-#include "tables.h"
 
+#if LINUX_VERSION_CODE >= ASC_LINUX_VERSION(2,1,0)
 #include <asm/uaccess.h>
+#define FAT_COPY_TO_USER(uaddr, kaddr, len) copy_to_user(uaddr, kaddr, len)
+#else
+#include <asm/segment.h>
+#define FAT_COPY_TO_USER(uaddr, kaddr, len) memcpy_tofs(uaddr, kaddr, len)
+#endif
 #include <asm/unaligned.h>
 
-
+#if 0
+#  define PRINTK(x) printk x
+#else
+#  define PRINTK(x)
+#endif
 
 void fat_put_inode(struct inode *inode)
 {
@@ -85,8 +98,24 @@
 
 void fat_put_super(struct super_block *sb)
 {
+	if (MSDOS_SB(sb)->fat_bits == 32) {
+		fat_clusters_flush(sb);
+	}
 	fat_cache_inval_dev(sb->s_dev);
 	set_blocksize (sb->s_dev,BLOCK_SIZE);
+	if (MSDOS_SB(sb)->nls_disk) {
+		unload_nls(MSDOS_SB(sb)->nls_disk);
+		MSDOS_SB(sb)->nls_disk = NULL;
+		MSDOS_SB(sb)->options.codepage = 0;
+	}
+	if (MSDOS_SB(sb)->nls_io) {
+		unload_nls(MSDOS_SB(sb)->nls_io);
+		MSDOS_SB(sb)->nls_io = NULL;
+		if (MSDOS_SB(sb)->options.iocharset) {
+			kfree(MSDOS_SB(sb)->options.iocharset);
+			MSDOS_SB(sb)->options.iocharset = NULL;
+		}
+	}
 	lock_super(sb);
 	sb->s_dev = 0;
 	unlock_super(sb);
@@ -98,27 +127,38 @@
 static int parse_options(char *options,int *fat, int *blksize, int *debug,
 			 struct fat_mount_options *opts)
 {
-	char *this_char,*value;
+	char *this_char,*value,save,*savep;
+	char *p;
+	int ret, len;
 
 	opts->name_check = 'n';
 	opts->conversion = 'b';
 	opts->fs_uid = current->uid;
 	opts->fs_gid = current->gid;
 	opts->fs_umask = current->fs->umask;
-	opts->quiet = opts->sys_immutable = opts->dotsOK = opts->showexec = opts->isvfat = 0;
+	opts->quiet = opts->sys_immutable = opts->dotsOK = opts->showexec = 0;
+	opts->codepage = 0;
+	opts->utf8 = 0;
+	opts->iocharset = NULL;
 	*debug = *fat = 0;
 
 	if (!options) return 1;
+	save = 0;
+	savep = NULL;
+	ret = 1;
 	for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) {
-		if ((value = strchr(this_char,'=')) != NULL)
+		if ((value = strchr(this_char,'=')) != NULL) {
+			save = *value;
+			savep = value;
 			*value++ = 0;
+		}
 		if (!strcmp(this_char,"check") && value) {
 			if (value[0] && !value[1] && strchr("rns",*value))
 				opts->name_check = *value;
 			else if (!strcmp(value,"relaxed")) opts->name_check = 'r';
 			else if (!strcmp(value,"normal")) opts->name_check = 'n';
 			else if (!strcmp(value,"strict")) opts->name_check = 's';
-			else return 0;
+			else ret = 0;
 		}
 		else if (!strcmp(this_char,"conv") && value) {
 			if (value[0] && !value[1] && strchr("bta",*value))
@@ -126,7 +166,7 @@
 			else if (!strcmp(value,"binary")) opts->conversion = 'b';
 			else if (!strcmp(value,"text")) opts->conversion = 't';
 			else if (!strcmp(value,"auto")) opts->conversion = 'a';
-			else return 0;
+			else ret = 0;
 		}
 		else if (!strcmp(this_char,"dots")) {
 			opts->dotsOK = 1;
@@ -140,57 +180,80 @@
 		else if (!strcmp(this_char,"dotsOK") && value) {
 			if (!strcmp(value,"yes")) opts->dotsOK = 1;
 			else if (!strcmp(value,"no")) opts->dotsOK = 0;
-			else return 0;
+			else ret = 0;
 		}
 		else if (!strcmp(this_char,"uid")) {
-			if (!value || !*value)
-				return 0;
-			opts->fs_uid = simple_strtoul(value,&value,0);
-			if (*value)
-				return 0;
+			if (!value || !*value) ret = 0;
+			else {
+				opts->fs_uid = simple_strtoul(value,&value,0);
+				if (*value) ret = 0;
+			}
 		}
 		else if (!strcmp(this_char,"gid")) {
-			if (!value || !*value)
-				return 0;
-			opts->fs_gid = simple_strtoul(value,&value,0);
-			if (*value)
-				return 0;
+			if (!value || !*value) ret= 0;
+			else {
+				opts->fs_gid = simple_strtoul(value,&value,0);
+				if (*value) ret = 0;
+			}
 		}
 		else if (!strcmp(this_char,"umask")) {
-			if (!value || !*value)
-				return 0;
-			opts->fs_umask = simple_strtoul(value,&value,8);
-			if (*value)
-				return 0;
+			if (!value || !*value) ret = 0;
+			else {
+				opts->fs_umask = simple_strtoul(value,&value,8);
+				if (*value) ret = 0;
+			}
 		}
 		else if (!strcmp(this_char,"debug")) {
-			if (value) return 0;
-			*debug = 1;
+			if (value) ret = 0;
+			else *debug = 1;
 		}
 		else if (!strcmp(this_char,"fat")) {
-			if (!value || !*value)
-				return 0;
-			*fat = simple_strtoul(value,&value,0);
-			if (*value || (*fat != 12 && *fat != 16))
-				return 0;
+			if (!value || !*value) ret = 0;
+			else {
+				*fat = simple_strtoul(value,&value,0);
+				if (*value || (*fat != 12 && *fat != 16 &&
+					       *fat != 32)) 
+					ret = 0;
+			}
 		}
 		else if (!strcmp(this_char,"quiet")) {
-			if (value) return 0;
-			opts->quiet = 1;
+			if (value) ret = 0;
+			else opts->quiet = 1;
 		}
 		else if (!strcmp(this_char,"blocksize")) {
-			*blksize = simple_strtoul(value,&value,0);
-			if (*value)
-				return 0;
-			if (*blksize != 512 && *blksize != 1024 && *blksize != 2048){
-				printk ("MSDOS FS: Invalid blocksize (512, 1024 or 2048)\n");
+			if (*value) ret = 0;
+			else if (*blksize != 512 && *blksize != 1024 && *blksize != 2048){
+				printk ("MSDOS FS: Invalid blocksize (512, 1024, or 2048)\n");
 			}
 		}
 		else if (!strcmp(this_char,"sys_immutable")) {
-			if (value)
-				return 0;
-			opts->sys_immutable = 1;
+			if (value) ret = 0;
+			else opts->sys_immutable = 1;
 		}
+		else if (!strcmp(this_char,"codepage")) {
+			opts->codepage = simple_strtoul(value,&value,0);
+			if (*value) ret = 0;
+			else printk ("MSDOS FS: Using codepage %d\n", opts->codepage);
+		}
+		else if (!strcmp(this_char,"iocharset")) {
+			p = value;
+			while (*value && *value != ',') value++;
+			len = value - p;
+			if (len) {
+				opts->iocharset = kmalloc(len+1, GFP_KERNEL);
+				memcpy(opts->iocharset, p, len);
+				opts->iocharset[len] = 0;
+				printk ("MSDOS FS: Using IO charset %s\n",
+					opts->iocharset);
+			} else {
+				opts->iocharset = NULL;
+				ret = 0;
+			}
+		}
+
+		if (this_char != options) *(this_char-1) = ',';
+		if (value) *savep = save;
+		if (ret == 0) return 0;
 	}
 	return 1;
 }
@@ -201,11 +264,14 @@
 struct super_block *fat_read_super(struct super_block *sb,void *data, int silent)
 {
 	struct buffer_head *bh;
-	struct msdos_boot_sector *b;
+	struct fat_boot_sector *b;
 	int data_sectors,logical_sector_size,sector_mult,fat_clusters=0;
-	int debug,error,fat;
+	int debug,error,fat,cp;
 	int blksize = 512;
+	int fat32;
 	struct fat_mount_options opts;
+	char buf[50];
+	char *p;
 	struct inode *root_inode;
 
 	MOD_INC_USE_COUNT;
@@ -215,6 +281,7 @@
 			printk ("MSDOS: Hardware sector size is %d\n",blksize);
 		}
 	}
+	opts.isvfat = MSDOS_SB(sb)->options.isvfat;
 	if (!parse_options((char *) data, &fat, &blksize, &debug, &opts)
 		|| (blksize != 512 && blksize != 1024 && blksize != 2048)) 
 	{
@@ -245,8 +312,8 @@
 		MOD_DEC_USE_COUNT;
 		return NULL;
 	}
-	b = (struct msdos_boot_sector *) bh->b_data;
 	set_blocksize(sb->s_dev, blksize);
+
 /*
  * The DOS3 partition size limit is *not* 32M as many people think.  
  * Instead, it is 64K sectors (with the usual sector size being
@@ -265,15 +332,37 @@
 #define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
     /* don't divide by zero */
 
+	b = (struct fat_boot_sector *) bh->b_data;
 	logical_sector_size =
 		CF_LE_W(get_unaligned((unsigned short *) &b->sector_size));
 	sector_mult = logical_sector_size >> SECTOR_BITS;
 	MSDOS_SB(sb)->cluster_size = b->cluster_size*sector_mult;
 	MSDOS_SB(sb)->fats = b->fats;
 	MSDOS_SB(sb)->fat_start = CF_LE_W(b->reserved)*sector_mult;
-	MSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
-	MSDOS_SB(sb)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
-	    b->fat_length))*sector_mult;
+	if (!b->fat_length && b->fat32_length) {
+		struct fat_boot_fsinfo *fsinfo;
+
+		/* Must be FAT32 */
+		fat32 = 1;
+		MSDOS_SB(sb)->fat_length= CF_LE_W(b->fat32_length)*sector_mult;
+		MSDOS_SB(sb)->root_cluster = CF_LE_L(b->root_cluster);
+		MSDOS_SB(sb)->fsinfo_offset =
+			CF_LE_W(b->info_sector) * logical_sector_size + 0x1e0;
+		fsinfo = (struct fat_boot_fsinfo *)
+			&bh->b_data[MSDOS_SB(sb)->fsinfo_offset];
+		if (CF_LE_L(fsinfo->signature) != 0x61417272) {
+			printk("fat_read_super: Did not find valid FSINFO signature. Found 0x%x\n", CF_LE_L(fsinfo->signature));
+		} else {
+			MSDOS_SB(sb)->free_clusters = CF_LE_L(fsinfo->free_clusters);
+		}
+	} else {
+		fat32 = 0;
+		MSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
+		MSDOS_SB(sb)->root_cluster = 0;
+		MSDOS_SB(sb)->free_clusters = -1; /* Don't know yet */
+	}
+	MSDOS_SB(sb)->dir_start= CF_LE_W(b->reserved)*sector_mult+
+	    b->fats*MSDOS_SB(sb)->fat_length;
 	MSDOS_SB(sb)->dir_entries =
 		CF_LE_W(get_unaligned((unsigned short *) &b->dir_entries));
 	MSDOS_SB(sb)->data_start = MSDOS_SB(sb)->dir_start+ROUND_TO_MULTIPLE((
@@ -288,8 +377,9 @@
 	if (!error) {
 		MSDOS_SB(sb)->clusters = b->cluster_size ? data_sectors/
 		    b->cluster_size/sector_mult : 0;
-		MSDOS_SB(sb)->fat_bits = fat ? fat : MSDOS_SB(sb)->clusters >
-		    MSDOS_FAT12 ? 16 : 12;
+		MSDOS_SB(sb)->fat_bits = fat32 ? 32 :
+			(fat ? fat :
+			 (MSDOS_SB(sb)->clusters > MSDOS_FAT12 ? 16 : 12));
 		fat_clusters = MSDOS_SB(sb)->fat_length*SECTOR_SIZE*8/
 		    MSDOS_SB(sb)->fat_bits;
 		error = !MSDOS_SB(sb)->fats || (MSDOS_SB(sb)->dir_entries &
@@ -315,12 +405,13 @@
 		       opts.conversion,opts.fs_uid,opts.fs_gid,opts.fs_umask,
 		       MSDOS_CAN_BMAP(MSDOS_SB(sb)) ? ",bmap" : "");
 		printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d,"
-		       "se=%d,ts=%d,ls=%d]\n",b->media,MSDOS_SB(sb)->cluster_size,
+		       "se=%d,ts=%ld,ls=%d,rc=%ld,fc=%u]\n",b->media,MSDOS_SB(sb)->cluster_size,
 		       MSDOS_SB(sb)->fats,MSDOS_SB(sb)->fat_start,MSDOS_SB(sb)->fat_length,
 		       MSDOS_SB(sb)->dir_start,MSDOS_SB(sb)->dir_entries,
 		       MSDOS_SB(sb)->data_start,
-		       CF_LE_W(get_unaligned((unsigned short *) &b->sectors)),
-		       CF_LE_L(b->total_sect),logical_sector_size);
+		       CF_LE_W(*(unsigned short *) &b->sectors),
+		       (unsigned long)b->total_sect,logical_sector_size,
+		       MSDOS_SB(sb)->root_cluster,MSDOS_SB(sb)->free_clusters);
 		printk ("Transaction block size = %d\n",blksize);
 	}
 	if (MSDOS_SB(sb)->clusters+2 > fat_clusters)
@@ -335,17 +426,51 @@
 	}
 	sb->s_magic = MSDOS_SUPER_MAGIC;
 	/* set up enough so that it can read an inode */
-	MSDOS_SB(sb)->free_clusters = -1; /* don't know yet */
 	MSDOS_SB(sb)->fat_wait = NULL;
 	MSDOS_SB(sb)->fat_lock = 0;
 	MSDOS_SB(sb)->prev_free = 0;
 	memcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options));
 
+	cp = opts.codepage ? opts.codepage : 437;
+	sprintf(buf, "cp%d", cp);
+	MSDOS_SB(sb)->nls_disk = load_nls(buf);
+	if (! MSDOS_SB(sb)->nls_disk) {
+		/* Fail only if explicit charset specified */
+		if (opts.codepage == 0) {
+			MSDOS_SB(sb)->options.codepage = 0;
+			MSDOS_SB(sb)->nls_disk = load_nls_default();
+		} else {
+			sb->s_dev = 0;
+			MOD_DEC_USE_COUNT;
+			return NULL;
+		}
+	}
+
+	p = opts.iocharset ? opts.iocharset : "iso8859-1";
+	if (MSDOS_SB(sb)->options.isvfat && !opts.utf8) {
+		MSDOS_SB(sb)->nls_io = load_nls(p);
+		if (! MSDOS_SB(sb)->nls_io) {
+			/* Fail only if explicit charset specified */
+			if (opts.iocharset) {
+				kfree(opts.iocharset);
+				unload_nls(MSDOS_SB(sb)->nls_disk);
+				sb->s_dev = 0;
+				MOD_DEC_USE_COUNT;
+				return NULL;
+			} else {
+				MSDOS_SB(sb)->nls_io = load_nls_default();
+			}
+		}
+	}
+
 	root_inode = iget(sb,MSDOS_ROOT_INO);
 	sb->s_root = d_alloc_root(root_inode, NULL);
 	if (!sb->s_root) {
 		sb->s_dev = 0;
 		printk("get root inode failed\n");
+		unload_nls(MSDOS_SB(sb)->nls_disk);
+		if (MSDOS_SB(sb)->nls_io) unload_nls(MSDOS_SB(sb)->nls_io);
+		if (opts.iocharset) kfree(opts.iocharset);
 		MOD_DEC_USE_COUNT;
 		return NULL;
 	}
@@ -386,7 +511,7 @@
 	int cluster,offset;
 
 	sb = MSDOS_SB(inode->i_sb);
-	if (inode->i_ino == MSDOS_ROOT_INO) {
+	if ((inode->i_ino == MSDOS_ROOT_INO) && (sb->fat_bits != 32)) {
 		return sb->dir_start + block;
 	}
 	cluster = block/sb->cluster_size;
@@ -412,6 +537,8 @@
 	struct msdos_dir_entry *raw_entry;
 	int nr;
 
+	PRINTK(("fat_read_inode: inode=%p, sb->dir_start=0x%x\n",
+		inode, MSDOS_SB(sb)->dir_start));
 	MSDOS_I(inode)->i_busy = 0;
 	MSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
 	MSDOS_I(inode)->i_linked = MSDOS_I(inode)->i_oldlink = NULL;
@@ -423,17 +550,33 @@
 		inode->i_mode = (S_IRWXUGO & ~MSDOS_SB(sb)->options.fs_umask) |
 		    S_IFDIR;
 		inode->i_op = fs_dir_inode_ops;
-		inode->i_nlink = fat_subdirs(inode)+2;
-		    /* subdirs (neither . nor ..) plus . and "self" */
-		inode->i_size = MSDOS_SB(sb)->dir_entries*
-		    sizeof(struct msdos_dir_entry);
+		if (MSDOS_SB(sb)->fat_bits == 32) {
+			MSDOS_I(inode)->i_start = MSDOS_SB(sb)->root_cluster;
+			if ((nr = MSDOS_I(inode)->i_start) != 0) {
+				while (nr != -1) {
+					inode->i_size += SECTOR_SIZE*MSDOS_SB(sb)->cluster_size;
+					if (!(nr = fat_access(sb,nr,-1))) {
+						printk("Directory %ld: bad FAT\n",
+						       inode->i_ino);
+						break;
+					}
+				}
+			}
+		} else {
+			MSDOS_I(inode)->i_start = 0;
+			inode->i_size = MSDOS_SB(sb)->dir_entries*
+				sizeof(struct msdos_dir_entry);
+		}
 		inode->i_blksize = MSDOS_SB(sb)->cluster_size*
 		    SECTOR_SIZE;
 		inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
 		    inode->i_blksize*MSDOS_SB(sb)->cluster_size;
-		MSDOS_I(inode)->i_start = 0;
+		MSDOS_I(inode)->i_logstart = 0;
+
 		MSDOS_I(inode)->i_attrs = 0;
 		inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
+		inode->i_nlink = fat_subdirs(inode)+2;
+		    /* subdirs (neither . nor ..) plus . and "self" */
 		return;
 	}
 	if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) {
@@ -449,6 +592,11 @@
 		inode->i_op = fs_dir_inode_ops;
 
 		MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
+		if (MSDOS_SB(sb)->fat_bits == 32) {
+			MSDOS_I(inode)->i_start |=
+				(CF_LE_W(raw_entry->starthi) << 16);
+		}
+		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 		inode->i_nlink = fat_subdirs(inode);
 		    /* includes .., compensating for "self" */
 #ifdef DEBUG
@@ -458,7 +606,7 @@
 		}
 #endif
 		inode->i_size = 0;
-		if ((nr = CF_LE_W(raw_entry->start)) != 0)
+		if ((nr = MSDOS_I(inode)->i_start) != 0)
 			while (nr != -1) {
 				inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
 				    i_sb)->cluster_size;
@@ -479,6 +627,11 @@
 			? &fat_file_inode_operations_1024
 			: &fat_file_inode_operations;
 		MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
+		if (MSDOS_SB(sb)->fat_bits == 32) {
+			MSDOS_I(inode)->i_start |=
+				(CF_LE_W(raw_entry->starthi) << 16);
+		}
+		MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 		inode->i_nlink = 1;
 		inode->i_size = CF_LE_L(raw_entry->size);
 	}
@@ -549,7 +702,8 @@
 	}
 	raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
 	    MSDOS_I(inode)->i_attrs;
-	raw_entry->start = CT_LE_W(MSDOS_I(inode)->i_start);
+	raw_entry->start = CT_LE_W(MSDOS_I(inode)->i_logstart);
+	raw_entry->starthi = CT_LE_W(MSDOS_I(inode)->i_logstart >> 16);
 	fat_date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
 	raw_entry->time = CT_LE_W(raw_entry->time);
 	raw_entry->date = CT_LE_W(raw_entry->date);