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

/* * It only removes the dentry from the dentry page,corresponding name * entry in name page does not need to be touched during deletion. */void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,						struct inode *inode){	struct	f2fs_dentry_block *dentry_blk;	unsigned int bit_pos;	struct address_space *mapping = page->mapping;	struct inode *dir = mapping->host;	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));	void *kaddr = page_address(page);	int i;	lock_page(page);	wait_on_page_writeback(page);	dentry_blk = (struct f2fs_dentry_block *)kaddr;	bit_pos = dentry - (struct f2fs_dir_entry *)dentry_blk->dentry;	for (i = 0; i < slots; i++)		test_and_clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);	/* Let's check and deallocate this dentry page */	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,			NR_DENTRY_IN_BLOCK,			0);	kunmap(page); /* kunmap - pair of f2fs_find_entry */	set_page_dirty(page);	dir->i_ctime = dir->i_mtime = CURRENT_TIME;	if (inode && S_ISDIR(inode->i_mode)) {		drop_nlink(dir);		update_inode_page(dir);	} else {		mark_inode_dirty(dir);	}	if (inode) {		inode->i_ctime = CURRENT_TIME;		drop_nlink(inode);		if (S_ISDIR(inode->i_mode)) {			drop_nlink(inode);			i_size_write(inode, 0);		}		update_inode_page(inode);		if (inode->i_nlink == 0)			add_orphan_inode(sbi, inode->i_ino);		else			release_orphan_inode(sbi);	}	if (bit_pos == NR_DENTRY_IN_BLOCK) {		truncate_hole(dir, page->index, page->index + 1);		clear_page_dirty_for_io(page);		ClearPageUptodate(page);		dec_page_count(sbi, F2FS_DIRTY_DENTS);		inode_dec_dirty_dents(dir);	}	f2fs_put_page(page, 1);}

void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	down_write(&F2FS_I(inode)->i_sem);	if (S_ISDIR(inode->i_mode)) {		drop_nlink(dir);		if (page)			update_inode(dir, page);		else			update_inode_page(dir);	}	inode->i_ctime = CURRENT_TIME;	drop_nlink(inode);	if (S_ISDIR(inode->i_mode)) {		drop_nlink(inode);		i_size_write(inode, 0);	}	up_write(&F2FS_I(inode)->i_sem);	update_inode_page(inode);	if (inode->i_nlink == 0)		add_orphan_inode(sbi, inode->i_ino);	else		release_orphan_inode(sbi);}

static int expand_inode_data(struct inode *inode, loff_t offset,					loff_t len, int mode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	pgoff_t index, pg_start, pg_end;	loff_t new_size = i_size_read(inode);	loff_t off_start, off_end;	int ret = 0;	f2fs_balance_fs(sbi);	ret = inode_newsize_ok(inode, (len + offset));	if (ret)		return ret;	if (f2fs_has_inline_data(inode)) {		ret = f2fs_convert_inline_inode(inode);		if (ret)			return ret;	}	pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;	pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;	off_start = offset & (PAGE_CACHE_SIZE - 1);	off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);	f2fs_lock_op(sbi);	for (index = pg_start; index <= pg_end; index++) {		struct dnode_of_data dn;		if (index == pg_end && !off_end)			goto noalloc;		set_new_dnode(&dn, inode, NULL, NULL, 0);		ret = f2fs_reserve_block(&dn, index);		if (ret)			break;noalloc:		if (pg_start == pg_end)			new_size = offset + len;		else if (index == pg_start && off_start)			new_size = (index + 1) << PAGE_CACHE_SHIFT;		else if (index == pg_end)			new_size = (index << PAGE_CACHE_SHIFT) + off_end;		else			new_size += PAGE_CACHE_SIZE;	}	if (!(mode & FALLOC_FL_KEEP_SIZE) &&		i_size_read(inode) < new_size) {		i_size_write(inode, new_size);		mark_inode_dirty(inode);		update_inode_page(inode);	}	f2fs_unlock_op(sbi);	return ret;}

int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	int ret;	if (inode->i_ino == F2FS_NODE_INO(sbi) ||			inode->i_ino == F2FS_META_INO(sbi))		return 0;	if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))		return 0;	/*	 * We need to lock here to prevent from producing dirty node pages	 * during the urgent cleaning time when runing out of free sections.	 */	f2fs_lock_op(sbi);	ret = update_inode_page(inode);	f2fs_unlock_op(sbi);	if (wbc)		f2fs_balance_fs(sbi);	return ret;}

/* caller should call f2fs_lock_op() */void handle_failed_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct node_info ni;	/*	 * clear nlink of inode in order to release resource of inode	 * immediately.	 */	clear_nlink(inode);	/*	 * we must call this to avoid inode being remained as dirty, resulting	 * in a panic when flushing dirty inodes in gdirty_list.	 */	update_inode_page(inode);	f2fs_inode_synced(inode);	/* don't make bad inode, since it becomes a regular file. */	unlock_new_inode(inode);	/*	 * Note: we should add inode to orphan list before f2fs_unlock_op()	 * so we can prevent losing this orphan when encoutering checkpoint	 * and following suddenly power-off.	 */	get_node_info(sbi, inode->i_ino, &ni);	if (ni.blk_addr != NULL_ADDR) {		int err = acquire_orphan_inode(sbi);		if (err) {			set_sbi_flag(sbi, SBI_NEED_FSCK);			f2fs_msg(sbi->sb, KERN_WARNING,				"Too many orphan inodes, run fsck to fix.");		} else {			add_orphan_inode(inode);		}		alloc_nid_done(sbi, inode->i_ino);	} else {		set_inode_flag(inode, FI_FREE_NID);	}	f2fs_unlock_op(sbi);	/* iput will drop the inode object */	iput(inode);}

int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	if (inode->i_ino == F2FS_NODE_INO(sbi) ||			inode->i_ino == F2FS_META_INO(sbi))		return 0;	if (!is_inode_flag_set(inode, FI_DIRTY_INODE))		return 0;	/*	 * We need to balance fs here to prevent from producing dirty node pages	 * during the urgent cleaning time when runing out of free sections.	 */	if (update_inode_page(inode) && wbc && wbc->nr_to_write)		f2fs_balance_fs(sbi, true);	return 0;}

static int f2fs_write_end(struct file *file,                        struct address_space *mapping,                        loff_t pos, unsigned len, unsigned copied,                        struct page *page, void *fsdata){        struct inode *inode = page->mapping->host;        trace_f2fs_write_end(inode, pos, len, copied);        set_page_dirty(page);        if (pos + copied > i_size_read(inode)) {                i_size_write(inode, pos + copied);                mark_inode_dirty(inode);                update_inode_page(inode);        }        f2fs_put_page(page, 1);        return copied;}

static void update_parent_metadata(struct inode *dir, struct inode *inode,						unsigned int current_depth){	if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {		if (S_ISDIR(inode->i_mode)) {			inc_nlink(dir);			set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);		}		clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);	}	dir->i_mtime = dir->i_ctime = CURRENT_TIME;	mark_inode_dirty(dir);	if (F2FS_I(dir)->i_current_depth != current_depth) {		F2FS_I(dir)->i_current_depth = current_depth;		set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR))		update_inode_page(dir);	if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))		clear_inode_flag(F2FS_I(inode), FI_INC_LINK);}

//.........这里部分代码省略.........    f2fs_unlock_op(sbi);    f2fs_wait_on_page_writeback(page, DATA);    if (len == PAGE_CACHE_SIZE)        goto out_update;    if (PageUptodate(page))        goto out_clear;    if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {        unsigned start = pos & (PAGE_CACHE_SIZE - 1);        unsigned end = start + len;        /* Reading beyond i_size is simple: memset to zero */        zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);        goto out_update;    }    if (dn.data_blkaddr == NEW_ADDR) {        zero_user_segment(page, 0, PAGE_CACHE_SIZE);    } else {        struct f2fs_io_info fio = {            .sbi = sbi,            .type = DATA,            .rw = READ_SYNC,            .blk_addr = dn.data_blkaddr,            .page = page,            .encrypted_page = NULL,        };        err = f2fs_submit_page_bio(&fio);        if (err)            goto fail;        lock_page(page);        if (unlikely(!PageUptodate(page))) {            err = -EIO;            goto fail;        }        if (unlikely(page->mapping != mapping)) {            f2fs_put_page(page, 1);            goto repeat;        }        /* avoid symlink page */        if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {            err = f2fs_decrypt_one(inode, page);            if (err)                goto fail;        }    }out_update:    SetPageUptodate(page);out_clear:    clear_cold_data(page);    return 0;put_fail:    f2fs_put_dnode(&dn);unlock_fail:    f2fs_unlock_op(sbi);fail:    f2fs_put_page(page, 1);    f2fs_write_failed(mapping, pos + len);    return err;}static int f2fs_write_end(struct file *file,                          struct address_space *mapping,                          loff_t pos, unsigned len, unsigned copied,                          struct page *page, void *fsdata){    struct inode *inode = page->mapping->host;    trace_f2fs_write_end(inode, pos, len, copied);    set_page_dirty(page);    if (pos + copied > i_size_read(inode)) {        i_size_write(inode, pos + copied);        mark_inode_dirty(inode);        update_inode_page(inode);    }    f2fs_put_page(page, 1);    return copied;}static int check_direct_IO(struct inode *inode, struct iov_iter *iter,                           loff_t offset){    unsigned blocksize_mask = inode->i_sb->s_blocksize - 1;    if (offset & blocksize_mask)        return -EINVAL;    if (iov_iter_alignment(iter) & blocksize_mask)        return -EINVAL;    return 0;}

//.........这里部分代码省略.........	if (value == NULL)		size = 0;	len = strlen(name);	if (len > F2FS_NAME_LEN || size > MAX_VALUE_LEN(inode))		return -ERANGE;	base_addr = read_all_xattrs(inode, ipage);	if (!base_addr)		goto exit;	/* find entry with wanted name. */	here = __find_xattr(base_addr, index, len, name);	found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;	if ((flags & XATTR_REPLACE) && !found) {		error = -ENODATA;		goto exit;	} else if ((flags & XATTR_CREATE) && found) {		error = -EEXIST;		goto exit;	}	last = here;	while (!IS_XATTR_LAST_ENTRY(last))		last = XATTR_NEXT_ENTRY(last);	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);	/* 1. Check space */	if (value) {		int free;		/*		 * If value is NULL, it is remove operation.		 * In case of update operation, we caculate free.		 */		free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);		if (found)			free = free + ENTRY_SIZE(here);		if (unlikely(free < newsize)) {			error = -ENOSPC;			goto exit;		}	}	/* 2. Remove old entry */	if (found) {		/*		 * If entry is found, remove old entry.		 * If not found, remove operation is not needed.		 */		struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);		int oldsize = ENTRY_SIZE(here);		memmove(here, next, (char *)last - (char *)next);		last = (struct f2fs_xattr_entry *)((char *)last - oldsize);		memset(last, 0, oldsize);	}	new_hsize = (char *)last - (char *)base_addr;	/* 3. Write new entry */	if (value) {		char *pval;		/*		 * Before we come here, old entry is removed.		 * We just write new entry.		 */		memset(last, 0, newsize);		last->e_name_index = index;		last->e_name_len = len;		memcpy(last->e_name, name, len);		pval = last->e_name + len;		memcpy(pval, value, size);		last->e_value_size = cpu_to_le16(size);		new_hsize += newsize;	}	error = write_all_xattrs(inode, new_hsize, base_addr, ipage);	if (error)		goto exit;	if (is_inode_flag_set(fi, FI_ACL_MODE)) {		inode->i_mode = fi->i_acl_mode;		inode->i_ctime = CURRENT_TIME;		clear_inode_flag(fi, FI_ACL_MODE);	}	if (ipage)		update_inode(inode, ipage);	else		update_inode_page(inode);exit:	kzfree(base_addr);	return error;}

static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,                             struct inode *new_dir, struct dentry *new_dentry){    struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);    struct inode *old_inode = old_dentry->d_inode;    struct inode *new_inode = new_dentry->d_inode;    struct page *old_dir_page, *new_dir_page;    struct page *old_page, *new_page;    struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;    struct f2fs_dir_entry *old_entry, *new_entry;    int old_nlink = 0, new_nlink = 0;    int err = -ENOENT;    f2fs_balance_fs(sbi);    old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);    if (!old_entry)        goto out;    new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);    if (!new_entry)        goto out_old;    /* prepare for updating ".." directory entry info later */    if (old_dir != new_dir) {        if (S_ISDIR(old_inode->i_mode)) {            err = -EIO;            old_dir_entry = f2fs_parent_dir(old_inode,                                            &old_dir_page);            if (!old_dir_entry)                goto out_new;        }        if (S_ISDIR(new_inode->i_mode)) {            err = -EIO;            new_dir_entry = f2fs_parent_dir(new_inode,                                            &new_dir_page);            if (!new_dir_entry)                goto out_old_dir;        }    }    /*     * If cross rename between file and directory those are not     * in the same directory, we will inc nlink of file's parent     * later, so we should check upper boundary of its nlink.     */    if ((!old_dir_entry || !new_dir_entry) &&            old_dir_entry != new_dir_entry) {        old_nlink = old_dir_entry ? -1 : 1;        new_nlink = -old_nlink;        err = -EMLINK;        if ((old_nlink > 0 && old_inode->i_nlink >= F2FS_LINK_MAX) ||                (new_nlink > 0 && new_inode->i_nlink >= F2FS_LINK_MAX))            goto out_new_dir;    }    f2fs_lock_op(sbi);    err = update_dent_inode(old_inode, &new_dentry->d_name);    if (err)        goto out_unlock;    err = update_dent_inode(new_inode, &old_dentry->d_name);    if (err)        goto out_undo;    /* update ".." directory entry info of old dentry */    if (old_dir_entry)        f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);    /* update ".." directory entry info of new dentry */    if (new_dir_entry)        f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);    /* update directory entry info of old dir inode */    f2fs_set_link(old_dir, old_entry, old_page, new_inode);    down_write(&F2FS_I(old_inode)->i_sem);    file_lost_pino(old_inode);    up_write(&F2FS_I(old_inode)->i_sem);    update_inode_page(old_inode);    old_dir->i_ctime = CURRENT_TIME;    if (old_nlink) {        down_write(&F2FS_I(old_dir)->i_sem);        if (old_nlink < 0)            drop_nlink(old_dir);        else            inc_nlink(old_dir);        up_write(&F2FS_I(old_dir)->i_sem);    }    mark_inode_dirty(old_dir);    update_inode_page(old_dir);    /* update directory entry info of new dir inode */    f2fs_set_link(new_dir, new_entry, new_page, old_inode);    down_write(&F2FS_I(new_inode)->i_sem);//.........这里部分代码省略.........

static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,                       struct inode *new_dir, struct dentry *new_dentry){    struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);    struct inode *old_inode = old_dentry->d_inode;    struct inode *new_inode = new_dentry->d_inode;    struct page *old_dir_page;    struct page *old_page, *new_page;    struct f2fs_dir_entry *old_dir_entry = NULL;    struct f2fs_dir_entry *old_entry;    struct f2fs_dir_entry *new_entry;    int err = -ENOENT;    f2fs_balance_fs(sbi);    old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);    if (!old_entry)        goto out;    if (S_ISDIR(old_inode->i_mode)) {        err = -EIO;        old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);        if (!old_dir_entry)            goto out_old;    }    if (new_inode) {        err = -ENOTEMPTY;        if (old_dir_entry && !f2fs_empty_dir(new_inode))            goto out_dir;        err = -ENOENT;        new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,                                    &new_page);        if (!new_entry)            goto out_dir;        f2fs_lock_op(sbi);        err = acquire_orphan_inode(sbi);        if (err)            goto put_out_dir;        if (update_dent_inode(old_inode, &new_dentry->d_name)) {            release_orphan_inode(sbi);            goto put_out_dir;        }        f2fs_set_link(new_dir, new_entry, new_page, old_inode);        new_inode->i_ctime = CURRENT_TIME;        down_write(&F2FS_I(new_inode)->i_sem);        if (old_dir_entry)            drop_nlink(new_inode);        drop_nlink(new_inode);        up_write(&F2FS_I(new_inode)->i_sem);        mark_inode_dirty(new_inode);        if (!new_inode->i_nlink)            add_orphan_inode(sbi, new_inode->i_ino);        else            release_orphan_inode(sbi);        update_inode_page(old_inode);        update_inode_page(new_inode);    } else {        f2fs_lock_op(sbi);        err = f2fs_add_link(new_dentry, old_inode);        if (err) {            f2fs_unlock_op(sbi);            goto out_dir;        }        if (old_dir_entry) {            inc_nlink(new_dir);            update_inode_page(new_dir);        }    }    down_write(&F2FS_I(old_inode)->i_sem);    file_lost_pino(old_inode);    up_write(&F2FS_I(old_inode)->i_sem);    old_inode->i_ctime = CURRENT_TIME;    mark_inode_dirty(old_inode);    f2fs_delete_entry(old_entry, old_page, old_dir, NULL);    if (old_dir_entry) {        if (old_dir != new_dir) {            f2fs_set_link(old_inode, old_dir_entry,                          old_dir_page, new_dir);            update_inode_page(old_inode);        } else {            f2fs_dentry_kunmap(old_inode, old_dir_page);            f2fs_put_page(old_dir_page, 0);        }//.........这里部分代码省略.........

//.........这里部分代码省略.........		new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,						&new_page, 0);		if (!new_entry)			goto out_dir;		f2fs_lock_op(sbi);		err = acquire_orphan_inode(sbi);		if (err)			goto put_out_dir;		if (update_dent_inode(old_inode, new_inode,						&new_dentry->d_name)) {			release_orphan_inode(sbi);			goto put_out_dir;		}		f2fs_set_link(new_dir, new_entry, new_page, old_inode);		new_inode->i_ctime = CURRENT_TIME;		down_write(&F2FS_I(new_inode)->i_sem);		if (old_dir_entry)			drop_nlink(new_inode);		drop_nlink(new_inode);		up_write(&F2FS_I(new_inode)->i_sem);		mark_inode_dirty(new_inode);		if (!new_inode->i_nlink)			add_orphan_inode(sbi, new_inode->i_ino);		else			release_orphan_inode(sbi);		update_inode_page(old_inode);		update_inode_page(new_inode);	} else {		f2fs_lock_op(sbi);		err = f2fs_add_link(new_dentry, old_inode);		if (err) {			f2fs_unlock_op(sbi);			goto out_dir;		}		if (old_dir_entry) {			inc_nlink(new_dir);			update_inode_page(new_dir);		}	}	down_write(&F2FS_I(old_inode)->i_sem);	file_lost_pino(old_inode);	if (new_inode && file_enc_name(new_inode))		file_set_enc_name(old_inode);	up_write(&F2FS_I(old_inode)->i_sem);	old_inode->i_ctime = CURRENT_TIME;	mark_inode_dirty(old_inode);	f2fs_delete_entry(old_entry, old_page, old_dir, NULL);	if (old_dir_entry) {		if (old_dir != new_dir) {			f2fs_set_link(old_inode, old_dir_entry,						old_dir_page, new_dir);			update_inode_page(old_inode);

//.........这里部分代码省略.........	} else {		/* The inode already has an extended attribute block. */		page = get_node_page(sbi, fi->i_xattr_nid);		if (IS_ERR(page)) {			error = PTR_ERR(page);			goto exit;		}		base_addr = page_address(page);		header = XATTR_HDR(base_addr);	}	if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {		error = -EIO;		goto cleanup;	}	/* find entry with wanted name. */	found = 0;	list_for_each_xattr(here, base_addr) {		if (here->e_name_index != name_index)			continue;		if (here->e_name_len != name_len)			continue;		if (!memcmp(here->e_name, name, name_len)) {			found = 1;			break;		}	}	last = here;	while (!IS_XATTR_LAST_ENTRY(last))		last = XATTR_NEXT_ENTRY(last);	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +			name_len + value_len);	/* 1. Check space */	if (value) {		/* If value is NULL, it is remove operation.		 * In case of update operation, we caculate free.		 */		free = MIN_OFFSET - ((char *)last - (char *)header);		if (found)			free = free - ENTRY_SIZE(here);		if (free < newsize) {			error = -ENOSPC;			goto cleanup;		}	}	/* 2. Remove old entry */	if (found) {		/* If entry is found, remove old entry.		 * If not found, remove operation is not needed.		 */		struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);		int oldsize = ENTRY_SIZE(here);		memmove(here, next, (char *)last - (char *)next);		last = (struct f2fs_xattr_entry *)((char *)last - oldsize);		memset(last, 0, oldsize);	}	/* 3. Write new entry */	if (value) {		/* Before we come here, old entry is removed.		 * We just write new entry. */		memset(last, 0, newsize);		last->e_name_index = name_index;		last->e_name_len = name_len;		memcpy(last->e_name, name, name_len);		pval = last->e_name + name_len;		memcpy(pval, value, value_len);		last->e_value_size = cpu_to_le16(value_len);	}	set_page_dirty(page);	f2fs_put_page(page, 1);	if (is_inode_flag_set(fi, FI_ACL_MODE)) {		inode->i_mode = fi->i_acl_mode;		inode->i_ctime = CURRENT_TIME;		clear_inode_flag(fi, FI_ACL_MODE);	}	if (ipage)		update_inode(inode, ipage);	else		update_inode_page(inode);	mutex_unlock_op(sbi, ilock);	return 0;cleanup:	f2fs_put_page(page, 1);exit:	mutex_unlock_op(sbi, ilock);	return error;}

//.........这里部分代码省略.........			.page = page,			.encrypted_page = NULL,		};		err = f2fs_submit_page_bio(&fio);		if (err)			goto fail;		lock_page(page);		if (unlikely(!PageUptodate(page))) {			err = -EIO;			goto fail;		}		if (unlikely(page->mapping != mapping)) {			f2fs_put_page(page, 1);			goto repeat;		}		/* avoid symlink page */		if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {			err = f2fs_decrypt_one(inode, page);			if (err)				goto fail;		}	}out_update:	SetPageUptodate(page);out_clear:	clear_cold_data(page);	return 0;put_fail:	f2fs_put_dnode(&dn);unlock_fail:	f2fs_unlock_op(sbi);fail:	f2fs_put_page(page, 1);	f2fs_write_failed(mapping, pos + len);	return err;}static int f2fs_write_end(struct file *file,			struct address_space *mapping,			loff_t pos, unsigned len, unsigned copied,			struct page *page, void *fsdata){	struct inode *inode = page->mapping->host;	trace_f2fs_write_end(inode, pos, len, copied);	set_page_dirty(page);	if (pos + copied > i_size_read(inode)) {		i_size_write(inode, pos + copied);		mark_inode_dirty(inode);		update_inode_page(inode);	}	f2fs_put_page(page, 1);	return copied;}static ssize_t check_direct_IO(struct inode *inode, int rw,		const struct iovec *iov, loff_t offset, unsigned long nr_segs){	unsigned blocksize_mask = inode->i_sb->s_blocksize - 1;	int seg, i;	size_t size;	unsigned long addr;	ssize_t retval = -EINVAL;	loff_t end = offset;	if (offset & blocksize_mask)		return -EINVAL;	/* Check the memory alignment.  Blocks cannot straddle pages */	for (seg = 0; seg < nr_segs; seg++) {		addr = (unsigned long)iov[seg].iov_base;		size = iov[seg].iov_len;		end += size;		if ((addr & blocksize_mask) || (size & blocksize_mask))			goto out;		/* If this is a write we don't need to check anymore */		if (rw & WRITE)			continue;		/*		 * Check to make sure we don't have duplicate iov_base's in this		 * iovec, if so return EINVAL, otherwise we'll get csum errors		 * when reading back.		 */		for (i = seg + 1; i < nr_segs; i++) {			if (iov[seg].iov_base == iov[i].iov_base)				goto out;		}	}	retval = 0;out:	return retval;}

/* * Called at the last iput() if i_nlink is zero */void f2fs_evict_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	nid_t xnid = F2FS_I(inode)->i_xattr_nid;	int err = 0;	/* some remained atomic pages should discarded */	if (f2fs_is_atomic_file(inode))		drop_inmem_pages(inode);	trace_f2fs_evict_inode(inode);	truncate_inode_pages_final(&inode->i_data);	if (inode->i_ino == F2FS_NODE_INO(sbi) ||			inode->i_ino == F2FS_META_INO(sbi))		goto out_clear;	f2fs_bug_on(sbi, get_dirty_pages(inode));	remove_dirty_inode(inode);	f2fs_destroy_extent_tree(inode);	if (inode->i_nlink || is_bad_inode(inode))		goto no_delete;#ifdef CONFIG_F2FS_FAULT_INJECTION	if (time_to_inject(sbi, FAULT_EVICT_INODE))		goto no_delete;#endif	remove_ino_entry(sbi, inode->i_ino, APPEND_INO);	remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);	sb_start_intwrite(inode->i_sb);	set_inode_flag(inode, FI_NO_ALLOC);	i_size_write(inode, 0);retry:	if (F2FS_HAS_BLOCKS(inode))		err = f2fs_truncate(inode);	if (!err) {		f2fs_lock_op(sbi);		err = remove_inode_page(inode);		f2fs_unlock_op(sbi);		if (err == -ENOENT)			err = 0;	}	/* give more chances, if ENOMEM case */	if (err == -ENOMEM) {		err = 0;		goto retry;	}	if (err)		update_inode_page(inode);	sb_end_intwrite(inode->i_sb);no_delete:	stat_dec_inline_xattr(inode);	stat_dec_inline_dir(inode);	stat_dec_inline_inode(inode);	invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);	if (xnid)		invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);	if (inode->i_nlink) {		if (is_inode_flag_set(inode, FI_APPEND_WRITE))			add_ino_entry(sbi, inode->i_ino, APPEND_INO);		if (is_inode_flag_set(inode, FI_UPDATE_WRITE))			add_ino_entry(sbi, inode->i_ino, UPDATE_INO);	}	if (is_inode_flag_set(inode, FI_FREE_NID)) {		alloc_nid_failed(sbi, inode->i_ino);		clear_inode_flag(inode, FI_FREE_NID);	}	f2fs_bug_on(sbi, err &&		!exist_written_data(sbi, inode->i_ino, ORPHAN_INO));out_clear:	fscrypt_put_encryption_info(inode, NULL);	clear_inode(inode);}

int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync){	struct inode *inode = file->f_mapping->host;	struct f2fs_inode_info *fi = F2FS_I(inode);	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	nid_t ino = inode->i_ino;	int ret = 0;	bool need_cp = false;	struct writeback_control wbc = {		.sync_mode = WB_SYNC_ALL,		.nr_to_write = LONG_MAX,		.for_reclaim = 0,	};	if (unlikely(f2fs_readonly(inode->i_sb)))		return 0;	trace_f2fs_sync_file_enter(inode);	/* if fdatasync is triggered, let's do in-place-update */	if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)		set_inode_flag(fi, FI_NEED_IPU);	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);	clear_inode_flag(fi, FI_NEED_IPU);	if (ret) {		trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);		return ret;	}	/* if the inode is dirty, let's recover all the time */	if (!datasync && is_inode_flag_set(fi, FI_DIRTY_INODE)) {		update_inode_page(inode);		goto go_write;	}	/*	 * if there is no written data, don't waste time to write recovery info.	 */	if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&			!exist_written_data(sbi, ino, APPEND_INO)) {		/* it may call write_inode just prior to fsync */		if (need_inode_page_update(sbi, ino))			goto go_write;		if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||				exist_written_data(sbi, ino, UPDATE_INO))			goto flush_out;		goto out;	}go_write:	/* guarantee free sections for fsync */	f2fs_balance_fs(sbi);	/*	 * Both of fdatasync() and fsync() are able to be recovered from	 * sudden-power-off.	 */	down_read(&fi->i_sem);	need_cp = need_do_checkpoint(inode);	up_read(&fi->i_sem);	if (need_cp) {		/* all the dirty node pages should be flushed for POR */		ret = f2fs_sync_fs(inode->i_sb, 1);		/*		 * We've secured consistency through sync_fs. Following pino		 * will be used only for fsynced inodes after checkpoint.		 */		try_to_fix_pino(inode);		clear_inode_flag(fi, FI_APPEND_WRITE);		clear_inode_flag(fi, FI_UPDATE_WRITE);		goto out;	}sync_nodes:	sync_node_pages(sbi, ino, &wbc);	/* if cp_error was enabled, we should avoid infinite loop */	if (unlikely(f2fs_cp_error(sbi)))		goto out;	if (need_inode_block_update(sbi, ino)) {		mark_inode_dirty_sync(inode);		f2fs_write_inode(inode, NULL);		goto sync_nodes;	}	ret = wait_on_node_pages_writeback(sbi, ino);	if (ret)		goto out;	/* once recovery info is written, don't need to tack this */	remove_dirty_inode(sbi, ino, APPEND_INO);	clear_inode_flag(fi, FI_APPEND_WRITE);flush_out:	remove_dirty_inode(sbi, ino, UPDATE_INO);	clear_inode_flag(fi, FI_UPDATE_WRITE);	ret = f2fs_issue_flush(sbi);//.........这里部分代码省略.........

//.........这里部分代码省略.........        err = -ENOENT;        new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,                                    &new_page);        if (!new_entry)            goto out_dir;        f2fs_lock_op(sbi);        err = acquire_orphan_inode(sbi);        if (err)            goto put_out_dir;        if (update_dent_inode(old_inode, &new_dentry->d_name)) {            release_orphan_inode(sbi);            goto put_out_dir;        }        f2fs_set_link(new_dir, new_entry, new_page, old_inode);        new_inode->i_ctime = CURRENT_TIME;        down_write(&F2FS_I(new_inode)->i_sem);        if (old_dir_entry)            drop_nlink(new_inode);        drop_nlink(new_inode);        up_write(&F2FS_I(new_inode)->i_sem);        mark_inode_dirty(new_inode);        if (!new_inode->i_nlink)            add_orphan_inode(sbi, new_inode->i_ino);        else            release_orphan_inode(sbi);        update_inode_page(old_inode);        update_inode_page(new_inode);    } else {        f2fs_lock_op(sbi);        err = f2fs_add_link(new_dentry, old_inode);        if (err) {            f2fs_unlock_op(sbi);            goto out_dir;        }        if (old_dir_entry) {            inc_nlink(new_dir);            update_inode_page(new_dir);        }    }    down_write(&F2FS_I(old_inode)->i_sem);    file_lost_pino(old_inode);    up_write(&F2FS_I(old_inode)->i_sem);    old_inode->i_ctime = CURRENT_TIME;    mark_inode_dirty(old_inode);    f2fs_delete_entry(old_entry, old_page, NULL);    if (old_dir_entry) {        if (old_dir != new_dir) {            f2fs_set_link(old_inode, old_dir_entry,                          old_dir_page, new_dir);            update_inode_page(old_inode);        } else {            kunmap(old_dir_page);

//.........这里部分代码省略.........		return -EINVAL;	ret = inode_newsize_ok(inode, (len + offset));	if (ret)		return ret;	f2fs_balance_fs(sbi);	if (f2fs_has_inline_data(inode)) {		ret = f2fs_convert_inline_inode(inode);		if (ret)			return ret;	}	ret = filemap_write_and_wait_range(mapping, offset, offset + len - 1);	if (ret)		return ret;	truncate_pagecache_range(inode, offset, offset + len - 1);	pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;	pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;	off_start = offset & (PAGE_CACHE_SIZE - 1);	off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);	if (pg_start == pg_end) {		ret = fill_zero(inode, pg_start, off_start,						off_end - off_start);		if (ret)			return ret;		if (offset + len > new_size)			new_size = offset + len;		new_size = max_t(loff_t, new_size, offset + len);	} else {		if (off_start) {			ret = fill_zero(inode, pg_start++, off_start,						PAGE_CACHE_SIZE - off_start);			if (ret)				return ret;			new_size = max_t(loff_t, new_size,						pg_start << PAGE_CACHE_SHIFT);		}		for (index = pg_start; index < pg_end; index++) {			struct dnode_of_data dn;			struct page *ipage;			f2fs_lock_op(sbi);			ipage = get_node_page(sbi, inode->i_ino);			if (IS_ERR(ipage)) {				ret = PTR_ERR(ipage);				f2fs_unlock_op(sbi);				goto out;			}			set_new_dnode(&dn, inode, ipage, NULL, 0);			ret = f2fs_reserve_block(&dn, index);			if (ret) {				f2fs_unlock_op(sbi);				goto out;			}			if (dn.data_blkaddr != NEW_ADDR) {				invalidate_blocks(sbi, dn.data_blkaddr);				dn.data_blkaddr = NEW_ADDR;				set_data_blkaddr(&dn);				dn.data_blkaddr = NULL_ADDR;				f2fs_update_extent_cache(&dn);			}			f2fs_put_dnode(&dn);			f2fs_unlock_op(sbi);			new_size = max_t(loff_t, new_size,					(index + 1) << PAGE_CACHE_SHIFT);		}		if (off_end) {			ret = fill_zero(inode, pg_end, 0, off_end);			if (ret)				goto out;			new_size = max_t(loff_t, new_size, offset + len);		}	}out:	if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) {		i_size_write(inode, new_size);		mark_inode_dirty(inode);		update_inode_page(inode);	}	return ret;}

/* * Caller should grab and release a rwsem by calling f2fs_lock_op() and * f2fs_unlock_op(). */int __f2fs_add_link(struct inode *dir, const struct qstr *name,						struct inode *inode){	unsigned int bit_pos;	unsigned int level;	unsigned int current_depth;	unsigned long bidx, block;	f2fs_hash_t dentry_hash;	struct f2fs_dir_entry *de;	unsigned int nbucket, nblock;	size_t namelen = name->len;	struct page *dentry_page = NULL;	struct f2fs_dentry_block *dentry_blk = NULL;	int slots = GET_DENTRY_SLOTS(namelen);	struct page *page;	int err = 0;	int i;	dentry_hash = f2fs_dentry_hash(name);	level = 0;	current_depth = F2FS_I(dir)->i_current_depth;	if (F2FS_I(dir)->chash == dentry_hash) {		level = F2FS_I(dir)->clevel;		F2FS_I(dir)->chash = 0;	}start:	if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))		return -ENOSPC;	/* Increase the depth, if required */	if (level == current_depth)		++current_depth;	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);	nblock = bucket_blocks(level);	bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,				(le32_to_cpu(dentry_hash) % nbucket));	for (block = bidx; block <= (bidx + nblock - 1); block++) {		dentry_page = get_new_data_page(dir, NULL, block, true);		if (IS_ERR(dentry_page))			return PTR_ERR(dentry_page);		dentry_blk = kmap(dentry_page);		bit_pos = room_for_filename(dentry_blk, slots);		if (bit_pos < NR_DENTRY_IN_BLOCK)			goto add_dentry;		kunmap(dentry_page);		f2fs_put_page(dentry_page, 1);	}	/* Move to next level to find the empty slot for new dentry */	++level;	goto start;add_dentry:	f2fs_wait_on_page_writeback(dentry_page, DATA);	down_write(&F2FS_I(inode)->i_sem);	page = init_inode_metadata(inode, dir, name);	if (IS_ERR(page)) {		err = PTR_ERR(page);		goto fail;	}	de = &dentry_blk->dentry[bit_pos];	de->hash_code = dentry_hash;	de->name_len = cpu_to_le16(namelen);	memcpy(dentry_blk->filename[bit_pos], name->name, name->len);	de->ino = cpu_to_le32(inode->i_ino);	set_de_type(de, inode);	for (i = 0; i < slots; i++)		test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);	set_page_dirty(dentry_page);	/* we don't need to mark_inode_dirty now */	F2FS_I(inode)->i_pino = dir->i_ino;	update_inode(inode, page);	f2fs_put_page(page, 1);	update_parent_metadata(dir, inode, current_depth);fail:	up_write(&F2FS_I(inode)->i_sem);	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {		update_inode_page(dir);		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}	kunmap(dentry_page);	f2fs_put_page(dentry_page, 1);	return err;}

static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,			struct inode *new_dir, struct dentry *new_dentry){	struct super_block *sb = old_dir->i_sb;	struct f2fs_sb_info *sbi = F2FS_SB(sb);	struct inode *old_inode = old_dentry->d_inode;	struct inode *new_inode = new_dentry->d_inode;	struct page *old_dir_page;	struct page *old_page, *new_page;	struct f2fs_dir_entry *old_dir_entry = NULL;	struct f2fs_dir_entry *old_entry;	struct f2fs_dir_entry *new_entry;	int err = -ENOENT;	f2fs_balance_fs(sbi);	old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);	if (!old_entry)		goto out;	if (S_ISDIR(old_inode->i_mode)) {		err = -EIO;		old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);		if (!old_dir_entry)			goto out_old;	}	f2fs_lock_op(sbi);	if (new_inode) {		err = -ENOTEMPTY;		if (old_dir_entry && !f2fs_empty_dir(new_inode))			goto out_dir;		err = -ENOENT;		new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,						&new_page);		if (!new_entry)			goto out_dir;		err = acquire_orphan_inode(sbi);		if (err)			goto put_out_dir;		if (update_dent_inode(old_inode, &new_dentry->d_name)) {			release_orphan_inode(sbi);			goto put_out_dir;		}		f2fs_set_link(new_dir, new_entry, new_page, old_inode);		new_inode->i_ctime = CURRENT_TIME;		if (old_dir_entry)			drop_nlink(new_inode);		drop_nlink(new_inode);		if (!new_inode->i_nlink)			add_orphan_inode(sbi, new_inode->i_ino);		else			release_orphan_inode(sbi);		update_inode_page(old_inode);		update_inode_page(new_inode);	} else {		err = f2fs_add_link(new_dentry, old_inode);		if (err)			goto out_dir;		if (old_dir_entry) {			inc_nlink(new_dir);			update_inode_page(new_dir);		}	}	old_inode->i_ctime = CURRENT_TIME;	mark_inode_dirty(old_inode);	f2fs_delete_entry(old_entry, old_page, NULL);	if (old_dir_entry) {		if (old_dir != new_dir) {			f2fs_set_link(old_inode, old_dir_entry,						old_dir_page, new_dir);		} else {			kunmap(old_dir_page);			f2fs_put_page(old_dir_page, 0);		}		drop_nlink(old_dir);		update_inode_page(old_dir);	}	f2fs_unlock_op(sbi);	return 0;put_out_dir:	if (PageLocked(new_page))		f2fs_put_page(new_page, 1);	else		f2fs_put_page(new_page, 0);//.........这里部分代码省略.........