socket.c 93 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7
/*
 * NET		An implementation of the SOCKET network access protocol.
 *
 * Version:	@(#)socket.c	1.1.93	18/02/95
 *
 * Authors:	Orest Zborowski, <obz@Kodak.COM>
8
 *		Ross Biro
Linus Torvalds's avatar
Linus Torvalds committed
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *
 * Fixes:
 *		Anonymous	:	NOTSOCK/BADF cleanup. Error fix in
 *					shutdown()
 *		Alan Cox	:	verify_area() fixes
 *		Alan Cox	:	Removed DDI
 *		Jonathan Kamens	:	SOCK_DGRAM reconnect bug
 *		Alan Cox	:	Moved a load of checks to the very
 *					top level.
 *		Alan Cox	:	Move address structures to/from user
 *					mode above the protocol layers.
 *		Rob Janssen	:	Allow 0 length sends.
 *		Alan Cox	:	Asynchronous I/O support (cribbed from the
 *					tty drivers).
 *		Niibe Yutaka	:	Asynchronous I/O for writes (4.4BSD style)
 *		Jeff Uphoff	:	Made max number of sockets command-line
 *					configurable.
 *		Matti Aarnio	:	Made the number of sockets dynamic,
 *					to be allocated when needed, and mr.
 *					Uphoff's max is used as max to be
 *					allowed to allocate.
 *		Linus		:	Argh. removed all the socket allocation
 *					altogether: it's in the inode now.
 *		Alan Cox	:	Made sock_alloc()/sock_release() public
 *					for NetROM and future kernel nfsd type
 *					stuff.
 *		Alan Cox	:	sendmsg/recvmsg basics.
 *		Tom Dyas	:	Export net symbols.
 *		Marcin Dalecki	:	Fixed problems with CONFIG_NET="n".
 *		Alan Cox	:	Added thread locking to sys_* calls
 *					for sockets. May have errors at the
 *					moment.
 *		Kevin Buhr	:	Fixed the dumb errors in the above.
 *		Andi Kleen	:	Some small cleanups, optimizations,
 *					and fixed a copy_from_user() bug.
 *		Tigran Aivazian	:	sys_send(args) calls sys_sendto(args, NULL, 0)
46
 *		Tigran Aivazian	:	Made listen(2) backlog sanity checks
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49
 *					protocol-independent
 *
 *	This module is effectively the top level interface to the BSD socket
50
 *	paradigm.
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55 56 57 58 59
 *
 *	Based upon Swansea University Computer Society NET3.039
 */

#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/file.h>
#include <linux/net.h>
#include <linux/interrupt.h>
Ulrich Drepper's avatar
Ulrich Drepper committed
60
#include <linux/thread_info.h>
61
#include <linux/rcupdate.h>
Linus Torvalds's avatar
Linus Torvalds committed
62 63 64
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
65
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
66
#include <linux/if_bridge.h>
67 68
#include <linux/if_frad.h>
#include <linux/if_vlan.h>
69
#include <linux/ptp_classify.h>
Linus Torvalds's avatar
Linus Torvalds committed
70 71 72 73 74 75
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/cache.h>
#include <linux/module.h>
#include <linux/highmem.h>
#include <linux/mount.h>
76
#include <linux/pseudo_fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/compat.h>
#include <linux/kmod.h>
81
#include <linux/audit.h>
82
#include <linux/wireless.h>
83
#include <linux/nsproxy.h>
Nick Black's avatar
Nick Black committed
84
#include <linux/magic.h>
85
#include <linux/slab.h>
86
#include <linux/xattr.h>
87
#include <linux/nospec.h>
88
#include <linux/indirect_call_wrapper.h>
Linus Torvalds's avatar
Linus Torvalds committed
89

90
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93
#include <asm/unistd.h>

#include <net/compat.h>
94
#include <net/wext.h>
95
#include <net/cls_cgroup.h>
Linus Torvalds's avatar
Linus Torvalds committed
96 97 98 99

#include <net/sock.h>
#include <linux/netfilter.h>

100 101 102 103
#include <linux/if_tun.h>
#include <linux/ipv6_route.h>
#include <linux/route.h>
#include <linux/sockios.h>
104
#include <net/busy_poll.h>
105
#include <linux/errqueue.h>
106

107
#ifdef CONFIG_NET_RX_BUSY_POLL
108 109
unsigned int sysctl_net_busy_read __read_mostly;
unsigned int sysctl_net_busy_poll __read_mostly;
110
#endif
111

112 113
static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
114
static int sock_mmap(struct file *file, struct vm_area_struct *vma);
Linus Torvalds's avatar
Linus Torvalds committed
115 116

static int sock_close(struct inode *inode, struct file *file);
117 118
static __poll_t sock_poll(struct file *file,
			      struct poll_table_struct *wait);
119
static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
120 121
#ifdef CONFIG_COMPAT
static long compat_sock_ioctl(struct file *file,
122
			      unsigned int cmd, unsigned long arg);
123
#endif
Linus Torvalds's avatar
Linus Torvalds committed
124 125 126
static int sock_fasync(int fd, struct file *filp, int on);
static ssize_t sock_sendpage(struct file *file, struct page *page,
			     int offset, size_t size, loff_t *ppos, int more);
Jens Axboe's avatar
Jens Axboe committed
127
static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
128
				struct pipe_inode_info *pipe, size_t len,
Jens Axboe's avatar
Jens Axboe committed
129
				unsigned int flags);
Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133 134 135

/*
 *	Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
 *	in the operation structures but are done directly via the socketcall() multiplexor.
 */

136
static const struct file_operations socket_file_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
137 138
	.owner =	THIS_MODULE,
	.llseek =	no_llseek,
139 140
	.read_iter =	sock_read_iter,
	.write_iter =	sock_write_iter,
Linus Torvalds's avatar
Linus Torvalds committed
141 142
	.poll =		sock_poll,
	.unlocked_ioctl = sock_ioctl,
143 144 145
#ifdef CONFIG_COMPAT
	.compat_ioctl = compat_sock_ioctl,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
146 147 148
	.mmap =		sock_mmap,
	.release =	sock_close,
	.fasync =	sock_fasync,
149 150
	.sendpage =	sock_sendpage,
	.splice_write = generic_splice_sendpage,
Jens Axboe's avatar
Jens Axboe committed
151
	.splice_read =	sock_splice_read,
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155 156 157 158
};

/*
 *	The protocol list. Each protocol is registered in here.
 */

static DEFINE_SPINLOCK(net_family_lock);
159
static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
160 161

/*
162 163 164
 * Support routines.
 * Move socket addresses back and forth across the kernel/user
 * divide and look after the messy bits.
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170 171 172 173 174 175 176 177
 */

/**
 *	move_addr_to_kernel	-	copy a socket address into kernel space
 *	@uaddr: Address in user space
 *	@kaddr: Address in kernel space
 *	@ulen: Length in user space
 *
 *	The address is copied into kernel space. If the provided address is
 *	too long an error code of -EINVAL is returned. If the copy gives
 *	invalid addresses -EFAULT is returned. On a success 0 is returned.
 */

178
int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
Linus Torvalds's avatar
Linus Torvalds committed
179
{
180
	if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
Linus Torvalds's avatar
Linus Torvalds committed
181
		return -EINVAL;
182
	if (ulen == 0)
Linus Torvalds's avatar
Linus Torvalds committed
183
		return 0;
184
	if (copy_from_user(kaddr, uaddr, ulen))
Linus Torvalds's avatar
Linus Torvalds committed
185
		return -EFAULT;
186
	return audit_sockaddr(ulen, kaddr);
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
}

/**
 *	move_addr_to_user	-	copy an address to user space
 *	@kaddr: kernel space address
 *	@klen: length of address in kernel
 *	@uaddr: user space address
 *	@ulen: pointer to user length field
 *
 *	The value pointed to by ulen on entry is the buffer length available.
 *	This is overwritten with the buffer space used. -EINVAL is returned
 *	if an overlong buffer is specified or a negative buffer size. -EFAULT
 *	is returned if either the buffer or the length field are not
 *	accessible.
 *	After copying the data up to the limit the user specifies, the true
 *	length of the data is written over the length limit the user
 *	specified. Zero is returned for a success.
 */
205

206
static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
207
			     void __user *uaddr, int __user *ulen)
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211
{
	int err;
	int len;

212
	BUG_ON(klen > sizeof(struct sockaddr_storage));
213 214
	err = get_user(len, ulen);
	if (err)
Linus Torvalds's avatar
Linus Torvalds committed
215
		return err;
216 217
	if (len > klen)
		len = klen;
218
	if (len < 0)
Linus Torvalds's avatar
Linus Torvalds committed
219
		return -EINVAL;
220
	if (len) {
Steve Grubb's avatar
Steve Grubb committed
221 222
		if (audit_sockaddr(klen, kaddr))
			return -ENOMEM;
223
		if (copy_to_user(uaddr, kaddr, len))
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
			return -EFAULT;
	}
	/*
227 228
	 *      "fromlen shall refer to the value before truncation.."
	 *                      1003.1g
Linus Torvalds's avatar
Linus Torvalds committed
229 230 231 232
	 */
	return __put_user(klen, ulen);
}

233
static struct kmem_cache *sock_inode_cachep __ro_after_init;
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236 237

static struct inode *sock_alloc_inode(struct super_block *sb)
{
	struct socket_alloc *ei;
238

239
	ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
240 241
	if (!ei)
		return NULL;
242 243 244
	init_waitqueue_head(&ei->socket.wq.wait);
	ei->socket.wq.fasync_list = NULL;
	ei->socket.wq.flags = 0;
245

Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249 250 251 252 253 254
	ei->socket.state = SS_UNCONNECTED;
	ei->socket.flags = 0;
	ei->socket.ops = NULL;
	ei->socket.sk = NULL;
	ei->socket.file = NULL;

	return &ei->vfs_inode;
}

Al Viro's avatar
Al Viro committed
255
static void sock_free_inode(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
256
{
257 258 259 260
	struct socket_alloc *ei;

	ei = container_of(inode, struct socket_alloc, vfs_inode);
	kmem_cache_free(sock_inode_cachep, ei);
Linus Torvalds's avatar
Linus Torvalds committed
261 262
}

263
static void init_once(void *foo)
Linus Torvalds's avatar
Linus Torvalds committed
264
{
265
	struct socket_alloc *ei = (struct socket_alloc *)foo;
Linus Torvalds's avatar
Linus Torvalds committed
266

267
	inode_init_once(&ei->vfs_inode);
Linus Torvalds's avatar
Linus Torvalds committed
268
}
269

270
static void init_inodecache(void)
Linus Torvalds's avatar
Linus Torvalds committed
271 272
{
	sock_inode_cachep = kmem_cache_create("sock_inode_cache",
273 274 275 276
					      sizeof(struct socket_alloc),
					      0,
					      (SLAB_HWCACHE_ALIGN |
					       SLAB_RECLAIM_ACCOUNT |
277
					       SLAB_MEM_SPREAD | SLAB_ACCOUNT),
278
					      init_once);
279
	BUG_ON(sock_inode_cachep == NULL);
Linus Torvalds's avatar
Linus Torvalds committed
280 281
}

282
static const struct super_operations sockfs_ops = {
283
	.alloc_inode	= sock_alloc_inode,
Al Viro's avatar
Al Viro committed
284
	.free_inode	= sock_free_inode,
285
	.statfs		= simple_statfs,
Linus Torvalds's avatar
Linus Torvalds committed
286 287
};

288 289 290 291 292 293
/*
 * sockfs_dname() is called from d_path().
 */
static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
{
	return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
294
				d_inode(dentry)->i_ino);
295 296
}

Al Viro's avatar
Al Viro committed
297
static const struct dentry_operations sockfs_dentry_operations = {
298
	.d_dname  = sockfs_dname,
Linus Torvalds's avatar
Linus Torvalds committed
299 300
};

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
static int sockfs_xattr_get(const struct xattr_handler *handler,
			    struct dentry *dentry, struct inode *inode,
			    const char *suffix, void *value, size_t size)
{
	if (value) {
		if (dentry->d_name.len + 1 > size)
			return -ERANGE;
		memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
	}
	return dentry->d_name.len + 1;
}

#define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
#define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
#define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)

static const struct xattr_handler sockfs_xattr_handler = {
	.name = XATTR_NAME_SOCKPROTONAME,
	.get = sockfs_xattr_get,
};

322 323 324 325 326 327 328 329 330 331 332 333 334 335
static int sockfs_security_xattr_set(const struct xattr_handler *handler,
				     struct dentry *dentry, struct inode *inode,
				     const char *suffix, const void *value,
				     size_t size, int flags)
{
	/* Handled by LSM. */
	return -EAGAIN;
}

static const struct xattr_handler sockfs_security_xattr_handler = {
	.prefix = XATTR_SECURITY_PREFIX,
	.set = sockfs_security_xattr_set,
};

336 337
static const struct xattr_handler *sockfs_xattr_handlers[] = {
	&sockfs_xattr_handler,
338
	&sockfs_security_xattr_handler,
339 340 341
	NULL
};

342
static int sockfs_init_fs_context(struct fs_context *fc)
343
{
344 345 346 347 348 349 350
	struct pseudo_fs_context *ctx = init_pseudo(fc, SOCKFS_MAGIC);
	if (!ctx)
		return -ENOMEM;
	ctx->ops = &sockfs_ops;
	ctx->dops = &sockfs_dentry_operations;
	ctx->xattr = sockfs_xattr_handlers;
	return 0;
351 352 353 354 355 356
}

static struct vfsmount *sock_mnt __read_mostly;

static struct file_system_type sock_fs_type = {
	.name =		"sockfs",
357
	.init_fs_context = sockfs_init_fs_context,
358 359 360
	.kill_sb =	kill_anon_super,
};

Linus Torvalds's avatar
Linus Torvalds committed
361 362 363
/*
 *	Obtains the first available file descriptor and sets it up for use.
 *
364 365
 *	These functions create file structures and maps them to fd space
 *	of the current process. On success it returns file descriptor
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372 373 374 375 376 377
 *	and file struct implicitly stored in sock->file.
 *	Note that another thread may close file descriptor before we return
 *	from this function. We use the fact that now we do not refer
 *	to socket after mapping. If one day we will need it, this
 *	function will increment ref. count on file by 1.
 *
 *	In any case returned fd MAY BE not valid!
 *	This race condition is unavoidable
 *	with shared fd spaces, we cannot solve it inside kernel,
 *	but we take care of internal coherence yet.
 */

378 379 380 381 382 383 384 385 386 387 388 389
/**
 *	sock_alloc_file - Bind a &socket to a &file
 *	@sock: socket
 *	@flags: file status flags
 *	@dname: protocol name
 *
 *	Returns the &file bound with @sock, implicitly storing it
 *	in sock->file. If dname is %NULL, sets to "".
 *	On failure the return is a ERR pointer (see linux/err.h).
 *	This function uses GFP_KERNEL internally.
 */

390
struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
Linus Torvalds's avatar
Linus Torvalds committed
391
{
392
	struct file *file;
Linus Torvalds's avatar
Linus Torvalds committed
393

Al Viro's avatar
Al Viro committed
394 395
	if (!dname)
		dname = sock->sk ? sock->sk->sk_prot_creator->name : "";
396

Al Viro's avatar
Al Viro committed
397 398 399
	file = alloc_file_pseudo(SOCK_INODE(sock), sock_mnt, dname,
				O_RDWR | (flags & O_NONBLOCK),
				&socket_file_ops);
400
	if (IS_ERR(file)) {
401
		sock_release(sock);
402
		return file;
403 404 405
	}

	sock->file = file;
406
	file->private_data = sock;
407
	return file;
408
}
409
EXPORT_SYMBOL(sock_alloc_file);
410

411
static int sock_map_fd(struct socket *sock, int flags)
412 413
{
	struct file *newfile;
414
	int fd = get_unused_fd_flags(flags);
415 416
	if (unlikely(fd < 0)) {
		sock_release(sock);
417
		return fd;
418
	}
419

420
	newfile = sock_alloc_file(sock, flags, NULL);
421
	if (!IS_ERR(newfile)) {
422
		fd_install(fd, newfile);
423 424
		return fd;
	}
425

426 427
	put_unused_fd(fd);
	return PTR_ERR(newfile);
Linus Torvalds's avatar
Linus Torvalds committed
428 429
}

430 431 432 433 434 435 436 437
/**
 *	sock_from_file - Return the &socket bounded to @file.
 *	@file: file
 *	@err: pointer to an error code return
 *
 *	On failure returns %NULL and assigns -ENOTSOCK to @err.
 */

438
struct socket *sock_from_file(struct file *file, int *err)
439 440 441 442
{
	if (file->f_op == &socket_file_ops)
		return file->private_data;	/* set in sock_map_fd */

443 444
	*err = -ENOTSOCK;
	return NULL;
445
}
446
EXPORT_SYMBOL(sock_from_file);
447

Linus Torvalds's avatar
Linus Torvalds committed
448
/**
449
 *	sockfd_lookup - Go from a file number to its socket slot
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453
 *	@fd: file handle
 *	@err: pointer to an error code return
 *
 *	The file handle passed in is locked and the socket it is bound
454
 *	to is returned. If an error occurs the err pointer is overwritten
Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458 459 460 461 462 463 464 465
 *	with a negative errno code and NULL is returned. The function checks
 *	for both invalid handles and passing a handle which is not a socket.
 *
 *	On a success the socket object pointer is returned.
 */

struct socket *sockfd_lookup(int fd, int *err)
{
	struct file *file;
	struct socket *sock;

466 467
	file = fget(fd);
	if (!file) {
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470
		*err = -EBADF;
		return NULL;
	}
471

472 473
	sock = sock_from_file(file, err);
	if (!sock)
Linus Torvalds's avatar
Linus Torvalds committed
474
		fput(file);
475 476
	return sock;
}
477
EXPORT_SYMBOL(sockfd_lookup);
Linus Torvalds's avatar
Linus Torvalds committed
478

479 480
static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
{
481
	struct fd f = fdget(fd);
482 483
	struct socket *sock;

484
	*err = -EBADF;
485 486 487 488
	if (f.file) {
		sock = sock_from_file(f.file, err);
		if (likely(sock)) {
			*fput_needed = f.flags;
489
			return sock;
490 491
		}
		fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
492
	}
493
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
494 495
}

496 497 498 499 500 501
static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
				size_t size)
{
	ssize_t len;
	ssize_t used = 0;

502
	len = security_inode_listsecurity(d_inode(dentry), buffer, size);
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
	if (len < 0)
		return len;
	used += len;
	if (buffer) {
		if (size < used)
			return -ERANGE;
		buffer += len;
	}

	len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
	used += len;
	if (buffer) {
		if (size < used)
			return -ERANGE;
		memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
		buffer += len;
	}

	return used;
}

524
static int sockfs_setattr(struct dentry *dentry, struct iattr *iattr)
525 526 527
{
	int err = simple_setattr(dentry, iattr);

528
	if (!err && (iattr->ia_valid & ATTR_UID)) {
529 530
		struct socket *sock = SOCKET_I(d_inode(dentry));

531 532 533 534
		if (sock->sk)
			sock->sk->sk_uid = iattr->ia_uid;
		else
			err = -ENOENT;
535 536 537 538 539
	}

	return err;
}

540 541
static const struct inode_operations sockfs_inode_ops = {
	.listxattr = sockfs_listxattr,
542
	.setattr = sockfs_setattr,
543 544
};

Linus Torvalds's avatar
Linus Torvalds committed
545
/**
546
 *	sock_alloc - allocate a socket
547
 *
Linus Torvalds's avatar
Linus Torvalds committed
548 549
 *	Allocate a new inode and socket object. The two are bound together
 *	and initialised. The socket is then returned. If we are out of inodes
550
 *	NULL is returned. This functions uses GFP_KERNEL internally.
Linus Torvalds's avatar
Linus Torvalds committed
551 552
 */

553
struct socket *sock_alloc(void)
Linus Torvalds's avatar
Linus Torvalds committed
554
{
555 556
	struct inode *inode;
	struct socket *sock;
Linus Torvalds's avatar
Linus Torvalds committed
557

558
	inode = new_inode_pseudo(sock_mnt->mnt_sb);
Linus Torvalds's avatar
Linus Torvalds committed
559 560 561 562 563
	if (!inode)
		return NULL;

	sock = SOCKET_I(inode);

564
	inode->i_ino = get_next_ino();
565
	inode->i_mode = S_IFSOCK | S_IRWXUGO;
566 567
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
568
	inode->i_op = &sockfs_inode_ops;
Linus Torvalds's avatar
Linus Torvalds committed
569 570 571

	return sock;
}
572
EXPORT_SYMBOL(sock_alloc);
Linus Torvalds's avatar
Linus Torvalds committed
573 574

/**
575
 *	sock_release - close a socket
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579
 *	@sock: socket to close
 *
 *	The socket is released from the protocol stack if it has a release
 *	callback, and the inode is then released if the socket is bound to
580
 *	an inode not a file.
Linus Torvalds's avatar
Linus Torvalds committed
581
 */
582

583
static void __sock_release(struct socket *sock, struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587
{
	if (sock->ops) {
		struct module *owner = sock->ops->owner;

588 589
		if (inode)
			inode_lock(inode);
Linus Torvalds's avatar
Linus Torvalds committed
590
		sock->ops->release(sock);
591
		sock->sk = NULL;
592 593
		if (inode)
			inode_unlock(inode);
Linus Torvalds's avatar
Linus Torvalds committed
594 595 596 597
		sock->ops = NULL;
		module_put(owner);
	}

598
	if (sock->wq.fasync_list)
599
		pr_err("%s: fasync list not empty!\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604

	if (!sock->file) {
		iput(SOCK_INODE(sock));
		return;
	}
605
	sock->file = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
606
}
607 608 609 610 611

void sock_release(struct socket *sock)
{
	__sock_release(sock, NULL);
}
612
EXPORT_SYMBOL(sock_release);
Linus Torvalds's avatar
Linus Torvalds committed
613

614
void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags)
615
{
616 617
	u8 flags = *tx_flags;

618
	if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE)
619 620
		flags |= SKBTX_HW_TSTAMP;

621
	if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
622 623
		flags |= SKBTX_SW_TSTAMP;

624
	if (tsflags & SOF_TIMESTAMPING_TX_SCHED)
625 626 627
		flags |= SKBTX_SCHED_TSTAMP;

	*tx_flags = flags;
628
}
629
EXPORT_SYMBOL(__sock_tx_timestamp);
630

631 632
INDIRECT_CALLABLE_DECLARE(int inet_sendmsg(struct socket *, struct msghdr *,
					   size_t));
633 634
INDIRECT_CALLABLE_DECLARE(int inet6_sendmsg(struct socket *, struct msghdr *,
					    size_t));
635
static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
Linus Torvalds's avatar
Linus Torvalds committed
636
{
637 638 639
	int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg,
				     inet_sendmsg, sock, msg,
				     msg_data_left(msg));
640 641
	BUG_ON(ret == -EIOCBQUEUED);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
642 643
}

644 645 646 647 648 649 650 651
/**
 *	sock_sendmsg - send a message through @sock
 *	@sock: socket
 *	@msg: message to send
 *
 *	Sends @msg through @sock, passing through LSM.
 *	Returns the number of bytes sent, or an error code.
 */
652
int sock_sendmsg(struct socket *sock, struct msghdr *msg)
653
{
654
	int err = security_socket_sendmsg(sock, msg,
Al Viro's avatar
Al Viro committed
655
					  msg_data_left(msg));
656

657
	return err ?: sock_sendmsg_nosec(sock, msg);
658
}
659
EXPORT_SYMBOL(sock_sendmsg);
Linus Torvalds's avatar
Linus Torvalds committed
660

661 662 663 664 665 666 667 668 669 670 671 672
/**
 *	kernel_sendmsg - send a message through @sock (kernel-space)
 *	@sock: socket
 *	@msg: message header
 *	@vec: kernel vec
 *	@num: vec array length
 *	@size: total message data size
 *
 *	Builds the message data with @vec and sends it through @sock.
 *	Returns the number of bytes sent, or an error code.
 */

Linus Torvalds's avatar
Linus Torvalds committed
673 674 675
int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
		   struct kvec *vec, size_t num, size_t size)
{
676
	iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);
677
	return sock_sendmsg(sock, msg);
Linus Torvalds's avatar
Linus Torvalds committed
678
}
679
EXPORT_SYMBOL(kernel_sendmsg);
Linus Torvalds's avatar
Linus Torvalds committed
680

681 682 683 684 685 686 687 688 689 690 691 692 693
/**
 *	kernel_sendmsg_locked - send a message through @sock (kernel-space)
 *	@sk: sock
 *	@msg: message header
 *	@vec: output s/g array
 *	@num: output s/g array length
 *	@size: total message data size
 *
 *	Builds the message data with @vec and sends it through @sock.
 *	Returns the number of bytes sent, or an error code.
 *	Caller must hold @sk.
 */

694 695 696 697 698 699
int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg,
			  struct kvec *vec, size_t num, size_t size)
{
	struct socket *sock = sk->sk_socket;

	if (!sock->ops->sendmsg_locked)
700
		return sock_no_sendmsg_locked(sk, msg, size);
701

702
	iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);
703 704 705 706 707

	return sock->ops->sendmsg_locked(sk, msg, msg_data_left(msg));
}
EXPORT_SYMBOL(kernel_sendmsg_locked);

708 709 710 711 712 713 714 715 716 717
static bool skb_is_err_queue(const struct sk_buff *skb)
{
	/* pkt_type of skbs enqueued on the error queue are set to
	 * PACKET_OUTGOING in skb_set_err_queue(). This is only safe to do
	 * in recvmsg, since skbs received on a local socket will never
	 * have a pkt_type of PACKET_OUTGOING.
	 */
	return skb->pkt_type == PACKET_OUTGOING;
}

718 719 720 721 722
/* On transmit, software and hardware timestamps are returned independently.
 * As the two skb clones share the hardware timestamp, which may be updated
 * before the software timestamp is received, a hardware TX timestamp may be
 * returned only if there is no software TX timestamp. Ignore false software
 * timestamps, which may be made in the __sock_recv_timestamp() call when the
723
 * option SO_TIMESTAMP_OLD(NS) is enabled on the socket, even when the skb has a
724 725 726 727 728 729 730
 * hardware timestamp.
 */
static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
{
	return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
}

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
{
	struct scm_ts_pktinfo ts_pktinfo;
	struct net_device *orig_dev;

	if (!skb_mac_header_was_set(skb))
		return;

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

	rcu_read_lock();
	orig_dev = dev_get_by_napi_id(skb_napi_id(skb));
	if (orig_dev)
		ts_pktinfo.if_index = orig_dev->ifindex;
	rcu_read_unlock();

	ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
		 sizeof(ts_pktinfo), &ts_pktinfo);
}

752 753 754 755 756 757
/*
 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
 */
void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
	struct sk_buff *skb)
{
758
	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
759
	int new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
760 761
	struct scm_timestamping_internal tss;

762
	int empty = 1, false_tstamp = 0;
763 764 765 766 767
	struct skb_shared_hwtstamps *shhwtstamps =
		skb_hwtstamps(skb);

	/* Race occurred between timestamp enabling and packet
	   receiving.  Fill in the current time for now. */
768
	if (need_software_tstamp && skb->tstamp == 0) {
769
		__net_timestamp(skb);
770 771
		false_tstamp = 1;
	}
772 773 774

	if (need_software_tstamp) {
		if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
775 776 777 778 779 780 781 782 783 784 785 786 787
			if (new_tstamp) {
				struct __kernel_sock_timeval tv;

				skb_get_new_timestamp(skb, &tv);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
					 sizeof(tv), &tv);
			} else {
				struct __kernel_old_timeval tv;

				skb_get_timestamp(skb, &tv);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
					 sizeof(tv), &tv);
			}
788
		} else {
789 790 791 792 793 794 795 796 797 798 799 800 801
			if (new_tstamp) {
				struct __kernel_timespec ts;

				skb_get_new_timestampns(skb, &ts);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
					 sizeof(ts), &ts);
			} else {
				struct timespec ts;

				skb_get_timestampns(skb, &ts);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
					 sizeof(ts), &ts);
			}
802 803 804
		}
	}

805
	memset(&tss, 0, sizeof(tss));
806
	if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
807
	    ktime_to_timespec64_cond(skb->tstamp, tss.ts + 0))
808
		empty = 0;
809
	if (shhwtstamps &&
810
	    (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
811
	    !skb_is_swtx_tstamp(skb, false_tstamp) &&
812
	    ktime_to_timespec64_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {
813
		empty = 0;
814 815 816 817
		if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
		    !skb_is_err_queue(skb))
			put_ts_pktinfo(msg, skb);
	}
818
	if (!empty) {
819 820 821 822
		if (sock_flag(sk, SOCK_TSTAMP_NEW))
			put_cmsg_scm_timestamping64(msg, &tss);
		else
			put_cmsg_scm_timestamping(msg, &tss);
823

824
		if (skb_is_err_queue(skb) && skb->len &&
825
		    SKB_EXT_ERR(skb)->opt_stats)
826 827 828
			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_OPT_STATS,
				 skb->len, skb->data);
	}
829
}
830 831
EXPORT_SYMBOL_GPL(__sock_recv_timestamp);

832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
	struct sk_buff *skb)
{
	int ack;

	if (!sock_flag(sk, SOCK_WIFI_STATUS))
		return;
	if (!skb->wifi_acked_valid)
		return;

	ack = skb->wifi_acked;

	put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
}
EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);

848 849
static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
				   struct sk_buff *skb)
850
{
851
	if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
852
		put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
853
			sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
854 855
}

856
void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
857 858 859 860 861
	struct sk_buff *skb)
{
	sock_recv_timestamp(msg, sk, skb);
	sock_recv_drops(msg, sk, skb);
}
862
EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
863

864
INDIRECT_CALLABLE_DECLARE(int inet_recvmsg(struct socket *, struct msghdr *,
865 866 867
					   size_t, int));
INDIRECT_CALLABLE_DECLARE(int inet6_recvmsg(struct socket *, struct msghdr *,
					    size_t, int));
868
static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
869
				     int flags)
Linus Torvalds's avatar
Linus Torvalds committed
870
{
871 872 873
	return INDIRECT_CALL_INET(sock->ops->recvmsg, inet6_recvmsg,
				  inet_recvmsg, sock, msg, msg_data_left(msg),
				  flags);
Linus Torvalds's avatar
Linus Torvalds committed
874 875
}

876 877 878 879 880 881 882 883 884
/**
 *	sock_recvmsg - receive a message from @sock
 *	@sock: socket
 *	@msg: message to receive
 *	@flags: message flags
 *
 *	Receives @msg from @sock, passing through LSM. Returns the total number
 *	of bytes received, or an error.
 */
885
int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)
886
{
887
	int err = security_socket_recvmsg(sock, msg, msg_data_left(msg), flags);
888

889
	return err ?: sock_recvmsg_nosec(sock, msg, flags);
Linus Torvalds's avatar
Linus Torvalds committed
890
}
891
EXPORT_SYMBOL(sock_recvmsg);
Linus Torvalds's avatar
Linus Torvalds committed
892

893
/**
894 895 896 897 898 899 900
 *	kernel_recvmsg - Receive a message from a socket (kernel space)
 *	@sock: The socket to receive the message from
 *	@msg: Received message
 *	@vec: Input s/g array for message data
 *	@num: Size of input s/g array
 *	@size: Number of bytes to read
 *	@flags: Message flags (MSG_DONTWAIT, etc...)
901
 *
902 903 904
 *	On return the msg structure contains the scatter/gather array passed in the
 *	vec argument. The array is modified so that it consists of the unfilled
 *	portion of the original array.
905
 *
906
 *	The returned value is the total number of bytes received, or an error.
907
 */
908

909 910
int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
		   struct kvec *vec, size_t num, size_t size, int flags)
Linus Torvalds's avatar
Linus Torvalds committed
911 912 913 914
{
	mm_segment_t oldfs = get_fs();
	int result;

915
	iov_iter_kvec(&msg->msg_iter, READ, vec, num, size);
Linus Torvalds's avatar
Linus Torvalds committed
916
	set_fs(KERNEL_DS);
917
	result = sock_recvmsg(sock, msg, flags);
Linus Torvalds's avatar
Linus Torvalds committed
918 919 920
	set_fs(oldfs);
	return result;
}
921
EXPORT_SYMBOL(kernel_recvmsg);
Linus Torvalds's avatar
Linus Torvalds committed
922

923 924
static ssize_t sock_sendpage(struct file *file, struct page *page,
			     int offset, size_t size, loff_t *ppos, int more)
Linus Torvalds's avatar
Linus Torvalds committed
925 926 927 928
{
	struct socket *sock;
	int flags;

929 930
	sock = file->private_data;

931 932 933
	flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
	/* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
	flags |= more;
934

935
	return kernel_sendpage(sock, page, offset, size, flags);
936
}
Linus Torvalds's avatar
Linus Torvalds committed
937

Jens Axboe's avatar
Jens Axboe committed
938
static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
939
				struct pipe_inode_info *pipe, size_t len,
Jens Axboe's avatar
Jens Axboe committed
940 941 942 943
				unsigned int flags)
{
	struct socket *sock = file->private_data;

944
	if (unlikely(!sock->ops->splice_read))
945
		return generic_file_splice_read(file, ppos, pipe, len, flags);
946

Jens Axboe's avatar
Jens Axboe committed
947 948 949
	return sock->ops->splice_read(sock, ppos, pipe, len, flags);
}

950
static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to)
951
{
952 953
	struct file *file = iocb->ki_filp;
	struct socket *sock = file->private_data;
954 955
	struct msghdr msg = {.msg_iter = *to,
			     .msg_iocb = iocb};
956
	ssize_t res;
957

958 959 960 961
	if (file->f_flags & O_NONBLOCK)
		msg.msg_flags = MSG_DONTWAIT;

	if (iocb->ki_pos != 0)
Linus Torvalds's avatar
Linus Torvalds committed
962
		return -ESPIPE;
963

Christoph Hellwig's avatar
Christoph Hellwig committed
964
	if (!iov_iter_count(to))	/* Match SYS5 behaviour */
Linus Torvalds's avatar
Linus Torvalds committed
965 966
		return 0;

967
	res = sock_recvmsg(sock, &msg, msg.msg_flags);
968 969
	*to = msg.msg_iter;
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
970 971
}

972
static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from)
973
{
974 975
	struct file *file = iocb->ki_filp;
	struct socket *sock = file->private_data;
976 977
	struct msghdr msg = {.msg_iter = *from,
			     .msg_iocb = iocb};
978
	ssize_t res;
Linus Torvalds's avatar
Linus Torvalds committed
979

980
	if (iocb->ki_pos != 0)
981
		return -ESPIPE;
982

983 984 985
	if (file->f_flags & O_NONBLOCK)
		msg.msg_flags = MSG_DONTWAIT;

986 987 988
	if (sock->type == SOCK_SEQPACKET)
		msg.msg_flags |= MSG_EOR;

989
	res = sock_sendmsg(sock, &msg);
990 991
	*from = msg.msg_iter;
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
992 993 994 995 996 997 998
}

/*
 * Atomic setting of ioctl hooks to avoid race
 * with module unload.
 */

Arjan van de Ven's avatar
Arjan van de Ven committed
999
static DEFINE_MUTEX(br_ioctl_mutex);
1000
static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);
Linus Torvalds's avatar
Linus Torvalds committed
1001

1002
void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
Linus Torvalds's avatar
Linus Torvalds committed
1003
{
Arjan van de Ven's avatar
Arjan van de Ven committed
1004
	mutex_lock(&br_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1005
	br_ioctl_hook = hook;
Arjan van de Ven's avatar
Arjan van de Ven committed
1006
	mutex_unlock(&br_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1007 1008 1009
}
EXPORT_SYMBOL(brioctl_set);

Arjan van de Ven's avatar
Arjan van de Ven committed
1010
static DEFINE_MUTEX(vlan_ioctl_mutex);
1011
static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
Linus Torvalds's avatar
Linus Torvalds committed
1012

1013
void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
Linus Torvalds's avatar
Linus Torvalds committed
1014
{
Arjan van de Ven's avatar
Arjan van de Ven committed
1015
	mutex_lock(&vlan_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1016
	vlan_ioctl_hook = hook;
Arjan van de Ven's avatar
Arjan van de Ven committed
1017
	mutex_unlock(&vlan_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1018 1019 1020
}
EXPORT_SYMBOL(vlan_ioctl_set);

Arjan van de Ven's avatar
Arjan van de Ven committed
1021
static DEFINE_MUTEX(dlci_ioctl_mutex);
1022
static int (*dlci_ioctl_hook) (unsigned int, void __user *);
Linus Torvalds's avatar
Linus Torvalds committed
1023

1024
void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
Linus Torvalds's avatar
Linus Torvalds committed
1025
{
Arjan van de Ven's avatar
Arjan van de Ven committed
1026
	mutex_lock(&dlci_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1027
	dlci_ioctl_hook = hook;
Arjan van de Ven's avatar
Arjan van de Ven committed
1028
	mutex_unlock(&dlci_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1029 1030 1031
}
EXPORT_SYMBOL(dlci_ioctl_set);

1032
static long sock_do_ioctl(struct net *net, struct socket *sock,
1033
			  unsigned int cmd, unsigned long arg)
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
{
	int err;
	void __user *argp = (void __user *)arg;

	err = sock->ops->ioctl(sock, cmd, arg);

	/*
	 * If this ioctl is unknown try to hand it down
	 * to the NIC driver.
	 */
1044 1045
	if (err != -ENOIOCTLCMD)
		return err;
1046

1047 1048 1049 1050 1051 1052 1053 1054 1055
	if (cmd == SIOCGIFCONF) {
		struct ifconf ifc;
		if (copy_from_user(&ifc, argp, sizeof(struct ifconf)))
			return -EFAULT;
		rtnl_lock();
		err = dev_ifconf(net, &ifc, sizeof(struct ifreq));
		rtnl_unlock();
		if (!err && copy_to_user(argp, &ifc, sizeof(struct ifconf)))
			err = -EFAULT;
1056 1057 1058
	} else {
		struct ifreq ifr;
		bool need_copyout;
1059
		if (copy_from_user(&ifr, argp, sizeof(struct ifreq)))
1060 1061 1062
			return -EFAULT;
		err = dev_ioctl(net, cmd, &ifr, &need_copyout);
		if (!err && need_copyout)
1063
			if (copy_to_user(argp, &ifr, sizeof(struct ifreq)))
1064
				return -EFAULT;
1065
	}
1066 1067 1068
	return err;
}

Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071 1072 1073
/*
 *	With an ioctl, arg may well be a user mode pointer, but we don't know
 *	what to do with it - that's up to the protocol still.
 */

1074 1075 1076 1077 1078 1079 1080
/**
 *	get_net_ns - increment the refcount of the network namespace
 *	@ns: common namespace (net)
 *
 *	Returns the net's common namespace.
 */

1081
struct ns_common *get_net_ns(struct ns_common *ns)
1082 1083 1084
{
	return &get_net(container_of(ns, struct net, ns))->ns;
}
1085
EXPORT_SYMBOL_GPL(get_net_ns);
1086

Linus Torvalds's avatar
Linus Torvalds committed
1087 1088 1089
static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
{
	struct socket *sock;
1090
	struct sock *sk;
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092
	void __user *argp = (void __user *)arg;
	int pid, err;
1093
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
1094

1095
	sock = file->private_data;
1096
	sk = sock->sk;
1097
	net = sock_net(sk);
1098 1099 1100 1101 1102 1103 1104 1105 1106
	if (unlikely(cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))) {
		struct ifreq ifr;
		bool need_copyout;
		if (copy_from_user(&ifr, argp, sizeof(struct ifreq)))
			return -EFAULT;
		err = dev_ioctl(net, cmd, &ifr, &need_copyout);
		if (!err && need_copyout)
			if (copy_to_user(argp, &ifr, sizeof(struct ifreq)))
				return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
1107
	} else
Johannes Berg's avatar
Johannes Berg committed
1108
#ifdef CONFIG_WEXT_CORE
Linus Torvalds's avatar
Linus Torvalds committed
1109
	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
1110
		err = wext_handle_ioctl(net, cmd, argp);
Linus Torvalds's avatar
Linus Torvalds committed
1111
	} else
Johannes Berg's avatar
Johannes Berg committed
1112
#endif
1113
		switch (cmd) {
Linus Torvalds's avatar
Linus Torvalds committed
1114 1115 1116 1117 1118
		case FIOSETOWN:
		case SIOCSPGRP:
			err = -EFAULT;
			if (get_user(pid, (int __user *)argp))
				break;
1119
			err = f_setown(sock->file, pid, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121 1122
			break;
		case FIOGETOWN:
		case SIOCGPGRP:
1123
			err = put_user(f_getown(sock->file),
1124
				       (int __user *)argp);
Linus Torvalds's avatar
Linus Torvalds committed
1125 1126 1127 1128 1129 1130 1131 1132 1133
			break;
		case SIOCGIFBR:
		case SIOCSIFBR:
		case SIOCBRADDBR:
		case SIOCBRDELBR:
			err = -ENOPKG;
			if (!br_ioctl_hook)
				request_module("bridge");

Arjan van de Ven's avatar
Arjan van de Ven committed
1134
			mutex_lock(&br_ioctl_mutex);
1135
			if (br_ioctl_hook)
1136
				err = br_ioctl_hook(net, cmd, argp);
Arjan van de Ven's avatar
Arjan van de Ven committed
1137
			mutex_unlock(&br_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139 1140 1141 1142 1143 1144
			break;
		case SIOCGIFVLAN:
		case SIOCSIFVLAN:
			err = -ENOPKG;
			if (!vlan_ioctl_hook)
				request_module("8021q");

Arjan van de Ven's avatar
Arjan van de Ven committed
1145
			mutex_lock(&vlan_ioctl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1146
			if (vlan_ioctl_hook)
1147
				err = vlan_ioctl_hook(net, argp);