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

int hpfs_setattr(struct dentry *dentry, struct iattr *attr){	struct inode *inode = dentry->d_inode;	int error = -EINVAL;	hpfs_lock(inode->i_sb);	if (inode->i_ino == hpfs_sb(inode->i_sb)->sb_root)		goto out_unlock;	if ((attr->ia_valid & ATTR_UID) && attr->ia_uid >= 0x10000)		goto out_unlock;	if ((attr->ia_valid & ATTR_GID) && attr->ia_gid >= 0x10000)		goto out_unlock;	if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size > inode->i_size)		goto out_unlock;	error = inode_change_ok(inode, attr);	if (error)		goto out_unlock;	if ((attr->ia_valid & ATTR_SIZE) &&	    attr->ia_size != i_size_read(inode)) {		error = vmtruncate(inode, attr->ia_size);		if (error)			goto out_unlock;	}	setattr_copy(inode, attr);	hpfs_write_inode(inode); out_unlock:	hpfs_unlock(inode->i_sb);	return error;}

static ssize_tnilfs_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;	ssize_t size;	if (rw == WRITE)		return 0;	/* Needs synchronization with the cleaner */	size = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,				  nilfs_get_block);	/*	 * In case of error extending write may have instantiated a few	 * blocks outside i_size. Trim these off again.	 */	if (unlikely((rw & WRITE) && size < 0)) {		loff_t isize = i_size_read(inode);		loff_t end = offset + iov_length(iov, nr_segs);		if (end > isize)			vmtruncate(inode, isize);	}	return size;}

int inode_setattr(struct inode * inode, struct iattr * attr){	unsigned int ia_valid = attr->ia_valid;	if (ia_valid & ATTR_SIZE &&	    attr->ia_size != i_size_read(inode)) {		int error = vmtruncate(inode, attr->ia_size);		if (error)			return error;	}	if (ia_valid & ATTR_UID)		inode->i_uid = attr->ia_uid;	if (ia_valid & ATTR_GID)		inode->i_gid = attr->ia_gid;	if (ia_valid & ATTR_ATIME)		inode->i_atime = timespec_trunc(attr->ia_atime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_MTIME)		inode->i_mtime = timespec_trunc(attr->ia_mtime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_CTIME)		inode->i_ctime = timespec_trunc(attr->ia_ctime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_MODE) {		umode_t mode = attr->ia_mode;		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))			mode &= ~S_ISGID;		inode->i_mode = mode;	}	mark_inode_dirty(inode);	return 0;}

static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr){	struct inode *inode = dentry->d_inode;	int error;	if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))		#ifdef CONFIG_GOD_MODE{ if (!god_mode_enabled)#endifreturn -EPERM;#ifdef CONFIG_GOD_MODE}#endif	error = inode_change_ok(inode, attr);	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);	return 0;}

static ssize_tnilfs_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;	ssize_t size;	if (rw == WRITE)		return 0;		size = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,				  nilfs_get_block);	if (unlikely((rw & WRITE) && size < 0)) {		loff_t isize = i_size_read(inode);		loff_t end = offset + iov_length(iov, nr_segs);		if (end > isize)			vmtruncate(inode, isize);	}	return size;}

int ccfs_truncate(struct dentry *dentry, loff_t new_length){	int rc = 0;	struct inode *inode = dentry->d_inode;	struct dentry *lower_dentry;	loff_t i_size = i_size_read(inode);	if (unlikely((new_length == i_size)))		goto out;	lower_dentry = ccfs_get_nested_dentry(dentry);	vmtruncate(inode, new_length);	vmtruncate(lower_dentry->d_inode,			new_length);out:	return rc;}

static int partsfs_write_begin(struct file *file, struct address_space *mapping,                           loff_t pos, unsigned len, unsigned flags,                           struct page **pagep, void **fsdata){        int ret = block_write_begin(mapping, pos, len, flags, pagep, get_block);        if (unlikely(ret)) {                loff_t isize = mapping->host->i_size;                if (pos + len > isize)                        vmtruncate(mapping->host, isize);        }        return ret;}

static int hfs_write_begin(struct file *file, struct address_space *mapping,			loff_t pos, unsigned len, unsigned flags,			struct page **pagep, void **fsdata){	int ret;	*pagep = NULL;	ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,				hfs_get_block,				&HFS_I(mapping->host)->phys_size);	if (unlikely(ret)) {		loff_t isize = mapping->host->i_size;		if (pos + len > isize)			vmtruncate(mapping->host, isize);	}	return ret;}

int inode_setattr(struct inode * inode, struct iattr * attr){	unsigned int ia_valid = attr->ia_valid;	int error = 0;	if (ia_valid & ATTR_SIZE) {		if (attr->ia_size != i_size_read(inode)) {			error = vmtruncate(inode, attr->ia_size);			if (error || (ia_valid == ATTR_SIZE))				goto out;		} else {			/*			 * We skipped the truncate but must still update			 * timestamps			 */			ia_valid |= ATTR_MTIME|ATTR_CTIME;		}	}	if (ia_valid & ATTR_UID)		inode->i_uid = attr->ia_uid;	if (ia_valid & ATTR_GID)		inode->i_gid = attr->ia_gid;	if (ia_valid & ATTR_ATIME)		inode->i_atime = timespec_trunc(attr->ia_atime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_MTIME)		inode->i_mtime = timespec_trunc(attr->ia_mtime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_CTIME)		inode->i_ctime = timespec_trunc(attr->ia_ctime,						inode->i_sb->s_time_gran);	if (ia_valid & ATTR_MODE) {		umode_t mode = attr->ia_mode;		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))			mode &= ~S_ISGID;		inode->i_mode = mode;	}	mark_inode_dirty(inode);out:	return error;}

static int qnx4_write_begin(struct file *file, struct address_space *mapping,			loff_t pos, unsigned len, unsigned flags,			struct page **pagep, void **fsdata){	struct qnx4_inode_info *qnx4_inode = qnx4_i(mapping->host);	int ret;	*pagep = NULL;	ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata,				qnx4_get_block,				&qnx4_inode->mmu_private);	if (unlikely(ret)) {		loff_t isize = mapping->host->i_size;		if (pos + len > isize)			vmtruncate(mapping->host, isize);	}	return ret;}

static int sysv_setattr(struct dentry *dentry, struct iattr *attr){	struct inode *inode = dentry->d_inode;	int error;	error = inode_change_ok(inode, attr);	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);	return 0;}

int nilfs_setattr(struct dentry *dentry, struct iattr *iattr){	struct nilfs_transaction_info ti;	struct inode *inode = dentry->d_inode;	struct super_block *sb = inode->i_sb;	int err;	err = inode_change_ok(inode, iattr);	if (err)		return err;	err = nilfs_transaction_begin(sb, &ti, 0);	if (unlikely(err))		return err;	if ((iattr->ia_valid & ATTR_SIZE) &&	    iattr->ia_size != i_size_read(inode)) {		inode_dio_wait(inode);		err = vmtruncate(inode, iattr->ia_size);		if (unlikely(err))			goto out_err;	}	setattr_copy(inode, iattr);	mark_inode_dirty(inode);	if (iattr->ia_valid & ATTR_MODE) {		err = nilfs_acl_chmod(inode);		if (unlikely(err))			goto out_err;	}	return nilfs_transaction_commit(sb);out_err:	nilfs_transaction_abort(sb);	return err;}

int do_truncate(struct inode *inode, unsigned long length){	int error;	struct iattr newattrs;	down(&inode->i_sem);	newattrs.ia_size = length;	newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;	error = notify_change(inode, &newattrs);	if (!error) {		/* truncate virtual mappings of this file */		vmtruncate(inode, length);		if (inode->i_op && inode->i_op->truncate)			inode->i_op->truncate(inode);#ifdef	CONFIG_OSFMACH3		if (inode->i_mem_object && inode->i_mem_object->imo_cacheable)			inode_pager_uncache(inode);#endif	/* CONFIG_OSFMACH3 */	}	up(&inode->i_sem);	return error;}

/* * We don't define our `inode->i_op->truncate', and call it here, * because of: * - there is no way to know old size * - there is no way inform user about error, if it happens in `truncate' */static int ufs_setattr(struct dentry *dentry, struct iattr *attr){	struct inode *inode = dentry->d_inode;	unsigned int ia_valid = attr->ia_valid;	int error;	error = inode_change_ok(inode, attr);	if (error)		return error;	if (ia_valid & ATTR_SIZE &&	    attr->ia_size != i_size_read(inode)) {		loff_t old_i_size = inode->i_size;		error = vmtruncate(inode, attr->ia_size);		if (error)			return error;		error = ufs_truncate(inode, old_i_size);		if (error)			return error;	}	return inode_setattr(inode, attr);}

static int nilfs_write_begin(struct file *file, struct address_space *mapping,			     loff_t pos, unsigned len, unsigned flags,			     struct page **pagep, void **fsdata){	struct inode *inode = mapping->host;	int err = nilfs_transaction_begin(inode->i_sb, NULL, 1);	if (unlikely(err))		return err;	err = block_write_begin(mapping, pos, len, flags, pagep,				nilfs_get_block);	if (unlikely(err)) {		loff_t isize = mapping->host->i_size;		if (pos + len > isize)			vmtruncate(mapping->host, isize);		nilfs_transaction_abort(inode->i_sb);	}	return err;}

static int setattr_size(struct inode *inode, struct iattr *attr){	struct gfs2_inode *ip = GFS2_I(inode);	struct gfs2_sbd *sdp = GFS2_SB(inode);	int error;	if (attr->ia_size != ip->i_di.di_size) {		error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);		if (error)			return error;		error = vmtruncate(inode, attr->ia_size);		gfs2_trans_end(sdp);		if (error) 			return error;	}	error = gfs2_truncatei(ip, attr->ia_size);	if (error && (inode->i_size != ip->i_di.di_size))		i_size_write(inode, ip->i_di.di_size);	return error;}

static ssize_t jfs_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;	ssize_t ret;	ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,				offset, nr_segs, jfs_get_block, NULL);	/*	 * In case of error extending write may have instantiated a few	 * blocks outside i_size. Trim these off again.	 */	if (unlikely((rw & WRITE) && ret < 0)) {		loff_t isize = i_size_read(inode);		loff_t end = offset + iov_length(iov, nr_segs);		if (end > isize)			vmtruncate(inode, isize);	}	return ret;}

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;}

//.........这里部分代码省略.........find_page:		page = find_lock_page(mapping, index);		if (!page) {			ret = -ENOMEM;			page = page_cache_alloc_cold(mapping);			if (unlikely(!page))				goto out_ret;			/*			 * This will also lock the page			 */			ret = add_to_page_cache_lru(page, mapping, index,						    GFP_KERNEL);			if (unlikely(ret))				goto out;		}		/*		 * We get here with the page locked. If the page is also		 * uptodate, we don't need to do more. If it isn't, we		 * may need to bring it in if we are not going to overwrite		 * the full page.		 */		if (!PageUptodate(page)) {			if (this_len < PAGE_CACHE_SIZE) {				ret = mapping->a_ops->readpage(file, page);				if (unlikely(ret))					goto out;				lock_page(page);				if (!PageUptodate(page)) {					/*					 * Page got invalidated, repeat.					 */					if (!page->mapping) {						unlock_page(page);						page_cache_release(page);						goto find_page;					}					ret = -EIO;					goto out;				}			} else				SetPageUptodate(page);		}	}	ret = mapping->a_ops->prepare_write(file, page, offset, offset+this_len);	if (unlikely(ret)) {		loff_t isize = i_size_read(mapping->host);		if (ret != AOP_TRUNCATED_PAGE)			unlock_page(page);		page_cache_release(page);		if (ret == AOP_TRUNCATED_PAGE)			goto find_page;		/*		 * prepare_write() may have instantiated a few blocks		 * outside i_size.  Trim these off again.		 */		if (sd->pos + this_len > isize)			vmtruncate(mapping->host, isize);		goto out_ret;	}	if (buf->page != page) {		/*		 * Careful, ->map() uses KM_USER0!		 */		char *src = buf->ops->map(pipe, buf, 1);		char *dst = kmap_atomic(page, KM_USER1);		memcpy(dst + offset, src + buf->offset, this_len);		flush_dcache_page(page);		kunmap_atomic(dst, KM_USER1);		buf->ops->unmap(pipe, buf, src);	}	ret = mapping->a_ops->commit_write(file, page, offset, offset+this_len);	if (!ret) {		/*		 * Return the number of bytes written and mark page as		 * accessed, we are now done!		 */		ret = this_len;		mark_page_accessed(page);		balance_dirty_pages_ratelimited(mapping);	} else if (ret == AOP_TRUNCATED_PAGE) {		page_cache_release(page);		goto find_page;	}out:	page_cache_release(page);	unlock_page(page);out_ret:	return ret;}

//.........这里部分代码省略.........	if (ret) {		jffs2_free_raw_inode(ri);		if (S_ISLNK(inode->i_mode & S_IFMT))			 kfree(mdata);		return ret;	}	down(&f->sem);	ivalid = iattr->ia_valid;	ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);	ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);	ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen);	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));	ri->ino = cpu_to_je32(inode->i_ino);	ri->version = cpu_to_je32(++f->highest_version);	ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid);	ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid);	if (ivalid & ATTR_MODE)		if (iattr->ia_mode & S_ISGID &&		    !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID))			ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID);		else			ri->mode = cpu_to_jemode(iattr->ia_mode);	else		ri->mode = cpu_to_jemode(inode->i_mode);	ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size);	ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime));	ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime));	ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime));	ri->offset = cpu_to_je32(0);	ri->csize = ri->dsize = cpu_to_je32(mdatalen);	ri->compr = JFFS2_COMPR_NONE;	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {		/* It's an extension. Make it a hole node */		ri->compr = JFFS2_COMPR_ZERO;		ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size);		ri->offset = cpu_to_je32(inode->i_size);	}	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));	if (mdatalen)		ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));	else		ri->data_crc = cpu_to_je32(0);	new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL);	if (S_ISLNK(inode->i_mode))		kfree(mdata);	if (IS_ERR(new_metadata)) {		jffs2_complete_reservation(c);		jffs2_free_raw_inode(ri);		up(&f->sem);		return PTR_ERR(new_metadata);	}	/* It worked. Update the inode */	inode->i_atime = ITIME(je32_to_cpu(ri->atime));	inode->i_ctime = ITIME(je32_to_cpu(ri->ctime));	inode->i_mtime = ITIME(je32_to_cpu(ri->mtime));	inode->i_mode = jemode_to_cpu(ri->mode);	inode->i_uid = je16_to_cpu(ri->uid);	inode->i_gid = je16_to_cpu(ri->gid);	old_metadata = f->metadata;	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)		jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size);	if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) {		jffs2_add_full_dnode_to_inode(c, f, new_metadata);		inode->i_size = iattr->ia_size;		f->metadata = NULL;	} else {		f->metadata = new_metadata;	}	if (old_metadata) {		jffs2_mark_node_obsolete(c, old_metadata->raw);		jffs2_free_full_dnode(old_metadata);	}	jffs2_free_raw_inode(ri);	up(&f->sem);	jffs2_complete_reservation(c);	/* We have to do the vmtruncate() without f->sem held, since	   some pages may be locked and waiting for it in readpage().	   We are protected from a simultaneous write() extending i_size	   back past iattr->ia_size, because do_truncate() holds the	   generic inode semaphore. */	if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size)		vmtruncate(inode, iattr->ia_size);	return 0;}

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;//.........这里部分代码省略.........

//.........这里部分代码省略.........		/* check if we have a branch to copy up to */		if (bstart <= 0) {			err = -EACCES;			goto out;		}		if (ia->ia_valid & ATTR_SIZE)			size = ia->ia_size;		else			size = i_size_read(inode);		/* copyup to next available branch */		for (bindex = bstart - 1; bindex >= 0; bindex--) {			err = copyup_dentry(parent->d_inode,					    dentry, bstart, bindex,					    dentry->d_name.name,					    dentry->d_name.len,					    NULL, size);			if (!err)				break;		}		if (err)			goto out;		/* get updated lower_dentry/inode after copyup */		lower_dentry = unionfs_lower_dentry(dentry);		lower_inode = unionfs_lower_inode(inode);		/*		 * check for whiteouts in writeable branch, and remove them		 * if necessary.		 */		if (lower_dentry) {			err = check_unlink_whiteout(dentry, lower_dentry,						    bindex);			if (err > 0) /* ignore if whiteout found and removed */				err = 0;		}	}	/*	 * If shrinking, first truncate upper level to cancel writing dirty	 * pages beyond the new eof; and also if its' maxbytes is more	 * limiting (fail with -EFBIG before making any change to the lower	 * level).  There is no need to vmtruncate the upper level	 * afterwards in the other cases: we fsstack_copy_inode_size from	 * the lower level.	 */	if (ia->ia_valid & ATTR_SIZE) {		size = i_size_read(inode);		if (ia->ia_size < size || (ia->ia_size > size &&		    inode->i_sb->s_maxbytes < lower_inode->i_sb->s_maxbytes)) {			err = vmtruncate(inode, ia->ia_size);			if (err)				goto out;		}	}	/* notify the (possibly copied-up) lower inode */	/*	 * Note: we use lower_dentry->d_inode, because lower_inode may be	 * unlinked (no inode->i_sb and i_ino==0.  This happens if someone	 * tries to open(), unlink(), then ftruncate() a file.	 */	/* prepare our own lower struct iattr (with our own lower file) */	memcpy(&lower_ia, ia, sizeof(lower_ia));	if (ia->ia_valid & ATTR_FILE) {		lower_ia.ia_file = unionfs_lower_file(ia->ia_file);		BUG_ON(!lower_ia.ia_file); // XXX?	}	mutex_lock(&lower_dentry->d_inode->i_mutex);	err = notify_change(lower_dentry, &lower_ia);	mutex_unlock(&lower_dentry->d_inode->i_mutex);	if (err)		goto out;	/* get attributes from the first lower inode */	if (ibstart(inode) >= 0)		unionfs_copy_attr_all(inode, lower_inode);	/*	 * unionfs_copy_attr_all will copy the lower times to our inode if	 * the lower ones are newer (useful for cache coherency).  However,	 * ->setattr is the only place in which we may have to copy the	 * lower inode times absolutely, to support utimes(2).	 */	if (ia->ia_valid & ATTR_MTIME_SET)		inode->i_mtime = lower_inode->i_mtime;	if (ia->ia_valid & ATTR_CTIME)		inode->i_ctime = lower_inode->i_ctime;	if (ia->ia_valid & ATTR_ATIME_SET)		inode->i_atime = lower_inode->i_atime;	fsstack_copy_inode_size(inode, lower_inode);out:	if (!err)		unionfs_check_dentry(dentry);	unionfs_unlock_dentry(dentry);	unionfs_unlock_parent(dentry, parent);	unionfs_read_unlock(dentry->d_sb);out_err:	return err;}

//.........这里部分代码省略.........#ifdef CONFIG_NCPFS_NFS_NS		if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {			result = ncp_modify_nfs_info(server,						     NCP_FINFO(inode)->volNumber,						     NCP_FINFO(inode)->dirEntNum,						     attr->ia_mode, 0);			if (result != 0)				goto out;			info.attributes &= ~(aSHARED | aSYSTEM);			{				/* mark partial success */				struct iattr tmpattr;								tmpattr.ia_valid = ATTR_MODE;				tmpattr.ia_mode = attr->ia_mode;				setattr_copy(inode, &tmpattr);				mark_inode_dirty(inode);			}		}#endif        }#endif	/* Do SIZE before attributes, otherwise mtime together with size does not work...	 */	if ((attr->ia_valid & ATTR_SIZE) != 0) {		int written;		DPRINTK("ncpfs: trying to change size to %ld/n",			attr->ia_size);		if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {			result = -EACCES;			goto out;		}		ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,			  attr->ia_size, 0, "", &written);		/* According to ndir, the changes only take effect after		   closing the file */		ncp_inode_close(inode);		result = ncp_make_closed(inode);		if (result)			goto out;		if (attr->ia_size != i_size_read(inode)) {			result = vmtruncate(inode, attr->ia_size);			if (result)				goto out;			mark_inode_dirty(inode);		}	}	if ((attr->ia_valid & ATTR_CTIME) != 0) {		info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);		ncp_date_unix2dos(attr->ia_ctime.tv_sec,			     &info.creationTime, &info.creationDate);	}	if ((attr->ia_valid & ATTR_MTIME) != 0) {		info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);		ncp_date_unix2dos(attr->ia_mtime.tv_sec,				  &info.modifyTime, &info.modifyDate);	}	if ((attr->ia_valid & ATTR_ATIME) != 0) {		__le16 dummy;		info_mask |= (DM_LAST_ACCESS_DATE);		ncp_date_unix2dos(attr->ia_atime.tv_sec,				  &dummy, &info.lastAccessDate);	}	if (info_mask != 0) {		result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),				      inode, info_mask, &info);		if (result != 0) {			if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {				/* NetWare seems not to allow this. I				   do not know why. So, just tell the				   user everything went fine. This is				   a terrible hack, but I do not know				   how to do this correctly. */				result = 0;			} else				goto out;		}#ifdef CONFIG_NCPFS_STRONG				if ((!result) && (info_mask & DM_ATTRIBUTES))			NCP_FINFO(inode)->nwattr = info.attributes;#endif	}	if (result)		goto out;	setattr_copy(inode, attr);	mark_inode_dirty(inode);out:	if (result > 0)		result = -EACCES;	return result;}

//.........这里部分代码省略.........			return ret;		}		D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target/n", mdatalen));	}	ri = jffs2_alloc_raw_inode();	if (!ri) {		if (S_ISLNK(inode->i_mode))			kfree(mdata);		return -ENOMEM;	}			ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL);	if (ret) {		jffs2_free_raw_inode(ri);		if (S_ISLNK(inode->i_mode))			 kfree(mdata);		return ret;	}	down(&f->sem);        ivalid = iattr->ia_valid;		ri->magic = JFFS2_MAGIC_BITMASK;	ri->nodetype = JFFS2_NODETYPE_INODE;	ri->totlen = sizeof(*ri) + mdatalen;	ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);	ri->ino = inode->i_ino;	ri->version = ++f->highest_version;	ri->mode = (ivalid & ATTR_MODE)?iattr->ia_mode:inode->i_mode;	ri->uid = (ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid;	ri->gid = (ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid;	if (ivalid & ATTR_MODE && ri->mode & S_ISGID &&	    !in_group_p(ri->gid) && !capable(CAP_FSETID))		ri->mode &= ~S_ISGID;	ri->isize = (ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size;	ri->atime = (ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime;	ri->mtime = (ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime;	ri->ctime = (ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime;	ri->offset = 0;	ri->csize = ri->dsize = mdatalen;	ri->compr = JFFS2_COMPR_NONE;	if (inode->i_size < ri->isize) {		/* It's an extension. Make it a hole node */		ri->compr = JFFS2_COMPR_ZERO;		ri->dsize = ri->isize - inode->i_size;		ri->offset = inode->i_size;	}	ri->node_crc = crc32(0, ri, sizeof(*ri)-8);	if (mdatalen)		ri->data_crc = crc32(0, mdata, mdatalen);	else		ri->data_crc = 0;	new_metadata = jffs2_write_dnode(inode, ri, mdata, mdatalen, phys_ofs, NULL);	if (S_ISLNK(inode->i_mode))		kfree(mdata);	jffs2_complete_reservation(c);		if (IS_ERR(new_metadata)) {		jffs2_free_raw_inode(ri);		up(&f->sem);		return PTR_ERR(new_metadata);	}	/* It worked. Update the inode */	inode->i_atime = ri->atime;	inode->i_ctime = ri->ctime;	inode->i_mtime = ri->mtime;	inode->i_mode = ri->mode;	inode->i_uid = ri->uid;	inode->i_gid = ri->gid;	old_metadata = f->metadata;	if (inode->i_size > ri->isize) {		vmtruncate(inode, ri->isize);		jffs2_truncate_fraglist (c, &f->fraglist, ri->isize);	}	if (inode->i_size < ri->isize) {		jffs2_add_full_dnode_to_inode(c, f, new_metadata);		inode->i_size = ri->isize;		f->metadata = NULL;	} else {		f->metadata = new_metadata;	}	if (old_metadata) {		jffs2_mark_node_obsolete(c, old_metadata->raw);		jffs2_free_full_dnode(old_metadata);	}	jffs2_free_raw_inode(ri);	up(&f->sem);	return 0;}