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

static int gfs2_readpages(struct file *file, struct address_space *mapping,			  struct list_head *pages, unsigned nr_pages){	struct inode *inode = mapping->host;	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_sbd *sdp = GFS2_SB(inode);	struct gfs2_holder gh;	int ret;	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);	ret = gfs2_glock_nq(&gh);	if (unlikely(ret))		goto out_uninit;	if (!gfs2_is_stuffed(ip))		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);	gfs2_glock_dq(&gh);out_uninit:	gfs2_holder_uninit(&gh);	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))		ret = -EIO;	return ret;}

static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,				    struct file *file, int *opened){	struct inode *inode;	struct dentry *d;	struct gfs2_holder gh;	struct gfs2_glock *gl;	int error;	inode = gfs2_lookupi(dir, &dentry->d_name, 0);	if (!inode)		return NULL;	if (IS_ERR(inode))		return ERR_CAST(inode);	gl = GFS2_I(inode)->i_gl;	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);	if (error) {		iput(inode);		return ERR_PTR(error);	}	d = d_splice_alias(inode, dentry);	if (IS_ERR(d)) {		iput(inode);		gfs2_glock_dq_uninit(&gh);		return d;	}	if (file && S_ISREG(inode->i_mode))		error = finish_open(file, dentry, gfs2_open_common, opened);	gfs2_glock_dq_uninit(&gh);	if (error) {		dput(d);		return ERR_PTR(error);	}	return d;}

static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence){	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);	struct gfs2_holder i_gh;	loff_t error;	switch (whence) {	case SEEK_END:		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,					   &i_gh);		if (!error) {			error = generic_file_llseek(file, offset, whence);			gfs2_glock_dq_uninit(&i_gh);		}		break;	case SEEK_DATA:		error = gfs2_seek_data(file, offset);		break;	case SEEK_HOLE:		error = gfs2_seek_hole(file, offset);		break;	case SEEK_CUR:	case SEEK_SET:		/*		 * These don't reference inode->i_size and don't depend on the		 * block mapping, so we don't need the glock.		 */		error = generic_file_llseek(file, offset, whence);		break;	default:		error = -EINVAL;	}	return error;}

static int gfs2_unlink_inode(struct gfs2_inode *dip,			     const struct dentry *dentry,			     struct buffer_head *bh){	struct inode *inode = dentry->d_inode;	struct gfs2_inode *ip = GFS2_I(inode);	int error;	error = gfs2_dir_del(dip, dentry);	if (error)		return error;	ip->i_entries = 0;	inode->i_ctime = CURRENT_TIME;	if (S_ISDIR(inode->i_mode))		clear_nlink(inode);	else		drop_nlink(inode);	mark_inode_dirty(inode);	if (inode->i_nlink == 0)		gfs2_unlink_di(inode);	return 0;}

static int gfs2_mmap(struct file *file, struct vm_area_struct *vma){	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);	if (!(file->f_flags & O_NOATIME) &&	    !IS_NOATIME(&ip->i_inode)) {		struct gfs2_holder i_gh;		int error;		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);		error = gfs2_glock_nq(&i_gh);		if (error == 0) {			file_accessed(file);			gfs2_glock_dq(&i_gh);		}		gfs2_holder_uninit(&i_gh);		if (error)			return error;	}	vma->vm_ops = &gfs2_vm_ops;	return 0;}

static void inode_go_inval(struct gfs2_glock *gl, int flags){	struct gfs2_inode *ip = gl->gl_object;	gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count));	if (flags & DIO_METADATA) {		struct address_space *mapping = gfs2_glock2aspace(gl);		truncate_inode_pages(mapping, 0);		if (ip) {			set_bit(GIF_INVALID, &ip->i_flags);			forget_all_cached_acls(&ip->i_inode);			gfs2_dir_hash_inval(ip);		}	}	if (ip == GFS2_I(gl->gl_sbd->sd_rindex)) {		gfs2_log_flush(gl->gl_sbd, NULL, NORMAL_FLUSH);		gl->gl_sbd->sd_rindex_uptodate = 0;	}	if (ip && S_ISREG(ip->i_inode.i_mode))		truncate_inode_pages(ip->i_inode.i_mapping, 0);}

static struct dentry *gfs2_get_dentry(struct super_block *sb,				      struct gfs2_inum_host *inum){	struct gfs2_sbd *sdp = sb->s_fs_info;	struct inode *inode;	inode = gfs2_ilookup(sb, inum->no_addr);	if (inode) {		if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {			iput(inode);			return ERR_PTR(-ESTALE);		}		goto out_inode;	}	inode = gfs2_lookup_by_inum(sdp, inum->no_addr, &inum->no_formal_ino,				    GFS2_BLKST_DINODE);	if (IS_ERR(inode))		return ERR_CAST(inode);out_inode:	return d_obtain_alias(inode);}

int gfs2_permission(struct inode *inode, int mask){	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_holder i_gh;	int error;	int unlock = 0;	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);		if (error)			return error;		unlock = 1;	}	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))		error = -EACCES;	else		error = generic_permission(inode, mask, gfs2_check_acl);	if (unlock)		gfs2_glock_dq_uninit(&i_gh);	return error;}

static int do_flock(struct file *file, int cmd, struct file_lock *fl){	struct gfs2_file *fp = file->private_data;	struct gfs2_holder *fl_gh = &fp->f_fl_gh;	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);	struct gfs2_glock *gl;	unsigned int state;	int flags;	int error = 0;	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;	mutex_lock(&fp->f_fl_mutex);	gl = fl_gh->gh_gl;	if (gl) {		if (fl_gh->gh_state == state)			goto out;		flock_lock_file_wait(file,				     &(struct file_lock){.fl_type = F_UNLCK});		gfs2_glock_dq_wait(fl_gh);		gfs2_holder_reinit(state, flags, fl_gh);	} else {

static int gfs2_rename(struct inode *odir, struct dentry *odentry,		       struct inode *ndir, struct dentry *ndentry){	struct gfs2_inode *odip = GFS2_I(odir);	struct gfs2_inode *ndip = GFS2_I(ndir);	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);	struct gfs2_inode *nip = NULL;	struct gfs2_sbd *sdp = GFS2_SB(odir);	struct gfs2_holder ghs[5], r_gh;	struct gfs2_rgrpd *nrgd;	unsigned int num_gh;	int dir_rename = 0;	int alloc_required;	unsigned int x;	int error;	if (ndentry->d_inode) {		nip = GFS2_I(ndentry->d_inode);		if (ip == nip)			return 0;	}	/* Make sure we aren't trying to move a dirctory into it's subdir */	if (S_ISDIR(ip->i_inode.i_mode) && odip != ndip) {		dir_rename = 1;		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE, 0,					   &r_gh);		if (error)			goto out;		error = gfs2_ok_to_move(ip, ndip);		if (error)			goto out_gunlock_r;	}	num_gh = 1;	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);	if (odip != ndip) {		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);		num_gh++;	}	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);	num_gh++;	if (nip) {		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);		num_gh++;		/* grab the resource lock for unlink flag twiddling 		 * this is the case of the target file already existing		 * so we unlink before doing the rename		 */		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr);		if (nrgd)			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);	}	error = gfs2_glock_nq_m(num_gh, ghs);	if (error)		goto out_uninit;	/* Check out the old directory */	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);	if (error)		goto out_gunlock;	/* Check out the new directory */	if (nip) {		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);		if (error)			goto out_gunlock;		if (S_ISDIR(nip->i_inode.i_mode)) {			if (nip->i_di.di_entries < 2) {				if (gfs2_consist_inode(nip))					gfs2_dinode_print(nip);				error = -EIO;				goto out_gunlock;			}			if (nip->i_di.di_entries > 2) {				error = -ENOTEMPTY;				goto out_gunlock;			}		}	} else {		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);		if (error)			goto out_gunlock;		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);		switch (error) {		case -ENOENT:			error = 0;			break;		case 0:			error = -EEXIST;		default://.........这里部分代码省略.........

struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,			   unsigned int mode, dev_t dev){	struct inode *inode = NULL;	struct gfs2_inode *dip = ghs->gh_gl->gl_object;	struct inode *dir = &dip->i_inode;	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);	struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };	int error;	u64 generation;	struct buffer_head *bh = NULL;	if (!name->len || name->len > GFS2_FNAMESIZE)		return ERR_PTR(-ENAMETOOLONG);	gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);	error = gfs2_glock_nq(ghs);	if (error)		goto fail;	error = create_ok(dip, name, mode);	if (error)		goto fail_gunlock;	error = alloc_dinode(dip, &inum.no_addr, &generation);	if (error)		goto fail_gunlock;	inum.no_formal_ino = generation;	error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,				  LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);	if (error)		goto fail_gunlock;	error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);	if (error)		goto fail_gunlock2;	inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,				  inum.no_formal_ino);	if (IS_ERR(inode))		goto fail_gunlock2;	error = gfs2_inode_refresh(GFS2_I(inode));	if (error)		goto fail_gunlock2;	error = gfs2_acl_create(dip, inode);	if (error)		goto fail_gunlock2;	error = gfs2_security_init(dip, GFS2_I(inode));	if (error)		goto fail_gunlock2;	error = link_dinode(dip, name, GFS2_I(inode));	if (error)		goto fail_gunlock2;	if (bh)		brelse(bh);	return inode;fail_gunlock2:	gfs2_glock_dq_uninit(ghs + 1);	if (inode && !IS_ERR(inode))		iput(inode);fail_gunlock:	gfs2_glock_dq(ghs);fail:	if (bh)		brelse(bh);	return ERR_PTR(error);}static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr){	struct inode *inode = &ip->i_inode;	struct buffer_head *dibh;	int error;	error = gfs2_meta_inode_buffer(ip, &dibh);	if (error)		return error;	if ((attr->ia_valid & ATTR_SIZE) &&	    attr->ia_size != i_size_read(inode)) {		error = vmtruncate(inode, attr->ia_size);		if (error)			return error;	}	setattr_copy(inode, attr);	mark_inode_dirty(inode);	gfs2_assert_warn(GFS2_SB(inode), !error);	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	gfs2_dinode_out(ip, dibh->b_data);	brelse(dibh);	return 0;//.........这里部分代码省略.........

struct inode *gfs2_inode_lookup(struct super_block *sb,				unsigned int type,				u64 no_addr,				u64 no_formal_ino){	struct inode *inode;	struct gfs2_inode *ip;	struct gfs2_glock *io_gl = NULL;	int error;	inode = gfs2_iget(sb, no_addr);	ip = GFS2_I(inode);	if (!inode)		return ERR_PTR(-ENOBUFS);	if (inode->i_state & I_NEW) {		struct gfs2_sbd *sdp = GFS2_SB(inode);		ip->i_no_formal_ino = no_formal_ino;		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);		if (unlikely(error))			goto fail;		ip->i_gl->gl_object = ip;		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);		if (unlikely(error))			goto fail_put;		set_bit(GIF_INVALID, &ip->i_flags);		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);		if (unlikely(error))			goto fail_iopen;		ip->i_iopen_gh.gh_gl->gl_object = ip;		gfs2_glock_put(io_gl);		io_gl = NULL;		if ((type == DT_UNKNOWN) && (no_formal_ino == 0))			goto gfs2_nfsbypass;		inode->i_mode = DT2IF(type);		/*		 * We must read the inode in order to work out its type in		 * this case. Note that this doesn't happen often as we normally		 * know the type beforehand. This code path only occurs during		 * unlinked inode recovery (where it is safe to do this glock,		 * which is not true in the general case).		 */		if (type == DT_UNKNOWN) {			struct gfs2_holder gh;			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);			if (unlikely(error))				goto fail_glock;			/* Inode is now uptodate */			gfs2_glock_dq_uninit(&gh);		}		gfs2_set_iop(inode);	}gfs2_nfsbypass:	return inode;fail_glock:	gfs2_glock_dq(&ip->i_iopen_gh);fail_iopen:	if (io_gl)		gfs2_glock_put(io_gl);fail_put:	if (inode->i_state & I_NEW)		ip->i_gl->gl_object = NULL;	gfs2_glock_put(ip->i_gl);fail:	if (inode->i_state & I_NEW)		iget_failed(inode);	else		iput(inode);	return ERR_PTR(error);}

static int gfs2_write_begin(struct file *file, struct address_space *mapping,			    loff_t pos, unsigned len, unsigned flags,			    struct page **pagep, void **fsdata){	struct gfs2_inode *ip = GFS2_I(mapping->host);	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;	int alloc_required;	int error = 0;	struct gfs2_qadata *qa = NULL;	pgoff_t index = pos >> PAGE_CACHE_SHIFT;	unsigned from = pos & (PAGE_CACHE_SIZE - 1);	struct page *page;	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);	error = gfs2_glock_nq(&ip->i_gh);	if (unlikely(error))		goto out_uninit;	if (&ip->i_inode == sdp->sd_rindex) {		error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,					   GL_NOCACHE, &m_ip->i_gh);		if (unlikely(error)) {			gfs2_glock_dq(&ip->i_gh);			goto out_uninit;		}	}	alloc_required = gfs2_write_alloc_required(ip, pos, len);	if (alloc_required || gfs2_is_jdata(ip))		gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);	if (alloc_required) {		qa = gfs2_qadata_get(ip);		if (!qa) {			error = -ENOMEM;			goto out_unlock;		}		error = gfs2_quota_lock_check(ip);		if (error)			goto out_alloc_put;		error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);		if (error)			goto out_qunlock;	}	rblocks = RES_DINODE + ind_blocks;	if (gfs2_is_jdata(ip))		rblocks += data_blocks ? data_blocks : 1;	if (ind_blocks || data_blocks)		rblocks += RES_STATFS + RES_QUOTA;	if (&ip->i_inode == sdp->sd_rindex)		rblocks += 2 * RES_STATFS;	if (alloc_required)		rblocks += gfs2_rg_blocks(ip);	error = gfs2_trans_begin(sdp, rblocks,				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);	if (error)		goto out_trans_fail;	error = -ENOMEM;	flags |= AOP_FLAG_NOFS;	page = grab_cache_page_write_begin(mapping, index, flags);	*pagep = page;	if (unlikely(!page))		goto out_endtrans;	if (gfs2_is_stuffed(ip)) {		error = 0;		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {			error = gfs2_unstuff_dinode(ip, page);			if (error == 0)				goto prepare_write;		} else if (!PageUptodate(page)) {			error = stuffed_readpage(ip, page);		}		goto out;	}prepare_write:	error = __block_write_begin(page, from, len, gfs2_block_map);out:	if (error == 0)		return 0;	unlock_page(page);	page_cache_release(page);	gfs2_trans_end(sdp);	if (pos + len > ip->i_inode.i_size)		gfs2_trim_blocks(&ip->i_inode);	goto out_trans_fail;out_endtrans:	gfs2_trans_end(sdp);out_trans_fail://.........这里部分代码省略.........

static int gfs2_write_begin(struct file *file, struct address_space *mapping,			    loff_t pos, unsigned len, unsigned flags,			    struct page **pagep, void **fsdata){	struct gfs2_inode *ip = GFS2_I(mapping->host);	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;	unsigned requested = 0;	int alloc_required;	int error = 0;	pgoff_t index = pos >> PAGE_CACHE_SHIFT;	unsigned from = pos & (PAGE_CACHE_SIZE - 1);	struct page *page;	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);	error = gfs2_glock_nq(&ip->i_gh);	if (unlikely(error))		goto out_uninit;	if (&ip->i_inode == sdp->sd_rindex) {		error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,					   GL_NOCACHE, &m_ip->i_gh);		if (unlikely(error)) {			gfs2_glock_dq(&ip->i_gh);			goto out_uninit;		}	}	alloc_required = gfs2_write_alloc_required(ip, pos, len);	if (alloc_required || gfs2_is_jdata(ip))		gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);	if (alloc_required) {		struct gfs2_alloc_parms ap = { .aflags = 0, };		requested = data_blocks + ind_blocks;		ap.target = requested;		error = gfs2_quota_lock_check(ip, &ap);		if (error)			goto out_unlock;		error = gfs2_inplace_reserve(ip, &ap);		if (error)			goto out_qunlock;	}	rblocks = RES_DINODE + ind_blocks;	if (gfs2_is_jdata(ip))		rblocks += data_blocks ? data_blocks : 1;	if (ind_blocks || data_blocks)		rblocks += RES_STATFS + RES_QUOTA;	if (&ip->i_inode == sdp->sd_rindex)		rblocks += 2 * RES_STATFS;	if (alloc_required)		rblocks += gfs2_rg_blocks(ip, requested);	error = gfs2_trans_begin(sdp, rblocks,				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);	if (error)		goto out_trans_fail;	error = -ENOMEM;	flags |= AOP_FLAG_NOFS;	page = grab_cache_page_write_begin(mapping, index, flags);	*pagep = page;	if (unlikely(!page))		goto out_endtrans;	if (gfs2_is_stuffed(ip)) {		error = 0;		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {			error = gfs2_unstuff_dinode(ip, page);			if (error == 0)				goto prepare_write;		} else if (!PageUptodate(page)) {			error = stuffed_readpage(ip, page);		}		goto out;	}prepare_write:	error = __block_write_begin(page, from, len, gfs2_block_map);out:	if (error == 0)		return 0;	unlock_page(page);	page_cache_release(page);	gfs2_trans_end(sdp);	if (pos + len > ip->i_inode.i_size)		gfs2_trim_blocks(&ip->i_inode);	goto out_trans_fail;out_endtrans:	gfs2_trans_end(sdp);out_trans_fail:	if (alloc_required) {		gfs2_inplace_release(ip);out_qunlock://.........这里部分代码省略.........

static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,			      const struct iovec *iov, loff_t offset,			      unsigned long nr_segs){	struct file *file = iocb->ki_filp;	struct inode *inode = file->f_mapping->host;	struct address_space *mapping = inode->i_mapping;	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_holder gh;	int rv;	/*	 * Deferred lock, even if its a write, since we do no allocation	 * on this path. All we need change is atime, and this lock mode	 * ensures that other nodes have flushed their buffered read caches	 * (i.e. their page cache entries for this inode). We do not,	 * unfortunately have the option of only flushing a range like	 * the VFS does.	 */	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh);	rv = gfs2_glock_nq(&gh);	if (rv)		return rv;	rv = gfs2_ok_for_dio(ip, rw, offset);	if (rv != 1)		goto out; /* dio not valid, fall back to buffered i/o */	/*	 * Now since we are holding a deferred (CW) lock at this point, you	 * might be wondering why this is ever needed. There is a case however	 * where we've granted a deferred local lock against a cached exclusive	 * glock. That is ok provided all granted local locks are deferred, but	 * it also means that it is possible to encounter pages which are	 * cached and possibly also mapped. So here we check for that and sort	 * them out ahead of the dio. The glock state machine will take care of	 * everything else.	 *	 * If in fact the cached glock state (gl->gl_state) is deferred (CW) in	 * the first place, mapping->nr_pages will always be zero.	 */	if (mapping->nrpages) {		loff_t lstart = offset & (PAGE_CACHE_SIZE - 1);		loff_t len = iov_length(iov, nr_segs);		loff_t end = PAGE_ALIGN(offset + len) - 1;		rv = 0;		if (len == 0)			goto out;		if (test_and_clear_bit(GIF_SW_PAGED, &ip->i_flags))			unmap_shared_mapping_range(ip->i_inode.i_mapping, offset, len);		rv = filemap_write_and_wait_range(mapping, lstart, end);		if (rv)			goto out;		if (rw == WRITE)			truncate_inode_pages_range(mapping, lstart, end);	}	rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,				  offset, nr_segs, gfs2_get_block_direct,				  NULL, NULL, 0);out:	gfs2_glock_dq(&gh);	gfs2_holder_uninit(&gh);	return rv;}

static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,		       struct gfs2_inode *ip, struct gfs2_diradd *da){	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);	struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };	int error;	if (da->nr_blocks) {		error = gfs2_quota_lock_check(dip);		if (error)			goto fail_quota_locks;		error = gfs2_inplace_reserve(dip, &ap);		if (error)			goto fail_quota_locks;		error = gfs2_trans_begin(sdp, gfs2_trans_da_blks(dip, da, 2), 0);		if (error)			goto fail_ipreserv;	} else {		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);		if (error)			goto fail_quota_locks;	}	error = gfs2_dir_add(&dip->i_inode, name, ip, da);	if (error)		goto fail_end_trans;fail_end_trans:	gfs2_trans_end(sdp);fail_ipreserv:	gfs2_inplace_release(dip);fail_quota_locks:	gfs2_quota_unlock(dip);	return error;}static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,		    void *fs_info){	const struct xattr *xattr;	int err = 0;	for (xattr = xattr_array; xattr->name != NULL; xattr++) {		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,				       xattr->value_len, 0,				       GFS2_EATYPE_SECURITY);		if (err < 0)			break;	}	return err;}static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,			      const struct qstr *qstr){	return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,					    &gfs2_initxattrs, NULL);}/** * gfs2_create_inode - Create a new inode * @dir: The parent directory * @dentry: The new dentry * @file: If non-NULL, the file which is being opened * @mode: The permissions on the new inode * @dev: For device nodes, this is the device number * @symname: For symlinks, this is the link destination * @size: The initial size of the inode (ignored for directories) * * Returns: 0 on success, or error code */static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,			     struct file *file,			     umode_t mode, dev_t dev, const char *symname,			     unsigned int size, int excl, int *opened){	const struct qstr *name = &dentry->d_name;	struct posix_acl *default_acl, *acl;	struct gfs2_holder ghs[2];	struct inode *inode = NULL;	struct gfs2_inode *dip = GFS2_I(dir), *ip;	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);	struct gfs2_glock *io_gl;	struct dentry *d;	int error;	u32 aflags = 0;	struct gfs2_diradd da = { .bh = NULL, };	if (!name->len || name->len > GFS2_FNAMESIZE)		return -ENAMETOOLONG;	error = gfs2_rs_alloc(dip);	if (error)		return error;	error = gfs2_rindex_update(sdp);	if (error)//.........这里部分代码省略.........

static int gfs2_rmdir(struct inode *dir, struct dentry *dentry){	struct gfs2_inode *dip = GFS2_I(dir);	struct gfs2_sbd *sdp = GFS2_SB(dir);	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);	struct gfs2_holder ghs[3];	struct gfs2_rgrpd *rgd;	int error;	error = gfs2_rindex_update(sdp);	if (error)		return error;	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);	error = gfs2_glock_nq(ghs); /* parent */	if (error)		goto out_parent;	error = gfs2_glock_nq(ghs + 1); /* child */	if (error)		goto out_child;	error = -ENOENT;	if (ip->i_inode.i_nlink == 0)		goto out_rgrp;	error = gfs2_glock_nq(ghs + 2); /* rgrp */	if (error)		goto out_rgrp;	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);	if (error)		goto out_gunlock;	if (ip->i_entries < 2) {		if (gfs2_consist_inode(ip))			gfs2_dinode_print(ip);		error = -EIO;		goto out_gunlock;	}	if (ip->i_entries > 2) {		error = -ENOTEMPTY;		goto out_gunlock;	}	error = gfs2_trans_begin(sdp, 2 * RES_DINODE + 3 * RES_LEAF + RES_RG_BIT, 0);	if (error)		goto out_gunlock;	error = gfs2_rmdiri(dip, &dentry->d_name, ip);	gfs2_trans_end(sdp);out_gunlock:	gfs2_glock_dq(ghs + 2);out_rgrp:	gfs2_holder_uninit(ghs + 2);	gfs2_glock_dq(ghs + 1);out_child:	gfs2_holder_uninit(ghs + 1);	gfs2_glock_dq(ghs);out_parent:	gfs2_holder_uninit(ghs);	return error;}

static int gfs2_unlink(struct inode *dir, struct dentry *dentry){	struct gfs2_inode *dip = GFS2_I(dir);	struct gfs2_sbd *sdp = GFS2_SB(dir);	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);	struct gfs2_holder ghs[3];	struct gfs2_rgrpd *rgd;	int error;	error = gfs2_rindex_update(sdp);	if (error)		return error;	error = -EROFS;	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);	if (!rgd)		goto out_inodes;	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);	error = gfs2_glock_nq(ghs); /* parent */	if (error)		goto out_parent;	error = gfs2_glock_nq(ghs + 1); /* child */	if (error)		goto out_child;	error = -ENOENT;	if (ip->i_inode.i_nlink == 0)		goto out_rgrp;	error = gfs2_glock_nq(ghs + 2); /* rgrp */	if (error)		goto out_rgrp;	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);	if (error)		goto out_gunlock;	error = gfs2_trans_begin(sdp, 2*RES_DINODE + RES_LEAF + RES_RG_BIT, 0);	if (error)		goto out_gunlock;	error = gfs2_dir_del(dip, &dentry->d_name);        if (error)                goto out_end_trans;	error = gfs2_change_nlink(ip, -1);out_end_trans:	gfs2_trans_end(sdp);out_gunlock:	gfs2_glock_dq(ghs + 2);out_rgrp:	gfs2_glock_dq(ghs + 1);out_child:	gfs2_glock_dq(ghs);out_parent:	gfs2_holder_uninit(ghs + 2);out_inodes:	gfs2_holder_uninit(ghs + 1);	gfs2_holder_uninit(ghs);	return error;}

int gfs2_block_map(struct inode *inode, sector_t lblock,		   struct buffer_head *bh_map, int create){	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_sbd *sdp = GFS2_SB(inode);	unsigned int bsize = sdp->sd_sb.sb_bsize;	const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;	const u64 *arr = sdp->sd_heightsize;	__be64 *ptr;	u64 size;	struct metapath mp;	int ret;	int eob;	unsigned int len;	struct buffer_head *bh;	u8 height;	BUG_ON(maxlen == 0);	memset(mp.mp_bh, 0, sizeof(mp.mp_bh));	bmap_lock(ip, create);	clear_buffer_mapped(bh_map);	clear_buffer_new(bh_map);	clear_buffer_boundary(bh_map);	if (gfs2_is_dir(ip)) {		bsize = sdp->sd_jbsize;		arr = sdp->sd_jheightsize;	}	ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);	if (ret)		goto out;	height = ip->i_height;	size = (lblock + 1) * bsize;	while (size > arr[height])		height++;	find_metapath(sdp, lblock, &mp, height);	ret = 1;	if (height > ip->i_height || gfs2_is_stuffed(ip))		goto do_alloc;	ret = lookup_metapath(ip, &mp);	if (ret < 0)		goto out;	if (ret != ip->i_height)		goto do_alloc;	ptr = metapointer(ip->i_height - 1, &mp);	if (*ptr == 0)		goto do_alloc;	map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));	bh = mp.mp_bh[ip->i_height - 1];	len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);	bh_map->b_size = (len << inode->i_blkbits);	if (eob)		set_buffer_boundary(bh_map);	ret = 0;out:	release_metapath(&mp);	bmap_unlock(ip, create);	return ret;do_alloc:	/* All allocations are done here, firstly check create flag */	if (!create) {		BUG_ON(gfs2_is_stuffed(ip));		ret = 0;		goto out;	}	/* At this point ret is the tree depth of already allocated blocks */	ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);	goto out;}

static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,			   struct buffer_head *bh_map, struct metapath *mp,			   const unsigned int sheight,			   const unsigned int height,			   const unsigned int maxlen){	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_sbd *sdp = GFS2_SB(inode);	struct buffer_head *dibh = mp->mp_bh[0];	u64 bn, dblock = 0;	unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;	unsigned dblks = 0;	unsigned ptrs_per_blk;	const unsigned end_of_metadata = height - 1;	int eob = 0;	enum alloc_state state;	__be64 *ptr;	__be64 zero_bn = 0;	BUG_ON(sheight < 1);	BUG_ON(dibh == NULL);	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	if (height == sheight) {		struct buffer_head *bh;		/* Bottom indirect block exists, find unalloced extent size */		ptr = metapointer(end_of_metadata, mp);		bh = mp->mp_bh[end_of_metadata];		dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,					   &eob);		BUG_ON(dblks < 1);		state = ALLOC_DATA;	} else {		/* Need to allocate indirect blocks */		ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;		dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]);		if (height == ip->i_height) {			/* Writing into existing tree, extend tree down */			iblks = height - sheight;			state = ALLOC_GROW_DEPTH;		} else {			/* Building up tree height */			state = ALLOC_GROW_HEIGHT;			iblks = height - ip->i_height;			branch_start = metapath_branch_start(mp);			iblks += (height - branch_start);		}	}	/* start of the second part of the function (state machine) */	blks = dblks + iblks;	i = sheight;	do {		n = blks - alloced;		bn = gfs2_alloc_block(ip, &n);		alloced += n;		if (state != ALLOC_DATA || gfs2_is_jdata(ip))			gfs2_trans_add_unrevoke(sdp, bn, n);		switch (state) {		/* Growing height of tree */		case ALLOC_GROW_HEIGHT:			if (i == 1) {				ptr = (__be64 *)(dibh->b_data +						 sizeof(struct gfs2_dinode));				zero_bn = *ptr;			}			for (; i - 1 < height - ip->i_height && n > 0; i++, n--)				gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);			if (i - 1 == height - ip->i_height) {				i--;				gfs2_buffer_copy_tail(mp->mp_bh[i],						sizeof(struct gfs2_meta_header),						dibh, sizeof(struct gfs2_dinode));				gfs2_buffer_clear_tail(dibh,						sizeof(struct gfs2_dinode) +						sizeof(__be64));				ptr = (__be64 *)(mp->mp_bh[i]->b_data +					sizeof(struct gfs2_meta_header));				*ptr = zero_bn;				state = ALLOC_GROW_DEPTH;				for(i = branch_start; i < height; i++) {					if (mp->mp_bh[i] == NULL)						break;					brelse(mp->mp_bh[i]);					mp->mp_bh[i] = NULL;				}				i = branch_start;			}			if (n == 0)				break;		/* Branching from existing tree */		case ALLOC_GROW_DEPTH:			if (i > 1 && i < height)				gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);			for (; i < height && n > 0; i++, n--)				gfs2_indirect_init(mp, ip->i_gl, i,						   mp->mp_list[i-1], bn++);			if (i == height)//.........这里部分代码省略.........

void gfs2_process_unlinked_inode(struct super_block *sb, u64 no_addr){	struct gfs2_sbd *sdp;	struct gfs2_inode *ip;	struct gfs2_glock *io_gl = NULL;	int error;	struct gfs2_holder gh;	struct inode *inode;	inode = gfs2_iget_skip(sb, no_addr);	if (!inode)		return;	/* If it's not a new inode, someone's using it, so leave it alone. */	if (!(inode->i_state & I_NEW)) {		iput(inode);		return;	}	ip = GFS2_I(inode);	sdp = GFS2_SB(inode);	ip->i_no_formal_ino = -1;	error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);	if (unlikely(error))		goto fail;	ip->i_gl->gl_object = ip;	error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);	if (unlikely(error))		goto fail_put;	set_bit(GIF_INVALID, &ip->i_flags);	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, LM_FLAG_TRY | GL_EXACT,				   &ip->i_iopen_gh);	if (unlikely(error))		goto fail_iopen;	ip->i_iopen_gh.gh_gl->gl_object = ip;	gfs2_glock_put(io_gl);	io_gl = NULL;	inode->i_mode = DT2IF(DT_UNKNOWN);	/*	 * We must read the inode in order to work out its type in	 * this case. Note that this doesn't happen often as we normally	 * know the type beforehand. This code path only occurs during	 * unlinked inode recovery (where it is safe to do this glock,	 * which is not true in the general case).	 */	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, LM_FLAG_TRY,				   &gh);	if (unlikely(error))		goto fail_glock;	/* Inode is now uptodate */	gfs2_glock_dq_uninit(&gh);	gfs2_set_iop(inode);	/* The iput will cause it to be deleted. */	iput(inode);	return;fail_glock:	gfs2_glock_dq(&ip->i_iopen_gh);fail_iopen:	if (io_gl)		gfs2_glock_put(io_gl);fail_put:	ip->i_gl->gl_object = NULL;	gfs2_glock_put(ip->i_gl);fail:	iget_failed(inode);	return;}

static int gfs2_link(struct dentry *old_dentry, struct inode *dir,		     struct dentry *dentry){	struct gfs2_inode *dip = GFS2_I(dir);	struct gfs2_sbd *sdp = GFS2_SB(dir);	struct inode *inode = old_dentry->d_inode;	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_holder ghs[2];	int alloc_required;	int error;	if (S_ISDIR(inode->i_mode))		return -EPERM;	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);	error = gfs2_glock_nq(ghs); /* parent */	if (error)		goto out_parent;	error = gfs2_glock_nq(ghs + 1); /* child */	if (error)		goto out_child;	error = -ENOENT;	if (inode->i_nlink == 0)		goto out_gunlock;	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);	if (error)		goto out_gunlock;	error = gfs2_dir_check(dir, &dentry->d_name, NULL);	switch (error) {	case -ENOENT:		break;	case 0:		error = -EEXIST;	default:		goto out_gunlock;	}	error = -EINVAL;	if (!dip->i_inode.i_nlink)		goto out_gunlock;	error = -EFBIG;	if (dip->i_entries == (u32)-1)		goto out_gunlock;	error = -EPERM;	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))		goto out_gunlock;	error = -EINVAL;	if (!ip->i_inode.i_nlink)		goto out_gunlock;	error = -EMLINK;	if (ip->i_inode.i_nlink == (u32)-1)		goto out_gunlock;	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);	if (error < 0)		goto out_gunlock;	error = 0;	if (alloc_required) {		struct gfs2_qadata *qa = gfs2_qadata_get(dip);		if (!qa) {			error = -ENOMEM;			goto out_gunlock;		}		error = gfs2_quota_lock_check(dip);		if (error)			goto out_alloc;		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres);		if (error)			goto out_gunlock_q;		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +					 gfs2_rg_blocks(dip) +					 2 * RES_DINODE + RES_STATFS +					 RES_QUOTA, 0);		if (error)			goto out_ipres;	} else {		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);		if (error)			goto out_ipres;	}	error = gfs2_dir_add(dir, &dentry->d_name, ip, IF2DT(inode->i_mode));	if (error)		goto out_end_trans;	error = gfs2_change_nlink(ip, +1);out_end_trans:	gfs2_trans_end(sdp);//.........这里部分代码省略.........

struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,				u64 no_addr, u64 no_formal_ino, int non_block){	struct inode *inode;	struct gfs2_inode *ip;	struct gfs2_glock *io_gl = NULL;	int error;	inode = gfs2_iget(sb, no_addr, non_block);	ip = GFS2_I(inode);	if (!inode)		return ERR_PTR(-ENOMEM);	if (inode->i_state & I_NEW) {		struct gfs2_sbd *sdp = GFS2_SB(inode);		ip->i_no_formal_ino = no_formal_ino;		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);		if (unlikely(error))			goto fail;		ip->i_gl->gl_object = ip;		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);		if (unlikely(error))			goto fail_put;		set_bit(GIF_INVALID, &ip->i_flags);		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);		if (unlikely(error))			goto fail_iopen;		ip->i_iopen_gh.gh_gl->gl_object = ip;		gfs2_glock_put(io_gl);		io_gl = NULL;		if (type == DT_UNKNOWN) {			/* Inode glock must be locked already */			error = gfs2_inode_refresh(GFS2_I(inode));			if (error)				goto fail_refresh;		} else {			inode->i_mode = DT2IF(type);		}		gfs2_set_iop(inode);		unlock_new_inode(inode);	}	return inode;fail_refresh:	ip->i_iopen_gh.gh_flags |= GL_NOCACHE;	ip->i_iopen_gh.gh_gl->gl_object = NULL;	gfs2_glock_dq_uninit(&ip->i_iopen_gh);fail_iopen:	if (io_gl)		gfs2_glock_put(io_gl);fail_put:	ip->i_gl->gl_object = NULL;	gfs2_glock_put(ip->i_gl);fail:	iget_failed(inode);	return ERR_PTR(error);}

static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode){	struct gfs2_inode *dip = GFS2_I(dir), *ip;	struct gfs2_sbd *sdp = GFS2_SB(dir);	struct gfs2_holder ghs[2];	struct inode *inode;	struct buffer_head *dibh;	int error;	gfs2_holder_init(dip->i_gl, 0, 0, ghs);	inode = gfs2_createi(ghs, &dentry->d_name, S_IFDIR | mode, 0);	if (IS_ERR(inode)) {		gfs2_holder_uninit(ghs);		return PTR_ERR(inode);	}	ip = ghs[1].gh_gl->gl_object;	ip->i_inode.i_nlink = 2;	ip->i_disksize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);	ip->i_diskflags |= GFS2_DIF_JDATA;	ip->i_entries = 2;	error = gfs2_meta_inode_buffer(ip, &dibh);	if (!gfs2_assert_withdraw(sdp, !error)) {		struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;		struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);		struct qstr str;		gfs2_str2qstr(&str, ".");		gfs2_trans_add_bh(ip->i_gl, dibh, 1);		gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);		dent->de_inum = di->di_num; /* already GFS2 endian */		dent->de_type = cpu_to_be16(DT_DIR);		di->di_entries = cpu_to_be32(1);		gfs2_str2qstr(&str, "..");		dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));		gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);		gfs2_inum_out(dip, dent);		dent->de_type = cpu_to_be16(DT_DIR);		gfs2_dinode_out(ip, di);		brelse(dibh);	}	error = gfs2_change_nlink(dip, +1);	gfs2_assert_withdraw(sdp, !error); /* dip already pinned */	gfs2_trans_end(sdp);	gfs2_inplace_release(dip);	gfs2_quota_unlock(dip);	gfs2_qadata_put(dip);	gfs2_glock_dq_uninit_m(2, ghs);	d_instantiate(dentry, inode);	mark_inode_dirty(inode);	return 0;}

static int gfs2_write_begin(struct file *file, struct address_space *mapping,			    loff_t pos, unsigned len, unsigned flags,			    struct page **pagep, void **fsdata){	struct gfs2_inode *ip = GFS2_I(mapping->host);	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);	unsigned int data_blocks, ind_blocks, rblocks;	int alloc_required;	int error = 0;	struct gfs2_alloc *al;	pgoff_t index = pos >> PAGE_CACHE_SHIFT;	unsigned from = pos & (PAGE_CACHE_SIZE - 1);	unsigned to = from + len;	struct page *page;	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);	error = gfs2_glock_nq_atime(&ip->i_gh);	if (unlikely(error))		goto out_uninit;	gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);	error = gfs2_write_alloc_required(ip, pos, len, &alloc_required);	if (error)		goto out_unlock;	if (alloc_required) {		al = gfs2_alloc_get(ip);		if (!al) {			error = -ENOMEM;			goto out_unlock;		}		error = gfs2_quota_lock_check(ip);		if (error)			goto out_alloc_put;		al->al_requested = data_blocks + ind_blocks;		error = gfs2_inplace_reserve(ip);		if (error)			goto out_qunlock;	}	rblocks = RES_DINODE + ind_blocks;	if (gfs2_is_jdata(ip))		rblocks += data_blocks ? data_blocks : 1;	if (ind_blocks || data_blocks)		rblocks += RES_STATFS + RES_QUOTA;	error = gfs2_trans_begin(sdp, rblocks,				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);	if (error)		goto out_trans_fail;	error = -ENOMEM;	page = grab_cache_page_write_begin(mapping, index, flags);	*pagep = page;	if (unlikely(!page))		goto out_endtrans;	if (gfs2_is_stuffed(ip)) {		error = 0;		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {			error = gfs2_unstuff_dinode(ip, page);			if (error == 0)				goto prepare_write;		} else if (!PageUptodate(page)) {			error = stuffed_readpage(ip, page);		}		goto out;	}prepare_write:	error = block_prepare_write(page, from, to, gfs2_block_map);out:	if (error == 0)		return 0;	page_cache_release(page);	if (pos + len > ip->i_inode.i_size)		vmtruncate(&ip->i_inode, ip->i_inode.i_size);out_endtrans:	gfs2_trans_end(sdp);out_trans_fail:	if (alloc_required) {		gfs2_inplace_release(ip);out_qunlock:		gfs2_quota_unlock(ip);out_alloc_put:		gfs2_alloc_put(ip);	}out_unlock:	gfs2_glock_dq(&ip->i_gh);out_uninit:	gfs2_holder_uninit(&ip->i_gh);	return error;}