自学教程：C++ BEFS_I函数代码示例

static struct dentry *befs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){	struct inode *inode = NULL;	struct super_block *sb = dir->i_sb;	befs_data_stream *ds = &BEFS_I(dir)->i_data.ds;	befs_off_t offset;	int ret;	int utfnamelen;	char *utfname;	const char *name = dentry->d_name.name;	befs_debug(sb, "---> befs_lookup() "		   "name %s inode %ld", dentry->d_name.name, dir->i_ino);	/* Convert to UTF-8 */	if (BEFS_SB(sb)->nls) {		ret =		    befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen);		if (ret < 0) {			befs_debug(sb, "<--- befs_lookup() ERROR");			return ERR_PTR(ret);		}		ret = befs_btree_find(sb, ds, utfname, &offset);		kfree(utfname);	} else {		ret = befs_btree_find(sb, ds, dentry->d_name.name, &offset);	}	if (ret == BEFS_BT_NOT_FOUND) {		befs_debug(sb, "<--- befs_lookup() %s not found",			   dentry->d_name.name);		return ERR_PTR(-ENOENT);	} else if (ret != BEFS_OK || offset == 0) {		befs_warning(sb, "<--- befs_lookup() Error");		return ERR_PTR(-ENODATA);	}	inode = iget(dir->i_sb, (ino_t) offset);	if (!inode)		return ERR_PTR(-EACCES);	d_add(dentry, inode);	befs_debug(sb, "<--- befs_lookup()");	return NULL;}

static struct dentry *befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags){	struct inode *inode;	struct super_block *sb = dir->i_sb;	const befs_data_stream *ds = &BEFS_I(dir)->i_data.ds;	befs_off_t offset;	int ret;	int utfnamelen;	char *utfname;	const char *name = dentry->d_name.name;	befs_debug(sb, "---> %s name %pd inode %ld", __func__,		   dentry, dir->i_ino);	/* Convert to UTF-8 */	if (BEFS_SB(sb)->nls) {		ret =		    befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen);		if (ret < 0) {			befs_debug(sb, "<--- %s ERROR", __func__);			return ERR_PTR(ret);		}		ret = befs_btree_find(sb, ds, utfname, &offset);		kfree(utfname);	} else {		ret = befs_btree_find(sb, ds, name, &offset);	}	if (ret == BEFS_BT_NOT_FOUND) {		befs_debug(sb, "<--- %s %pd not found", __func__, dentry);		d_add(dentry, NULL);		return ERR_PTR(-ENOENT);	} else if (ret != BEFS_OK || offset == 0) {		befs_error(sb, "<--- %s Error", __func__);		return ERR_PTR(-ENODATA);	}	inode = befs_iget(dir->i_sb, (ino_t) offset);	if (IS_ERR(inode))		return ERR_CAST(inode);	d_add(dentry, inode);	befs_debug(sb, "<--- %s", __func__);	return NULL;}

static intbefs_get_block(struct inode *inode, sector_t block,	       struct buffer_head *bh_result, int create){	struct super_block *sb = inode->i_sb;	befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;	befs_block_run run = BAD_IADDR;	int res = 0;	ulong disk_off;	befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",		   inode->i_ino, block);	if (block < 0) {		befs_error(sb, "befs_get_block() was asked for a block "			   "number less than zero: block %ld in inode %lu",			   block, inode->i_ino);		return -EIO;	}	if (create) {		befs_error(sb, "befs_get_block() was asked to write to "			   "block %ld in inode %lu", block, inode->i_ino);		return -EPERM;	}	res = befs_fblock2brun(sb, ds, block, &run);	if (res != BEFS_OK) {		befs_error(sb,			   "<--- befs_get_block() for inode %lu, block "			   "%ld ERROR", inode->i_ino, block);		return -EFBIG;	}	disk_off = (ulong) iaddr2blockno(sb, &run);	map_bh(bh_result, inode->i_sb, disk_off);	befs_debug(sb, "<--- befs_get_block() for inode %lu, block %ld, "		   "disk address %lu", inode->i_ino, block, disk_off);	return 0;}

static intbefs_get_block(struct inode *inode, sector_t block,	       struct buffer_head *bh_result, int create){	struct super_block *sb = inode->i_sb;	befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;	befs_block_run run = BAD_IADDR;	int res;	ulong disk_off;	befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",		   (unsigned long)inode->i_ino, (long)block);	if (create) {		befs_error(sb, "befs_get_block() was asked to write to "			   "block %ld in inode %lu", (long)block,			   (unsigned long)inode->i_ino);		return -EPERM;	}	res = befs_fblock2brun(sb, ds, block, &run);	if (res != BEFS_OK) {		befs_error(sb,			   "<--- %s for inode %lu, block %ld ERROR",			   __func__, (unsigned long)inode->i_ino,			   (long)block);		return -EFBIG;	}	disk_off = (ulong) iaddr2blockno(sb, &run);	map_bh(bh_result, inode->i_sb, disk_off);	befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu",		  __func__, (unsigned long)inode->i_ino, (long)block,		  (unsigned long)disk_off);	return 0;}

static struct inode *befs_iget(struct super_block *sb, unsigned long ino){	struct buffer_head *bh = NULL;	befs_inode *raw_inode = NULL;	befs_sb_info *befs_sb = BEFS_SB(sb);	befs_inode_info *befs_ino = NULL;	struct inode *inode;	long ret = -EIO;	befs_debug(sb, "---> befs_read_inode() " "inode = %lu", ino);	inode = iget_locked(sb, ino);	if (!inode)		return ERR_PTR(-ENOMEM);	if (!(inode->i_state & I_NEW))		return inode;	befs_ino = BEFS_I(inode);	/* convert from vfs's inode number to befs's inode number */	befs_ino->i_inode_num = blockno2iaddr(sb, inode->i_ino);	befs_debug(sb, "  real inode number [%u, %hu, %hu]",		   befs_ino->i_inode_num.allocation_group,		   befs_ino->i_inode_num.start, befs_ino->i_inode_num.len);	bh = befs_bread(sb, inode->i_ino);	if (!bh) {		befs_error(sb, "unable to read inode block - "			   "inode = %lu", inode->i_ino);		goto unacquire_none;	}	raw_inode = (befs_inode *) bh->b_data;	befs_dump_inode(sb, raw_inode);	if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) {		befs_error(sb, "Bad inode: %lu", inode->i_ino);		goto unacquire_bh;	}	inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode);	/*	 * set uid and gid.  But since current BeOS is single user OS, so	 * you can change by "uid" or "gid" options.	 */   	inode->i_uid = befs_sb->mount_opts.use_uid ?		befs_sb->mount_opts.uid :		make_kuid(&init_user_ns, fs32_to_cpu(sb, raw_inode->uid));	inode->i_gid = befs_sb->mount_opts.use_gid ?		befs_sb->mount_opts.gid :		make_kgid(&init_user_ns, fs32_to_cpu(sb, raw_inode->gid));	set_nlink(inode, 1);	/*	 * BEFS's time is 64 bits, but current VFS is 32 bits...	 * BEFS don't have access time. Nor inode change time. VFS	 * doesn't have creation time.	 * Also, the lower 16 bits of the last_modified_time and 	 * create_time are just a counter to help ensure uniqueness	 * for indexing purposes. (PFD, page 54)	 */	inode->i_mtime.tv_sec =	    fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16;	inode->i_mtime.tv_nsec = 0;   /* lower 16 bits are not a time */		inode->i_ctime = inode->i_mtime;	inode->i_atime = inode->i_mtime;	befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num);	befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent);	befs_ino->i_attribute = fsrun_to_cpu(sb, raw_inode->attributes);	befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags);	if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){		inode->i_size = 0;		inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE;		strncpy(befs_ino->i_data.symlink, raw_inode->data.symlink,			BEFS_SYMLINK_LEN - 1);		befs_ino->i_data.symlink[BEFS_SYMLINK_LEN - 1] = '/0';	} else {		int num_blks;		befs_ino->i_data.ds =		    fsds_to_cpu(sb, &raw_inode->data.datastream);		num_blks = befs_count_blocks(sb, &befs_ino->i_data.ds);		inode->i_blocks =		    num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE);		inode->i_size = befs_ino->i_data.ds.size;	}	inode->i_mapping->a_ops = &befs_aops;	if (S_ISREG(inode->i_mode)) {//.........这里部分代码省略.........

static void befs_i_callback(struct rcu_head *head){	struct inode *inode = container_of(head, struct inode, i_rcu);        kmem_cache_free(befs_inode_cachep, BEFS_I(inode));}

static intbefs_readdir(struct file *file, struct dir_context *ctx){	struct inode *inode = file_inode(file);	struct super_block *sb = inode->i_sb;	befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;	befs_off_t value;	int result;	size_t keysize;	unsigned char d_type;	char keybuf[BEFS_NAME_LEN + 1];	const char *dirname = file->f_path.dentry->d_name.name;	befs_debug(sb, "---> befs_readdir() "		   "name %s, inode %ld, ctx->pos %Ld",		   dirname, inode->i_ino, ctx->pos);more:	result = befs_btree_read(sb, ds, ctx->pos, BEFS_NAME_LEN + 1,				 keybuf, &keysize, &value);	if (result == BEFS_ERR) {		befs_debug(sb, "<--- befs_readdir() ERROR");		befs_error(sb, "IO error reading %s (inode %lu)",			   dirname, inode->i_ino);		return -EIO;	} else if (result == BEFS_BT_END) {		befs_debug(sb, "<--- befs_readdir() END");		return 0;	} else if (result == BEFS_BT_EMPTY) {		befs_debug(sb, "<--- befs_readdir() Empty directory");		return 0;	}	d_type = DT_UNKNOWN;	/* Convert to NLS */	if (BEFS_SB(sb)->nls) {		char *nlsname;		int nlsnamelen;		result =		    befs_utf2nls(sb, keybuf, keysize, &nlsname, &nlsnamelen);		if (result < 0) {			befs_debug(sb, "<--- befs_readdir() ERROR");			return result;		}		if (!dir_emit(ctx, nlsname, nlsnamelen,				 (ino_t) value, d_type)) {			kfree(nlsname);			return 0;		}		kfree(nlsname);	} else {		if (!dir_emit(ctx, keybuf, keysize,				 (ino_t) value, d_type))			return 0;	}	ctx->pos++;	goto more;	befs_debug(sb, "<--- befs_readdir() pos %Ld", ctx->pos);	return 0;}

static voidbefs_destroy_inode(struct inode *inode){        kmem_cache_free(befs_inode_cachep, BEFS_I(inode));}

static intbefs_readdir(struct file *filp, void *dirent, filldir_t filldir){	struct inode *inode = filp->f_dentry->d_inode;	struct super_block *sb = inode->i_sb;	befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;	befs_off_t value;	int result;	size_t keysize;	unsigned char d_type;	char keybuf[BEFS_NAME_LEN + 1];	char *nlsname;	int nlsnamelen;	const char *dirname = filp->f_dentry->d_name.name;	befs_debug(sb, "---> befs_readdir() "		   "name %s, inode %ld, filp->f_pos %Ld",		   dirname, inode->i_ino, filp->f_pos);	result = befs_btree_read(sb, ds, filp->f_pos, BEFS_NAME_LEN + 1,				 keybuf, &keysize, &value);	if (result == BEFS_ERR) {		befs_debug(sb, "<--- befs_readdir() ERROR");		befs_error(sb, "IO error reading %s (inode %lu)",			   dirname, inode->i_ino);		return -EIO;	} else if (result == BEFS_BT_END) {		befs_debug(sb, "<--- befs_readdir() END");		return 0;	} else if (result == BEFS_BT_EMPTY) {		befs_debug(sb, "<--- befs_readdir() Empty directory");		return 0;	}	d_type = DT_UNKNOWN;	/* Convert to NLS */	if (BEFS_SB(sb)->nls) {		result =		    befs_utf2nls(sb, keybuf, keysize, &nlsname, &nlsnamelen);		if (result < 0) {			befs_debug(sb, "<--- befs_readdir() ERROR");			return result;		}		result = filldir(dirent, nlsname, nlsnamelen, filp->f_pos,				 (ino_t) value, d_type);		kfree(nlsname);	} else {		result = filldir(dirent, keybuf, keysize, filp->f_pos,				 (ino_t) value, d_type);	}	filp->f_pos++;	befs_debug(sb, "<--- befs_readdir() filp->f_pos %Ld", filp->f_pos);	return 0;}

static void befs_i_callback(struct rcu_head *head){	struct inode *inode = container_of(head, struct inode, i_rcu);	INIT_LIST_HEAD(&inode->i_dentry);        kmem_cache_free(befs_inode_cachep, BEFS_I(inode));}