autofs: copy autofs4 to autofs (ebc921ca) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/autofs/autofs_i.h

0 → 100644

+273 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
		* Copyright 2005-2006 Ian Kent <raven@themaw.net>
		*
		* This file is part of the Linux kernel and is made available under
		* the terms of the GNU General Public License, version 2, or at your
		* option, any later version, incorporated herein by reference.
		*/

		/* Internal header file for autofs */

		#include <linux/auto_fs.h>
		#include <linux/auto_dev-ioctl.h>

		#include <linux/kernel.h>
		#include <linux/slab.h>
		#include <linux/time.h>
		#include <linux/string.h>
		#include <linux/wait.h>
		#include <linux/sched.h>
		#include <linux/mount.h>
		#include <linux/namei.h>
		#include <linux/uaccess.h>
		#include <linux/mutex.h>
		#include <linux/spinlock.h>
		#include <linux/list.h>
		#include <linux/completion.h>
		#include <asm/current.h>

		/* This is the range of ioctl() numbers we claim as ours */
		#define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
		#define AUTOFS_IOC_COUNT 32

		#define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
		#define AUTOFS_DEV_IOCTL_IOC_COUNT \
		(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD - AUTOFS_DEV_IOCTL_VERSION_CMD)

		#ifdef pr_fmt
		#undef pr_fmt
		#endif
		#define pr_fmt(fmt) KBUILD_MODNAME ":pid:%d:%s: " fmt, current->pid, __func__

		/*
		* Unified info structure. This is pointed to by both the dentry and
		* inode structures. Each file in the filesystem has an instance of this
		* structure. It holds a reference to the dentry, so dentries are never
		* flushed while the file exists. All name lookups are dealt with at the
		* dentry level, although the filesystem can interfere in the validation
		* process. Readdir is implemented by traversing the dentry lists.
		*/
		struct autofs_info {
		struct dentry *dentry;
		struct inode *inode;

		int flags;

		struct completion expire_complete;

		struct list_head active;
		int active_count;

		struct list_head expiring;

		struct autofs_sb_info *sbi;
		unsigned long last_used;
		atomic_t count;

		kuid_t uid;
		kgid_t gid;
		};

		#define AUTOFS_INF_EXPIRING (1<<0) /* dentry in the process of expiring */
		#define AUTOFS_INF_WANT_EXPIRE (1<<1) /* the dentry is being considered
		* for expiry, so RCU_walk is
		* not permitted. If it progresses to
		* actual expiry attempt, the flag is
		* not cleared when EXPIRING is set -
		* in that case it gets cleared only
		* when it comes to clearing EXPIRING.
		*/
		#define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */

		struct autofs_wait_queue {
		wait_queue_head_t queue;
		struct autofs_wait_queue *next;
		autofs_wqt_t wait_queue_token;
		/* We use the following to see what we are waiting for */
		struct qstr name;
		u32 dev;
		u64 ino;
		kuid_t uid;
		kgid_t gid;
		pid_t pid;
		pid_t tgid;
		/* This is for status reporting upon return */
		int status;
		unsigned int wait_ctr;
		};

		#define AUTOFS_SBI_MAGIC 0x6d4a556d

		struct autofs_sb_info {
		u32 magic;
		int pipefd;
		struct file *pipe;
		struct pid *oz_pgrp;
		int catatonic;
		int version;
		int sub_version;
		int min_proto;
		int max_proto;
		unsigned long exp_timeout;
		unsigned int type;
		struct super_block *sb;
		struct mutex wq_mutex;
		struct mutex pipe_mutex;
		spinlock_t fs_lock;
		struct autofs_wait_queue queues; / Wait queue pointer */
		spinlock_t lookup_lock;
		struct list_head active_list;
		struct list_head expiring_list;
		struct rcu_head rcu;
		};

		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 autofs_dentry_ino(struct dentry dentry)
		{
		return (struct autofs_info *)(dentry->d_fsdata);
		}

		/* 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 autofs_oz_mode(struct autofs_sb_info *sbi)
		{
		return sbi->catatonic \|\| task_pgrp(current) == sbi->oz_pgrp;
		}

		struct inode autofs_get_inode(struct super_block , umode_t);
		void autofs_free_ino(struct autofs_info *);

		/* Expiration */
		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 autofs_do_expire_multi(struct super_block sb, struct vfsmount mnt,
		struct autofs_sb_info *sbi, int when);
		int autofs_expire_multi(struct super_block , struct vfsmount ,
		struct autofs_sb_info , int __user );
		struct dentry autofs_expire_direct(struct super_block sb,
		struct vfsmount *mnt,
		struct autofs_sb_info *sbi, int how);
		struct dentry autofs_expire_indirect(struct super_block sb,
		struct vfsmount *mnt,
		struct autofs_sb_info *sbi, int how);

		/* Device node initialization */

		int autofs_dev_ioctl_init(void);
		void autofs_dev_ioctl_exit(void);

		/* Operations structures */

		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)
		{
		dentry->d_flags \|= (DCACHE_NEED_AUTOMOUNT\|DCACHE_MANAGE_TRANSIT);
		}

		static inline void managed_dentry_set_managed(struct dentry *dentry)
		{
		spin_lock(&dentry->d_lock);
		__managed_dentry_set_managed(dentry);
		spin_unlock(&dentry->d_lock);
		}

		static inline void __managed_dentry_clear_managed(struct dentry *dentry)
		{
		dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT\|DCACHE_MANAGE_TRANSIT);
		}

		static inline void managed_dentry_clear_managed(struct dentry *dentry)
		{
		spin_lock(&dentry->d_lock);
		__managed_dentry_clear_managed(dentry);
		spin_unlock(&dentry->d_lock);
		}

		/* Initializing function */

		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)
		{
		if (!(pipe->f_mode & FMODE_CAN_WRITE))
		return -EINVAL;
		if (!S_ISFIFO(file_inode(pipe)->i_mode))
		return -EINVAL;
		/* We want a packet pipe */
		pipe->f_flags \|= O_DIRECT;
		return 0;
		}

		/* Queue management functions */

		int autofs_wait(struct autofs_sb_info *,
		const struct path *, enum autofs_notify);
		int autofs_wait_release(struct autofs_sb_info *, autofs_wqt_t, int);
		void autofs_catatonic_mode(struct autofs_sb_info *);

		static inline u32 autofs_get_dev(struct autofs_sb_info *sbi)
		{
		return new_encode_dev(sbi->sb->s_dev);
		}

		static inline u64 autofs_get_ino(struct autofs_sb_info *sbi)
		{
		return d_inode(sbi->sb->s_root)->i_ino;
		}

		static inline void __autofs_add_expiring(struct dentry *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))
		list_add(&ino->expiring, &sbi->expiring_list);
		}
		}

		static inline void autofs_add_expiring(struct dentry *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);
		if (list_empty(&ino->expiring))
		list_add(&ino->expiring, &sbi->expiring_list);
		spin_unlock(&sbi->lookup_lock);
		}
		}

		static inline void autofs_del_expiring(struct dentry *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);
		if (!list_empty(&ino->expiring))
		list_del_init(&ino->expiring);
		spin_unlock(&sbi->lookup_lock);
		}
		}

		void autofs_kill_sb(struct super_block *);

fs/autofs/dev-ioctl.c

0 → 100644

+761 −0

File added.

Preview size limit exceeded, changes collapsed.

fs/autofs/expire.c

0 → 100644

+631 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
		* Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
		* Copyright 2001-2006 Ian Kent <raven@themaw.net>
		*
		* This file is part of the Linux kernel and is made available under
		* the terms of the GNU General Public License, version 2, or at your
		* option, any later version, incorporated herein by reference.
		*/

		#include "autofs_i.h"

		static unsigned long now;

		/* Check if a dentry can be expired */
		static inline int autofs_can_expire(struct dentry *dentry,
		unsigned long timeout, int do_now)
		{
		struct autofs_info *ino = autofs_dentry_ino(dentry);

		/* dentry in the process of being deleted */
		if (ino == NULL)
		return 0;

		if (!do_now) {
		/* Too young to die */
		if (!timeout \|\| time_after(ino->last_used + timeout, now))
		return 0;
		}
		return 1;
		}

		/* Check a mount point for busyness */
		static int autofs_mount_busy(struct vfsmount mnt, struct dentry dentry)
		{
		struct dentry *top = dentry;
		struct path path = {.mnt = mnt, .dentry = dentry};
		int status = 1;

		pr_debug("dentry %p %pd\n", dentry, dentry);

		path_get(&path);

		if (!follow_down_one(&path))
		goto done;

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

		/* Update the expiry counter if fs is busy */
		if (!may_umount_tree(path.mnt)) {
		struct autofs_info *ino;

		ino = autofs_dentry_ino(top);
		ino->last_used = jiffies;
		goto done;
		}

		status = 0;
		done:
		pr_debug("returning = %d\n", status);
		path_put(&path);
		return status;
		}

		/*
		* Calculate and dget next entry in the subdirs list under root.
		*/
		static struct dentry get_next_positive_subdir(struct dentry prev,
		struct dentry *root)
		{
		struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
		struct list_head *next;
		struct dentry *q;

		spin_lock(&sbi->lookup_lock);
		spin_lock(&root->d_lock);

		if (prev)
		next = prev->d_child.next;
		else {
		prev = dget_dlock(root);
		next = prev->d_subdirs.next;
		}

		cont:
		if (next == &root->d_subdirs) {
		spin_unlock(&root->d_lock);
		spin_unlock(&sbi->lookup_lock);
		dput(prev);
		return NULL;
		}

		q = list_entry(next, struct dentry, d_child);

		spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
		/* Already gone or negative dentry (under construction) - try next */
		if (!d_count(q) \|\| !simple_positive(q)) {
		spin_unlock(&q->d_lock);
		next = q->d_child.next;
		goto cont;
		}
		dget_dlock(q);
		spin_unlock(&q->d_lock);
		spin_unlock(&root->d_lock);
		spin_unlock(&sbi->lookup_lock);

		dput(prev);

		return q;
		}

		/*
		* Calculate and dget next entry in top down tree traversal.
		*/
		static struct dentry get_next_positive_dentry(struct dentry prev,
		struct dentry *root)
		{
		struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
		struct list_head *next;
		struct dentry p, ret;

		if (prev == NULL)
		return dget(root);

		spin_lock(&sbi->lookup_lock);
		relock:
		p = prev;
		spin_lock(&p->d_lock);
		again:
		next = p->d_subdirs.next;
		if (next == &p->d_subdirs) {
		while (1) {
		struct dentry *parent;

		if (p == root) {
		spin_unlock(&p->d_lock);
		spin_unlock(&sbi->lookup_lock);
		dput(prev);
		return NULL;
		}

		parent = p->d_parent;
		if (!spin_trylock(&parent->d_lock)) {
		spin_unlock(&p->d_lock);
		cpu_relax();
		goto relock;
		}
		spin_unlock(&p->d_lock);
		next = p->d_child.next;
		p = parent;
		if (next != &parent->d_subdirs)
		break;
		}
		}
		ret = list_entry(next, struct dentry, d_child);

		spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
		/* Negative dentry - try next */
		if (!simple_positive(ret)) {
		spin_unlock(&p->d_lock);
		lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_);
		p = ret;
		goto again;
		}
		dget_dlock(ret);
		spin_unlock(&ret->d_lock);
		spin_unlock(&p->d_lock);
		spin_unlock(&sbi->lookup_lock);

		dput(prev);

		return ret;
		}

		/*
		* Check a direct mount point for busyness.
		* Direct mounts have similar expiry semantics to tree mounts.
		* The tree is not busy iff no mountpoints are busy and there are no
		* autofs submounts.
		*/
		static int autofs_direct_busy(struct vfsmount *mnt,
		struct dentry *top,
		unsigned long timeout,
		int do_now)
		{
		pr_debug("top %p %pd\n", top, top);

		/* If it's busy update the expiry counters */
		if (!may_umount_tree(mnt)) {
		struct autofs_info *ino;

		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 (!autofs_can_expire(top, timeout, do_now))
		return 1;

		return 0;
		}

		/*
		* Check a directory tree of mount points for busyness
		* The tree is not busy iff no mountpoints are busy
		*/
		static int autofs_tree_busy(struct vfsmount *mnt,
		struct dentry *top,
		unsigned long timeout,
		int do_now)
		{
		struct autofs_info *top_ino = autofs_dentry_ino(top);
		struct dentry *p;

		pr_debug("top %p %pd\n", top, top);

		/* Negative dentry - give up */
		if (!simple_positive(top))
		return 1;

		p = NULL;
		while ((p = get_next_positive_dentry(p, top))) {
		pr_debug("dentry %p %pd\n", p, p);

		/*
		* Is someone visiting anywhere in the subtree ?
		* If there's no mount we need to check the usage
		* count for the autofs dentry.
		* If the fs is busy update the expiry counter.
		*/
		if (d_mountpoint(p)) {
		if (autofs_mount_busy(mnt, p)) {
		top_ino->last_used = jiffies;
		dput(p);
		return 1;
		}
		} else {
		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 */
		if (p == top)
		ino_count += 2;
		else
		ino_count++;

		if (d_count(p) > ino_count) {
		top_ino->last_used = jiffies;
		dput(p);
		return 1;
		}
		}
		}

		/* Timeout of a tree mount is ultimately determined by its top dentry */
		if (!autofs_can_expire(top, timeout, do_now))
		return 1;

		return 0;
		}

		static struct dentry autofs_check_leaves(struct vfsmount mnt,
		struct dentry *parent,
		unsigned long timeout,
		int do_now)
		{
		struct dentry *p;

		pr_debug("parent %p %pd\n", parent, parent);

		p = NULL;
		while ((p = get_next_positive_dentry(p, parent))) {
		pr_debug("dentry %p %pd\n", p, p);

		if (d_mountpoint(p)) {
		/* Can we umount this guy */
		if (autofs_mount_busy(mnt, p))
		continue;

		/* Can we expire this guy */
		if (autofs_can_expire(p, timeout, do_now))
		return p;
		}
		}
		return NULL;
		}

		/* Check if we can expire a direct mount (possibly a tree) */
		struct dentry autofs_expire_direct(struct super_block sb,
		struct vfsmount *mnt,
		struct autofs_sb_info *sbi,
		int how)
		{
		unsigned long timeout;
		struct dentry *root = dget(sb->s_root);
		int do_now = how & AUTOFS_EXP_IMMEDIATE;
		struct autofs_info *ino;

		if (!root)
		return NULL;

		now = jiffies;
		timeout = sbi->exp_timeout;

		if (!autofs_direct_busy(mnt, root, timeout, do_now)) {
		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(root);
		/* No point expiring a pending mount */
		if (ino->flags & AUTOFS_INF_PENDING) {
		spin_unlock(&sbi->fs_lock);
		goto out;
		}
		ino->flags \|= AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		synchronize_rcu();
		if (!autofs_direct_busy(mnt, root, timeout, do_now)) {
		spin_lock(&sbi->fs_lock);
		ino->flags \|= AUTOFS_INF_EXPIRING;
		init_completion(&ino->expire_complete);
		spin_unlock(&sbi->fs_lock);
		return root;
		}
		spin_lock(&sbi->fs_lock);
		ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		}
		out:
		dput(root);

		return NULL;
		}

		/* Check if 'dentry' should expire, or return a nearby
		* dentry that is suitable.
		* If returned dentry is different from arg dentry,
		* then a dget() reference was taken, else not.
		*/
		static struct dentry should_expire(struct dentry dentry,
		struct vfsmount *mnt,
		unsigned long timeout,
		int how)
		{
		int do_now = how & AUTOFS_EXP_IMMEDIATE;
		int exp_leaves = how & AUTOFS_EXP_LEAVES;
		struct autofs_info *ino = autofs_dentry_ino(dentry);
		unsigned int ino_count;

		/* No point expiring a pending mount */
		if (ino->flags & AUTOFS_INF_PENDING)
		return NULL;

		/*
		* Case 1: (i) indirect mount or top level pseudo direct mount
		* (autofs-4.1).
		* (ii) indirect mount with offset mount, check the "/"
		* offset (autofs-5.0+).
		*/
		if (d_mountpoint(dentry)) {
		pr_debug("checking mountpoint %p %pd\n", dentry, dentry);

		/* Can we umount this guy */
		if (autofs_mount_busy(mnt, dentry))
		return NULL;

		/* Can we expire this guy */
		if (autofs_can_expire(dentry, timeout, do_now))
		return dentry;
		return NULL;
		}

		if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
		pr_debug("checking symlink %p %pd\n", dentry, dentry);
		/*
		* A symlink can't be "busy" in the usual sense so
		* just check last used for expire timeout.
		*/
		if (autofs_can_expire(dentry, timeout, do_now))
		return dentry;
		return NULL;
		}

		if (simple_empty(dentry))
		return NULL;

		/* Case 2: tree mount, expire iff entire tree is not busy */
		if (!exp_leaves) {
		/* Path walk currently on this dentry? */
		ino_count = atomic_read(&ino->count) + 1;
		if (d_count(dentry) > ino_count)
		return NULL;

		if (!autofs_tree_busy(mnt, dentry, timeout, do_now))
		return dentry;
		/*
		* Case 3: pseudo direct mount, expire individual leaves
		* (autofs-4.1).
		*/
		} else {
		/* Path walk currently on this dentry? */
		struct dentry *expired;

		ino_count = atomic_read(&ino->count) + 1;
		if (d_count(dentry) > ino_count)
		return NULL;

		expired = autofs_check_leaves(mnt, dentry, timeout, do_now);
		if (expired) {
		if (expired == dentry)
		dput(dentry);
		return expired;
		}
		}
		return NULL;
		}

		/*
		* Find an eligible tree to time-out
		* A tree is eligible if :-
		* - it is unused by any user process
		* - it has been unused for exp_timeout time
		*/
		struct dentry autofs_expire_indirect(struct super_block sb,
		struct vfsmount *mnt,
		struct autofs_sb_info *sbi,
		int how)
		{
		unsigned long timeout;
		struct dentry *root = sb->s_root;
		struct dentry *dentry;
		struct dentry *expired;
		struct dentry *found;
		struct autofs_info *ino;

		if (!root)
		return NULL;

		now = jiffies;
		timeout = sbi->exp_timeout;

		dentry = NULL;
		while ((dentry = get_next_positive_subdir(dentry, root))) {
		int flags = how;

		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(dentry);
		if (ino->flags & AUTOFS_INF_WANT_EXPIRE) {
		spin_unlock(&sbi->fs_lock);
		continue;
		}
		spin_unlock(&sbi->fs_lock);

		expired = should_expire(dentry, mnt, timeout, flags);
		if (!expired)
		continue;

		spin_lock(&sbi->fs_lock);
		ino = autofs_dentry_ino(expired);
		ino->flags \|= AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		synchronize_rcu();

		/* Make sure a reference is not taken on found if
		* things have changed.
		*/
		flags &= ~AUTOFS_EXP_LEAVES;
		found = should_expire(expired, mnt, timeout, how);
		if (!found \|\| found != expired)
		/* Something has changed, continue */
		goto next;

		if (expired != dentry)
		dput(dentry);

		spin_lock(&sbi->fs_lock);
		goto found;
		next:
		spin_lock(&sbi->fs_lock);
		ino->flags &= ~AUTOFS_INF_WANT_EXPIRE;
		spin_unlock(&sbi->fs_lock);
		if (expired != dentry)
		dput(expired);
		}
		return NULL;

		found:
		pr_debug("returning %p %pd\n", expired, expired);
		ino->flags \|= AUTOFS_INF_EXPIRING;
		init_completion(&ino->expire_complete);
		spin_unlock(&sbi->fs_lock);
		return expired;
		}

		int autofs_expire_wait(const struct path *path, int rcu_walk)
		{
		struct dentry *dentry = path->dentry;
		struct autofs_sb_info *sbi = autofs_sbi(dentry->d_sb);
		struct autofs_info *ino = autofs_dentry_ino(dentry);
		int status;
		int state;

		/* Block on any pending expire */
		if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE))
		return 0;
		if (rcu_walk)
		return -ECHILD;

		retry:
		spin_lock(&sbi->fs_lock);
		state = ino->flags & (AUTOFS_INF_WANT_EXPIRE \| AUTOFS_INF_EXPIRING);
		if (state == AUTOFS_INF_WANT_EXPIRE) {
		spin_unlock(&sbi->fs_lock);
		/*
		* Possibly being selected for expire, wait until
		* it's selected or not.
		*/
		schedule_timeout_uninterruptible(HZ/10);
		goto retry;
		}
		if (state & AUTOFS_INF_EXPIRING) {
		spin_unlock(&sbi->fs_lock);

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

		status = autofs_wait(sbi, path, NFY_NONE);
		wait_for_completion(&ino->expire_complete);

		pr_debug("expire done status=%d\n", status);

		if (d_unhashed(dentry))
		return -EAGAIN;

		return status;
		}
		spin_unlock(&sbi->fs_lock);

		return 0;
		}

		/* Perform an expiry operation */
		int autofs_expire_run(struct super_block *sb,
		struct vfsmount *mnt,
		struct autofs_sb_info *sbi,
		struct autofs_packet_expire __user *pkt_p)
		{
		struct autofs_packet_expire pkt;
		struct autofs_info *ino;
		struct dentry *dentry;
		int ret = 0;

		memset(&pkt, 0, sizeof(pkt));

		pkt.hdr.proto_version = sbi->version;
		pkt.hdr.type = autofs_ptype_expire;

		dentry = autofs_expire_indirect(sb, mnt, sbi, 0);
		if (!dentry)
		return -EAGAIN;

		pkt.len = dentry->d_name.len;
		memcpy(pkt.name, dentry->d_name.name, pkt.len);
		pkt.name[pkt.len] = '\0';
		dput(dentry);

		if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
		ret = -EFAULT;

		spin_lock(&sbi->fs_lock);
		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);
		complete_all(&ino->expire_complete);
		spin_unlock(&sbi->fs_lock);

		return ret;
		}

		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 = autofs_expire_direct(sb, mnt, sbi, when);
		else
		dentry = autofs_expire_indirect(sb, mnt, sbi, when);

		if (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 = autofs_wait(sbi, &path, NFY_EXPIRE);

		spin_lock(&sbi->fs_lock);
		/* avoid rapid-fire expire attempts if expiry fails */
		ino->last_used = now;
		ino->flags &= ~(AUTOFS_INF_EXPIRING\|AUTOFS_INF_WANT_EXPIRE);
		complete_all(&ino->expire_complete);
		spin_unlock(&sbi->fs_lock);
		dput(dentry);
		}

		return ret;
		}

		/*
		* Call repeatedly until it returns -EAGAIN, meaning there's nothing
		* more to be done.
		*/
		int autofs_expire_multi(struct super_block sb, struct vfsmount mnt,
		struct autofs_sb_info sbi, int __user arg)
		{
		int do_now = 0;

		if (arg && get_user(do_now, arg))
		return -EFAULT;

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

fs/autofs/init.c

0 → 100644

+48 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
		*
		* This file is part of the Linux kernel and is made available under
		* the terms of the GNU General Public License, version 2, or at your
		* option, any later version, incorporated herein by reference.
		*/

		#include <linux/module.h>
		#include <linux/init.h>
		#include "autofs_i.h"

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

		static struct file_system_type autofs_fs_type = {
		.owner = THIS_MODULE,
		.name = "autofs",
		.mount = autofs_mount,
		.kill_sb = autofs_kill_sb,
		};
		MODULE_ALIAS_FS("autofs");

		static int __init init_autofs_fs(void)
		{
		int err;

		autofs_dev_ioctl_init();

		err = register_filesystem(&autofs_fs_type);
		if (err)
		autofs_dev_ioctl_exit();

		return err;
		}

		static void __exit exit_autofs_fs(void)
		{
		autofs_dev_ioctl_exit();
		unregister_filesystem(&autofs_fs_type);
		}

		module_init(init_autofs_fs)
		module_exit(exit_autofs_fs)
		MODULE_LICENSE("GPL");

fs/autofs/inode.c

0 → 100644

+375 −0

File added.

Preview size limit exceeded, changes collapsed.