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

long link_by_fd(int file_fd, int newdfd, const char __user * newname){    int error;    int fput_needed;    struct file *filep;    struct nameidata nd;    struct dentry *new_dentry;    filep = fget_light(file_fd, &fput_needed);    if(!filep)        return -EBADF;    error = __user_walk_fd(newdfd, newname, LOOKUP_PARENT, &nd);    if(error)        goto file_out;    error = -EXDEV;    if(filep->f_vfsmnt != nd.mnt)        goto out_release;    new_dentry = lookup_create(&nd, 0);    error = PTR_ERR(new_dentry);    if(!IS_ERR(new_dentry))        {            error = vfs_link(filep->f_dentry, nd.dentry->d_inode, new_dentry);            dput(new_dentry);        }    mutex_unlock(&nd.dentry->d_inode->i_mutex);out_release:    path_release(&nd);file_out:    fput_light(filep, fput_needed);    return error;}

static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,			 struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int rc;	file_size_save = i_size_read(old_dentry->d_inode);	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);	dget(lower_old_dentry);	dget(lower_new_dentry);	lower_dir_dentry = lock_parent(lower_new_dentry);	rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		      lower_new_dentry);	if (rc || !lower_new_dentry->d_inode)		goto out_lock;	rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);	if (rc)		goto out_lock;	fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out_lock:	unlock_dir(lower_dir_dentry);	dput(lower_new_dentry);	dput(lower_old_dentry);	return rc;}

int	do_link (struct inode *inode, struct inode *dir, const char *name,	         int len){#if USE_DENTRY_F	struct dentry	*ref_dent;	struct dentry	*new_dent;#endif	int		ret;	DOWN(&(dir->i_sem));#if POST_20_KERNEL_F		/* Get a dentry for the link source. */	ref_dent = ovlfs_inode2dentry(inode);	if ( ref_dent == NULL )	{		ret = -ENOENT;	}	else	{			/* Create a temporary negative dentry for the target. */		ret = ovlfs_inode_get_child_dentry(dir, name, len, &new_dent,		                                   OVLFS_DENT_GET_NEGATIVE);		if ( ret != 0 )			dput(ref_dent);	}	if ( ret == 0 )	{			/* Use the vfs_link function to do the dirty work. */		ret = vfs_link(ref_dent, dir, new_dent);		dput(ref_dent);		dput(new_dent);	}#else	IMARK(inode);	IMARK(dir);	ret = dir->i_op->link(inode, dir, name, len);#endif	UP(&(dir->i_sem));	return	ret;}

static int wrapfs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)		DEBUG_MESG("Enter");	file_size_save = i_size_read(old_dentry->d_inode);	wrapfs_get_lower_path(old_dentry, &lower_old_path);	wrapfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_dir_dentry = lock_parent(lower_new_dentry);	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_unlock;	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry);	if (err || !lower_new_dentry->d_inode)		goto out;	err = wrapfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  wrapfs_lower_inode(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	mnt_drop_write(lower_new_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	wrapfs_put_lower_path(old_dentry, &lower_old_path);	wrapfs_put_lower_path(new_dentry, &lower_new_path);	if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)		DEBUG_RETURN("Exit", err);	return err;}

/* sysfile_link - link file */intsysfile_link(const char *__path1, const char *__path2) {    int ret;    char *old_path, *new_path;    if ((ret = copy_path(&old_path, __path1)) != 0) {        return ret;    }    if ((ret = copy_path(&new_path, __path2)) != 0) {        kfree(old_path);        return ret;    }    ret = vfs_link(old_path, new_path);    kfree(old_path), kfree(new_path);    return ret;}

static int sdcardfs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));		file_size_save = i_size_read(old_dentry->d_inode);	sdcardfs_get_lower_path(old_dentry, &lower_old_path);	sdcardfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_dir_dentry = lock_parent(lower_new_dentry);	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_unlock;	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry);	if (err || !lower_new_dentry->d_inode)		goto out;	err = sdcardfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  sdcardfs_lower_inode(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	mnt_drop_write(lower_new_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	sdcardfs_put_lower_path(old_dentry, &lower_old_path);	sdcardfs_put_lower_path(new_dentry, &lower_new_path);	REVERT_CRED();	return err;}

int vfsub_link(struct dentry *src_dentry, struct inode *dir, struct path *path,	       struct inode **delegated_inode){	int err;	struct dentry *d;	IMustLock(dir);	err = au_test_nlink(d_inode(src_dentry));	if (unlikely(err))		return err;	/* we don't call may_linkat() */	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_link(src_dentry, path, d);	path->dentry = d;	if (unlikely(err))		goto out;	lockdep_off();	err = vfs_link(src_dentry, dir, path->dentry, delegated_inode);	lockdep_on();	if (!err) {		struct path tmp = *path;		int did;		/* fuse has different memory inode for the same inumber */		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);			tmp.dentry = src_dentry;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

static int diaryfs_link(struct dentry * old_dentry, struct inode *dir,						struct dentry * new_dentry) {	struct dentry * lower_old_dentry;	struct dentry * lower_new_dentry;	struct dentry * lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	file_size_save = i_size_read(old_dentry->d_inode);	diaryfs_get_lower_path(old_dentry, &lower_old_path);	diaryfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_dir_dentry = lock_parent(lower_new_dentry);	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode, 				   lower_new_dentry, NULL);	if (err || !lower_new_dentry->d_inode)		goto out;	err = diaryfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err) 		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		(	diaryfs_lower_inode(old_dentry->d_inode))->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	unlock_dir(lower_dir_dentry);	diaryfs_put_lower_path(old_dentry, &lower_old_path);	diaryfs_put_lower_path(new_dentry, &lower_new_path);	return err;}

static int ccfs_link(struct dentry *old_dentry, struct inode *dir,			 struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int rc;	// TODO: Update cached link	file_size_save = i_size_read(old_dentry->d_inode);	lower_old_dentry = ccfs_get_nested_dentry(old_dentry);	lower_new_dentry = ccfs_get_nested_dentry(new_dentry);		dget(lower_old_dentry);	dget(lower_new_dentry);		mdbg(INFO3,"Link w/ lower_dentry->d_name.name = [%s] Link = [%s]", lower_old_dentry->d_name.name, lower_new_dentry->d_name.name);	lower_dir_dentry = lock_parent(lower_new_dentry);	rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		      lower_new_dentry);	if (rc || !lower_new_dentry->d_inode)		goto out_lock;	rc = ccfs_interpose(lower_new_dentry, new_dentry, dir->i_sb, 0);	if (rc)		goto out_lock;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode, ccfs_get_nested_inode(old_dentry->d_inode)->i_nlink); //Fix for kernel 3.7.1 use function set_nlink by Jiri Rakosnik	i_size_write(new_dentry->d_inode, file_size_save);out_lock:	unlock_dir(lower_dir_dentry);	dput(lower_new_dentry);	dput(lower_old_dentry);	d_drop(lower_old_dentry);	d_drop(new_dentry);	d_drop(old_dentry);	return rc;}

int do_vfsub_link(struct dentry *src_dentry, struct inode *dir,		  struct dentry *dentry){	int err;	LKTRTrace("%.*s, i%lu, %.*s/n",		  AuDLNPair(src_dentry), dir->i_ino, AuDLNPair(dentry));	IMustLock(dir);	lockdep_off();	err = vfs_link(src_dentry, dir, dentry);	lockdep_on();	if (!err) {		LKTRTrace("src_i %p, dst_i %p/n",			  src_dentry->d_inode, dentry->d_inode);		/* fuse has different memory inode for the same inumber */		au_update_fuse_h_inode(NULL, src_dentry); /*ignore*/		/* dir inode is locked */		au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/		au_update_fuse_h_inode(NULL, dentry); /*ignore*/	}	return err;}

static int unionfs_link(struct dentry *old_dentry, struct inode *dir,			struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_dir_dentry = NULL;	struct dentry *old_parent, *new_parent;	char *name = NULL;	bool valid;	unionfs_read_lock(old_dentry->d_sb, UNIONFS_SMUTEX_CHILD);	old_parent = dget_parent(old_dentry);	new_parent = dget_parent(new_dentry);	unionfs_double_lock_parents(old_parent, new_parent);	unionfs_double_lock_dentry(old_dentry, new_dentry);	valid = __unionfs_d_revalidate(old_dentry, old_parent, false, 0);	if (unlikely(!valid)) {		err = -ESTALE;		goto out;	}	if (new_dentry->d_inode) {		valid = __unionfs_d_revalidate(new_dentry, new_parent, false, 0);		if (unlikely(!valid)) {			err = -ESTALE;			goto out;		}	}	lower_new_dentry = unionfs_lower_dentry(new_dentry);	/* check for a whiteout in new dentry branch, and delete it */	err = check_unlink_whiteout(new_dentry, lower_new_dentry,				    dbstart(new_dentry));	if (err > 0) {	       /* whiteout found and removed successfully */		lower_dir_dentry = dget_parent(lower_new_dentry);		fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);		dput(lower_dir_dentry);		set_nlink(dir, unionfs_get_nlinks(dir));		err = 0;	}	if (err)		goto out;	/* check if parent hierachy is needed, then link in same branch */	if (dbstart(old_dentry) != dbstart(new_dentry)) {		lower_new_dentry = create_parents(dir, new_dentry,						  new_dentry->d_name.name,						  dbstart(old_dentry));		err = PTR_ERR(lower_new_dentry);		if (IS_COPYUP_ERR(err))			goto docopyup;		if (!lower_new_dentry || IS_ERR(lower_new_dentry))			goto out;	}	lower_new_dentry = unionfs_lower_dentry(new_dentry);	lower_old_dentry = unionfs_lower_dentry(old_dentry);	BUG_ON(dbstart(old_dentry) != dbstart(new_dentry));	lower_dir_dentry = lock_parent(lower_new_dentry);	err = is_robranch(old_dentry);	if (!err) {		/* see Documentation/filesystems/unionfs/issues.txt */		lockdep_off();		err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,			       lower_new_dentry);		lockdep_on();	}	unlock_dir(lower_dir_dentry);docopyup:	if (IS_COPYUP_ERR(err)) {		int old_bstart = dbstart(old_dentry);		int bindex;		for (bindex = old_bstart - 1; bindex >= 0; bindex--) {			err = copyup_dentry(old_parent->d_inode,					    old_dentry, old_bstart,					    bindex, old_dentry->d_name.name,					    old_dentry->d_name.len, NULL,					    i_size_read(old_dentry->d_inode));			if (err)				continue;			lower_new_dentry =				create_parents(dir, new_dentry,					       new_dentry->d_name.name,					       bindex);			lower_old_dentry = unionfs_lower_dentry(old_dentry);			lower_dir_dentry = lock_parent(lower_new_dentry);			/* see Documentation/filesystems/unionfs/issues.txt */			lockdep_off();			/* do vfs_link */			err = vfs_link(lower_old_dentry,				       lower_dir_dentry->d_inode,				       lower_new_dentry);			lockdep_on();			unlock_dir(lower_dir_dentry);			goto check_link;		}//.........这里部分代码省略.........

static int amfs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	char *value = NULL;	if (old_dentry->d_inode->i_ino ==			AMFS_SB(old_dentry->d_sb)->inode_no) {		err = -EPERM;		goto out_err;	}	/************XATTR************/	value = kzalloc(5, __GFP_WAIT);	if (value == NULL) {		err = -ENOMEM;		goto out_err;	}	if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5) > 0) {		if (!strncmp(value, AMFS_BADFILE, 3)) {			err = -EPERM;			goto freevalue;		}	} else if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5)			!= -ENODATA){		err = amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5);		goto freevalue;	}	/************XATTR***********/	file_size_save = i_size_read(old_dentry->d_inode);	amfs_get_lower_path(old_dentry, &lower_old_path);	amfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_dir_dentry = lock_parent(lower_new_dentry);	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry, NULL);	if (err || !lower_new_dentry->d_inode)		goto out;	err = amfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  amfs_lower_inode(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	unlock_dir(lower_dir_dentry);	amfs_put_lower_path(old_dentry, &lower_old_path);	amfs_put_lower_path(new_dentry, &lower_new_path);freevalue:	kfree(value);out_err:	return err;}

static int u2fs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err=0;	int idx;	struct dentry *ret = NULL;	struct path lower_old_path, lower_new_path;		file_size_save = i_size_read(old_dentry->d_inode);	if((U2FS_D(old_dentry)->lower_path[LEFT].dentry != NULL) &&	(U2FS_D(old_dentry)->lower_path[LEFT].mnt != NULL)){		u2fs_get_lower_path(old_dentry, &lower_old_path, LEFT);		idx = LEFT;	}	else{		u2fs_get_lower_path(old_dentry, &lower_old_path, RIGHT);		idx = RIGHT;	}	/* creating parent directories if destination is read-only */	if((U2FS_D(new_dentry)->lower_path[LEFT].dentry) == NULL && 		(U2FS_D(new_dentry)->lower_path[LEFT].mnt) == NULL){		ret = create_parents(dir, new_dentry, 					new_dentry->d_name.name);		if (!ret || IS_ERR(ret)) {					err = PTR_ERR(ret);					if (!IS_COPYUP_ERR(err))						printk(KERN_ERR					      	 "u2fs: create_parents for "				     		  "u2fs_link failed"					      	 "err=%d/n", err);					goto out_copyup;		}		u2fs_postcopyup_setmnt(new_dentry);		u2fs_put_reset_lower_path(new_dentry, RIGHT);				if(err)			goto out_copyup;		}	u2fs_get_lower_path(new_dentry, &lower_new_path, LEFT);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_dir_dentry = lock_parent(lower_new_dentry);	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_unlock;	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry);	if (err || !lower_new_dentry->d_inode)		goto out;	err = u2fs_interpose(new_dentry, dir->i_sb, &lower_new_path, LEFT);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  u2fs_lower_inode(old_dentry->d_inode, idx)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	mnt_drop_write(lower_new_path.mnt);out_unlock:	unlock_dir(lower_dir_dentry);	u2fs_put_lower_path(new_dentry, &lower_new_path);out_copyup:	u2fs_put_lower_path(old_dentry, &lower_old_path);	return err;}