Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 989a2979205dd34269382b357e6d4b4b6956b889

Authored by Eric Dumazet 2010-04-14 17:55:35 +0800

Committed by David S. Miller 2010-04-22 07:19:29 +0800

Exists in master and in 7 other branches

fasync: RCU and fine grained locking

kill_fasync() uses a central rwlock, candidate for RCU conversion, to
avoid cache line ping pongs on SMP.

fasync_remove_entry() and fasync_add_entry() can disable IRQS on a short
section instead during whole list scan.

Use a spinlock per fasync_struct to synchronize kill_fasync_rcu() and
fasync_{remove|add}_entry(). This spinlock is IRQ safe, so sock_fasync()
doesnt need its own implementation and can use fasync_helper(), to
reduce code size and complexity.

We can remove __kill_fasync() direct use in net/socket.c, and rename it
to kill_fasync_rcu().

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 3 changed files with 59 additions and 92 deletions Inline Diff

fs/fcntl.c
include/linux/fs.h
net/socket.c

fs/fcntl.c

Diff comments View file @ 989a297

 /*
  *  linux/fs/fcntl.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 #include <linux/syscalls.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/fdtable.h>
 #include <linux/capability.h>
 #include <linux/dnotify.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/security.h>
 #include <linux/ptrace.h>
 #include <linux/signal.h>
 #include <linux/rcupdate.h>
 #include <linux/pid_namespace.h>
 #include <asm/poll.h>
 #include <asm/siginfo.h>
 #include <asm/uaccess.h>
 void set_close_on_exec(unsigned int fd, int flag)
 {
 	struct files_struct *files = current->files;
 	struct fdtable *fdt;
 	spin_lock(&files->file_lock);
 	fdt = files_fdtable(files);
 	if (flag)
 		FD_SET(fd, fdt->close_on_exec);
 	else
 		FD_CLR(fd, fdt->close_on_exec);
 	spin_unlock(&files->file_lock);
 }
 static int get_close_on_exec(unsigned int fd)
 {
 	struct files_struct *files = current->files;
 	struct fdtable *fdt;
 	int res;
 	rcu_read_lock();
 	fdt = files_fdtable(files);
 	res = FD_ISSET(fd, fdt->close_on_exec);
 	rcu_read_unlock();
 	return res;
 }
 SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
 {
 	int err = -EBADF;
 	struct file * file, *tofree;
 	struct files_struct * files = current->files;
 	struct fdtable *fdt;
 	if ((flags & ~O_CLOEXEC) != 0)
 		return -EINVAL;
 	if (unlikely(oldfd == newfd))
 		return -EINVAL;
 	spin_lock(&files->file_lock);
 	err = expand_files(files, newfd);
 	file = fcheck(oldfd);
 	if (unlikely(!file))
 		goto Ebadf;
 	if (unlikely(err < 0)) {
 		if (err == -EMFILE)
 			goto Ebadf;
 		goto out_unlock;
 	}
 	/*
 	 * We need to detect attempts to do dup2() over allocated but still
 	 * not finished descriptor.  NB: OpenBSD avoids that at the price of
 	 * extra work in their equivalent of fget() - they insert struct
 	 * file immediately after grabbing descriptor, mark it larval if
 	 * more work (e.g. actual opening) is needed and make sure that
 	 * fget() treats larval files as absent.  Potentially interesting,
 	 * but while extra work in fget() is trivial, locking implications
 	 * and amount of surgery on open()-related paths in VFS are not.
 	 * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
 	 * deadlocks in rather amusing ways, AFAICS.  All of that is out of
 	 * scope of POSIX or SUS, since neither considers shared descriptor
 	 * tables and this condition does not arise without those.
 	 */
 	err = -EBUSY;
 	fdt = files_fdtable(files);
 	tofree = fdt->fd[newfd];
 	if (!tofree && FD_ISSET(newfd, fdt->open_fds))
 		goto out_unlock;
 	get_file(file);
 	rcu_assign_pointer(fdt->fd[newfd], file);
 	FD_SET(newfd, fdt->open_fds);
 	if (flags & O_CLOEXEC)
 		FD_SET(newfd, fdt->close_on_exec);
 	else
 		FD_CLR(newfd, fdt->close_on_exec);
 	spin_unlock(&files->file_lock);
 	if (tofree)
 		filp_close(tofree, files);
 	return newfd;
 Ebadf:
 	err = -EBADF;
 out_unlock:
 	spin_unlock(&files->file_lock);
 	return err;
 }
 SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
 {
 	if (unlikely(newfd == oldfd)) { /* corner case */
 		struct files_struct *files = current->files;
 		int retval = oldfd;
 		rcu_read_lock();
 		if (!fcheck_files(files, oldfd))
 			retval = -EBADF;
 		rcu_read_unlock();
 		return retval;
 	}
 	return sys_dup3(oldfd, newfd, 0);
 }
 SYSCALL_DEFINE1(dup, unsigned int, fildes)
 {
 	int ret = -EBADF;
 	struct file *file = fget(fildes);
 	if (file) {
 		ret = get_unused_fd();
 		if (ret >= 0)
 			fd_install(ret, file);
 		else
 			fput(file);
 	}
 	return ret;
 }
 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
 static int setfl(int fd, struct file * filp, unsigned long arg)
 {
 	struct inode * inode = filp->f_path.dentry->d_inode;
 	int error = 0;
 	/*
 	 * O_APPEND cannot be cleared if the file is marked as append-only
 	 * and the file is open for write.
 	 */
 	if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
 		return -EPERM;
 	/* O_NOATIME can only be set by the owner or superuser */
 	if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
 		if (!is_owner_or_cap(inode))
 			return -EPERM;
 	/* required for strict SunOS emulation */
 	if (O_NONBLOCK != O_NDELAY)
 	       if (arg & O_NDELAY)
 		   arg |= O_NONBLOCK;
 	if (arg & O_DIRECT) {
 		if (!filp->f_mapping || !filp->f_mapping->a_ops ||
 			!filp->f_mapping->a_ops->direct_IO)
 				return -EINVAL;
 	}
 	if (filp->f_op && filp->f_op->check_flags)
 		error = filp->f_op->check_flags(arg);
 	if (error)
 		return error;
 	/*
 	 * ->fasync() is responsible for setting the FASYNC bit.
 	 */
 	if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
 			filp->f_op->fasync) {
 		error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
 		if (error < 0)
 			goto out;
 		if (error > 0)
 			error = 0;
 	}
 	spin_lock(&filp->f_lock);
 	filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
 	spin_unlock(&filp->f_lock);
  out:
 	return error;
 }
 static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
                      int force)
 {
 	write_lock_irq(&filp->f_owner.lock);
 	if (force || !filp->f_owner.pid) {
 		put_pid(filp->f_owner.pid);
 		filp->f_owner.pid = get_pid(pid);
 		filp->f_owner.pid_type = type;
 		if (pid) {
 			const struct cred *cred = current_cred();
 			filp->f_owner.uid = cred->uid;
 			filp->f_owner.euid = cred->euid;
 		}
 	}
 	write_unlock_irq(&filp->f_owner.lock);
 }
 int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
 		int force)
 {
 	int err;
 	err = security_file_set_fowner(filp);
 	if (err)
 		return err;
 	f_modown(filp, pid, type, force);
 	return 0;
 }
 EXPORT_SYMBOL(__f_setown);
 int f_setown(struct file *filp, unsigned long arg, int force)
 {
 	enum pid_type type;
 	struct pid *pid;
 	int who = arg;
 	int result;
 	type = PIDTYPE_PID;
 	if (who < 0) {
 		type = PIDTYPE_PGID;
 		who = -who;
 	}
 	rcu_read_lock();
 	pid = find_vpid(who);
 	result = __f_setown(filp, pid, type, force);
 	rcu_read_unlock();
 	return result;
 }
 EXPORT_SYMBOL(f_setown);
 void f_delown(struct file *filp)
 {
 	f_modown(filp, NULL, PIDTYPE_PID, 1);
 }
 pid_t f_getown(struct file *filp)
 {
 	pid_t pid;
 	read_lock(&filp->f_owner.lock);
 	pid = pid_vnr(filp->f_owner.pid);
 	if (filp->f_owner.pid_type == PIDTYPE_PGID)
 		pid = -pid;
 	read_unlock(&filp->f_owner.lock);
 	return pid;
 }
 static int f_setown_ex(struct file *filp, unsigned long arg)
 {
 	struct f_owner_ex * __user owner_p = (void * __user)arg;
 	struct f_owner_ex owner;
 	struct pid *pid;
 	int type;
 	int ret;
 	ret = copy_from_user(&owner, owner_p, sizeof(owner));
 	if (ret)
 		return ret;
 	switch (owner.type) {
 	case F_OWNER_TID:
 		type = PIDTYPE_MAX;
 		break;
 	case F_OWNER_PID:
 		type = PIDTYPE_PID;
 		break;
 	case F_OWNER_PGRP:
 		type = PIDTYPE_PGID;
 		break;
 	default:
 		return -EINVAL;
 	}
 	rcu_read_lock();
 	pid = find_vpid(owner.pid);
 	if (owner.pid && !pid)
 		ret = -ESRCH;
 	else
 		ret = __f_setown(filp, pid, type, 1);
 	rcu_read_unlock();
 	return ret;
 }
 static int f_getown_ex(struct file *filp, unsigned long arg)
 {
 	struct f_owner_ex * __user owner_p = (void * __user)arg;
 	struct f_owner_ex owner;
 	int ret = 0;
 	read_lock(&filp->f_owner.lock);
 	owner.pid = pid_vnr(filp->f_owner.pid);
 	switch (filp->f_owner.pid_type) {
 	case PIDTYPE_MAX:
 		owner.type = F_OWNER_TID;
 		break;
 	case PIDTYPE_PID:
 		owner.type = F_OWNER_PID;
 		break;
 	case PIDTYPE_PGID:
 		owner.type = F_OWNER_PGRP;
 		break;
 	default:
 		WARN_ON(1);
 		ret = -EINVAL;
 		break;
 	}
 	read_unlock(&filp->f_owner.lock);
 	if (!ret)
 		ret = copy_to_user(owner_p, &owner, sizeof(owner));
 	return ret;
 }
 static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
 		struct file *filp)
 {
 	long err = -EINVAL;
 	switch (cmd) {
 	case F_DUPFD:
 	case F_DUPFD_CLOEXEC:
 		if (arg >= rlimit(RLIMIT_NOFILE))
 			break;
 		err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
 		if (err >= 0) {
 			get_file(filp);
 			fd_install(err, filp);
 		}
 		break;
 	case F_GETFD:
 		err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
 		break;
 	case F_SETFD:
 		err = 0;
 		set_close_on_exec(fd, arg & FD_CLOEXEC);
 		break;
 	case F_GETFL:
 		err = filp->f_flags;
 		break;
 	case F_SETFL:
 		err = setfl(fd, filp, arg);
 		break;
 	case F_GETLK:
 		err = fcntl_getlk(filp, (struct flock __user *) arg);
 		break;
 	case F_SETLK:
 	case F_SETLKW:
 		err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
 		break;
 	case F_GETOWN:
 		/*
 		 * XXX If f_owner is a process group, the
 		 * negative return value will get converted
 		 * into an error.  Oops.  If we keep the
 		 * current syscall conventions, the only way
 		 * to fix this will be in libc.
 		 */
 		err = f_getown(filp);
 		force_successful_syscall_return();
 		break;
 	case F_SETOWN:
 		err = f_setown(filp, arg, 1);
 		break;
 	case F_GETOWN_EX:
 		err = f_getown_ex(filp, arg);
 		break;
 	case F_SETOWN_EX:
 		err = f_setown_ex(filp, arg);
 		break;
 	case F_GETSIG:
 		err = filp->f_owner.signum;
 		break;
 	case F_SETSIG:
 		/* arg == 0 restores default behaviour. */
 		if (!valid_signal(arg)) {
 			break;
 		}
 		err = 0;
 		filp->f_owner.signum = arg;
 		break;
 	case F_GETLEASE:
 		err = fcntl_getlease(filp);
 		break;
 	case F_SETLEASE:
 		err = fcntl_setlease(fd, filp, arg);
 		break;
 	case F_NOTIFY:
 		err = fcntl_dirnotify(fd, filp, arg);
 		break;
 	default:
 		break;
 	}
 	return err;
 }
 SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
 {
 	struct file *filp;
 	long err = -EBADF;
 	filp = fget(fd);
 	if (!filp)
 		goto out;
 	err = security_file_fcntl(filp, cmd, arg);
 	if (err) {
 		fput(filp);
 		return err;
 	}
 	err = do_fcntl(fd, cmd, arg, filp);
  	fput(filp);
 out:
 	return err;
 }
 #if BITS_PER_LONG == 32
 SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
 		unsigned long, arg)
 {
 	struct file * filp;
 	long err;
 	err = -EBADF;
 	filp = fget(fd);
 	if (!filp)
 		goto out;
 	err = security_file_fcntl(filp, cmd, arg);
 	if (err) {
 		fput(filp);
 		return err;
 	}
 	err = -EBADF;
 	switch (cmd) {
 		case F_GETLK64:
 			err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
 			break;
 		case F_SETLK64:
 		case F_SETLKW64:
 			err = fcntl_setlk64(fd, filp, cmd,
 					(struct flock64 __user *) arg);
 			break;
 		default:
 			err = do_fcntl(fd, cmd, arg, filp);
 			break;
 	}
 	fput(filp);
 out:
 	return err;
 }
 #endif
 /* Table to convert sigio signal codes into poll band bitmaps */
 static const long band_table[NSIGPOLL] = {
 	POLLIN | POLLRDNORM,			/* POLL_IN */
 	POLLOUT | POLLWRNORM | POLLWRBAND,	/* POLL_OUT */
 	POLLIN | POLLRDNORM | POLLMSG,		/* POLL_MSG */
 	POLLERR,				/* POLL_ERR */
 	POLLPRI | POLLRDBAND,			/* POLL_PRI */
 	POLLHUP | POLLERR			/* POLL_HUP */
 };
 static inline int sigio_perm(struct task_struct *p,
                              struct fown_struct *fown, int sig)
 {
 	const struct cred *cred;
 	int ret;
 	rcu_read_lock();
 	cred = __task_cred(p);
 	ret = ((fown->euid == 0 ||
 		fown->euid == cred->suid || fown->euid == cred->uid ||
 		fown->uid  == cred->suid || fown->uid  == cred->uid) &&
 	       !security_file_send_sigiotask(p, fown, sig));
 	rcu_read_unlock();
 	return ret;
 }
 static void send_sigio_to_task(struct task_struct *p,
 			       struct fown_struct *fown,
 			       int fd, int reason, int group)
 {
 	/*
 	 * F_SETSIG can change ->signum lockless in parallel, make
 	 * sure we read it once and use the same value throughout.
 	 */
 	int signum = ACCESS_ONCE(fown->signum);
 	if (!sigio_perm(p, fown, signum))
 		return;
 	switch (signum) {
 		siginfo_t si;
 		default:
 			/* Queue a rt signal with the appropriate fd as its
 			   value.  We use SI_SIGIO as the source, not
 			   SI_KERNEL, since kernel signals always get
 			   delivered even if we can't queue.  Failure to
 			   queue in this case _should_ be reported; we fall
 			   back to SIGIO in that case. --sct */
 			si.si_signo = signum;
 			si.si_errno = 0;
 		        si.si_code  = reason;
 			/* Make sure we are called with one of the POLL_*
 			   reasons, otherwise we could leak kernel stack into
 			   userspace.  */
 			BUG_ON((reason & __SI_MASK) != __SI_POLL);
 			if (reason - POLL_IN >= NSIGPOLL)
 				si.si_band  = ~0L;
 			else
 				si.si_band = band_table[reason - POLL_IN];
 			si.si_fd    = fd;
 			if (!do_send_sig_info(signum, &si, p, group))
 				break;
 		/* fall-through: fall back on the old plain SIGIO signal */
 		case 0:
 			do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
 	}
 }
 void send_sigio(struct fown_struct *fown, int fd, int band)
 {
 	struct task_struct *p;
 	enum pid_type type;
 	struct pid *pid;
 	int group = 1;
 	read_lock(&fown->lock);
 	type = fown->pid_type;
 	if (type == PIDTYPE_MAX) {
 		group = 0;
 		type = PIDTYPE_PID;
 	}
 	pid = fown->pid;
 	if (!pid)
 		goto out_unlock_fown;
 	read_lock(&tasklist_lock);
 	do_each_pid_task(pid, type, p) {
 		send_sigio_to_task(p, fown, fd, band, group);
 	} while_each_pid_task(pid, type, p);
 	read_unlock(&tasklist_lock);
  out_unlock_fown:
 	read_unlock(&fown->lock);
 }
 static void send_sigurg_to_task(struct task_struct *p,
 				struct fown_struct *fown, int group)
 {
 	if (sigio_perm(p, fown, SIGURG))
 		do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
 }
 int send_sigurg(struct fown_struct *fown)
 {
 	struct task_struct *p;
 	enum pid_type type;
 	struct pid *pid;
 	int group = 1;
 	int ret = 0;
 	read_lock(&fown->lock);
 	type = fown->pid_type;
 	if (type == PIDTYPE_MAX) {
 		group = 0;
 		type = PIDTYPE_PID;
 	}
 	pid = fown->pid;
 	if (!pid)
 		goto out_unlock_fown;
 	ret = 1;
 	read_lock(&tasklist_lock);
 	do_each_pid_task(pid, type, p) {
 		send_sigurg_to_task(p, fown, group);
 	} while_each_pid_task(pid, type, p);
 	read_unlock(&tasklist_lock);
  out_unlock_fown:
 	read_unlock(&fown->lock);
 	return ret;
 }
-static DEFINE_RWLOCK(fasync_lock);
+static DEFINE_SPINLOCK(fasync_lock);
 static struct kmem_cache *fasync_cache __read_mostly;
+static void fasync_free_rcu(struct rcu_head *head)
+{
+	kmem_cache_free(fasync_cache,
+			container_of(head, struct fasync_struct, fa_rcu));
+}
 /*
  * Remove a fasync entry. If successfully removed, return
  * positive and clear the FASYNC flag. If no entry exists,
  * do nothing and return 0.
  *
  * NOTE! It is very important that the FASYNC flag always
  * match the state "is the filp on a fasync list".
  *
- * We always take the 'filp->f_lock', in since fasync_lock
- * needs to be irq-safe.
  */
 static int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
 {
 	struct fasync_struct *fa, **fp;
 	int result = 0;
 	spin_lock(&filp->f_lock);
-	write_lock_irq(&fasync_lock);
+	spin_lock(&fasync_lock);
 	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
 		if (fa->fa_file != filp)
 			continue;
+		spin_lock_irq(&fa->fa_lock);
+		fa->fa_file = NULL;
+		spin_unlock_irq(&fa->fa_lock);
 		*fp = fa->fa_next;
-		kmem_cache_free(fasync_cache, fa);
+		call_rcu(&fa->fa_rcu, fasync_free_rcu);
 		filp->f_flags &= ~FASYNC;
 		result = 1;
 		break;
 	}
-	write_unlock_irq(&fasync_lock);
+	spin_unlock(&fasync_lock);
 	spin_unlock(&filp->f_lock);
 	return result;
 }
 /*
  * Add a fasync entry. Return negative on error, positive if
  * added, and zero if did nothing but change an existing one.
  *
  * NOTE! It is very important that the FASYNC flag always
  * match the state "is the filp on a fasync list".
  */
 static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
 {
 	struct fasync_struct *new, *fa, **fp;
 	int result = 0;
 	new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
 	if (!new)
 		return -ENOMEM;
 	spin_lock(&filp->f_lock);
-	write_lock_irq(&fasync_lock);
+	spin_lock(&fasync_lock);
 	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
 		if (fa->fa_file != filp)
 			continue;
+		spin_lock_irq(&fa->fa_lock);
 		fa->fa_fd = fd;
+		spin_unlock_irq(&fa->fa_lock);
 		kmem_cache_free(fasync_cache, new);
 		goto out;
 	}
+	spin_lock_init(&new->fa_lock);
 	new->magic = FASYNC_MAGIC;
 	new->fa_file = filp;
 	new->fa_fd = fd;
 	new->fa_next = *fapp;
-	*fapp = new;
+	rcu_assign_pointer(*fapp, new);
 	result = 1;
 	filp->f_flags |= FASYNC;
 out:
-	write_unlock_irq(&fasync_lock);
+	spin_unlock(&fasync_lock);
 	spin_unlock(&filp->f_lock);
 	return result;
 }
 /*
  * fasync_helper() is used by almost all character device drivers
  * to set up the fasync queue, and for regular files by the file
  * lease code. It returns negative on error, 0 if it did no changes
  * and positive if it added/deleted the entry.
  */
 int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
 {
 	if (!on)
 		return fasync_remove_entry(filp, fapp);
 	return fasync_add_entry(fd, filp, fapp);
 }
 EXPORT_SYMBOL(fasync_helper);
-void __kill_fasync(struct fasync_struct *fa, int sig, int band)
+/*
+ * rcu_read_lock() is held
+ */
+static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
 {
 	while (fa) {
-		struct fown_struct * fown;
+		struct fown_struct *fown;
 		if (fa->magic != FASYNC_MAGIC) {
 			printk(KERN_ERR "kill_fasync: bad magic number in "
 			       "fasync_struct!\n");
 			return;
 		}
-		fown = &fa->fa_file->f_owner;
+		spin_lock(&fa->fa_lock);
-		/* Don't send SIGURG to processes which have not set a
+		if (fa->fa_file) {
-		   queued signum: SIGURG has its own default signalling
+			fown = &fa->fa_file->f_owner;
-		   mechanism. */
+			/* Don't send SIGURG to processes which have not set a
-		if (!(sig == SIGURG && fown->signum == 0))
+			   queued signum: SIGURG has its own default signalling
-			send_sigio(fown, fa->fa_fd, band);
+			   mechanism. */
-		fa = fa->fa_next;
+			if (!(sig == SIGURG && fown->signum == 0))
+				send_sigio(fown, fa->fa_fd, band);
+		}
+		spin_unlock(&fa->fa_lock);
+		fa = rcu_dereference(fa->fa_next);
 	}
 }
-EXPORT_SYMBOL(__kill_fasync);
 void kill_fasync(struct fasync_struct **fp, int sig, int band)
 {
 	/* First a quick test without locking: usually
 	 * the list is empty.
 	 */
 	if (*fp) {
-		read_lock(&fasync_lock);
+		rcu_read_lock();
-		/* reread *fp after obtaining the lock */
+		kill_fasync_rcu(rcu_dereference(*fp), sig, band);
-		__kill_fasync(*fp, sig, band);
+		rcu_read_unlock();
-		read_unlock(&fasync_lock);
 	}
 }
 EXPORT_SYMBOL(kill_fasync);
 static int __init fasync_init(void)
 {
 	fasync_cache = kmem_cache_create("fasync_cache",
 		sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);

include/linux/fs.h

Diff comments View file @ 989a297

 #ifndef _LINUX_FS_H
 #define _LINUX_FS_H
 /*
  * This file has definitions for some important file table
  * structures etc.
  */
 #include <linux/limits.h>
 #include <linux/ioctl.h>
 /*
  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  * the file limit at runtime and only root can increase the per-process
  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  * upper limit on files-per-process.
  *
  * Some programs (notably those using select()) may have to be
  * recompiled to take full advantage of the new limits..
  */
 /* Fixed constants first: */
 #undef NR_OPEN
 #define INR_OPEN 1024		/* Initial setting for nfile rlimits */
 #define BLOCK_SIZE_BITS 10
 #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
 #define SEEK_SET	0	/* seek relative to beginning of file */
 #define SEEK_CUR	1	/* seek relative to current file position */
 #define SEEK_END	2	/* seek relative to end of file */
 #define SEEK_MAX	SEEK_END
 /* And dynamically-tunable limits and defaults: */
 struct files_stat_struct {
 	int nr_files;		/* read only */
 	int nr_free_files;	/* read only */
 	int max_files;		/* tunable */
 };
 struct inodes_stat_t {
 	int nr_inodes;
 	int nr_unused;
 	int dummy[5];		/* padding for sysctl ABI compatibility */
 };
 #define NR_FILE  8192	/* this can well be larger on a larger system */
 #define MAY_EXEC 1
 #define MAY_WRITE 2
 #define MAY_READ 4
 #define MAY_APPEND 8
 #define MAY_ACCESS 16
 #define MAY_OPEN 32
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
  * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
  */
 /* file is open for reading */
 #define FMODE_READ		((__force fmode_t)0x1)
 /* file is open for writing */
 #define FMODE_WRITE		((__force fmode_t)0x2)
 /* file is seekable */
 #define FMODE_LSEEK		((__force fmode_t)0x4)
 /* file can be accessed using pread */
 #define FMODE_PREAD		((__force fmode_t)0x8)
 /* file can be accessed using pwrite */
 #define FMODE_PWRITE		((__force fmode_t)0x10)
 /* File is opened for execution with sys_execve / sys_uselib */
 #define FMODE_EXEC		((__force fmode_t)0x20)
 /* File is opened with O_NDELAY (only set for block devices) */
 #define FMODE_NDELAY		((__force fmode_t)0x40)
 /* File is opened with O_EXCL (only set for block devices) */
 #define FMODE_EXCL		((__force fmode_t)0x80)
 /* File is opened using open(.., 3, ..) and is writeable only for ioctls
    (specialy hack for floppy.c) */
 #define FMODE_WRITE_IOCTL	((__force fmode_t)0x100)
 /*
  * Don't update ctime and mtime.
  *
  * Currently a special hack for the XFS open_by_handle ioctl, but we'll
  * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
  */
 #define FMODE_NOCMTIME		((__force fmode_t)0x800)
 /* Expect random access pattern */
 #define FMODE_RANDOM		((__force fmode_t)0x1000)
 /*
  * The below are the various read and write types that we support. Some of
  * them include behavioral modifiers that send information down to the
  * block layer and IO scheduler. Terminology:
  *
  *	The block layer uses device plugging to defer IO a little bit, in
  *	the hope that we will see more IO very shortly. This increases
  *	coalescing of adjacent IO and thus reduces the number of IOs we
  *	have to send to the device. It also allows for better queuing,
  *	if the IO isn't mergeable. If the caller is going to be waiting
  *	for the IO, then he must ensure that the device is unplugged so
  *	that the IO is dispatched to the driver.
  *
  *	All IO is handled async in Linux. This is fine for background
  *	writes, but for reads or writes that someone waits for completion
  *	on, we want to notify the block layer and IO scheduler so that they
  *	know about it. That allows them to make better scheduling
  *	decisions. So when the below references 'sync' and 'async', it
  *	is referencing this priority hint.
  *
  * With that in mind, the available types are:
  *
  * READ			A normal read operation. Device will be plugged.
  * READ_SYNC		A synchronous read. Device is not plugged, caller can
  *			immediately wait on this read without caring about
  *			unplugging.
  * READA		Used for read-ahead operations. Lower priority, and the
  *			 block layer could (in theory) choose to ignore this
  *			request if it runs into resource problems.
  * WRITE		A normal async write. Device will be plugged.
  * SWRITE		Like WRITE, but a special case for ll_rw_block() that
  *			tells it to lock the buffer first. Normally a buffer
  *			must be locked before doing IO.
  * WRITE_SYNC_PLUG	Synchronous write. Identical to WRITE, but passes down
  *			the hint that someone will be waiting on this IO
  *			shortly. The device must still be unplugged explicitly,
  *			WRITE_SYNC_PLUG does not do this as we could be
  *			submitting more writes before we actually wait on any
  *			of them.
  * WRITE_SYNC		Like WRITE_SYNC_PLUG, but also unplugs the device
  *			immediately after submission. The write equivalent
  *			of READ_SYNC.
  * WRITE_ODIRECT_PLUG	Special case write for O_DIRECT only.
  * SWRITE_SYNC
  * SWRITE_SYNC_PLUG	Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
  *			See SWRITE.
  * WRITE_BARRIER	Like WRITE, but tells the block layer that all
  *			previously submitted writes must be safely on storage
  *			before this one is started. Also guarantees that when
  *			this write is complete, it itself is also safely on
  *			storage. Prevents reordering of writes on both sides
  *			of this IO.
  *
  */
 #define RW_MASK		1
 #define RWA_MASK	2
 #define READ 0
 #define WRITE 1
 #define READA 2		/* read-ahead  - don't block if no resources */
 #define SWRITE 3	/* for ll_rw_block() - wait for buffer lock */
 #define READ_SYNC	(READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
 #define READ_META	(READ | (1 << BIO_RW_META))
 #define WRITE_SYNC_PLUG	(WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
 #define WRITE_SYNC	(WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
 #define WRITE_ODIRECT_PLUG	(WRITE | (1 << BIO_RW_SYNCIO))
 #define WRITE_META	(WRITE | (1 << BIO_RW_META))
 #define SWRITE_SYNC_PLUG	\
 			(SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
 #define SWRITE_SYNC	(SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
 #define WRITE_BARRIER	(WRITE | (1 << BIO_RW_BARRIER))
 /*
  * These aren't really reads or writes, they pass down information about
  * parts of device that are now unused by the file system.
  */
 #define DISCARD_NOBARRIER (WRITE | (1 << BIO_RW_DISCARD))
 #define DISCARD_BARRIER (DISCARD_NOBARRIER | (1 << BIO_RW_BARRIER))
 #define SEL_IN		1
 #define SEL_OUT		2
 #define SEL_EX		4
 /* public flags for file_system_type */
 #define FS_REQUIRES_DEV 1
 #define FS_BINARY_MOUNTDATA 2
 #define FS_HAS_SUBTYPE 4
 #define FS_REVAL_DOT	16384	/* Check the paths ".", ".." for staleness */
 #define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move()
 					 * during rename() internally.
 					 */
 /*
  * These are the fs-independent mount-flags: up to 32 flags are supported
  */
 #define MS_RDONLY	 1	/* Mount read-only */
 #define MS_NOSUID	 2	/* Ignore suid and sgid bits */
 #define MS_NODEV	 4	/* Disallow access to device special files */
 #define MS_NOEXEC	 8	/* Disallow program execution */
 #define MS_SYNCHRONOUS	16	/* Writes are synced at once */
 #define MS_REMOUNT	32	/* Alter flags of a mounted FS */
 #define MS_MANDLOCK	64	/* Allow mandatory locks on an FS */
 #define MS_DIRSYNC	128	/* Directory modifications are synchronous */
 #define MS_NOATIME	1024	/* Do not update access times. */
 #define MS_NODIRATIME	2048	/* Do not update directory access times */
 #define MS_BIND		4096
 #define MS_MOVE		8192
 #define MS_REC		16384
 #define MS_VERBOSE	32768	/* War is peace. Verbosity is silence.
 				   MS_VERBOSE is deprecated. */
 #define MS_SILENT	32768
 #define MS_POSIXACL	(1<<16)	/* VFS does not apply the umask */
 #define MS_UNBINDABLE	(1<<17)	/* change to unbindable */
 #define MS_PRIVATE	(1<<18)	/* change to private */
 #define MS_SLAVE	(1<<19)	/* change to slave */
 #define MS_SHARED	(1<<20)	/* change to shared */
 #define MS_RELATIME	(1<<21)	/* Update atime relative to mtime/ctime. */
 #define MS_KERNMOUNT	(1<<22) /* this is a kern_mount call */
 #define MS_I_VERSION	(1<<23) /* Update inode I_version field */
 #define MS_STRICTATIME	(1<<24) /* Always perform atime updates */
 #define MS_ACTIVE	(1<<30)
 #define MS_NOUSER	(1<<31)
 /*
  * Superblock flags that can be altered by MS_REMOUNT
  */
 #define MS_RMT_MASK	(MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
 /*
  * Old magic mount flag and mask
  */
 #define MS_MGC_VAL 0xC0ED0000
 #define MS_MGC_MSK 0xffff0000
 /* Inode flags - they have nothing to superblock flags now */
 #define S_SYNC		1	/* Writes are synced at once */
 #define S_NOATIME	2	/* Do not update access times */
 #define S_APPEND	4	/* Append-only file */
 #define S_IMMUTABLE	8	/* Immutable file */
 #define S_DEAD		16	/* removed, but still open directory */
 #define S_NOQUOTA	32	/* Inode is not counted to quota */
 #define S_DIRSYNC	64	/* Directory modifications are synchronous */
 #define S_NOCMTIME	128	/* Do not update file c/mtime */
 #define S_SWAPFILE	256	/* Do not truncate: swapon got its bmaps */
 #define S_PRIVATE	512	/* Inode is fs-internal */
 /*
  * Note that nosuid etc flags are inode-specific: setting some file-system
  * flags just means all the inodes inherit those flags by default. It might be
  * possible to override it selectively if you really wanted to with some
  * ioctl() that is not currently implemented.
  *
  * Exception: MS_RDONLY is always applied to the entire file system.
  *
  * Unfortunately, it is possible to change a filesystems flags with it mounted
  * with files in use.  This means that all of the inodes will not have their
  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  */
 #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
 #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
 #define IS_SYNC(inode)		(__IS_FLG(inode, MS_SYNCHRONOUS) || \
 					((inode)->i_flags & S_SYNC))
 #define IS_DIRSYNC(inode)	(__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
 					((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
 #define IS_MANDLOCK(inode)	__IS_FLG(inode, MS_MANDLOCK)
 #define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
 #define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
 #define IS_NOQUOTA(inode)	((inode)->i_flags & S_NOQUOTA)
 #define IS_APPEND(inode)	((inode)->i_flags & S_APPEND)
 #define IS_IMMUTABLE(inode)	((inode)->i_flags & S_IMMUTABLE)
 #define IS_POSIXACL(inode)	__IS_FLG(inode, MS_POSIXACL)
 #define IS_DEADDIR(inode)	((inode)->i_flags & S_DEAD)
 #define IS_NOCMTIME(inode)	((inode)->i_flags & S_NOCMTIME)
 #define IS_SWAPFILE(inode)	((inode)->i_flags & S_SWAPFILE)
 #define IS_PRIVATE(inode)	((inode)->i_flags & S_PRIVATE)
 /* the read-only stuff doesn't really belong here, but any other place is
    probably as bad and I don't want to create yet another include file. */
 #define BLKROSET   _IO(0x12,93)	/* set device read-only (0 = read-write) */
 #define BLKROGET   _IO(0x12,94)	/* get read-only status (0 = read_write) */
 #define BLKRRPART  _IO(0x12,95)	/* re-read partition table */
 #define BLKGETSIZE _IO(0x12,96)	/* return device size /512 (long *arg) */
 #define BLKFLSBUF  _IO(0x12,97)	/* flush buffer cache */
 #define BLKRASET   _IO(0x12,98)	/* set read ahead for block device */
 #define BLKRAGET   _IO(0x12,99)	/* get current read ahead setting */
 #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
 #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
 #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
 #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
 #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
 #if 0
 #define BLKPG      _IO(0x12,105)/* See blkpg.h */
 /* Some people are morons.  Do not use sizeof! */
 #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
 #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
 /* This was here just to show that the number is taken -
    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
 #endif
 /* A jump here: 108-111 have been used for various private purposes. */
 #define BLKBSZGET  _IOR(0x12,112,size_t)
 #define BLKBSZSET  _IOW(0x12,113,size_t)
 #define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */
 #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
 #define BLKTRACESTART _IO(0x12,116)
 #define BLKTRACESTOP _IO(0x12,117)
 #define BLKTRACETEARDOWN _IO(0x12,118)
 #define BLKDISCARD _IO(0x12,119)
 #define BLKIOMIN _IO(0x12,120)
 #define BLKIOOPT _IO(0x12,121)
 #define BLKALIGNOFF _IO(0x12,122)
 #define BLKPBSZGET _IO(0x12,123)
 #define BLKDISCARDZEROES _IO(0x12,124)
 #define BMAP_IOCTL 1		/* obsolete - kept for compatibility */
 #define FIBMAP	   _IO(0x00,1)	/* bmap access */
 #define FIGETBSZ   _IO(0x00,2)	/* get the block size used for bmap */
 #define FIFREEZE	_IOWR('X', 119, int)	/* Freeze */
 #define FITHAW		_IOWR('X', 120, int)	/* Thaw */
 #define	FS_IOC_GETFLAGS			_IOR('f', 1, long)
 #define	FS_IOC_SETFLAGS			_IOW('f', 2, long)
 #define	FS_IOC_GETVERSION		_IOR('v', 1, long)
 #define	FS_IOC_SETVERSION		_IOW('v', 2, long)
 #define FS_IOC_FIEMAP			_IOWR('f', 11, struct fiemap)
 #define FS_IOC32_GETFLAGS		_IOR('f', 1, int)
 #define FS_IOC32_SETFLAGS		_IOW('f', 2, int)
 #define FS_IOC32_GETVERSION		_IOR('v', 1, int)
 #define FS_IOC32_SETVERSION		_IOW('v', 2, int)
 /*
  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  */
 #define	FS_SECRM_FL			0x00000001 /* Secure deletion */
 #define	FS_UNRM_FL			0x00000002 /* Undelete */
 #define	FS_COMPR_FL			0x00000004 /* Compress file */
 #define FS_SYNC_FL			0x00000008 /* Synchronous updates */
 #define FS_IMMUTABLE_FL			0x00000010 /* Immutable file */
 #define FS_APPEND_FL			0x00000020 /* writes to file may only append */
 #define FS_NODUMP_FL			0x00000040 /* do not dump file */
 #define FS_NOATIME_FL			0x00000080 /* do not update atime */
 /* Reserved for compression usage... */
 #define FS_DIRTY_FL			0x00000100
 #define FS_COMPRBLK_FL			0x00000200 /* One or more compressed clusters */
 #define FS_NOCOMP_FL			0x00000400 /* Don't compress */
 #define FS_ECOMPR_FL			0x00000800 /* Compression error */
 /* End compression flags --- maybe not all used */
 #define FS_BTREE_FL			0x00001000 /* btree format dir */
 #define FS_INDEX_FL			0x00001000 /* hash-indexed directory */
 #define FS_IMAGIC_FL			0x00002000 /* AFS directory */
 #define FS_JOURNAL_DATA_FL		0x00004000 /* Reserved for ext3 */
 #define FS_NOTAIL_FL			0x00008000 /* file tail should not be merged */
 #define FS_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */
 #define FS_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
 #define FS_EXTENT_FL			0x00080000 /* Extents */
 #define FS_DIRECTIO_FL			0x00100000 /* Use direct i/o */
 #define FS_RESERVED_FL			0x80000000 /* reserved for ext2 lib */
 #define FS_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
 #define FS_FL_USER_MODIFIABLE		0x000380FF /* User modifiable flags */
 #define SYNC_FILE_RANGE_WAIT_BEFORE	1
 #define SYNC_FILE_RANGE_WRITE		2
 #define SYNC_FILE_RANGE_WAIT_AFTER	4
 #ifdef __KERNEL__
 #include <linux/linkage.h>
 #include <linux/wait.h>
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
 #include <linux/path.h>
 #include <linux/stat.h>
 #include <linux/cache.h>
 #include <linux/kobject.h>
 #include <linux/list.h>
 #include <linux/radix-tree.h>
 #include <linux/prio_tree.h>
 #include <linux/init.h>
 #include <linux/pid.h>
 #include <linux/mutex.h>
 #include <linux/capability.h>
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
 #include <asm/atomic.h>
 #include <asm/byteorder.h>
 struct export_operations;
 struct hd_geometry;
 struct iovec;
 struct nameidata;
 struct kiocb;
 struct pipe_inode_info;
 struct poll_table_struct;
 struct kstatfs;
 struct vm_area_struct;
 struct vfsmount;
 struct cred;
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
 extern void __init files_init(unsigned long);
 extern struct files_stat_struct files_stat;
 extern int get_max_files(void);
 extern int sysctl_nr_open;
 extern struct inodes_stat_t inodes_stat;
 extern int leases_enable, lease_break_time;
 #ifdef CONFIG_DNOTIFY
 extern int dir_notify_enable;
 #endif
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
 			struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 			ssize_t bytes, void *private);
 /*
  * Attribute flags.  These should be or-ed together to figure out what
  * has been changed!
  */
 #define ATTR_MODE	(1 << 0)
 #define ATTR_UID	(1 << 1)
 #define ATTR_GID	(1 << 2)
 #define ATTR_SIZE	(1 << 3)
 #define ATTR_ATIME	(1 << 4)
 #define ATTR_MTIME	(1 << 5)
 #define ATTR_CTIME	(1 << 6)
 #define ATTR_ATIME_SET	(1 << 7)
 #define ATTR_MTIME_SET	(1 << 8)
 #define ATTR_FORCE	(1 << 9) /* Not a change, but a change it */
 #define ATTR_ATTR_FLAG	(1 << 10)
 #define ATTR_KILL_SUID	(1 << 11)
 #define ATTR_KILL_SGID	(1 << 12)
 #define ATTR_FILE	(1 << 13)
 #define ATTR_KILL_PRIV	(1 << 14)
 #define ATTR_OPEN	(1 << 15) /* Truncating from open(O_TRUNC) */
 #define ATTR_TIMES_SET	(1 << 16)
 /*
  * This is the Inode Attributes structure, used for notify_change().  It
  * uses the above definitions as flags, to know which values have changed.
  * Also, in this manner, a Filesystem can look at only the values it cares
  * about.  Basically, these are the attributes that the VFS layer can
  * request to change from the FS layer.
  *
  * Derek Atkins <warlord@MIT.EDU> 94-10-20
  */
 struct iattr {
 	unsigned int	ia_valid;
 	umode_t		ia_mode;
 	uid_t		ia_uid;
 	gid_t		ia_gid;
 	loff_t		ia_size;
 	struct timespec	ia_atime;
 	struct timespec	ia_mtime;
 	struct timespec	ia_ctime;
 	/*
 	 * Not an attribute, but an auxilary info for filesystems wanting to
 	 * implement an ftruncate() like method.  NOTE: filesystem should
 	 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
 	 */
 	struct file	*ia_file;
 };
 /*
  * Includes for diskquotas.
  */
 #include <linux/quota.h>
 /**
  * enum positive_aop_returns - aop return codes with specific semantics
  *
  * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
  * 			    completed, that the page is still locked, and
  * 			    should be considered active.  The VM uses this hint
  * 			    to return the page to the active list -- it won't
  * 			    be a candidate for writeback again in the near
  * 			    future.  Other callers must be careful to unlock
  * 			    the page if they get this return.  Returned by
  * 			    writepage();
  *
  * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
  *  			unlocked it and the page might have been truncated.
  *  			The caller should back up to acquiring a new page and
  *  			trying again.  The aop will be taking reasonable
  *  			precautions not to livelock.  If the caller held a page
  *  			reference, it should drop it before retrying.  Returned
  *  			by readpage().
  *
  * address_space_operation functions return these large constants to indicate
  * special semantics to the caller.  These are much larger than the bytes in a
  * page to allow for functions that return the number of bytes operated on in a
  * given page.
  */
 enum positive_aop_returns {
 	AOP_WRITEPAGE_ACTIVATE	= 0x80000,
 	AOP_TRUNCATED_PAGE	= 0x80001,
 };
 #define AOP_FLAG_UNINTERRUPTIBLE	0x0001 /* will not do a short write */
 #define AOP_FLAG_CONT_EXPAND		0x0002 /* called from cont_expand */
 #define AOP_FLAG_NOFS			0x0004 /* used by filesystem to direct
 						* helper code (eg buffer layer)
 						* to clear GFP_FS from alloc */
 /*
  * oh the beauties of C type declarations.
  */
 struct page;
 struct address_space;
 struct writeback_control;
 struct iov_iter {
 	const struct iovec *iov;
 	unsigned long nr_segs;
 	size_t iov_offset;
 	size_t count;
 };
 size_t iov_iter_copy_from_user_atomic(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 size_t iov_iter_copy_from_user(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 void iov_iter_advance(struct iov_iter *i, size_t bytes);
 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
 size_t iov_iter_single_seg_count(struct iov_iter *i);
 static inline void iov_iter_init(struct iov_iter *i,
 			const struct iovec *iov, unsigned long nr_segs,
 			size_t count, size_t written)
 {
 	i->iov = iov;
 	i->nr_segs = nr_segs;
 	i->iov_offset = 0;
 	i->count = count + written;
 	iov_iter_advance(i, written);
 }
 static inline size_t iov_iter_count(struct iov_iter *i)
 {
 	return i->count;
 }
 /*
  * "descriptor" for what we're up to with a read.
  * This allows us to use the same read code yet
  * have multiple different users of the data that
  * we read from a file.
  *
  * The simplest case just copies the data to user
  * mode.
  */
 typedef struct {
 	size_t written;
 	size_t count;
 	union {
 		char __user *buf;
 		void *data;
 	} arg;
 	int error;
 } read_descriptor_t;
 typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
 		unsigned long, unsigned long);
 struct address_space_operations {
 	int (*writepage)(struct page *page, struct writeback_control *wbc);
 	int (*readpage)(struct file *, struct page *);
 	void (*sync_page)(struct page *);
 	/* Write back some dirty pages from this mapping. */
 	int (*writepages)(struct address_space *, struct writeback_control *);
 	/* Set a page dirty.  Return true if this dirtied it */
 	int (*set_page_dirty)(struct page *page);
 	int (*readpages)(struct file *filp, struct address_space *mapping,
 			struct list_head *pages, unsigned nr_pages);
 	int (*write_begin)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 	int (*write_end)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
 	sector_t (*bmap)(struct address_space *, sector_t);
 	void (*invalidatepage) (struct page *, unsigned long);
 	int (*releasepage) (struct page *, gfp_t);
 	ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
 			loff_t offset, unsigned long nr_segs);
 	int (*get_xip_mem)(struct address_space *, pgoff_t, int,
 						void **, unsigned long *);
 	/* migrate the contents of a page to the specified target */
 	int (*migratepage) (struct address_space *,
 			struct page *, struct page *);
 	int (*launder_page) (struct page *);
 	int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
 					unsigned long);
 	int (*error_remove_page)(struct address_space *, struct page *);
 };
 /*
  * pagecache_write_begin/pagecache_write_end must be used by general code
  * to write into the pagecache.
  */
 int pagecache_write_begin(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 int pagecache_write_end(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 struct backing_dev_info;
 struct address_space {
 	struct inode		*host;		/* owner: inode, block_device */
 	struct radix_tree_root	page_tree;	/* radix tree of all pages */
 	spinlock_t		tree_lock;	/* and lock protecting it */
 	unsigned int		i_mmap_writable;/* count VM_SHARED mappings */
 	struct prio_tree_root	i_mmap;		/* tree of private and shared mappings */
 	struct list_head	i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
 	spinlock_t		i_mmap_lock;	/* protect tree, count, list */
 	unsigned int		truncate_count;	/* Cover race condition with truncate */
 	unsigned long		nrpages;	/* number of total pages */
 	pgoff_t			writeback_index;/* writeback starts here */
 	const struct address_space_operations *a_ops;	/* methods */
 	unsigned long		flags;		/* error bits/gfp mask */
 	struct backing_dev_info *backing_dev_info; /* device readahead, etc */
 	spinlock_t		private_lock;	/* for use by the address_space */
 	struct list_head	private_list;	/* ditto */
 	struct address_space	*assoc_mapping;	/* ditto */
 } __attribute__((aligned(sizeof(long))));
 	/*
 	 * On most architectures that alignment is already the case; but
 	 * must be enforced here for CRIS, to let the least signficant bit
 	 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
 	 */
 struct block_device {
 	dev_t			bd_dev;  /* not a kdev_t - it's a search key */
 	struct inode *		bd_inode;	/* will die */
 	struct super_block *	bd_super;
 	int			bd_openers;
 	struct mutex		bd_mutex;	/* open/close mutex */
 	struct list_head	bd_inodes;
 	void *			bd_holder;
 	int			bd_holders;
 #ifdef CONFIG_SYSFS
 	struct list_head	bd_holder_list;
 #endif
 	struct block_device *	bd_contains;
 	unsigned		bd_block_size;
 	struct hd_struct *	bd_part;
 	/* number of times partitions within this device have been opened. */
 	unsigned		bd_part_count;
 	int			bd_invalidated;
 	struct gendisk *	bd_disk;
 	struct list_head	bd_list;
 	/*
 	 * Private data.  You must have bd_claim'ed the block_device
 	 * to use this.  NOTE:  bd_claim allows an owner to claim
 	 * the same device multiple times, the owner must take special
 	 * care to not mess up bd_private for that case.
 	 */
 	unsigned long		bd_private;
 	/* The counter of freeze processes */
 	int			bd_fsfreeze_count;
 	/* Mutex for freeze */
 	struct mutex		bd_fsfreeze_mutex;
 };
 /*
  * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
  * radix trees
  */
 #define PAGECACHE_TAG_DIRTY	0
 #define PAGECACHE_TAG_WRITEBACK	1
 int mapping_tagged(struct address_space *mapping, int tag);
 /*
  * Might pages of this file be mapped into userspace?
  */
 static inline int mapping_mapped(struct address_space *mapping)
 {
 	return	!prio_tree_empty(&mapping->i_mmap) ||
 		!list_empty(&mapping->i_mmap_nonlinear);
 }
 /*
  * Might pages of this file have been modified in userspace?
  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
  * marks vma as VM_SHARED if it is shared, and the file was opened for
  * writing i.e. vma may be mprotected writable even if now readonly.
  */
 static inline int mapping_writably_mapped(struct address_space *mapping)
 {
 	return mapping->i_mmap_writable != 0;
 }
 /*
  * Use sequence counter to get consistent i_size on 32-bit processors.
  */
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 #include <linux/seqlock.h>
 #define __NEED_I_SIZE_ORDERED
 #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
 #else
 #define i_size_ordered_init(inode) do { } while (0)
 #endif
 struct posix_acl;
 #define ACL_NOT_CACHED ((void *)(-1))
 struct inode {
 	struct hlist_node	i_hash;
 	struct list_head	i_list;		/* backing dev IO list */
 	struct list_head	i_sb_list;
 	struct list_head	i_dentry;
 	unsigned long		i_ino;
 	atomic_t		i_count;
 	unsigned int		i_nlink;
 	uid_t			i_uid;
 	gid_t			i_gid;
 	dev_t			i_rdev;
 	unsigned int		i_blkbits;
 	u64			i_version;
 	loff_t			i_size;
 #ifdef __NEED_I_SIZE_ORDERED
 	seqcount_t		i_size_seqcount;
 #endif
 	struct timespec		i_atime;
 	struct timespec		i_mtime;
 	struct timespec		i_ctime;
 	blkcnt_t		i_blocks;
 	unsigned short          i_bytes;
 	umode_t			i_mode;
 	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
 	struct mutex		i_mutex;
 	struct rw_semaphore	i_alloc_sem;
 	const struct inode_operations	*i_op;
 	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
 	struct super_block	*i_sb;
 	struct file_lock	*i_flock;
 	struct address_space	*i_mapping;
 	struct address_space	i_data;
 #ifdef CONFIG_QUOTA
 	struct dquot		*i_dquot[MAXQUOTAS];
 #endif
 	struct list_head	i_devices;
 	union {
 		struct pipe_inode_info	*i_pipe;
 		struct block_device	*i_bdev;
 		struct cdev		*i_cdev;
 	};
 	__u32			i_generation;
 #ifdef CONFIG_FSNOTIFY
 	__u32			i_fsnotify_mask; /* all events this inode cares about */
 	struct hlist_head	i_fsnotify_mark_entries; /* fsnotify mark entries */
 #endif
 #ifdef CONFIG_INOTIFY
 	struct list_head	inotify_watches; /* watches on this inode */
 	struct mutex		inotify_mutex;	/* protects the watches list */
 #endif
 	unsigned long		i_state;
 	unsigned long		dirtied_when;	/* jiffies of first dirtying */
 	unsigned int		i_flags;
 	atomic_t		i_writecount;
 #ifdef CONFIG_SECURITY
 	void			*i_security;
 #endif
 #ifdef CONFIG_FS_POSIX_ACL
 	struct posix_acl	*i_acl;
 	struct posix_acl	*i_default_acl;
 #endif
 	void			*i_private; /* fs or device private pointer */
 };
 /*
  * inode->i_mutex nesting subclasses for the lock validator:
  *
  * 0: the object of the current VFS operation
  * 1: parent
  * 2: child/target
  * 3: quota file
  *
  * The locking order between these classes is
  * parent -> child -> normal -> xattr -> quota
  */
 enum inode_i_mutex_lock_class
 {
 	I_MUTEX_NORMAL,
 	I_MUTEX_PARENT,
 	I_MUTEX_CHILD,
 	I_MUTEX_XATTR,
 	I_MUTEX_QUOTA
 };
 /*
  * NOTE: in a 32bit arch with a preemptable kernel and
  * an UP compile the i_size_read/write must be atomic
  * with respect to the local cpu (unlike with preempt disabled),
  * but they don't need to be atomic with respect to other cpus like in
  * true SMP (so they need either to either locally disable irq around
  * the read or for example on x86 they can be still implemented as a
  * cmpxchg8b without the need of the lock prefix). For SMP compiles
  * and 64bit archs it makes no difference if preempt is enabled or not.
  */
 static inline loff_t i_size_read(const struct inode *inode)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	loff_t i_size;
 	unsigned int seq;
 	do {
 		seq = read_seqcount_begin(&inode->i_size_seqcount);
 		i_size = inode->i_size;
 	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
 	return i_size;
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	loff_t i_size;
 	preempt_disable();
 	i_size = inode->i_size;
 	preempt_enable();
 	return i_size;
 #else
 	return inode->i_size;
 #endif
 }
 /*
  * NOTE: unlike i_size_read(), i_size_write() does need locking around it
  * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
  * can be lost, resulting in subsequent i_size_read() calls spinning forever.
  */
 static inline void i_size_write(struct inode *inode, loff_t i_size)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	write_seqcount_begin(&inode->i_size_seqcount);
 	inode->i_size = i_size;
 	write_seqcount_end(&inode->i_size_seqcount);
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	preempt_disable();
 	inode->i_size = i_size;
 	preempt_enable();
 #else
 	inode->i_size = i_size;
 #endif
 }
 static inline unsigned iminor(const struct inode *inode)
 {
 	return MINOR(inode->i_rdev);
 }
 static inline unsigned imajor(const struct inode *inode)
 {
 	return MAJOR(inode->i_rdev);
 }
 extern struct block_device *I_BDEV(struct inode *inode);
 struct fown_struct {
 	rwlock_t lock;          /* protects pid, uid, euid fields */
 	struct pid *pid;	/* pid or -pgrp where SIGIO should be sent */
 	enum pid_type pid_type;	/* Kind of process group SIGIO should be sent to */
 	uid_t uid, euid;	/* uid/euid of process setting the owner */
 	int signum;		/* posix.1b rt signal to be delivered on IO */
 };
 /*
  * Track a single file's readahead state
  */
 struct file_ra_state {
 	pgoff_t start;			/* where readahead started */
 	unsigned int size;		/* # of readahead pages */
 	unsigned int async_size;	/* do asynchronous readahead when
 					   there are only # of pages ahead */
 	unsigned int ra_pages;		/* Maximum readahead window */
 	unsigned int mmap_miss;		/* Cache miss stat for mmap accesses */
 	loff_t prev_pos;		/* Cache last read() position */
 };
 /*
  * Check if @index falls in the readahead windows.
  */
 static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
 {
 	return (index >= ra->start &&
 		index <  ra->start + ra->size);
 }
 #define FILE_MNT_WRITE_TAKEN	1
 #define FILE_MNT_WRITE_RELEASED	2
 struct file {
 	/*
 	 * fu_list becomes invalid after file_free is called and queued via
 	 * fu_rcuhead for RCU freeing
 	 */
 	union {
 		struct list_head	fu_list;
 		struct rcu_head 	fu_rcuhead;
 	} f_u;
 	struct path		f_path;
 #define f_dentry	f_path.dentry
 #define f_vfsmnt	f_path.mnt
 	const struct file_operations	*f_op;
 	spinlock_t		f_lock;  /* f_ep_links, f_flags, no IRQ */
 	atomic_long_t		f_count;
 	unsigned int 		f_flags;
 	fmode_t			f_mode;
 	loff_t			f_pos;
 	struct fown_struct	f_owner;
 	const struct cred	*f_cred;
 	struct file_ra_state	f_ra;
 	u64			f_version;
 #ifdef CONFIG_SECURITY
 	void			*f_security;
 #endif
 	/* needed for tty driver, and maybe others */
 	void			*private_data;
 #ifdef CONFIG_EPOLL
 	/* Used by fs/eventpoll.c to link all the hooks to this file */
 	struct list_head	f_ep_links;
 #endif /* #ifdef CONFIG_EPOLL */
 	struct address_space	*f_mapping;
 #ifdef CONFIG_DEBUG_WRITECOUNT
 	unsigned long f_mnt_write_state;
 #endif
 };
 extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
 #define file_list_unlock() spin_unlock(&files_lock);
 #define get_file(x)	atomic_long_inc(&(x)->f_count)
 #define file_count(x)	atomic_long_read(&(x)->f_count)
 #ifdef CONFIG_DEBUG_WRITECOUNT
 static inline void file_take_write(struct file *f)
 {
 	WARN_ON(f->f_mnt_write_state != 0);
 	f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
 }
 static inline void file_release_write(struct file *f)
 {
 	f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
 }
 static inline void file_reset_write(struct file *f)
 {
 	f->f_mnt_write_state = 0;
 }
 static inline void file_check_state(struct file *f)
 {
 	/*
 	 * At this point, either both or neither of these bits
 	 * should be set.
 	 */
 	WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
 	WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
 }
 static inline int file_check_writeable(struct file *f)
 {
 	if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
 		return 0;
 	printk(KERN_WARNING "writeable file with no "
 			    "mnt_want_write()\n");
 	WARN_ON(1);
 	return -EINVAL;
 }
 #else /* !CONFIG_DEBUG_WRITECOUNT */
 static inline void file_take_write(struct file *filp) {}
 static inline void file_release_write(struct file *filp) {}
 static inline void file_reset_write(struct file *filp) {}
 static inline void file_check_state(struct file *filp) {}
 static inline int file_check_writeable(struct file *filp)
 {
 	return 0;
 }
 #endif /* CONFIG_DEBUG_WRITECOUNT */
 #define	MAX_NON_LFS	((1UL<<31) - 1)
 /* Page cache limit. The filesystems should put that into their s_maxbytes
    limits, otherwise bad things can happen in VM. */
 #if BITS_PER_LONG==32
 #define MAX_LFS_FILESIZE	(((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
 #elif BITS_PER_LONG==64
 #define MAX_LFS_FILESIZE 	0x7fffffffffffffffUL
 #endif
 #define FL_POSIX	1
 #define FL_FLOCK	2
 #define FL_ACCESS	8	/* not trying to lock, just looking */
 #define FL_EXISTS	16	/* when unlocking, test for existence */
 #define FL_LEASE	32	/* lease held on this file */
 #define FL_CLOSE	64	/* unlock on close */
 #define FL_SLEEP	128	/* A blocking lock */
 /*
  * Special return value from posix_lock_file() and vfs_lock_file() for
  * asynchronous locking.
  */
 #define FILE_LOCK_DEFERRED 1
 /*
  * The POSIX file lock owner is determined by
  * the "struct files_struct" in the thread group
  * (or NULL for no owner - BSD locks).
  *
  * Lockd stuffs a "host" pointer into this.
  */
 typedef struct files_struct *fl_owner_t;
 struct file_lock_operations {
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 };
 struct lock_manager_operations {
 	int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
 	void (*fl_notify)(struct file_lock *);	/* unblock callback */
 	int (*fl_grant)(struct file_lock *, struct file_lock *, int);
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 	void (*fl_break)(struct file_lock *);
 	int (*fl_mylease)(struct file_lock *, struct file_lock *);
 	int (*fl_change)(struct file_lock **, int);
 };
 struct lock_manager {
 	struct list_head list;
 };
 void locks_start_grace(struct lock_manager *);
 void locks_end_grace(struct lock_manager *);
 int locks_in_grace(void);
 /* that will die - we need it for nfs_lock_info */
 #include <linux/nfs_fs_i.h>
 struct file_lock {
 	struct file_lock *fl_next;	/* singly linked list for this inode  */
 	struct list_head fl_link;	/* doubly linked list of all locks */
 	struct list_head fl_block;	/* circular list of blocked processes */
 	fl_owner_t fl_owner;
 	unsigned char fl_flags;
 	unsigned char fl_type;
 	unsigned int fl_pid;
 	struct pid *fl_nspid;
 	wait_queue_head_t fl_wait;
 	struct file *fl_file;
 	loff_t fl_start;
 	loff_t fl_end;
 	struct fasync_struct *	fl_fasync; /* for lease break notifications */
 	unsigned long fl_break_time;	/* for nonblocking lease breaks */
 	const struct file_lock_operations *fl_ops;	/* Callbacks for filesystems */
 	const struct lock_manager_operations *fl_lmops;	/* Callbacks for lockmanagers */
 	union {
 		struct nfs_lock_info	nfs_fl;
 		struct nfs4_lock_info	nfs4_fl;
 		struct {
 			struct list_head link;	/* link in AFS vnode's pending_locks list */
 			int state;		/* state of grant or error if -ve */
 		} afs;
 	} fl_u;
 };
 /* The following constant reflects the upper bound of the file/locking space */
 #ifndef OFFSET_MAX
 #define INT_LIMIT(x)	(~((x)1 << (sizeof(x)*8 - 1)))
 #define OFFSET_MAX	INT_LIMIT(loff_t)
 #define OFFT_OFFSET_MAX	INT_LIMIT(off_t)
 #endif
 #include <linux/fcntl.h>
 extern void send_sigio(struct fown_struct *fown, int fd, int band);
 #ifdef CONFIG_FILE_LOCKING
 extern int fcntl_getlk(struct file *, struct flock __user *);
 extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
 			struct flock __user *);
 #if BITS_PER_LONG == 32
 extern int fcntl_getlk64(struct file *, struct flock64 __user *);
 extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
 			struct flock64 __user *);
 #endif
 extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
 extern int fcntl_getlease(struct file *filp);
 /* fs/locks.c */
 extern void locks_init_lock(struct file_lock *);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern void locks_release_private(struct file_lock *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **);
 extern int vfs_setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
 #else /* !CONFIG_FILE_LOCKING */
 static inline int fcntl_getlk(struct file *file, struct flock __user *user)
 {
 	return -EINVAL;
 }
 static inline int fcntl_setlk(unsigned int fd, struct file *file,
 			      unsigned int cmd, struct flock __user *user)
 {
 	return -EACCES;
 }
 #if BITS_PER_LONG == 32
 static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
 {
 	return -EINVAL;
 }
 static inline int fcntl_setlk64(unsigned int fd, struct file *file,
 				unsigned int cmd, struct flock64 __user *user)
 {
 	return -EACCES;
 }
 #endif
 static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 {
 	return 0;
 }
 static inline int fcntl_getlease(struct file *filp)
 {
 	return 0;
 }
 static inline void locks_init_lock(struct file_lock *fl)
 {
 	return;
 }
 static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 {
 	return;
 }
 static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 {
 	return;
 }
 static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
 {
 	return;
 }
 static inline void locks_remove_flock(struct file *filp)
 {
 	return;
 }
 static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
 {
 	return;
 }
 static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
 				  struct file_lock *conflock)
 {
 	return -ENOLCK;
 }
 static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
 {
 	return -ENOLCK;
 }
 static inline int posix_unblock_lock(struct file *filp,
 				     struct file_lock *waiter)
 {
 	return -ENOENT;
 }
 static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
 {
 	return 0;
 }
 static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
 				struct file_lock *fl, struct file_lock *conf)
 {
 	return -ENOLCK;
 }
 static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
 {
 	return 0;
 }
 static inline int flock_lock_file_wait(struct file *filp,
 				       struct file_lock *request)
 {
 	return -ENOLCK;
 }
 static inline int __break_lease(struct inode *inode, unsigned int mode)
 {
 	return 0;
 }
 static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
 {
 	return;
 }
 static inline int generic_setlease(struct file *filp, long arg,
 				    struct file_lock **flp)
 {
 	return -EINVAL;
 }
 static inline int vfs_setlease(struct file *filp, long arg,
 			       struct file_lock **lease)
 {
 	return -EINVAL;
 }
 static inline int lease_modify(struct file_lock **before, int arg)
 {
 	return -EINVAL;
 }
 static inline int lock_may_read(struct inode *inode, loff_t start,
 				unsigned long len)
 {
 	return 1;
 }
 static inline int lock_may_write(struct inode *inode, loff_t start,
 				 unsigned long len)
 {
 	return 1;
 }
 #endif /* !CONFIG_FILE_LOCKING */
 struct fasync_struct {
-	int	magic;
+	spinlock_t		fa_lock;
-	int	fa_fd;
+	int			magic;
-	struct	fasync_struct	*fa_next; /* singly linked list */
+	int			fa_fd;
-	struct	file 		*fa_file;
+	struct fasync_struct	*fa_next; /* singly linked list */
+	struct file		*fa_file;
+	struct rcu_head		fa_rcu;
 };
 #define FASYNC_MAGIC 0x4601
 /* SMP safe fasync helpers: */
 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
 /* can be called from interrupts */
 extern void kill_fasync(struct fasync_struct **, int, int);
-/* only for net: no internal synchronization */
-extern void __kill_fasync(struct fasync_struct *, int, int);
 extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
 extern int f_setown(struct file *filp, unsigned long arg, int force);
 extern void f_delown(struct file *filp);
 extern pid_t f_getown(struct file *filp);
 extern int send_sigurg(struct fown_struct *fown);
 /*
  *	Umount options
  */
 #define MNT_FORCE	0x00000001	/* Attempt to forcibily umount */
 #define MNT_DETACH	0x00000002	/* Just detach from the tree */
 #define MNT_EXPIRE	0x00000004	/* Mark for expiry */
 #define UMOUNT_NOFOLLOW	0x00000008	/* Don't follow symlink on umount */
 #define UMOUNT_UNUSED	0x80000000	/* Flag guaranteed to be unused */
 extern struct list_head super_blocks;
 extern spinlock_t sb_lock;
 #define sb_entry(list)  list_entry((list), struct super_block, s_list)
 #define S_BIAS (1<<30)
 struct super_block {
 	struct list_head	s_list;		/* Keep this first */
 	dev_t			s_dev;		/* search index; _not_ kdev_t */
 	unsigned char		s_dirt;
 	unsigned char		s_blocksize_bits;
 	unsigned long		s_blocksize;
 	loff_t			s_maxbytes;	/* Max file size */
 	struct file_system_type	*s_type;
 	const struct super_operations	*s_op;
 	const struct dquot_operations	*dq_op;
 	const struct quotactl_ops	*s_qcop;
 	const struct export_operations *s_export_op;
 	unsigned long		s_flags;
 	unsigned long		s_magic;
 	struct dentry		*s_root;
 	struct rw_semaphore	s_umount;
 	struct mutex		s_lock;
 	int			s_count;
 	int			s_need_sync;
 	atomic_t		s_active;
 #ifdef CONFIG_SECURITY
 	void                    *s_security;
 #endif
 	struct xattr_handler	**s_xattr;
 	struct list_head	s_inodes;	/* all inodes */
 	struct hlist_head	s_anon;		/* anonymous dentries for (nfs) exporting */
 	struct list_head	s_files;
 	/* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
 	struct list_head	s_dentry_lru;	/* unused dentry lru */
 	int			s_nr_dentry_unused;	/* # of dentry on lru */
 	struct block_device	*s_bdev;
 	struct backing_dev_info *s_bdi;
 	struct mtd_info		*s_mtd;
 	struct list_head	s_instances;
 	struct quota_info	s_dquot;	/* Diskquota specific options */
 	int			s_frozen;
 	wait_queue_head_t	s_wait_unfrozen;
 	char s_id[32];				/* Informational name */
 	void 			*s_fs_info;	/* Filesystem private info */
 	fmode_t			s_mode;
 	/* Granularity of c/m/atime in ns.
 	   Cannot be worse than a second */
 	u32		   s_time_gran;
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
 	 * even looking at it. You had been warned.
 	 */
 	struct mutex s_vfs_rename_mutex;	/* Kludge */
 	/*
 	 * Filesystem subtype.  If non-empty the filesystem type field
 	 * in /proc/mounts will be "type.subtype"
 	 */
 	char *s_subtype;
 	/*
 	 * Saved mount options for lazy filesystems using
 	 * generic_show_options()
 	 */
 	char *s_options;
 };
 extern struct timespec current_fs_time(struct super_block *sb);
 /*
  * Snapshotting support.
  */
 enum {
 	SB_UNFROZEN = 0,
 	SB_FREEZE_WRITE	= 1,
 	SB_FREEZE_TRANS = 2,
 };
 #define vfs_check_frozen(sb, level) \
 	wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
 #define get_fs_excl() atomic_inc(&current->fs_excl)
 #define put_fs_excl() atomic_dec(&current->fs_excl)
 #define has_fs_excl() atomic_read(&current->fs_excl)
 #define is_owner_or_cap(inode)	\
 	((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))
 /* not quite ready to be deprecated, but... */
 extern void lock_super(struct super_block *);
 extern void unlock_super(struct super_block *);
 /*
  * VFS helper functions..
  */
 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
 extern int vfs_symlink(struct inode *, struct dentry *, const char *);
 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 /*
  * VFS dentry helper functions.
  */
 extern void dentry_unhash(struct dentry *dentry);
 /*
  * VFS file helper functions.
  */
 extern int file_permission(struct file *, int);
 /*
  * VFS FS_IOC_FIEMAP helper definitions.
  */
 struct fiemap_extent_info {
 	unsigned int fi_flags;		/* Flags as passed from user */
 	unsigned int fi_extents_mapped;	/* Number of mapped extents */
 	unsigned int fi_extents_max;	/* Size of fiemap_extent array */
 	struct fiemap_extent *fi_extents_start; /* Start of fiemap_extent
 						 * array */
 };
 int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
 			    u64 phys, u64 len, u32 flags);
 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
 /*
  * File types
  *
  * NOTE! These match bits 12..15 of stat.st_mode
  * (ie "(i_mode >> 12) & 15").
  */
 #define DT_UNKNOWN	0
 #define DT_FIFO		1
 #define DT_CHR		2
 #define DT_DIR		4
 #define DT_BLK		6
 #define DT_REG		8
 #define DT_LNK		10
 #define DT_SOCK		12
 #define DT_WHT		14
 /*
  * This is the "filldir" function type, used by readdir() to let
  * the kernel specify what kind of dirent layout it wants to have.
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
 typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
 struct block_device_operations;
 /* These macros are for out of kernel modules to test that
  * the kernel supports the unlocked_ioctl and compat_ioctl
  * fields in struct file_operations. */
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 /*
  * NOTE:
  * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
  * can be called without the big kernel lock held in all filesystems.
  */
 struct file_operations {
 	struct module *owner;
 	loff_t (*llseek) (struct file *, loff_t, int);
 	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	int (*readdir) (struct file *, void *, filldir_t);
 	unsigned int (*poll) (struct file *, struct poll_table_struct *);
 	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 	int (*mmap) (struct file *, struct vm_area_struct *);
 	int (*open) (struct inode *, struct file *);
 	int (*flush) (struct file *, fl_owner_t id);
 	int (*release) (struct inode *, struct file *);
 	int (*fsync) (struct file *, struct dentry *, int datasync);
 	int (*aio_fsync) (struct kiocb *, int datasync);
 	int (*fasync) (int, struct file *, int);
 	int (*lock) (struct file *, int, struct file_lock *);
 	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
 	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 	int (*check_flags)(int);
 	int (*flock) (struct file *, int, struct file_lock *);
 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
 	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
 	int (*setlease)(struct file *, long, struct file_lock **);
 };
 struct inode_operations {
 	int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
 	struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
 	int (*link) (struct dentry *,struct inode *,struct dentry *);
 	int (*unlink) (struct inode *,struct dentry *);
 	int (*symlink) (struct inode *,struct dentry *,const char *);
 	int (*mkdir) (struct inode *,struct dentry *,int);
 	int (*rmdir) (struct inode *,struct dentry *);
 	int (*mknod) (struct inode *,struct dentry *,int,dev_t);
 	int (*rename) (struct inode *, struct dentry *,
 			struct inode *, struct dentry *);
 	int (*readlink) (struct dentry *, char __user *,int);
 	void * (*follow_link) (struct dentry *, struct nameidata *);
 	void (*put_link) (struct dentry *, struct nameidata *, void *);
 	void (*truncate) (struct inode *);
 	int (*permission) (struct inode *, int);
 	int (*check_acl)(struct inode *, int);
 	int (*setattr) (struct dentry *, struct iattr *);
 	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
 	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
 	int (*removexattr) (struct dentry *, const char *);
 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 	long (*fallocate)(struct inode *inode, int mode, loff_t offset,
 			  loff_t len);
 	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
 		      u64 len);
 };
 struct seq_file;
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 				unsigned long nr_segs, unsigned long fast_segs,
 				struct iovec *fast_pointer,
 				struct iovec **ret_pointer);
 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 struct super_operations {
    	struct inode *(*alloc_inode)(struct super_block *sb);
 	void (*destroy_inode)(struct inode *);
    	void (*dirty_inode) (struct inode *);
 	int (*write_inode) (struct inode *, struct writeback_control *wbc);
 	void (*drop_inode) (struct inode *);
 	void (*delete_inode) (struct inode *);
 	void (*put_super) (struct super_block *);
 	void (*write_super) (struct super_block *);
 	int (*sync_fs)(struct super_block *sb, int wait);
 	int (*freeze_fs) (struct super_block *);
 	int (*unfreeze_fs) (struct super_block *);
 	int (*statfs) (struct dentry *, struct kstatfs *);
 	int (*remount_fs) (struct super_block *, int *, char *);
 	void (*clear_inode) (struct inode *);
 	void (*umount_begin) (struct super_block *);
 	int (*show_options)(struct seq_file *, struct vfsmount *);
 	int (*show_stats)(struct seq_file *, struct vfsmount *);
 #ifdef CONFIG_QUOTA
 	ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
 	ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
 #endif
 	int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
 };
 /*
  * Inode state bits.  Protected by inode_lock.
  *
  * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
  * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
  *
  * Four bits define the lifetime of an inode.  Initially, inodes are I_NEW,
  * until that flag is cleared.  I_WILL_FREE, I_FREEING and I_CLEAR are set at
  * various stages of removing an inode.
  *
  * Two bits are used for locking and completion notification, I_NEW and I_SYNC.
  *
  * I_DIRTY_SYNC		Inode is dirty, but doesn't have to be written on
  *			fdatasync().  i_atime is the usual cause.
  * I_DIRTY_DATASYNC	Data-related inode changes pending. We keep track of
  *			these changes separately from I_DIRTY_SYNC so that we
  *			don't have to write inode on fdatasync() when only
  *			mtime has changed in it.
  * I_DIRTY_PAGES	Inode has dirty pages.  Inode itself may be clean.
  * I_NEW		Serves as both a mutex and completion notification.
  *			New inodes set I_NEW.  If two processes both create
  *			the same inode, one of them will release its inode and
  *			wait for I_NEW to be released before returning.
  *			Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
  *			also cause waiting on I_NEW, without I_NEW actually
  *			being set.  find_inode() uses this to prevent returning
  *			nearly-dead inodes.
  * I_WILL_FREE		Must be set when calling write_inode_now() if i_count
  *			is zero.  I_FREEING must be set when I_WILL_FREE is
  *			cleared.
  * I_FREEING		Set when inode is about to be freed but still has dirty
  *			pages or buffers attached or the inode itself is still
  *			dirty.
  * I_CLEAR		Set by clear_inode().  In this state the inode is clean
  *			and can be destroyed.
  *
  *			Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
  *			prohibited for many purposes.  iget() must wait for
  *			the inode to be completely released, then create it
  *			anew.  Other functions will just ignore such inodes,
  *			if appropriate.  I_NEW is used for waiting.
  *
  * I_SYNC		Synchonized write of dirty inode data.  The bits is
  *			set during data writeback, and cleared with a wakeup
  *			on the bit address once it is done.
  *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC		1
 #define I_DIRTY_DATASYNC	2
 #define I_DIRTY_PAGES		4
 #define __I_NEW			3
 #define I_NEW			(1 << __I_NEW)
 #define I_WILL_FREE		16
 #define I_FREEING		32
 #define I_CLEAR			64
 #define __I_SYNC		7
 #define I_SYNC			(1 << __I_SYNC)
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 extern void __mark_inode_dirty(struct inode *, int);
 static inline void mark_inode_dirty(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY);
 }
 static inline void mark_inode_dirty_sync(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 /**
  * inc_nlink - directly increment an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  Currently,
  * it is only here for parity with dec_nlink().
  */
 static inline void inc_nlink(struct inode *inode)
 {
 	inode->i_nlink++;
 }
 static inline void inode_inc_link_count(struct inode *inode)
 {
 	inc_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * drop_nlink - directly drop an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  In cases
  * where we are attempting to track writes to the
  * filesystem, a decrement to zero means an imminent
  * write when the file is truncated and actually unlinked
  * on the filesystem.
  */
 static inline void drop_nlink(struct inode *inode)
 {
 	inode->i_nlink--;
 }
 /**
  * clear_nlink - directly zero an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  See
  * drop_nlink() for why we care about i_nlink hitting zero.
  */
 static inline void clear_nlink(struct inode *inode)
 {
 	inode->i_nlink = 0;
 }
 static inline void inode_dec_link_count(struct inode *inode)
 {
 	drop_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * inode_inc_iversion - increments i_version
  * @inode: inode that need to be updated
  *
  * Every time the inode is modified, the i_version field will be incremented.
  * The filesystem has to be mounted with i_version flag
  */
 static inline void inode_inc_iversion(struct inode *inode)
 {
        spin_lock(&inode->i_lock);
        inode->i_version++;
        spin_unlock(&inode->i_lock);
 }
 extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
 static inline void file_accessed(struct file *file)
 {
 	if (!(file->f_flags & O_NOATIME))
 		touch_atime(file->f_path.mnt, file->f_path.dentry);
 }
 int sync_inode(struct inode *inode, struct writeback_control *wbc);
 struct file_system_type {
 	const char *name;
 	int fs_flags;
 	int (*get_sb) (struct file_system_type *, int,
 		       const char *, void *, struct vfsmount *);
 	void (*kill_sb) (struct super_block *);
 	struct module *owner;
 	struct file_system_type * next;
 	struct list_head fs_supers;
 	struct lock_class_key s_lock_key;
 	struct lock_class_key s_umount_key;
 	struct lock_class_key i_lock_key;
 	struct lock_class_key i_mutex_key;
 	struct lock_class_key i_mutex_dir_key;
 	struct lock_class_key i_alloc_sem_key;
 };
 extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_bdev(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_single(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_nodev(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 void generic_shutdown_super(struct super_block *sb);
 void kill_block_super(struct super_block *sb);
 void kill_anon_super(struct super_block *sb);
 void kill_litter_super(struct super_block *sb);
 void deactivate_super(struct super_block *sb);
 void deactivate_locked_super(struct super_block *sb);
 int set_anon_super(struct super_block *s, void *data);
 struct super_block *sget(struct file_system_type *type,
 			int (*test)(struct super_block *,void *),
 			int (*set)(struct super_block *,void *),
 			void *data);
 extern int get_sb_pseudo(struct file_system_type *, char *,
 	const struct super_operations *ops, unsigned long,
 	struct vfsmount *mnt);
 extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
 int __put_super_and_need_restart(struct super_block *sb);
 void put_super(struct super_block *sb);
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
 #define fops_get(fops) \
 	(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
 #define fops_put(fops) \
 	do { if (fops) module_put((fops)->owner); } while(0)
 extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 #define kern_mount(type) kern_mount_data(type, NULL)
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
 extern struct vfsmount *collect_mounts(struct path *);
 extern void drop_collected_mounts(struct vfsmount *);
 extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
 			  struct vfsmount *);
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 extern int current_umask(void);
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 extern int rw_verify_area(int, struct file *, loff_t *, size_t);
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
 #ifdef CONFIG_FILE_LOCKING
 extern int locks_mandatory_locked(struct inode *);
 extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
 /*
  * Candidates for mandatory locking have the setgid bit set
  * but no group execute bit -  an otherwise meaningless combination.
  */
 static inline int __mandatory_lock(struct inode *ino)
 {
 	return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
 }
 /*
  * ... and these candidates should be on MS_MANDLOCK mounted fs,
  * otherwise these will be advisory locks
  */
 static inline int mandatory_lock(struct inode *ino)
 {
 	return IS_MANDLOCK(ino) && __mandatory_lock(ino);
 }
 static inline int locks_verify_locked(struct inode *inode)
 {
 	if (mandatory_lock(inode))
 		return locks_mandatory_locked(inode);
 	return 0;
 }
 static inline int locks_verify_truncate(struct inode *inode,
 				    struct file *filp,
 				    loff_t size)
 {
 	if (inode->i_flock && mandatory_lock(inode))
 		return locks_mandatory_area(
 			FLOCK_VERIFY_WRITE, inode, filp,
 			size < inode->i_size ? size : inode->i_size,
 			(size < inode->i_size ? inode->i_size - size
 			 : size - inode->i_size)
 		);
 	return 0;
 }
 static inline int break_lease(struct inode *inode, unsigned int mode)
 {
 	if (inode->i_flock)
 		return __break_lease(inode, mode);
 	return 0;
 }
 #else /* !CONFIG_FILE_LOCKING */
 static inline int locks_mandatory_locked(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_mandatory_area(int rw, struct inode *inode,
 				       struct file *filp, loff_t offset,
 				       size_t count)
 {
 	return 0;
 }
 static inline int __mandatory_lock(struct inode *inode)
 {
 	return 0;
 }
 static inline int mandatory_lock(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_verify_locked(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
 					size_t size)
 {
 	return 0;
 }
 static inline int break_lease(struct inode *inode, unsigned int mode)
 {
 	return 0;
 }
 #endif /* CONFIG_FILE_LOCKING */
 /* fs/open.c */
 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
 		       struct file *filp);
 extern int do_fallocate(struct file *file, int mode, loff_t offset,
 			loff_t len);
 extern long do_sys_open(int dfd, const char __user *filename, int flags,
 			int mode);
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
 				 const struct cred *);
 extern int filp_close(struct file *, fl_owner_t id);
 extern char * getname(const char __user *);
 /* fs/ioctl.c */
 extern int ioctl_preallocate(struct file *filp, void __user *argp);
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
 extern void __init vfs_caches_init(unsigned long);
 extern struct kmem_cache *names_cachep;
 #define __getname_gfp(gfp)	kmem_cache_alloc(names_cachep, (gfp))
 #define __getname()		__getname_gfp(GFP_KERNEL)
 #define __putname(name)		kmem_cache_free(names_cachep, (void *)(name))
 #ifndef CONFIG_AUDITSYSCALL
 #define putname(name)   __putname(name)
 #else
 extern void putname(const char *name);
 #endif
 #ifdef CONFIG_BLOCK
 extern int register_blkdev(unsigned int, const char *);
 extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern struct block_device *bdgrab(struct block_device *bdev);
 extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct block_device *open_by_devnum(dev_t, fmode_t);
 extern void invalidate_bdev(struct block_device *);
 extern int sync_blockdev(struct block_device *bdev);
 extern struct super_block *freeze_bdev(struct block_device *);
 extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
 #else
 static inline void bd_forget(struct inode *inode) {}
 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
 static inline void invalidate_bdev(struct block_device *bdev) {}
 static inline struct super_block *freeze_bdev(struct block_device *sb)
 {
 	return NULL;
 }
 static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
 {
 	return 0;
 }
 #endif
 extern int sync_filesystem(struct super_block *);
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;
 extern const struct file_operations def_fifo_fops;
 #ifdef CONFIG_BLOCK
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
 extern int blkdev_get(struct block_device *, fmode_t);
 extern int blkdev_put(struct block_device *, fmode_t);
 extern int bd_claim(struct block_device *, void *);
 extern void bd_release(struct block_device *);
 #ifdef CONFIG_SYSFS
 extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
 extern void bd_release_from_disk(struct block_device *, struct gendisk *);
 #else
 #define bd_claim_by_disk(bdev, holder, disk)	bd_claim(bdev, holder)
 #define bd_release_from_disk(bdev, disk)	bd_release(bdev)
 #endif
 #endif
 /* fs/char_dev.c */
 #define CHRDEV_MAJOR_HASH_SIZE	255
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int __register_chrdev(unsigned int major, unsigned int baseminor,
 			     unsigned int count, const char *name,
 			     const struct file_operations *fops);
 extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
 				unsigned int count, const char *name);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern void chrdev_show(struct seq_file *,off_t);
 static inline int register_chrdev(unsigned int major, const char *name,
 				  const struct file_operations *fops)
 {
 	return __register_chrdev(major, 0, 256, name, fops);
 }
 static inline void unregister_chrdev(unsigned int major, const char *name)
 {
 	__unregister_chrdev(major, 0, 256, name);
 }
 /* fs/block_dev.c */
 #define BDEVNAME_SIZE	32	/* Largest string for a blockdev identifier */
 #define BDEVT_SIZE	10	/* Largest string for MAJ:MIN for blkdev */
 #ifdef CONFIG_BLOCK
 #define BLKDEV_MAJOR_HASH_SIZE	255
 extern const char *__bdevname(dev_t, char *buffer);
 extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_exclusive(const char *, fmode_t, void *);
 extern void close_bdev_exclusive(struct block_device *, fmode_t);
 extern void blkdev_show(struct seq_file *,off_t);
 #else
 #define BLKDEV_MAJOR_HASH_SIZE	0
 #endif
 extern void init_special_inode(struct inode *, umode_t, dev_t);
 /* Invalid inode operations -- fs/bad_inode.c */
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 extern const struct file_operations read_pipefifo_fops;
 extern const struct file_operations write_pipefifo_fops;
 extern const struct file_operations rdwr_pipefifo_fops;
 extern int fs_may_remount_ro(struct super_block *);
 #ifdef CONFIG_BLOCK
 /*
  * return READ, READA, or WRITE
  */
 #define bio_rw(bio)		((bio)->bi_rw & (RW_MASK | RWA_MASK))
 /*
  * return data direction, READ or WRITE
  */
 #define bio_data_dir(bio)	((bio)->bi_rw & 1)
 extern void check_disk_size_change(struct gendisk *disk,
 				   struct block_device *bdev);
 extern int revalidate_disk(struct gendisk *);
 extern int check_disk_change(struct block_device *);
 extern int __invalidate_device(struct block_device *);
 extern int invalidate_partition(struct gendisk *, int);
 #endif
 extern int invalidate_inodes(struct super_block *);
 unsigned long invalidate_mapping_pages(struct address_space *mapping,
 					pgoff_t start, pgoff_t end);
 static inline void invalidate_remote_inode(struct inode *inode)
 {
 	if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 	    S_ISLNK(inode->i_mode))
 		invalidate_mapping_pages(inode->i_mapping, 0, -1);
 }
 extern int invalidate_inode_pages2(struct address_space *mapping);
 extern int invalidate_inode_pages2_range(struct address_space *mapping,
 					 pgoff_t start, pgoff_t end);
 extern int write_inode_now(struct inode *, int);
 extern int filemap_fdatawrite(struct address_space *);
 extern int filemap_flush(struct address_space *);
 extern int filemap_fdatawait(struct address_space *);
 extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
 				   loff_t lend);
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
 				        loff_t lstart, loff_t lend);
 extern int __filemap_fdatawrite_range(struct address_space *mapping,
 				loff_t start, loff_t end, int sync_mode);
 extern int filemap_fdatawrite_range(struct address_space *mapping,
 				loff_t start, loff_t end);
 extern int vfs_fsync_range(struct file *file, struct dentry *dentry,
 			   loff_t start, loff_t end, int datasync);
 extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
 extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
 extern void sync_supers(void);
 extern void emergency_sync(void);
 extern void emergency_remount(void);
 #ifdef CONFIG_BLOCK
 extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int,
 		int (*check_acl)(struct inode *, int));
 static inline bool execute_ok(struct inode *inode)
 {
 	return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
 }
 extern int get_write_access(struct inode *);
 extern int deny_write_access(struct file *);
 static inline void put_write_access(struct inode * inode)
 {
 	atomic_dec(&inode->i_writecount);
 }
 static inline void allow_write_access(struct file *file)
 {
 	if (file)
 		atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
 }
 extern int do_pipe_flags(int *, int);
 extern struct file *create_read_pipe(struct file *f, int flags);
 extern struct file *create_write_pipe(int flags);
 extern void free_write_pipe(struct file *);
 extern struct file *do_filp_open(int dfd, const char *pathname,
 		int open_flag, int mode, int acc_mode);
 extern int may_open(struct path *, int, int);
 extern int kernel_read(struct file *, loff_t, char *, unsigned long);
 extern struct file * open_exec(const char *);
 /* fs/dcache.c -- generic fs support functions */
 extern int is_subdir(struct dentry *, struct dentry *);
 extern int path_is_under(struct path *, struct path *);
 extern ino_t find_inode_number(struct dentry *, struct qstr *);
 #include <linux/err.h>
 /* needed for stackable file system support */
 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
 extern int inode_init_always(struct super_block *, struct inode *);
 extern void inode_init_once(struct inode *);
 extern void inode_add_to_lists(struct super_block *, struct inode *);
 extern void iput(struct inode *);
 extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
 extern void generic_delete_inode(struct inode *inode);
 extern void generic_drop_inode(struct inode *inode);
 extern int generic_detach_inode(struct inode *inode);
 extern struct inode *ilookup5_nowait(struct super_block *sb,
 		unsigned long hashval, int (*test)(struct inode *, void *),
 		void *data);
 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
 		int (*test)(struct inode *, void *), void *data);
 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
 extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
 extern struct inode * iget_locked(struct super_block *, unsigned long);
 extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
 extern int insert_inode_locked(struct inode *);
 extern void unlock_new_inode(struct inode *);
 extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void clear_inode(struct inode *);
 extern void destroy_inode(struct inode *);
 extern void __destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
 extern int should_remove_suid(struct dentry *);
 extern int file_remove_suid(struct file *);
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 extern void remove_inode_hash(struct inode *);
 static inline void insert_inode_hash(struct inode *inode) {
 	__insert_inode_hash(inode, inode->i_ino);
 }
 extern void file_move(struct file *f, struct list_head *list);
 extern void file_kill(struct file *f);
 #ifdef CONFIG_BLOCK
 struct bio;
 extern void submit_bio(int, struct bio *);
 extern int bdev_read_only(struct block_device *);
 #endif
 extern int set_blocksize(struct block_device *, int);
 extern int sb_set_blocksize(struct super_block *, int);
 extern int sb_min_blocksize(struct super_block *, int);
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
 extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
 int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
 extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t __generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long,
 		loff_t *);
 extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
 		unsigned long *, loff_t, loff_t *, size_t, size_t);
 extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t, loff_t *, size_t, ssize_t);
 extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
 extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
 extern int generic_segment_checks(const struct iovec *iov,
 		unsigned long *nr_segs, size_t *count, int access_flags);
 /* fs/block_dev.c */
 extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
 				unsigned long nr_segs, loff_t pos);
 extern int blkdev_fsync(struct file *filp, struct dentry *dentry, int datasync);
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
 		struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t default_file_splice_read(struct file *, loff_t *,
 		struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
 		struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
 		struct file *out, loff_t *, size_t len, unsigned int flags);
 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 		size_t len, unsigned int flags);
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
 			int origin);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 #ifdef CONFIG_FS_XIP
 extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
 			     loff_t *ppos);
 extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
 extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
 			      size_t len, loff_t *ppos);
 extern int xip_truncate_page(struct address_space *mapping, loff_t from);
 #else
 static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 {
 	return 0;
 }
 #endif
 #ifdef CONFIG_BLOCK
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 	struct block_device *bdev, const struct iovec *iov, loff_t offset,
 	unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 	int lock_type);
 enum {
 	/* need locking between buffered and direct access */
 	DIO_LOCKING	= 0x01,
 	/* filesystem does not support filling holes */
 	DIO_SKIP_HOLES	= 0x02,
 };
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				    nr_segs, get_block, end_io,
 				    DIO_LOCKING | DIO_SKIP_HOLES);
 }
 static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, 0);
 }
 #endif
 extern const struct file_operations generic_ro_fops;
 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
 extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
 extern void *page_follow_link_light(struct dentry *, struct nameidata *);
 extern void page_put_link(struct dentry *, struct nameidata *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
 		int nofs);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
 extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 void __inode_add_bytes(struct inode *inode, loff_t bytes);
 void inode_add_bytes(struct inode *inode, loff_t bytes);
 void inode_sub_bytes(struct inode *inode, loff_t bytes);
 loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
 extern int vfs_readdir(struct file *, filldir_t, void *);
 extern int vfs_stat(char __user *, struct kstat *);
 extern int vfs_lstat(char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
 extern int vfs_fstatat(int , char __user *, struct kstat *, int);
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
 		    unsigned long arg);
 extern int __generic_block_fiemap(struct inode *inode,
 				  struct fiemap_extent_info *fieinfo, u64 start,
 				  u64 len, get_block_t *get_block);
 extern int generic_block_fiemap(struct inode *inode,
 				struct fiemap_extent_info *fieinfo, u64 start,
 				u64 len, get_block_t *get_block);
 extern void get_filesystem(struct file_system_type *fs);
 extern void put_filesystem(struct file_system_type *fs);
 extern struct file_system_type *get_fs_type(const char *name);
 extern struct super_block *get_super(struct block_device *);
 extern struct super_block *get_active_super(struct block_device *bdev);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
 extern int dcache_readdir(struct file *, void *, filldir_t);
 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int simple_statfs(struct dentry *, struct kstatfs *);
 extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 extern int simple_sync_file(struct file *, struct dentry *, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
 extern int simple_write_begin(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned flags,
 			struct page **pagep, void **fsdata);
 extern int simple_write_end(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned copied,
 			struct page *page, void *fsdata);
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
 extern const struct file_operations simple_dir_operations;
 extern const struct inode_operations simple_dir_inode_operations;
 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
 extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
 extern void simple_release_fs(struct vfsmount **mount, int *count);
 extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
 			loff_t *ppos, const void *from, size_t available);
 extern int simple_fsync(struct file *, struct dentry *, int);
 #ifdef CONFIG_MIGRATION
 extern int buffer_migrate_page(struct address_space *,
 				struct page *, struct page *);
 #else
 #define buffer_migrate_page NULL
 #endif
 extern int inode_change_ok(const struct inode *, struct iattr *);
 extern int inode_newsize_ok(const struct inode *, loff_t offset);
 extern int __must_check inode_setattr(struct inode *, struct iattr *);
 extern void file_update_time(struct file *file);
 extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
 extern void save_mount_options(struct super_block *sb, char *options);
 extern void replace_mount_options(struct super_block *sb, char *options);
 static inline ino_t parent_ino(struct dentry *dentry)
 {
 	ino_t res;
 	spin_lock(&dentry->d_lock);
 	res = dentry->d_parent->d_inode->i_ino;
 	spin_unlock(&dentry->d_lock);
 	return res;
 }
 /* Transaction based IO helpers */
 /*
  * An argresp is stored in an allocated page and holds the
  * size of the argument or response, along with its content
  */
 struct simple_transaction_argresp {
 	ssize_t size;
 	char data[0];
 };
 #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
 char *simple_transaction_get(struct file *file, const char __user *buf,
 				size_t size);
 ssize_t simple_transaction_read(struct file *file, char __user *buf,
 				size_t size, loff_t *pos);
 int simple_transaction_release(struct inode *inode, struct file *file);
 void simple_transaction_set(struct file *file, size_t n);
 /*
  * simple attribute files
  *
  * These attributes behave similar to those in sysfs:
  *
  * Writing to an attribute immediately sets a value, an open file can be
  * written to multiple times.
  *
  * Reading from an attribute creates a buffer from the value that might get
  * read with multiple read calls. When the attribute has been read
  * completely, no further read calls are possible until the file is opened
  * again.
  *
  * All attributes contain a text representation of a numeric value
  * that are accessed with the get() and set() functions.
  */
 #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)		\
 static int __fops ## _open(struct inode *inode, struct file *file)	\
 {									\
 	__simple_attr_check_format(__fmt, 0ull);			\
 	return simple_attr_open(inode, file, __get, __set, __fmt);	\
 }									\
 static const struct file_operations __fops = {				\
 	.owner	 = THIS_MODULE,						\
 	.open	 = __fops ## _open,					\
 	.release = simple_attr_release,					\
 	.read	 = simple_attr_read,					\
 	.write	 = simple_attr_write,					\
 };
 static inline void __attribute__((format(printf, 1, 2)))
 __simple_attr_check_format(const char *fmt, ...)
 {
 	/* don't do anything, just let the compiler check the arguments; */
 }
 int simple_attr_open(struct inode *inode, struct file *file,
 		     int (*get)(void *, u64 *), int (*set)(void *, u64),
 		     const char *fmt);
 int simple_attr_release(struct inode *inode, struct file *file);
 ssize_t simple_attr_read(struct file *file, char __user *buf,
 			 size_t len, loff_t *ppos);
 ssize_t simple_attr_write(struct file *file, const char __user *buf,
 			  size_t len, loff_t *ppos);
 struct ctl_table;
 int proc_nr_files(struct ctl_table *table, int write,
 		  void __user *buffer, size_t *lenp, loff_t *ppos);
 int __init get_filesystem_list(char *buf);
 #define ACC_MODE(x) ("\004\002\006\006"[(x)&O_ACCMODE])
 #define OPEN_FMODE(flag) ((__force fmode_t)((flag + 1) & O_ACCMODE))
 #endif /* __KERNEL__ */

net/socket.c

Diff comments View file @ 989a297

1	/*	1	/*
2	* NET An implementation of the SOCKET network access protocol.	2	* NET An implementation of the SOCKET network access protocol.
3	*	3	*
4	* Version: @(#)socket.c 1.1.93 18/02/95	4	* Version: @(#)socket.c 1.1.93 18/02/95
5	*	5	*
6	* Authors: Orest Zborowski, <obz@Kodak.COM>	6	* Authors: Orest Zborowski, <obz@Kodak.COM>
7	* Ross Biro	7	* Ross Biro
8	* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>	8	* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
9	*	9	*
10	* Fixes:	10	* Fixes:
11	* Anonymous : NOTSOCK/BADF cleanup. Error fix in	11	* Anonymous : NOTSOCK/BADF cleanup. Error fix in
12	* shutdown()	12	* shutdown()
13	* Alan Cox : verify_area() fixes	13	* Alan Cox : verify_area() fixes
14	* Alan Cox : Removed DDI	14	* Alan Cox : Removed DDI
15	* Jonathan Kamens : SOCK_DGRAM reconnect bug	15	* Jonathan Kamens : SOCK_DGRAM reconnect bug
16	* Alan Cox : Moved a load of checks to the very	16	* Alan Cox : Moved a load of checks to the very
17	* top level.	17	* top level.
18	* Alan Cox : Move address structures to/from user	18	* Alan Cox : Move address structures to/from user
19	* mode above the protocol layers.	19	* mode above the protocol layers.
20	* Rob Janssen : Allow 0 length sends.	20	* Rob Janssen : Allow 0 length sends.
21	* Alan Cox : Asynchronous I/O support (cribbed from the	21	* Alan Cox : Asynchronous I/O support (cribbed from the
22	* tty drivers).	22	* tty drivers).
23	* Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style)	23	* Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style)
24	* Jeff Uphoff : Made max number of sockets command-line	24	* Jeff Uphoff : Made max number of sockets command-line
25	* configurable.	25	* configurable.
26	* Matti Aarnio : Made the number of sockets dynamic,	26	* Matti Aarnio : Made the number of sockets dynamic,
27	* to be allocated when needed, and mr.	27	* to be allocated when needed, and mr.
28	* Uphoff's max is used as max to be	28	* Uphoff's max is used as max to be
29	* allowed to allocate.	29	* allowed to allocate.
30	* Linus : Argh. removed all the socket allocation	30	* Linus : Argh. removed all the socket allocation
31	* altogether: it's in the inode now.	31	* altogether: it's in the inode now.
32	* Alan Cox : Made sock_alloc()/sock_release() public	32	* Alan Cox : Made sock_alloc()/sock_release() public
33	* for NetROM and future kernel nfsd type	33	* for NetROM and future kernel nfsd type
34	* stuff.	34	* stuff.
35	* Alan Cox : sendmsg/recvmsg basics.	35	* Alan Cox : sendmsg/recvmsg basics.
36	* Tom Dyas : Export net symbols.	36	* Tom Dyas : Export net symbols.
37	* Marcin Dalecki : Fixed problems with CONFIG_NET="n".	37	* Marcin Dalecki : Fixed problems with CONFIG_NET="n".
38	* Alan Cox : Added thread locking to sys_* calls	38	* Alan Cox : Added thread locking to sys_* calls
39	* for sockets. May have errors at the	39	* for sockets. May have errors at the
40	* moment.	40	* moment.
41	* Kevin Buhr : Fixed the dumb errors in the above.	41	* Kevin Buhr : Fixed the dumb errors in the above.
42	* Andi Kleen : Some small cleanups, optimizations,	42	* Andi Kleen : Some small cleanups, optimizations,
43	* and fixed a copy_from_user() bug.	43	* and fixed a copy_from_user() bug.
44	* Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0)	44	* Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0)
45	* Tigran Aivazian : Made listen(2) backlog sanity checks	45	* Tigran Aivazian : Made listen(2) backlog sanity checks
46	* protocol-independent	46	* protocol-independent
47	*	47	*
48	*	48	*
49	* This program is free software; you can redistribute it and/or	49	* This program is free software; you can redistribute it and/or
50	* modify it under the terms of the GNU General Public License	50	* modify it under the terms of the GNU General Public License
51	* as published by the Free Software Foundation; either version	51	* as published by the Free Software Foundation; either version
52	* 2 of the License, or (at your option) any later version.	52	* 2 of the License, or (at your option) any later version.
53	*	53	*
54	*	54	*
55	* This module is effectively the top level interface to the BSD socket	55	* This module is effectively the top level interface to the BSD socket
56	* paradigm.	56	* paradigm.
57	*	57	*
58	* Based upon Swansea University Computer Society NET3.039	58	* Based upon Swansea University Computer Society NET3.039
59	*/	59	*/
60		60
61	#include <linux/mm.h>	61	#include <linux/mm.h>
62	#include <linux/socket.h>	62	#include <linux/socket.h>
63	#include <linux/file.h>	63	#include <linux/file.h>
64	#include <linux/net.h>	64	#include <linux/net.h>
65	#include <linux/interrupt.h>	65	#include <linux/interrupt.h>
66	#include <linux/thread_info.h>	66	#include <linux/thread_info.h>
67	#include <linux/rcupdate.h>	67	#include <linux/rcupdate.h>
68	#include <linux/netdevice.h>	68	#include <linux/netdevice.h>
69	#include <linux/proc_fs.h>	69	#include <linux/proc_fs.h>
70	#include <linux/seq_file.h>	70	#include <linux/seq_file.h>
71	#include <linux/mutex.h>	71	#include <linux/mutex.h>
72	#include <linux/wanrouter.h>	72	#include <linux/wanrouter.h>
73	#include <linux/if_bridge.h>	73	#include <linux/if_bridge.h>
74	#include <linux/if_frad.h>	74	#include <linux/if_frad.h>
75	#include <linux/if_vlan.h>	75	#include <linux/if_vlan.h>
76	#include <linux/init.h>	76	#include <linux/init.h>
77	#include <linux/poll.h>	77	#include <linux/poll.h>
78	#include <linux/cache.h>	78	#include <linux/cache.h>
79	#include <linux/module.h>	79	#include <linux/module.h>
80	#include <linux/highmem.h>	80	#include <linux/highmem.h>
81	#include <linux/mount.h>	81	#include <linux/mount.h>
82	#include <linux/security.h>	82	#include <linux/security.h>
83	#include <linux/syscalls.h>	83	#include <linux/syscalls.h>
84	#include <linux/compat.h>	84	#include <linux/compat.h>
85	#include <linux/kmod.h>	85	#include <linux/kmod.h>
86	#include <linux/audit.h>	86	#include <linux/audit.h>
87	#include <linux/wireless.h>	87	#include <linux/wireless.h>
88	#include <linux/nsproxy.h>	88	#include <linux/nsproxy.h>
89	#include <linux/magic.h>	89	#include <linux/magic.h>
90	#include <linux/slab.h>	90	#include <linux/slab.h>
91		91
92	#include <asm/uaccess.h>	92	#include <asm/uaccess.h>
93	#include <asm/unistd.h>	93	#include <asm/unistd.h>
94		94
95	#include <net/compat.h>	95	#include <net/compat.h>
96	#include <net/wext.h>	96	#include <net/wext.h>
97		97
98	#include <net/sock.h>	98	#include <net/sock.h>
99	#include <linux/netfilter.h>	99	#include <linux/netfilter.h>
100		100
101	#include <linux/if_tun.h>	101	#include <linux/if_tun.h>
102	#include <linux/ipv6_route.h>	102	#include <linux/ipv6_route.h>
103	#include <linux/route.h>	103	#include <linux/route.h>
104	#include <linux/sockios.h>	104	#include <linux/sockios.h>
105	#include <linux/atalk.h>	105	#include <linux/atalk.h>
106		106
107	static int sock_no_open(struct inode irrelevant, struct file dontcare);	107	static int sock_no_open(struct inode irrelevant, struct file dontcare);
108	static ssize_t sock_aio_read(struct kiocb iocb, const struct iovec iov,	108	static ssize_t sock_aio_read(struct kiocb iocb, const struct iovec iov,
109	unsigned long nr_segs, loff_t pos);	109	unsigned long nr_segs, loff_t pos);
110	static ssize_t sock_aio_write(struct kiocb iocb, const struct iovec iov,	110	static ssize_t sock_aio_write(struct kiocb iocb, const struct iovec iov,
111	unsigned long nr_segs, loff_t pos);	111	unsigned long nr_segs, loff_t pos);
112	static int sock_mmap(struct file file, struct vm_area_struct vma);	112	static int sock_mmap(struct file file, struct vm_area_struct vma);
113		113
114	static int sock_close(struct inode inode, struct file file);	114	static int sock_close(struct inode inode, struct file file);
115	static unsigned int sock_poll(struct file *file,	115	static unsigned int sock_poll(struct file *file,
116	struct poll_table_struct *wait);	116	struct poll_table_struct *wait);
117	static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);	117	static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
118	#ifdef CONFIG_COMPAT	118	#ifdef CONFIG_COMPAT
119	static long compat_sock_ioctl(struct file *file,	119	static long compat_sock_ioctl(struct file *file,
120	unsigned int cmd, unsigned long arg);	120	unsigned int cmd, unsigned long arg);
121	#endif	121	#endif
122	static int sock_fasync(int fd, struct file *filp, int on);	122	static int sock_fasync(int fd, struct file *filp, int on);
123	static ssize_t sock_sendpage(struct file file, struct page page,	123	static ssize_t sock_sendpage(struct file file, struct page page,
124	int offset, size_t size, loff_t *ppos, int more);	124	int offset, size_t size, loff_t *ppos, int more);
125	static ssize_t sock_splice_read(struct file file, loff_t ppos,	125	static ssize_t sock_splice_read(struct file file, loff_t ppos,
126	struct pipe_inode_info *pipe, size_t len,	126	struct pipe_inode_info *pipe, size_t len,
127	unsigned int flags);	127	unsigned int flags);
128		128
129	/*	129	/*
130	* Socket files have a set of 'special' operations as well as the generic file ones. These don't appear	130	* Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
131	* in the operation structures but are done directly via the socketcall() multiplexor.	131	* in the operation structures but are done directly via the socketcall() multiplexor.
132	*/	132	*/
133		133
134	static const struct file_operations socket_file_ops = {	134	static const struct file_operations socket_file_ops = {
135	.owner = THIS_MODULE,	135	.owner = THIS_MODULE,
136	.llseek = no_llseek,	136	.llseek = no_llseek,
137	.aio_read = sock_aio_read,	137	.aio_read = sock_aio_read,
138	.aio_write = sock_aio_write,	138	.aio_write = sock_aio_write,
139	.poll = sock_poll,	139	.poll = sock_poll,
140	.unlocked_ioctl = sock_ioctl,	140	.unlocked_ioctl = sock_ioctl,
141	#ifdef CONFIG_COMPAT	141	#ifdef CONFIG_COMPAT
142	.compat_ioctl = compat_sock_ioctl,	142	.compat_ioctl = compat_sock_ioctl,
143	#endif	143	#endif
144	.mmap = sock_mmap,	144	.mmap = sock_mmap,
145	.open = sock_no_open, /* special open code to disallow open via /proc */	145	.open = sock_no_open, /* special open code to disallow open via /proc */
146	.release = sock_close,	146	.release = sock_close,
147	.fasync = sock_fasync,	147	.fasync = sock_fasync,
148	.sendpage = sock_sendpage,	148	.sendpage = sock_sendpage,
149	.splice_write = generic_splice_sendpage,	149	.splice_write = generic_splice_sendpage,
150	.splice_read = sock_splice_read,	150	.splice_read = sock_splice_read,
151	};	151	};
152		152
153	/*	153	/*
154	* The protocol list. Each protocol is registered in here.	154	* The protocol list. Each protocol is registered in here.
155	*/	155	*/
156		156
157	static DEFINE_SPINLOCK(net_family_lock);	157	static DEFINE_SPINLOCK(net_family_lock);
158	static const struct net_proto_family *net_families[NPROTO] __read_mostly;	158	static const struct net_proto_family *net_families[NPROTO] __read_mostly;
159		159
160	/*	160	/*
161	* Statistics counters of the socket lists	161	* Statistics counters of the socket lists
162	*/	162	*/
163		163
164	static DEFINE_PER_CPU(int, sockets_in_use) = 0;	164	static DEFINE_PER_CPU(int, sockets_in_use) = 0;
165		165
166	/*	166	/*
167	* Support routines.	167	* Support routines.
168	* Move socket addresses back and forth across the kernel/user	168	* Move socket addresses back and forth across the kernel/user
169	* divide and look after the messy bits.	169	* divide and look after the messy bits.
170	*/	170	*/
171		171
172	#define MAX_SOCK_ADDR 128 /* 108 for Unix domain -	172	#define MAX_SOCK_ADDR 128 /* 108 for Unix domain -
173	16 for IP, 16 for IPX,	173	16 for IP, 16 for IPX,
174	24 for IPv6,	174	24 for IPv6,
175	about 80 for AX.25	175	about 80 for AX.25
176	must be at least one bigger than	176	must be at least one bigger than
177	the AF_UNIX size (see net/unix/af_unix.c	177	the AF_UNIX size (see net/unix/af_unix.c
178	:unix_mkname()).	178	:unix_mkname()).
179	*/	179	*/
180		180
181	/**	181	/**
182	* move_addr_to_kernel - copy a socket address into kernel space	182	* move_addr_to_kernel - copy a socket address into kernel space
183	* @uaddr: Address in user space	183	* @uaddr: Address in user space
184	* @kaddr: Address in kernel space	184	* @kaddr: Address in kernel space
185	* @ulen: Length in user space	185	* @ulen: Length in user space
186	*	186	*
187	* The address is copied into kernel space. If the provided address is	187	* The address is copied into kernel space. If the provided address is
188	* too long an error code of -EINVAL is returned. If the copy gives	188	* too long an error code of -EINVAL is returned. If the copy gives
189	* invalid addresses -EFAULT is returned. On a success 0 is returned.	189	* invalid addresses -EFAULT is returned. On a success 0 is returned.
190	*/	190	*/
191		191
192	int move_addr_to_kernel(void __user uaddr, int ulen, struct sockaddr kaddr)	192	int move_addr_to_kernel(void __user uaddr, int ulen, struct sockaddr kaddr)
193	{	193	{
194	if (ulen < 0 \|\| ulen > sizeof(struct sockaddr_storage))	194	if (ulen < 0 \|\| ulen > sizeof(struct sockaddr_storage))
195	return -EINVAL;	195	return -EINVAL;
196	if (ulen == 0)	196	if (ulen == 0)
197	return 0;	197	return 0;
198	if (copy_from_user(kaddr, uaddr, ulen))	198	if (copy_from_user(kaddr, uaddr, ulen))
199	return -EFAULT;	199	return -EFAULT;
200	return audit_sockaddr(ulen, kaddr);	200	return audit_sockaddr(ulen, kaddr);
201	}	201	}
202		202
203	/**	203	/**
204	* move_addr_to_user - copy an address to user space	204	* move_addr_to_user - copy an address to user space
205	* @kaddr: kernel space address	205	* @kaddr: kernel space address
206	* @klen: length of address in kernel	206	* @klen: length of address in kernel
207	* @uaddr: user space address	207	* @uaddr: user space address
208	* @ulen: pointer to user length field	208	* @ulen: pointer to user length field
209	*	209	*
210	* The value pointed to by ulen on entry is the buffer length available.	210	* The value pointed to by ulen on entry is the buffer length available.
211	* This is overwritten with the buffer space used. -EINVAL is returned	211	* This is overwritten with the buffer space used. -EINVAL is returned
212	* if an overlong buffer is specified or a negative buffer size. -EFAULT	212	* if an overlong buffer is specified or a negative buffer size. -EFAULT
213	* is returned if either the buffer or the length field are not	213	* is returned if either the buffer or the length field are not
214	* accessible.	214	* accessible.
215	* After copying the data up to the limit the user specifies, the true	215	* After copying the data up to the limit the user specifies, the true
216	* length of the data is written over the length limit the user	216	* length of the data is written over the length limit the user
217	* specified. Zero is returned for a success.	217	* specified. Zero is returned for a success.
218	*/	218	*/
219		219
220	int move_addr_to_user(struct sockaddr kaddr, int klen, void __user uaddr,	220	int move_addr_to_user(struct sockaddr kaddr, int klen, void __user uaddr,
221	int __user *ulen)	221	int __user *ulen)
222	{	222	{
223	int err;	223	int err;
224	int len;	224	int len;
225		225
226	err = get_user(len, ulen);	226	err = get_user(len, ulen);
227	if (err)	227	if (err)
228	return err;	228	return err;
229	if (len > klen)	229	if (len > klen)
230	len = klen;	230	len = klen;
231	if (len < 0 \|\| len > sizeof(struct sockaddr_storage))	231	if (len < 0 \|\| len > sizeof(struct sockaddr_storage))
232	return -EINVAL;	232	return -EINVAL;
233	if (len) {	233	if (len) {
234	if (audit_sockaddr(klen, kaddr))	234	if (audit_sockaddr(klen, kaddr))
235	return -ENOMEM;	235	return -ENOMEM;
236	if (copy_to_user(uaddr, kaddr, len))	236	if (copy_to_user(uaddr, kaddr, len))
237	return -EFAULT;	237	return -EFAULT;
238	}	238	}
239	/*	239	/*
240	* "fromlen shall refer to the value before truncation.."	240	* "fromlen shall refer to the value before truncation.."
241	* 1003.1g	241	* 1003.1g
242	*/	242	*/
243	return __put_user(klen, ulen);	243	return __put_user(klen, ulen);
244	}	244	}
245		245
246	static struct kmem_cache *sock_inode_cachep __read_mostly;	246	static struct kmem_cache *sock_inode_cachep __read_mostly;
247		247
248	static struct inode sock_alloc_inode(struct super_block sb)	248	static struct inode sock_alloc_inode(struct super_block sb)
249	{	249	{
250	struct socket_alloc *ei;	250	struct socket_alloc *ei;
251		251
252	ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);	252	ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
253	if (!ei)	253	if (!ei)
254	return NULL;	254	return NULL;
255	init_waitqueue_head(&ei->socket.wait);	255	init_waitqueue_head(&ei->socket.wait);
256		256
257	ei->socket.fasync_list = NULL;	257	ei->socket.fasync_list = NULL;
258	ei->socket.state = SS_UNCONNECTED;	258	ei->socket.state = SS_UNCONNECTED;
259	ei->socket.flags = 0;	259	ei->socket.flags = 0;
260	ei->socket.ops = NULL;	260	ei->socket.ops = NULL;
261	ei->socket.sk = NULL;	261	ei->socket.sk = NULL;
262	ei->socket.file = NULL;	262	ei->socket.file = NULL;
263		263
264	return &ei->vfs_inode;	264	return &ei->vfs_inode;
265	}	265	}
266		266
267	static void sock_destroy_inode(struct inode *inode)	267	static void sock_destroy_inode(struct inode *inode)
268	{	268	{
269	kmem_cache_free(sock_inode_cachep,	269	kmem_cache_free(sock_inode_cachep,
270	container_of(inode, struct socket_alloc, vfs_inode));	270	container_of(inode, struct socket_alloc, vfs_inode));
271	}	271	}
272		272
273	static void init_once(void *foo)	273	static void init_once(void *foo)
274	{	274	{
275	struct socket_alloc ei = (struct socket_alloc )foo;	275	struct socket_alloc ei = (struct socket_alloc )foo;
276		276
277	inode_init_once(&ei->vfs_inode);	277	inode_init_once(&ei->vfs_inode);
278	}	278	}
279		279
280	static int init_inodecache(void)	280	static int init_inodecache(void)
281	{	281	{
282	sock_inode_cachep = kmem_cache_create("sock_inode_cache",	282	sock_inode_cachep = kmem_cache_create("sock_inode_cache",
283	sizeof(struct socket_alloc),	283	sizeof(struct socket_alloc),
284	0,	284	0,
285	(SLAB_HWCACHE_ALIGN \|	285	(SLAB_HWCACHE_ALIGN \|
286	SLAB_RECLAIM_ACCOUNT \|	286	SLAB_RECLAIM_ACCOUNT \|
287	SLAB_MEM_SPREAD),	287	SLAB_MEM_SPREAD),
288	init_once);	288	init_once);
289	if (sock_inode_cachep == NULL)	289	if (sock_inode_cachep == NULL)
290	return -ENOMEM;	290	return -ENOMEM;
291	return 0;	291	return 0;
292	}	292	}
293		293
294	static const struct super_operations sockfs_ops = {	294	static const struct super_operations sockfs_ops = {
295	.alloc_inode = sock_alloc_inode,	295	.alloc_inode = sock_alloc_inode,
296	.destroy_inode =sock_destroy_inode,	296	.destroy_inode =sock_destroy_inode,
297	.statfs = simple_statfs,	297	.statfs = simple_statfs,
298	};	298	};
299		299
300	static int sockfs_get_sb(struct file_system_type *fs_type,	300	static int sockfs_get_sb(struct file_system_type *fs_type,
301	int flags, const char dev_name, void data,	301	int flags, const char dev_name, void data,
302	struct vfsmount *mnt)	302	struct vfsmount *mnt)
303	{	303	{
304	return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,	304	return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,
305	mnt);	305	mnt);
306	}	306	}
307		307
308	static struct vfsmount *sock_mnt __read_mostly;	308	static struct vfsmount *sock_mnt __read_mostly;
309		309
310	static struct file_system_type sock_fs_type = {	310	static struct file_system_type sock_fs_type = {
311	.name = "sockfs",	311	.name = "sockfs",
312	.get_sb = sockfs_get_sb,	312	.get_sb = sockfs_get_sb,
313	.kill_sb = kill_anon_super,	313	.kill_sb = kill_anon_super,
314	};	314	};
315		315
316	/*	316	/*
317	* sockfs_dname() is called from d_path().	317	* sockfs_dname() is called from d_path().
318	*/	318	*/
319	static char sockfs_dname(struct dentry dentry, char *buffer, int buflen)	319	static char sockfs_dname(struct dentry dentry, char *buffer, int buflen)
320	{	320	{
321	return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",	321	return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
322	dentry->d_inode->i_ino);	322	dentry->d_inode->i_ino);
323	}	323	}
324		324
325	static const struct dentry_operations sockfs_dentry_operations = {	325	static const struct dentry_operations sockfs_dentry_operations = {
326	.d_dname = sockfs_dname,	326	.d_dname = sockfs_dname,
327	};	327	};
328		328
329	/*	329	/*
330	* Obtains the first available file descriptor and sets it up for use.	330	* Obtains the first available file descriptor and sets it up for use.
331	*	331	*
332	* These functions create file structures and maps them to fd space	332	* These functions create file structures and maps them to fd space
333	* of the current process. On success it returns file descriptor	333	* of the current process. On success it returns file descriptor
334	* and file struct implicitly stored in sock->file.	334	* and file struct implicitly stored in sock->file.
335	* Note that another thread may close file descriptor before we return	335	* Note that another thread may close file descriptor before we return
336	* from this function. We use the fact that now we do not refer	336	* from this function. We use the fact that now we do not refer
337	* to socket after mapping. If one day we will need it, this	337	* to socket after mapping. If one day we will need it, this
338	* function will increment ref. count on file by 1.	338	* function will increment ref. count on file by 1.
339	*	339	*
340	* In any case returned fd MAY BE not valid!	340	* In any case returned fd MAY BE not valid!
341	* This race condition is unavoidable	341	* This race condition is unavoidable
342	* with shared fd spaces, we cannot solve it inside kernel,	342	* with shared fd spaces, we cannot solve it inside kernel,
343	* but we take care of internal coherence yet.	343	* but we take care of internal coherence yet.
344	*/	344	*/
345		345
346	static int sock_alloc_file(struct socket sock, struct file *f, int flags)	346	static int sock_alloc_file(struct socket sock, struct file *f, int flags)
347	{	347	{
348	struct qstr name = { .name = "" };	348	struct qstr name = { .name = "" };
349	struct path path;	349	struct path path;
350	struct file *file;	350	struct file *file;
351	int fd;	351	int fd;
352		352
353	fd = get_unused_fd_flags(flags);	353	fd = get_unused_fd_flags(flags);
354	if (unlikely(fd < 0))	354	if (unlikely(fd < 0))
355	return fd;	355	return fd;
356		356
357	path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);	357	path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
358	if (unlikely(!path.dentry)) {	358	if (unlikely(!path.dentry)) {
359	put_unused_fd(fd);	359	put_unused_fd(fd);
360	return -ENOMEM;	360	return -ENOMEM;
361	}	361	}
362	path.mnt = mntget(sock_mnt);	362	path.mnt = mntget(sock_mnt);
363		363
364	path.dentry->d_op = &sockfs_dentry_operations;	364	path.dentry->d_op = &sockfs_dentry_operations;
365	d_instantiate(path.dentry, SOCK_INODE(sock));	365	d_instantiate(path.dentry, SOCK_INODE(sock));
366	SOCK_INODE(sock)->i_fop = &socket_file_ops;	366	SOCK_INODE(sock)->i_fop = &socket_file_ops;
367		367
368	file = alloc_file(&path, FMODE_READ \| FMODE_WRITE,	368	file = alloc_file(&path, FMODE_READ \| FMODE_WRITE,
369	&socket_file_ops);	369	&socket_file_ops);
370	if (unlikely(!file)) {	370	if (unlikely(!file)) {
371	/* drop dentry, keep inode */	371	/* drop dentry, keep inode */
372	atomic_inc(&path.dentry->d_inode->i_count);	372	atomic_inc(&path.dentry->d_inode->i_count);
373	path_put(&path);	373	path_put(&path);
374	put_unused_fd(fd);	374	put_unused_fd(fd);
375	return -ENFILE;	375	return -ENFILE;
376	}	376	}
377		377
378	sock->file = file;	378	sock->file = file;
379	file->f_flags = O_RDWR \| (flags & O_NONBLOCK);	379	file->f_flags = O_RDWR \| (flags & O_NONBLOCK);
380	file->f_pos = 0;	380	file->f_pos = 0;
381	file->private_data = sock;	381	file->private_data = sock;
382		382
383	*f = file;	383	*f = file;
384	return fd;	384	return fd;
385	}	385	}
386		386
387	int sock_map_fd(struct socket *sock, int flags)	387	int sock_map_fd(struct socket *sock, int flags)
388	{	388	{
389	struct file *newfile;	389	struct file *newfile;
390	int fd = sock_alloc_file(sock, &newfile, flags);	390	int fd = sock_alloc_file(sock, &newfile, flags);
391		391
392	if (likely(fd >= 0))	392	if (likely(fd >= 0))
393	fd_install(fd, newfile);	393	fd_install(fd, newfile);
394		394
395	return fd;	395	return fd;
396	}	396	}
397		397
398	static struct socket sock_from_file(struct file file, int *err)	398	static struct socket sock_from_file(struct file file, int *err)
399	{	399	{
400	if (file->f_op == &socket_file_ops)	400	if (file->f_op == &socket_file_ops)
401	return file->private_data; /* set in sock_map_fd */	401	return file->private_data; /* set in sock_map_fd */
402		402
403	*err = -ENOTSOCK;	403	*err = -ENOTSOCK;
404	return NULL;	404	return NULL;
405	}	405	}
406		406
407	/**	407	/**
408	* sockfd_lookup - Go from a file number to its socket slot	408	* sockfd_lookup - Go from a file number to its socket slot
409	* @fd: file handle	409	* @fd: file handle
410	* @err: pointer to an error code return	410	* @err: pointer to an error code return
411	*	411	*
412	* The file handle passed in is locked and the socket it is bound	412	* The file handle passed in is locked and the socket it is bound
413	* too is returned. If an error occurs the err pointer is overwritten	413	* too is returned. If an error occurs the err pointer is overwritten
414	* with a negative errno code and NULL is returned. The function checks	414	* with a negative errno code and NULL is returned. The function checks
415	* for both invalid handles and passing a handle which is not a socket.	415	* for both invalid handles and passing a handle which is not a socket.
416	*	416	*
417	* On a success the socket object pointer is returned.	417	* On a success the socket object pointer is returned.
418	*/	418	*/
419		419
420	struct socket sockfd_lookup(int fd, int err)	420	struct socket sockfd_lookup(int fd, int err)
421	{	421	{
422	struct file *file;	422	struct file *file;
423	struct socket *sock;	423	struct socket *sock;
424		424
425	file = fget(fd);	425	file = fget(fd);
426	if (!file) {	426	if (!file) {
427	*err = -EBADF;	427	*err = -EBADF;
428	return NULL;	428	return NULL;
429	}	429	}
430		430
431	sock = sock_from_file(file, err);	431	sock = sock_from_file(file, err);
432	if (!sock)	432	if (!sock)
433	fput(file);	433	fput(file);
434	return sock;	434	return sock;
435	}	435	}
436		436
437	static struct socket sockfd_lookup_light(int fd, int err, int *fput_needed)	437	static struct socket sockfd_lookup_light(int fd, int err, int *fput_needed)
438	{	438	{
439	struct file *file;	439	struct file *file;
440	struct socket *sock;	440	struct socket *sock;
441		441
442	*err = -EBADF;	442	*err = -EBADF;
443	file = fget_light(fd, fput_needed);	443	file = fget_light(fd, fput_needed);
444	if (file) {	444	if (file) {
445	sock = sock_from_file(file, err);	445	sock = sock_from_file(file, err);
446	if (sock)	446	if (sock)
447	return sock;	447	return sock;
448	fput_light(file, *fput_needed);	448	fput_light(file, *fput_needed);
449	}	449	}
450	return NULL;	450	return NULL;
451	}	451	}
452		452
453	/**	453	/**
454	* sock_alloc - allocate a socket	454	* sock_alloc - allocate a socket
455	*	455	*
456	* Allocate a new inode and socket object. The two are bound together	456	* Allocate a new inode and socket object. The two are bound together
457	* and initialised. The socket is then returned. If we are out of inodes	457	* and initialised. The socket is then returned. If we are out of inodes
458	* NULL is returned.	458	* NULL is returned.
459	*/	459	*/
460		460
461	static struct socket *sock_alloc(void)	461	static struct socket *sock_alloc(void)
462	{	462	{
463	struct inode *inode;	463	struct inode *inode;
464	struct socket *sock;	464	struct socket *sock;
465		465
466	inode = new_inode(sock_mnt->mnt_sb);	466	inode = new_inode(sock_mnt->mnt_sb);
467	if (!inode)	467	if (!inode)
468	return NULL;	468	return NULL;
469		469
470	sock = SOCKET_I(inode);	470	sock = SOCKET_I(inode);
471		471
472	kmemcheck_annotate_bitfield(sock, type);	472	kmemcheck_annotate_bitfield(sock, type);
473	inode->i_mode = S_IFSOCK \| S_IRWXUGO;	473	inode->i_mode = S_IFSOCK \| S_IRWXUGO;
474	inode->i_uid = current_fsuid();	474	inode->i_uid = current_fsuid();
475	inode->i_gid = current_fsgid();	475	inode->i_gid = current_fsgid();
476		476
477	percpu_add(sockets_in_use, 1);	477	percpu_add(sockets_in_use, 1);
478	return sock;	478	return sock;
479	}	479	}
480		480
481	/*	481	/*
482	* In theory you can't get an open on this inode, but /proc provides	482	* In theory you can't get an open on this inode, but /proc provides
483	* a back door. Remember to keep it shut otherwise you'll let the	483	* a back door. Remember to keep it shut otherwise you'll let the
484	* creepy crawlies in.	484	* creepy crawlies in.
485	*/	485	*/
486		486
487	static int sock_no_open(struct inode irrelevant, struct file dontcare)	487	static int sock_no_open(struct inode irrelevant, struct file dontcare)
488	{	488	{
489	return -ENXIO;	489	return -ENXIO;
490	}	490	}
491		491
492	const struct file_operations bad_sock_fops = {	492	const struct file_operations bad_sock_fops = {
493	.owner = THIS_MODULE,	493	.owner = THIS_MODULE,
494	.open = sock_no_open,	494	.open = sock_no_open,
495	};	495	};
496		496
497	/**	497	/**
498	* sock_release - close a socket	498	* sock_release - close a socket
499	* @sock: socket to close	499	* @sock: socket to close
500	*	500	*
501	* The socket is released from the protocol stack if it has a release	501	* The socket is released from the protocol stack if it has a release
502	* callback, and the inode is then released if the socket is bound to	502	* callback, and the inode is then released if the socket is bound to
503	* an inode not a file.	503	* an inode not a file.
504	*/	504	*/
505		505
506	void sock_release(struct socket *sock)	506	void sock_release(struct socket *sock)
507	{	507	{
508	if (sock->ops) {	508	if (sock->ops) {
509	struct module *owner = sock->ops->owner;	509	struct module *owner = sock->ops->owner;
510		510
511	sock->ops->release(sock);	511	sock->ops->release(sock);
512	sock->ops = NULL;	512	sock->ops = NULL;
513	module_put(owner);	513	module_put(owner);
514	}	514	}
515		515
516	if (sock->fasync_list)	516	if (sock->fasync_list)
517	printk(KERN_ERR "sock_release: fasync list not empty!\n");	517	printk(KERN_ERR "sock_release: fasync list not empty!\n");
518		518
519	percpu_sub(sockets_in_use, 1);	519	percpu_sub(sockets_in_use, 1);
520	if (!sock->file) {	520	if (!sock->file) {
521	iput(SOCK_INODE(sock));	521	iput(SOCK_INODE(sock));
522	return;	522	return;
523	}	523	}
524	sock->file = NULL;	524	sock->file = NULL;
525	}	525	}
526		526
527	int sock_tx_timestamp(struct msghdr msg, struct sock sk,	527	int sock_tx_timestamp(struct msghdr msg, struct sock sk,
528	union skb_shared_tx *shtx)	528	union skb_shared_tx *shtx)
529	{	529	{
530	shtx->flags = 0;	530	shtx->flags = 0;
531	if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))	531	if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
532	shtx->hardware = 1;	532	shtx->hardware = 1;
533	if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))	533	if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
534	shtx->software = 1;	534	shtx->software = 1;
535	return 0;	535	return 0;
536	}	536	}
537	EXPORT_SYMBOL(sock_tx_timestamp);	537	EXPORT_SYMBOL(sock_tx_timestamp);
538		538
539	static inline int __sock_sendmsg(struct kiocb iocb, struct socket sock,	539	static inline int __sock_sendmsg(struct kiocb iocb, struct socket sock,
540	struct msghdr *msg, size_t size)	540	struct msghdr *msg, size_t size)
541	{	541	{
542	struct sock_iocb *si = kiocb_to_siocb(iocb);	542	struct sock_iocb *si = kiocb_to_siocb(iocb);
543	int err;	543	int err;
544		544
545	si->sock = sock;	545	si->sock = sock;
546	si->scm = NULL;	546	si->scm = NULL;
547	si->msg = msg;	547	si->msg = msg;
548	si->size = size;	548	si->size = size;
549		549
550	err = security_socket_sendmsg(sock, msg, size);	550	err = security_socket_sendmsg(sock, msg, size);
551	if (err)	551	if (err)
552	return err;	552	return err;
553		553
554	return sock->ops->sendmsg(iocb, sock, msg, size);	554	return sock->ops->sendmsg(iocb, sock, msg, size);
555	}	555	}
556		556
557	int sock_sendmsg(struct socket sock, struct msghdr msg, size_t size)	557	int sock_sendmsg(struct socket sock, struct msghdr msg, size_t size)
558	{	558	{
559	struct kiocb iocb;	559	struct kiocb iocb;
560	struct sock_iocb siocb;	560	struct sock_iocb siocb;
561	int ret;	561	int ret;
562		562
563	init_sync_kiocb(&iocb, NULL);	563	init_sync_kiocb(&iocb, NULL);
564	iocb.private = &siocb;	564	iocb.private = &siocb;
565	ret = __sock_sendmsg(&iocb, sock, msg, size);	565	ret = __sock_sendmsg(&iocb, sock, msg, size);
566	if (-EIOCBQUEUED == ret)	566	if (-EIOCBQUEUED == ret)
567	ret = wait_on_sync_kiocb(&iocb);	567	ret = wait_on_sync_kiocb(&iocb);
568	return ret;	568	return ret;
569	}	569	}
570		570
571	int kernel_sendmsg(struct socket sock, struct msghdr msg,	571	int kernel_sendmsg(struct socket sock, struct msghdr msg,
572	struct kvec *vec, size_t num, size_t size)	572	struct kvec *vec, size_t num, size_t size)
573	{	573	{
574	mm_segment_t oldfs = get_fs();	574	mm_segment_t oldfs = get_fs();
575	int result;	575	int result;
576		576
577	set_fs(KERNEL_DS);	577	set_fs(KERNEL_DS);
578	/*	578	/*
579	* the following is safe, since for compiler definitions of kvec and	579	* the following is safe, since for compiler definitions of kvec and
580	* iovec are identical, yielding the same in-core layout and alignment	580	* iovec are identical, yielding the same in-core layout and alignment
581	*/	581	*/
582	msg->msg_iov = (struct iovec *)vec;	582	msg->msg_iov = (struct iovec *)vec;
583	msg->msg_iovlen = num;	583	msg->msg_iovlen = num;
584	result = sock_sendmsg(sock, msg, size);	584	result = sock_sendmsg(sock, msg, size);
585	set_fs(oldfs);	585	set_fs(oldfs);
586	return result;	586	return result;
587	}	587	}
588		588
589	static int ktime2ts(ktime_t kt, struct timespec *ts)	589	static int ktime2ts(ktime_t kt, struct timespec *ts)
590	{	590	{
591	if (kt.tv64) {	591	if (kt.tv64) {
592	*ts = ktime_to_timespec(kt);	592	*ts = ktime_to_timespec(kt);
593	return 1;	593	return 1;
594	} else {	594	} else {
595	return 0;	595	return 0;
596	}	596	}
597	}	597	}
598		598
599	/*	599	/*
600	* called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)	600	* called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
601	*/	601	*/
602	void __sock_recv_timestamp(struct msghdr msg, struct sock sk,	602	void __sock_recv_timestamp(struct msghdr msg, struct sock sk,
603	struct sk_buff *skb)	603	struct sk_buff *skb)
604	{	604	{
605	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);	605	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
606	struct timespec ts[3];	606	struct timespec ts[3];
607	int empty = 1;	607	int empty = 1;
608	struct skb_shared_hwtstamps *shhwtstamps =	608	struct skb_shared_hwtstamps *shhwtstamps =
609	skb_hwtstamps(skb);	609	skb_hwtstamps(skb);
610		610
611	/* Race occurred between timestamp enabling and packet	611	/* Race occurred between timestamp enabling and packet
612	receiving. Fill in the current time for now. */	612	receiving. Fill in the current time for now. */
613	if (need_software_tstamp && skb->tstamp.tv64 == 0)	613	if (need_software_tstamp && skb->tstamp.tv64 == 0)
614	__net_timestamp(skb);	614	__net_timestamp(skb);
615		615
616	if (need_software_tstamp) {	616	if (need_software_tstamp) {
617	if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {	617	if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
618	struct timeval tv;	618	struct timeval tv;
619	skb_get_timestamp(skb, &tv);	619	skb_get_timestamp(skb, &tv);
620	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,	620	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
621	sizeof(tv), &tv);	621	sizeof(tv), &tv);
622	} else {	622	} else {
623	skb_get_timestampns(skb, &ts[0]);	623	skb_get_timestampns(skb, &ts[0]);
624	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,	624	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
625	sizeof(ts[0]), &ts[0]);	625	sizeof(ts[0]), &ts[0]);
626	}	626	}
627	}	627	}
628		628
629		629
630	memset(ts, 0, sizeof(ts));	630	memset(ts, 0, sizeof(ts));
631	if (skb->tstamp.tv64 &&	631	if (skb->tstamp.tv64 &&
632	sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) {	632	sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) {
633	skb_get_timestampns(skb, ts + 0);	633	skb_get_timestampns(skb, ts + 0);
634	empty = 0;	634	empty = 0;
635	}	635	}
636	if (shhwtstamps) {	636	if (shhwtstamps) {
637	if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) &&	637	if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) &&
638	ktime2ts(shhwtstamps->syststamp, ts + 1))	638	ktime2ts(shhwtstamps->syststamp, ts + 1))
639	empty = 0;	639	empty = 0;
640	if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) &&	640	if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) &&
641	ktime2ts(shhwtstamps->hwtstamp, ts + 2))	641	ktime2ts(shhwtstamps->hwtstamp, ts + 2))
642	empty = 0;	642	empty = 0;
643	}	643	}
644	if (!empty)	644	if (!empty)
645	put_cmsg(msg, SOL_SOCKET,	645	put_cmsg(msg, SOL_SOCKET,
646	SCM_TIMESTAMPING, sizeof(ts), &ts);	646	SCM_TIMESTAMPING, sizeof(ts), &ts);
647	}	647	}
648		648
649	EXPORT_SYMBOL_GPL(__sock_recv_timestamp);	649	EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
650		650
651	inline void sock_recv_drops(struct msghdr msg, struct sock sk, struct sk_buff *skb)	651	inline void sock_recv_drops(struct msghdr msg, struct sock sk, struct sk_buff *skb)
652	{	652	{
653	if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)	653	if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)
654	put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,	654	put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
655	sizeof(__u32), &skb->dropcount);	655	sizeof(__u32), &skb->dropcount);
656	}	656	}
657		657
658	void sock_recv_ts_and_drops(struct msghdr msg, struct sock sk,	658	void sock_recv_ts_and_drops(struct msghdr msg, struct sock sk,
659	struct sk_buff *skb)	659	struct sk_buff *skb)
660	{	660	{
661	sock_recv_timestamp(msg, sk, skb);	661	sock_recv_timestamp(msg, sk, skb);
662	sock_recv_drops(msg, sk, skb);	662	sock_recv_drops(msg, sk, skb);
663	}	663	}
664	EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops);	664	EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops);
665		665
666	static inline int __sock_recvmsg_nosec(struct kiocb iocb, struct socket sock,	666	static inline int __sock_recvmsg_nosec(struct kiocb iocb, struct socket sock,
667	struct msghdr *msg, size_t size, int flags)	667	struct msghdr *msg, size_t size, int flags)
668	{	668	{
669	struct sock_iocb *si = kiocb_to_siocb(iocb);	669	struct sock_iocb *si = kiocb_to_siocb(iocb);
670		670
671	si->sock = sock;	671	si->sock = sock;
672	si->scm = NULL;	672	si->scm = NULL;
673	si->msg = msg;	673	si->msg = msg;
674	si->size = size;	674	si->size = size;
675	si->flags = flags;	675	si->flags = flags;
676		676
677	return sock->ops->recvmsg(iocb, sock, msg, size, flags);	677	return sock->ops->recvmsg(iocb, sock, msg, size, flags);
678	}	678	}
679		679
680	static inline int __sock_recvmsg(struct kiocb iocb, struct socket sock,	680	static inline int __sock_recvmsg(struct kiocb iocb, struct socket sock,
681	struct msghdr *msg, size_t size, int flags)	681	struct msghdr *msg, size_t size, int flags)
682	{	682	{
683	int err = security_socket_recvmsg(sock, msg, size, flags);	683	int err = security_socket_recvmsg(sock, msg, size, flags);
684		684
685	return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);	685	return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);
686	}	686	}
687		687
688	int sock_recvmsg(struct socket sock, struct msghdr msg,	688	int sock_recvmsg(struct socket sock, struct msghdr msg,
689	size_t size, int flags)	689	size_t size, int flags)
690	{	690	{
691	struct kiocb iocb;	691	struct kiocb iocb;
692	struct sock_iocb siocb;	692	struct sock_iocb siocb;
693	int ret;	693	int ret;
694		694
695	init_sync_kiocb(&iocb, NULL);	695	init_sync_kiocb(&iocb, NULL);
696	iocb.private = &siocb;	696	iocb.private = &siocb;
697	ret = __sock_recvmsg(&iocb, sock, msg, size, flags);	697	ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
698	if (-EIOCBQUEUED == ret)	698	if (-EIOCBQUEUED == ret)
699	ret = wait_on_sync_kiocb(&iocb);	699	ret = wait_on_sync_kiocb(&iocb);
700	return ret;	700	return ret;
701	}	701	}
702		702
703	static int sock_recvmsg_nosec(struct socket sock, struct msghdr msg,	703	static int sock_recvmsg_nosec(struct socket sock, struct msghdr msg,
704	size_t size, int flags)	704	size_t size, int flags)
705	{	705	{
706	struct kiocb iocb;	706	struct kiocb iocb;
707	struct sock_iocb siocb;	707	struct sock_iocb siocb;
708	int ret;	708	int ret;
709		709
710	init_sync_kiocb(&iocb, NULL);	710	init_sync_kiocb(&iocb, NULL);
711	iocb.private = &siocb;	711	iocb.private = &siocb;
712	ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);	712	ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);
713	if (-EIOCBQUEUED == ret)	713	if (-EIOCBQUEUED == ret)
714	ret = wait_on_sync_kiocb(&iocb);	714	ret = wait_on_sync_kiocb(&iocb);
715	return ret;	715	return ret;
716	}	716	}
717		717
718	int kernel_recvmsg(struct socket sock, struct msghdr msg,	718	int kernel_recvmsg(struct socket sock, struct msghdr msg,
719	struct kvec *vec, size_t num, size_t size, int flags)	719	struct kvec *vec, size_t num, size_t size, int flags)
720	{	720	{
721	mm_segment_t oldfs = get_fs();	721	mm_segment_t oldfs = get_fs();
722	int result;	722	int result;
723		723
724	set_fs(KERNEL_DS);	724	set_fs(KERNEL_DS);
725	/*	725	/*
726	* the following is safe, since for compiler definitions of kvec and	726	* the following is safe, since for compiler definitions of kvec and
727	* iovec are identical, yielding the same in-core layout and alignment	727	* iovec are identical, yielding the same in-core layout and alignment
728	*/	728	*/
729	msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;	729	msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
730	result = sock_recvmsg(sock, msg, size, flags);	730	result = sock_recvmsg(sock, msg, size, flags);
731	set_fs(oldfs);	731	set_fs(oldfs);
732	return result;	732	return result;
733	}	733	}
734		734
735	static void sock_aio_dtor(struct kiocb *iocb)	735	static void sock_aio_dtor(struct kiocb *iocb)
736	{	736	{
737	kfree(iocb->private);	737	kfree(iocb->private);
738	}	738	}
739		739
740	static ssize_t sock_sendpage(struct file file, struct page page,	740	static ssize_t sock_sendpage(struct file file, struct page page,
741	int offset, size_t size, loff_t *ppos, int more)	741	int offset, size_t size, loff_t *ppos, int more)
742	{	742	{
743	struct socket *sock;	743	struct socket *sock;
744	int flags;	744	int flags;
745		745
746	sock = file->private_data;	746	sock = file->private_data;
747		747
748	flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;	748	flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
749	if (more)	749	if (more)
750	flags \|= MSG_MORE;	750	flags \|= MSG_MORE;
751		751
752	return kernel_sendpage(sock, page, offset, size, flags);	752	return kernel_sendpage(sock, page, offset, size, flags);
753	}	753	}
754		754
755	static ssize_t sock_splice_read(struct file file, loff_t ppos,	755	static ssize_t sock_splice_read(struct file file, loff_t ppos,
756	struct pipe_inode_info *pipe, size_t len,	756	struct pipe_inode_info *pipe, size_t len,
757	unsigned int flags)	757	unsigned int flags)
758	{	758	{
759	struct socket *sock = file->private_data;	759	struct socket *sock = file->private_data;
760		760
761	if (unlikely(!sock->ops->splice_read))	761	if (unlikely(!sock->ops->splice_read))
762	return -EINVAL;	762	return -EINVAL;
763		763
764	return sock->ops->splice_read(sock, ppos, pipe, len, flags);	764	return sock->ops->splice_read(sock, ppos, pipe, len, flags);
765	}	765	}
766		766
767	static struct sock_iocb alloc_sock_iocb(struct kiocb iocb,	767	static struct sock_iocb alloc_sock_iocb(struct kiocb iocb,
768	struct sock_iocb *siocb)	768	struct sock_iocb *siocb)
769	{	769	{
770	if (!is_sync_kiocb(iocb)) {	770	if (!is_sync_kiocb(iocb)) {
771	siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);	771	siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);
772	if (!siocb)	772	if (!siocb)
773	return NULL;	773	return NULL;
774	iocb->ki_dtor = sock_aio_dtor;	774	iocb->ki_dtor = sock_aio_dtor;
775	}	775	}
776		776
777	siocb->kiocb = iocb;	777	siocb->kiocb = iocb;
778	iocb->private = siocb;	778	iocb->private = siocb;
779	return siocb;	779	return siocb;
780	}	780	}
781		781
782	static ssize_t do_sock_read(struct msghdr msg, struct kiocb iocb,	782	static ssize_t do_sock_read(struct msghdr msg, struct kiocb iocb,
783	struct file file, const struct iovec iov,	783	struct file file, const struct iovec iov,
784	unsigned long nr_segs)	784	unsigned long nr_segs)
785	{	785	{
786	struct socket *sock = file->private_data;	786	struct socket *sock = file->private_data;
787	size_t size = 0;	787	size_t size = 0;
788	int i;	788	int i;
789		789
790	for (i = 0; i < nr_segs; i++)	790	for (i = 0; i < nr_segs; i++)
791	size += iov[i].iov_len;	791	size += iov[i].iov_len;
792		792
793	msg->msg_name = NULL;	793	msg->msg_name = NULL;
794	msg->msg_namelen = 0;	794	msg->msg_namelen = 0;
795	msg->msg_control = NULL;	795	msg->msg_control = NULL;
796	msg->msg_controllen = 0;	796	msg->msg_controllen = 0;
797	msg->msg_iov = (struct iovec *)iov;	797	msg->msg_iov = (struct iovec *)iov;
798	msg->msg_iovlen = nr_segs;	798	msg->msg_iovlen = nr_segs;
799	msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;	799	msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
800		800
801	return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);	801	return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
802	}	802	}
803		803
804	static ssize_t sock_aio_read(struct kiocb iocb, const struct iovec iov,	804	static ssize_t sock_aio_read(struct kiocb iocb, const struct iovec iov,
805	unsigned long nr_segs, loff_t pos)	805	unsigned long nr_segs, loff_t pos)
806	{	806	{
807	struct sock_iocb siocb, *x;	807	struct sock_iocb siocb, *x;
808		808
809	if (pos != 0)	809	if (pos != 0)
810	return -ESPIPE;	810	return -ESPIPE;
811		811
812	if (iocb->ki_left == 0) /* Match SYS5 behaviour */	812	if (iocb->ki_left == 0) /* Match SYS5 behaviour */
813	return 0;	813	return 0;
814		814
815		815
816	x = alloc_sock_iocb(iocb, &siocb);	816	x = alloc_sock_iocb(iocb, &siocb);
817	if (!x)	817	if (!x)
818	return -ENOMEM;	818	return -ENOMEM;
819	return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);	819	return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
820	}	820	}
821		821
822	static ssize_t do_sock_write(struct msghdr msg, struct kiocb iocb,	822	static ssize_t do_sock_write(struct msghdr msg, struct kiocb iocb,
823	struct file file, const struct iovec iov,	823	struct file file, const struct iovec iov,
824	unsigned long nr_segs)	824	unsigned long nr_segs)
825	{	825	{
826	struct socket *sock = file->private_data;	826	struct socket *sock = file->private_data;
827	size_t size = 0;	827	size_t size = 0;
828	int i;	828	int i;
829		829
830	for (i = 0; i < nr_segs; i++)	830	for (i = 0; i < nr_segs; i++)
831	size += iov[i].iov_len;	831	size += iov[i].iov_len;
832		832
833	msg->msg_name = NULL;	833	msg->msg_name = NULL;
834	msg->msg_namelen = 0;	834	msg->msg_namelen = 0;
835	msg->msg_control = NULL;	835	msg->msg_control = NULL;
836	msg->msg_controllen = 0;	836	msg->msg_controllen = 0;
837	msg->msg_iov = (struct iovec *)iov;	837	msg->msg_iov = (struct iovec *)iov;
838	msg->msg_iovlen = nr_segs;	838	msg->msg_iovlen = nr_segs;
839	msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;	839	msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
840	if (sock->type == SOCK_SEQPACKET)	840	if (sock->type == SOCK_SEQPACKET)
841	msg->msg_flags \|= MSG_EOR;	841	msg->msg_flags \|= MSG_EOR;
842		842
843	return __sock_sendmsg(iocb, sock, msg, size);	843	return __sock_sendmsg(iocb, sock, msg, size);
844	}	844	}
845		845
846	static ssize_t sock_aio_write(struct kiocb iocb, const struct iovec iov,	846	static ssize_t sock_aio_write(struct kiocb iocb, const struct iovec iov,
847	unsigned long nr_segs, loff_t pos)	847	unsigned long nr_segs, loff_t pos)
848	{	848	{
849	struct sock_iocb siocb, *x;	849	struct sock_iocb siocb, *x;
850		850
851	if (pos != 0)	851	if (pos != 0)
852	return -ESPIPE;	852	return -ESPIPE;
853		853
854	x = alloc_sock_iocb(iocb, &siocb);	854	x = alloc_sock_iocb(iocb, &siocb);
855	if (!x)	855	if (!x)
856	return -ENOMEM;	856	return -ENOMEM;
857		857
858	return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);	858	return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
859	}	859	}
860		860
861	/*	861	/*
862	* Atomic setting of ioctl hooks to avoid race	862	* Atomic setting of ioctl hooks to avoid race
863	* with module unload.	863	* with module unload.
864	*/	864	*/
865		865
866	static DEFINE_MUTEX(br_ioctl_mutex);	866	static DEFINE_MUTEX(br_ioctl_mutex);
867	static int (br_ioctl_hook) (struct net , unsigned int cmd, void __user *arg) = NULL;	867	static int (br_ioctl_hook) (struct net , unsigned int cmd, void __user *arg) = NULL;
868		868
869	void brioctl_set(int (hook) (struct net , unsigned int, void __user *))	869	void brioctl_set(int (hook) (struct net , unsigned int, void __user *))
870	{	870	{
871	mutex_lock(&br_ioctl_mutex);	871	mutex_lock(&br_ioctl_mutex);
872	br_ioctl_hook = hook;	872	br_ioctl_hook = hook;
873	mutex_unlock(&br_ioctl_mutex);	873	mutex_unlock(&br_ioctl_mutex);
874	}	874	}
875		875
876	EXPORT_SYMBOL(brioctl_set);	876	EXPORT_SYMBOL(brioctl_set);
877		877
878	static DEFINE_MUTEX(vlan_ioctl_mutex);	878	static DEFINE_MUTEX(vlan_ioctl_mutex);
879	static int (vlan_ioctl_hook) (struct net , void __user *arg);	879	static int (vlan_ioctl_hook) (struct net , void __user *arg);
880		880
881	void vlan_ioctl_set(int (hook) (struct net , void __user *))	881	void vlan_ioctl_set(int (hook) (struct net , void __user *))
882	{	882	{
883	mutex_lock(&vlan_ioctl_mutex);	883	mutex_lock(&vlan_ioctl_mutex);
884	vlan_ioctl_hook = hook;	884	vlan_ioctl_hook = hook;
885	mutex_unlock(&vlan_ioctl_mutex);	885	mutex_unlock(&vlan_ioctl_mutex);
886	}	886	}
887		887
888	EXPORT_SYMBOL(vlan_ioctl_set);	888	EXPORT_SYMBOL(vlan_ioctl_set);
889		889
890	static DEFINE_MUTEX(dlci_ioctl_mutex);	890	static DEFINE_MUTEX(dlci_ioctl_mutex);
891	static int (dlci_ioctl_hook) (unsigned int, void __user );	891	static int (dlci_ioctl_hook) (unsigned int, void __user );
892		892
893	void dlci_ioctl_set(int (hook) (unsigned int, void __user ))	893	void dlci_ioctl_set(int (hook) (unsigned int, void __user ))
894	{	894	{
895	mutex_lock(&dlci_ioctl_mutex);	895	mutex_lock(&dlci_ioctl_mutex);
896	dlci_ioctl_hook = hook;	896	dlci_ioctl_hook = hook;
897	mutex_unlock(&dlci_ioctl_mutex);	897	mutex_unlock(&dlci_ioctl_mutex);
898	}	898	}
899		899
900	EXPORT_SYMBOL(dlci_ioctl_set);	900	EXPORT_SYMBOL(dlci_ioctl_set);
901		901
902	static long sock_do_ioctl(struct net net, struct socket sock,	902	static long sock_do_ioctl(struct net net, struct socket sock,
903	unsigned int cmd, unsigned long arg)	903	unsigned int cmd, unsigned long arg)
904	{	904	{
905	int err;	905	int err;
906	void __user argp = (void __user )arg;	906	void __user argp = (void __user )arg;
907		907
908	err = sock->ops->ioctl(sock, cmd, arg);	908	err = sock->ops->ioctl(sock, cmd, arg);
909		909
910	/*	910	/*
911	* If this ioctl is unknown try to hand it down	911	* If this ioctl is unknown try to hand it down
912	* to the NIC driver.	912	* to the NIC driver.
913	*/	913	*/
914	if (err == -ENOIOCTLCMD)	914	if (err == -ENOIOCTLCMD)
915	err = dev_ioctl(net, cmd, argp);	915	err = dev_ioctl(net, cmd, argp);
916		916
917	return err;	917	return err;
918	}	918	}
919		919
920	/*	920	/*
921	* With an ioctl, arg may well be a user mode pointer, but we don't know	921	* With an ioctl, arg may well be a user mode pointer, but we don't know
922	* what to do with it - that's up to the protocol still.	922	* what to do with it - that's up to the protocol still.
923	*/	923	*/
924		924
925	static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)	925	static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
926	{	926	{
927	struct socket *sock;	927	struct socket *sock;
928	struct sock *sk;	928	struct sock *sk;
929	void __user argp = (void __user )arg;	929	void __user argp = (void __user )arg;
930	int pid, err;	930	int pid, err;
931	struct net *net;	931	struct net *net;
932		932
933	sock = file->private_data;	933	sock = file->private_data;
934	sk = sock->sk;	934	sk = sock->sk;
935	net = sock_net(sk);	935	net = sock_net(sk);
936	if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {	936	if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
937	err = dev_ioctl(net, cmd, argp);	937	err = dev_ioctl(net, cmd, argp);
938	} else	938	} else
939	#ifdef CONFIG_WEXT_CORE	939	#ifdef CONFIG_WEXT_CORE
940	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {	940	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
941	err = dev_ioctl(net, cmd, argp);	941	err = dev_ioctl(net, cmd, argp);
942	} else	942	} else
943	#endif	943	#endif
944	switch (cmd) {	944	switch (cmd) {
945	case FIOSETOWN:	945	case FIOSETOWN:
946	case SIOCSPGRP:	946	case SIOCSPGRP:
947	err = -EFAULT;	947	err = -EFAULT;
948	if (get_user(pid, (int __user *)argp))	948	if (get_user(pid, (int __user *)argp))
949	break;	949	break;
950	err = f_setown(sock->file, pid, 1);	950	err = f_setown(sock->file, pid, 1);
951	break;	951	break;
952	case FIOGETOWN:	952	case FIOGETOWN:
953	case SIOCGPGRP:	953	case SIOCGPGRP:
954	err = put_user(f_getown(sock->file),	954	err = put_user(f_getown(sock->file),
955	(int __user *)argp);	955	(int __user *)argp);
956	break;	956	break;
957	case SIOCGIFBR:	957	case SIOCGIFBR:
958	case SIOCSIFBR:	958	case SIOCSIFBR:
959	case SIOCBRADDBR:	959	case SIOCBRADDBR:
960	case SIOCBRDELBR:	960	case SIOCBRDELBR:
961	err = -ENOPKG;	961	err = -ENOPKG;
962	if (!br_ioctl_hook)	962	if (!br_ioctl_hook)
963	request_module("bridge");	963	request_module("bridge");
964		964
965	mutex_lock(&br_ioctl_mutex);	965	mutex_lock(&br_ioctl_mutex);
966	if (br_ioctl_hook)	966	if (br_ioctl_hook)
967	err = br_ioctl_hook(net, cmd, argp);	967	err = br_ioctl_hook(net, cmd, argp);
968	mutex_unlock(&br_ioctl_mutex);	968	mutex_unlock(&br_ioctl_mutex);
969	break;	969	break;
970	case SIOCGIFVLAN:	970	case SIOCGIFVLAN:
971	case SIOCSIFVLAN:	971	case SIOCSIFVLAN:
972	err = -ENOPKG;	972	err = -ENOPKG;
973	if (!vlan_ioctl_hook)	973	if (!vlan_ioctl_hook)
974	request_module("8021q");	974	request_module("8021q");
975		975
976	mutex_lock(&vlan_ioctl_mutex);	976	mutex_lock(&vlan_ioctl_mutex);
977	if (vlan_ioctl_hook)	977	if (vlan_ioctl_hook)
978	err = vlan_ioctl_hook(net, argp);	978	err = vlan_ioctl_hook(net, argp);
979	mutex_unlock(&vlan_ioctl_mutex);	979	mutex_unlock(&vlan_ioctl_mutex);
980	break;	980	break;
981	case SIOCADDDLCI:	981	case SIOCADDDLCI:
982	case SIOCDELDLCI:	982	case SIOCDELDLCI:
983	err = -ENOPKG;	983	err = -ENOPKG;
984	if (!dlci_ioctl_hook)	984	if (!dlci_ioctl_hook)
985	request_module("dlci");	985	request_module("dlci");
986		986
987	mutex_lock(&dlci_ioctl_mutex);	987	mutex_lock(&dlci_ioctl_mutex);
988	if (dlci_ioctl_hook)	988	if (dlci_ioctl_hook)
989	err = dlci_ioctl_hook(cmd, argp);	989	err = dlci_ioctl_hook(cmd, argp);
990	mutex_unlock(&dlci_ioctl_mutex);	990	mutex_unlock(&dlci_ioctl_mutex);
991	break;	991	break;
992	default:	992	default:
993	err = sock_do_ioctl(net, sock, cmd, arg);	993	err = sock_do_ioctl(net, sock, cmd, arg);
994	break;	994	break;
995	}	995	}
996	return err;	996	return err;
997	}	997	}
998		998
999	int sock_create_lite(int family, int type, int protocol, struct socket **res)	999	int sock_create_lite(int family, int type, int protocol, struct socket **res)
1000	{	1000	{
1001	int err;	1001	int err;
1002	struct socket *sock = NULL;	1002	struct socket *sock = NULL;
1003		1003
1004	err = security_socket_create(family, type, protocol, 1);	1004	err = security_socket_create(family, type, protocol, 1);
1005	if (err)	1005	if (err)
1006	goto out;	1006	goto out;
1007		1007
1008	sock = sock_alloc();	1008	sock = sock_alloc();
1009	if (!sock) {	1009	if (!sock) {
1010	err = -ENOMEM;	1010	err = -ENOMEM;
1011	goto out;	1011	goto out;
1012	}	1012	}
1013		1013
1014	sock->type = type;	1014	sock->type = type;
1015	err = security_socket_post_create(sock, family, type, protocol, 1);	1015	err = security_socket_post_create(sock, family, type, protocol, 1);
1016	if (err)	1016	if (err)
1017	goto out_release;	1017	goto out_release;
1018		1018
1019	out:	1019	out:
1020	*res = sock;	1020	*res = sock;
1021	return err;	1021	return err;
1022	out_release:	1022	out_release:
1023	sock_release(sock);	1023	sock_release(sock);
1024	sock = NULL;	1024	sock = NULL;
1025	goto out;	1025	goto out;
1026	}	1026	}
1027		1027
1028	/* No kernel lock held - perfect */	1028	/* No kernel lock held - perfect */
1029	static unsigned int sock_poll(struct file file, poll_table wait)	1029	static unsigned int sock_poll(struct file file, poll_table wait)
1030	{	1030	{
1031	struct socket *sock;	1031	struct socket *sock;
1032		1032
1033	/*	1033	/*
1034	* We can't return errors to poll, so it's either yes or no.	1034	* We can't return errors to poll, so it's either yes or no.
1035	*/	1035	*/
1036	sock = file->private_data;	1036	sock = file->private_data;
1037	return sock->ops->poll(file, sock, wait);	1037	return sock->ops->poll(file, sock, wait);
1038	}	1038	}
1039		1039
1040	static int sock_mmap(struct file file, struct vm_area_struct vma)	1040	static int sock_mmap(struct file file, struct vm_area_struct vma)
1041	{	1041	{
1042	struct socket *sock = file->private_data;	1042	struct socket *sock = file->private_data;
1043		1043
1044	return sock->ops->mmap(file, sock, vma);	1044	return sock->ops->mmap(file, sock, vma);
1045	}	1045	}
1046		1046
1047	static int sock_close(struct inode inode, struct file filp)	1047	static int sock_close(struct inode inode, struct file filp)
1048	{	1048	{
1049	/*	1049	/*
1050	* It was possible the inode is NULL we were	1050	* It was possible the inode is NULL we were
1051	* closing an unfinished socket.	1051	* closing an unfinished socket.
1052	*/	1052	*/
1053		1053
1054	if (!inode) {	1054	if (!inode) {
1055	printk(KERN_DEBUG "sock_close: NULL inode\n");	1055	printk(KERN_DEBUG "sock_close: NULL inode\n");
1056	return 0;	1056	return 0;
1057	}	1057	}
1058	sock_release(SOCKET_I(inode));	1058	sock_release(SOCKET_I(inode));
1059	return 0;	1059	return 0;
1060	}	1060	}
1061		1061
1062	/*	1062	/*
1063	* Update the socket async list	1063	* Update the socket async list
1064	*	1064	*
1065	* Fasync_list locking strategy.	1065	* Fasync_list locking strategy.
1066	*	1066	*
1067	* 1. fasync_list is modified only under process context socket lock	1067	* 1. fasync_list is modified only under process context socket lock
1068	* i.e. under semaphore.	1068	* i.e. under semaphore.
1069	* 2. fasync_list is used under read_lock(&sk->sk_callback_lock)	1069	* 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1070	* or under socket lock.	1070	* or under socket lock
1071	* 3. fasync_list can be used from softirq context, so that
1072	* modification under socket lock have to be enhanced with
1073	* write_lock_bh(&sk->sk_callback_lock).
1074	* --ANK (990710)
1075	*/	1071	*/
1076		1072
1077	static int sock_fasync(int fd, struct file *filp, int on)	1073	static int sock_fasync(int fd, struct file *filp, int on)
1078	{	1074	{
1079	struct fasync_struct fa, fna = NULL, **prev;	1075	struct socket *sock = filp->private_data;
1080	struct socket *sock;	1076	struct sock *sk = sock->sk;
1081	struct sock *sk;
1082		1077
1083	if (on) {	1078	if (sk == NULL)
1084	fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
1085	if (fna == NULL)
1086	return -ENOMEM;
1087	}
1088
1089	sock = filp->private_data;
1090
1091	sk = sock->sk;
1092	if (sk == NULL) {
1093	kfree(fna);
1094	return -EINVAL;	1079	return -EINVAL;
1095	}
1096		1080
1097	lock_sock(sk);	1081	lock_sock(sk);
1098		1082
1099	spin_lock(&filp->f_lock);	1083	fasync_helper(fd, filp, on, &sock->fasync_list);
1100	if (on)
1101	filp->f_flags \|= FASYNC;
1102	else
1103	filp->f_flags &= ~FASYNC;
1104	spin_unlock(&filp->f_lock);
1105		1084
1106	prev = &(sock->fasync_list);	1085	if (!sock->fasync_list)
1107		1086	sock_reset_flag(sk, SOCK_FASYNC);
1108	for (fa = prev; fa != NULL; prev = &fa->fa_next, fa = prev)	1087	else
1109	if (fa->fa_file == filp)
1110	break;
1111
1112	if (on) {
1113	if (fa != NULL) {
1114	write_lock_bh(&sk->sk_callback_lock);
1115	fa->fa_fd = fd;
1116	write_unlock_bh(&sk->sk_callback_lock);
1117
1118	kfree(fna);
1119	goto out;
1120	}
1121	fna->fa_file = filp;
1122	fna->fa_fd = fd;
1123	fna->magic = FASYNC_MAGIC;
1124	fna->fa_next = sock->fasync_list;
1125	write_lock_bh(&sk->sk_callback_lock);
1126	sock->fasync_list = fna;
1127	sock_set_flag(sk, SOCK_FASYNC);	1088	sock_set_flag(sk, SOCK_FASYNC);
1128	write_unlock_bh(&sk->sk_callback_lock);
1129	} else {
1130	if (fa != NULL) {
1131	write_lock_bh(&sk->sk_callback_lock);
1132	*prev = fa->fa_next;
1133	if (!sock->fasync_list)
1134	sock_reset_flag(sk, SOCK_FASYNC);
1135	write_unlock_bh(&sk->sk_callback_lock);
1136	kfree(fa);
1137	}
1138	}
1139		1089
1140	out:	1090	release_sock(sk);
1141	release_sock(sock->sk);
1142	return 0;	1091	return 0;
1143	}	1092	}
1144		1093
1145	/* This function may be called only under socket lock or callback_lock */	1094	/* This function may be called only under socket lock or callback_lock */
1146		1095
1147	int sock_wake_async(struct socket *sock, int how, int band)	1096	int sock_wake_async(struct socket *sock, int how, int band)
1148	{	1097	{
1149	if (!sock \|\| !sock->fasync_list)	1098	if (!sock \|\| !sock->fasync_list)
1150	return -1;	1099	return -1;
1151	switch (how) {	1100	switch (how) {
1152	case SOCK_WAKE_WAITD:	1101	case SOCK_WAKE_WAITD:
1153	if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))	1102	if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1154	break;	1103	break;
1155	goto call_kill;	1104	goto call_kill;
1156	case SOCK_WAKE_SPACE:	1105	case SOCK_WAKE_SPACE:
1157	if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))	1106	if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1158	break;	1107	break;
1159	/* fall through */	1108	/* fall through */
1160	case SOCK_WAKE_IO:	1109	case SOCK_WAKE_IO:
1161	call_kill:	1110	call_kill:
1162	__kill_fasync(sock->fasync_list, SIGIO, band);	1111	kill_fasync(&sock->fasync_list, SIGIO, band);
1163	break;	1112	break;
1164	case SOCK_WAKE_URG:	1113	case SOCK_WAKE_URG:
1165	__kill_fasync(sock->fasync_list, SIGURG, band);	1114	kill_fasync(&sock->fasync_list, SIGURG, band);
1166	}	1115	}
1167	return 0;	1116	return 0;
1168	}	1117	}
1169		1118
1170	static int __sock_create(struct net *net, int family, int type, int protocol,	1119	static int __sock_create(struct net *net, int family, int type, int protocol,
1171	struct socket **res, int kern)	1120	struct socket **res, int kern)
1172	{	1121	{
1173	int err;	1122	int err;
1174	struct socket *sock;	1123	struct socket *sock;
1175	const struct net_proto_family *pf;	1124	const struct net_proto_family *pf;
1176		1125
1177	/*	1126	/*
1178	* Check protocol is in range	1127	* Check protocol is in range
1179	*/	1128	*/
1180	if (family < 0 \|\| family >= NPROTO)	1129	if (family < 0 \|\| family >= NPROTO)
1181	return -EAFNOSUPPORT;	1130	return -EAFNOSUPPORT;
1182	if (type < 0 \|\| type >= SOCK_MAX)	1131	if (type < 0 \|\| type >= SOCK_MAX)
1183	return -EINVAL;	1132	return -EINVAL;
1184		1133
1185	/* Compatibility.	1134	/* Compatibility.
1186		1135
1187	This uglymoron is moved from INET layer to here to avoid	1136	This uglymoron is moved from INET layer to here to avoid
1188	deadlock in module load.	1137	deadlock in module load.
1189	*/	1138	*/
1190	if (family == PF_INET && type == SOCK_PACKET) {	1139	if (family == PF_INET && type == SOCK_PACKET) {
1191	static int warned;	1140	static int warned;
1192	if (!warned) {	1141	if (!warned) {
1193	warned = 1;	1142	warned = 1;
1194	printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",	1143	printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1195	current->comm);	1144	current->comm);
1196	}	1145	}
1197	family = PF_PACKET;	1146	family = PF_PACKET;
1198	}	1147	}
1199		1148
1200	err = security_socket_create(family, type, protocol, kern);	1149	err = security_socket_create(family, type, protocol, kern);
1201	if (err)	1150	if (err)
1202	return err;	1151	return err;
1203		1152
1204	/*	1153	/*
1205	* Allocate the socket and allow the family to set things up. if	1154	* Allocate the socket and allow the family to set things up. if
1206	* the protocol is 0, the family is instructed to select an appropriate	1155	* the protocol is 0, the family is instructed to select an appropriate
1207	* default.	1156	* default.
1208	*/	1157	*/
1209	sock = sock_alloc();	1158	sock = sock_alloc();
1210	if (!sock) {	1159	if (!sock) {
1211	if (net_ratelimit())	1160	if (net_ratelimit())
1212	printk(KERN_WARNING "socket: no more sockets\n");	1161	printk(KERN_WARNING "socket: no more sockets\n");
1213	return -ENFILE; /* Not exactly a match, but its the	1162	return -ENFILE; /* Not exactly a match, but its the
1214	closest posix thing */	1163	closest posix thing */
1215	}	1164	}
1216		1165
1217	sock->type = type;	1166	sock->type = type;
1218		1167
1219	#ifdef CONFIG_MODULES	1168	#ifdef CONFIG_MODULES
1220	/* Attempt to load a protocol module if the find failed.	1169	/* Attempt to load a protocol module if the find failed.
1221	*	1170	*
1222	* 12/09/1996 Marcin: But! this makes REALLY only sense, if the user	1171	* 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1223	* requested real, full-featured networking support upon configuration.	1172	* requested real, full-featured networking support upon configuration.
1224	* Otherwise module support will break!	1173	* Otherwise module support will break!
1225	*/	1174	*/
1226	if (net_families[family] == NULL)	1175	if (net_families[family] == NULL)
1227	request_module("net-pf-%d", family);	1176	request_module("net-pf-%d", family);
1228	#endif	1177	#endif
1229		1178
1230	rcu_read_lock();	1179	rcu_read_lock();
1231	pf = rcu_dereference(net_families[family]);	1180	pf = rcu_dereference(net_families[family]);
1232	err = -EAFNOSUPPORT;	1181	err = -EAFNOSUPPORT;
1233	if (!pf)	1182	if (!pf)
1234	goto out_release;	1183	goto out_release;
1235		1184
1236	/*	1185	/*
1237	* We will call the ->create function, that possibly is in a loadable	1186	* We will call the ->create function, that possibly is in a loadable
1238	* module, so we have to bump that loadable module refcnt first.	1187	* module, so we have to bump that loadable module refcnt first.
1239	*/	1188	*/
1240	if (!try_module_get(pf->owner))	1189	if (!try_module_get(pf->owner))
1241	goto out_release;	1190	goto out_release;
1242		1191
1243	/* Now protected by module ref count */	1192	/* Now protected by module ref count */
1244	rcu_read_unlock();	1193	rcu_read_unlock();
1245		1194
1246	err = pf->create(net, sock, protocol, kern);	1195	err = pf->create(net, sock, protocol, kern);
1247	if (err < 0)	1196	if (err < 0)
1248	goto out_module_put;	1197	goto out_module_put;
1249		1198
1250	/*	1199	/*
1251	* Now to bump the refcnt of the [loadable] module that owns this	1200	* Now to bump the refcnt of the [loadable] module that owns this
1252	* socket at sock_release time we decrement its refcnt.	1201	* socket at sock_release time we decrement its refcnt.
1253	*/	1202	*/
1254	if (!try_module_get(sock->ops->owner))	1203	if (!try_module_get(sock->ops->owner))
1255	goto out_module_busy;	1204	goto out_module_busy;
1256		1205
1257	/*	1206	/*
1258	* Now that we're done with the ->create function, the [loadable]	1207	* Now that we're done with the ->create function, the [loadable]
1259	* module can have its refcnt decremented	1208	* module can have its refcnt decremented
1260	*/	1209	*/
1261	module_put(pf->owner);	1210	module_put(pf->owner);
1262	err = security_socket_post_create(sock, family, type, protocol, kern);	1211	err = security_socket_post_create(sock, family, type, protocol, kern);
1263	if (err)	1212	if (err)
1264	goto out_sock_release;	1213	goto out_sock_release;
1265	*res = sock;	1214	*res = sock;
1266		1215
1267	return 0;	1216	return 0;
1268		1217
1269	out_module_busy:	1218	out_module_busy:
1270	err = -EAFNOSUPPORT;	1219	err = -EAFNOSUPPORT;
1271	out_module_put:	1220	out_module_put:
1272	sock->ops = NULL;	1221	sock->ops = NULL;
1273	module_put(pf->owner);	1222	module_put(pf->owner);
1274	out_sock_release:	1223	out_sock_release:
1275	sock_release(sock);	1224	sock_release(sock);
1276	return err;	1225	return err;
1277		1226
1278	out_release:	1227	out_release:
1279	rcu_read_unlock();	1228	rcu_read_unlock();
1280	goto out_sock_release;	1229	goto out_sock_release;
1281	}	1230	}
1282		1231
1283	int sock_create(int family, int type, int protocol, struct socket **res)	1232	int sock_create(int family, int type, int protocol, struct socket **res)
1284	{	1233	{
1285	return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);	1234	return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1286	}	1235	}
1287		1236
1288	int sock_create_kern(int family, int type, int protocol, struct socket **res)	1237	int sock_create_kern(int family, int type, int protocol, struct socket **res)
1289	{	1238	{
1290	return __sock_create(&init_net, family, type, protocol, res, 1);	1239	return __sock_create(&init_net, family, type, protocol, res, 1);
1291	}	1240	}
1292		1241
1293	SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)	1242	SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1294	{	1243	{
1295	int retval;	1244	int retval;
1296	struct socket *sock;	1245	struct socket *sock;
1297	int flags;	1246	int flags;
1298		1247
1299	/* Check the SOCK_* constants for consistency. */	1248	/* Check the SOCK_* constants for consistency. */
1300	BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);	1249	BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1301	BUILD_BUG_ON((SOCK_MAX \| SOCK_TYPE_MASK) != SOCK_TYPE_MASK);	1250	BUILD_BUG_ON((SOCK_MAX \| SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1302	BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);	1251	BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1303	BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);	1252	BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1304		1253
1305	flags = type & ~SOCK_TYPE_MASK;	1254	flags = type & ~SOCK_TYPE_MASK;
1306	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))	1255	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))
1307	return -EINVAL;	1256	return -EINVAL;
1308	type &= SOCK_TYPE_MASK;	1257	type &= SOCK_TYPE_MASK;
1309		1258
1310	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))	1259	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1311	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;	1260	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;
1312		1261
1313	retval = sock_create(family, type, protocol, &sock);	1262	retval = sock_create(family, type, protocol, &sock);
1314	if (retval < 0)	1263	if (retval < 0)
1315	goto out;	1264	goto out;
1316		1265
1317	retval = sock_map_fd(sock, flags & (O_CLOEXEC \| O_NONBLOCK));	1266	retval = sock_map_fd(sock, flags & (O_CLOEXEC \| O_NONBLOCK));
1318	if (retval < 0)	1267	if (retval < 0)
1319	goto out_release;	1268	goto out_release;
1320		1269
1321	out:	1270	out:
1322	/* It may be already another descriptor 8) Not kernel problem. */	1271	/* It may be already another descriptor 8) Not kernel problem. */
1323	return retval;	1272	return retval;
1324		1273
1325	out_release:	1274	out_release:
1326	sock_release(sock);	1275	sock_release(sock);
1327	return retval;	1276	return retval;
1328	}	1277	}
1329		1278
1330	/*	1279	/*
1331	* Create a pair of connected sockets.	1280	* Create a pair of connected sockets.
1332	*/	1281	*/
1333		1282
1334	SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,	1283	SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1335	int __user *, usockvec)	1284	int __user *, usockvec)
1336	{	1285	{
1337	struct socket sock1, sock2;	1286	struct socket sock1, sock2;
1338	int fd1, fd2, err;	1287	int fd1, fd2, err;
1339	struct file newfile1, newfile2;	1288	struct file newfile1, newfile2;
1340	int flags;	1289	int flags;
1341		1290
1342	flags = type & ~SOCK_TYPE_MASK;	1291	flags = type & ~SOCK_TYPE_MASK;
1343	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))	1292	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))
1344	return -EINVAL;	1293	return -EINVAL;
1345	type &= SOCK_TYPE_MASK;	1294	type &= SOCK_TYPE_MASK;
1346		1295
1347	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))	1296	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1348	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;	1297	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;
1349		1298
1350	/*	1299	/*
1351	* Obtain the first socket and check if the underlying protocol	1300	* Obtain the first socket and check if the underlying protocol
1352	* supports the socketpair call.	1301	* supports the socketpair call.
1353	*/	1302	*/
1354		1303
1355	err = sock_create(family, type, protocol, &sock1);	1304	err = sock_create(family, type, protocol, &sock1);
1356	if (err < 0)	1305	if (err < 0)
1357	goto out;	1306	goto out;
1358		1307
1359	err = sock_create(family, type, protocol, &sock2);	1308	err = sock_create(family, type, protocol, &sock2);
1360	if (err < 0)	1309	if (err < 0)
1361	goto out_release_1;	1310	goto out_release_1;
1362		1311
1363	err = sock1->ops->socketpair(sock1, sock2);	1312	err = sock1->ops->socketpair(sock1, sock2);
1364	if (err < 0)	1313	if (err < 0)
1365	goto out_release_both;	1314	goto out_release_both;
1366		1315
1367	fd1 = sock_alloc_file(sock1, &newfile1, flags);	1316	fd1 = sock_alloc_file(sock1, &newfile1, flags);
1368	if (unlikely(fd1 < 0)) {	1317	if (unlikely(fd1 < 0)) {
1369	err = fd1;	1318	err = fd1;
1370	goto out_release_both;	1319	goto out_release_both;
1371	}	1320	}
1372		1321
1373	fd2 = sock_alloc_file(sock2, &newfile2, flags);	1322	fd2 = sock_alloc_file(sock2, &newfile2, flags);
1374	if (unlikely(fd2 < 0)) {	1323	if (unlikely(fd2 < 0)) {
1375	err = fd2;	1324	err = fd2;
1376	fput(newfile1);	1325	fput(newfile1);
1377	put_unused_fd(fd1);	1326	put_unused_fd(fd1);
1378	sock_release(sock2);	1327	sock_release(sock2);
1379	goto out;	1328	goto out;
1380	}	1329	}
1381		1330
1382	audit_fd_pair(fd1, fd2);	1331	audit_fd_pair(fd1, fd2);
1383	fd_install(fd1, newfile1);	1332	fd_install(fd1, newfile1);
1384	fd_install(fd2, newfile2);	1333	fd_install(fd2, newfile2);
1385	/* fd1 and fd2 may be already another descriptors.	1334	/* fd1 and fd2 may be already another descriptors.
1386	* Not kernel problem.	1335	* Not kernel problem.
1387	*/	1336	*/
1388		1337
1389	err = put_user(fd1, &usockvec[0]);	1338	err = put_user(fd1, &usockvec[0]);
1390	if (!err)	1339	if (!err)
1391	err = put_user(fd2, &usockvec[1]);	1340	err = put_user(fd2, &usockvec[1]);
1392	if (!err)	1341	if (!err)
1393	return 0;	1342	return 0;
1394		1343
1395	sys_close(fd2);	1344	sys_close(fd2);
1396	sys_close(fd1);	1345	sys_close(fd1);
1397	return err;	1346	return err;
1398		1347
1399	out_release_both:	1348	out_release_both:
1400	sock_release(sock2);	1349	sock_release(sock2);
1401	out_release_1:	1350	out_release_1:
1402	sock_release(sock1);	1351	sock_release(sock1);
1403	out:	1352	out:
1404	return err;	1353	return err;
1405	}	1354	}
1406		1355
1407	/*	1356	/*
1408	* Bind a name to a socket. Nothing much to do here since it's	1357	* Bind a name to a socket. Nothing much to do here since it's
1409	* the protocol's responsibility to handle the local address.	1358	* the protocol's responsibility to handle the local address.
1410	*	1359	*
1411	* We move the socket address to kernel space before we call	1360	* We move the socket address to kernel space before we call
1412	* the protocol layer (having also checked the address is ok).	1361	* the protocol layer (having also checked the address is ok).
1413	*/	1362	*/
1414		1363
1415	SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)	1364	SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1416	{	1365	{
1417	struct socket *sock;	1366	struct socket *sock;
1418	struct sockaddr_storage address;	1367	struct sockaddr_storage address;
1419	int err, fput_needed;	1368	int err, fput_needed;
1420		1369
1421	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1370	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1422	if (sock) {	1371	if (sock) {
1423	err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);	1372	err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
1424	if (err >= 0) {	1373	if (err >= 0) {
1425	err = security_socket_bind(sock,	1374	err = security_socket_bind(sock,
1426	(struct sockaddr *)&address,	1375	(struct sockaddr *)&address,
1427	addrlen);	1376	addrlen);
1428	if (!err)	1377	if (!err)
1429	err = sock->ops->bind(sock,	1378	err = sock->ops->bind(sock,
1430	(struct sockaddr *)	1379	(struct sockaddr *)
1431	&address, addrlen);	1380	&address, addrlen);
1432	}	1381	}
1433	fput_light(sock->file, fput_needed);	1382	fput_light(sock->file, fput_needed);
1434	}	1383	}
1435	return err;	1384	return err;
1436	}	1385	}
1437		1386
1438	/*	1387	/*
1439	* Perform a listen. Basically, we allow the protocol to do anything	1388	* Perform a listen. Basically, we allow the protocol to do anything
1440	* necessary for a listen, and if that works, we mark the socket as	1389	* necessary for a listen, and if that works, we mark the socket as
1441	* ready for listening.	1390	* ready for listening.
1442	*/	1391	*/
1443		1392
1444	SYSCALL_DEFINE2(listen, int, fd, int, backlog)	1393	SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1445	{	1394	{
1446	struct socket *sock;	1395	struct socket *sock;
1447	int err, fput_needed;	1396	int err, fput_needed;
1448	int somaxconn;	1397	int somaxconn;
1449		1398
1450	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1399	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1451	if (sock) {	1400	if (sock) {
1452	somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;	1401	somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
1453	if ((unsigned)backlog > somaxconn)	1402	if ((unsigned)backlog > somaxconn)
1454	backlog = somaxconn;	1403	backlog = somaxconn;
1455		1404
1456	err = security_socket_listen(sock, backlog);	1405	err = security_socket_listen(sock, backlog);
1457	if (!err)	1406	if (!err)
1458	err = sock->ops->listen(sock, backlog);	1407	err = sock->ops->listen(sock, backlog);
1459		1408
1460	fput_light(sock->file, fput_needed);	1409	fput_light(sock->file, fput_needed);
1461	}	1410	}
1462	return err;	1411	return err;
1463	}	1412	}
1464		1413
1465	/*	1414	/*
1466	* For accept, we attempt to create a new socket, set up the link	1415	* For accept, we attempt to create a new socket, set up the link
1467	* with the client, wake up the client, then return the new	1416	* with the client, wake up the client, then return the new
1468	* connected fd. We collect the address of the connector in kernel	1417	* connected fd. We collect the address of the connector in kernel
1469	* space and move it to user at the very end. This is unclean because	1418	* space and move it to user at the very end. This is unclean because
1470	* we open the socket then return an error.	1419	* we open the socket then return an error.
1471	*	1420	*
1472	* 1003.1g adds the ability to recvmsg() to query connection pending	1421	* 1003.1g adds the ability to recvmsg() to query connection pending
1473	* status to recvmsg. We need to add that support in a way thats	1422	* status to recvmsg. We need to add that support in a way thats
1474	* clean when we restucture accept also.	1423	* clean when we restucture accept also.
1475	*/	1424	*/
1476		1425
1477	SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,	1426	SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1478	int __user *, upeer_addrlen, int, flags)	1427	int __user *, upeer_addrlen, int, flags)
1479	{	1428	{
1480	struct socket sock, newsock;	1429	struct socket sock, newsock;
1481	struct file *newfile;	1430	struct file *newfile;
1482	int err, len, newfd, fput_needed;	1431	int err, len, newfd, fput_needed;
1483	struct sockaddr_storage address;	1432	struct sockaddr_storage address;
1484		1433
1485	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))	1434	if (flags & ~(SOCK_CLOEXEC \| SOCK_NONBLOCK))
1486	return -EINVAL;	1435	return -EINVAL;
1487		1436
1488	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))	1437	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1489	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;	1438	flags = (flags & ~SOCK_NONBLOCK) \| O_NONBLOCK;
1490		1439
1491	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1440	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1492	if (!sock)	1441	if (!sock)
1493	goto out;	1442	goto out;
1494		1443
1495	err = -ENFILE;	1444	err = -ENFILE;
1496	if (!(newsock = sock_alloc()))	1445	if (!(newsock = sock_alloc()))
1497	goto out_put;	1446	goto out_put;
1498		1447
1499	newsock->type = sock->type;	1448	newsock->type = sock->type;
1500	newsock->ops = sock->ops;	1449	newsock->ops = sock->ops;
1501		1450
1502	/*	1451	/*
1503	* We don't need try_module_get here, as the listening socket (sock)	1452	* We don't need try_module_get here, as the listening socket (sock)
1504	* has the protocol module (sock->ops->owner) held.	1453	* has the protocol module (sock->ops->owner) held.
1505	*/	1454	*/
1506	__module_get(newsock->ops->owner);	1455	__module_get(newsock->ops->owner);
1507		1456
1508	newfd = sock_alloc_file(newsock, &newfile, flags);	1457	newfd = sock_alloc_file(newsock, &newfile, flags);
1509	if (unlikely(newfd < 0)) {	1458	if (unlikely(newfd < 0)) {
1510	err = newfd;	1459	err = newfd;
1511	sock_release(newsock);	1460	sock_release(newsock);
1512	goto out_put;	1461	goto out_put;
1513	}	1462	}
1514		1463
1515	err = security_socket_accept(sock, newsock);	1464	err = security_socket_accept(sock, newsock);
1516	if (err)	1465	if (err)
1517	goto out_fd;	1466	goto out_fd;
1518		1467
1519	err = sock->ops->accept(sock, newsock, sock->file->f_flags);	1468	err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1520	if (err < 0)	1469	if (err < 0)
1521	goto out_fd;	1470	goto out_fd;
1522		1471
1523	if (upeer_sockaddr) {	1472	if (upeer_sockaddr) {
1524	if (newsock->ops->getname(newsock, (struct sockaddr *)&address,	1473	if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
1525	&len, 2) < 0) {	1474	&len, 2) < 0) {
1526	err = -ECONNABORTED;	1475	err = -ECONNABORTED;
1527	goto out_fd;	1476	goto out_fd;
1528	}	1477	}
1529	err = move_addr_to_user((struct sockaddr *)&address,	1478	err = move_addr_to_user((struct sockaddr *)&address,
1530	len, upeer_sockaddr, upeer_addrlen);	1479	len, upeer_sockaddr, upeer_addrlen);
1531	if (err < 0)	1480	if (err < 0)
1532	goto out_fd;	1481	goto out_fd;
1533	}	1482	}
1534		1483
1535	/* File flags are not inherited via accept() unlike another OSes. */	1484	/* File flags are not inherited via accept() unlike another OSes. */
1536		1485
1537	fd_install(newfd, newfile);	1486	fd_install(newfd, newfile);
1538	err = newfd;	1487	err = newfd;
1539		1488
1540	out_put:	1489	out_put:
1541	fput_light(sock->file, fput_needed);	1490	fput_light(sock->file, fput_needed);
1542	out:	1491	out:
1543	return err;	1492	return err;
1544	out_fd:	1493	out_fd:
1545	fput(newfile);	1494	fput(newfile);
1546	put_unused_fd(newfd);	1495	put_unused_fd(newfd);
1547	goto out_put;	1496	goto out_put;
1548	}	1497	}
1549		1498
1550	SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,	1499	SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1551	int __user *, upeer_addrlen)	1500	int __user *, upeer_addrlen)
1552	{	1501	{
1553	return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);	1502	return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
1554	}	1503	}
1555		1504
1556	/*	1505	/*
1557	* Attempt to connect to a socket with the server address. The address	1506	* Attempt to connect to a socket with the server address. The address
1558	* is in user space so we verify it is OK and move it to kernel space.	1507	* is in user space so we verify it is OK and move it to kernel space.
1559	*	1508	*
1560	* For 1003.1g we need to add clean support for a bind to AF_UNSPEC to	1509	* For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1561	* break bindings	1510	* break bindings
1562	*	1511	*
1563	* NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and	1512	* NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1564	* other SEQPACKET protocols that take time to connect() as it doesn't	1513	* other SEQPACKET protocols that take time to connect() as it doesn't
1565	* include the -EINPROGRESS status for such sockets.	1514	* include the -EINPROGRESS status for such sockets.
1566	*/	1515	*/
1567		1516
1568	SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,	1517	SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1569	int, addrlen)	1518	int, addrlen)
1570	{	1519	{
1571	struct socket *sock;	1520	struct socket *sock;
1572	struct sockaddr_storage address;	1521	struct sockaddr_storage address;
1573	int err, fput_needed;	1522	int err, fput_needed;
1574		1523
1575	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1524	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1576	if (!sock)	1525	if (!sock)
1577	goto out;	1526	goto out;
1578	err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);	1527	err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
1579	if (err < 0)	1528	if (err < 0)
1580	goto out_put;	1529	goto out_put;
1581		1530
1582	err =	1531	err =
1583	security_socket_connect(sock, (struct sockaddr *)&address, addrlen);	1532	security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1584	if (err)	1533	if (err)
1585	goto out_put;	1534	goto out_put;
1586		1535
1587	err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,	1536	err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1588	sock->file->f_flags);	1537	sock->file->f_flags);
1589	out_put:	1538	out_put:
1590	fput_light(sock->file, fput_needed);	1539	fput_light(sock->file, fput_needed);
1591	out:	1540	out:
1592	return err;	1541	return err;
1593	}	1542	}
1594		1543
1595	/*	1544	/*
1596	* Get the local address ('name') of a socket object. Move the obtained	1545	* Get the local address ('name') of a socket object. Move the obtained
1597	* name to user space.	1546	* name to user space.
1598	*/	1547	*/
1599		1548
1600	SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,	1549	SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1601	int __user *, usockaddr_len)	1550	int __user *, usockaddr_len)
1602	{	1551	{
1603	struct socket *sock;	1552	struct socket *sock;
1604	struct sockaddr_storage address;	1553	struct sockaddr_storage address;
1605	int len, err, fput_needed;	1554	int len, err, fput_needed;
1606		1555
1607	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1556	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1608	if (!sock)	1557	if (!sock)
1609	goto out;	1558	goto out;
1610		1559
1611	err = security_socket_getsockname(sock);	1560	err = security_socket_getsockname(sock);
1612	if (err)	1561	if (err)
1613	goto out_put;	1562	goto out_put;
1614		1563
1615	err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);	1564	err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1616	if (err)	1565	if (err)
1617	goto out_put;	1566	goto out_put;
1618	err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);	1567	err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
1619		1568
1620	out_put:	1569	out_put:
1621	fput_light(sock->file, fput_needed);	1570	fput_light(sock->file, fput_needed);
1622	out:	1571	out:
1623	return err;	1572	return err;
1624	}	1573	}
1625		1574
1626	/*	1575	/*
1627	* Get the remote address ('name') of a socket object. Move the obtained	1576	* Get the remote address ('name') of a socket object. Move the obtained
1628	* name to user space.	1577	* name to user space.
1629	*/	1578	*/
1630		1579
1631	SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,	1580	SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1632	int __user *, usockaddr_len)	1581	int __user *, usockaddr_len)
1633	{	1582	{
1634	struct socket *sock;	1583	struct socket *sock;
1635	struct sockaddr_storage address;	1584	struct sockaddr_storage address;
1636	int len, err, fput_needed;	1585	int len, err, fput_needed;
1637		1586
1638	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1587	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1639	if (sock != NULL) {	1588	if (sock != NULL) {
1640	err = security_socket_getpeername(sock);	1589	err = security_socket_getpeername(sock);
1641	if (err) {	1590	if (err) {
1642	fput_light(sock->file, fput_needed);	1591	fput_light(sock->file, fput_needed);
1643	return err;	1592	return err;
1644	}	1593	}
1645		1594
1646	err =	1595	err =
1647	sock->ops->getname(sock, (struct sockaddr *)&address, &len,	1596	sock->ops->getname(sock, (struct sockaddr *)&address, &len,
1648	1);	1597	1);
1649	if (!err)	1598	if (!err)
1650	err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,	1599	err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
1651	usockaddr_len);	1600	usockaddr_len);
1652	fput_light(sock->file, fput_needed);	1601	fput_light(sock->file, fput_needed);
1653	}	1602	}
1654	return err;	1603	return err;
1655	}	1604	}
1656		1605
1657	/*	1606	/*
1658	* Send a datagram to a given address. We move the address into kernel	1607	* Send a datagram to a given address. We move the address into kernel
1659	* space and check the user space data area is readable before invoking	1608	* space and check the user space data area is readable before invoking
1660	* the protocol.	1609	* the protocol.
1661	*/	1610	*/
1662		1611
1663	SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,	1612	SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
1664	unsigned, flags, struct sockaddr __user *, addr,	1613	unsigned, flags, struct sockaddr __user *, addr,
1665	int, addr_len)	1614	int, addr_len)
1666	{	1615	{
1667	struct socket *sock;	1616	struct socket *sock;
1668	struct sockaddr_storage address;	1617	struct sockaddr_storage address;
1669	int err;	1618	int err;
1670	struct msghdr msg;	1619	struct msghdr msg;
1671	struct iovec iov;	1620	struct iovec iov;
1672	int fput_needed;	1621	int fput_needed;
1673		1622
1674	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1623	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1675	if (!sock)	1624	if (!sock)
1676	goto out;	1625	goto out;
1677		1626
1678	iov.iov_base = buff;	1627	iov.iov_base = buff;
1679	iov.iov_len = len;	1628	iov.iov_len = len;
1680	msg.msg_name = NULL;	1629	msg.msg_name = NULL;
1681	msg.msg_iov = &iov;	1630	msg.msg_iov = &iov;
1682	msg.msg_iovlen = 1;	1631	msg.msg_iovlen = 1;
1683	msg.msg_control = NULL;	1632	msg.msg_control = NULL;
1684	msg.msg_controllen = 0;	1633	msg.msg_controllen = 0;
1685	msg.msg_namelen = 0;	1634	msg.msg_namelen = 0;
1686	if (addr) {	1635	if (addr) {
1687	err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);	1636	err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
1688	if (err < 0)	1637	if (err < 0)
1689	goto out_put;	1638	goto out_put;
1690	msg.msg_name = (struct sockaddr *)&address;	1639	msg.msg_name = (struct sockaddr *)&address;
1691	msg.msg_namelen = addr_len;	1640	msg.msg_namelen = addr_len;
1692	}	1641	}
1693	if (sock->file->f_flags & O_NONBLOCK)	1642	if (sock->file->f_flags & O_NONBLOCK)
1694	flags \|= MSG_DONTWAIT;	1643	flags \|= MSG_DONTWAIT;
1695	msg.msg_flags = flags;	1644	msg.msg_flags = flags;
1696	err = sock_sendmsg(sock, &msg, len);	1645	err = sock_sendmsg(sock, &msg, len);
1697		1646
1698	out_put:	1647	out_put:
1699	fput_light(sock->file, fput_needed);	1648	fput_light(sock->file, fput_needed);
1700	out:	1649	out:
1701	return err;	1650	return err;
1702	}	1651	}
1703		1652
1704	/*	1653	/*
1705	* Send a datagram down a socket.	1654	* Send a datagram down a socket.
1706	*/	1655	*/
1707		1656
1708	SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,	1657	SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
1709	unsigned, flags)	1658	unsigned, flags)
1710	{	1659	{
1711	return sys_sendto(fd, buff, len, flags, NULL, 0);	1660	return sys_sendto(fd, buff, len, flags, NULL, 0);
1712	}	1661	}
1713		1662
1714	/*	1663	/*
1715	* Receive a frame from the socket and optionally record the address of the	1664	* Receive a frame from the socket and optionally record the address of the
1716	* sender. We verify the buffers are writable and if needed move the	1665	* sender. We verify the buffers are writable and if needed move the
1717	* sender address from kernel to user space.	1666	* sender address from kernel to user space.
1718	*/	1667	*/
1719		1668
1720	SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,	1669	SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
1721	unsigned, flags, struct sockaddr __user *, addr,	1670	unsigned, flags, struct sockaddr __user *, addr,
1722	int __user *, addr_len)	1671	int __user *, addr_len)
1723	{	1672	{
1724	struct socket *sock;	1673	struct socket *sock;
1725	struct iovec iov;	1674	struct iovec iov;
1726	struct msghdr msg;	1675	struct msghdr msg;
1727	struct sockaddr_storage address;	1676	struct sockaddr_storage address;
1728	int err, err2;	1677	int err, err2;
1729	int fput_needed;	1678	int fput_needed;
1730		1679
1731	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1680	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1732	if (!sock)	1681	if (!sock)
1733	goto out;	1682	goto out;
1734		1683
1735	msg.msg_control = NULL;	1684	msg.msg_control = NULL;
1736	msg.msg_controllen = 0;	1685	msg.msg_controllen = 0;
1737	msg.msg_iovlen = 1;	1686	msg.msg_iovlen = 1;
1738	msg.msg_iov = &iov;	1687	msg.msg_iov = &iov;
1739	iov.iov_len = size;	1688	iov.iov_len = size;
1740	iov.iov_base = ubuf;	1689	iov.iov_base = ubuf;
1741	msg.msg_name = (struct sockaddr *)&address;	1690	msg.msg_name = (struct sockaddr *)&address;
1742	msg.msg_namelen = sizeof(address);	1691	msg.msg_namelen = sizeof(address);
1743	if (sock->file->f_flags & O_NONBLOCK)	1692	if (sock->file->f_flags & O_NONBLOCK)
1744	flags \|= MSG_DONTWAIT;	1693	flags \|= MSG_DONTWAIT;
1745	err = sock_recvmsg(sock, &msg, size, flags);	1694	err = sock_recvmsg(sock, &msg, size, flags);
1746		1695
1747	if (err >= 0 && addr != NULL) {	1696	if (err >= 0 && addr != NULL) {
1748	err2 = move_addr_to_user((struct sockaddr *)&address,	1697	err2 = move_addr_to_user((struct sockaddr *)&address,
1749	msg.msg_namelen, addr, addr_len);	1698	msg.msg_namelen, addr, addr_len);
1750	if (err2 < 0)	1699	if (err2 < 0)
1751	err = err2;	1700	err = err2;
1752	}	1701	}
1753		1702
1754	fput_light(sock->file, fput_needed);	1703	fput_light(sock->file, fput_needed);
1755	out:	1704	out:
1756	return err;	1705	return err;
1757	}	1706	}
1758		1707
1759	/*	1708	/*
1760	* Receive a datagram from a socket.	1709	* Receive a datagram from a socket.
1761	*/	1710	*/
1762		1711
1763	asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,	1712	asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
1764	unsigned flags)	1713	unsigned flags)
1765	{	1714	{
1766	return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);	1715	return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1767	}	1716	}
1768		1717
1769	/*	1718	/*
1770	* Set a socket option. Because we don't know the option lengths we have	1719	* Set a socket option. Because we don't know the option lengths we have
1771	* to pass the user mode parameter for the protocols to sort out.	1720	* to pass the user mode parameter for the protocols to sort out.
1772	*/	1721	*/
1773		1722
1774	SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,	1723	SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1775	char __user *, optval, int, optlen)	1724	char __user *, optval, int, optlen)
1776	{	1725	{
1777	int err, fput_needed;	1726	int err, fput_needed;
1778	struct socket *sock;	1727	struct socket *sock;
1779		1728
1780	if (optlen < 0)	1729	if (optlen < 0)
1781	return -EINVAL;	1730	return -EINVAL;
1782		1731
1783	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1732	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1784	if (sock != NULL) {	1733	if (sock != NULL) {
1785	err = security_socket_setsockopt(sock, level, optname);	1734	err = security_socket_setsockopt(sock, level, optname);
1786	if (err)	1735	if (err)
1787	goto out_put;	1736	goto out_put;
1788		1737
1789	if (level == SOL_SOCKET)	1738	if (level == SOL_SOCKET)
1790	err =	1739	err =
1791	sock_setsockopt(sock, level, optname, optval,	1740	sock_setsockopt(sock, level, optname, optval,
1792	optlen);	1741	optlen);
1793	else	1742	else
1794	err =	1743	err =
1795	sock->ops->setsockopt(sock, level, optname, optval,	1744	sock->ops->setsockopt(sock, level, optname, optval,
1796	optlen);	1745	optlen);
1797	out_put:	1746	out_put:
1798	fput_light(sock->file, fput_needed);	1747	fput_light(sock->file, fput_needed);
1799	}	1748	}
1800	return err;	1749	return err;
1801	}	1750	}
1802		1751
1803	/*	1752	/*
1804	* Get a socket option. Because we don't know the option lengths we have	1753	* Get a socket option. Because we don't know the option lengths we have
1805	* to pass a user mode parameter for the protocols to sort out.	1754	* to pass a user mode parameter for the protocols to sort out.
1806	*/	1755	*/
1807		1756
1808	SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,	1757	SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1809	char __user , optval, int __user , optlen)	1758	char __user , optval, int __user , optlen)
1810	{	1759	{
1811	int err, fput_needed;	1760	int err, fput_needed;
1812	struct socket *sock;	1761	struct socket *sock;
1813		1762
1814	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1763	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1815	if (sock != NULL) {	1764	if (sock != NULL) {
1816	err = security_socket_getsockopt(sock, level, optname);	1765	err = security_socket_getsockopt(sock, level, optname);
1817	if (err)	1766	if (err)
1818	goto out_put;	1767	goto out_put;
1819		1768
1820	if (level == SOL_SOCKET)	1769	if (level == SOL_SOCKET)
1821	err =	1770	err =
1822	sock_getsockopt(sock, level, optname, optval,	1771	sock_getsockopt(sock, level, optname, optval,
1823	optlen);	1772	optlen);
1824	else	1773	else
1825	err =	1774	err =
1826	sock->ops->getsockopt(sock, level, optname, optval,	1775	sock->ops->getsockopt(sock, level, optname, optval,
1827	optlen);	1776	optlen);
1828	out_put:	1777	out_put:
1829	fput_light(sock->file, fput_needed);	1778	fput_light(sock->file, fput_needed);
1830	}	1779	}
1831	return err;	1780	return err;
1832	}	1781	}
1833		1782
1834	/*	1783	/*
1835	* Shutdown a socket.	1784	* Shutdown a socket.
1836	*/	1785	*/
1837		1786
1838	SYSCALL_DEFINE2(shutdown, int, fd, int, how)	1787	SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1839	{	1788	{
1840	int err, fput_needed;	1789	int err, fput_needed;
1841	struct socket *sock;	1790	struct socket *sock;
1842		1791
1843	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1792	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1844	if (sock != NULL) {	1793	if (sock != NULL) {
1845	err = security_socket_shutdown(sock, how);	1794	err = security_socket_shutdown(sock, how);
1846	if (!err)	1795	if (!err)
1847	err = sock->ops->shutdown(sock, how);	1796	err = sock->ops->shutdown(sock, how);
1848	fput_light(sock->file, fput_needed);	1797	fput_light(sock->file, fput_needed);
1849	}	1798	}
1850	return err;	1799	return err;
1851	}	1800	}
1852		1801
1853	/* A couple of helpful macros for getting the address of the 32/64 bit	1802	/* A couple of helpful macros for getting the address of the 32/64 bit
1854	* fields which are the same type (int / unsigned) on our platforms.	1803	* fields which are the same type (int / unsigned) on our platforms.
1855	*/	1804	*/
1856	#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)	1805	#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1857	#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)	1806	#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1858	#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)	1807	#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1859		1808
1860	/*	1809	/*
1861	* BSD sendmsg interface	1810	* BSD sendmsg interface
1862	*/	1811	*/
1863		1812
1864	SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)	1813	SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
1865	{	1814	{
1866	struct compat_msghdr __user *msg_compat =	1815	struct compat_msghdr __user *msg_compat =
1867	(struct compat_msghdr __user *)msg;	1816	(struct compat_msghdr __user *)msg;
1868	struct socket *sock;	1817	struct socket *sock;
1869	struct sockaddr_storage address;	1818	struct sockaddr_storage address;
1870	struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;	1819	struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1871	unsigned char ctl[sizeof(struct cmsghdr) + 20]	1820	unsigned char ctl[sizeof(struct cmsghdr) + 20]
1872	__attribute__ ((aligned(sizeof(__kernel_size_t))));	1821	__attribute__ ((aligned(sizeof(__kernel_size_t))));
1873	/* 20 is size of ipv6_pktinfo */	1822	/* 20 is size of ipv6_pktinfo */
1874	unsigned char *ctl_buf = ctl;	1823	unsigned char *ctl_buf = ctl;
1875	struct msghdr msg_sys;	1824	struct msghdr msg_sys;
1876	int err, ctl_len, iov_size, total_len;	1825	int err, ctl_len, iov_size, total_len;
1877	int fput_needed;	1826	int fput_needed;
1878		1827
1879	err = -EFAULT;	1828	err = -EFAULT;
1880	if (MSG_CMSG_COMPAT & flags) {	1829	if (MSG_CMSG_COMPAT & flags) {
1881	if (get_compat_msghdr(&msg_sys, msg_compat))	1830	if (get_compat_msghdr(&msg_sys, msg_compat))
1882	return -EFAULT;	1831	return -EFAULT;
1883	}	1832	}
1884	else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))	1833	else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1885	return -EFAULT;	1834	return -EFAULT;
1886		1835
1887	sock = sockfd_lookup_light(fd, &err, &fput_needed);	1836	sock = sockfd_lookup_light(fd, &err, &fput_needed);
1888	if (!sock)	1837	if (!sock)
1889	goto out;	1838	goto out;
1890		1839
1891	/* do not move before msg_sys is valid */	1840	/* do not move before msg_sys is valid */
1892	err = -EMSGSIZE;	1841	err = -EMSGSIZE;
1893	if (msg_sys.msg_iovlen > UIO_MAXIOV)	1842	if (msg_sys.msg_iovlen > UIO_MAXIOV)
1894	goto out_put;	1843	goto out_put;
1895		1844
1896	/* Check whether to allocate the iovec area */	1845	/* Check whether to allocate the iovec area */
1897	err = -ENOMEM;	1846	err = -ENOMEM;
1898	iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);	1847	iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1899	if (msg_sys.msg_iovlen > UIO_FASTIOV) {	1848	if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1900	iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);	1849	iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1901	if (!iov)	1850	if (!iov)
1902	goto out_put;	1851	goto out_put;
1903	}	1852	}
1904		1853
1905	/* This will also move the address data into kernel space */	1854	/* This will also move the address data into kernel space */
1906	if (MSG_CMSG_COMPAT & flags) {	1855	if (MSG_CMSG_COMPAT & flags) {
1907	err = verify_compat_iovec(&msg_sys, iov,	1856	err = verify_compat_iovec(&msg_sys, iov,
1908	(struct sockaddr *)&address,	1857	(struct sockaddr *)&address,
1909	VERIFY_READ);	1858	VERIFY_READ);
1910	} else	1859	} else
1911	err = verify_iovec(&msg_sys, iov,	1860	err = verify_iovec(&msg_sys, iov,
1912	(struct sockaddr *)&address,	1861	(struct sockaddr *)&address,
1913	VERIFY_READ);	1862	VERIFY_READ);
1914	if (err < 0)	1863	if (err < 0)
1915	goto out_freeiov;	1864	goto out_freeiov;
1916	total_len = err;	1865	total_len = err;
1917		1866
1918	err = -ENOBUFS;	1867	err = -ENOBUFS;
1919		1868
1920	if (msg_sys.msg_controllen > INT_MAX)	1869	if (msg_sys.msg_controllen > INT_MAX)
1921	goto out_freeiov;	1870	goto out_freeiov;
1922	ctl_len = msg_sys.msg_controllen;	1871	ctl_len = msg_sys.msg_controllen;
1923	if ((MSG_CMSG_COMPAT & flags) && ctl_len) {	1872	if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
1924	err =	1873	err =
1925	cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,	1874	cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
1926	sizeof(ctl));	1875	sizeof(ctl));
1927	if (err)	1876	if (err)
1928	goto out_freeiov;	1877	goto out_freeiov;
1929	ctl_buf = msg_sys.msg_control;	1878	ctl_buf = msg_sys.msg_control;
1930	ctl_len = msg_sys.msg_controllen;	1879	ctl_len = msg_sys.msg_controllen;
1931	} else if (ctl_len) {	1880	} else if (ctl_len) {
1932	if (ctl_len > sizeof(ctl)) {	1881	if (ctl_len > sizeof(ctl)) {
1933	ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);	1882	ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
1934	if (ctl_buf == NULL)	1883	if (ctl_buf == NULL)
1935	goto out_freeiov;	1884	goto out_freeiov;
1936	}	1885	}
1937	err = -EFAULT;	1886	err = -EFAULT;
1938	/*	1887	/*
1939	* Careful! Before this, msg_sys.msg_control contains a user pointer.	1888	* Careful! Before this, msg_sys.msg_control contains a user pointer.
1940	* Afterwards, it will be a kernel pointer. Thus the compiler-assisted	1889	* Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1941	* checking falls down on this.	1890	* checking falls down on this.
1942	*/	1891	*/
1943	if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,	1892	if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,
1944	ctl_len))	1893	ctl_len))
1945	goto out_freectl;	1894	goto out_freectl;
1946	msg_sys.msg_control = ctl_buf;	1895	msg_sys.msg_control = ctl_buf;
1947	}	1896	}
1948	msg_sys.msg_flags = flags;	1897	msg_sys.msg_flags = flags;
1949		1898
1950	if (sock->file->f_flags & O_NONBLOCK)	1899	if (sock->file->f_flags & O_NONBLOCK)
1951	msg_sys.msg_flags \|= MSG_DONTWAIT;	1900	msg_sys.msg_flags \|= MSG_DONTWAIT;
1952	err = sock_sendmsg(sock, &msg_sys, total_len);	1901	err = sock_sendmsg(sock, &msg_sys, total_len);
1953		1902
1954	out_freectl:	1903	out_freectl:
1955	if (ctl_buf != ctl)	1904	if (ctl_buf != ctl)
1956	sock_kfree_s(sock->sk, ctl_buf, ctl_len);	1905	sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1957	out_freeiov:	1906	out_freeiov:
1958	if (iov != iovstack)	1907	if (iov != iovstack)
1959	sock_kfree_s(sock->sk, iov, iov_size);	1908	sock_kfree_s(sock->sk, iov, iov_size);
1960	out_put:	1909	out_put:
1961	fput_light(sock->file, fput_needed);	1910	fput_light(sock->file, fput_needed);
1962	out:	1911	out:
1963	return err;	1912	return err;
1964	}	1913	}
1965		1914
1966	static int __sys_recvmsg(struct socket sock, struct msghdr __user msg,	1915	static int __sys_recvmsg(struct socket sock, struct msghdr __user msg,
1967	struct msghdr *msg_sys, unsigned flags, int nosec)	1916	struct msghdr *msg_sys, unsigned flags, int nosec)
1968	{	1917	{
1969	struct compat_msghdr __user *msg_compat =	1918	struct compat_msghdr __user *msg_compat =
1970	(struct compat_msghdr __user *)msg;	1919	(struct compat_msghdr __user *)msg;
1971	struct iovec iovstack[UIO_FASTIOV];	1920	struct iovec iovstack[UIO_FASTIOV];
1972	struct iovec *iov = iovstack;	1921	struct iovec *iov = iovstack;
1973	unsigned long cmsg_ptr;	1922	unsigned long cmsg_ptr;
1974	int err, iov_size, total_len, len;	1923	int err, iov_size, total_len, len;
1975		1924
1976	/* kernel mode address */	1925	/* kernel mode address */
1977	struct sockaddr_storage addr;	1926	struct sockaddr_storage addr;
1978		1927
1979	/* user mode address pointers */	1928	/* user mode address pointers */
1980	struct sockaddr __user *uaddr;	1929	struct sockaddr __user *uaddr;
1981	int __user *uaddr_len;	1930	int __user *uaddr_len;
1982		1931
1983	if (MSG_CMSG_COMPAT & flags) {	1932	if (MSG_CMSG_COMPAT & flags) {
1984	if (get_compat_msghdr(msg_sys, msg_compat))	1933	if (get_compat_msghdr(msg_sys, msg_compat))
1985	return -EFAULT;	1934	return -EFAULT;
1986	}	1935	}
1987	else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr)))	1936	else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr)))
1988	return -EFAULT;	1937	return -EFAULT;
1989		1938
1990	err = -EMSGSIZE;	1939	err = -EMSGSIZE;
1991	if (msg_sys->msg_iovlen > UIO_MAXIOV)	1940	if (msg_sys->msg_iovlen > UIO_MAXIOV)
1992	goto out;	1941	goto out;
1993		1942
1994	/* Check whether to allocate the iovec area */	1943	/* Check whether to allocate the iovec area */
1995	err = -ENOMEM;	1944	err = -ENOMEM;
1996	iov_size = msg_sys->msg_iovlen * sizeof(struct iovec);	1945	iov_size = msg_sys->msg_iovlen * sizeof(struct iovec);
1997	if (msg_sys->msg_iovlen > UIO_FASTIOV) {	1946	if (msg_sys->msg_iovlen > UIO_FASTIOV) {
1998	iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);	1947	iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1999	if (!iov)	1948	if (!iov)
2000	goto out;	1949	goto out;
2001	}	1950	}
2002		1951
2003	/*	1952	/*
2004	* Save the user-mode address (verify_iovec will change the	1953	* Save the user-mode address (verify_iovec will change the
2005	* kernel msghdr to use the kernel address space)	1954	* kernel msghdr to use the kernel address space)
2006	*/	1955	*/
2007		1956
2008	uaddr = (__force void __user *)msg_sys->msg_name;	1957	uaddr = (__force void __user *)msg_sys->msg_name;
2009	uaddr_len = COMPAT_NAMELEN(msg);	1958	uaddr_len = COMPAT_NAMELEN(msg);
2010	if (MSG_CMSG_COMPAT & flags) {	1959	if (MSG_CMSG_COMPAT & flags) {
2011	err = verify_compat_iovec(msg_sys, iov,	1960	err = verify_compat_iovec(msg_sys, iov,
2012	(struct sockaddr *)&addr,	1961	(struct sockaddr *)&addr,
2013	VERIFY_WRITE);	1962	VERIFY_WRITE);
2014	} else	1963	} else
2015	err = verify_iovec(msg_sys, iov,	1964	err = verify_iovec(msg_sys, iov,
2016	(struct sockaddr *)&addr,	1965	(struct sockaddr *)&addr,
2017	VERIFY_WRITE);	1966	VERIFY_WRITE);
2018	if (err < 0)	1967	if (err < 0)
2019	goto out_freeiov;	1968	goto out_freeiov;
2020	total_len = err;	1969	total_len = err;
2021		1970
2022	cmsg_ptr = (unsigned long)msg_sys->msg_control;	1971	cmsg_ptr = (unsigned long)msg_sys->msg_control;
2023	msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC\|MSG_CMSG_COMPAT);	1972	msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC\|MSG_CMSG_COMPAT);
2024		1973
2025	if (sock->file->f_flags & O_NONBLOCK)	1974	if (sock->file->f_flags & O_NONBLOCK)
2026	flags \|= MSG_DONTWAIT;	1975	flags \|= MSG_DONTWAIT;
2027	err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,	1976	err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
2028	total_len, flags);	1977	total_len, flags);
2029	if (err < 0)	1978	if (err < 0)
2030	goto out_freeiov;	1979	goto out_freeiov;
2031	len = err;	1980	len = err;
2032		1981
2033	if (uaddr != NULL) {	1982	if (uaddr != NULL) {
2034	err = move_addr_to_user((struct sockaddr *)&addr,	1983	err = move_addr_to_user((struct sockaddr *)&addr,
2035	msg_sys->msg_namelen, uaddr,	1984	msg_sys->msg_namelen, uaddr,
2036	uaddr_len);	1985	uaddr_len);
2037	if (err < 0)	1986	if (err < 0)
2038	goto out_freeiov;	1987	goto out_freeiov;
2039	}	1988	}
2040	err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),	1989	err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
2041	COMPAT_FLAGS(msg));	1990	COMPAT_FLAGS(msg));
2042	if (err)	1991	if (err)
2043	goto out_freeiov;	1992	goto out_freeiov;
2044	if (MSG_CMSG_COMPAT & flags)	1993	if (MSG_CMSG_COMPAT & flags)
2045	err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,	1994	err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2046	&msg_compat->msg_controllen);	1995	&msg_compat->msg_controllen);
2047	else	1996	else
2048	err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,	1997	err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2049	&msg->msg_controllen);	1998	&msg->msg_controllen);
2050	if (err)	1999	if (err)
2051	goto out_freeiov;	2000	goto out_freeiov;
2052	err = len;	2001	err = len;
2053		2002
2054	out_freeiov:	2003	out_freeiov:
2055	if (iov != iovstack)	2004	if (iov != iovstack)
2056	sock_kfree_s(sock->sk, iov, iov_size);	2005	sock_kfree_s(sock->sk, iov, iov_size);
2057	out:	2006	out:
2058	return err;	2007	return err;
2059	}	2008	}
2060		2009
2061	/*	2010	/*
2062	* BSD recvmsg interface	2011	* BSD recvmsg interface
2063	*/	2012	*/
2064		2013
2065	SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,	2014	SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2066	unsigned int, flags)	2015	unsigned int, flags)
2067	{	2016	{
2068	int fput_needed, err;	2017	int fput_needed, err;
2069	struct msghdr msg_sys;	2018	struct msghdr msg_sys;
2070	struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed);	2019	struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed);
2071		2020
2072	if (!sock)	2021	if (!sock)
2073	goto out;	2022	goto out;
2074		2023
2075	err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0);	2024	err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0);
2076		2025
2077	fput_light(sock->file, fput_needed);	2026	fput_light(sock->file, fput_needed);
2078	out:	2027	out:
2079	return err;	2028	return err;
2080	}	2029	}
2081		2030
2082	/*	2031	/*
2083	* Linux recvmmsg interface	2032	* Linux recvmmsg interface
2084	*/	2033	*/
2085		2034
2086	int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,	2035	int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2087	unsigned int flags, struct timespec *timeout)	2036	unsigned int flags, struct timespec *timeout)
2088	{	2037	{
2089	int fput_needed, err, datagrams;	2038	int fput_needed, err, datagrams;
2090	struct socket *sock;	2039	struct socket *sock;
2091	struct mmsghdr __user *entry;	2040	struct mmsghdr __user *entry;
2092	struct compat_mmsghdr __user *compat_entry;	2041	struct compat_mmsghdr __user *compat_entry;
2093	struct msghdr msg_sys;	2042	struct msghdr msg_sys;
2094	struct timespec end_time;	2043	struct timespec end_time;
2095		2044
2096	if (timeout &&	2045	if (timeout &&
2097	poll_select_set_timeout(&end_time, timeout->tv_sec,	2046	poll_select_set_timeout(&end_time, timeout->tv_sec,
2098	timeout->tv_nsec))	2047	timeout->tv_nsec))
2099	return -EINVAL;	2048	return -EINVAL;
2100		2049
2101	datagrams = 0;	2050	datagrams = 0;
2102		2051
2103	sock = sockfd_lookup_light(fd, &err, &fput_needed);	2052	sock = sockfd_lookup_light(fd, &err, &fput_needed);
2104	if (!sock)	2053	if (!sock)
2105	return err;	2054	return err;
2106		2055
2107	err = sock_error(sock->sk);	2056	err = sock_error(sock->sk);
2108	if (err)	2057	if (err)
2109	goto out_put;	2058	goto out_put;
2110		2059
2111	entry = mmsg;	2060	entry = mmsg;
2112	compat_entry = (struct compat_mmsghdr __user *)mmsg;	2061	compat_entry = (struct compat_mmsghdr __user *)mmsg;
2113		2062
2114	while (datagrams < vlen) {	2063	while (datagrams < vlen) {
2115	/*	2064	/*
2116	* No need to ask LSM for more than the first datagram.	2065	* No need to ask LSM for more than the first datagram.
2117	*/	2066	*/
2118	if (MSG_CMSG_COMPAT & flags) {	2067	if (MSG_CMSG_COMPAT & flags) {
2119	err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry,	2068	err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
2120	&msg_sys, flags, datagrams);	2069	&msg_sys, flags, datagrams);
2121	if (err < 0)	2070	if (err < 0)
2122	break;	2071	break;
2123	err = __put_user(err, &compat_entry->msg_len);	2072	err = __put_user(err, &compat_entry->msg_len);
2124	++compat_entry;	2073	++compat_entry;
2125	} else {	2074	} else {
2126	err = __sys_recvmsg(sock, (struct msghdr __user *)entry,	2075	err = __sys_recvmsg(sock, (struct msghdr __user *)entry,
2127	&msg_sys, flags, datagrams);	2076	&msg_sys, flags, datagrams);
2128	if (err < 0)	2077	if (err < 0)
2129	break;	2078	break;
2130	err = put_user(err, &entry->msg_len);	2079	err = put_user(err, &entry->msg_len);
2131	++entry;	2080	++entry;
2132	}	2081	}
2133		2082
2134	if (err)	2083	if (err)
2135	break;	2084	break;
2136	++datagrams;	2085	++datagrams;
2137		2086
2138	/* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */	2087	/* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2139	if (flags & MSG_WAITFORONE)	2088	if (flags & MSG_WAITFORONE)
2140	flags \|= MSG_DONTWAIT;	2089	flags \|= MSG_DONTWAIT;
2141		2090
2142	if (timeout) {	2091	if (timeout) {
2143	ktime_get_ts(timeout);	2092	ktime_get_ts(timeout);
2144	timeout = timespec_sub(end_time, timeout);	2093	timeout = timespec_sub(end_time, timeout);
2145	if (timeout->tv_sec < 0) {	2094	if (timeout->tv_sec < 0) {
2146	timeout->tv_sec = timeout->tv_nsec = 0;	2095	timeout->tv_sec = timeout->tv_nsec = 0;
2147	break;	2096	break;
2148	}	2097	}
2149		2098
2150	/* Timeout, return less than vlen datagrams */	2099	/* Timeout, return less than vlen datagrams */
2151	if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)	2100	if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2152	break;	2101	break;
2153	}	2102	}
2154		2103
2155	/* Out of band data, return right away */	2104	/* Out of band data, return right away */
2156	if (msg_sys.msg_flags & MSG_OOB)	2105	if (msg_sys.msg_flags & MSG_OOB)
2157	break;	2106	break;
2158	}	2107	}
2159		2108
2160	out_put:	2109	out_put:
2161	fput_light(sock->file, fput_needed);	2110	fput_light(sock->file, fput_needed);
2162		2111
2163	if (err == 0)	2112	if (err == 0)
2164	return datagrams;	2113	return datagrams;
2165		2114
2166	if (datagrams != 0) {	2115	if (datagrams != 0) {
2167	/*	2116	/*
2168	* We may return less entries than requested (vlen) if the	2117	* We may return less entries than requested (vlen) if the
2169	* sock is non block and there aren't enough datagrams...	2118	* sock is non block and there aren't enough datagrams...
2170	*/	2119	*/
2171	if (err != -EAGAIN) {	2120	if (err != -EAGAIN) {
2172	/*	2121	/*
2173	* ... or if recvmsg returns an error after we	2122	* ... or if recvmsg returns an error after we
2174	* received some datagrams, where we record the	2123	* received some datagrams, where we record the
2175	* error to return on the next call or if the	2124	* error to return on the next call or if the
2176	* app asks about it using getsockopt(SO_ERROR).	2125	* app asks about it using getsockopt(SO_ERROR).
2177	*/	2126	*/
2178	sock->sk->sk_err = -err;	2127	sock->sk->sk_err = -err;
2179	}	2128	}
2180		2129
2181	return datagrams;	2130	return datagrams;
2182	}	2131	}
2183		2132
2184	return err;	2133	return err;
2185	}	2134	}
2186		2135
2187	SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,	2136	SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2188	unsigned int, vlen, unsigned int, flags,	2137	unsigned int, vlen, unsigned int, flags,
2189	struct timespec __user *, timeout)	2138	struct timespec __user *, timeout)
2190	{	2139	{
2191	int datagrams;	2140	int datagrams;
2192	struct timespec timeout_sys;	2141	struct timespec timeout_sys;
2193		2142
2194	if (!timeout)	2143	if (!timeout)
2195	return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);	2144	return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2196		2145
2197	if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))	2146	if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2198	return -EFAULT;	2147	return -EFAULT;
2199		2148
2200	datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);	2149	datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2201		2150
2202	if (datagrams > 0 &&	2151	if (datagrams > 0 &&
2203	copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))	2152	copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2204	datagrams = -EFAULT;	2153	datagrams = -EFAULT;
2205		2154
2206	return datagrams;	2155	return datagrams;
2207	}	2156	}
2208		2157
2209	#ifdef __ARCH_WANT_SYS_SOCKETCALL	2158	#ifdef __ARCH_WANT_SYS_SOCKETCALL
2210	/* Argument list sizes for sys_socketcall */	2159	/* Argument list sizes for sys_socketcall */
2211	#define AL(x) ((x) * sizeof(unsigned long))	2160	#define AL(x) ((x) * sizeof(unsigned long))
2212	static const unsigned char nargs[20] = {	2161	static const unsigned char nargs[20] = {
2213	AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),	2162	AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2214	AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),	2163	AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
2215	AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),	2164	AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
2216	AL(4),AL(5)	2165	AL(4),AL(5)
2217	};	2166	};
2218		2167
2219	#undef AL	2168	#undef AL
2220		2169
2221	/*	2170	/*
2222	* System call vectors.	2171	* System call vectors.
2223	*	2172	*
2224	* Argument checking cleaned up. Saved 20% in size.	2173	* Argument checking cleaned up. Saved 20% in size.
2225	* This function doesn't need to set the kernel lock because	2174	* This function doesn't need to set the kernel lock because
2226	* it is set by the callees.	2175	* it is set by the callees.
2227	*/	2176	*/
2228		2177
2229	SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)	2178	SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2230	{	2179	{
2231	unsigned long a[6];	2180	unsigned long a[6];
2232	unsigned long a0, a1;	2181	unsigned long a0, a1;
2233	int err;	2182	int err;
2234	unsigned int len;	2183	unsigned int len;
2235		2184
2236	if (call < 1 \|\| call > SYS_RECVMMSG)	2185	if (call < 1 \|\| call > SYS_RECVMMSG)
2237	return -EINVAL;	2186	return -EINVAL;
2238		2187
2239	len = nargs[call];	2188	len = nargs[call];
2240	if (len > sizeof(a))	2189	if (len > sizeof(a))
2241	return -EINVAL;	2190	return -EINVAL;
2242		2191
2243	/* copy_from_user should be SMP safe. */	2192	/* copy_from_user should be SMP safe. */
2244	if (copy_from_user(a, args, len))	2193	if (copy_from_user(a, args, len))
2245	return -EFAULT;	2194	return -EFAULT;
2246		2195
2247	audit_socketcall(nargs[call] / sizeof(unsigned long), a);	2196	audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2248		2197
2249	a0 = a[0];	2198	a0 = a[0];
2250	a1 = a[1];	2199	a1 = a[1];
2251		2200
2252	switch (call) {	2201	switch (call) {
2253	case SYS_SOCKET:	2202	case SYS_SOCKET:
2254	err = sys_socket(a0, a1, a[2]);	2203	err = sys_socket(a0, a1, a[2]);
2255	break;	2204	break;
2256	case SYS_BIND:	2205	case SYS_BIND:
2257	err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);	2206	err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2258	break;	2207	break;
2259	case SYS_CONNECT:	2208	case SYS_CONNECT:
2260	err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);	2209	err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2261	break;	2210	break;
2262	case SYS_LISTEN:	2211	case SYS_LISTEN:
2263	err = sys_listen(a0, a1);	2212	err = sys_listen(a0, a1);
2264	break;	2213	break;
2265	case SYS_ACCEPT:	2214	case SYS_ACCEPT:
2266	err = sys_accept4(a0, (struct sockaddr __user *)a1,	2215	err = sys_accept4(a0, (struct sockaddr __user *)a1,
2267	(int __user *)a[2], 0);	2216	(int __user *)a[2], 0);
2268	break;	2217	break;
2269	case SYS_GETSOCKNAME:	2218	case SYS_GETSOCKNAME:
2270	err =	2219	err =
2271	sys_getsockname(a0, (struct sockaddr __user *)a1,	2220	sys_getsockname(a0, (struct sockaddr __user *)a1,
2272	(int __user *)a[2]);	2221	(int __user *)a[2]);
2273	break;	2222	break;
2274	case SYS_GETPEERNAME:	2223	case SYS_GETPEERNAME:
2275	err =	2224	err =
2276	sys_getpeername(a0, (struct sockaddr __user *)a1,	2225	sys_getpeername(a0, (struct sockaddr __user *)a1,
2277	(int __user *)a[2]);	2226	(int __user *)a[2]);
2278	break;	2227	break;
2279	case SYS_SOCKETPAIR:	2228	case SYS_SOCKETPAIR:
2280	err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);	2229	err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2281	break;	2230	break;
2282	case SYS_SEND:	2231	case SYS_SEND:
2283	err = sys_send(a0, (void __user *)a1, a[2], a[3]);	2232	err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2284	break;	2233	break;
2285	case SYS_SENDTO:	2234	case SYS_SENDTO:
2286	err = sys_sendto(a0, (void __user *)a1, a[2], a[3],	2235	err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2287	(struct sockaddr __user *)a[4], a[5]);	2236	(struct sockaddr __user *)a[4], a[5]);
2288	break;	2237	break;
2289	case SYS_RECV:	2238	case SYS_RECV:
2290	err = sys_recv(a0, (void __user *)a1, a[2], a[3]);	2239	err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2291	break;	2240	break;
2292	case SYS_RECVFROM:	2241	case SYS_RECVFROM:
2293	err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],	2242	err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2294	(struct sockaddr __user *)a[4],	2243	(struct sockaddr __user *)a[4],
2295	(int __user *)a[5]);	2244	(int __user *)a[5]);
2296	break;	2245	break;
2297	case SYS_SHUTDOWN:	2246	case SYS_SHUTDOWN:
2298	err = sys_shutdown(a0, a1);	2247	err = sys_shutdown(a0, a1);
2299	break;	2248	break;
2300	case SYS_SETSOCKOPT:	2249	case SYS_SETSOCKOPT:
2301	err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);	2250	err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2302	break;	2251	break;
2303	case SYS_GETSOCKOPT:	2252	case SYS_GETSOCKOPT:
2304	err =	2253	err =
2305	sys_getsockopt(a0, a1, a[2], (char __user *)a[3],	2254	sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2306	(int __user *)a[4]);	2255	(int __user *)a[4]);
2307	break;	2256	break;
2308	case SYS_SENDMSG:	2257	case SYS_SENDMSG:
2309	err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);	2258	err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2310	break;	2259	break;
2311	case SYS_RECVMSG:	2260	case SYS_RECVMSG:
2312	err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);	2261	err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2313	break;	2262	break;
2314	case SYS_RECVMMSG:	2263	case SYS_RECVMMSG:
2315	err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],	2264	err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2316	(struct timespec __user *)a[4]);	2265	(struct timespec __user *)a[4]);
2317	break;	2266	break;
2318	case SYS_ACCEPT4:	2267	case SYS_ACCEPT4:
2319	err = sys_accept4(a0, (struct sockaddr __user *)a1,	2268	err = sys_accept4(a0, (struct sockaddr __user *)a1,
2320	(int __user *)a[2], a[3]);	2269	(int __user *)a[2], a[3]);
2321	break;	2270	break;
2322	default:	2271	default:
2323	err = -EINVAL;	2272	err = -EINVAL;
2324	break;	2273	break;
2325	}	2274	}
2326	return err;	2275	return err;
2327	}	2276	}
2328		2277
2329	#endif /* __ARCH_WANT_SYS_SOCKETCALL */	2278	#endif /* __ARCH_WANT_SYS_SOCKETCALL */
2330		2279
2331	/**	2280	/**
2332	* sock_register - add a socket protocol handler	2281	* sock_register - add a socket protocol handler
2333	* @ops: description of protocol	2282	* @ops: description of protocol
2334	*	2283	*
2335	* This function is called by a protocol handler that wants to	2284	* This function is called by a protocol handler that wants to
2336	* advertise its address family, and have it linked into the	2285	* advertise its address family, and have it linked into the
2337	* socket interface. The value ops->family coresponds to the	2286	* socket interface. The value ops->family coresponds to the
2338	* socket system call protocol family.	2287	* socket system call protocol family.
2339	*/	2288	*/
2340	int sock_register(const struct net_proto_family *ops)	2289	int sock_register(const struct net_proto_family *ops)
2341	{	2290	{
2342	int err;	2291	int err;
2343		2292
2344	if (ops->family >= NPROTO) {	2293	if (ops->family >= NPROTO) {
2345	printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,	2294	printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
2346	NPROTO);	2295	NPROTO);
2347	return -ENOBUFS;	2296	return -ENOBUFS;
2348	}	2297	}
2349		2298
2350	spin_lock(&net_family_lock);	2299	spin_lock(&net_family_lock);
2351	if (net_families[ops->family])	2300	if (net_families[ops->family])
2352	err = -EEXIST;	2301	err = -EEXIST;
2353	else {	2302	else {
2354	net_families[ops->family] = ops;	2303	net_families[ops->family] = ops;
2355	err = 0;	2304	err = 0;
2356	}	2305	}
2357	spin_unlock(&net_family_lock);	2306	spin_unlock(&net_family_lock);
2358		2307
2359	printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);	2308	printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
2360	return err;	2309	return err;
2361	}	2310	}
2362		2311
2363	/**	2312	/**
2364	* sock_unregister - remove a protocol handler	2313	* sock_unregister - remove a protocol handler
2365	* @family: protocol family to remove	2314	* @family: protocol family to remove
2366	*	2315	*
2367	* This function is called by a protocol handler that wants to	2316	* This function is called by a protocol handler that wants to
2368	* remove its address family, and have it unlinked from the	2317	* remove its address family, and have it unlinked from the
2369	* new socket creation.	2318	* new socket creation.
2370	*	2319	*
2371	* If protocol handler is a module, then it can use module reference	2320	* If protocol handler is a module, then it can use module reference
2372	* counts to protect against new references. If protocol handler is not	2321	* counts to protect against new references. If protocol handler is not
2373	* a module then it needs to provide its own protection in	2322	* a module then it needs to provide its own protection in
2374	* the ops->create routine.	2323	* the ops->create routine.
2375	*/	2324	*/
2376	void sock_unregister(int family)	2325	void sock_unregister(int family)
2377	{	2326	{
2378	BUG_ON(family < 0 \|\| family >= NPROTO);	2327	BUG_ON(family < 0 \|\| family >= NPROTO);
2379		2328
2380	spin_lock(&net_family_lock);	2329	spin_lock(&net_family_lock);
2381	net_families[family] = NULL;	2330	net_families[family] = NULL;
2382	spin_unlock(&net_family_lock);	2331	spin_unlock(&net_family_lock);
2383		2332
2384	synchronize_rcu();	2333	synchronize_rcu();
2385		2334
2386	printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);	2335	printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
2387	}	2336	}
2388		2337
2389	static int __init sock_init(void)	2338	static int __init sock_init(void)
2390	{	2339	{
2391	/*	2340	/*
2392	* Initialize sock SLAB cache.	2341	* Initialize sock SLAB cache.
2393	*/	2342	*/
2394		2343
2395	sk_init();	2344	sk_init();
2396		2345
2397	/*	2346	/*
2398	* Initialize skbuff SLAB cache	2347	* Initialize skbuff SLAB cache
2399	*/	2348	*/
2400	skb_init();	2349	skb_init();
2401		2350
2402	/*	2351	/*
2403	* Initialize the protocols module.	2352	* Initialize the protocols module.
2404	*/	2353	*/
2405		2354
2406	init_inodecache();	2355	init_inodecache();
2407	register_filesystem(&sock_fs_type);	2356	register_filesystem(&sock_fs_type);
2408	sock_mnt = kern_mount(&sock_fs_type);	2357	sock_mnt = kern_mount(&sock_fs_type);
2409		2358
2410	/* The real protocol initialization is performed in later initcalls.	2359	/* The real protocol initialization is performed in later initcalls.
2411	*/	2360	*/
2412		2361
2413	#ifdef CONFIG_NETFILTER	2362	#ifdef CONFIG_NETFILTER
2414	netfilter_init();	2363	netfilter_init();
2415	#endif	2364	#endif
2416		2365
2417	return 0;	2366	return 0;
2418	}	2367	}
2419		2368
2420	core_initcall(sock_init); /* early initcall */	2369	core_initcall(sock_init); /* early initcall */
2421		2370
2422	#ifdef CONFIG_PROC_FS	2371	#ifdef CONFIG_PROC_FS
2423	void socket_seq_show(struct seq_file *seq)	2372	void socket_seq_show(struct seq_file *seq)
2424	{	2373	{
2425	int cpu;	2374	int cpu;
2426	int counter = 0;	2375	int counter = 0;
2427		2376
2428	for_each_possible_cpu(cpu)	2377	for_each_possible_cpu(cpu)
2429	counter += per_cpu(sockets_in_use, cpu);	2378	counter += per_cpu(sockets_in_use, cpu);
2430		2379
2431	/* It can be negative, by the way. 8) */	2380	/* It can be negative, by the way. 8) */
2432	if (counter < 0)	2381	if (counter < 0)
2433	counter = 0;	2382	counter = 0;
2434		2383
2435	seq_printf(seq, "sockets: used %d\n", counter);	2384	seq_printf(seq, "sockets: used %d\n", counter);
2436	}	2385	}
2437	#endif /* CONFIG_PROC_FS */	2386	#endif /* CONFIG_PROC_FS */
2438		2387
2439	#ifdef CONFIG_COMPAT	2388	#ifdef CONFIG_COMPAT
2440	static int do_siocgstamp(struct net net, struct socket sock,	2389	static int do_siocgstamp(struct net net, struct socket sock,
2441	unsigned int cmd, struct compat_timeval __user *up)	2390	unsigned int cmd, struct compat_timeval __user *up)
2442	{	2391	{
2443	mm_segment_t old_fs = get_fs();	2392	mm_segment_t old_fs = get_fs();
2444	struct timeval ktv;	2393	struct timeval ktv;
2445	int err;	2394	int err;
2446		2395
2447	set_fs(KERNEL_DS);	2396	set_fs(KERNEL_DS);
2448	err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);	2397	err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
2449	set_fs(old_fs);	2398	set_fs(old_fs);
2450	if (!err) {	2399	if (!err) {
2451	err = put_user(ktv.tv_sec, &up->tv_sec);	2400	err = put_user(ktv.tv_sec, &up->tv_sec);
2452	err \|= __put_user(ktv.tv_usec, &up->tv_usec);	2401	err \|= __put_user(ktv.tv_usec, &up->tv_usec);
2453	}	2402	}
2454	return err;	2403	return err;
2455	}	2404	}
2456		2405
2457	static int do_siocgstampns(struct net net, struct socket sock,	2406	static int do_siocgstampns(struct net net, struct socket sock,
2458	unsigned int cmd, struct compat_timespec __user *up)	2407	unsigned int cmd, struct compat_timespec __user *up)
2459	{	2408	{
2460	mm_segment_t old_fs = get_fs();	2409	mm_segment_t old_fs = get_fs();
2461	struct timespec kts;	2410	struct timespec kts;
2462	int err;	2411	int err;
2463		2412
2464	set_fs(KERNEL_DS);	2413	set_fs(KERNEL_DS);
2465	err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);	2414	err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
2466	set_fs(old_fs);	2415	set_fs(old_fs);
2467	if (!err) {	2416	if (!err) {
2468	err = put_user(kts.tv_sec, &up->tv_sec);	2417	err = put_user(kts.tv_sec, &up->tv_sec);
2469	err \|= __put_user(kts.tv_nsec, &up->tv_nsec);	2418	err \|= __put_user(kts.tv_nsec, &up->tv_nsec);
2470	}	2419	}
2471	return err;	2420	return err;
2472	}	2421	}
2473		2422
2474	static int dev_ifname32(struct net net, struct compat_ifreq __user uifr32)	2423	static int dev_ifname32(struct net net, struct compat_ifreq __user uifr32)
2475	{	2424	{
2476	struct ifreq __user *uifr;	2425	struct ifreq __user *uifr;
2477	int err;	2426	int err;
2478		2427
2479	uifr = compat_alloc_user_space(sizeof(struct ifreq));	2428	uifr = compat_alloc_user_space(sizeof(struct ifreq));
2480	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))	2429	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2481	return -EFAULT;	2430	return -EFAULT;
2482		2431
2483	err = dev_ioctl(net, SIOCGIFNAME, uifr);	2432	err = dev_ioctl(net, SIOCGIFNAME, uifr);
2484	if (err)	2433	if (err)
2485	return err;	2434	return err;
2486		2435
2487	if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))	2436	if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
2488	return -EFAULT;	2437	return -EFAULT;
2489		2438
2490	return 0;	2439	return 0;
2491	}	2440	}
2492		2441
2493	static int dev_ifconf(struct net net, struct compat_ifconf __user uifc32)	2442	static int dev_ifconf(struct net net, struct compat_ifconf __user uifc32)
2494	{	2443	{
2495	struct compat_ifconf ifc32;	2444	struct compat_ifconf ifc32;
2496	struct ifconf ifc;	2445	struct ifconf ifc;
2497	struct ifconf __user *uifc;	2446	struct ifconf __user *uifc;
2498	struct compat_ifreq __user *ifr32;	2447	struct compat_ifreq __user *ifr32;
2499	struct ifreq __user *ifr;	2448	struct ifreq __user *ifr;
2500	unsigned int i, j;	2449	unsigned int i, j;
2501	int err;	2450	int err;
2502		2451
2503	if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))	2452	if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
2504	return -EFAULT;	2453	return -EFAULT;
2505		2454
2506	if (ifc32.ifcbuf == 0) {	2455	if (ifc32.ifcbuf == 0) {
2507	ifc32.ifc_len = 0;	2456	ifc32.ifc_len = 0;
2508	ifc.ifc_len = 0;	2457	ifc.ifc_len = 0;
2509	ifc.ifc_req = NULL;	2458	ifc.ifc_req = NULL;
2510	uifc = compat_alloc_user_space(sizeof(struct ifconf));	2459	uifc = compat_alloc_user_space(sizeof(struct ifconf));
2511	} else {	2460	} else {
2512	size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) *	2461	size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) *
2513	sizeof (struct ifreq);	2462	sizeof (struct ifreq);
2514	uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);	2463	uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2515	ifc.ifc_len = len;	2464	ifc.ifc_len = len;
2516	ifr = ifc.ifc_req = (void __user *)(uifc + 1);	2465	ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2517	ifr32 = compat_ptr(ifc32.ifcbuf);	2466	ifr32 = compat_ptr(ifc32.ifcbuf);
2518	for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) {	2467	for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) {
2519	if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))	2468	if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
2520	return -EFAULT;	2469	return -EFAULT;
2521	ifr++;	2470	ifr++;
2522	ifr32++;	2471	ifr32++;
2523	}	2472	}
2524	}	2473	}
2525	if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))	2474	if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2526	return -EFAULT;	2475	return -EFAULT;
2527		2476
2528	err = dev_ioctl(net, SIOCGIFCONF, uifc);	2477	err = dev_ioctl(net, SIOCGIFCONF, uifc);
2529	if (err)	2478	if (err)
2530	return err;	2479	return err;
2531		2480
2532	if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))	2481	if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2533	return -EFAULT;	2482	return -EFAULT;
2534		2483
2535	ifr = ifc.ifc_req;	2484	ifr = ifc.ifc_req;
2536	ifr32 = compat_ptr(ifc32.ifcbuf);	2485	ifr32 = compat_ptr(ifc32.ifcbuf);
2537	for (i = 0, j = 0;	2486	for (i = 0, j = 0;
2538	i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;	2487	i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2539	i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) {	2488	i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) {
2540	if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq)))	2489	if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq)))
2541	return -EFAULT;	2490	return -EFAULT;
2542	ifr32++;	2491	ifr32++;
2543	ifr++;	2492	ifr++;
2544	}	2493	}
2545		2494
2546	if (ifc32.ifcbuf == 0) {	2495	if (ifc32.ifcbuf == 0) {
2547	/* Translate from 64-bit structure multiple to	2496	/* Translate from 64-bit structure multiple to
2548	* a 32-bit one.	2497	* a 32-bit one.
2549	*/	2498	*/
2550	i = ifc.ifc_len;	2499	i = ifc.ifc_len;
2551	i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));	2500	i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
2552	ifc32.ifc_len = i;	2501	ifc32.ifc_len = i;
2553	} else {	2502	} else {
2554	ifc32.ifc_len = i;	2503	ifc32.ifc_len = i;
2555	}	2504	}
2556	if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))	2505	if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
2557	return -EFAULT;	2506	return -EFAULT;
2558		2507
2559	return 0;	2508	return 0;
2560	}	2509	}
2561		2510
2562	static int ethtool_ioctl(struct net net, struct compat_ifreq __user ifr32)	2511	static int ethtool_ioctl(struct net net, struct compat_ifreq __user ifr32)
2563	{	2512	{
2564	struct ifreq __user *ifr;	2513	struct ifreq __user *ifr;
2565	u32 data;	2514	u32 data;
2566	void __user *datap;	2515	void __user *datap;
2567		2516
2568	ifr = compat_alloc_user_space(sizeof(*ifr));	2517	ifr = compat_alloc_user_space(sizeof(*ifr));
2569		2518
2570	if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))	2519	if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2571	return -EFAULT;	2520	return -EFAULT;
2572		2521
2573	if (get_user(data, &ifr32->ifr_ifru.ifru_data))	2522	if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2574	return -EFAULT;	2523	return -EFAULT;
2575		2524
2576	datap = compat_ptr(data);	2525	datap = compat_ptr(data);
2577	if (put_user(datap, &ifr->ifr_ifru.ifru_data))	2526	if (put_user(datap, &ifr->ifr_ifru.ifru_data))
2578	return -EFAULT;	2527	return -EFAULT;
2579		2528
2580	return dev_ioctl(net, SIOCETHTOOL, ifr);	2529	return dev_ioctl(net, SIOCETHTOOL, ifr);
2581	}	2530	}
2582		2531
2583	static int compat_siocwandev(struct net net, struct compat_ifreq __user uifr32)	2532	static int compat_siocwandev(struct net net, struct compat_ifreq __user uifr32)
2584	{	2533	{
2585	void __user *uptr;	2534	void __user *uptr;
2586	compat_uptr_t uptr32;	2535	compat_uptr_t uptr32;
2587	struct ifreq __user *uifr;	2536	struct ifreq __user *uifr;
2588		2537
2589	uifr = compat_alloc_user_space(sizeof (*uifr));	2538	uifr = compat_alloc_user_space(sizeof (*uifr));
2590	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))	2539	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2591	return -EFAULT;	2540	return -EFAULT;
2592		2541
2593	if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))	2542	if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2594	return -EFAULT;	2543	return -EFAULT;
2595		2544
2596	uptr = compat_ptr(uptr32);	2545	uptr = compat_ptr(uptr32);
2597		2546
2598	if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))	2547	if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2599	return -EFAULT;	2548	return -EFAULT;
2600		2549
2601	return dev_ioctl(net, SIOCWANDEV, uifr);	2550	return dev_ioctl(net, SIOCWANDEV, uifr);
2602	}	2551	}
2603		2552
2604	static int bond_ioctl(struct net *net, unsigned int cmd,	2553	static int bond_ioctl(struct net *net, unsigned int cmd,
2605	struct compat_ifreq __user *ifr32)	2554	struct compat_ifreq __user *ifr32)
2606	{	2555	{
2607	struct ifreq kifr;	2556	struct ifreq kifr;
2608	struct ifreq __user *uifr;	2557	struct ifreq __user *uifr;
2609	mm_segment_t old_fs;	2558	mm_segment_t old_fs;
2610	int err;	2559	int err;
2611	u32 data;	2560	u32 data;
2612	void __user *datap;	2561	void __user *datap;
2613		2562
2614	switch (cmd) {	2563	switch (cmd) {
2615	case SIOCBONDENSLAVE:	2564	case SIOCBONDENSLAVE:
2616	case SIOCBONDRELEASE:	2565	case SIOCBONDRELEASE:
2617	case SIOCBONDSETHWADDR:	2566	case SIOCBONDSETHWADDR:
2618	case SIOCBONDCHANGEACTIVE:	2567	case SIOCBONDCHANGEACTIVE:
2619	if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))	2568	if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
2620	return -EFAULT;	2569	return -EFAULT;
2621		2570
2622	old_fs = get_fs();	2571	old_fs = get_fs();
2623	set_fs (KERNEL_DS);	2572	set_fs (KERNEL_DS);
2624	err = dev_ioctl(net, cmd, &kifr);	2573	err = dev_ioctl(net, cmd, &kifr);
2625	set_fs (old_fs);	2574	set_fs (old_fs);
2626		2575
2627	return err;	2576	return err;
2628	case SIOCBONDSLAVEINFOQUERY:	2577	case SIOCBONDSLAVEINFOQUERY:
2629	case SIOCBONDINFOQUERY:	2578	case SIOCBONDINFOQUERY:
2630	uifr = compat_alloc_user_space(sizeof(*uifr));	2579	uifr = compat_alloc_user_space(sizeof(*uifr));
2631	if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))	2580	if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2632	return -EFAULT;	2581	return -EFAULT;
2633		2582
2634	if (get_user(data, &ifr32->ifr_ifru.ifru_data))	2583	if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2635	return -EFAULT;	2584	return -EFAULT;
2636		2585
2637	datap = compat_ptr(data);	2586	datap = compat_ptr(data);
2638	if (put_user(datap, &uifr->ifr_ifru.ifru_data))	2587	if (put_user(datap, &uifr->ifr_ifru.ifru_data))
2639	return -EFAULT;	2588	return -EFAULT;
2640		2589
2641	return dev_ioctl(net, cmd, uifr);	2590	return dev_ioctl(net, cmd, uifr);
2642	default:	2591	default:
2643	return -EINVAL;	2592	return -EINVAL;
2644	};	2593	};
2645	}	2594	}
2646		2595
2647	static int siocdevprivate_ioctl(struct net *net, unsigned int cmd,	2596	static int siocdevprivate_ioctl(struct net *net, unsigned int cmd,
2648	struct compat_ifreq __user *u_ifreq32)	2597	struct compat_ifreq __user *u_ifreq32)
2649	{	2598	{
2650	struct ifreq __user *u_ifreq64;	2599	struct ifreq __user *u_ifreq64;
2651	char tmp_buf[IFNAMSIZ];	2600	char tmp_buf[IFNAMSIZ];
2652	void __user *data64;	2601	void __user *data64;
2653	u32 data32;	2602	u32 data32;
2654		2603
2655	if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),	2604	if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
2656	IFNAMSIZ))	2605	IFNAMSIZ))
2657	return -EFAULT;	2606	return -EFAULT;
2658	if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))	2607	if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
2659	return -EFAULT;	2608	return -EFAULT;
2660	data64 = compat_ptr(data32);	2609	data64 = compat_ptr(data32);
2661		2610
2662	u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));	2611	u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
2663		2612
2664	/* Don't check these user accesses, just let that get trapped	2613	/* Don't check these user accesses, just let that get trapped
2665	* in the ioctl handler instead.	2614	* in the ioctl handler instead.
2666	*/	2615	*/
2667	if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],	2616	if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
2668	IFNAMSIZ))	2617	IFNAMSIZ))
2669	return -EFAULT;	2618	return -EFAULT;
2670	if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))	2619	if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
2671	return -EFAULT;	2620	return -EFAULT;
2672		2621
2673	return dev_ioctl(net, cmd, u_ifreq64);	2622	return dev_ioctl(net, cmd, u_ifreq64);
2674	}	2623	}
2675		2624
2676	static int dev_ifsioc(struct net net, struct socket sock,	2625	static int dev_ifsioc(struct net net, struct socket sock,
2677	unsigned int cmd, struct compat_ifreq __user *uifr32)	2626	unsigned int cmd, struct compat_ifreq __user *uifr32)
2678	{	2627	{
2679	struct ifreq __user *uifr;	2628	struct ifreq __user *uifr;
2680	int err;	2629	int err;
2681		2630
2682	uifr = compat_alloc_user_space(sizeof(*uifr));	2631	uifr = compat_alloc_user_space(sizeof(*uifr));
2683	if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))	2632	if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
2684	return -EFAULT;	2633	return -EFAULT;
2685		2634
2686	err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);	2635	err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
2687		2636
2688	if (!err) {	2637	if (!err) {
2689	switch (cmd) {	2638	switch (cmd) {
2690	case SIOCGIFFLAGS:	2639	case SIOCGIFFLAGS:
2691	case SIOCGIFMETRIC:	2640	case SIOCGIFMETRIC:
2692	case SIOCGIFMTU:	2641	case SIOCGIFMTU:
2693	case SIOCGIFMEM:	2642	case SIOCGIFMEM:
2694	case SIOCGIFHWADDR:	2643	case SIOCGIFHWADDR:
2695	case SIOCGIFINDEX:	2644	case SIOCGIFINDEX:
2696	case SIOCGIFADDR:	2645	case SIOCGIFADDR:
2697	case SIOCGIFBRDADDR:	2646	case SIOCGIFBRDADDR:
2698	case SIOCGIFDSTADDR:	2647	case SIOCGIFDSTADDR:
2699	case SIOCGIFNETMASK:	2648	case SIOCGIFNETMASK:
2700	case SIOCGIFPFLAGS:	2649	case SIOCGIFPFLAGS:
2701	case SIOCGIFTXQLEN:	2650	case SIOCGIFTXQLEN:
2702	case SIOCGMIIPHY:	2651	case SIOCGMIIPHY:
2703	case SIOCGMIIREG:	2652	case SIOCGMIIREG:
2704	if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))	2653	if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
2705	err = -EFAULT;	2654	err = -EFAULT;
2706	break;	2655	break;
2707	}	2656	}
2708	}	2657	}
2709	return err;	2658	return err;
2710	}	2659	}
2711		2660
2712	static int compat_sioc_ifmap(struct net *net, unsigned int cmd,	2661	static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
2713	struct compat_ifreq __user *uifr32)	2662	struct compat_ifreq __user *uifr32)
2714	{	2663	{
2715	struct ifreq ifr;	2664	struct ifreq ifr;
2716	struct compat_ifmap __user *uifmap32;	2665	struct compat_ifmap __user *uifmap32;
2717	mm_segment_t old_fs;	2666	mm_segment_t old_fs;
2718	int err;	2667	int err;
2719		2668
2720	uifmap32 = &uifr32->ifr_ifru.ifru_map;	2669	uifmap32 = &uifr32->ifr_ifru.ifru_map;
2721	err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));	2670	err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
2722	err \|= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);	2671	err \|= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2723	err \|= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);	2672	err \|= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2724	err \|= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);	2673	err \|= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2725	err \|= __get_user(ifr.ifr_map.irq, &uifmap32->irq);	2674	err \|= __get_user(ifr.ifr_map.irq, &uifmap32->irq);
2726	err \|= __get_user(ifr.ifr_map.dma, &uifmap32->dma);	2675	err \|= __get_user(ifr.ifr_map.dma, &uifmap32->dma);
2727	err \|= __get_user(ifr.ifr_map.port, &uifmap32->port);	2676	err \|= __get_user(ifr.ifr_map.port, &uifmap32->port);
2728	if (err)	2677	if (err)
2729	return -EFAULT;	2678	return -EFAULT;
2730		2679
2731	old_fs = get_fs();	2680	old_fs = get_fs();
2732	set_fs (KERNEL_DS);	2681	set_fs (KERNEL_DS);
2733	err = dev_ioctl(net, cmd, (void __user *)&ifr);	2682	err = dev_ioctl(net, cmd, (void __user *)&ifr);
2734	set_fs (old_fs);	2683	set_fs (old_fs);
2735		2684
2736	if (cmd == SIOCGIFMAP && !err) {	2685	if (cmd == SIOCGIFMAP && !err) {
2737	err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));	2686	err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
2738	err \|= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);	2687	err \|= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2739	err \|= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);	2688	err \|= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2740	err \|= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);	2689	err \|= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2741	err \|= __put_user(ifr.ifr_map.irq, &uifmap32->irq);	2690	err \|= __put_user(ifr.ifr_map.irq, &uifmap32->irq);
2742	err \|= __put_user(ifr.ifr_map.dma, &uifmap32->dma);	2691	err \|= __put_user(ifr.ifr_map.dma, &uifmap32->dma);
2743	err \|= __put_user(ifr.ifr_map.port, &uifmap32->port);	2692	err \|= __put_user(ifr.ifr_map.port, &uifmap32->port);
2744	if (err)	2693	if (err)
2745	err = -EFAULT;	2694	err = -EFAULT;
2746	}	2695	}
2747	return err;	2696	return err;
2748	}	2697	}
2749		2698
2750	static int compat_siocshwtstamp(struct net net, struct compat_ifreq __user uifr32)	2699	static int compat_siocshwtstamp(struct net net, struct compat_ifreq __user uifr32)
2751	{	2700	{
2752	void __user *uptr;	2701	void __user *uptr;
2753	compat_uptr_t uptr32;	2702	compat_uptr_t uptr32;
2754	struct ifreq __user *uifr;	2703	struct ifreq __user *uifr;
2755		2704
2756	uifr = compat_alloc_user_space(sizeof (*uifr));	2705	uifr = compat_alloc_user_space(sizeof (*uifr));
2757	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))	2706	if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2758	return -EFAULT;	2707	return -EFAULT;
2759		2708
2760	if (get_user(uptr32, &uifr32->ifr_data))	2709	if (get_user(uptr32, &uifr32->ifr_data))
2761	return -EFAULT;	2710	return -EFAULT;
2762		2711
2763	uptr = compat_ptr(uptr32);	2712	uptr = compat_ptr(uptr32);
2764		2713
2765	if (put_user(uptr, &uifr->ifr_data))	2714	if (put_user(uptr, &uifr->ifr_data))
2766	return -EFAULT;	2715	return -EFAULT;
2767		2716
2768	return dev_ioctl(net, SIOCSHWTSTAMP, uifr);	2717	return dev_ioctl(net, SIOCSHWTSTAMP, uifr);
2769	}	2718	}
2770		2719
2771	struct rtentry32 {	2720	struct rtentry32 {
2772	u32 rt_pad1;	2721	u32 rt_pad1;
2773	struct sockaddr rt_dst; /* target address */	2722	struct sockaddr rt_dst; /* target address */
2774	struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */	2723	struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
2775	struct sockaddr rt_genmask; /* target network mask (IP) */	2724	struct sockaddr rt_genmask; /* target network mask (IP) */
2776	unsigned short rt_flags;	2725	unsigned short rt_flags;
2777	short rt_pad2;	2726	short rt_pad2;
2778	u32 rt_pad3;	2727	u32 rt_pad3;
2779	unsigned char rt_tos;	2728	unsigned char rt_tos;
2780	unsigned char rt_class;	2729	unsigned char rt_class;
2781	short rt_pad4;	2730	short rt_pad4;
2782	short rt_metric; /* +1 for binary compatibility! */	2731	short rt_metric; /* +1 for binary compatibility! */
2783	/* char * / u32 rt_dev; / forcing the device at add */	2732	/* char * / u32 rt_dev; / forcing the device at add */
2784	u32 rt_mtu; /* per route MTU/Window */	2733	u32 rt_mtu; /* per route MTU/Window */
2785	u32 rt_window; /* Window clamping */	2734	u32 rt_window; /* Window clamping */
2786	unsigned short rt_irtt; /* Initial RTT */	2735	unsigned short rt_irtt; /* Initial RTT */
2787	};	2736	};
2788		2737
2789	struct in6_rtmsg32 {	2738	struct in6_rtmsg32 {
2790	struct in6_addr rtmsg_dst;	2739	struct in6_addr rtmsg_dst;
2791	struct in6_addr rtmsg_src;	2740	struct in6_addr rtmsg_src;
2792	struct in6_addr rtmsg_gateway;	2741	struct in6_addr rtmsg_gateway;
2793	u32 rtmsg_type;	2742	u32 rtmsg_type;
2794	u16 rtmsg_dst_len;	2743	u16 rtmsg_dst_len;
2795	u16 rtmsg_src_len;	2744	u16 rtmsg_src_len;
2796	u32 rtmsg_metric;	2745	u32 rtmsg_metric;
2797	u32 rtmsg_info;	2746	u32 rtmsg_info;
2798	u32 rtmsg_flags;	2747	u32 rtmsg_flags;
2799	s32 rtmsg_ifindex;	2748	s32 rtmsg_ifindex;
2800	};	2749	};
2801		2750
2802	static int routing_ioctl(struct net net, struct socket sock,	2751	static int routing_ioctl(struct net net, struct socket sock,
2803	unsigned int cmd, void __user *argp)	2752	unsigned int cmd, void __user *argp)
2804	{	2753	{
2805	int ret;	2754	int ret;
2806	void *r = NULL;	2755	void *r = NULL;
2807	struct in6_rtmsg r6;	2756	struct in6_rtmsg r6;
2808	struct rtentry r4;	2757	struct rtentry r4;
2809	char devname[16];	2758	char devname[16];
2810	u32 rtdev;	2759	u32 rtdev;
2811	mm_segment_t old_fs = get_fs();	2760	mm_segment_t old_fs = get_fs();
2812		2761
2813	if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */	2762	if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
2814	struct in6_rtmsg32 __user *ur6 = argp;	2763	struct in6_rtmsg32 __user *ur6 = argp;
2815	ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst),	2764	ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst),
2816	3 * sizeof(struct in6_addr));	2765	3 * sizeof(struct in6_addr));
2817	ret \|= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type));	2766	ret \|= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type));
2818	ret \|= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));	2767	ret \|= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
2819	ret \|= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len));	2768	ret \|= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
2820	ret \|= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric));	2769	ret \|= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric));
2821	ret \|= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info));	2770	ret \|= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info));
2822	ret \|= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags));	2771	ret \|= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags));
2823	ret \|= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));	2772	ret \|= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
2824		2773
2825	r = (void *) &r6;	2774	r = (void *) &r6;
2826	} else { /* ipv4 */	2775	} else { /* ipv4 */
2827	struct rtentry32 __user *ur4 = argp;	2776	struct rtentry32 __user *ur4 = argp;
2828	ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst),	2777	ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst),
2829	3 * sizeof(struct sockaddr));	2778	3 * sizeof(struct sockaddr));
2830	ret \|= __get_user (r4.rt_flags, &(ur4->rt_flags));	2779	ret \|= __get_user (r4.rt_flags, &(ur4->rt_flags));
2831	ret \|= __get_user (r4.rt_metric, &(ur4->rt_metric));	2780	ret \|= __get_user (r4.rt_metric, &(ur4->rt_metric));
2832	ret \|= __get_user (r4.rt_mtu, &(ur4->rt_mtu));	2781	ret \|= __get_user (r4.rt_mtu, &(ur4->rt_mtu));
2833	ret \|= __get_user (r4.rt_window, &(ur4->rt_window));	2782	ret \|= __get_user (r4.rt_window, &(ur4->rt_window));
2834	ret \|= __get_user (r4.rt_irtt, &(ur4->rt_irtt));	2783	ret \|= __get_user (r4.rt_irtt, &(ur4->rt_irtt));
2835	ret \|= __get_user (rtdev, &(ur4->rt_dev));	2784	ret \|= __get_user (rtdev, &(ur4->rt_dev));
2836	if (rtdev) {	2785	if (rtdev) {
2837	ret \|= copy_from_user (devname, compat_ptr(rtdev), 15);	2786	ret \|= copy_from_user (devname, compat_ptr(rtdev), 15);
2838	r4.rt_dev = devname; devname[15] = 0;	2787	r4.rt_dev = devname; devname[15] = 0;
2839	} else	2788	} else
2840	r4.rt_dev = NULL;	2789	r4.rt_dev = NULL;
2841		2790
2842	r = (void *) &r4;	2791	r = (void *) &r4;
2843	}	2792	}
2844		2793
2845	if (ret) {	2794	if (ret) {
2846	ret = -EFAULT;	2795	ret = -EFAULT;
2847	goto out;	2796	goto out;
2848	}	2797	}
2849		2798
2850	set_fs (KERNEL_DS);	2799	set_fs (KERNEL_DS);
2851	ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);	2800	ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
2852	set_fs (old_fs);	2801	set_fs (old_fs);
2853		2802
2854	out:	2803	out:
2855	return ret;	2804	return ret;
2856	}	2805	}
2857		2806
2858	/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE	2807	/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
2859	* for some operations; this forces use of the newer bridge-utils that	2808	* for some operations; this forces use of the newer bridge-utils that
2860	* use compatiable ioctls	2809	* use compatiable ioctls
2861	*/	2810	*/
2862	static int old_bridge_ioctl(compat_ulong_t __user *argp)	2811	static int old_bridge_ioctl(compat_ulong_t __user *argp)
2863	{	2812	{
2864	compat_ulong_t tmp;	2813	compat_ulong_t tmp;
2865		2814
2866	if (get_user(tmp, argp))	2815	if (get_user(tmp, argp))
2867	return -EFAULT;	2816	return -EFAULT;
2868	if (tmp == BRCTL_GET_VERSION)	2817	if (tmp == BRCTL_GET_VERSION)
2869	return BRCTL_VERSION + 1;	2818	return BRCTL_VERSION + 1;
2870	return -EINVAL;	2819	return -EINVAL;
2871	}	2820	}
2872		2821
2873	static int compat_sock_ioctl_trans(struct file file, struct socket sock,	2822	static int compat_sock_ioctl_trans(struct file file, struct socket sock,
2874	unsigned int cmd, unsigned long arg)	2823	unsigned int cmd, unsigned long arg)
2875	{	2824	{
2876	void __user *argp = compat_ptr(arg);	2825	void __user *argp = compat_ptr(arg);
2877	struct sock *sk = sock->sk;	2826	struct sock *sk = sock->sk;
2878	struct net *net = sock_net(sk);	2827	struct net *net = sock_net(sk);
2879		2828
2880	if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))	2829	if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
2881	return siocdevprivate_ioctl(net, cmd, argp);	2830	return siocdevprivate_ioctl(net, cmd, argp);
2882		2831
2883	switch (cmd) {	2832	switch (cmd) {
2884	case SIOCSIFBR:	2833	case SIOCSIFBR:
2885	case SIOCGIFBR:	2834	case SIOCGIFBR:
2886	return old_bridge_ioctl(argp);	2835	return old_bridge_ioctl(argp);
2887	case SIOCGIFNAME:	2836	case SIOCGIFNAME:
2888	return dev_ifname32(net, argp);	2837	return dev_ifname32(net, argp);
2889	case SIOCGIFCONF:	2838	case SIOCGIFCONF:
2890	return dev_ifconf(net, argp);	2839	return dev_ifconf(net, argp);
2891	case SIOCETHTOOL:	2840	case SIOCETHTOOL:
2892	return ethtool_ioctl(net, argp);	2841	return ethtool_ioctl(net, argp);
2893	case SIOCWANDEV:	2842	case SIOCWANDEV:
2894	return compat_siocwandev(net, argp);	2843	return compat_siocwandev(net, argp);
2895	case SIOCGIFMAP:	2844	case SIOCGIFMAP:
2896	case SIOCSIFMAP:	2845	case SIOCSIFMAP:
2897	return compat_sioc_ifmap(net, cmd, argp);	2846	return compat_sioc_ifmap(net, cmd, argp);
2898	case SIOCBONDENSLAVE:	2847	case SIOCBONDENSLAVE:
2899	case SIOCBONDRELEASE:	2848	case SIOCBONDRELEASE:
2900	case SIOCBONDSETHWADDR:	2849	case SIOCBONDSETHWADDR:
2901	case SIOCBONDSLAVEINFOQUERY:	2850	case SIOCBONDSLAVEINFOQUERY:
2902	case SIOCBONDINFOQUERY:	2851	case SIOCBONDINFOQUERY:
2903	case SIOCBONDCHANGEACTIVE:	2852	case SIOCBONDCHANGEACTIVE:
2904	return bond_ioctl(net, cmd, argp);	2853	return bond_ioctl(net, cmd, argp);
2905	case SIOCADDRT:	2854	case SIOCADDRT:
2906	case SIOCDELRT:	2855	case SIOCDELRT:
2907	return routing_ioctl(net, sock, cmd, argp);	2856	return routing_ioctl(net, sock, cmd, argp);
2908	case SIOCGSTAMP:	2857	case SIOCGSTAMP:
2909	return do_siocgstamp(net, sock, cmd, argp);	2858	return do_siocgstamp(net, sock, cmd, argp);
2910	case SIOCGSTAMPNS:	2859	case SIOCGSTAMPNS:
2911	return do_siocgstampns(net, sock, cmd, argp);	2860	return do_siocgstampns(net, sock, cmd, argp);
2912	case SIOCSHWTSTAMP:	2861	case SIOCSHWTSTAMP:
2913	return compat_siocshwtstamp(net, argp);	2862	return compat_siocshwtstamp(net, argp);
2914		2863
2915	case FIOSETOWN:	2864	case FIOSETOWN:
2916	case SIOCSPGRP:	2865	case SIOCSPGRP:
2917	case FIOGETOWN:	2866	case FIOGETOWN:
2918	case SIOCGPGRP:	2867	case SIOCGPGRP:
2919	case SIOCBRADDBR:	2868	case SIOCBRADDBR:
2920	case SIOCBRDELBR:	2869	case SIOCBRDELBR:
2921	case SIOCGIFVLAN:	2870	case SIOCGIFVLAN:
2922	case SIOCSIFVLAN:	2871	case SIOCSIFVLAN:
2923	case SIOCADDDLCI:	2872	case SIOCADDDLCI:
2924	case SIOCDELDLCI:	2873	case SIOCDELDLCI:
2925	return sock_ioctl(file, cmd, arg);	2874	return sock_ioctl(file, cmd, arg);
2926		2875
2927	case SIOCGIFFLAGS:	2876	case SIOCGIFFLAGS:
2928	case SIOCSIFFLAGS:	2877	case SIOCSIFFLAGS:
2929	case SIOCGIFMETRIC:	2878	case SIOCGIFMETRIC:
2930	case SIOCSIFMETRIC:	2879	case SIOCSIFMETRIC:
2931	case SIOCGIFMTU:	2880	case SIOCGIFMTU:
2932	case SIOCSIFMTU:	2881	case SIOCSIFMTU:
2933	case SIOCGIFMEM:	2882	case SIOCGIFMEM:
2934	case SIOCSIFMEM:	2883	case SIOCSIFMEM:
2935	case SIOCGIFHWADDR:	2884	case SIOCGIFHWADDR:
2936	case SIOCSIFHWADDR:	2885	case SIOCSIFHWADDR:
2937	case SIOCADDMULTI:	2886	case SIOCADDMULTI:
2938	case SIOCDELMULTI:	2887	case SIOCDELMULTI:
2939	case SIOCGIFINDEX:	2888	case SIOCGIFINDEX:
2940	case SIOCGIFADDR:	2889	case SIOCGIFADDR:
2941	case SIOCSIFADDR:	2890	case SIOCSIFADDR:
2942	case SIOCSIFHWBROADCAST:	2891	case SIOCSIFHWBROADCAST:
2943	case SIOCDIFADDR:	2892	case SIOCDIFADDR:
2944	case SIOCGIFBRDADDR:	2893	case SIOCGIFBRDADDR:
2945	case SIOCSIFBRDADDR:	2894	case SIOCSIFBRDADDR:
2946	case SIOCGIFDSTADDR:	2895	case SIOCGIFDSTADDR:
2947	case SIOCSIFDSTADDR:	2896	case SIOCSIFDSTADDR:
2948	case SIOCGIFNETMASK:	2897	case SIOCGIFNETMASK:
2949	case SIOCSIFNETMASK:	2898	case SIOCSIFNETMASK:
2950	case SIOCSIFPFLAGS:	2899	case SIOCSIFPFLAGS:
2951	case SIOCGIFPFLAGS:	2900	case SIOCGIFPFLAGS:
2952	case SIOCGIFTXQLEN:	2901	case SIOCGIFTXQLEN:
2953	case SIOCSIFTXQLEN:	2902	case SIOCSIFTXQLEN:
2954	case SIOCBRADDIF:	2903	case SIOCBRADDIF:
2955	case SIOCBRDELIF:	2904	case SIOCBRDELIF:
2956	case SIOCSIFNAME:	2905	case SIOCSIFNAME:
2957	case SIOCGMIIPHY:	2906	case SIOCGMIIPHY:
2958	case SIOCGMIIREG:	2907	case SIOCGMIIREG:
2959	case SIOCSMIIREG:	2908	case SIOCSMIIREG:
2960	return dev_ifsioc(net, sock, cmd, argp);	2909	return dev_ifsioc(net, sock, cmd, argp);
2961		2910
2962	case SIOCSARP:	2911	case SIOCSARP:
2963	case SIOCGARP:	2912	case SIOCGARP:
2964	case SIOCDARP:	2913	case SIOCDARP:
2965	case SIOCATMARK:	2914	case SIOCATMARK:
2966	return sock_do_ioctl(net, sock, cmd, arg);	2915	return sock_do_ioctl(net, sock, cmd, arg);
2967	}	2916	}
2968		2917
2969	/* Prevent warning from compat_sys_ioctl, these always	2918	/* Prevent warning from compat_sys_ioctl, these always
2970	* result in -EINVAL in the native case anyway. */	2919	* result in -EINVAL in the native case anyway. */
2971	switch (cmd) {	2920	switch (cmd) {
2972	case SIOCRTMSG:	2921	case SIOCRTMSG:
2973	case SIOCGIFCOUNT:	2922	case SIOCGIFCOUNT:
2974	case SIOCSRARP:	2923	case SIOCSRARP:
2975	case SIOCGRARP:	2924	case SIOCGRARP:
2976	case SIOCDRARP:	2925	case SIOCDRARP:
2977	case SIOCSIFLINK:	2926	case SIOCSIFLINK:
2978	case SIOCGIFSLAVE:	2927	case SIOCGIFSLAVE:
2979	case SIOCSIFSLAVE:	2928	case SIOCSIFSLAVE:
2980	return -EINVAL;	2929	return -EINVAL;
2981	}	2930	}
2982		2931
2983	return -ENOIOCTLCMD;	2932	return -ENOIOCTLCMD;
2984	}	2933	}
2985		2934
2986	static long compat_sock_ioctl(struct file *file, unsigned cmd,	2935	static long compat_sock_ioctl(struct file *file, unsigned cmd,
2987	unsigned long arg)	2936	unsigned long arg)
2988	{	2937	{
2989	struct socket *sock = file->private_data;	2938	struct socket *sock = file->private_data;
2990	int ret = -ENOIOCTLCMD;	2939	int ret = -ENOIOCTLCMD;
2991	struct sock *sk;	2940	struct sock *sk;
2992	struct net *net;	2941	struct net *net;
2993		2942
2994	sk = sock->sk;	2943	sk = sock->sk;
2995	net = sock_net(sk);	2944	net = sock_net(sk);
2996		2945
2997	if (sock->ops->compat_ioctl)	2946	if (sock->ops->compat_ioctl)
2998	ret = sock->ops->compat_ioctl(sock, cmd, arg);	2947	ret = sock->ops->compat_ioctl(sock, cmd, arg);
2999		2948
3000	if (ret == -ENOIOCTLCMD &&	2949	if (ret == -ENOIOCTLCMD &&
3001	(cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))	2950	(cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3002	ret = compat_wext_handle_ioctl(net, cmd, arg);	2951	ret = compat_wext_handle_ioctl(net, cmd, arg);
3003		2952
3004	if (ret == -ENOIOCTLCMD)	2953	if (ret == -ENOIOCTLCMD)
3005	ret = compat_sock_ioctl_trans(file, sock, cmd, arg);	2954	ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3006		2955
3007	return ret;	2956	return ret;
3008	}	2957	}
3009	#endif	2958	#endif
3010		2959
3011	int kernel_bind(struct socket sock, struct sockaddr addr, int addrlen)	2960	int kernel_bind(struct socket sock, struct sockaddr addr, int addrlen)
3012	{	2961	{
3013	return sock->ops->bind(sock, addr, addrlen);	2962	return sock->ops->bind(sock, addr, addrlen);
3014	}	2963	}
3015		2964
3016	int kernel_listen(struct socket *sock, int backlog)	2965	int kernel_listen(struct socket *sock, int backlog)
3017	{	2966	{
3018	return sock->ops->listen(sock, backlog);	2967	return sock->ops->listen(sock, backlog);
3019	}	2968	}
3020		2969
3021	int kernel_accept(struct socket sock, struct socket *newsock, int flags)	2970	int kernel_accept(struct socket sock, struct socket *newsock, int flags)
3022	{	2971	{
3023	struct sock *sk = sock->sk;	2972	struct sock *sk = sock->sk;
3024	int err;	2973	int err;
3025		2974
3026	err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,	2975	err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3027	newsock);	2976	newsock);
3028	if (err < 0)	2977	if (err < 0)
3029	goto done;	2978	goto done;
3030		2979
3031	err = sock->ops->accept(sock, *newsock, flags);	2980	err = sock->ops->accept(sock, *newsock, flags);
3032	if (err < 0) {	2981	if (err < 0) {
3033	sock_release(*newsock);	2982	sock_release(*newsock);
3034	*newsock = NULL;	2983	*newsock = NULL;
3035	goto done;	2984	goto done;
3036	}	2985	}
3037		2986
3038	(*newsock)->ops = sock->ops;	2987	(*newsock)->ops = sock->ops;
3039	__module_get((*newsock)->ops->owner);	2988	__module_get((*newsock)->ops->owner);
3040		2989
3041	done:	2990	done:
3042	return err;	2991	return err;
3043	}	2992	}
3044		2993
3045	int kernel_connect(struct socket sock, struct sockaddr addr, int addrlen,	2994	int kernel_connect(struct socket sock, struct sockaddr addr, int addrlen,
3046	int flags)	2995	int flags)
3047	{	2996	{
3048	return sock->ops->connect(sock, addr, addrlen, flags);	2997	return sock->ops->connect(sock, addr, addrlen, flags);
3049	}	2998	}
3050		2999
3051	int kernel_getsockname(struct socket sock, struct sockaddr addr,	3000	int kernel_getsockname(struct socket sock, struct sockaddr addr,
3052	int *addrlen)	3001	int *addrlen)
3053	{	3002	{
3054	return sock->ops->getname(sock, addr, addrlen, 0);	3003	return sock->ops->getname(sock, addr, addrlen, 0);
3055	}	3004	}
3056		3005
3057	int kernel_getpeername(struct socket sock, struct sockaddr addr,	3006	int kernel_getpeername(struct socket sock, struct sockaddr addr,
3058	int *addrlen)	3007	int *addrlen)
3059	{	3008	{
3060	return sock->ops->getname(sock, addr, addrlen, 1);	3009	return sock->ops->getname(sock, addr, addrlen, 1);
3061	}	3010	}
3062		3011
3063	int kernel_getsockopt(struct socket *sock, int level, int optname,	3012	int kernel_getsockopt(struct socket *sock, int level, int optname,
3064	char optval, int optlen)	3013	char optval, int optlen)
3065	{	3014	{
3066	mm_segment_t oldfs = get_fs();	3015	mm_segment_t oldfs = get_fs();
3067	int err;	3016	int err;
3068		3017
3069	set_fs(KERNEL_DS);	3018	set_fs(KERNEL_DS);
3070	if (level == SOL_SOCKET)	3019	if (level == SOL_SOCKET)
3071	err = sock_getsockopt(sock, level, optname, optval, optlen);	3020	err = sock_getsockopt(sock, level, optname, optval, optlen);
3072	else	3021	else
3073	err = sock->ops->getsockopt(sock, level, optname, optval,	3022	err = sock->ops->getsockopt(sock, level, optname, optval,
3074	optlen);	3023	optlen);
3075	set_fs(oldfs);	3024	set_fs(oldfs);
3076	return err;	3025	return err;
3077	}	3026	}
3078		3027
3079	int kernel_setsockopt(struct socket *sock, int level, int optname,	3028	int kernel_setsockopt(struct socket *sock, int level, int optname,
3080	char *optval, unsigned int optlen)	3029	char *optval, unsigned int optlen)
3081	{	3030	{
3082	mm_segment_t oldfs = get_fs();	3031	mm_segment_t oldfs = get_fs();
3083	int err;	3032	int err;
3084		3033
3085	set_fs(KERNEL_DS);	3034	set_fs(KERNEL_DS);
3086	if (level == SOL_SOCKET)	3035	if (level == SOL_SOCKET)
3087	err = sock_setsockopt(sock, level, optname, optval, optlen);	3036	err = sock_setsockopt(sock, level, optname, optval, optlen);
3088	else	3037	else
3089	err = sock->ops->setsockopt(sock, level, optname, optval,	3038	err = sock->ops->setsockopt(sock, level, optname, optval,
3090	optlen);	3039	optlen);
3091	set_fs(oldfs);	3040	set_fs(oldfs);
3092	return err;	3041	return err;
3093	}	3042	}
3094		3043
3095	int kernel_sendpage(struct socket sock, struct page page, int offset,	3044	int kernel_sendpage(struct socket sock, struct page page, int offset,
3096	size_t size, int flags)	3045	size_t size, int flags)
3097	{	3046	{
3098	if (sock->ops->sendpage)	3047	if (sock->ops->sendpage)
3099	return sock->ops->sendpage(sock, page, offset, size, flags);	3048	return sock->ops->sendpage(sock, page, offset, size, flags);
3100		3049
3101	return sock_no_sendpage(sock, page, offset, size, flags);	3050	return sock_no_sendpage(sock, page, offset, size, flags);
3102	}	3051	}
3103		3052
3104	int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)	3053	int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
3105	{	3054	{
3106	mm_segment_t oldfs = get_fs();	3055	mm_segment_t oldfs = get_fs();
3107	int err;	3056	int err;
3108		3057
3109	set_fs(KERNEL_DS);	3058	set_fs(KERNEL_DS);
3110	err = sock->ops->ioctl(sock, cmd, arg);	3059	err = sock->ops->ioctl(sock, cmd, arg);
3111	set_fs(oldfs);	3060	set_fs(oldfs);
3112		3061
3113	return err;	3062	return err;
3114	}	3063	}
3115		3064
3116	int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)	3065	int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3117	{	3066	{
3118	return sock->ops->shutdown(sock, how);	3067	return sock->ops->shutdown(sock, how);
3119	}	3068	}
3120		3069
3121	EXPORT_SYMBOL(sock_create);	3070	EXPORT_SYMBOL(sock_create);
3122	EXPORT_SYMBOL(sock_create_kern);	3071	EXPORT_SYMBOL(sock_create_kern);
3123	EXPORT_SYMBOL(sock_create_lite);	3072	EXPORT_SYMBOL(sock_create_lite);
3124	EXPORT_SYMBOL(sock_map_fd);	3073	EXPORT_SYMBOL(sock_map_fd);
3125	EXPORT_SYMBOL(sock_recvmsg);	3074	EXPORT_SYMBOL(sock_recvmsg);
3126	EXPORT_SYMBOL(sock_register);	3075	EXPORT_SYMBOL(sock_register);
3127	EXPORT_SYMBOL(sock_release);	3076	EXPORT_SYMBOL(sock_release);
3128	EXPORT_SYMBOL(sock_sendmsg);	3077	EXPORT_SYMBOL(sock_sendmsg);
3129	EXPORT_SYMBOL(sock_unregister);	3078	EXPORT_SYMBOL(sock_unregister);
3130	EXPORT_SYMBOL(sock_wake_async);	3079	EXPORT_SYMBOL(sock_wake_async);
3131	EXPORT_SYMBOL(sockfd_lookup);	3080	EXPORT_SYMBOL(sockfd_lookup);
3132	EXPORT_SYMBOL(kernel_sendmsg);	3081	EXPORT_SYMBOL(kernel_sendmsg);
3133	EXPORT_SYMBOL(kernel_recvmsg);	3082	EXPORT_SYMBOL(kernel_recvmsg);
3134	EXPORT_SYMBOL(kernel_bind);	3083	EXPORT_SYMBOL(kernel_bind);
3135	EXPORT_SYMBOL(kernel_listen);	3084	EXPORT_SYMBOL(kernel_listen);
3136	EXPORT_SYMBOL(kernel_accept);	3085	EXPORT_SYMBOL(kernel_accept);
3137	EXPORT_SYMBOL(kernel_connect);	3086	EXPORT_SYMBOL(kernel_connect);
3138	EXPORT_SYMBOL(kernel_getsockname);	3087	EXPORT_SYMBOL(kernel_getsockname);
3139	EXPORT_SYMBOL(kernel_getpeername);	3088	EXPORT_SYMBOL(kernel_getpeername);
3140	EXPORT_SYMBOL(kernel_getsockopt);	3089	EXPORT_SYMBOL(kernel_getsockopt);
3141	EXPORT_SYMBOL(kernel_setsockopt);	3090	EXPORT_SYMBOL(kernel_setsockopt);
3142	EXPORT_SYMBOL(kernel_sendpage);	3091	EXPORT_SYMBOL(kernel_sendpage);
3143	EXPORT_SYMBOL(kernel_sock_ioctl);	3092	EXPORT_SYMBOL(kernel_sock_ioctl);
3144	EXPORT_SYMBOL(kernel_sock_shutdown);	3093	EXPORT_SYMBOL(kernel_sock_shutdown);
3145		3094