2 * NET4: Implementation of BSD Unix domain sockets.
4 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 * Linus Torvalds : Assorted bug cures.
13 * Niibe Yutaka : async I/O support.
14 * Carsten Paeth : PF_UNIX check, address fixes.
15 * Alan Cox : Limit size of allocated blocks.
16 * Alan Cox : Fixed the stupid socketpair bug.
17 * Alan Cox : BSD compatibility fine tuning.
18 * Alan Cox : Fixed a bug in connect when interrupted.
19 * Alan Cox : Sorted out a proper draft version of
20 * file descriptor passing hacked up from
22 * Marty Leisner : Fixes to fd passing
23 * Nick Nevin : recvmsg bugfix.
24 * Alan Cox : Started proper garbage collector
25 * Heiko EiBfeldt : Missing verify_area check
26 * Alan Cox : Started POSIXisms
27 * Andreas Schwab : Replace inode by dentry for proper
29 * Kirk Petersen : Made this a module
30 * Christoph Rohland : Elegant non-blocking accept/connect algorithm.
32 * Alexey Kuznetosv : Repaired (I hope) bugs introduces
33 * by above two patches.
34 * Andrea Arcangeli : If possible we block in connect(2)
35 * if the max backlog of the listen socket
36 * is been reached. This won't break
37 * old apps and it will avoid huge amount
38 * of socks hashed (this for unix_gc()
39 * performances reasons).
40 * Security fix that limits the max
41 * number of socks to 2*max_files and
42 * the number of skb queueable in the
44 * Artur Skawina : Hash function optimizations
45 * Alexey Kuznetsov : Full scale SMP. Lot of bugs are introduced 8)
46 * Malcolm Beattie : Set peercred for socketpair
47 * Michal Ostrowski : Module initialization cleanup.
48 * Arnaldo C. Melo : Remove MOD_{INC,DEC}_USE_COUNT,
49 * the core infrastructure is doing that
50 * for all net proto families now (2.5.69+)
53 * Known differences from reference BSD that was tested:
56 * ECONNREFUSED is not returned from one end of a connected() socket to the
57 * other the moment one end closes.
58 * fstat() doesn't return st_dev=0, and give the blksize as high water mark
59 * and a fake inode identifier (nor the BSD first socket fstat twice bug).
61 * accept() returns a path name even if the connecting socket has closed
62 * in the meantime (BSD loses the path and gives up).
63 * accept() returns 0 length path for an unbound connector. BSD returns 16
64 * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
65 * socketpair(...SOCK_RAW..) doesn't panic the kernel.
66 * BSD af_unix apparently has connect forgetting to block properly.
67 * (need to check this with the POSIX spec in detail)
69 * Differences from 2.0.0-11-... (ANK)
70 * Bug fixes and improvements.
71 * - client shutdown killed server socket.
72 * - removed all useless cli/sti pairs.
74 * Semantic changes/extensions.
75 * - generic control message passing.
76 * - SCM_CREDENTIALS control message.
77 * - "Abstract" (not FS based) socket bindings.
78 * Abstract names are sequences of bytes (not zero terminated)
79 * started by 0, so that this name space does not intersect
83 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
85 #include <linux/module.h>
86 #include <linux/kernel.h>
87 #include <linux/signal.h>
88 #include <linux/sched.h>
89 #include <linux/errno.h>
90 #include <linux/string.h>
91 #include <linux/stat.h>
92 #include <linux/dcache.h>
93 #include <linux/namei.h>
94 #include <linux/socket.h>
96 #include <linux/fcntl.h>
97 #include <linux/termios.h>
98 #include <linux/sockios.h>
99 #include <linux/net.h>
100 #include <linux/in.h>
101 #include <linux/fs.h>
102 #include <linux/slab.h>
103 #include <asm/uaccess.h>
104 #include <linux/skbuff.h>
105 #include <linux/netdevice.h>
106 #include <net/net_namespace.h>
107 #include <net/sock.h>
108 #include <net/tcp_states.h>
109 #include <net/af_unix.h>
110 #include <linux/proc_fs.h>
111 #include <linux/seq_file.h>
113 #include <linux/init.h>
114 #include <linux/poll.h>
115 #include <linux/rtnetlink.h>
116 #include <linux/mount.h>
117 #include <net/checksum.h>
118 #include <linux/security.h>
119 #include <linux/freezer.h>
123 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
124 EXPORT_SYMBOL_GPL(unix_socket_table);
125 DEFINE_SPINLOCK(unix_table_lock);
126 EXPORT_SYMBOL_GPL(unix_table_lock);
127 static atomic_long_t unix_nr_socks;
130 static struct hlist_head *unix_sockets_unbound(void *addr)
132 unsigned long hash = (unsigned long)addr;
136 hash %= UNIX_HASH_SIZE;
137 return &unix_socket_table[UNIX_HASH_SIZE + hash];
140 #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
142 #ifdef CONFIG_SECURITY_NETWORK
143 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
145 UNIXCB(skb).secid = scm->secid;
148 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
150 scm->secid = UNIXCB(skb).secid;
153 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
155 return (scm->secid == UNIXCB(skb).secid);
158 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
161 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
164 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
168 #endif /* CONFIG_SECURITY_NETWORK */
171 * SMP locking strategy:
172 * hash table is protected with spinlock unix_table_lock
173 * each socket state is protected by separate spin lock.
176 static inline unsigned int unix_hash_fold(__wsum n)
178 unsigned int hash = (__force unsigned int)csum_fold(n);
181 return hash&(UNIX_HASH_SIZE-1);
184 #define unix_peer(sk) (unix_sk(sk)->peer)
186 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
188 return unix_peer(osk) == sk;
191 static inline int unix_may_send(struct sock *sk, struct sock *osk)
193 return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
196 static inline int unix_recvq_full(const struct sock *sk)
198 return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
201 static inline int unix_recvq_full_lockless(const struct sock *sk)
203 return skb_queue_len_lockless(&sk->sk_receive_queue) >
204 READ_ONCE(sk->sk_max_ack_backlog);
207 struct sock *unix_peer_get(struct sock *s)
215 unix_state_unlock(s);
218 EXPORT_SYMBOL_GPL(unix_peer_get);
220 static inline void unix_release_addr(struct unix_address *addr)
222 if (atomic_dec_and_test(&addr->refcnt))
227 * Check unix socket name:
228 * - should be not zero length.
229 * - if started by not zero, should be NULL terminated (FS object)
230 * - if started by zero, it is abstract name.
233 static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
237 if (len <= sizeof(short) || len > sizeof(*sunaddr))
239 if (!sunaddr || sunaddr->sun_family != AF_UNIX)
241 if (sunaddr->sun_path[0]) {
243 * This may look like an off by one error but it is a bit more
244 * subtle. 108 is the longest valid AF_UNIX path for a binding.
245 * sun_path[108] doesn't as such exist. However in kernel space
246 * we are guaranteed that it is a valid memory location in our
247 * kernel address buffer.
249 ((char *)sunaddr)[len] = 0;
250 len = strlen(sunaddr->sun_path)+1+sizeof(short);
254 *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
258 static void __unix_remove_socket(struct sock *sk)
260 sk_del_node_init(sk);
263 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
265 WARN_ON(!sk_unhashed(sk));
266 sk_add_node(sk, list);
269 static inline void unix_remove_socket(struct sock *sk)
271 spin_lock(&unix_table_lock);
272 __unix_remove_socket(sk);
273 spin_unlock(&unix_table_lock);
276 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
278 spin_lock(&unix_table_lock);
279 __unix_insert_socket(list, sk);
280 spin_unlock(&unix_table_lock);
283 static struct sock *__unix_find_socket_byname(struct net *net,
284 struct sockaddr_un *sunname,
285 int len, int type, unsigned int hash)
289 sk_for_each(s, &unix_socket_table[hash ^ type]) {
290 struct unix_sock *u = unix_sk(s);
292 if (!net_eq(sock_net(s), net))
295 if (u->addr->len == len &&
296 !memcmp(u->addr->name, sunname, len))
304 static inline struct sock *unix_find_socket_byname(struct net *net,
305 struct sockaddr_un *sunname,
311 spin_lock(&unix_table_lock);
312 s = __unix_find_socket_byname(net, sunname, len, type, hash);
315 spin_unlock(&unix_table_lock);
319 static struct sock *unix_find_socket_byinode(struct inode *i)
323 spin_lock(&unix_table_lock);
325 &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
326 struct dentry *dentry = unix_sk(s)->path.dentry;
328 if (dentry && d_real_inode(dentry) == i) {
335 spin_unlock(&unix_table_lock);
339 /* Support code for asymmetrically connected dgram sockets
341 * If a datagram socket is connected to a socket not itself connected
342 * to the first socket (eg, /dev/log), clients may only enqueue more
343 * messages if the present receive queue of the server socket is not
344 * "too large". This means there's a second writeability condition
345 * poll and sendmsg need to test. The dgram recv code will do a wake
346 * up on the peer_wait wait queue of a socket upon reception of a
347 * datagram which needs to be propagated to sleeping would-be writers
348 * since these might not have sent anything so far. This can't be
349 * accomplished via poll_wait because the lifetime of the server
350 * socket might be less than that of its clients if these break their
351 * association with it or if the server socket is closed while clients
352 * are still connected to it and there's no way to inform "a polling
353 * implementation" that it should let go of a certain wait queue
355 * In order to propagate a wake up, a wait_queue_t of the client
356 * socket is enqueued on the peer_wait queue of the server socket
357 * whose wake function does a wake_up on the ordinary client socket
358 * wait queue. This connection is established whenever a write (or
359 * poll for write) hit the flow control condition and broken when the
360 * association to the server socket is dissolved or after a wake up
364 static int unix_dgram_peer_wake_relay(wait_queue_t *q, unsigned mode, int flags,
368 wait_queue_head_t *u_sleep;
370 u = container_of(q, struct unix_sock, peer_wake);
372 __remove_wait_queue(&unix_sk(u->peer_wake.private)->peer_wait,
374 u->peer_wake.private = NULL;
376 /* relaying can only happen while the wq still exists */
377 u_sleep = sk_sleep(&u->sk);
379 wake_up_interruptible_poll(u_sleep, key);
384 static int unix_dgram_peer_wake_connect(struct sock *sk, struct sock *other)
386 struct unix_sock *u, *u_other;
390 u_other = unix_sk(other);
392 spin_lock(&u_other->peer_wait.lock);
394 if (!u->peer_wake.private) {
395 u->peer_wake.private = other;
396 __add_wait_queue(&u_other->peer_wait, &u->peer_wake);
401 spin_unlock(&u_other->peer_wait.lock);
405 static void unix_dgram_peer_wake_disconnect(struct sock *sk,
408 struct unix_sock *u, *u_other;
411 u_other = unix_sk(other);
412 spin_lock(&u_other->peer_wait.lock);
414 if (u->peer_wake.private == other) {
415 __remove_wait_queue(&u_other->peer_wait, &u->peer_wake);
416 u->peer_wake.private = NULL;
419 spin_unlock(&u_other->peer_wait.lock);
422 static void unix_dgram_peer_wake_disconnect_wakeup(struct sock *sk,
425 unix_dgram_peer_wake_disconnect(sk, other);
426 wake_up_interruptible_poll(sk_sleep(sk),
433 * - unix_peer(sk) == other
434 * - association is stable
436 static int unix_dgram_peer_wake_me(struct sock *sk, struct sock *other)
440 connected = unix_dgram_peer_wake_connect(sk, other);
442 if (unix_recvq_full(other))
446 unix_dgram_peer_wake_disconnect(sk, other);
451 static int unix_writable(const struct sock *sk)
453 return sk->sk_state != TCP_LISTEN &&
454 (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
457 static void unix_write_space(struct sock *sk)
459 struct socket_wq *wq;
462 if (unix_writable(sk)) {
463 wq = rcu_dereference(sk->sk_wq);
464 if (wq_has_sleeper(wq))
465 wake_up_interruptible_sync_poll(&wq->wait,
466 POLLOUT | POLLWRNORM | POLLWRBAND);
467 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
472 /* When dgram socket disconnects (or changes its peer), we clear its receive
473 * queue of packets arrived from previous peer. First, it allows to do
474 * flow control based only on wmem_alloc; second, sk connected to peer
475 * may receive messages only from that peer. */
476 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
478 if (!skb_queue_empty(&sk->sk_receive_queue)) {
479 skb_queue_purge(&sk->sk_receive_queue);
480 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
482 /* If one link of bidirectional dgram pipe is disconnected,
483 * we signal error. Messages are lost. Do not make this,
484 * when peer was not connected to us.
486 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
487 other->sk_err = ECONNRESET;
488 other->sk_error_report(other);
493 static void unix_sock_destructor(struct sock *sk)
495 struct unix_sock *u = unix_sk(sk);
497 skb_queue_purge(&sk->sk_receive_queue);
499 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
500 WARN_ON(!sk_unhashed(sk));
501 WARN_ON(sk->sk_socket);
502 if (!sock_flag(sk, SOCK_DEAD)) {
503 pr_info("Attempt to release alive unix socket: %p\n", sk);
508 unix_release_addr(u->addr);
510 atomic_long_dec(&unix_nr_socks);
512 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
514 #ifdef UNIX_REFCNT_DEBUG
515 pr_debug("UNIX %p is destroyed, %ld are still alive.\n", sk,
516 atomic_long_read(&unix_nr_socks));
520 static void unix_release_sock(struct sock *sk, int embrion)
522 struct unix_sock *u = unix_sk(sk);
528 unix_remove_socket(sk);
533 sk->sk_shutdown = SHUTDOWN_MASK;
535 u->path.dentry = NULL;
537 state = sk->sk_state;
538 sk->sk_state = TCP_CLOSE;
540 skpair = unix_peer(sk);
541 unix_peer(sk) = NULL;
543 unix_state_unlock(sk);
545 wake_up_interruptible_all(&u->peer_wait);
547 if (skpair != NULL) {
548 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
549 unix_state_lock(skpair);
551 skpair->sk_shutdown = SHUTDOWN_MASK;
552 if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
553 skpair->sk_err = ECONNRESET;
554 unix_state_unlock(skpair);
555 skpair->sk_state_change(skpair);
556 sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
559 unix_dgram_peer_wake_disconnect(sk, skpair);
560 sock_put(skpair); /* It may now die */
563 /* Try to flush out this socket. Throw out buffers at least */
565 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
566 if (state == TCP_LISTEN)
567 unix_release_sock(skb->sk, 1);
568 /* passed fds are erased in the kfree_skb hook */
569 UNIXCB(skb).consumed = skb->len;
578 /* ---- Socket is dead now and most probably destroyed ---- */
581 * Fixme: BSD difference: In BSD all sockets connected to us get
582 * ECONNRESET and we die on the spot. In Linux we behave
583 * like files and pipes do and wait for the last
586 * Can't we simply set sock->err?
588 * What the above comment does talk about? --ANK(980817)
591 if (unix_tot_inflight)
592 unix_gc(); /* Garbage collect fds */
595 static void init_peercred(struct sock *sk)
597 const struct cred *old_cred;
600 spin_lock(&sk->sk_peer_lock);
601 old_pid = sk->sk_peer_pid;
602 old_cred = sk->sk_peer_cred;
603 sk->sk_peer_pid = get_pid(task_tgid(current));
604 sk->sk_peer_cred = get_current_cred();
605 spin_unlock(&sk->sk_peer_lock);
611 static void copy_peercred(struct sock *sk, struct sock *peersk)
613 const struct cred *old_cred;
617 spin_lock(&sk->sk_peer_lock);
618 spin_lock_nested(&peersk->sk_peer_lock, SINGLE_DEPTH_NESTING);
620 spin_lock(&peersk->sk_peer_lock);
621 spin_lock_nested(&sk->sk_peer_lock, SINGLE_DEPTH_NESTING);
623 old_pid = sk->sk_peer_pid;
624 old_cred = sk->sk_peer_cred;
625 sk->sk_peer_pid = get_pid(peersk->sk_peer_pid);
626 sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
628 spin_unlock(&sk->sk_peer_lock);
629 spin_unlock(&peersk->sk_peer_lock);
635 static int unix_listen(struct socket *sock, int backlog)
638 struct sock *sk = sock->sk;
639 struct unix_sock *u = unix_sk(sk);
640 struct pid *old_pid = NULL;
643 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
644 goto out; /* Only stream/seqpacket sockets accept */
647 goto out; /* No listens on an unbound socket */
649 if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
651 if (backlog > sk->sk_max_ack_backlog)
652 wake_up_interruptible_all(&u->peer_wait);
653 sk->sk_max_ack_backlog = backlog;
654 sk->sk_state = TCP_LISTEN;
655 /* set credentials so connect can copy them */
660 unix_state_unlock(sk);
666 static int unix_release(struct socket *);
667 static int unix_bind(struct socket *, struct sockaddr *, int);
668 static int unix_stream_connect(struct socket *, struct sockaddr *,
669 int addr_len, int flags);
670 static int unix_socketpair(struct socket *, struct socket *);
671 static int unix_accept(struct socket *, struct socket *, int);
672 static int unix_getname(struct socket *, struct sockaddr *, int *, int);
673 static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
674 static unsigned int unix_dgram_poll(struct file *, struct socket *,
676 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
677 static int unix_shutdown(struct socket *, int);
678 static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
679 static int unix_stream_recvmsg(struct socket *, struct msghdr *, size_t, int);
680 static ssize_t unix_stream_sendpage(struct socket *, struct page *, int offset,
681 size_t size, int flags);
682 static ssize_t unix_stream_splice_read(struct socket *, loff_t *ppos,
683 struct pipe_inode_info *, size_t size,
685 static int unix_dgram_sendmsg(struct socket *, struct msghdr *, size_t);
686 static int unix_dgram_recvmsg(struct socket *, struct msghdr *, size_t, int);
687 static int unix_dgram_connect(struct socket *, struct sockaddr *,
689 static int unix_seqpacket_sendmsg(struct socket *, struct msghdr *, size_t);
690 static int unix_seqpacket_recvmsg(struct socket *, struct msghdr *, size_t,
693 static int unix_set_peek_off(struct sock *sk, int val)
695 struct unix_sock *u = unix_sk(sk);
697 if (mutex_lock_interruptible(&u->iolock))
700 sk->sk_peek_off = val;
701 mutex_unlock(&u->iolock);
707 static const struct proto_ops unix_stream_ops = {
709 .owner = THIS_MODULE,
710 .release = unix_release,
712 .connect = unix_stream_connect,
713 .socketpair = unix_socketpair,
714 .accept = unix_accept,
715 .getname = unix_getname,
718 .listen = unix_listen,
719 .shutdown = unix_shutdown,
720 .setsockopt = sock_no_setsockopt,
721 .getsockopt = sock_no_getsockopt,
722 .sendmsg = unix_stream_sendmsg,
723 .recvmsg = unix_stream_recvmsg,
724 .mmap = sock_no_mmap,
725 .sendpage = unix_stream_sendpage,
726 .splice_read = unix_stream_splice_read,
727 .set_peek_off = unix_set_peek_off,
730 static const struct proto_ops unix_dgram_ops = {
732 .owner = THIS_MODULE,
733 .release = unix_release,
735 .connect = unix_dgram_connect,
736 .socketpair = unix_socketpair,
737 .accept = sock_no_accept,
738 .getname = unix_getname,
739 .poll = unix_dgram_poll,
741 .listen = sock_no_listen,
742 .shutdown = unix_shutdown,
743 .setsockopt = sock_no_setsockopt,
744 .getsockopt = sock_no_getsockopt,
745 .sendmsg = unix_dgram_sendmsg,
746 .recvmsg = unix_dgram_recvmsg,
747 .mmap = sock_no_mmap,
748 .sendpage = sock_no_sendpage,
749 .set_peek_off = unix_set_peek_off,
752 static const struct proto_ops unix_seqpacket_ops = {
754 .owner = THIS_MODULE,
755 .release = unix_release,
757 .connect = unix_stream_connect,
758 .socketpair = unix_socketpair,
759 .accept = unix_accept,
760 .getname = unix_getname,
761 .poll = unix_dgram_poll,
763 .listen = unix_listen,
764 .shutdown = unix_shutdown,
765 .setsockopt = sock_no_setsockopt,
766 .getsockopt = sock_no_getsockopt,
767 .sendmsg = unix_seqpacket_sendmsg,
768 .recvmsg = unix_seqpacket_recvmsg,
769 .mmap = sock_no_mmap,
770 .sendpage = sock_no_sendpage,
771 .set_peek_off = unix_set_peek_off,
774 static struct proto unix_proto = {
776 .owner = THIS_MODULE,
777 .obj_size = sizeof(struct unix_sock),
781 * AF_UNIX sockets do not interact with hardware, hence they
782 * dont trigger interrupts - so it's safe for them to have
783 * bh-unsafe locking for their sk_receive_queue.lock. Split off
784 * this special lock-class by reinitializing the spinlock key:
786 static struct lock_class_key af_unix_sk_receive_queue_lock_key;
788 static struct sock *unix_create1(struct net *net, struct socket *sock, int kern)
790 struct sock *sk = NULL;
793 atomic_long_inc(&unix_nr_socks);
794 if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
797 sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto, kern);
801 sock_init_data(sock, sk);
802 lockdep_set_class(&sk->sk_receive_queue.lock,
803 &af_unix_sk_receive_queue_lock_key);
805 sk->sk_write_space = unix_write_space;
806 sk->sk_max_ack_backlog = net->unx.sysctl_max_dgram_qlen;
807 sk->sk_destruct = unix_sock_destructor;
809 u->path.dentry = NULL;
811 spin_lock_init(&u->lock);
812 atomic_long_set(&u->inflight, 0);
813 INIT_LIST_HEAD(&u->link);
814 mutex_init(&u->iolock); /* single task reading lock */
815 mutex_init(&u->bindlock); /* single task binding lock */
816 init_waitqueue_head(&u->peer_wait);
817 init_waitqueue_func_entry(&u->peer_wake, unix_dgram_peer_wake_relay);
818 unix_insert_socket(unix_sockets_unbound(sk), sk);
821 atomic_long_dec(&unix_nr_socks);
824 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
830 static int unix_create(struct net *net, struct socket *sock, int protocol,
833 if (protocol && protocol != PF_UNIX)
834 return -EPROTONOSUPPORT;
836 sock->state = SS_UNCONNECTED;
838 switch (sock->type) {
840 sock->ops = &unix_stream_ops;
843 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
847 sock->type = SOCK_DGRAM;
849 sock->ops = &unix_dgram_ops;
852 sock->ops = &unix_seqpacket_ops;
855 return -ESOCKTNOSUPPORT;
858 return unix_create1(net, sock, kern) ? 0 : -ENOMEM;
861 static int unix_release(struct socket *sock)
863 struct sock *sk = sock->sk;
868 unix_release_sock(sk, 0);
874 static int unix_autobind(struct socket *sock)
876 struct sock *sk = sock->sk;
877 struct net *net = sock_net(sk);
878 struct unix_sock *u = unix_sk(sk);
879 static u32 ordernum = 1;
880 struct unix_address *addr;
882 unsigned int retries = 0;
884 err = mutex_lock_interruptible(&u->bindlock);
893 addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
897 addr->name->sun_family = AF_UNIX;
898 atomic_set(&addr->refcnt, 1);
901 addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
902 addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
904 spin_lock(&unix_table_lock);
905 ordernum = (ordernum+1)&0xFFFFF;
907 if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
909 spin_unlock(&unix_table_lock);
911 * __unix_find_socket_byname() may take long time if many names
912 * are already in use.
915 /* Give up if all names seems to be in use. */
916 if (retries++ == 0xFFFFF) {
923 addr->hash ^= sk->sk_type;
925 __unix_remove_socket(sk);
926 smp_store_release(&u->addr, addr);
927 __unix_insert_socket(&unix_socket_table[addr->hash], sk);
928 spin_unlock(&unix_table_lock);
931 out: mutex_unlock(&u->bindlock);
935 static struct sock *unix_find_other(struct net *net,
936 struct sockaddr_un *sunname, int len,
937 int type, unsigned int hash, int *error)
943 if (sunname->sun_path[0]) {
945 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
948 inode = d_real_inode(path.dentry);
949 err = inode_permission(inode, MAY_WRITE);
954 if (!S_ISSOCK(inode->i_mode))
956 u = unix_find_socket_byinode(inode);
960 if (u->sk_type == type)
966 if (u->sk_type != type) {
972 u = unix_find_socket_byname(net, sunname, len, type, hash);
974 struct dentry *dentry;
975 dentry = unix_sk(u)->path.dentry;
977 touch_atime(&unix_sk(u)->path);
990 static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
992 struct dentry *dentry;
996 * Get the parent directory, calculate the hash for last
999 dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
1000 err = PTR_ERR(dentry);
1005 * All right, let's create it.
1007 err = security_path_mknod(&path, dentry, mode, 0);
1009 err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
1011 res->mnt = mntget(path.mnt);
1012 res->dentry = dget(dentry);
1015 done_path_create(&path, dentry);
1019 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1021 struct sock *sk = sock->sk;
1022 struct net *net = sock_net(sk);
1023 struct unix_sock *u = unix_sk(sk);
1024 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1025 char *sun_path = sunaddr->sun_path;
1028 struct unix_address *addr;
1029 struct hlist_head *list;
1030 struct path path = { NULL, NULL };
1033 if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
1034 sunaddr->sun_family != AF_UNIX)
1037 if (addr_len == sizeof(short)) {
1038 err = unix_autobind(sock);
1042 err = unix_mkname(sunaddr, addr_len, &hash);
1048 umode_t mode = S_IFSOCK |
1049 (SOCK_INODE(sock)->i_mode & ~current_umask());
1050 err = unix_mknod(sun_path, mode, &path);
1058 err = mutex_lock_interruptible(&u->bindlock);
1067 addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
1071 memcpy(addr->name, sunaddr, addr_len);
1072 addr->len = addr_len;
1073 addr->hash = hash ^ sk->sk_type;
1074 atomic_set(&addr->refcnt, 1);
1077 addr->hash = UNIX_HASH_SIZE;
1078 hash = d_real_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
1079 spin_lock(&unix_table_lock);
1081 list = &unix_socket_table[hash];
1083 spin_lock(&unix_table_lock);
1085 if (__unix_find_socket_byname(net, sunaddr, addr_len,
1086 sk->sk_type, hash)) {
1087 unix_release_addr(addr);
1091 list = &unix_socket_table[addr->hash];
1095 __unix_remove_socket(sk);
1096 smp_store_release(&u->addr, addr);
1097 __unix_insert_socket(list, sk);
1100 spin_unlock(&unix_table_lock);
1102 mutex_unlock(&u->bindlock);
1110 static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
1112 if (unlikely(sk1 == sk2) || !sk2) {
1113 unix_state_lock(sk1);
1117 unix_state_lock(sk1);
1118 unix_state_lock_nested(sk2);
1120 unix_state_lock(sk2);
1121 unix_state_lock_nested(sk1);
1125 static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
1127 if (unlikely(sk1 == sk2) || !sk2) {
1128 unix_state_unlock(sk1);
1131 unix_state_unlock(sk1);
1132 unix_state_unlock(sk2);
1135 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
1136 int alen, int flags)
1138 struct sock *sk = sock->sk;
1139 struct net *net = sock_net(sk);
1140 struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
1146 if (alen < offsetofend(struct sockaddr, sa_family))
1149 if (addr->sa_family != AF_UNSPEC) {
1150 err = unix_mkname(sunaddr, alen, &hash);
1155 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
1156 !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
1160 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
1164 unix_state_double_lock(sk, other);
1166 /* Apparently VFS overslept socket death. Retry. */
1167 if (sock_flag(other, SOCK_DEAD)) {
1168 unix_state_double_unlock(sk, other);
1174 if (!unix_may_send(sk, other))
1177 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1183 * 1003.1g breaking connected state with AF_UNSPEC
1186 unix_state_double_lock(sk, other);
1190 * If it was connected, reconnect.
1192 if (unix_peer(sk)) {
1193 struct sock *old_peer = unix_peer(sk);
1194 unix_peer(sk) = other;
1195 unix_dgram_peer_wake_disconnect_wakeup(sk, old_peer);
1197 unix_state_double_unlock(sk, other);
1199 if (other != old_peer)
1200 unix_dgram_disconnected(sk, old_peer);
1203 unix_peer(sk) = other;
1204 unix_state_double_unlock(sk, other);
1209 unix_state_double_unlock(sk, other);
1215 static long unix_wait_for_peer(struct sock *other, long timeo)
1217 struct unix_sock *u = unix_sk(other);
1221 prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1223 sched = !sock_flag(other, SOCK_DEAD) &&
1224 !(other->sk_shutdown & RCV_SHUTDOWN) &&
1225 unix_recvq_full(other);
1227 unix_state_unlock(other);
1230 timeo = schedule_timeout(timeo);
1232 finish_wait(&u->peer_wait, &wait);
1236 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1237 int addr_len, int flags)
1239 struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1240 struct sock *sk = sock->sk;
1241 struct net *net = sock_net(sk);
1242 struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1243 struct sock *newsk = NULL;
1244 struct sock *other = NULL;
1245 struct sk_buff *skb = NULL;
1251 err = unix_mkname(sunaddr, addr_len, &hash);
1256 if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1257 (err = unix_autobind(sock)) != 0)
1260 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1262 /* First of all allocate resources.
1263 If we will make it after state is locked,
1264 we will have to recheck all again in any case.
1269 /* create new sock for complete connection */
1270 newsk = unix_create1(sock_net(sk), NULL, 0);
1274 /* Allocate skb for sending to listening sock */
1275 skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1280 /* Find listening sock. */
1281 other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1285 /* Latch state of peer */
1286 unix_state_lock(other);
1288 /* Apparently VFS overslept socket death. Retry. */
1289 if (sock_flag(other, SOCK_DEAD)) {
1290 unix_state_unlock(other);
1295 err = -ECONNREFUSED;
1296 if (other->sk_state != TCP_LISTEN)
1298 if (other->sk_shutdown & RCV_SHUTDOWN)
1301 if (unix_recvq_full(other)) {
1306 timeo = unix_wait_for_peer(other, timeo);
1308 err = sock_intr_errno(timeo);
1309 if (signal_pending(current))
1317 It is tricky place. We need to grab our state lock and cannot
1318 drop lock on peer. It is dangerous because deadlock is
1319 possible. Connect to self case and simultaneous
1320 attempt to connect are eliminated by checking socket
1321 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1322 check this before attempt to grab lock.
1324 Well, and we have to recheck the state after socket locked.
1330 /* This is ok... continue with connect */
1332 case TCP_ESTABLISHED:
1333 /* Socket is already connected */
1341 unix_state_lock_nested(sk);
1343 if (sk->sk_state != st) {
1344 unix_state_unlock(sk);
1345 unix_state_unlock(other);
1350 err = security_unix_stream_connect(sk, other, newsk);
1352 unix_state_unlock(sk);
1356 /* The way is open! Fastly set all the necessary fields... */
1359 unix_peer(newsk) = sk;
1360 newsk->sk_state = TCP_ESTABLISHED;
1361 newsk->sk_type = sk->sk_type;
1362 init_peercred(newsk);
1363 newu = unix_sk(newsk);
1364 RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1365 otheru = unix_sk(other);
1367 /* copy address information from listening to new sock
1369 * The contents of *(otheru->addr) and otheru->path
1370 * are seen fully set up here, since we have found
1371 * otheru in hash under unix_table_lock. Insertion
1372 * into the hash chain we'd found it in had been done
1373 * in an earlier critical area protected by unix_table_lock,
1374 * the same one where we'd set *(otheru->addr) contents,
1375 * as well as otheru->path and otheru->addr itself.
1377 * Using smp_store_release() here to set newu->addr
1378 * is enough to make those stores, as well as stores
1379 * to newu->path visible to anyone who gets newu->addr
1380 * by smp_load_acquire(). IOW, the same warranties
1381 * as for unix_sock instances bound in unix_bind() or
1382 * in unix_autobind().
1384 if (otheru->path.dentry) {
1385 path_get(&otheru->path);
1386 newu->path = otheru->path;
1388 atomic_inc(&otheru->addr->refcnt);
1389 smp_store_release(&newu->addr, otheru->addr);
1391 /* Set credentials */
1392 copy_peercred(sk, other);
1394 sock->state = SS_CONNECTED;
1395 sk->sk_state = TCP_ESTABLISHED;
1398 smp_mb__after_atomic(); /* sock_hold() does an atomic_inc() */
1399 unix_peer(sk) = newsk;
1401 unix_state_unlock(sk);
1403 /* take ten and and send info to listening sock */
1404 spin_lock(&other->sk_receive_queue.lock);
1405 __skb_queue_tail(&other->sk_receive_queue, skb);
1406 spin_unlock(&other->sk_receive_queue.lock);
1407 unix_state_unlock(other);
1408 other->sk_data_ready(other);
1414 unix_state_unlock(other);
1419 unix_release_sock(newsk, 0);
1425 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1427 struct sock *ska = socka->sk, *skb = sockb->sk;
1429 /* Join our sockets back to back */
1432 unix_peer(ska) = skb;
1433 unix_peer(skb) = ska;
1437 if (ska->sk_type != SOCK_DGRAM) {
1438 ska->sk_state = TCP_ESTABLISHED;
1439 skb->sk_state = TCP_ESTABLISHED;
1440 socka->state = SS_CONNECTED;
1441 sockb->state = SS_CONNECTED;
1446 static void unix_sock_inherit_flags(const struct socket *old,
1449 if (test_bit(SOCK_PASSCRED, &old->flags))
1450 set_bit(SOCK_PASSCRED, &new->flags);
1451 if (test_bit(SOCK_PASSSEC, &old->flags))
1452 set_bit(SOCK_PASSSEC, &new->flags);
1455 static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1457 struct sock *sk = sock->sk;
1459 struct sk_buff *skb;
1463 if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1467 if (sk->sk_state != TCP_LISTEN)
1470 /* If socket state is TCP_LISTEN it cannot change (for now...),
1471 * so that no locks are necessary.
1474 skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1476 /* This means receive shutdown. */
1483 skb_free_datagram(sk, skb);
1484 wake_up_interruptible(&unix_sk(sk)->peer_wait);
1486 /* attach accepted sock to socket */
1487 unix_state_lock(tsk);
1488 newsock->state = SS_CONNECTED;
1489 unix_sock_inherit_flags(sock, newsock);
1490 sock_graft(tsk, newsock);
1491 unix_state_unlock(tsk);
1499 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1501 struct sock *sk = sock->sk;
1502 struct unix_address *addr;
1503 DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1507 sk = unix_peer_get(sk);
1517 addr = smp_load_acquire(&unix_sk(sk)->addr);
1519 sunaddr->sun_family = AF_UNIX;
1520 sunaddr->sun_path[0] = 0;
1521 *uaddr_len = sizeof(short);
1523 *uaddr_len = addr->len;
1524 memcpy(sunaddr, addr->name, *uaddr_len);
1531 static void unix_peek_fds(struct scm_cookie *scm, struct sk_buff *skb)
1533 scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1536 * Garbage collection of unix sockets starts by selecting a set of
1537 * candidate sockets which have reference only from being in flight
1538 * (total_refs == inflight_refs). This condition is checked once during
1539 * the candidate collection phase, and candidates are marked as such, so
1540 * that non-candidates can later be ignored. While inflight_refs is
1541 * protected by unix_gc_lock, total_refs (file count) is not, hence this
1542 * is an instantaneous decision.
1544 * Once a candidate, however, the socket must not be reinstalled into a
1545 * file descriptor while the garbage collection is in progress.
1547 * If the above conditions are met, then the directed graph of
1548 * candidates (*) does not change while unix_gc_lock is held.
1550 * Any operations that changes the file count through file descriptors
1551 * (dup, close, sendmsg) does not change the graph since candidates are
1552 * not installed in fds.
1554 * Dequeing a candidate via recvmsg would install it into an fd, but
1555 * that takes unix_gc_lock to decrement the inflight count, so it's
1556 * serialized with garbage collection.
1558 * MSG_PEEK is special in that it does not change the inflight count,
1559 * yet does install the socket into an fd. The following lock/unlock
1560 * pair is to ensure serialization with garbage collection. It must be
1561 * done between incrementing the file count and installing the file into
1564 * If garbage collection starts after the barrier provided by the
1565 * lock/unlock, then it will see the elevated refcount and not mark this
1566 * as a candidate. If a garbage collection is already in progress
1567 * before the file count was incremented, then the lock/unlock pair will
1568 * ensure that garbage collection is finished before progressing to
1569 * installing the fd.
1571 * (*) A -> B where B is on the queue of A or B is on the queue of C
1572 * which is on the queue of listening socket A.
1574 spin_lock(&unix_gc_lock);
1575 spin_unlock(&unix_gc_lock);
1578 static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1582 UNIXCB(skb).pid = get_pid(scm->pid);
1583 UNIXCB(skb).uid = scm->creds.uid;
1584 UNIXCB(skb).gid = scm->creds.gid;
1585 UNIXCB(skb).fp = NULL;
1586 unix_get_secdata(scm, skb);
1587 if (scm->fp && send_fds)
1588 err = unix_attach_fds(scm, skb);
1590 skb->destructor = unix_destruct_scm;
1594 static bool unix_passcred_enabled(const struct socket *sock,
1595 const struct sock *other)
1597 return test_bit(SOCK_PASSCRED, &sock->flags) ||
1598 !other->sk_socket ||
1599 test_bit(SOCK_PASSCRED, &other->sk_socket->flags);
1603 * Some apps rely on write() giving SCM_CREDENTIALS
1604 * We include credentials if source or destination socket
1605 * asserted SOCK_PASSCRED.
1607 static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1608 const struct sock *other)
1610 if (UNIXCB(skb).pid)
1612 if (unix_passcred_enabled(sock, other)) {
1613 UNIXCB(skb).pid = get_pid(task_tgid(current));
1614 current_uid_gid(&UNIXCB(skb).uid, &UNIXCB(skb).gid);
1618 static int maybe_init_creds(struct scm_cookie *scm,
1619 struct socket *socket,
1620 const struct sock *other)
1623 struct msghdr msg = { .msg_controllen = 0 };
1625 err = scm_send(socket, &msg, scm, false);
1629 if (unix_passcred_enabled(socket, other)) {
1630 scm->pid = get_pid(task_tgid(current));
1631 current_uid_gid(&scm->creds.uid, &scm->creds.gid);
1636 static bool unix_skb_scm_eq(struct sk_buff *skb,
1637 struct scm_cookie *scm)
1639 const struct unix_skb_parms *u = &UNIXCB(skb);
1641 return u->pid == scm->pid &&
1642 uid_eq(u->uid, scm->creds.uid) &&
1643 gid_eq(u->gid, scm->creds.gid) &&
1644 unix_secdata_eq(scm, skb);
1648 * Send AF_UNIX data.
1651 static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
1654 struct sock *sk = sock->sk;
1655 struct net *net = sock_net(sk);
1656 struct unix_sock *u = unix_sk(sk);
1657 DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
1658 struct sock *other = NULL;
1659 int namelen = 0; /* fake GCC */
1662 struct sk_buff *skb;
1664 struct scm_cookie scm;
1670 err = scm_send(sock, msg, &scm, false);
1675 if (msg->msg_flags&MSG_OOB)
1678 if (msg->msg_namelen) {
1679 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1686 other = unix_peer_get(sk);
1691 if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1692 && (err = unix_autobind(sock)) != 0)
1696 if (len > sk->sk_sndbuf - 32)
1699 if (len > SKB_MAX_ALLOC) {
1700 data_len = min_t(size_t,
1701 len - SKB_MAX_ALLOC,
1702 MAX_SKB_FRAGS * PAGE_SIZE);
1703 data_len = PAGE_ALIGN(data_len);
1705 BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
1708 skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1709 msg->msg_flags & MSG_DONTWAIT, &err,
1710 PAGE_ALLOC_COSTLY_ORDER);
1714 err = unix_scm_to_skb(&scm, skb, true);
1717 max_level = err + 1;
1719 skb_put(skb, len - data_len);
1720 skb->data_len = data_len;
1722 err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1726 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1731 if (sunaddr == NULL)
1734 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1740 if (sk_filter(other, skb) < 0) {
1741 /* Toss the packet but do not return any error to the sender */
1747 unix_state_lock(other);
1750 if (!unix_may_send(sk, other))
1753 if (unlikely(sock_flag(other, SOCK_DEAD))) {
1755 * Check with 1003.1g - what should
1758 unix_state_unlock(other);
1762 unix_state_lock(sk);
1765 if (unix_peer(sk) == other) {
1766 unix_peer(sk) = NULL;
1767 unix_dgram_peer_wake_disconnect_wakeup(sk, other);
1769 unix_state_unlock(sk);
1771 unix_dgram_disconnected(sk, other);
1773 err = -ECONNREFUSED;
1775 unix_state_unlock(sk);
1785 if (other->sk_shutdown & RCV_SHUTDOWN)
1788 if (sk->sk_type != SOCK_SEQPACKET) {
1789 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1794 /* other == sk && unix_peer(other) != sk if
1795 * - unix_peer(sk) == NULL, destination address bound to sk
1796 * - unix_peer(sk) == sk by time of get but disconnected before lock
1799 unlikely(unix_peer(other) != sk &&
1800 unix_recvq_full_lockless(other))) {
1802 timeo = unix_wait_for_peer(other, timeo);
1804 err = sock_intr_errno(timeo);
1805 if (signal_pending(current))
1812 unix_state_unlock(other);
1813 unix_state_double_lock(sk, other);
1816 if (unix_peer(sk) != other ||
1817 unix_dgram_peer_wake_me(sk, other)) {
1825 goto restart_locked;
1829 if (unlikely(sk_locked))
1830 unix_state_unlock(sk);
1832 if (sock_flag(other, SOCK_RCVTSTAMP))
1833 __net_timestamp(skb);
1834 maybe_add_creds(skb, sock, other);
1835 skb_queue_tail(&other->sk_receive_queue, skb);
1836 if (max_level > unix_sk(other)->recursion_level)
1837 unix_sk(other)->recursion_level = max_level;
1838 unix_state_unlock(other);
1839 other->sk_data_ready(other);
1846 unix_state_unlock(sk);
1847 unix_state_unlock(other);
1857 /* We use paged skbs for stream sockets, and limit occupancy to 32768
1858 * bytes, and a minimun of a full page.
1860 #define UNIX_SKB_FRAGS_SZ (PAGE_SIZE << get_order(32768))
1862 static int unix_stream_sendmsg(struct socket *sock, struct msghdr *msg,
1865 struct sock *sk = sock->sk;
1866 struct sock *other = NULL;
1868 struct sk_buff *skb;
1870 struct scm_cookie scm;
1871 bool fds_sent = false;
1876 err = scm_send(sock, msg, &scm, false);
1881 if (msg->msg_flags&MSG_OOB)
1884 if (msg->msg_namelen) {
1885 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1889 other = unix_peer(sk);
1894 if (sk->sk_shutdown & SEND_SHUTDOWN)
1897 while (sent < len) {
1900 /* Keep two messages in the pipe so it schedules better */
1901 size = min_t(int, size, (sk->sk_sndbuf >> 1) - 64);
1903 /* allow fallback to order-0 allocations */
1904 size = min_t(int, size, SKB_MAX_HEAD(0) + UNIX_SKB_FRAGS_SZ);
1906 data_len = max_t(int, 0, size - SKB_MAX_HEAD(0));
1908 data_len = min_t(size_t, size, PAGE_ALIGN(data_len));
1910 skb = sock_alloc_send_pskb(sk, size - data_len, data_len,
1911 msg->msg_flags & MSG_DONTWAIT, &err,
1912 get_order(UNIX_SKB_FRAGS_SZ));
1916 /* Only send the fds in the first buffer */
1917 err = unix_scm_to_skb(&scm, skb, !fds_sent);
1922 max_level = err + 1;
1925 skb_put(skb, size - data_len);
1926 skb->data_len = data_len;
1928 err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
1934 unix_state_lock(other);
1936 if (sock_flag(other, SOCK_DEAD) ||
1937 (other->sk_shutdown & RCV_SHUTDOWN))
1940 maybe_add_creds(skb, sock, other);
1941 skb_queue_tail(&other->sk_receive_queue, skb);
1942 if (max_level > unix_sk(other)->recursion_level)
1943 unix_sk(other)->recursion_level = max_level;
1944 unix_state_unlock(other);
1945 other->sk_data_ready(other);
1954 unix_state_unlock(other);
1957 if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1958 send_sig(SIGPIPE, current, 0);
1962 return sent ? : err;
1965 static ssize_t unix_stream_sendpage(struct socket *socket, struct page *page,
1966 int offset, size_t size, int flags)
1969 bool send_sigpipe = false;
1970 bool init_scm = true;
1971 struct scm_cookie scm;
1972 struct sock *other, *sk = socket->sk;
1973 struct sk_buff *skb, *newskb = NULL, *tail = NULL;
1975 if (flags & MSG_OOB)
1978 other = unix_peer(sk);
1979 if (!other || sk->sk_state != TCP_ESTABLISHED)
1984 unix_state_unlock(other);
1985 mutex_unlock(&unix_sk(other)->iolock);
1986 newskb = sock_alloc_send_pskb(sk, 0, 0, flags & MSG_DONTWAIT,
1992 /* we must acquire iolock as we modify already present
1993 * skbs in the sk_receive_queue and mess with skb->len
1995 err = mutex_lock_interruptible(&unix_sk(other)->iolock);
1997 err = flags & MSG_DONTWAIT ? -EAGAIN : -ERESTARTSYS;
2001 if (sk->sk_shutdown & SEND_SHUTDOWN) {
2003 send_sigpipe = true;
2007 unix_state_lock(other);
2009 if (sock_flag(other, SOCK_DEAD) ||
2010 other->sk_shutdown & RCV_SHUTDOWN) {
2012 send_sigpipe = true;
2013 goto err_state_unlock;
2017 err = maybe_init_creds(&scm, socket, other);
2019 goto err_state_unlock;
2023 skb = skb_peek_tail(&other->sk_receive_queue);
2024 if (tail && tail == skb) {
2026 } else if (!skb || !unix_skb_scm_eq(skb, &scm)) {
2033 } else if (newskb) {
2034 /* this is fast path, we don't necessarily need to
2035 * call to kfree_skb even though with newskb == NULL
2036 * this - does no harm
2038 consume_skb(newskb);
2042 if (skb_append_pagefrags(skb, page, offset, size)) {
2048 skb->data_len += size;
2049 skb->truesize += size;
2050 atomic_add(size, &sk->sk_wmem_alloc);
2053 err = unix_scm_to_skb(&scm, skb, false);
2055 goto err_state_unlock;
2056 spin_lock(&other->sk_receive_queue.lock);
2057 __skb_queue_tail(&other->sk_receive_queue, newskb);
2058 spin_unlock(&other->sk_receive_queue.lock);
2061 unix_state_unlock(other);
2062 mutex_unlock(&unix_sk(other)->iolock);
2064 other->sk_data_ready(other);
2069 unix_state_unlock(other);
2071 mutex_unlock(&unix_sk(other)->iolock);
2074 if (send_sigpipe && !(flags & MSG_NOSIGNAL))
2075 send_sig(SIGPIPE, current, 0);
2081 static int unix_seqpacket_sendmsg(struct socket *sock, struct msghdr *msg,
2085 struct sock *sk = sock->sk;
2087 err = sock_error(sk);
2091 if (sk->sk_state != TCP_ESTABLISHED)
2094 if (msg->msg_namelen)
2095 msg->msg_namelen = 0;
2097 return unix_dgram_sendmsg(sock, msg, len);
2100 static int unix_seqpacket_recvmsg(struct socket *sock, struct msghdr *msg,
2101 size_t size, int flags)
2103 struct sock *sk = sock->sk;
2105 if (sk->sk_state != TCP_ESTABLISHED)
2108 return unix_dgram_recvmsg(sock, msg, size, flags);
2111 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
2113 struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);
2116 msg->msg_namelen = addr->len;
2117 memcpy(msg->msg_name, addr->name, addr->len);
2121 static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
2122 size_t size, int flags)
2124 struct scm_cookie scm;
2125 struct sock *sk = sock->sk;
2126 struct unix_sock *u = unix_sk(sk);
2127 int noblock = flags & MSG_DONTWAIT;
2128 struct sk_buff *skb;
2136 err = mutex_lock_interruptible(&u->iolock);
2137 if (unlikely(err)) {
2138 /* recvmsg() in non blocking mode is supposed to return -EAGAIN
2139 * sk_rcvtimeo is not honored by mutex_lock_interruptible()
2141 err = noblock ? -EAGAIN : -ERESTARTSYS;
2145 skip = sk_peek_offset(sk, flags);
2147 skb = __skb_recv_datagram(sk, flags, &peeked, &skip, &err);
2149 unix_state_lock(sk);
2150 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
2151 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
2152 (sk->sk_shutdown & RCV_SHUTDOWN))
2154 unix_state_unlock(sk);
2158 wake_up_interruptible_sync_poll(&u->peer_wait,
2159 POLLOUT | POLLWRNORM | POLLWRBAND);
2162 unix_copy_addr(msg, skb->sk);
2164 if (size > skb->len - skip)
2165 size = skb->len - skip;
2166 else if (size < skb->len - skip)
2167 msg->msg_flags |= MSG_TRUNC;
2169 err = skb_copy_datagram_msg(skb, skip, msg, size);
2173 if (sock_flag(sk, SOCK_RCVTSTAMP))
2174 __sock_recv_timestamp(msg, sk, skb);
2176 memset(&scm, 0, sizeof(scm));
2178 scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2179 unix_set_secdata(&scm, skb);
2181 if (!(flags & MSG_PEEK)) {
2183 unix_detach_fds(&scm, skb);
2185 sk_peek_offset_bwd(sk, skb->len);
2187 /* It is questionable: on PEEK we could:
2188 - do not return fds - good, but too simple 8)
2189 - return fds, and do not return them on read (old strategy,
2191 - clone fds (I chose it for now, it is the most universal
2194 POSIX 1003.1g does not actually define this clearly
2195 at all. POSIX 1003.1g doesn't define a lot of things
2200 sk_peek_offset_fwd(sk, size);
2203 unix_peek_fds(&scm, skb);
2205 err = (flags & MSG_TRUNC) ? skb->len - skip : size;
2207 scm_recv(sock, msg, &scm, flags);
2210 skb_free_datagram(sk, skb);
2212 mutex_unlock(&u->iolock);
2218 * Sleep until more data has arrived. But check for races..
2220 static long unix_stream_data_wait(struct sock *sk, long timeo,
2221 struct sk_buff *last, unsigned int last_len,
2224 struct sk_buff *tail;
2227 unix_state_lock(sk);
2230 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2232 tail = skb_peek_tail(&sk->sk_receive_queue);
2234 (tail && tail->len != last_len) ||
2236 (sk->sk_shutdown & RCV_SHUTDOWN) ||
2237 signal_pending(current) ||
2241 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2242 unix_state_unlock(sk);
2244 timeo = freezable_schedule_timeout(timeo);
2246 timeo = schedule_timeout(timeo);
2247 unix_state_lock(sk);
2249 if (sock_flag(sk, SOCK_DEAD))
2252 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2255 finish_wait(sk_sleep(sk), &wait);
2256 unix_state_unlock(sk);
2260 static unsigned int unix_skb_len(const struct sk_buff *skb)
2262 return skb->len - UNIXCB(skb).consumed;
2265 struct unix_stream_read_state {
2266 int (*recv_actor)(struct sk_buff *, int, int,
2267 struct unix_stream_read_state *);
2268 struct socket *socket;
2270 struct pipe_inode_info *pipe;
2273 unsigned int splice_flags;
2276 static int unix_stream_read_generic(struct unix_stream_read_state *state,
2279 struct scm_cookie scm;
2280 struct socket *sock = state->socket;
2281 struct sock *sk = sock->sk;
2282 struct unix_sock *u = unix_sk(sk);
2284 int flags = state->flags;
2285 int noblock = flags & MSG_DONTWAIT;
2286 bool check_creds = false;
2291 size_t size = state->size;
2292 unsigned int last_len;
2294 if (unlikely(sk->sk_state != TCP_ESTABLISHED)) {
2299 if (unlikely(flags & MSG_OOB)) {
2304 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
2305 timeo = sock_rcvtimeo(sk, noblock);
2307 memset(&scm, 0, sizeof(scm));
2309 /* Lock the socket to prevent queue disordering
2310 * while sleeps in memcpy_tomsg
2312 mutex_lock(&u->iolock);
2314 if (flags & MSG_PEEK)
2315 skip = sk_peek_offset(sk, flags);
2322 struct sk_buff *skb, *last;
2324 unix_state_lock(sk);
2325 if (sock_flag(sk, SOCK_DEAD)) {
2329 last = skb = skb_peek(&sk->sk_receive_queue);
2330 last_len = last ? last->len : 0;
2333 unix_sk(sk)->recursion_level = 0;
2334 if (copied >= target)
2338 * POSIX 1003.1g mandates this order.
2341 err = sock_error(sk);
2344 if (sk->sk_shutdown & RCV_SHUTDOWN)
2347 unix_state_unlock(sk);
2353 mutex_unlock(&u->iolock);
2355 timeo = unix_stream_data_wait(sk, timeo, last,
2356 last_len, freezable);
2358 if (signal_pending(current)) {
2359 err = sock_intr_errno(timeo);
2364 mutex_lock(&u->iolock);
2367 unix_state_unlock(sk);
2371 while (skip >= unix_skb_len(skb)) {
2372 skip -= unix_skb_len(skb);
2374 last_len = skb->len;
2375 skb = skb_peek_next(skb, &sk->sk_receive_queue);
2380 unix_state_unlock(sk);
2383 /* Never glue messages from different writers */
2384 if (!unix_skb_scm_eq(skb, &scm))
2386 } else if (test_bit(SOCK_PASSCRED, &sock->flags)) {
2387 /* Copy credentials */
2388 scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2389 unix_set_secdata(&scm, skb);
2393 /* Copy address just once */
2394 if (state->msg && state->msg->msg_name) {
2395 DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr,
2396 state->msg->msg_name);
2397 unix_copy_addr(state->msg, skb->sk);
2401 chunk = min_t(unsigned int, unix_skb_len(skb) - skip, size);
2403 chunk = state->recv_actor(skb, skip, chunk, state);
2404 drop_skb = !unix_skb_len(skb);
2405 /* skb is only safe to use if !drop_skb */
2416 /* the skb was touched by a concurrent reader;
2417 * we should not expect anything from this skb
2418 * anymore and assume it invalid - we can be
2419 * sure it was dropped from the socket queue
2421 * let's report a short read
2427 /* Mark read part of skb as used */
2428 if (!(flags & MSG_PEEK)) {
2429 UNIXCB(skb).consumed += chunk;
2431 sk_peek_offset_bwd(sk, chunk);
2434 unix_detach_fds(&scm, skb);
2436 if (unix_skb_len(skb))
2439 skb_unlink(skb, &sk->sk_receive_queue);
2445 /* It is questionable, see note in unix_dgram_recvmsg.
2448 unix_peek_fds(&scm, skb);
2450 sk_peek_offset_fwd(sk, chunk);
2457 last_len = skb->len;
2458 unix_state_lock(sk);
2459 skb = skb_peek_next(skb, &sk->sk_receive_queue);
2462 unix_state_unlock(sk);
2467 mutex_unlock(&u->iolock);
2469 scm_recv(sock, state->msg, &scm, flags);
2473 return copied ? : err;
2476 static int unix_stream_read_actor(struct sk_buff *skb,
2477 int skip, int chunk,
2478 struct unix_stream_read_state *state)
2482 ret = skb_copy_datagram_msg(skb, UNIXCB(skb).consumed + skip,
2484 return ret ?: chunk;
2487 static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
2488 size_t size, int flags)
2490 struct unix_stream_read_state state = {
2491 .recv_actor = unix_stream_read_actor,
2498 return unix_stream_read_generic(&state, true);
2501 static ssize_t skb_unix_socket_splice(struct sock *sk,
2502 struct pipe_inode_info *pipe,
2503 struct splice_pipe_desc *spd)
2506 struct unix_sock *u = unix_sk(sk);
2508 mutex_unlock(&u->iolock);
2509 ret = splice_to_pipe(pipe, spd);
2510 mutex_lock(&u->iolock);
2515 static int unix_stream_splice_actor(struct sk_buff *skb,
2516 int skip, int chunk,
2517 struct unix_stream_read_state *state)
2519 return skb_splice_bits(skb, state->socket->sk,
2520 UNIXCB(skb).consumed + skip,
2521 state->pipe, chunk, state->splice_flags,
2522 skb_unix_socket_splice);
2525 static ssize_t unix_stream_splice_read(struct socket *sock, loff_t *ppos,
2526 struct pipe_inode_info *pipe,
2527 size_t size, unsigned int flags)
2529 struct unix_stream_read_state state = {
2530 .recv_actor = unix_stream_splice_actor,
2534 .splice_flags = flags,
2537 if (unlikely(*ppos))
2540 if (sock->file->f_flags & O_NONBLOCK ||
2541 flags & SPLICE_F_NONBLOCK)
2542 state.flags = MSG_DONTWAIT;
2544 return unix_stream_read_generic(&state, false);
2547 static int unix_shutdown(struct socket *sock, int mode)
2549 struct sock *sk = sock->sk;
2552 if (mode < SHUT_RD || mode > SHUT_RDWR)
2555 * SHUT_RD (0) -> RCV_SHUTDOWN (1)
2556 * SHUT_WR (1) -> SEND_SHUTDOWN (2)
2557 * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
2561 unix_state_lock(sk);
2562 sk->sk_shutdown |= mode;
2563 other = unix_peer(sk);
2566 unix_state_unlock(sk);
2567 sk->sk_state_change(sk);
2570 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2574 if (mode&RCV_SHUTDOWN)
2575 peer_mode |= SEND_SHUTDOWN;
2576 if (mode&SEND_SHUTDOWN)
2577 peer_mode |= RCV_SHUTDOWN;
2578 unix_state_lock(other);
2579 other->sk_shutdown |= peer_mode;
2580 unix_state_unlock(other);
2581 other->sk_state_change(other);
2582 if (peer_mode == SHUTDOWN_MASK)
2583 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2584 else if (peer_mode & RCV_SHUTDOWN)
2585 sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2593 long unix_inq_len(struct sock *sk)
2595 struct sk_buff *skb;
2598 if (sk->sk_state == TCP_LISTEN)
2601 spin_lock(&sk->sk_receive_queue.lock);
2602 if (sk->sk_type == SOCK_STREAM ||
2603 sk->sk_type == SOCK_SEQPACKET) {
2604 skb_queue_walk(&sk->sk_receive_queue, skb)
2605 amount += unix_skb_len(skb);
2607 skb = skb_peek(&sk->sk_receive_queue);
2611 spin_unlock(&sk->sk_receive_queue.lock);
2615 EXPORT_SYMBOL_GPL(unix_inq_len);
2617 long unix_outq_len(struct sock *sk)
2619 return sk_wmem_alloc_get(sk);
2621 EXPORT_SYMBOL_GPL(unix_outq_len);
2623 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2625 struct sock *sk = sock->sk;
2631 amount = unix_outq_len(sk);
2632 err = put_user(amount, (int __user *)arg);
2635 amount = unix_inq_len(sk);
2639 err = put_user(amount, (int __user *)arg);
2648 static unsigned int unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2650 struct sock *sk = sock->sk;
2653 sock_poll_wait(file, sk_sleep(sk), wait);
2656 /* exceptional events? */
2659 if (sk->sk_shutdown == SHUTDOWN_MASK)
2661 if (sk->sk_shutdown & RCV_SHUTDOWN)
2662 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2665 if (!skb_queue_empty(&sk->sk_receive_queue))
2666 mask |= POLLIN | POLLRDNORM;
2668 /* Connection-based need to check for termination and startup */
2669 if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2670 sk->sk_state == TCP_CLOSE)
2674 * we set writable also when the other side has shut down the
2675 * connection. This prevents stuck sockets.
2677 if (unix_writable(sk))
2678 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2683 static unsigned int unix_dgram_poll(struct file *file, struct socket *sock,
2686 struct sock *sk = sock->sk, *other;
2687 unsigned int mask, writable;
2689 sock_poll_wait(file, sk_sleep(sk), wait);
2692 /* exceptional events? */
2693 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
2695 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
2697 if (sk->sk_shutdown & RCV_SHUTDOWN)
2698 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
2699 if (sk->sk_shutdown == SHUTDOWN_MASK)
2703 if (!skb_queue_empty(&sk->sk_receive_queue))
2704 mask |= POLLIN | POLLRDNORM;
2706 /* Connection-based need to check for termination and startup */
2707 if (sk->sk_type == SOCK_SEQPACKET) {
2708 if (sk->sk_state == TCP_CLOSE)
2710 /* connection hasn't started yet? */
2711 if (sk->sk_state == TCP_SYN_SENT)
2715 /* No write status requested, avoid expensive OUT tests. */
2716 if (!(poll_requested_events(wait) & (POLLWRBAND|POLLWRNORM|POLLOUT)))
2719 writable = unix_writable(sk);
2721 unix_state_lock(sk);
2723 other = unix_peer(sk);
2724 if (other && unix_peer(other) != sk &&
2725 unix_recvq_full_lockless(other) &&
2726 unix_dgram_peer_wake_me(sk, other))
2729 unix_state_unlock(sk);
2733 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
2735 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2740 #ifdef CONFIG_PROC_FS
2742 #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2744 #define get_bucket(x) ((x) >> BUCKET_SPACE)
2745 #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2746 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2748 static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2750 unsigned long offset = get_offset(*pos);
2751 unsigned long bucket = get_bucket(*pos);
2753 unsigned long count = 0;
2755 for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2756 if (sock_net(sk) != seq_file_net(seq))
2758 if (++count == offset)
2765 static struct sock *unix_next_socket(struct seq_file *seq,
2769 unsigned long bucket;
2771 while (sk > (struct sock *)SEQ_START_TOKEN) {
2775 if (sock_net(sk) == seq_file_net(seq))
2780 sk = unix_from_bucket(seq, pos);
2785 bucket = get_bucket(*pos) + 1;
2786 *pos = set_bucket_offset(bucket, 1);
2787 } while (bucket < ARRAY_SIZE(unix_socket_table));
2792 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2793 __acquires(unix_table_lock)
2795 spin_lock(&unix_table_lock);
2798 return SEQ_START_TOKEN;
2800 if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2803 return unix_next_socket(seq, NULL, pos);
2806 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2809 return unix_next_socket(seq, v, pos);
2812 static void unix_seq_stop(struct seq_file *seq, void *v)
2813 __releases(unix_table_lock)
2815 spin_unlock(&unix_table_lock);
2818 static int unix_seq_show(struct seq_file *seq, void *v)
2821 if (v == SEQ_START_TOKEN)
2822 seq_puts(seq, "Num RefCount Protocol Flags Type St "
2826 struct unix_sock *u = unix_sk(s);
2829 seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2831 atomic_read(&s->sk_refcnt),
2833 s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2836 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2837 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2840 if (u->addr) { // under unix_table_lock here
2845 len = u->addr->len - sizeof(short);
2846 if (!UNIX_ABSTRACT(s))
2852 for ( ; i < len; i++)
2853 seq_putc(seq, u->addr->name->sun_path[i]);
2855 unix_state_unlock(s);
2856 seq_putc(seq, '\n');
2862 static const struct seq_operations unix_seq_ops = {
2863 .start = unix_seq_start,
2864 .next = unix_seq_next,
2865 .stop = unix_seq_stop,
2866 .show = unix_seq_show,
2869 static int unix_seq_open(struct inode *inode, struct file *file)
2871 return seq_open_net(inode, file, &unix_seq_ops,
2872 sizeof(struct seq_net_private));
2875 static const struct file_operations unix_seq_fops = {
2876 .owner = THIS_MODULE,
2877 .open = unix_seq_open,
2879 .llseek = seq_lseek,
2880 .release = seq_release_net,
2885 static const struct net_proto_family unix_family_ops = {
2887 .create = unix_create,
2888 .owner = THIS_MODULE,
2892 static int __net_init unix_net_init(struct net *net)
2894 int error = -ENOMEM;
2896 net->unx.sysctl_max_dgram_qlen = 10;
2897 if (unix_sysctl_register(net))
2900 #ifdef CONFIG_PROC_FS
2901 if (!proc_create("unix", 0, net->proc_net, &unix_seq_fops)) {
2902 unix_sysctl_unregister(net);
2911 static void __net_exit unix_net_exit(struct net *net)
2913 unix_sysctl_unregister(net);
2914 remove_proc_entry("unix", net->proc_net);
2917 static struct pernet_operations unix_net_ops = {
2918 .init = unix_net_init,
2919 .exit = unix_net_exit,
2922 static int __init af_unix_init(void)
2926 BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
2928 rc = proto_register(&unix_proto, 1);
2930 pr_crit("%s: Cannot create unix_sock SLAB cache!\n", __func__);
2934 sock_register(&unix_family_ops);
2935 register_pernet_subsys(&unix_net_ops);
2940 static void __exit af_unix_exit(void)
2942 sock_unregister(PF_UNIX);
2943 proto_unregister(&unix_proto);
2944 unregister_pernet_subsys(&unix_net_ops);
2947 /* Earlier than device_initcall() so that other drivers invoking
2948 request_module() don't end up in a loop when modprobe tries
2949 to use a UNIX socket. But later than subsys_initcall() because
2950 we depend on stuff initialised there */
2951 fs_initcall(af_unix_init);
2952 module_exit(af_unix_exit);
2954 MODULE_LICENSE("GPL");
2955 MODULE_ALIAS_NETPROTO(PF_UNIX);