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

/* Primary function to update the seguse_table. Updates the segusage entry for * the partiulcar segment. */void segusetbl_update_entry(struct super_block *sb, int segnum, 			    struct segusage *seguse){	int offset;	sector_t newblock;	struct buffer_head *bh;	struct inode *inode = SEGUSETBL_INODE(sb);	struct segusage *pseguse = NULL;	if(is_new_segment(segnum, inode))		inode->i_size += LFS_SEGUSE_SIZE;	bh = segusetbl_read_entry(sb, segnum, &pseguse);	/* update the seguse_table */	if(bh) {		/* updating the in-memory contents */		//dprintk("Updating in-memory contents/n");		offset = LFS_CI_SIZE + LFS_SEGUSE_SIZE * segnum;		offset = offset % LFS_BSIZE;		//dprintk("Updating at offset = %d/n", offset);		newblock = segment_write_block_from_bh(			 	sb, seguse, LFS_SEGUSE_SIZE, offset, bh);		if(newblock != bh->b_blocknr)			update_inode(inode, get_iblock_nr(segnum), newblock);		brelse(bh);	}	else {			/* new seguse entry */		offset = 0;		newblock = segment_write_block(	sb, seguse, LFS_SEGUSE_SIZE, 						offset, 0);		update_inode(inode, get_iblock_nr(segnum), newblock);		//dprintk("updating %Lu to %Lu block/n", get_iblock_nr(segp), newblock);	}	mark_inode_dirty(inode);}

bool recover_inline_data(struct inode *inode, struct page *npage){    struct f2fs_sb_info *sbi = F2FS_I_SB(inode);    struct f2fs_inode *ri = NULL;    void *src_addr, *dst_addr;    struct page *ipage;    /*     * The inline_data recovery policy is as follows.     * [prev.] [next] of inline_data flag     *    o       o  -> recover inline_data     *    o       x  -> remove inline_data, and then recover data blocks     *    x       o  -> remove inline_data, and then recover inline_data     *    x       x  -> recover data blocks     */    if (IS_INODE(npage))        ri = F2FS_INODE(npage);    if (f2fs_has_inline_data(inode) &&            ri && (ri->i_inline & F2FS_INLINE_DATA)) {process_inline:        ipage = get_node_page(sbi, inode->i_ino);        f2fs_bug_on(sbi, IS_ERR(ipage));        f2fs_wait_on_page_writeback(ipage, NODE);        src_addr = inline_data_addr(npage);        dst_addr = inline_data_addr(ipage);        memcpy(dst_addr, src_addr, MAX_INLINE_DATA);        set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);        set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);        update_inode(inode, ipage);        f2fs_put_page(ipage, 1);        return true;    }    if (f2fs_has_inline_data(inode)) {        ipage = get_node_page(sbi, inode->i_ino);        f2fs_bug_on(sbi, IS_ERR(ipage));        truncate_inline_inode(ipage, 0);        f2fs_clear_inline_inode(inode);        update_inode(inode, ipage);        f2fs_put_page(ipage, 1);    } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {        truncate_blocks(inode, 0, false);        goto process_inline;    }    return false;}

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

int gen_inum(MFS_Header_t **header, int offset) {	int i, j, tmp_offset;	MFS_Imap_t *imap_temp;	void *block_ptr = (void *)(*header) + sizeof(MFS_Header_t);	i = 0;	while(i < 4096/ 14) {		if((*header)->map[i] == -1) {			imap_temp = allot_space(header, sizeof(MFS_Imap_t), &tmp_offset);						for(j = 0; j < 14; j++) {				imap_temp->inodes[j] = -1;			}						imap_temp->inodes[0] = offset;			(*header)->map[i] = tmp_offset;						return (i * 14) + 0;		} else {			imap_temp = (MFS_Imap_t *)(block_ptr + (*header)->map[i]);						for(j = 0; j < 14; j++) {				if(imap_temp->inodes[j] == -1) {					update_inode(header, (i * 14) + j, offset);					return (i * 14) + j;				}			}		}		i++;	}	return -1;}

int recover_inline_data(struct inode *inode, struct page *npage){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct f2fs_inode *ri = NULL;	void *src_addr, *dst_addr;	struct page *ipage;	/*	 * The inline_data recovery policy is as follows.	 * [prev.] [next] of inline_data flag	 *    o       o  -> recover inline_data	 *    o       x  -> remove inline_data, and then recover data blocks	 *    x       o  -> remove inline_data, and then recover inline_data	 *    x       x  -> recover data blocks	 */	if (IS_INODE(npage))		ri = F2FS_INODE(npage);	if (f2fs_has_inline_data(inode) &&			ri && ri->i_inline & F2FS_INLINE_DATA) {process_inline:		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(IS_ERR(ipage));		src_addr = inline_data_addr(npage);		dst_addr = inline_data_addr(ipage);		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);		update_inode(inode, ipage);		f2fs_put_page(ipage, 1);		return -1;	}	if (f2fs_has_inline_data(inode)) {		ipage = get_node_page(sbi, inode->i_ino);		f2fs_bug_on(IS_ERR(ipage));		zero_user_segment(ipage, INLINE_DATA_OFFSET,				 INLINE_DATA_OFFSET + MAX_INLINE_DATA);		clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);		update_inode(inode, ipage);		f2fs_put_page(ipage, 1);	} else if (ri && ri->i_inline & F2FS_INLINE_DATA) {		truncate_blocks(inode, 0);		set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);		goto process_inline;	}	return 0;}

static int change_root_fmap (tree_s *tree, buf_s *root){	info_s	*file = container(tree, info_s, in_tree);	int	rc;FN;	file->in_inode.i_root = root->b_blkno;	rc = update_inode( &file->in_inode);	return rc;}

int update_inode_page(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct page *node_page;	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	update_inode(inode, node_page);	f2fs_put_page(node_page, 1);	return 0;}

void update_inode_page(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct page *node_page;retry:	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page)) {		int err = PTR_ERR(node_page);		if (err == -ENOMEM) {			cond_resched();			goto retry;		} else if (err != -ENOENT) {			f2fs_stop_checkpoint(sbi);		}		return;	}	update_inode(inode, node_page);	f2fs_put_page(node_page, 1);}

int f2fs_do_tmpfile(struct inode *inode, struct inode *dir){	struct page *page;	int err = 0;	down_write(&F2FS_I(inode)->i_sem);	page = init_inode_metadata(inode, dir, NULL);	if (IS_ERR(page)) {		err = PTR_ERR(page);		goto fail;	}	/* we don't need to mark_inode_dirty now */	update_inode(inode, page);	f2fs_put_page(page, 1);	clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);fail:	up_write(&F2FS_I(inode)->i_sem);	return err;}

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

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

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,                          struct inode *inode, nid_t ino, umode_t mode){    struct f2fs_sb_info *sbi = F2FS_I_SB(dir);    struct page *ipage;    unsigned int bit_pos;    f2fs_hash_t name_hash;    size_t namelen = name->len;    struct f2fs_inline_dentry *dentry_blk = NULL;    struct f2fs_dentry_ptr d;    int slots = GET_DENTRY_SLOTS(namelen);    struct page *page = NULL;    int err = 0;    ipage = get_node_page(sbi, dir->i_ino);    if (IS_ERR(ipage))        return PTR_ERR(ipage);    dentry_blk = inline_data_addr(ipage);    bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,                                slots, NR_INLINE_DENTRY);    if (bit_pos >= NR_INLINE_DENTRY) {        err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);        if (!err)            err = -EAGAIN;        goto out;    }    if (inode) {        down_write(&F2FS_I(inode)->i_sem);        page = init_inode_metadata(inode, dir, name, ipage);        if (IS_ERR(page)) {            err = PTR_ERR(page);            goto fail;        }    }    f2fs_wait_on_page_writeback(ipage, NODE);    name_hash = f2fs_dentry_hash(name);    make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);    f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);    set_page_dirty(ipage);    /* we don't need to mark_inode_dirty now */    if (inode) {        F2FS_I(inode)->i_pino = dir->i_ino;        update_inode(inode, page);        f2fs_put_page(page, 1);    }    update_parent_metadata(dir, inode, 0);fail:    if (inode)        up_write(&F2FS_I(inode)->i_sem);    if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {        update_inode(dir, ipage);        clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);    }out:    f2fs_put_page(ipage, 1);    return err;}

//.........这里部分代码省略.........	file_update_time(inode); //BrechREiZ: We need this for Kernel 2.6.17	written = 0;	do {		long offset;		size_t copied;		int i, siblock, eiblock, boffset;		sector_t block;						offset = (segp->offset % BUF_IN_PAGE) * LFS_BSIZE; 		offset += pos & (LFS_BSIZE - 1); /* within block */		bytes = PAGE_CACHE_SIZE - offset; /* number of bytes written						     in this iteration */		invalidate_old_page(inode, pos);		if (bytes > count) 			bytes = count;				//dprintk("1:segp->start=%Lu,segp->offset=%d,segp->end=%Lu,offset=%lu,bytes=%d/n", segp->start, segp->offset, segp->end,offset,bytes);				siblock = pos >> LFS_BSIZE_BITS;		eiblock = (pos + bytes - 1) >> LFS_BSIZE_BITS;		//dprintk("writing %d bytes at offset %ld (pos = %Lu)/n", bytes, offset, pos);		//dprintk("siblock = %d, eiblock = %d/n", siblock, eiblock);				/*		 * Bring in the user page that we will copy from _first_.		 * Otherwise there's a nasty deadlock on copying from the		 * same page as we're writing to, without it being marked		 * up-to-date.		 */		fault_in_pages_readable(buf, bytes);		page = get_seg_page(segp);		if (!page) {			res = -ENOMEM;			break;		}		/* fill the page with current inode blocks if any */		boffset = offset / LFS_BSIZE;;		for(i = siblock; i <= eiblock; ++i, ++boffset) {			struct buffer_head *bh;			//dprintk("Asking for block %d/n", i);			bh = lfs_read_block(inode, i);			if(!bh) /* new block */				break;			//dprintk("boffset = %d/n", boffset);			memcpy(page_address(page) + LFS_BSIZE * boffset, bh->b_data, LFS_BSIZE);			brelse(bh);		}		copied = __copy_from_user(page_address(page) + offset, buf, bytes);		flush_dcache_page(page);		block = segp->start + segp->offset;		for(i = siblock;i <= eiblock; ++i, ++block)			segsum_update_finfo(segp, inode->i_ino, i, block);		block = segp->start + segp->offset;		segp->offset += (bytes  - 1)/LFS_BSIZE + 1;		//dprintk("2:segp->start=%Lu,segp->offset=%d,segp->end=%Lu,offset=%lu,bytes=%d/n",		//segp->start, segp->offset, segp->end,offset,bytes);		BUG_ON(segp->start + segp->offset > segp->end);		if(segp->start + segp->offset == segp->end) {			dprintk("allocating new segment/n");			/* This also is going to write the previous segment */			segment_allocate_new(inode->i_sb, segp, segp->start + segp->offset);			segp = LFS_SBI(sb)->s_curr;		}		/* update the inode */		for(i = siblock;i <= eiblock; ++i, ++block)			update_inode(inode, i, block);		//dprintk("start=%Lu,offset=%d,end=%Lu/n", segp->start, segp->offset, segp->end);		segusetbl_add_livebytes(sb, segp->segnum, bytes);				written += bytes;		buf += bytes;		pos += bytes;		count -= bytes;	} while(count);	*ppos = pos;	if(pos > inode->i_size)		i_size_write(inode, pos);	if(written)		mark_inode_dirty(inode);		lfs_unlock(sb);	//up(&inode->i_sem);	mutex_unlock(&inode->i_mutex); //BrechREiZ: and unlocking...	return written ? written : res;out:	lfs_unlock(sb);	//up(&inode->i_sem);	mutex_unlock(&inode->i_mutex); //BrechREiZ: and unlocking...	return res; }

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,						struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct page *ipage;	unsigned int bit_pos;	f2fs_hash_t name_hash;	struct f2fs_dir_entry *de;	size_t namelen = name->len;	struct f2fs_inline_dentry *dentry_blk = NULL;	int slots = GET_DENTRY_SLOTS(namelen);	struct page *page;	int err = 0;	int i;	name_hash = f2fs_dentry_hash(name);	ipage = get_node_page(sbi, dir->i_ino);	if (IS_ERR(ipage))		return PTR_ERR(ipage);	dentry_blk = inline_data_addr(ipage);	bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,						slots, NR_INLINE_DENTRY);	if (bit_pos >= NR_INLINE_DENTRY) {		err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);		if (!err)			err = -EAGAIN;		goto out;	}	down_write(&F2FS_I(inode)->i_sem);	page = init_inode_metadata(inode, dir, name, ipage);	if (IS_ERR(page)) {		err = PTR_ERR(page);		goto fail;	}	f2fs_wait_on_page_writeback(ipage, NODE);	de = &dentry_blk->dentry[bit_pos];	de->hash_code = name_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(ipage);	/* 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, 0);fail:	up_write(&F2FS_I(inode)->i_sem);	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {		update_inode(dir, ipage);		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}out:	f2fs_put_page(ipage, 1);	return err;}

//.........这里部分代码省略.........	} else if (ino == F2FS_META_INO(sbi)) {		inode->i_mapping->a_ops = &f2fs_meta_aops;		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);	} else if (S_ISREG(inode->i_mode)) {		inode->i_op = &f2fs_file_inode_operations;		inode->i_fop = &f2fs_file_operations;		inode->i_mapping->a_ops = &f2fs_dblock_aops;	} else if (S_ISDIR(inode->i_mode)) {		inode->i_op = &f2fs_dir_inode_operations;		inode->i_fop = &f2fs_dir_operations;		inode->i_mapping->a_ops = &f2fs_dblock_aops;		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER_MOVABLE |				__GFP_ZERO);	} else if (S_ISLNK(inode->i_mode)) {		inode->i_op = &f2fs_symlink_inode_operations;		inode->i_mapping->a_ops = &f2fs_dblock_aops;	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {		inode->i_op = &f2fs_special_inode_operations;		init_special_inode(inode, inode->i_mode, inode->i_rdev);	} else {		ret = -EIO;		goto bad_inode;	}	unlock_new_inode(inode);	return inode;bad_inode:	iget_failed(inode);	return ERR_PTR(ret);}void update_inode(struct inode *inode, struct page *node_page){	struct f2fs_node *rn;	struct f2fs_inode *ri;	wait_on_page_writeback(node_page);	rn = page_address(node_page);	ri = &(rn->i);	ri->i_mode = cpu_to_le16(inode->i_mode);	ri->i_advise = F2FS_I(inode)->i_advise;	ri->i_uid = cpu_to_le32(i_uid_read(inode));	ri->i_gid = cpu_to_le32(i_gid_read(inode));	ri->i_links = cpu_to_le32(inode->i_nlink);	ri->i_size = cpu_to_le64(i_size_read(inode));	ri->i_blocks = cpu_to_le64(inode->i_blocks);	set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);	ri->i_generation = cpu_to_le32(inode->i_generation);	set_cold_node(inode, node_page);	set_page_dirty(node_page);}

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

uint8_t* ramdisk_init(){	int i;	uint8_t* ramdisk;	int root_bid;	struct rd_inode* root_inode;	struct rd_super_block* InitSuperBlock;#ifdef UL_DEBUG	if(!(ramdisk=(uint8_t*)malloc(RAMDISK_SIZE*sizeof(uint8_t)))){		fprintf(stderr,"No sufficient mem space for ramdisk!/n");		exit(-1);	}#endif#ifndef UL_DEBUG	if(!(ramdisk=(uint8_t*)vmalloc(RAMDISK_SIZE*sizeof(uint8_t)))){		printk("<1> No sufficient mem space for ramdisk!/n");		return NULL;	}#endif	//Nullify all the data in ramdisk	memset(ramdisk,0,RAMDISK_SIZE);	//Init the bitmap	for(i=0;i<=(BITMAP_LIMIT+1)/RD_BLOCK_SIZE;i++){		set_bitmap(ramdisk,i);	}	//Init the root directory	root_bid=find_next_free_block(ramdisk);//BlockNO for root dir#ifdef UL_DEBUG	if(!(root_inode=(struct rd_inode*)malloc(sizeof(struct rd_inode)))){		fprintf(stderr, "No sufficient mem space for root dir!/n");		exit(-1);	}#endif#ifndef UL_DEBUG	if(!(root_inode=(struct rd_inode*)vmalloc(sizeof(struct rd_inode)))){		printk("<1> No sufficient mem space for root dir!/n");		return NULL;	}#endif	root_inode->type=0;	root_inode->size=0;	root_inode->BlockPointer[0]=root_bid;	update_inode(ramdisk,0,root_inode);		//Init the superblock#ifdef UL_DEBUG	if(!(InitSuperBlock=(struct rd_super_block*)malloc(sizeof(struct rd_super_block)))){		fprintf(stderr,"No sufficient mem/n");		exit(-1);	}#endif #ifndef UL_DEBUG	if(!(InitSuperBlock=(struct rd_super_block*)vmalloc(sizeof(struct rd_super_block)))){		printk("<1> No sufficient mem/n");		return NULL;	}#endif 	InitSuperBlock->FreeBlockNum=BLOCK_NUM-(BITMAP_LIMIT+1)/RD_BLOCK_SIZE;	InitSuperBlock->FreeInodeNum=INODE_NUM-1;//The root dir takes one inode	memset(InitSuperBlock->InodeBitmap,0,INODEBITMAP_SIZE);	update_superblock(ramdisk,InitSuperBlock);		//Init the inode bitmap in superblock	set_inode_bitmap(ramdisk,0);#ifndef UL_DEBUG	vfree(root_inode);#endif	return ramdisk;	}

//.........这里部分代码省略.........								prot_r->ret = -1;				MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);				prot_r->ret = lookup(block_ptr, parent_inode, &(prot_r->datapacket[0]));			} else if(prot_r->cmd == CMD_SHUTDOWN){				//Close file				rc = close(fd);				if(rc < 0){					fprintf(stderr, "Cannot open file");					exit(1);				}				prot_r->ret = 0;				if(UDP_Write(sd, &s, (char*)prot_r, sizeof(MFS_Prot_t)) < -1){					fprintf(stderr, "Unable to send result");					exit(1);				}				exit(0);			} else if(prot_r->cmd == CMD_UNLINK){								verify(&header, &block_ptr, 16384);				prot_r->ret = -1;				MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);				if(parent_inode != NULL && parent_inode->type == MFS_DIRECTORY){					int exist = lookup(block_ptr, parent_inode, &(prot_r->datapacket[0]));					if(exist != -1){						//Check if empty						MFS_Inode_t* this_inode = fix_inode(header, exist);						if(!(this_inode->type == MFS_DIRECTORY && this_inode->size != 0)){							//Need to remove							MFS_DirEnt_t* new_dir_entry = allot_space(&header, MFS_BLOCK_SIZE, &entry_offset);							MFS_Inode_t* new_parent_inode = allot_space(&header, sizeof(MFS_Inode_t), &parent_inode_offset);							prepare_inode(new_parent_inode, 0, parent_inode);							update_inode(&header, prot_r->pinum, parent_inode_offset);							i = 0, done = 0;							while(i < 14) {								if(parent_inode->data[i] != -1){									j = 0;									while(j < MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t)){										//printf("Parent node %d %d/n", inode->data[i], MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t) );										MFS_DirEnt_t* entry = (MFS_DirEnt_t*)(block_ptr + parent_inode->data[i] + (j * sizeof(MFS_DirEnt_t)));													if(entry->inum != -1 && strcmp(entry->name, prot_r->datapacket) == 0 ){											memcpy(new_dir_entry, block_ptr + parent_inode->data[i] , MFS_BLOCK_SIZE);											//We now know which entry											new_parent_inode->data[i] = entry_offset;											new_dir_entry[j].inum = -1;											update_inode(&header, exist, -1);											prot_r->ret = 0;											new_parent_inode->size--;											done = 1;											break;										}										j++;									}									if(done == 1) break;								}								i++;							}						}					}else{						prot_r->ret = 0;					}				}