j_inode.cpp

JFFS的源代码

	/* Initialize the raw inode.  */
	raw_inode.magic = JFFS_MAGIC_BITMASK;
	raw_inode.ino = del_f->ino;
	raw_inode.pino = del_f->pino;
	raw_inode.version = del_f->highest_version + 1;
	raw_inode.mode = del_f->mode;
	/*raw_inode.uid = current->fsuid;
	raw_inode.gid = current->fsgid;*/
	raw_inode.atime = CURRENT_TIME;
	raw_inode.mtime = del_f->mtime;
	raw_inode.ctime = raw_inode.atime;
	raw_inode.offset = 0;
	raw_inode.dsize = 0;
	raw_inode.rsize = 0;
	raw_inode.nsize = 0;
	raw_inode.nlink = del_f->nlink;
	raw_inode.spare = 0;
	raw_inode.rename = 0;
	raw_inode.deleted = 1;

	/* Write the new node to the flash memory.  */
	if (jffs_write_node(c, del_node, &raw_inode, 0, 0) < 0) {
		kfree(del_node);
		DJM(no_jffs_node--);
		result = -1;
		goto jffs_remove_end;
	}

	/* Update the file.  This operation will make the file disappear
	   from the in-memory file system structures.  */
	jffs_insert_node(c, del_f, &raw_inode, 0, del_node);

	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
        dir->i_dirt = 1;
	/*inode->i_nlink = inode->i_nlink ? inode->i_nlink - 1 : 0;
	if (inode->i_nlink == 0) {
		inode->u.generic_ip = 0;
	}
	inode->i_dirt = 1;
	inode->i_ctime = dir->i_ctime;*/

jffs_remove_end:
	/*if (must_iput) {
		iput(dir);
	}
	if (inode) {
		iput(inode);
	}*/
	return result;
} /* jffs_remove()  */


/* Remove any kind of file except for directories.  */
static int jffs_unlink(struct inode *dir, const char *name, int len)
{
	D3(printk("***jffs_unlink()\n"));
	return jffs_remove(dir, name, len, 0, 1);
}

/* Called by the VFS at mount time to initialize the whole file system.  */
static struct super_block *jffs_read_super(struct super_block *sb, void *data, int silent)
{
	kdev_t dev = sb->s_dev;
	struct jffs_control *c = 0;


	/*printk(KERN_NOTICE "JFFS: Trying to mount device %s.\n",
	       kdevname(dev));*/

	/*MOD_INC_USE_COUNT;
	lock_super(sb);
	set_blocksize(dev, BLOCK_SIZE);*/
	sb->s_blocksize = BLOCK_SIZE;
	sb->s_blocksize_bits = BLOCK_SIZE_BITS;
	sb->u.generic_sbp = (void *) 0;

	memset(&I_FLASH, 0, sizeof(struct inode));
	I_FLASH.i_op = &jffs_dir_inode_operations;

	/* Build the file system.  */
	if (jffs_build_fs(sb) < 0) {	//热点
		goto jffs_sb_err1;
	}
		/*!!!!!*/
	
	sb->s_magic = JFFS_MAGIC_SB_BITMASK;
	sb->s_op = &jffs_ops;

	/* Get the root directory of this file system.  */
	/*if (!(sb->s_mounted = iget(sb, JFFS_MIN_INO))) {
		goto jffs_sb_err2;
	}*/
	sb->s_mounted = &I_FLASH;
	
	c = (struct jffs_control *)sb->u.generic_sbp;

#ifdef CONFIG_JFFS_PROC_FS
	/* Set up the jffs proc file system.  */
	if (jffs_register_jffs_proc_dir(dev, c) < 0) {
		printk(KERN_WARNING "JFFS: Failed to initialize the JFFS "
		       "proc file system for device %s.\n",
		       kdevname(dev));
	}
#endif

#ifdef USE_GC
	/* Do a garbage collect every time we mount.  */
	printf("Jffs garbage collect...\n");
	jffs_garbage_collect((struct jffs_control *)sb->u.generic_sbp);
#endif

	/*unlock_super(sb);
	printk(KERN_NOTICE "JFFS: Successfully mounted device %s.\n",
	       kdevname(dev));*/
	printf("JFFS Successfully mounted\n");
       
	return sb;

jffs_sb_err2:
	jffs_cleanup_control((struct jffs_control *)sb->u.generic_sbp);
jffs_sb_err1:
	/*unlock_super(sb);
	MOD_DEC_USE_COUNT;*/
	printf("JFFS Failed to mount device\n");

	return 0;
}

/* Create a new directory.  */
static int jffs_mkdir(struct inode *dir, const char *name, int len, int mode)
{
	struct jffs_raw_inode raw_inode;
	struct jffs_control *c;
	struct jffs_node *node;
	struct jffs_file *dir_f;
	int dir_mode;
	int result = 0;

	D1({
		char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
		memcpy(_name, name, len);
		_name[len] = '\0';
		printk("***jffs_mkdir(): dir = 0x%p, name = \"%s\", "
		       "len = %d, mode = 0x%08x\n", dir, _name, len, mode);
		kfree(_name);
	});

	if (!dir) {
		return -ENOENT;
	}
	if (len > JFFS_MAX_NAME_LEN) {
		result = -ENAMETOOLONG;
		goto jffs_mkdir_end;
	}

	dir_f = (struct jffs_file *)dir->u.generic_ip;
	ASSERT(if (!dir_f) {
		printk(KERN_ERR "jffs_mkdir(): No reference to a "
		       "jffs_file struct in inode.\n");
		result = -1;
		goto jffs_mkdir_end;
	});

	c = dir_f->c;

	if (!JFFS_ENOUGH_SPACE(c->fmc)) {
		D1(printk("jffs_mkdir(): Free size = %u\n",
			  jffs_free_size1(c->fmc) + jffs_free_size2(c->fmc)));
		D(printk("JFFS: No space left on device\n"));
		result = -ENOSPC;
		goto jffs_mkdir_end;
	}

	/* If there already exists a file or directory with the same name,
	   then this operation should fail. I originally thought that VFS
	   should take care of this issue.  */
	if (jffs_find_child(dir_f, name, len)) {
		D(printk("jffs_mkdir(): There already exists a file or "
			 "directory with the same name!\n"));
		result = -EEXIST;
		goto jffs_mkdir_end;
	}

	/*m* dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask);*/
	dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX));
	if (dir->i_mode & S_ISGID) {
                dir_mode |= S_ISGID;
	}

	/* Create a node and initialize it as much as needed.  */
	if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
						  GFP_KERNEL))) {
		D(printk("jffs_mkdir(): Allocation failed: node == 0\n"));
		result = -ENOMEM;
		goto jffs_mkdir_end;
	}
	DJM(no_jffs_node++);
	node->data_offset = 0;
	node->removed_size = 0;

	/* Initialize the raw inode.  */
	raw_inode.magic = JFFS_MAGIC_BITMASK;
	raw_inode.ino = c->next_ino++;
	raw_inode.pino = dir_f->ino;
	raw_inode.version = 1;
	raw_inode.mode = dir_mode;
	/*m* raw_inode.uid = current->fsuid;
	raw_inode.gid = current->fsgid;*/
	raw_inode.atime = CURRENT_TIME;
	raw_inode.mtime = raw_inode.atime;
	raw_inode.ctime = raw_inode.atime;
	raw_inode.offset = 0;
	raw_inode.dsize = 0;
	raw_inode.rsize = 0;
	raw_inode.nsize = len;
	raw_inode.nlink = 1;
	raw_inode.spare = 0;
	raw_inode.rename = 0;
	raw_inode.deleted = 0;

	/* Write the new node to the flash.  */
	if (jffs_write_node(c, node, &raw_inode, name, 0) < 0) {
		D(printk("jffs_mkdir(): jffs_write_node() failed.\n"));
		kfree(node);
		DJM(no_jffs_node--);
		result = -1;
		goto jffs_mkdir_end;
	}

	/* Insert the new node into the file system.  */
	result = jffs_insert_node(c, 0, &raw_inode, name, node);

jffs_mkdir_end:
	iput(dir);
	return result;
} /* jffs_mkdir()  */

/* Rename a file.  */
int jffs_rename(struct inode *old_dir, const char *old_name, int old_len,
            struct inode *new_dir, const char *new_name, int new_len,
            int must_be_dir)
{
	struct jffs_raw_inode raw_inode;
	struct jffs_control *c;
	struct jffs_file *old_dir_f;
	struct jffs_file *new_dir_f;
	struct jffs_file *del_f;
	struct jffs_file *f;
	struct jffs_node *node;
	struct inode *inode;
	int result = 0;
	__u32 rename_data = 0;

	D2(printk("***jffs_rename()\n"));

	if (!old_dir || !old_name || !new_dir || !new_name) {
		D(printk("jffs_rename(): old_dir: 0x%p, old_name: 0x%p, "
			 "new_dir: 0x%p, new_name: 0x%p\n",
			 old_dir, old_name, new_dir, new_name));
		return -1;
	}

	c = (struct jffs_control *)old_dir->i_sb->u.generic_sbp;
	ASSERT(if (!c) {
		printk(KERN_ERR "jffs_rename(): The old_dir inode "
		       "didn't have a reference to a jffs_file struct\n");
		return -1;
	});

	if (!JFFS_ENOUGH_SPACE(c->fmc)) {
		D1(printk("jffs_rename(): Free size = %u\n",
			  jffs_free_size1(c->fmc) + jffs_free_size2(c->fmc)));
		/*m* D(printk(KERN_NOTICE "JFFS: No space left on device\n"));*/
		D(printk("JFFS: No space left on device\n"));
		return -ENOSPC;
	}

	/*while (c->rename_lock) {
		sleep_on(&c->rename_wait);
	}
	c->rename_lock = 1;*/

	/* Check the lengths of the names.  */
	if ((old_len > JFFS_MAX_NAME_LEN) || (new_len > JFFS_MAX_NAME_LEN)) {
		result = -ENAMETOOLONG;
		goto jffs_rename_end;
	}
	/* Find the the old directory.  */
	if (!(old_dir_f = (struct jffs_file *)old_dir->u.generic_ip)) {
		D(printk("jffs_rename(): Old dir invalid.\n"));
		result = -ENOTDIR;
		goto jffs_rename_end;
	}
	/* See if it really is a directory.  */
	if (!S_ISDIR(old_dir_f->mode)) {
		D(printk("jffs_rename(): old_dir is not a directory.\n"));
		result = -ENOTDIR;
		goto jffs_rename_end;
	}
	/* Try to find the file to move.  */
	if (!(f = jffs_find_child(old_dir_f, old_name, old_len))) {
		result = -ENOENT;
		goto jffs_rename_end;
	}
	/* Try to find the new directory's node.  */
	if (!(new_dir_f = (struct jffs_file *)new_dir->u.generic_ip)) {
		D(printk("jffs_rename(): New dir invalid.\n"));
		result = -ENOTDIR;
		goto jffs_rename_end;
	}
	/* See if the node really is a directory.  */
	if (!S_ISDIR(new_dir_f->mode)) {
		D(printk("jffs_rename(): The new position of the node "
			 "is not a directory.\n"));
		result = -ENOTDIR;
		goto jffs_rename_end;
	}

	/* Create a node and initialize as much as needed.  */
	if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
						  GFP_KERNEL))) {
		D(printk("jffs_rename(): Allocation failed: node == 0\n"));
		result = -ENOMEM;
		goto jffs_rename_end;
	}
	DJM(no_jffs_node++);
	node->data_offset = 0;
	node->removed_size = 0;

	/* Initialize the raw inode.  */
	raw_inode.magic = JFFS_MAGIC_BITMASK;
	raw_inode.ino = f->ino;
	raw_inode.pino = new_dir_f->ino;
	raw_inode.version = f->highest_version + 1;
	raw_inode.mode = f->mode;
	/*raw_inode.uid = current->fsuid;
	raw_inode.gid = current->fsgid;*/
#if 0
	raw_inode.uid = f->uid;
	raw_inode.gid = f->gid;
#endif
	raw_inode.atime = CURRENT_TIME;
	raw_inode.mtime = raw_inode.atime;
	raw_inode.ctime = f->ctime;
	raw_inode.offset = 0;
	raw_inode.dsize = 0;
	raw_inode.rsize = 0;
	raw_inode.nsize = new_len;
	raw_inode.nlink = f->nlink;
	raw_inode.spare = 0;
	raw_inode.rename = 0;
	raw_inode.deleted = 0;

	/* See if there already exists a file with the same name as
	   new_name.  */
	if ((del_f = jffs_find_child(new_dir_f, new_name, new_len))) {
		raw_inode.rename = 1;
		/*raw_inode.mode = del_f->ino;*/
	}

	/* Write the new node to the flash memory.  */
	if ((result = jffs_write_node(c, node, &raw_inode, new_name,
				      (unsigned char*)&rename_data)) < 0) {
		D(printk("jffs_rename(): Failed to write node to flash.\n"));
		kfree(node);
		DJM(no_jffs_node--);
		goto jffs_rename_end;
	}

	if (raw_inode.rename) {
		/* The file with the same name must be deleted.  */
		c->fmc->no_call_gc = 1;
		if ((result = jffs_remove(new_dir, new_name, new_len,
				          del_f->mode, 0)) < 0) {
			/* This is really bad.  */
			/*m* printk(KERN_ERR "JFFS: An error occurred in "
			       "rename().\n");*/
			printk("JFFS: An error occurred in "
			       "rename().\n");

		}
		c->fmc->no_call_gc = 0;
	}

	if (old_dir_f != new_dir_f) {
		/* Remove the file from its old position in the
		   filesystem tree.  */
		jffs_unlink_file_from_tree(f);
	}

	/* Insert the new node into the file system.  */
	if ((result = jffs_insert_node(c, f, &raw_inode,
				       new_name, node)) < 0) {
		/*m* D(printk(KERN_ERR "jffs_rename(): jffs_insert_node() "
			 "failed!\n"));*/
		D(printk("jffs_rename(): jffs_insert_node() "
			 "failed!\n"));
	}

	if (old_dir_f != new_dir_f) {
		/* Insert the file to its new position in the
		   file system.  */
		jffs_insert_file_into_tree(f);
	}

	/* This is a kind of update of the inode we're about to make
	   here.  This is what they do in ext2fs.  Kind of.  */
	if ((inode = iget(new_dir->i_sb, f->ino))) {
		inode->i_ctime = CURRENT_TIME;
		inode->i_dirt = 1;
		iput(inode);
	}

jffs_rename_end:
	iput(old_dir);
	iput(new_dir);
	c->rename_lock = 0;
	/*m* wake_up(&c->rename_wait);*/
	return result;
} /* jffs_rename()  */