inode.c

elinux jffs初始版本 具体了解JFFS的文件系统！

				/* because clusters (DOS) are often aligned */
				/* on odd sectors. */
	sb->s_blocksize_bits = blksize == 512 ? 9 : 10;
	if (error || debug) {
		/* The MSDOS_CAN_BMAP is obsolete, but left just to remember */
		printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
		       "uid=%d,gid=%d,umask=%03o%s]\n",
		       MSDOS_SB(sb)->fat_bits,opts.name_check,
		       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=%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(*(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)
		MSDOS_SB(sb)->clusters = fat_clusters-2;
	if (error) {
		if (!silent)
			printk("VFS: Can't find a valid MSDOS filesystem on dev "
			       "%s.\n", kdevname(sb->s_dev));
		sb->s_dev = 0;
		MOD_DEC_USE_COUNT;
		return NULL;
	}
	sb->s_magic = MSDOS_SUPER_MAGIC;
	/* set up enough so that it can read an inode */
	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";
	MSDOS_SB(sb)->nls_io = NULL;
	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();
			}
		}
	}

	if (!(sb->s_mounted = iget(sb,MSDOS_ROOT_INO))) {
		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;
	}

	return sb;
}


void fat_statfs(struct super_block *sb,struct statfs *buf, int bufsiz)
{
	int free,nr;
	struct statfs tmp;

	lock_fat(sb);
	if (MSDOS_SB(sb)->free_clusters != -1)
		free = MSDOS_SB(sb)->free_clusters;
	else {
		free = 0;
		for (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++)
			if (!fat_access(sb,nr,-1)) free++;
		MSDOS_SB(sb)->free_clusters = free;
	}
	unlock_fat(sb);
	tmp.f_type = sb->s_magic;
	tmp.f_bsize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
	tmp.f_blocks = MSDOS_SB(sb)->clusters;
	tmp.f_bfree = free;
	tmp.f_bavail = free;
	tmp.f_files = 0;
	tmp.f_ffree = 0;
	tmp.f_namelen = 12;
	FAT_COPY_TO_USER(buf, &tmp, bufsiz);
}


int fat_bmap(struct inode *inode,int block)
{
	struct msdos_sb_info *sb;
	int cluster,offset;

	sb = MSDOS_SB(inode->i_sb);
	if ((inode->i_ino == MSDOS_ROOT_INO) && (sb->fat_bits != 32)) {
		return sb->dir_start + block;
	}
	cluster = block/sb->cluster_size;
	offset = block % sb->cluster_size;
	if (!(cluster = get_cluster(inode,cluster))) return 0;
	return (cluster-2)*sb->cluster_size+sb->data_start+offset;
}

static int is_exec(char *extension)
{
	char *exe_extensions = "EXECOMBAT", *walk;

	for (walk = exe_extensions; *walk; walk += 3)
		if (!strncmp(extension, walk, 3))
			return 1;
	return 0;
}

void fat_read_inode(struct inode *inode, struct inode_operations *fs_dir_inode_ops)
{
	struct super_block *sb = inode->i_sb;
	struct buffer_head *bh;
	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;
	MSDOS_I(inode)->i_binary = 1;
	inode->i_uid = MSDOS_SB(sb)->options.fs_uid;
	inode->i_gid = MSDOS_SB(sb)->options.fs_gid;
	inode->i_version = ++event;
	if (inode->i_ino == MSDOS_ROOT_INO) {
		inode->i_mode = (S_IRWXUGO & ~MSDOS_SB(sb)->options.fs_umask) |
		    S_IFDIR;
		inode->i_op = fs_dir_inode_ops;
		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_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))) {
		printk("dev = %s, ino = %ld\n",
		       kdevname(inode->i_dev), inode->i_ino);
		panic("fat_read_inode: unable to read i-node block");
	}
	raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
	    [inode->i_ino & (MSDOS_DPB-1)];
	if ((raw_entry->attr & ATTR_DIR) && !IS_FREE(raw_entry->name)) {
		inode->i_mode = MSDOS_MKMODE(raw_entry->attr,S_IRWXUGO &
		    ~MSDOS_SB(sb)->options.fs_umask) | S_IFDIR;
		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
		if (!inode->i_nlink) {
			printk("directory %d: i_nlink == 0\n",inode->i_ino);
			inode->i_nlink = 1;
		}
#endif
		inode->i_size = 0;
		if ((nr = MSDOS_I(inode)->i_start) != 0)
			while (nr != -1) {
				inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
				    i_sb)->cluster_size;
				if (!(nr = fat_access(sb,nr,-1))) {
					printk("Directory %ld: bad FAT\n",
					    inode->i_ino);
					break;
				}
			}
	} else { /* not a directory */
		inode->i_mode = MSDOS_MKMODE(raw_entry->attr,
		    ((IS_NOEXEC(inode) || 
		      (MSDOS_SB(sb)->options.showexec &&
		       !is_exec(raw_entry->ext)))
		    	? S_IRUGO|S_IWUGO : S_IRWXUGO)
		    & ~MSDOS_SB(sb)->options.fs_umask) | S_IFREG;
		inode->i_op = (sb->s_blocksize == 1024)
			? &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);
	}
	if(raw_entry->attr & ATTR_SYS)
		if (MSDOS_SB(sb)->options.sys_immutable)
			inode->i_flags |= S_IMMUTABLE;
	MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(sb)->options.conversion,
	    raw_entry->ext);
	MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
	/* this is as close to the truth as we can get ... */
	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;
	inode->i_mtime = inode->i_atime =
	    date_dos2unix(CF_LE_W(raw_entry->time),CF_LE_W(raw_entry->date));
	inode->i_ctime =
		MSDOS_SB(sb)->options.isvfat
		? date_dos2unix(CF_LE_W(raw_entry->ctime),CF_LE_W(raw_entry->cdate))
		: inode->i_mtime;
	fat_brelse(sb, bh);
}


void fat_write_inode(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;
	struct buffer_head *bh;
	struct msdos_dir_entry *raw_entry;
	struct inode *linked;

	linked = MSDOS_I(inode)->i_linked;
	if (linked) {
		if (MSDOS_I(linked)->i_oldlink != inode) {
			printk("Invalid link (0x%p): expected 0x%p, got 0x%p\n",
			       linked, inode, MSDOS_I(linked)->i_oldlink);
			fat_fs_panic(sb,"...");
			return;
		}
		linked->i_version = ++event;
		linked->i_mode = inode->i_mode;
		linked->i_uid = inode->i_uid;
		linked->i_gid = inode->i_gid;
		linked->i_size = inode->i_size;
		linked->i_atime = inode->i_atime;
		linked->i_mtime = inode->i_mtime;
		linked->i_ctime = inode->i_ctime;
		linked->i_blocks = inode->i_blocks;
		linked->i_atime = inode->i_atime;
		MSDOS_I(linked)->i_attrs = MSDOS_I(inode)->i_attrs;
		linked->i_dirt = 1;
	}

	inode->i_dirt = 0;
	if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
	if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) {
		printk("dev = %s, ino = %ld\n",
		       kdevname(inode->i_dev), inode->i_ino);
		panic("msdos_write_inode: unable to read i-node block");
	}
	raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
	    [inode->i_ino & (MSDOS_DPB-1)];
	if (S_ISDIR(inode->i_mode)) {
		raw_entry->attr = ATTR_DIR;
		raw_entry->size = 0;
	}
	else {
		raw_entry->attr = ATTR_NONE;
		raw_entry->size = CT_LE_L(inode->i_size);
	}
	raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
	    MSDOS_I(inode)->i_attrs;
	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);
	if (MSDOS_SB(sb)->options.isvfat) {
		fat_date_unix2dos(inode->i_ctime,&raw_entry->ctime,&raw_entry->cdate);
		raw_entry->ctime = CT_LE_W(raw_entry->ctime);
		raw_entry->cdate = CT_LE_W(raw_entry->cdate);
	}
	fat_mark_buffer_dirty(sb, bh, 1);
	fat_brelse(sb, bh);
}


int fat_notify_change(struct inode * inode,struct iattr * attr)
{
	struct super_block *sb = inode->i_sb;
	int error;

	error = inode_change_ok(inode, attr);
	if (error)
		return MSDOS_SB(sb)->options.quiet ? 0 : error;

	if (((attr->ia_valid & ATTR_UID) && 
	     (attr->ia_uid != MSDOS_SB(sb)->options.fs_uid)) ||
	    ((attr->ia_valid & ATTR_GID) && 
	     (attr->ia_gid != MSDOS_SB(sb)->options.fs_gid)) ||
	    ((attr->ia_valid & ATTR_MODE) &&
	     (attr->ia_mode & ~MSDOS_VALID_MODE)))
		error = -EPERM;

	if (error)
		return MSDOS_SB(sb)->options.quiet ? 0 : error;

	inode_setattr(inode, attr);

	if (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode))
		inode->i_mode &= S_IFMT | S_IRUGO | S_IWUGO;
	else
		inode->i_mode |= S_IXUGO;

	inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
	    & ~MSDOS_SB(sb)->options.fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) &
	    ~MSDOS_SB(sb)->options.fs_umask;
	return 0;
}


#ifdef MODULE
int init_module(void)
{
	return init_fat_fs();
}


void cleanup_module(void)
{
	/* Nothing to be done, really! */
	return;
}
#endif