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

/*********************************************************************************************************** Function name:           socket_attach** Descriptions:            联结 socket** input parameters:        sock_fd             socket 的私有文件描述符** output parameters:       NONE** Returned value:          IO 系统文件描述符*********************************************************************************************************/int socket_attach(int sock_fd){    char path[PATH_MAX];    int fd;    privinfo_t *priv;    reg_t reg;    file_t *file;    int err;    priv = kmalloc(sizeof(privinfo_t), GFP_KERNEL);    if (priv != NULL) {        priv->sock_fd = sock_fd;        device_init(priv);        sprintf(path, "/dev/socket%d", sock_fd);        reg = interrupt_disable();        if (device_create(path, "socket", priv) < 0) {            interrupt_resume(reg);            kfree(priv);            return -1;        }        fd = vfs_open(path, O_RDWR, 0666);        if (fd < 0) {            geterrno(err);            vfs_unlink(path);            seterrno(err);            interrupt_resume(reg);            kfree(priv);            return -1;        }        file = vfs_get_file(fd);        if (file == NULL) {            geterrno(err);            vfs_close(fd);            vfs_unlink(path);            seterrno(err);            interrupt_resume(reg);            kfree(priv);            return -1;        }        file->type = VFS_FILE_TYPE_SOCK;        vfs_put_file(file);        lwip_socket_set_ctx(sock_fd, priv);        interrupt_resume(reg);        seterrno(0);        return fd;    } else {        seterrno(ENOMEM);        return -1;    }}

/** * ecryptfs_do_create * @directory_inode: inode of the new file's dentry's parent in ecryptfs * @ecryptfs_dentry: New file's dentry in ecryptfs * @mode: The mode of the new file * * Creates the underlying file and the eCryptfs inode which will link to * it. It will also update the eCryptfs directory inode to mimic the * stat of the lower directory inode. * * Returns the new eCryptfs inode on success; an ERR_PTR on error condition */static struct inode *ecryptfs_do_create(struct inode *directory_inode,		   struct dentry *ecryptfs_dentry, umode_t mode){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	struct inode *inode;	lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);	if (rc) {		printk(KERN_ERR "%s: Failure to create dentry in lower fs; "		       "rc = [%d]/n", __func__, rc);		inode = ERR_PTR(rc);		goto out_lock;	}	inode = __ecryptfs_get_inode(d_inode(lower_dentry),				     directory_inode->i_sb);	if (IS_ERR(inode)) {		vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);		goto out_lock;	}	fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));	fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));out_lock:	unlock_dir(lower_dir_dentry);	return inode;}

int main(){    struct dentry *dentry = NULL;    struct inode *inode = NULL;    return vfs_unlink(inode, dentry, &inode);}

int	do_unlink (struct inode *inode, const char *name, int len){#if POST_20_KERNEL_F	struct dentry	*tmp_dent;#endif	int		ret_code;	DOWN(&(inode->i_sem));#if POST_20_KERNEL_F		/* Grab a dentry for the file being unlinked. */	ret_code = ovlfs_inode_get_child_dentry(inode, name, len, &tmp_dent,	                                        OVLFS_DENT_GET_POSITIVE);	if ( ret_code == 0 )	{			/* Use the vfs_unlink function to do the dirty work. */		ret_code = vfs_unlink(inode, tmp_dent);		dput(tmp_dent);	}#else	IMARK(inode);	ret = inode->i_op->unlink(inode, fname, len);#endif	UP(&(inode->i_sem));	return	ret_code;}

static int mlog_vfs_destroy(struct mlog_handle *handle){	struct dentry *dentry = NULL;	struct mlog_ctxt *ctxt = NULL;	int ret = 0;	struct vfsmount *mnt = NULL;	MENTRY();	dentry = handle->mgh_file->f_dentry;	mnt = handle->mgh_file->f_vfsmnt;	ctxt = handle->mgh_ctxt;	MASSERT(dentry->d_parent == ctxt->moc_dlog);	mntget(mnt);	dget(dentry);	ret = mlog_vfs_close(handle);	if (ret == 0) {		mutex_lock(&dentry->d_parent->d_inode->i_mutex);		ret = vfs_unlink(dentry->d_parent->d_inode, dentry);		mutex_unlock(&dentry->d_parent->d_inode->i_mutex);	}	dput(dentry);	mntput(mnt);	MRETURN(ret);}

static int delete_partial_file(struct file *fp){	int rc;	struct dentry *d = fp->f_path.dentry;	struct inode *pi = fp->f_path.dentry->d_parent->d_inode;	struct dentry *pd = NULL;	dget(d);	pd= dget_parent(d);	mutex_lock_nested(&pd->d_inode->i_mutex,I_MUTEX_PARENT);		rc= vfs_unlink(pi,d,NULL);	if(rc){		printk("Error in vfs_unlink() /n");		rc= -ECANCELED;		goto out;	}	out:	mutex_unlock(&pd->d_inode->i_mutex);	dput(pd);	dput(d);	printk("rc = %d/n",rc);	return rc;}																																																			

static int sdcardfs_unlink(struct inode *dir, struct dentry *dentry){	int err;	struct dentry *lower_dentry;	struct inode *lower_dir_inode = sdcardfs_lower_inode(dir);	struct dentry *lower_dir_dentry;	struct path lower_path;	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);	const struct cred *saved_cred = NULL;	int has_rw = get_caller_has_rw_locked(sbi->pkgl_id, sbi->options.derive);	if(!check_caller_access_to_name(dir, dentry->d_name.name, sbi->options.derive, 1, has_rw)) {		printk(KERN_INFO "%s: need to check the caller's gid in packages.list/n" 						 "  dentry: %s, task:%s/n",						 __func__, dentry->d_name.name, current->comm);		err = -EACCES;		goto out_eacces;	}	/* save current_cred and override it */	OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb), saved_cred);	sdcardfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	err = mnt_want_write(lower_path.mnt);	if (err)		goto out_unlock;	err = vfs_unlink(lower_dir_inode, lower_dentry);	/*	 * Note: unlinking on top of NFS can cause silly-renamed files.	 * Trying to delete such files results in EBUSY from NFS	 * below.  Silly-renamed files will get deleted by NFS later on, so	 * we just need to detect them here and treat such EBUSY errors as	 * if the upper file was successfully deleted.	 */	if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)		err = 0;	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_dir_inode);	fsstack_copy_inode_size(dir, lower_dir_inode);	set_nlink(dentry->d_inode,		  sdcardfs_lower_inode(dentry->d_inode)->i_nlink);	dentry->d_inode->i_ctime = dir->i_ctime;	d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */out:	mnt_drop_write(lower_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	sdcardfs_put_lower_path(dentry, &lower_path);	REVERT_CRED(saved_cred);out_eacces:	return err;}

int main(){    struct dentry *dentry = NULL;    struct inode *inode = NULL;    struct vfsmount *mnt = NULL;    return vfs_unlink(inode, dentry, mnt);}

void __u2fs_unlink(struct work_struct *work){	struct sioq_args *args = container_of(work, struct sioq_args, work);	struct unlink_args *u = &args->unlink;	args->err = vfs_unlink(u->parent, u->dentry);	complete(&args->comp);}

static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry){	int err;	struct dentry *newdentry;	const struct cred *old_cred;	struct cred *override_cred;	/* FIXME: recheck lower dentry to see if whiteout is really needed */	err = -ENOMEM;	override_cred = ovl_prepare_creds(dentry->d_sb);	if (!override_cred)		goto out;	override_cred->fsuid = make_kuid(override_cred->user_ns, 0);	if (!uid_valid(override_cred->fsuid))		override_cred->fsuid = GLOBAL_ROOT_UID;	override_cred->fsgid = make_kgid(override_cred->user_ns, 0);	if (!gid_valid(override_cred->fsgid))		override_cred->fsgid = GLOBAL_ROOT_GID;	old_cred = override_creds(override_cred);	newdentry = lookup_one_len(dentry->d_name.name, upperdir,				   dentry->d_name.len);	err = PTR_ERR(newdentry);	if (IS_ERR(newdentry))		goto out_put_cred;	/* Just been removed within the same locked region */	WARN_ON(newdentry->d_inode);	err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink);	if (err)		goto out_dput;	ovl_dentry_version_inc(dentry->d_parent);	err = ovl_do_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0);	if (err)		vfs_unlink(upperdir->d_inode, newdentry, NULL);out_dput:	dput(newdentry);out_put_cred:	revert_creds(old_cred);	put_cred(override_cred);out:	if (err) {		/*		 * There's no way to recover from failure to whiteout.		 * What should we do?  Log a big fat error and... ?		 */		pr_err("overlayfs: ERROR - failed to whiteout '%s'/n",		       dentry->d_name.name);	}	return err;}

/** * ecryptfs_do_create2 * @directory_inode: inode of the new file's dentry's parent in ecryptfs * @ecryptfs_dentry: New file's dentry in ecryptfs * @mode: The mode of the new file * @nd: nameidata of ecryptfs' parent's dentry & vfsmount * * Creates the underlying file and the eCryptfs inode which will link to * it. It will also update the eCryptfs directory inode to mimic the * stat of the lower directory inode. * * Returns the new eCryptfs inode on success; an ERR_PTR on error condition */static struct inode *ecryptfs_do_create2(struct inode *directory_inode,		   struct dentry *ecryptfs_dentry, umode_t mode, struct nameidata *nd){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	struct vfsmount *lower_mnt = NULL;	struct inode *inode = NULL;	struct dentry *dentry_save = NULL;	struct vfsmount *vfsmount_save = NULL;	lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);	lower_mnt = ecryptfs_dentry_to_lower_mnt(ecryptfs_dentry);	if (!lower_dentry->d_op || !lower_dentry->d_op->d_revalidate)		goto out;	lower_dir_dentry = lock_parent(lower_dentry);	if (IS_ERR(lower_dir_dentry)) {		ecryptfs_printk(KERN_ERR, "Error locking directory of "				"dentry/n");		inode = ERR_CAST(lower_dir_dentry);		goto out;	}	if (nd) {		dentry_save = nd->path.dentry;		vfsmount_save = nd->path.mnt;		nd->path.dentry = lower_dentry;		nd->path.mnt = lower_mnt;	}	rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, nd);	if (nd) {		nd->path.dentry = dentry_save;		nd->path.mnt = vfsmount_save;	}	if (rc) {		printk(KERN_ERR "%s: Failure to create dentry in lower fs; "		       "rc = [%d]/n", __func__, rc);		inode = ERR_PTR(rc);		goto out_lock;	}	inode = __ecryptfs_get_inode(lower_dentry->d_inode,				     directory_inode->i_sb);	if (IS_ERR(inode)) {		vfs_unlink(lower_dir_dentry->d_inode, lower_dentry);		goto out_lock;	}	fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);	fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);out_lock:	unlock_dir(lower_dir_dentry);out:	return inode;}

voidhwgfs_unregister(	hwgfs_handle_t		de){	struct inode		*parent_inode = de->d_parent->d_inode;	if (S_ISDIR(de->d_inode->i_mode))		vfs_rmdir(parent_inode, de);	else		vfs_unlink(parent_inode, de);}

/* sysfile_unlink - unlink file */intsysfile_unlink(const char *__path) {    int ret;    char *path;    if ((ret = copy_path(&path, __path)) != 0) {        return ret;    }    ret = vfs_unlink(path);    kfree(path);    return ret;}

int remove_file(struct file *fp){    mm_segment_t oldfs=get_fs();    int ret;    struct dentry *fp_dentry=NULL;    set_fs(get_ds());    fp_dentry=fp->f_dentry;    filp_close(fp,NULL);    ret= vfs_unlink(fp_dentry->d_parent->d_inode,fp_dentry);    set_fs(oldfs);    return ret;}

void unlink_file_ghost(ghost_t *ghost){	struct file_ghost_data *ghost_data = ghost->data;	struct dentry *dentry = ghost_data->file->f_dentry;	struct inode *dir = dentry->d_parent->d_inode;	BUG_ON(ghost_data->from_fd);	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);	vfs_unlink(dir, dentry);	mutex_unlock(&dir->i_mutex);}

int sys_unlink (char *pathname){	error_t err = 0;	if((err = vfs_unlink(current_task->vfs_cwd, pathname)))	{		current_thread->info.errno = (err < 0) ? -err : err;		return -1;	}  	return 0;}

int devtmpfs_delete_node(struct device *dev){	const char *tmp = NULL;	const char *nodename;	const struct cred *curr_cred;	struct nameidata nd;	struct dentry *dentry;	struct kstat stat;	int deleted = 1;	int err;	if (!dev_mnt)		return 0;	nodename = device_get_devnode(dev, NULL, &tmp);	if (!nodename)		return -ENOMEM;	curr_cred = override_creds(&init_cred);	err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,			      nodename, LOOKUP_PARENT, &nd);	if (err)		goto out;	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);	dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);	if (!IS_ERR(dentry)) {		if (dentry->d_inode) {			err = vfs_getattr(nd.path.mnt, dentry, &stat);			if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {				err = vfs_unlink(nd.path.dentry->d_inode,						 dentry);				if (!err || err == -ENOENT)					deleted = 1;			}		} else {			err = -ENOENT;		}		dput(dentry);	} else {		err = PTR_ERR(dentry);	}	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);	path_put(&nd.path);	if (deleted && strchr(nodename, '/'))		delete_path(nodename);out:	kfree(tmp);	revert_creds(curr_cred);	return err;}

static int wrapfs_unlink(struct inode *dir, struct dentry *dentry){	int err;	struct dentry *lower_dentry;	struct inode *lower_dir_inode = wrapfs_lower_inode(dir);	struct dentry *lower_dir_dentry;	struct path lower_path;	if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)		DEBUG_MESG("Enter");	wrapfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	err = mnt_want_write(lower_path.mnt);	if (err)		goto out_unlock;	err = vfs_unlink(lower_dir_inode, lower_dentry);	/*	 * Note: unlinking on top of NFS can cause silly-renamed files.	 * Trying to delete such files results in EBUSY from NFS	 * below.  Silly-renamed files will get deleted by NFS later on, so	 * we just need to detect them here and treat such EBUSY errors as	 * if the upper file was successfully deleted.	 */	if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)		err = 0;	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_dir_inode);	fsstack_copy_inode_size(dir, lower_dir_inode);	set_nlink(dentry->d_inode,		  wrapfs_lower_inode(dentry->d_inode)->i_nlink);	dentry->d_inode->i_ctime = dir->i_ctime;	d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */out:	mnt_drop_write(lower_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	wrapfs_put_lower_path(dentry, &lower_path);	if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)		DEBUG_RETURN("Exit", err);	return err;}

static intnfsd4_remove_clid_file(struct dentry *dir, struct dentry *dentry){	int status;	if (!S_ISREG(dir->d_inode->i_mode)) {		printk("nfsd4: non-file found in client recovery directory/n");		return -EINVAL;	}	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);	status = vfs_unlink(dir->d_inode, dentry);	mutex_unlock(&dir->d_inode->i_mutex);	return status;}

static int handle_remove(const char *nodename, struct device *dev){	struct nameidata nd;	struct dentry *dentry;	struct kstat stat;	int deleted = 1;	int err;	err = kern_path_parent(nodename, &nd);	if (err)		return err;	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);	dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);	if (!IS_ERR(dentry)) {		if (dentry->d_inode) {			err = vfs_getattr(nd.path.mnt, dentry, &stat);			if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {				struct iattr newattrs;				/*				 * before unlinking this node, reset permissions				 * of possible references like hardlinks				 */				newattrs.ia_uid = 0;				newattrs.ia_gid = 0;				newattrs.ia_mode = stat.mode & ~0777;				newattrs.ia_valid =					ATTR_UID|ATTR_GID|ATTR_MODE;				mutex_lock(&dentry->d_inode->i_mutex);				notify_change(dentry, &newattrs);				mutex_unlock(&dentry->d_inode->i_mutex);				err = vfs_unlink(nd.path.dentry->d_inode,						 dentry);				if (!err || err == -ENOENT)					deleted = 1;			}		} else {			err = -ENOENT;		}		dput(dentry);	} else {		err = PTR_ERR(dentry);	}	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);	path_put(&nd.path);	if (deleted && strchr(nodename, '/'))		delete_path(nodename);	return err;}

int sys_unlink (char *pathname){	error_t err = 0;	struct ku_obj ku_path;	KU_BUFF(ku_path, pathname);	if((err = vfs_unlink(&current_task->vfs_cwd, &ku_path)))	{		current_thread->info.errno = (err < 0) ? -err : err;		return -1;	}  	return 0;}

static int esdfs_unlink(struct inode *dir, struct dentry *dentry){	int err;	struct dentry *lower_dentry;	struct inode *lower_dir_inode = esdfs_lower_inode(dir);	struct dentry *lower_dir_dentry;	struct path lower_path;	const struct cred *creds;	creds = esdfs_override_creds(ESDFS_SB(dir->i_sb), NULL);	if (!creds)		return -ENOMEM;	esdfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	err = mnt_want_write(lower_path.mnt);	if (err)		goto out_unlock;	err = vfs_unlink(lower_dir_inode, lower_dentry);	/*	 * Note: unlinking on top of NFS can cause silly-renamed files.	 * Trying to delete such files results in EBUSY from NFS	 * below.  Silly-renamed files will get deleted by NFS later on, so	 * we just need to detect them here and treat such EBUSY errors as	 * if the upper file was successfully deleted.	 */	if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)		err = 0;	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_dir_inode);	fsstack_copy_inode_size(dir, lower_dir_inode);	set_nlink(dentry->d_inode,		  esdfs_lower_inode(dentry->d_inode)->i_nlink);	dentry->d_inode->i_ctime = dir->i_ctime;	d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */out:	mnt_drop_write(lower_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	esdfs_put_lower_path(dentry, &lower_path);	esdfs_revert_creds(creds, NULL);	return err;}

int do_vfsub_unlink(struct inode *dir, struct dentry *dentry){	int err;	LKTRTrace("i%lu, %.*s/n", dir->i_ino, AuDLNPair(dentry));	IMustLock(dir);	/* vfs_unlink() locks inode */	lockdep_off();	err = vfs_unlink(dir, dentry);	lockdep_on();	/* dir inode is locked */	if (!err)		au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/	return err;}

static struct inode *scfs_do_create(struct inode *parent_inode,		struct dentry *scfs_dentry, umode_t mode){	struct dentry *lower_file_dentry;	struct dentry *lower_parent_dentry;	struct inode *inode;	int ret;	SCFS_DEBUG_START;		lower_file_dentry = scfs_lower_dentry(scfs_dentry);	lower_parent_dentry = lock_parent(lower_file_dentry);	if (IS_ERR(lower_parent_dentry)) {		SCFS_PRINT_ERROR("lower_parent_dentry is invalid/n");		inode = ERR_CAST(lower_parent_dentry);		goto out;	}#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)	ret = vfs_create(lower_parent_dentry->d_inode, lower_file_dentry,			mode, true);#else	ret = vfs_create(lower_parent_dentry->d_inode, lower_file_dentry,			mode, NULL);#endif	if (ret) {		SCFS_PRINT_ERROR("error in vfs_create, lower create, ret : %d/n", ret);		inode = ERR_PTR(ret);		goto unlock;	}	inode = _scfs_get_inode(lower_file_dentry->d_inode, parent_inode->i_sb);	if (IS_ERR(inode)) {		SCFS_PRINT_ERROR("error in get_inode, so lower thing will be unlinked/n");		vfs_unlink(lower_parent_dentry->d_inode, lower_file_dentry);		goto unlock;	}	fsstack_copy_attr_times(parent_inode, lower_parent_dentry->d_inode);	fsstack_copy_inode_size(parent_inode, lower_parent_dentry->d_inode);unlock:	unlock_dir(lower_parent_dentry);out:	SCFS_DEBUG_END;		return inode;}

static int amfs_unlink(struct inode *dir, struct dentry *dentry){	int err;	struct dentry *lower_dentry;	struct inode *lower_dir_inode = amfs_lower_inode(dir);	struct dentry *lower_dir_dentry;	struct path lower_path;	/*************Check if trying to delete pattern file**************/	if (dentry->d_inode->i_ino == AMFS_SB(dentry->d_sb)->inode_no) {		err = -EPERM;		goto out_err;	}	/* here I am not allowing user to delete pattern db file. This will only	 * work if pattern db lies inside the directory which is being mounted	 */	/**********************XATTR ENDS HERE**************/	amfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	err = vfs_unlink(lower_dir_inode, lower_dentry, NULL);	/*	 * Note: unlinking on top of NFS can cause silly-renamed files.	 * Trying to delete such files results in EBUSY from NFS	 * below.  Silly-renamed files will get deleted by NFS later on, so	 * we just need to detect them here and treat such EBUSY errors as	 * if the upper file was successfully deleted.	 */	if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED)		err = 0;	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_dir_inode);	fsstack_copy_inode_size(dir, lower_dir_inode);	set_nlink(dentry->d_inode,		  amfs_lower_inode(dentry->d_inode)->i_nlink);	dentry->d_inode->i_ctime = dir->i_ctime;	d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */out:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	amfs_put_lower_path(dentry, &lower_path);out_err:	return err;}

static int _rm_handler(int argc, char **argv){    if (argc < 2) {        _vfs_usage(argv);        return 1;    }    char *rm_name = argv[1];    printf("%s: unlink: %s/n", argv[0], rm_name);    int res = vfs_unlink(rm_name);    if (res < 0) {        char errbuf[16];        _errno_string(res, (char *)errbuf, sizeof(errbuf));        printf("rm ERR: %s/n", errbuf);        return 2;    }    return 0;}

static int cmd_vfs_rm(struct vmm_chardev *cdev, const char *path){	int rc;	struct stat st;	rc = vfs_stat(path, &st);	if (rc) {		vmm_cprintf(cdev, "Path %s does not exist./n", path);		return rc;	}	if (!(st.st_mode & S_IFREG)) {		vmm_cprintf(cdev, "Path %s should be regular file./n", path);		return VMM_EINVALID;	}	return vfs_unlink(path);}