[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / fs / autofs4 / autofs_i.h

/* -*- c -*- ------------------------------------------------------------- *
 *   
 * linux/fs/autofs/autofs_i.h
 *
 *   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_fs4.h>
#include <linux/auto_dev-ioctl.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/list.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_IOC_COUNT - 11)

#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 <asm/current.h>
#include <asm/uaccess.h>

/* #define DEBUG */

#define DPRINTK(fmt, ...)				\
	pr_debug("pid %d: %s: " fmt "\n",		\
		current->pid, __func__, ##__VA_ARGS__)

#define AUTOFS_WARN(fmt, ...)				\
	printk(KERN_WARNING "pid %d: %s: " fmt "\n",	\
		current->pid, __func__, ##__VA_ARGS__)

#define AUTOFS_ERROR(fmt, ...)				\
	printk(KERN_ERR "pid %d: %s: " fmt "\n",	\
		current->pid, __func__, ##__VA_ARGS__)

/* 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 is 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;
	int reghost_enabled;
	int needs_reghost;
	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 *autofs4_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)
{
	return (struct autofs_info *)(dentry->d_fsdata);
}

/* autofs4_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) {
	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 *);

/* Expiration */
int is_autofs4_dentry(struct dentry *);
int autofs4_expire_wait(struct dentry *dentry, int rcu_walk);
int autofs4_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,
			    struct autofs_sb_info *sbi, int when);
int autofs4_expire_multi(struct super_block *, struct vfsmount *,
			struct autofs_sb_info *, int __user *);
struct dentry *autofs4_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 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 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;

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

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 autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
void autofs4_catatonic_mode(struct autofs_sb_info *);

static inline u32 autofs4_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)
{
	return d_inode(sbi->sb->s_root)->i_ino;
}

static inline void __autofs4_add_expiring(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	if (ino) {
		if (list_empty(&ino->expiring))
			list_add(&ino->expiring, &sbi->expiring_list);
	}
	return;
}

static inline void autofs4_add_expiring(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_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);
	}
	return;
}

static inline void autofs4_del_expiring(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_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);
	}
	return;
}

extern void autofs4_kill_sb(struct super_block *);
Commit	Line	Data
1da177e4 LT	1	/* -- c -- ------------------------------------------------------------- *
	2	*
	3	* linux/fs/autofs/autofs_i.h
	4	*
	5	* Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
34ca959c	6	* Copyright 2005-2006 Ian Kent <raven@themaw.net>
1da177e4 LT	7	*
	8	* This file is part of the Linux kernel and is made available under
	9	* the terms of the GNU General Public License, version 2, or at your
	10	* option, any later version, incorporated herein by reference.
	11	*
	12	* ----------------------------------------------------------------------- */
	13
	14	/* Internal header file for autofs */
	15
	16	#include <linux/auto_fs4.h>
8d7b48e0	17	#include <linux/auto_dev-ioctl.h>
1d5599e3	18	#include <linux/mutex.h>
b5c84bf6	19	#include <linux/spinlock.h>
1da177e4 LT	20	#include <linux/list.h>
	21
	22	/* This is the range of ioctl() numbers we claim as ours */
	23	#define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
	24	#define AUTOFS_IOC_COUNT 32
	25
8d7b48e0 IK	26	#define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
	27	#define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11)
	28
1da177e4 LT	29	#include <linux/kernel.h>
	30	#include <linux/slab.h>
	31	#include <linux/time.h>
	32	#include <linux/string.h>
	33	#include <linux/wait.h>
	34	#include <linux/sched.h>
	35	#include <linux/mount.h>
	36	#include <linux/namei.h>
	37	#include <asm/current.h>
	38	#include <asm/uaccess.h>
	39
	40	/* #define DEBUG */
	41
c3ad9962 LT	42	#define DPRINTK(fmt, ...) \
	43	pr_debug("pid %d: %s: " fmt "\n", \
	44	current->pid, __func__, ##__VA_ARGS__)
1da177e4	45
c3ad9962	46	#define AUTOFS_WARN(fmt, ...) \
8d7b48e0	47	printk(KERN_WARNING "pid %d: %s: " fmt "\n", \
c3ad9962	48	current->pid, __func__, ##__VA_ARGS__)
8d7b48e0	49
c3ad9962	50	#define AUTOFS_ERROR(fmt, ...) \
8d7b48e0	51	printk(KERN_ERR "pid %d: %s: " fmt "\n", \
c3ad9962	52	current->pid, __func__, ##__VA_ARGS__)
8d7b48e0	53
1da177e4 LT	54	/* Unified info structure. This is pointed to by both the dentry and
	55	inode structures. Each file in the filesystem has an instance of this
	56	structure. It holds a reference to the dentry, so dentries are never
	57	flushed while the file exists. All name lookups are dealt with at the
	58	dentry level, although the filesystem can interfere in the validation
	59	process. Readdir is implemented by traversing the dentry lists. */
	60	struct autofs_info {
	61	struct dentry *dentry;
	62	struct inode *inode;
	63
	64	int flags;
	65
6e60a9ab IK	66	struct completion expire_complete;
6e60a9ab IK	67
25767378	68	struct list_head active;
4f8427d1 IK	69	int active_count;
4f8427d1 IK	70
5f6f4f28	71	struct list_head expiring;
f50b6f86	72
1da177e4 LT	73	struct autofs_sb_info *sbi;
1da177e4 LT	74	unsigned long last_used;
1aff3c8b	75	atomic_t count;
1da177e4	76
45634cd8 EB	77	kuid_t uid;
45634cd8 EB	78	kgid_t gid;
1da177e4 LT	79	};
	80
	81	#define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */
30b54a26	82	#define AUTOFS_INF_WANT_EXPIRE (1<<1) /* the dentry is being considered
4d885f90	83	* for expiry, so RCU_walk is
30b54a26 AV	84	* not permitted. If it progresses to
	85	* actual expiry attempt, the flag is
	86	* not cleared when EXPIRING is set -
	87	* in that case it gets cleared only
	88	* when it comes to clearing EXPIRING.
4d885f90	89	*/
aa952eb2	90	#define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
1da177e4 LT	91
	92	struct autofs_wait_queue {
	93	wait_queue_head_t queue;
	94	struct autofs_wait_queue *next;
	95	autofs_wqt_t wait_queue_token;
	96	/* We use the following to see what we are waiting for */
70b52a0a	97	struct qstr name;
5c0a32fc IK	98	u32 dev;
5c0a32fc IK	99	u64 ino;
45634cd8 EB	100	kuid_t uid;
45634cd8 EB	101	kgid_t gid;
5c0a32fc IK	102	pid_t pid;
5c0a32fc IK	103	pid_t tgid;
1da177e4 LT	104	/* This is for status reporting upon return */
1da177e4 LT	105	int status;
296f7bf7	106	unsigned int wait_ctr;
1da177e4 LT	107	};
	108
	109	#define AUTOFS_SBI_MAGIC 0x6d4a556d
	110
	111	struct autofs_sb_info {
	112	u32 magic;
d7c4a5f1	113	int pipefd;
1da177e4	114	struct file *pipe;
6eaba35b	115	struct pid *oz_pgrp;
1da177e4 LT	116	int catatonic;
	117	int version;
	118	int sub_version;
d7c4a5f1 IK	119	int min_proto;
d7c4a5f1 IK	120	int max_proto;
1da177e4	121	unsigned long exp_timeout;
34ca959c	122	unsigned int type;
1da177e4 LT	123	int reghost_enabled;
	124	int needs_reghost;
	125	struct super_block *sb;
1d5599e3	126	struct mutex wq_mutex;
d668dc56	127	struct mutex pipe_mutex;
3a9720ce	128	spinlock_t fs_lock;
1da177e4	129	struct autofs_wait_queue queues; / Wait queue pointer */
5f6f4f28	130	spinlock_t lookup_lock;
25767378	131	struct list_head active_list;
5f6f4f28	132	struct list_head expiring_list;
baa40671	133	struct rcu_head rcu;
1da177e4 LT	134	};
	135
	136	static inline struct autofs_sb_info autofs4_sbi(struct super_block sb)
	137	{
	138	return (struct autofs_sb_info *)(sb->s_fs_info);
	139	}
	140
	141	static inline struct autofs_info autofs4_dentry_ino(struct dentry dentry)
	142	{
	143	return (struct autofs_info *)(dentry->d_fsdata);
	144	}
	145
	146	/* autofs4_oz_mode(): do we see the man behind the curtain? (The
	147	processes which do manipulations for us in user space sees the raw
	148	filesystem without "magic".) */
	149
	150	static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
6eaba35b	151	return sbi->catatonic \|\| task_pgrp(current) == sbi->oz_pgrp;
1da177e4 LT	152	}
1da177e4 LT	153
030a8ba4	154	struct inode autofs4_get_inode(struct super_block , umode_t);
1da177e4 LT	155	void autofs4_free_ino(struct autofs_info *);
	156
	157	/* Expiration */
	158	int is_autofs4_dentry(struct dentry *);
23bfc2a2	159	int autofs4_expire_wait(struct dentry *dentry, int rcu_walk);
1da177e4 LT	160	int autofs4_expire_run(struct super_block , struct vfsmount ,
	161	struct autofs_sb_info *,
	162	struct autofs_packet_expire __user *);
56fcef75 IK	163	int autofs4_do_expire_multi(struct super_block sb, struct vfsmount mnt,
56fcef75 IK	164	struct autofs_sb_info *sbi, int when);
1da177e4 LT	165	int autofs4_expire_multi(struct super_block , struct vfsmount ,
1da177e4 LT	166	struct autofs_sb_info , int __user );
8d7b48e0 IK	167	struct dentry autofs4_expire_direct(struct super_block sb,
	168	struct vfsmount *mnt,
	169	struct autofs_sb_info *sbi, int how);
	170	struct dentry autofs4_expire_indirect(struct super_block sb,
	171	struct vfsmount *mnt,
	172	struct autofs_sb_info *sbi, int how);
	173
	174	/* Device node initialization */
	175
	176	int autofs_dev_ioctl_init(void);
	177	void autofs_dev_ioctl_exit(void);
1da177e4 LT	178
	179	/* Operations structures */
	180
754661f1 AV	181	extern const struct inode_operations autofs4_symlink_inode_operations;
754661f1 AV	182	extern const struct inode_operations autofs4_dir_inode_operations;
4b6f5d20 AV	183	extern const struct file_operations autofs4_dir_operations;
4b6f5d20 AV	184	extern const struct file_operations autofs4_root_operations;
71e469db	185	extern const struct dentry_operations autofs4_dentry_operations;
10584211 IK	186
10584211 IK	187	/* VFS automount flags management functions */
b5b80177 IK	188	static inline void __managed_dentry_set_managed(struct dentry *dentry)
	189	{
	190	dentry->d_flags \|= (DCACHE_NEED_AUTOMOUNT\|DCACHE_MANAGE_TRANSIT);
	191	}
	192
	193	static inline void managed_dentry_set_managed(struct dentry *dentry)
	194	{
	195	spin_lock(&dentry->d_lock);
	196	__managed_dentry_set_managed(dentry);
	197	spin_unlock(&dentry->d_lock);
	198	}
	199
	200	static inline void __managed_dentry_clear_managed(struct dentry *dentry)
	201	{
	202	dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT\|DCACHE_MANAGE_TRANSIT);
	203	}
	204
	205	static inline void managed_dentry_clear_managed(struct dentry *dentry)
	206	{
	207	spin_lock(&dentry->d_lock);
	208	__managed_dentry_clear_managed(dentry);
	209	spin_unlock(&dentry->d_lock);
	210	}
	211
1da177e4 LT	212	/* Initializing function */
	213
	214	int autofs4_fill_super(struct super_block , void , int);
26e6c910 AV	215	struct autofs_info autofs4_new_ino(struct autofs_sb_info );
26e6c910 AV	216	void autofs4_clean_ino(struct autofs_info *);
1da177e4	217
64f371bc LT	218	static inline int autofs_prepare_pipe(struct file *pipe)
64f371bc LT	219	{
a35fb914	220	if (!(pipe->f_mode & FMODE_CAN_WRITE))
64f371bc	221	return -EINVAL;
496ad9aa	222	if (!S_ISFIFO(file_inode(pipe)->i_mode))
64f371bc LT	223	return -EINVAL;
	224	/* We want a packet pipe */
	225	pipe->f_flags \|= O_DIRECT;
	226	return 0;
	227	}
	228
1da177e4 LT	229	/* Queue management functions */
1da177e4 LT	230
1da177e4 LT	231	int autofs4_wait(struct autofs_sb_info ,struct dentry , enum autofs_notify);
	232	int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
	233	void autofs4_catatonic_mode(struct autofs_sb_info *);
	234
5c0a32fc IK	235	static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
	236	{
	237	return new_encode_dev(sbi->sb->s_dev);
	238	}
	239
	240	static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
	241	{
2b0143b5	242	return d_inode(sbi->sb->s_root)->i_ino;
5c0a32fc IK	243	}
5c0a32fc IK	244
2fd6b7f5 NP	245	static inline void __autofs4_add_expiring(struct dentry *dentry)
	246	{
	247	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	248	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	249	if (ino) {
	250	if (list_empty(&ino->expiring))
	251	list_add(&ino->expiring, &sbi->expiring_list);
	252	}
	253	return;
	254	}
	255
c4cd70b3 IK	256	static inline void autofs4_add_expiring(struct dentry *dentry)
	257	{
	258	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	259	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	260	if (ino) {
	261	spin_lock(&sbi->lookup_lock);
	262	if (list_empty(&ino->expiring))
	263	list_add(&ino->expiring, &sbi->expiring_list);
	264	spin_unlock(&sbi->lookup_lock);
	265	}
	266	return;
	267	}
	268
	269	static inline void autofs4_del_expiring(struct dentry *dentry)
	270	{
	271	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	272	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	273	if (ino) {
	274	spin_lock(&sbi->lookup_lock);
	275	if (!list_empty(&ino->expiring))
	276	list_del_init(&ino->expiring);
	277	spin_unlock(&sbi->lookup_lock);
	278	}
	279	return;
	280	}
	281
6ce31523	282	extern void autofs4_kill_sb(struct super_block *);