net/socket.c

File Facts

System

Linux kernel

Corpus path

net/socket.c

Extension

.c

Size

95868 bytes

Lines

3823

Domain

Networking Core

Bucket

Sockets, Protocols, Packet Path, And Network Policy

Inferred role

Networking Core: syscall or user/kernel boundary

Status

core implementation candidate

Why This File Exists

Networking stack implementation surface: socket APIs, protocol dispatch, packet flow, routing, filtering, and network namespaces.

• Networking stack implementation surface: socket APIs, protocol dispatch, packet flow, routing, filtering, and network namespaces.
• Defines or participates in a user/kernel boundary; inspect argument validation, copy_from_user/copy_to_user, credentials, and dispatch target.
• Touches user memory; correctness depends on fault-safe copying and privilege boundary handling.
• Uses kernel synchronization; read lock ordering, sleepability, and interrupt context assumptions before translating.
• Allocates kernel memory; connect allocation flags and lifetime to context constraints.
• Defines or uses C structs; map object ownership, embedded links, reference counts, and lock ownership.

Dependency Surface

• linux/bpf-cgroup.h
• linux/ethtool.h
• linux/mm.h
• linux/socket.h
• linux/file.h
• linux/splice.h
• linux/net.h
• linux/interrupt.h
• linux/thread_info.h
• linux/rcupdate.h
• linux/netdevice.h
• linux/proc_fs.h
• linux/seq_file.h
• linux/mutex.h
• linux/if_bridge.h
• linux/if_vlan.h
• linux/ptp_classify.h
• linux/init.h
• linux/poll.h
• linux/cache.h
• linux/module.h
• linux/highmem.h
• linux/mount.h
• linux/pseudo_fs.h
• linux/security.h
• linux/uio.h
• linux/syscalls.h
• linux/compat.h
• linux/kmod.h
• linux/audit.h
• linux/wireless.h
• linux/nsproxy.h

Detected Declarations

• syscall socket
• syscall socketpair
• syscall bind
• syscall listen
• syscall accept4
• syscall accept
• syscall connect
• syscall getsockname
• syscall getpeername
• syscall sendto
• syscall send
• syscall recvfrom
• syscall recv
• syscall setsockopt
• syscall getsockopt
• syscall shutdown
• syscall sendmsg
• syscall sendmmsg
• syscall recvmsg
• syscall recvmmsg
• syscall recvmmsg_time32
• syscall socketcall
• struct sockfs_inode
• struct socket_alloc
• struct used_address
• function sock_show_fdinfo
• function move_addr_to_kernel
• function move_addr_to_user
• function scoped_user_rw_access_size
• function sock_evict_inode
• function sock_free_inode
• function init_once
• function init_inodecache
• function sockfs_dname
• function sockfs_xattr_get
• function sockfs_security_xattr_set
• function sockfs_user_xattr_get
• function sockfs_user_xattr_set
• function sockfs_init_fs_context
• function sock_map_fd
• function sockfs_listxattr
• function sockfs_setattr
• function __sock_release
• function sock_release
• function __sock_tx_timestamp
• function call_trace_sock_send_length
• function sock_sendmsg_nosec
• function __sock_sendmsg

Annotated Snippet

SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
	return __sys_socket(family, type, protocol);
}

/*
 *	Create a pair of connected sockets.
 */

int __sys_socketpair(int family, int type, int protocol, int __user *usockvec)
{
	struct socket *sock1, *sock2;
	int fd1, fd2, err;
	struct file *newfile1, *newfile2;
	int flags;

	flags = type & ~SOCK_TYPE_MASK;
	if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
		return -EINVAL;
	type &= SOCK_TYPE_MASK;

	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
		flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;

	/*
	 * reserve descriptors and make sure we won't fail
	 * to return them to userland.
	 */
	fd1 = get_unused_fd_flags(flags);
	if (unlikely(fd1 < 0))
		return fd1;

	fd2 = get_unused_fd_flags(flags);
	if (unlikely(fd2 < 0)) {
		put_unused_fd(fd1);
		return fd2;
	}

	err = put_user(fd1, &usockvec[0]);
	if (err)
		goto out;

	err = put_user(fd2, &usockvec[1]);
	if (err)
		goto out;

	/*
	 * Obtain the first socket and check if the underlying protocol
	 * supports the socketpair call.
	 */

	err = sock_create(family, type, protocol, &sock1);
	if (unlikely(err < 0))
		goto out;

	err = sock_create(family, type, protocol, &sock2);
	if (unlikely(err < 0)) {
		sock_release(sock1);
		goto out;
	}

	err = security_socket_socketpair(sock1, sock2);
	if (unlikely(err)) {
		sock_release(sock2);
		sock_release(sock1);
		goto out;
	}

	err = READ_ONCE(sock1->ops)->socketpair(sock1, sock2);
	if (unlikely(err < 0)) {
		sock_release(sock2);
		sock_release(sock1);
		goto out;
	}

	newfile1 = sock_alloc_file(sock1, flags, NULL);
	if (IS_ERR(newfile1)) {
		err = PTR_ERR(newfile1);
		sock_release(sock2);
		goto out;
	}

	newfile2 = sock_alloc_file(sock2, flags, NULL);
	if (IS_ERR(newfile2)) {
		err = PTR_ERR(newfile2);
		fput(newfile1);
		goto out;
	}

	audit_fd_pair(fd1, fd2);

Annotation

• Immediate include surface: `linux/bpf-cgroup.h`, `linux/ethtool.h`, `linux/mm.h`, `linux/socket.h`, `linux/file.h`, `linux/splice.h`, `linux/net.h`, `linux/interrupt.h`.
• Detected declarations: `syscall socket`, `syscall socketpair`, `syscall bind`, `syscall listen`, `syscall accept4`, `syscall accept`, `syscall connect`, `syscall getsockname`, `syscall getpeername`, `syscall sendto`.
• Atlas domain: Networking Core / Sockets, Protocols, Packet Path, And Network Policy.
• Implementation status: core implementation candidate.
• This snippet crosses the user/kernel memory boundary; validate fault handling and access checks before translating the pattern.
• Synchronization appears in or near this file; preserve lock ordering, sleepability, and interrupt-context constraints.

Implementation Notes

• This generated page is the file-by-file coverage layer; curated subsystem chapters should link here when they synthesize a multi-file control flow.
• Core OS pages should be promoted from atlas-only to deep-reviewed when they explain data structures, invariants, locking, lifecycle, and C implementation snippets.
• Driver-family pages are intentionally pattern-oriented unless they are part of the selected PCIe/NVMe representative device path.