Lines Matching +full:foo +full:- +full:queue
1 // SPDX-License-Identifier: GPL-2.0-or-later
25 * Jeff Uphoff : Made max number of sockets command-line
47 * protocol-independent
55 #include <linux/bpf-cgroup.h>
142 struct socket *sock = f->private_data;
143 const struct proto_ops *ops = READ_ONCE(sock->ops);
145 if (ops->show_fdinfo)
146 ops->show_fdinfo(m, sock);
239 * move_addr_to_kernel - copy a socket address into kernel space
245 * too long an error code of -EINVAL is returned. If the copy gives
246 * invalid addresses -EFAULT is returned. On a success 0 is returned.
252 return -EINVAL;
256 return -EFAULT;
261 * move_addr_to_user - copy an address to user space
268 * This is overwritten with the buffer space used. -EINVAL is returned
269 * if an overlong buffer is specified or a negative buffer size. -EFAULT
299 return -EINVAL;
301 return -ENOMEM;
303 return -EFAULT;
308 return -EFAULT;
333 INIT_LIST_HEAD_RCU(&si->xattrs);
334 simple_xattr_limits_init(&si->xattr_limits);
336 init_waitqueue_head(&si->socket.wq.wait);
337 si->socket.wq.fasync_list = NULL;
338 si->socket.wq.flags = 0;
340 si->socket.state = SS_UNCONNECTED;
341 si->socket.flags = 0;
342 si->socket.ops = NULL;
343 si->socket.sk = NULL;
344 si->socket.file = NULL;
346 return &si->vfs_inode;
353 simple_xattrs_free(&sockfs_xa_cache, &si->xattrs, NULL);
364 static void init_once(void *foo)
366 struct sockfs_inode *si = (struct sockfs_inode *)foo;
368 inode_init_once(&si->vfs_inode);
396 d_inode(dentry)->i_ino);
408 if (dentry->d_name.len + 1 > size)
409 return -ERANGE;
410 memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
412 return dentry->d_name.len + 1;
417 #define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
431 return -EAGAIN;
446 return simple_xattr_get(&sockfs_xa_cache, &si->xattrs, name, value, size);
458 return simple_xattr_set_limited(&sockfs_xa_cache, &si->xattrs, &si->xattr_limits,
479 return -ENOMEM;
480 ctx->ops = &sockfs_ops;
481 ctx->dops = &sockfs_dentry_operations;
482 ctx->xattr = sockfs_xattr_handlers;
499 * and file struct implicitly stored in sock->file.
512 * sock_alloc_file - Bind a &socket to a &file
518 * in sock->file. If dname is %NULL, sets to "".
530 dname = sock->sk ? sock->sk->sk_prot_creator->name : "";
540 file->f_mode |= FMODE_NOWAIT;
541 sock->file = file;
542 file->private_data = sock;
545 * Disable permission and pre-content events, but enable legacy
573 * sock_from_file - Return the &socket bounded to @file.
581 if (likely(file->f_op == &socket_file_ops))
582 return file->private_data; /* set in sock_alloc_file */
589 * sockfd_lookup - Go from a file number to its socket slot
608 *err = -EBADF;
614 *err = -ENOTSOCK;
627 len = simple_xattr_list(d_inode(dentry), &si->xattrs, buffer, size);
634 size -= len;
641 return -ERANGE;
653 if (!err && (iattr->ia_valid & ATTR_UID)) {
656 if (sock->sk) {
658 WRITE_ONCE(sock->sk->sk_uid, iattr->ia_uid);
660 err = -ENOENT;
673 * sock_alloc - allocate a socket
685 inode = new_inode_pseudo(sock_mnt->mnt_sb);
691 inode->i_ino = get_next_ino();
692 inode->i_mode = S_IFSOCK | S_IRWXUGO;
693 inode->i_uid = current_fsuid();
694 inode->i_gid = current_fsgid();
695 inode->i_op = &sockfs_inode_ops;
703 const struct proto_ops *ops = READ_ONCE(sock->ops);
706 struct module *owner = ops->owner;
710 ops->release(sock);
711 sock->sk = NULL;
714 sock->ops = NULL;
718 if (sock->wq.fasync_list)
721 if (!sock->file) {
725 WRITE_ONCE(sock->file, NULL);
729 * sock_release - close a socket
775 int ret = INDIRECT_CALL_INET(READ_ONCE(sock->ops)->sendmsg, inet6_sendmsg,
778 BUG_ON(ret == -EIOCBQUEUED);
781 call_trace_sock_send_length(sock->sk, ret, 0);
794 * sock_sendmsg - send a message through @sock
803 struct sockaddr_storage *save_addr = (struct sockaddr_storage *)msg->msg_name;
805 int save_len = msg->msg_namelen;
808 if (msg->msg_name) {
809 memcpy(&address, msg->msg_name, msg->msg_namelen);
810 msg->msg_name = &address;
814 msg->msg_name = save_addr;
815 msg->msg_namelen = save_len;
822 * kernel_sendmsg - send a message through @sock (kernel-space)
836 iov_iter_kvec(&msg->msg_iter, ITER_SOURCE, vec, num, size);
843 /* Error-queue skbs are marked as PACKET_OUTGOING in
848 return skb->pkt_type == PACKET_OUTGOING &&
849 skb->destructor == sock_rmem_free;
862 return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
867 bool cycles = READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_BIND_PHC;
875 *if_index = orig_dev->ifindex;
878 hwtstamp = shhwtstamps->hwtstamp;
900 if_index = orig_dev->ifindex;
905 ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
913 u32 tsflags = READ_ONCE(sk->sk_tsflags);
915 if (serr->ee.ee_errno != ENOMSG ||
916 serr->ee.ee_origin != SO_EE_ORIGIN_TIMESTAMPING)
920 if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) && skb->tstamp)
924 skb_hwtstamps(skb)->hwtstamp;
930 u32 tsflags = READ_ONCE(sk->sk_tsflags);
935 ktime_to_timespec64_cond(skb->tstamp, ts))
940 return -ENOENT;
942 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
945 hwtstamp = skb_hwtstamps(skb)->hwtstamp;
949 READ_ONCE(sk->sk_bind_phc));
951 return -ENOENT;
973 if (need_software_tstamp && skb->tstamp == 0) {
1011 tsflags = READ_ONCE(sk->sk_tsflags);
1016 tss.ts[0] = skb->tstamp;
1025 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
1028 hwtstamp = shhwtstamps->hwtstamp;
1032 READ_ONCE(sk->sk_bind_phc));
1048 if (skb_is_err_queue(skb) && skb->len &&
1049 SKB_EXT_ERR(skb)->opt_stats)
1051 skb->len, skb->data);
1064 if (!skb->wifi_acked_valid)
1067 ack = skb->wifi_acked;
1077 if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
1079 sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
1087 __u32 mark = skb->mark;
1097 __u32 priority = skb->priority;
1126 int ret = INDIRECT_CALL_INET(READ_ONCE(sock->ops)->recvmsg,
1131 call_trace_sock_recv_length(sock->sk, ret, flags);
1136 * sock_recvmsg - receive a message from @sock
1153 * kernel_recvmsg - Receive a message from a socket (kernel space)
1171 msg->msg_control_is_user = false;
1172 iov_iter_kvec(&msg->msg_iter, ITER_DEST, vec, num, size);
1181 struct socket *sock = file->private_data;
1184 ops = READ_ONCE(sock->ops);
1185 if (unlikely(!ops->splice_read))
1188 return ops->splice_read(sock, ppos, pipe, len, flags);
1193 struct socket *sock = file->private_data;
1196 ops = READ_ONCE(sock->ops);
1197 if (ops->splice_eof)
1198 ops->splice_eof(sock);
1203 struct file *file = iocb->ki_filp;
1204 struct socket *sock = file->private_data;
1208 if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1211 if (iocb->ki_pos != 0)
1212 return -ESPIPE;
1224 struct file *file = iocb->ki_filp;
1225 struct socket *sock = file->private_data;
1229 if (iocb->ki_pos != 0)
1230 return -ESPIPE;
1232 if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1235 if (sock->type == SOCK_SEQPACKET)
1238 if (iocb->ki_flags & IOCB_NOSIGNAL)
1266 int err = -ENOPKG;
1293 const struct proto_ops *ops = READ_ONCE(sock->ops);
1300 err = ops->ioctl(sock, cmd, arg);
1306 if (err != -ENOIOCTLCMD)
1310 return -ENOTTY;
1313 return -EFAULT;
1317 return -EFAULT;
1324 * what to do with it - that's up to the protocol still.
1336 sock = file->private_data;
1337 ops = READ_ONCE(sock->ops);
1338 sk = sock->sk;
1345 return -EFAULT;
1349 return -EFAULT;
1359 err = -EFAULT;
1362 err = f_setown(sock->file, pid, 1);
1366 err = put_user(f_getown(sock->file),
1379 err = -ENOPKG;
1389 err = -EPERM;
1390 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1393 err = open_related_ns(&net->ns, get_net_ns);
1397 if (!ops->gettstamp) {
1398 err = -ENOIOCTLCMD;
1401 err = ops->gettstamp(sock, argp,
1407 if (!ops->gettstamp) {
1408 err = -ENOIOCTLCMD;
1411 err = ops->gettstamp(sock, argp,
1428 * sock_create_lite - creates a socket
1451 err = -ENOMEM;
1455 sock->type = type;
1470 /* No kernel lock held - perfect */
1473 struct socket *sock = file->private_data;
1474 const struct proto_ops *ops = READ_ONCE(sock->ops);
1477 if (!ops->poll)
1480 if (sk_can_busy_loop(sock->sk)) {
1483 sk_busy_loop(sock->sk, 1);
1489 return ops->poll(file, sock, wait) | flag;
1494 struct socket *sock = file->private_data;
1496 return READ_ONCE(sock->ops)->mmap(file, sock, vma);
1512 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1518 struct socket *sock = filp->private_data;
1519 struct sock *sk = sock->sk;
1520 struct socket_wq *wq = &sock->wq;
1523 return -EINVAL;
1526 fasync_helper(fd, filp, on, &wq->fasync_list);
1528 if (!wq->fasync_list)
1541 if (!wq || !wq->fasync_list)
1542 return -1;
1546 if (test_bit(SOCKWQ_ASYNC_WAITDATA, &wq->flags))
1550 if (!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags))
1555 kill_fasync(&wq->fasync_list, SIGIO, band);
1558 kill_fasync(&wq->fasync_list, SIGURG, band);
1566 * __sock_create - creates a socket
1591 return -EAFNOSUPPORT;
1593 return -EINVAL;
1602 current->comm);
1618 return -ENFILE; /* Not exactly a match, but its the
1622 sock->type = type;
1628 * requested real, full-featured networking support upon configuration.
1632 request_module("net-pf-%d", family);
1637 err = -EAFNOSUPPORT;
1642 * We will call the ->create function, that possibly is in a loadable
1645 if (!try_module_get(pf->owner))
1651 err = pf->create(net, sock, protocol, kern);
1653 /* ->create should release the allocated sock->sk object on error
1654 * and make sure sock->sk is set to NULL to avoid use-after-free
1656 DEBUG_NET_WARN_ONCE(sock->sk,
1657 "%ps must clear sock->sk on failure, family: %d, type: %d, protocol: %d\n",
1658 pf->create, family, type, protocol);
1666 if (!try_module_get(sock->ops->owner))
1670 * Now that we're done with the ->create function, the [loadable]
1673 module_put(pf->owner);
1682 err = -EAFNOSUPPORT;
1684 sock->ops = NULL;
1685 module_put(pf->owner);
1697 * sock_create - creates a socket
1709 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1714 * sock_create_kern - creates a socket (kernel space)
1743 return ERR_PTR(-EINVAL);
1823 return -EINVAL;
1873 err = READ_ONCE(sock1->ops)->socketpair(sock1, sock2);
1920 err = READ_ONCE(sock->ops)->bind(sock,
1942 return -EBADF;
1945 return -ENOTSOCK;
1968 somaxconn = READ_ONCE(sock_net(sock->sk)->core.sysctl_somaxconn);
1974 err = READ_ONCE(sock->ops)->listen(sock, backlog);
1984 return -EBADF;
1987 return -ENOTSOCK;
2009 return ERR_PTR(-ENOTSOCK);
2013 return ERR_PTR(-ENFILE);
2014 ops = READ_ONCE(sock->ops);
2016 newsock->type = sock->type;
2017 newsock->ops = ops;
2021 * has the protocol module (sock->ops->owner) held.
2023 __module_get(ops->owner);
2025 newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
2033 arg->flags |= sock->file->f_flags;
2034 err = ops->accept(sock, newsock, arg);
2039 len = ops->getname(newsock, (struct sockaddr *)&address, 2);
2041 err = -ECONNABORTED;
2063 return -EINVAL;
2089 return -EBADF;
2115 * include the -EINPROGRESS status for such sockets.
2126 err = -ENOTSOCK;
2135 err = READ_ONCE(sock->ops)->connect(sock, (struct sockaddr_unsized *)address,
2136 addrlen, sock->file->f_flags | file_flags);
2148 return -EBADF;
2175 err = READ_ONCE(sock->ops)->getname(sock, (struct sockaddr *)&address, peer);
2193 return -EBADF;
2196 return -ENOTSOCK;
2231 return -EBADF;
2234 return -ENOTSOCK;
2249 if (sock->file->f_flags & O_NONBLOCK)
2295 return -EBADF;
2298 return -ENOTSOCK;
2300 if (sock->file->f_flags & O_NONBLOCK)
2332 return test_bit(SOCK_CUSTOM_SOCKOPT, &sock->flags);
2343 return -EINVAL;
2350 err = BPF_CGROUP_RUN_PROG_SETSOCKOPT(sock->sk, &level, &optname,
2362 ops = READ_ONCE(sock->ops);
2365 else if (unlikely(!ops->setsockopt))
2366 err = -EOPNOTSUPP;
2368 err = ops->setsockopt(sock, level, optname, optval,
2388 return -EBADF;
2391 return -ENOTSOCK;
2409 * .iter_in is read-only and .iter_out is write-only by the protocol callbacks
2417 return -EFAULT;
2420 return -EINVAL;
2423 kvec->iov_base = optval.kernel;
2424 kvec->iov_len = koptlen;
2425 iov_iter_kvec(&opt->iter_out, ITER_DEST, kvec, 1, koptlen);
2426 iov_iter_kvec(&opt->iter_in, ITER_SOURCE, kvec, 1, koptlen);
2428 iov_iter_ubuf(&opt->iter_out, ITER_DEST, optval.user, koptlen);
2429 iov_iter_ubuf(&opt->iter_in, ITER_SOURCE, optval.user,
2432 opt->optlen = koptlen;
2453 ops = READ_ONCE(sock->ops);
2455 err = sk_getsockopt(sock->sk, level, optname, optval, optlen);
2456 } else if (ops->getsockopt_iter) {
2461 err = ops->getsockopt_iter(sock, level, optname, &opt);
2464 * (e.g. CAN raw) return -ERANGE and set optlen to the
2468 return -EFAULT;
2469 } else if (ops->getsockopt) {
2472 return -EOPNOTSUPP;
2474 err = ops->getsockopt(sock, level, optname, optval.user,
2477 err = -EOPNOTSUPP;
2481 err = BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock->sk, level, optname,
2500 return -EBADF;
2503 return -ENOTSOCK;
2525 err = READ_ONCE(sock->ops)->shutdown(sock, how);
2536 return -EBADF;
2539 return -ENOTSOCK;
2552 #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
2567 kmsg->msg_control_is_user = true;
2568 kmsg->msg_get_inq = 0;
2569 kmsg->msg_control_user = msg->msg_control;
2570 kmsg->msg_controllen = msg->msg_controllen;
2571 kmsg->msg_flags = msg->msg_flags;
2573 kmsg->msg_namelen = msg->msg_namelen;
2574 if (!msg->msg_name)
2575 kmsg->msg_namelen = 0;
2577 if (kmsg->msg_namelen < 0)
2578 return -EINVAL;
2580 if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
2581 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
2584 *save_addr = msg->msg_name;
2586 if (msg->msg_name && kmsg->msg_namelen) {
2588 err = move_addr_to_kernel(msg->msg_name,
2589 kmsg->msg_namelen,
2590 kmsg->msg_name);
2595 kmsg->msg_name = NULL;
2596 kmsg->msg_namelen = 0;
2599 if (msg->msg_iovlen > UIO_MAXIOV)
2600 return -EMSGSIZE;
2602 kmsg->msg_ubuf = NULL;
2615 return -EFAULT;
2623 UIO_FASTIOV, iov, &kmsg->msg_iter);
2638 err = -ENOBUFS;
2640 if (msg_sys->msg_controllen > INT_MAX)
2642 flags |= (msg_sys->msg_flags & allowed_msghdr_flags);
2643 ctl_len = msg_sys->msg_controllen;
2646 cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
2650 ctl_buf = msg_sys->msg_control;
2651 ctl_len = msg_sys->msg_controllen;
2656 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
2660 err = -EFAULT;
2661 if (copy_from_user(ctl_buf, msg_sys->msg_control_user, ctl_len))
2663 msg_sys->msg_control = ctl_buf;
2664 msg_sys->msg_control_is_user = false;
2667 msg_sys->msg_flags = flags;
2669 if (sock->file->f_flags & O_NONBLOCK)
2670 msg_sys->msg_flags |= MSG_DONTWAIT;
2674 * used_address->name_len is initialized to UINT_MAX so that the first
2677 if (used_address && msg_sys->msg_name &&
2678 used_address->name_len == msg_sys->msg_namelen &&
2679 !memcmp(&used_address->name, msg_sys->msg_name,
2680 used_address->name_len)) {
2690 used_address->name_len = msg_sys->msg_namelen;
2691 if (msg_sys->msg_name)
2692 memcpy(&used_address->name, msg_sys->msg_name,
2693 used_address->name_len);
2698 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2732 msg_sys->msg_name = &address;
2760 return -EINVAL;
2765 return -EBADF;
2768 return -ENOTSOCK;
2794 return -EINVAL;
2804 return -EBADF;
2807 return -ENOTSOCK;
2816 if (datagrams == vlen - 1)
2824 err = __put_user(err, &compat_entry->msg_len);
2832 err = put_user(err, &entry->msg_len);
2891 msg_sys->msg_name = &addr;
2892 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2893 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
2896 msg_sys->msg_namelen = 0;
2898 if (sock->file->f_flags & O_NONBLOCK)
2912 msg_sys->msg_namelen, uaddr,
2917 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
2922 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2923 &msg_compat->msg_controllen);
2925 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2926 &msg->msg_controllen);
2969 return -EINVAL;
2974 return -EBADF;
2977 return -ENOTSOCK;
3005 poll_select_set_timeout(&end_time, timeout->tv_sec,
3006 timeout->tv_nsec))
3007 return -EINVAL;
3014 return -EBADF;
3017 return -ENOTSOCK;
3020 err = sock_error(sock->sk);
3038 err = __put_user(err, &compat_entry->msg_len);
3047 err = put_user(err, &entry->msg_len);
3062 if (timeout->tv_sec < 0) {
3063 timeout->tv_sec = timeout->tv_nsec = 0;
3068 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
3088 if (err != -EAGAIN) {
3095 WRITE_ONCE(sock->sk->sk_err, -err);
3109 return -EFAULT;
3112 return -EFAULT;
3123 datagrams = -EFAULT;
3126 datagrams = -EFAULT;
3136 return -EINVAL;
3147 return -EINVAL;
3181 return -EINVAL;
3186 return -EINVAL;
3190 return -EFAULT;
3286 err = -EINVAL;
3295 * sock_register - add a socket protocol handler
3300 * socket interface. The value ops->family corresponds to the
3307 if (ops->family >= NPROTO) {
3308 pr_crit("protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
3309 return -ENOBUFS;
3313 if (rcu_dereference_protected(net_families[ops->family],
3315 err = -EEXIST;
3317 rcu_assign_pointer(net_families[ops->family], ops);
3322 pr_info("NET: Registered %s protocol family\n", pf_family_names[ops->family]);
3328 * sock_unregister - remove a protocol handler
3338 * the ops->create routine.
3414 sock_inuse_get(seq->private));
3421 * ifreq::ifru_ifmap (which is 16 bytes on 32 bit, 24 bytes on 64-bit,
3434 return -EFAULT;
3437 *ifrdata = compat_ptr(ifr32->ifr_data);
3443 return -EFAULT;
3446 *ifrdata = ifr->ifr_data;
3460 return -EFAULT;
3475 return -EFAULT;
3477 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
3478 return -EFAULT;
3487 err = -EFAULT;
3500 return -ENOTTY;
3502 return -EFAULT;
3512 struct sock *sk = sock->sk;
3524 ops = READ_ONCE(sock->ops);
3525 if (!ops->gettstamp)
3526 return -ENOIOCTLCMD;
3527 return ops->gettstamp(sock, argp, cmd == SIOCGSTAMP_OLD,
3602 return -ENOIOCTLCMD;
3608 struct socket *sock = file->private_data;
3609 const struct proto_ops *ops = READ_ONCE(sock->ops);
3610 int ret = -ENOIOCTLCMD;
3614 sk = sock->sk;
3617 if (ops->compat_ioctl)
3618 ret = ops->compat_ioctl(sock, cmd, arg);
3620 if (ret == -ENOIOCTLCMD &&
3624 if (ret == -ENOIOCTLCMD)
3632 * kernel_bind - bind an address to a socket (kernel space)
3646 return READ_ONCE(sock->ops)->bind(sock, (struct sockaddr_unsized *)&address,
3652 * kernel_listen - move socket to listening state (kernel space)
3654 * @backlog: pending connections queue size
3661 return READ_ONCE(sock->ops)->listen(sock, backlog);
3666 * kernel_accept - accept a connection (kernel space)
3678 struct sock *sk = sock->sk;
3679 const struct proto_ops *ops = READ_ONCE(sock->ops);
3686 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3691 err = ops->accept(sock, *newsock, &arg);
3698 (*newsock)->ops = ops;
3699 __module_get(ops->owner);
3707 * kernel_connect - connect a socket (kernel space)
3726 return READ_ONCE(sock->ops)->connect(sock, (struct sockaddr_unsized *)&address,
3732 * kernel_getsockname - get the address which the socket is bound (kernel space)
3742 return READ_ONCE(sock->ops)->getname(sock, addr, 0);
3747 * kernel_getpeername - get the address which the socket is connected (kernel space)
3757 return READ_ONCE(sock->ops)->getname(sock, addr, 1);
3762 * kernel_sock_shutdown - shut down part of a full-duplex connection (kernel space)
3771 return READ_ONCE(sock->ops)->shutdown(sock, how);
3776 * kernel_sock_ip_overhead - returns the IP overhead imposed by a socket
3798 switch (sk->sk_family) {
3802 opt = rcu_dereference_protected(inet->inet_opt,
3805 overhead += opt->opt.optlen;
3812 optv6 = rcu_dereference_protected(np->opt,
3815 overhead += (optv6->opt_flen + optv6->opt_nflen);