Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 47206e01 authored by Ian Kent's avatar Ian Kent Committed by Linus Torvalds
Browse files

autofs4: use autofs instead of autofs4 everywhere 

Update naming within autofs source to be consistent by changing
occurrences of autofs4 to autofs.

Link: http://lkml.kernel.org/r/152626703688.28589.8315406711135226803.stgit@pluto.themaw.net


Signed-off-by: default avatarIan Kent <raven@themaw.net>
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent ef8b42f7

fs/autofs4/autofs_i.h

+44 −44
Original line number Diff line number Diff line
@@ -122,42 +122,42 @@ struct autofs_sb_info { 
	struct rcu_head rcu;

};



static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)

static inline struct autofs_sb_info *autofs_sbi(struct super_block *sb)

{

	return (struct autofs_sb_info *)(sb->s_fs_info);

}



static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)

static inline struct autofs_info *autofs_dentry_ino(struct dentry *dentry)

{

	return (struct autofs_info *)(dentry->d_fsdata);

}



/* autofs4_oz_mode(): do we see the man behind the curtain?  (The

/* autofs_oz_mode(): do we see the man behind the curtain?  (The

 * processes which do manipulations for us in user space sees the raw

 * filesystem without "magic".)

 */

static inline int autofs4_oz_mode(struct autofs_sb_info *sbi)

static inline int autofs_oz_mode(struct autofs_sb_info *sbi)

{

	return sbi->catatonic || task_pgrp(current) == sbi->oz_pgrp;

}



struct inode *autofs4_get_inode(struct super_block *, umode_t);

void autofs4_free_ino(struct autofs_info *);

struct inode *autofs_get_inode(struct super_block *, umode_t);

void autofs_free_ino(struct autofs_info *);



/* Expiration */

int is_autofs4_dentry(struct dentry *);

int autofs4_expire_wait(const struct path *path, int rcu_walk);

int autofs4_expire_run(struct super_block *, struct vfsmount *,

int is_autofs_dentry(struct dentry *);

int autofs_expire_wait(const struct path *path, int rcu_walk);

int autofs_expire_run(struct super_block *, struct vfsmount *,

		      struct autofs_sb_info *,

		      struct autofs_packet_expire __user *);

int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,

int autofs_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,

			   struct autofs_sb_info *sbi, int when);

int autofs4_expire_multi(struct super_block *, struct vfsmount *,

int autofs_expire_multi(struct super_block *, struct vfsmount *,

			struct autofs_sb_info *, int __user *);

struct dentry *autofs4_expire_direct(struct super_block *sb,

struct dentry *autofs_expire_direct(struct super_block *sb,

				    struct vfsmount *mnt,

				    struct autofs_sb_info *sbi, int how);

struct dentry *autofs4_expire_indirect(struct super_block *sb,

struct dentry *autofs_expire_indirect(struct super_block *sb,

				      struct vfsmount *mnt,

				      struct autofs_sb_info *sbi, int how);
@@ -168,11 +168,11 @@ void autofs_dev_ioctl_exit(void); 


/* Operations structures */



extern const struct inode_operations autofs4_symlink_inode_operations;

extern const struct inode_operations autofs4_dir_inode_operations;

extern const struct file_operations autofs4_dir_operations;

extern const struct file_operations autofs4_root_operations;

extern const struct dentry_operations autofs4_dentry_operations;

extern const struct inode_operations autofs_symlink_inode_operations;

extern const struct inode_operations autofs_dir_inode_operations;

extern const struct file_operations autofs_dir_operations;

extern const struct file_operations autofs_root_operations;

extern const struct dentry_operations autofs_dentry_operations;



/* VFS automount flags management functions */

static inline void __managed_dentry_set_managed(struct dentry *dentry)
@@ -201,9 +201,9 @@ static inline void managed_dentry_clear_managed(struct dentry *dentry) 


/* Initializing function */



int autofs4_fill_super(struct super_block *, void *, int);

struct autofs_info *autofs4_new_ino(struct autofs_sb_info *);

void autofs4_clean_ino(struct autofs_info *);

int autofs_fill_super(struct super_block *, void *, int);

struct autofs_info *autofs_new_ino(struct autofs_sb_info *);

void autofs_clean_ino(struct autofs_info *);



static inline int autofs_prepare_pipe(struct file *pipe)

{
@@ -218,25 +218,25 @@ static inline int autofs_prepare_pipe(struct file *pipe) 


/* Queue management functions */



int autofs4_wait(struct autofs_sb_info *,

int autofs_wait(struct autofs_sb_info *,

		 const struct path *, enum autofs_notify);

int autofs4_wait_release(struct autofs_sb_info *, autofs_wqt_t, int);

void autofs4_catatonic_mode(struct autofs_sb_info *);

int autofs_wait_release(struct autofs_sb_info *, autofs_wqt_t, int);

void autofs_catatonic_mode(struct autofs_sb_info *);



static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)

static inline u32 autofs_get_dev(struct autofs_sb_info *sbi)

{

	return new_encode_dev(sbi->sb->s_dev);

}



static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)

static inline u64 autofs_get_ino(struct autofs_sb_info *sbi)

{

	return d_inode(sbi->sb->s_root)->i_ino;

}



static inline void __autofs4_add_expiring(struct dentry *dentry)

static inline void __autofs_add_expiring(struct dentry *dentry)

{

	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs_dentry_ino(dentry);



	if (ino) {

		if (list_empty(&ino->expiring))
@@ -244,10 +244,10 @@ static inline void __autofs4_add_expiring(struct dentry *dentry) 
	}

}



static inline void autofs4_add_expiring(struct dentry *dentry)

static inline void autofs_add_expiring(struct dentry *dentry)

{

	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs_dentry_ino(dentry);



	if (ino) {

		spin_lock(&sbi->lookup_lock);
@@ -257,10 +257,10 @@ static inline void autofs4_add_expiring(struct dentry *dentry) 
	}

}



static inline void autofs4_del_expiring(struct dentry *dentry)

static inline void autofs_del_expiring(struct dentry *dentry)

{

	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs_dentry_ino(dentry);



	if (ino) {

		spin_lock(&sbi->lookup_lock);
@@ -270,4 +270,4 @@ static inline void autofs4_del_expiring(struct dentry *dentry) 
	}

}



void autofs4_kill_sb(struct super_block *);
 
void autofs_kill_sb(struct super_block *);

fs/autofs4/dev-ioctl.c

+9 −9
Original line number Diff line number Diff line
@@ -166,7 +166,7 @@ static struct autofs_sb_info *autofs_dev_ioctl_sbi(struct file *f) 


	if (f) {

		inode = file_inode(f);

		sbi = autofs4_sbi(inode->i_sb);

		sbi = autofs_sbi(inode->i_sb);

	}

	return sbi;

}
@@ -236,7 +236,7 @@ static int test_by_dev(const struct path *path, void *p) 


static int test_by_type(const struct path *path, void *p)

{

	struct autofs_info *ino = autofs4_dentry_ino(path->dentry);

	struct autofs_info *ino = autofs_dentry_ino(path->dentry);



	return ino && ino->sbi->type & *(unsigned *)p;

}
@@ -324,7 +324,7 @@ static int autofs_dev_ioctl_ready(struct file *fp, 
	autofs_wqt_t token;



	token = (autofs_wqt_t) param->ready.token;

	return autofs4_wait_release(sbi, token, 0);

	return autofs_wait_release(sbi, token, 0);

}



/*
@@ -340,7 +340,7 @@ static int autofs_dev_ioctl_fail(struct file *fp, 


	token = (autofs_wqt_t) param->fail.token;

	status = param->fail.status < 0 ? param->fail.status : -ENOENT;

	return autofs4_wait_release(sbi, token, status);

	return autofs_wait_release(sbi, token, status);

}



/*
@@ -412,7 +412,7 @@ static int autofs_dev_ioctl_catatonic(struct file *fp, 
				      struct autofs_sb_info *sbi,

				      struct autofs_dev_ioctl *param)

{

	autofs4_catatonic_mode(sbi);

	autofs_catatonic_mode(sbi);

	return 0;

}
@@ -459,10 +459,10 @@ static int autofs_dev_ioctl_requester(struct file *fp, 
	if (err)

		goto out;



	ino = autofs4_dentry_ino(path.dentry);

	ino = autofs_dentry_ino(path.dentry);

	if (ino) {

		err = 0;

		autofs4_expire_wait(&path, 0);

		autofs_expire_wait(&path, 0);

		spin_lock(&sbi->fs_lock);

		param->requester.uid =

			from_kuid_munged(current_user_ns(), ino->uid);
@@ -489,7 +489,7 @@ static int autofs_dev_ioctl_expire(struct file *fp, 
	how = param->expire.how;

	mnt = fp->f_path.mnt;



	return autofs4_do_expire_multi(sbi->sb, mnt, sbi, how);

	return autofs_do_expire_multi(sbi->sb, mnt, sbi, how);

}



/* Check if autofs mount point is in use */
@@ -686,7 +686,7 @@ static int _autofs_dev_ioctl(unsigned int command, 
		 * Admin needs to be able to set the mount catatonic in

		 * order to be able to perform the re-open.

		 */

		if (!autofs4_oz_mode(sbi) &&

		if (!autofs_oz_mode(sbi) &&

		    cmd != AUTOFS_DEV_IOCTL_CATATONIC_CMD) {

			err = -EACCES;

			fput(fp);

fs/autofs4/expire.c

+66 −66
Original line number Diff line number Diff line
@@ -13,10 +13,10 @@ 
static unsigned long now;



/* Check if a dentry can be expired */

static inline int autofs4_can_expire(struct dentry *dentry,

static inline int autofs_can_expire(struct dentry *dentry,

				    unsigned long timeout, int do_now)

{

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_info *ino = autofs_dentry_ino(dentry);



	/* dentry in the process of being deleted */

	if (ino == NULL)
@@ -31,7 +31,7 @@ static inline int autofs4_can_expire(struct dentry *dentry, 
}



/* Check a mount point for busyness */

static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)

static int autofs_mount_busy(struct vfsmount *mnt, struct dentry *dentry)

{

	struct dentry *top = dentry;

	struct path path = {.mnt = mnt, .dentry = dentry};
@@ -44,8 +44,8 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry) 
	if (!follow_down_one(&path))

		goto done;



	if (is_autofs4_dentry(path.dentry)) {

		struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb);

	if (is_autofs_dentry(path.dentry)) {

		struct autofs_sb_info *sbi = autofs_sbi(path.dentry->d_sb);



		/* This is an autofs submount, we can't expire it */

		if (autofs_type_indirect(sbi->type))
@@ -56,7 +56,7 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry) 
	if (!may_umount_tree(path.mnt)) {

		struct autofs_info *ino;



		ino = autofs4_dentry_ino(top);

		ino = autofs_dentry_ino(top);

		ino->last_used = jiffies;

		goto done;

	}
@@ -74,7 +74,7 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry) 
static struct dentry *get_next_positive_subdir(struct dentry *prev,

					       struct dentry *root)

{

	struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);

	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);

	struct list_head *next;

	struct dentry *q;
@@ -121,7 +121,7 @@ static struct dentry *get_next_positive_subdir(struct dentry *prev, 
static struct dentry *get_next_positive_dentry(struct dentry *prev,

					       struct dentry *root)

{

	struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);

	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);

	struct list_head *next;

	struct dentry *p, *ret;
@@ -184,7 +184,7 @@ static struct dentry *get_next_positive_dentry(struct dentry *prev, 
 * The tree is not busy iff no mountpoints are busy and there are no

 * autofs submounts.

 */

static int autofs4_direct_busy(struct vfsmount *mnt,

static int autofs_direct_busy(struct vfsmount *mnt,

			      struct dentry *top,

			      unsigned long timeout,

			      int do_now)
@@ -195,14 +195,14 @@ static int autofs4_direct_busy(struct vfsmount *mnt, 
	if (!may_umount_tree(mnt)) {

		struct autofs_info *ino;



		ino = autofs4_dentry_ino(top);

		ino = autofs_dentry_ino(top);

		if (ino)

			ino->last_used = jiffies;

		return 1;

	}



	/* Timeout of a direct mount is determined by its top dentry */

	if (!autofs4_can_expire(top, timeout, do_now))

	if (!autofs_can_expire(top, timeout, do_now))

		return 1;



	return 0;
@@ -212,12 +212,12 @@ static int autofs4_direct_busy(struct vfsmount *mnt, 
 * Check a directory tree of mount points for busyness

 * The tree is not busy iff no mountpoints are busy

 */

static int autofs4_tree_busy(struct vfsmount *mnt,

static int autofs_tree_busy(struct vfsmount *mnt,

			    struct dentry *top,

			    unsigned long timeout,

			    int do_now)

{

	struct autofs_info *top_ino = autofs4_dentry_ino(top);

	struct autofs_info *top_ino = autofs_dentry_ino(top);

	struct dentry *p;



	pr_debug("top %p %pd\n", top, top);
@@ -237,13 +237,13 @@ static int autofs4_tree_busy(struct vfsmount *mnt, 
		 * If the fs is busy update the expiry counter.

		 */

		if (d_mountpoint(p)) {

			if (autofs4_mount_busy(mnt, p)) {

			if (autofs_mount_busy(mnt, p)) {

				top_ino->last_used = jiffies;

				dput(p);

				return 1;

			}

		} else {

			struct autofs_info *ino = autofs4_dentry_ino(p);

			struct autofs_info *ino = autofs_dentry_ino(p);

			unsigned int ino_count = atomic_read(&ino->count);



			/* allow for dget above and top is already dgot */
@@ -261,13 +261,13 @@ static int autofs4_tree_busy(struct vfsmount *mnt, 
	}



	/* Timeout of a tree mount is ultimately determined by its top dentry */

	if (!autofs4_can_expire(top, timeout, do_now))

	if (!autofs_can_expire(top, timeout, do_now))

		return 1;



	return 0;

}



static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,

static struct dentry *autofs_check_leaves(struct vfsmount *mnt,

					  struct dentry *parent,

					  unsigned long timeout,

					  int do_now)
@@ -282,11 +282,11 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt, 


		if (d_mountpoint(p)) {

			/* Can we umount this guy */

			if (autofs4_mount_busy(mnt, p))

			if (autofs_mount_busy(mnt, p))

				continue;



			/* Can we expire this guy */

			if (autofs4_can_expire(p, timeout, do_now))

			if (autofs_can_expire(p, timeout, do_now))

				return p;

		}

	}
@@ -294,7 +294,7 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt, 
}



/* Check if we can expire a direct mount (possibly a tree) */

struct dentry *autofs4_expire_direct(struct super_block *sb,

struct dentry *autofs_expire_direct(struct super_block *sb,

				    struct vfsmount *mnt,

				    struct autofs_sb_info *sbi,

				    int how)
@@ -310,9 +310,9 @@ struct dentry *autofs4_expire_direct(struct super_block *sb, 
	now = jiffies;

	timeout = sbi->exp_timeout;



	if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {

	if (!autofs_direct_busy(mnt, root, timeout, do_now)) {

		spin_lock(&sbi->fs_lock);

		ino = autofs4_dentry_ino(root);

		ino = autofs_dentry_ino(root);

		/* No point expiring a pending mount */

		if (ino->flags & AUTOFS_INF_PENDING) {

			spin_unlock(&sbi->fs_lock);
@@ -321,7 +321,7 @@ struct dentry *autofs4_expire_direct(struct super_block *sb, 
		ino->flags |= AUTOFS_INF_WANT_EXPIRE;

		spin_unlock(&sbi->fs_lock);

		synchronize_rcu();

		if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {

		if (!autofs_direct_busy(mnt, root, timeout, do_now)) {

			spin_lock(&sbi->fs_lock);

			ino->flags |= AUTOFS_INF_EXPIRING;

			init_completion(&ino->expire_complete);
@@ -350,7 +350,7 @@ static struct dentry *should_expire(struct dentry *dentry, 
{

	int do_now = how & AUTOFS_EXP_IMMEDIATE;

	int exp_leaves = how & AUTOFS_EXP_LEAVES;

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_info *ino = autofs_dentry_ino(dentry);

	unsigned int ino_count;



	/* No point expiring a pending mount */
@@ -367,11 +367,11 @@ static struct dentry *should_expire(struct dentry *dentry, 
		pr_debug("checking mountpoint %p %pd\n", dentry, dentry);



		/* Can we umount this guy */

		if (autofs4_mount_busy(mnt, dentry))

		if (autofs_mount_busy(mnt, dentry))

			return NULL;



		/* Can we expire this guy */

		if (autofs4_can_expire(dentry, timeout, do_now))

		if (autofs_can_expire(dentry, timeout, do_now))

			return dentry;

		return NULL;

	}
@@ -382,7 +382,7 @@ static struct dentry *should_expire(struct dentry *dentry, 
		 * A symlink can't be "busy" in the usual sense so

		 * just check last used for expire timeout.

		 */

		if (autofs4_can_expire(dentry, timeout, do_now))

		if (autofs_can_expire(dentry, timeout, do_now))

			return dentry;

		return NULL;

	}
@@ -397,7 +397,7 @@ static struct dentry *should_expire(struct dentry *dentry, 
		if (d_count(dentry) > ino_count)

			return NULL;



		if (!autofs4_tree_busy(mnt, dentry, timeout, do_now))

		if (!autofs_tree_busy(mnt, dentry, timeout, do_now))

			return dentry;

	/*

	 * Case 3: pseudo direct mount, expire individual leaves
@@ -411,7 +411,7 @@ static struct dentry *should_expire(struct dentry *dentry, 
		if (d_count(dentry) > ino_count)

			return NULL;



		expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);

		expired = autofs_check_leaves(mnt, dentry, timeout, do_now);

		if (expired) {

			if (expired == dentry)

				dput(dentry);
@@ -427,7 +427,7 @@ static struct dentry *should_expire(struct dentry *dentry, 
 *  - it is unused by any user process

 *  - it has been unused for exp_timeout time

 */

struct dentry *autofs4_expire_indirect(struct super_block *sb,

struct dentry *autofs_expire_indirect(struct super_block *sb,

				      struct vfsmount *mnt,

				      struct autofs_sb_info *sbi,

				      int how)
@@ -450,7 +450,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb, 
		int flags = how;



		spin_lock(&sbi->fs_lock);

		ino = autofs4_dentry_ino(dentry);

		ino = autofs_dentry_ino(dentry);

		if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {

			spin_unlock(&sbi->fs_lock);

			continue;
@@ -462,7 +462,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb, 
			continue;



		spin_lock(&sbi->fs_lock);

		ino = autofs4_dentry_ino(expired);

		ino = autofs_dentry_ino(expired);

		ino->flags |= AUTOFS_INF_WANT_EXPIRE;

		spin_unlock(&sbi->fs_lock);

		synchronize_rcu();
@@ -498,11 +498,11 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb, 
	return expired;

}



int autofs4_expire_wait(const struct path *path, int rcu_walk)

int autofs_expire_wait(const struct path *path, int rcu_walk)

{

	struct dentry *dentry = path->dentry;

	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs4_dentry_ino(dentry);

	struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);

	struct autofs_info *ino = autofs_dentry_ino(dentry);

	int status;

	int state;
@@ -529,7 +529,7 @@ int autofs4_expire_wait(const struct path *path, int rcu_walk) 


		pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);



		status = autofs4_wait(sbi, path, NFY_NONE);

		status = autofs_wait(sbi, path, NFY_NONE);

		wait_for_completion(&ino->expire_complete);



		pr_debug("expire done status=%d\n", status);
@@ -545,7 +545,7 @@ int autofs4_expire_wait(const struct path *path, int rcu_walk) 
}



/* Perform an expiry operation */

int autofs4_expire_run(struct super_block *sb,

int autofs_expire_run(struct super_block *sb,

		      struct vfsmount *mnt,

		      struct autofs_sb_info *sbi,

		      struct autofs_packet_expire __user *pkt_p)
@@ -560,7 +560,7 @@ int autofs4_expire_run(struct super_block *sb, 
	pkt.hdr.proto_version = sbi->version;

	pkt.hdr.type = autofs_ptype_expire;



	dentry = autofs4_expire_indirect(sb, mnt, sbi, 0);

	dentry = autofs_expire_indirect(sb, mnt, sbi, 0);

	if (!dentry)

		return -EAGAIN;
@@ -573,7 +573,7 @@ int autofs4_expire_run(struct super_block *sb, 
		ret = -EFAULT;



	spin_lock(&sbi->fs_lock);

	ino = autofs4_dentry_ino(dentry);

	ino = autofs_dentry_ino(dentry);

	/* avoid rapid-fire expire attempts if expiry fails */

	ino->last_used = now;

	ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE);
@@ -583,25 +583,25 @@ int autofs4_expire_run(struct super_block *sb, 
	return ret;

}



int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,

int autofs_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,

			   struct autofs_sb_info *sbi, int when)

{

	struct dentry *dentry;

	int ret = -EAGAIN;



	if (autofs_type_trigger(sbi->type))

		dentry = autofs4_expire_direct(sb, mnt, sbi, when);

		dentry = autofs_expire_direct(sb, mnt, sbi, when);

	else

		dentry = autofs4_expire_indirect(sb, mnt, sbi, when);

		dentry = autofs_expire_indirect(sb, mnt, sbi, when);



	if (dentry) {

		struct autofs_info *ino = autofs4_dentry_ino(dentry);

		struct autofs_info *ino = autofs_dentry_ino(dentry);

		const struct path path = { .mnt = mnt, .dentry = dentry };



		/* This is synchronous because it makes the daemon a

		 * little easier

		 */

		ret = autofs4_wait(sbi, &path, NFY_EXPIRE);

		ret = autofs_wait(sbi, &path, NFY_EXPIRE);



		spin_lock(&sbi->fs_lock);

		/* avoid rapid-fire expire attempts if expiry fails */
@@ -619,7 +619,7 @@ int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, 
 * Call repeatedly until it returns -EAGAIN, meaning there's nothing

 * more to be done.

 */

int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,

int autofs_expire_multi(struct super_block *sb, struct vfsmount *mnt,

			struct autofs_sb_info *sbi, int __user *arg)

{

	int do_now = 0;
@@ -627,6 +627,6 @@ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt, 
	if (arg && get_user(do_now, arg))

		return -EFAULT;



	return autofs4_do_expire_multi(sb, mnt, sbi, do_now);

	return autofs_do_expire_multi(sb, mnt, sbi, do_now);

}

fs/autofs4/init.c

+6 −6
Original line number Diff line number Diff line
@@ -13,18 +13,18 @@ 
static struct dentry *autofs_mount(struct file_system_type *fs_type,

	int flags, const char *dev_name, void *data)

{

	return mount_nodev(fs_type, flags, data, autofs4_fill_super);

	return mount_nodev(fs_type, flags, data, autofs_fill_super);

}



static struct file_system_type autofs_fs_type = {

	.owner		= THIS_MODULE,

	.name		= "autofs",

	.mount		= autofs_mount,

	.kill_sb	= autofs4_kill_sb,

	.kill_sb	= autofs_kill_sb,

};

MODULE_ALIAS_FS("autofs");



static int __init init_autofs4_fs(void)

static int __init init_autofs_fs(void)

{

	int err;
@@ -37,12 +37,12 @@ static int __init init_autofs4_fs(void) 
	return err;

}



static void __exit exit_autofs4_fs(void)

static void __exit exit_autofs_fs(void)

{

	autofs_dev_ioctl_exit();

	unregister_filesystem(&autofs_fs_type);

}



module_init(init_autofs4_fs) 

module_exit(exit_autofs4_fs)

module_init(init_autofs_fs)

module_exit(exit_autofs_fs)

MODULE_LICENSE("GPL");

fs/autofs4/inode.c

+24 −24
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ 
#include "autofs_i.h"

#include <linux/module.h>



struct autofs_info *autofs4_new_ino(struct autofs_sb_info *sbi)

struct autofs_info *autofs_new_ino(struct autofs_sb_info *sbi)

{

	struct autofs_info *ino;
@@ -32,21 +32,21 @@ struct autofs_info *autofs4_new_ino(struct autofs_sb_info *sbi) 
	return ino;

}



void autofs4_clean_ino(struct autofs_info *ino)

void autofs_clean_ino(struct autofs_info *ino)

{

	ino->uid = GLOBAL_ROOT_UID;

	ino->gid = GLOBAL_ROOT_GID;

	ino->last_used = jiffies;

}



void autofs4_free_ino(struct autofs_info *ino)

void autofs_free_ino(struct autofs_info *ino)

{

	kfree(ino);

}



void autofs4_kill_sb(struct super_block *sb)

void autofs_kill_sb(struct super_block *sb)

{

	struct autofs_sb_info *sbi = autofs4_sbi(sb);

	struct autofs_sb_info *sbi = autofs_sbi(sb);



	/*

	 * In the event of a failure in get_sb_nodev the superblock
@@ -56,7 +56,7 @@ void autofs4_kill_sb(struct super_block *sb) 
	 */

	if (sbi) {

		/* Free wait queues, close pipe */

		autofs4_catatonic_mode(sbi);

		autofs_catatonic_mode(sbi);

		put_pid(sbi->oz_pgrp);

	}
@@ -66,9 +66,9 @@ void autofs4_kill_sb(struct super_block *sb) 
		kfree_rcu(sbi, rcu);

}



static int autofs4_show_options(struct seq_file *m, struct dentry *root)

static int autofs_show_options(struct seq_file *m, struct dentry *root)

{

	struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);

	struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);

	struct inode *root_inode = d_inode(root->d_sb->s_root);



	if (!sbi)
@@ -101,16 +101,16 @@ static int autofs4_show_options(struct seq_file *m, struct dentry *root) 
	return 0;

}



static void autofs4_evict_inode(struct inode *inode)

static void autofs_evict_inode(struct inode *inode)

{

	clear_inode(inode);

	kfree(inode->i_private);

}



static const struct super_operations autofs4_sops = {

static const struct super_operations autofs_sops = {

	.statfs		= simple_statfs,

	.show_options	= autofs4_show_options,

	.evict_inode	= autofs4_evict_inode,

	.show_options	= autofs_show_options,

	.evict_inode	= autofs_evict_inode,

};



enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto,
@@ -206,7 +206,7 @@ static int parse_options(char *options, int *pipefd, kuid_t *uid, kgid_t *gid, 
	return (*pipefd < 0);

}



int autofs4_fill_super(struct super_block *s, void *data, int silent)

int autofs_fill_super(struct super_block *s, void *data, int silent)

{

	struct inode *root_inode;

	struct dentry *root;
@@ -246,19 +246,19 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent) 
	s->s_blocksize = 1024;

	s->s_blocksize_bits = 10;

	s->s_magic = AUTOFS_SUPER_MAGIC;

	s->s_op = &autofs4_sops;

	s->s_d_op = &autofs4_dentry_operations;

	s->s_op = &autofs_sops;

	s->s_d_op = &autofs_dentry_operations;

	s->s_time_gran = 1;



	/*

	 * Get the root inode and dentry, but defer checking for errors.

	 */

	ino = autofs4_new_ino(sbi);

	ino = autofs_new_ino(sbi);

	if (!ino) {

		ret = -ENOMEM;

		goto fail_free;

	}

	root_inode = autofs4_get_inode(s, S_IFDIR | 0755);

	root_inode = autofs_get_inode(s, S_IFDIR | 0755);

	root = d_make_root(root_inode);

	if (!root)

		goto fail_ino;
@@ -305,8 +305,8 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent) 
	if (autofs_type_trigger(sbi->type))

		__managed_dentry_set_managed(root);



	root_inode->i_fop = &autofs4_root_operations;

	root_inode->i_op = &autofs4_dir_inode_operations;

	root_inode->i_fop = &autofs_root_operations;

	root_inode->i_op = &autofs_dir_inode_operations;



	pr_debug("pipe fd = %d, pgrp = %u\n", pipefd, pid_nr(sbi->oz_pgrp));

	pipe = fget(pipefd);
@@ -340,14 +340,14 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent) 
	dput(root);

	goto fail_free;

fail_ino:

	autofs4_free_ino(ino);

	autofs_free_ino(ino);

fail_free:

	kfree(sbi);

	s->s_fs_info = NULL;

	return ret;

}



struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode)

struct inode *autofs_get_inode(struct super_block *sb, umode_t mode)

{

	struct inode *inode = new_inode(sb);
@@ -364,10 +364,10 @@ struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode) 


	if (S_ISDIR(mode)) {

		set_nlink(inode, 2);

		inode->i_op = &autofs4_dir_inode_operations;

		inode->i_fop = &autofs4_dir_operations;

		inode->i_op = &autofs_dir_inode_operations;

		inode->i_fop = &autofs_dir_operations;

	} else if (S_ISLNK(mode)) {

		inode->i_op = &autofs4_symlink_inode_operations;

		inode->i_op = &autofs_symlink_inode_operations;

	} else

		WARN_ON(1);