2 * NET4: Implementation of BSD Unix domain sockets.
4 * Authors: Alan Cox, <alan.cox@linux.org>
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.
11 * Version: $Id: af_unix.c,v 1.133 2002/02/08 03:57:19 davem Exp $
14 * Linus Torvalds : Assorted bug cures.
15 * Niibe Yutaka : async I/O support.
16 * Carsten Paeth : PF_UNIX check, address fixes.
17 * Alan Cox : Limit size of allocated blocks.
18 * Alan Cox : Fixed the stupid socketpair bug.
19 * Alan Cox : BSD compatibility fine tuning.
20 * Alan Cox : Fixed a bug in connect when interrupted.
21 * Alan Cox : Sorted out a proper draft version of
22 * file descriptor passing hacked up from
24 * Marty Leisner : Fixes to fd passing
25 * Nick Nevin : recvmsg bugfix.
26 * Alan Cox : Started proper garbage collector
27 * Heiko EiBfeldt : Missing verify_area check
28 * Alan Cox : Started POSIXisms
29 * Andreas Schwab : Replace inode by dentry for proper
31 * Kirk Petersen : Made this a module
32 * Christoph Rohland : Elegant non-blocking accept/connect algorithm.
34 * Alexey Kuznetosv : Repaired (I hope) bugs introduces
35 * by above two patches.
36 * Andrea Arcangeli : If possible we block in connect(2)
37 * if the max backlog of the listen socket
38 * is been reached. This won't break
39 * old apps and it will avoid huge amount
40 * of socks hashed (this for unix_gc()
41 * performances reasons).
42 * Security fix that limits the max
43 * number of socks to 2*max_files and
44 * the number of skb queueable in the
46 * Artur Skawina : Hash function optimizations
47 * Alexey Kuznetsov : Full scale SMP. Lot of bugs are introduced 8)
48 * Malcolm Beattie : Set peercred for socketpair
49 * Michal Ostrowski : Module initialization cleanup.
50 * Arnaldo C. Melo : Remove MOD_{INC,DEC}_USE_COUNT,
51 * the core infrastructure is doing that
52 * for all net proto families now (2.5.69+)
55 * Known differences from reference BSD that was tested:
58 * ECONNREFUSED is not returned from one end of a connected() socket to the
59 * other the moment one end closes.
60 * fstat() doesn't return st_dev=0, and give the blksize as high water mark
61 * and a fake inode identifier (nor the BSD first socket fstat twice bug).
63 * accept() returns a path name even if the connecting socket has closed
64 * in the meantime (BSD loses the path and gives up).
65 * accept() returns 0 length path for an unbound connector. BSD returns 16
66 * and a null first byte in the path (but not for gethost/peername - BSD bug ??)
67 * socketpair(...SOCK_RAW..) doesn't panic the kernel.
68 * BSD af_unix apparently has connect forgetting to block properly.
69 * (need to check this with the POSIX spec in detail)
71 * Differences from 2.0.0-11-... (ANK)
72 * Bug fixes and improvements.
73 * - client shutdown killed server socket.
74 * - removed all useless cli/sti pairs.
76 * Semantic changes/extensions.
77 * - generic control message passing.
78 * - SCM_CREDENTIALS control message.
79 * - "Abstract" (not FS based) socket bindings.
80 * Abstract names are sequences of bytes (not zero terminated)
81 * started by 0, so that this name space does not intersect
85 #include <linux/module.h>
86 #include <linux/config.h>
87 #include <linux/kernel.h>
88 #include <linux/signal.h>
89 #include <linux/sched.h>
90 #include <linux/errno.h>
91 #include <linux/string.h>
92 #include <linux/stat.h>
93 #include <linux/dcache.h>
94 #include <linux/namei.h>
95 #include <linux/socket.h>
97 #include <linux/fcntl.h>
98 #include <linux/termios.h>
99 #include <linux/sockios.h>
100 #include <linux/net.h>
101 #include <linux/in.h>
102 #include <linux/fs.h>
103 #include <linux/slab.h>
104 #include <asm/uaccess.h>
105 #include <linux/skbuff.h>
106 #include <linux/netdevice.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/smp_lock.h>
116 #include <linux/rtnetlink.h>
117 #include <linux/mount.h>
118 #include <net/checksum.h>
119 #include <linux/security.h>
120 #include <linux/vs_context.h>
121 #include <linux/vs_network.h>
122 #include <linux/vs_limit.h>
124 int sysctl_unix_max_dgram_qlen = 10;
126 struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1];
127 DEFINE_SPINLOCK(unix_table_lock);
128 static atomic_t unix_nr_socks = ATOMIC_INIT(0);
130 #define unix_sockets_unbound (&unix_socket_table[UNIX_HASH_SIZE])
132 #define UNIX_ABSTRACT(sk) (unix_sk(sk)->addr->hash != UNIX_HASH_SIZE)
135 * SMP locking strategy:
136 * hash table is protected with spinlock unix_table_lock
137 * each socket state is protected by separate rwlock.
140 static inline unsigned unix_hash_fold(unsigned hash)
144 return hash&(UNIX_HASH_SIZE-1);
147 #define unix_peer(sk) (unix_sk(sk)->peer)
149 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
151 return unix_peer(osk) == sk;
154 static inline int unix_may_send(struct sock *sk, struct sock *osk)
156 return (unix_peer(osk) == NULL || unix_our_peer(sk, osk));
159 static struct sock *unix_peer_get(struct sock *s)
167 unix_state_runlock(s);
171 static inline void unix_release_addr(struct unix_address *addr)
173 if (atomic_dec_and_test(&addr->refcnt))
178 * Check unix socket name:
179 * - should be not zero length.
180 * - if started by not zero, should be NULL terminated (FS object)
181 * - if started by zero, it is abstract name.
184 static int unix_mkname(struct sockaddr_un * sunaddr, int len, unsigned *hashp)
186 if (len <= sizeof(short) || len > sizeof(*sunaddr))
188 if (!sunaddr || sunaddr->sun_family != AF_UNIX)
190 if (sunaddr->sun_path[0]) {
192 * This may look like an off by one error but it is a bit more
193 * subtle. 108 is the longest valid AF_UNIX path for a binding.
194 * sun_path[108] doesnt as such exist. However in kernel space
195 * we are guaranteed that it is a valid memory location in our
196 * kernel address buffer.
198 ((char *)sunaddr)[len]=0;
199 len = strlen(sunaddr->sun_path)+1+sizeof(short);
203 *hashp = unix_hash_fold(csum_partial((char*)sunaddr, len, 0));
207 static void __unix_remove_socket(struct sock *sk)
209 sk_del_node_init(sk);
212 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
214 BUG_TRAP(sk_unhashed(sk));
215 sk_add_node(sk, list);
218 static inline void unix_remove_socket(struct sock *sk)
220 spin_lock(&unix_table_lock);
221 __unix_remove_socket(sk);
222 spin_unlock(&unix_table_lock);
225 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
227 spin_lock(&unix_table_lock);
228 __unix_insert_socket(list, sk);
229 spin_unlock(&unix_table_lock);
232 static struct sock *__unix_find_socket_byname(struct sockaddr_un *sunname,
233 int len, int type, unsigned hash)
236 struct hlist_node *node;
238 sk_for_each(s, node, &unix_socket_table[hash ^ type]) {
239 struct unix_sock *u = unix_sk(s);
241 if (!vx_check(s->sk_xid, VX_IDENT|VX_WATCH))
243 if (u->addr->len == len &&
244 !memcmp(u->addr->name, sunname, len))
252 static inline struct sock *unix_find_socket_byname(struct sockaddr_un *sunname,
258 spin_lock(&unix_table_lock);
259 s = __unix_find_socket_byname(sunname, len, type, hash);
262 spin_unlock(&unix_table_lock);
266 static struct sock *unix_find_socket_byinode(struct inode *i)
269 struct hlist_node *node;
271 spin_lock(&unix_table_lock);
273 &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
274 struct dentry *dentry = unix_sk(s)->dentry;
276 if(dentry && dentry->d_inode == i)
284 spin_unlock(&unix_table_lock);
288 static inline int unix_writable(struct sock *sk)
290 return (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
293 static void unix_write_space(struct sock *sk)
295 read_lock(&sk->sk_callback_lock);
296 if (unix_writable(sk)) {
297 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
298 wake_up_interruptible(sk->sk_sleep);
299 sk_wake_async(sk, 2, POLL_OUT);
301 read_unlock(&sk->sk_callback_lock);
304 /* When dgram socket disconnects (or changes its peer), we clear its receive
305 * queue of packets arrived from previous peer. First, it allows to do
306 * flow control based only on wmem_alloc; second, sk connected to peer
307 * may receive messages only from that peer. */
308 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
310 if (!skb_queue_empty(&sk->sk_receive_queue)) {
311 skb_queue_purge(&sk->sk_receive_queue);
312 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
314 /* If one link of bidirectional dgram pipe is disconnected,
315 * we signal error. Messages are lost. Do not make this,
316 * when peer was not connected to us.
318 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
319 other->sk_err = ECONNRESET;
320 other->sk_error_report(other);
325 static void unix_sock_destructor(struct sock *sk)
327 struct unix_sock *u = unix_sk(sk);
329 skb_queue_purge(&sk->sk_receive_queue);
331 BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
332 BUG_TRAP(sk_unhashed(sk));
333 BUG_TRAP(!sk->sk_socket);
334 if (!sock_flag(sk, SOCK_DEAD)) {
335 printk("Attempt to release alive unix socket: %p\n", sk);
340 unix_release_addr(u->addr);
342 atomic_dec(&unix_nr_socks);
343 #ifdef UNIX_REFCNT_DEBUG
344 printk(KERN_DEBUG "UNIX %p is destroyed, %d are still alive.\n", sk, atomic_read(&unix_nr_socks));
348 static int unix_release_sock (struct sock *sk, int embrion)
350 struct unix_sock *u = unix_sk(sk);
351 struct dentry *dentry;
352 struct vfsmount *mnt;
357 unix_remove_socket(sk);
360 unix_state_wlock(sk);
362 sk->sk_shutdown = SHUTDOWN_MASK;
367 state = sk->sk_state;
368 sk->sk_state = TCP_CLOSE;
369 unix_state_wunlock(sk);
371 wake_up_interruptible_all(&u->peer_wait);
373 skpair=unix_peer(sk);
376 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
377 unix_state_wlock(skpair);
379 skpair->sk_shutdown = SHUTDOWN_MASK;
380 if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
381 skpair->sk_err = ECONNRESET;
382 unix_state_wunlock(skpair);
383 skpair->sk_state_change(skpair);
384 read_lock(&skpair->sk_callback_lock);
385 sk_wake_async(skpair,1,POLL_HUP);
386 read_unlock(&skpair->sk_callback_lock);
388 sock_put(skpair); /* It may now die */
389 unix_peer(sk) = NULL;
392 /* Try to flush out this socket. Throw out buffers at least */
394 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
395 if (state==TCP_LISTEN)
396 unix_release_sock(skb->sk, 1);
397 /* passed fds are erased in the kfree_skb hook */
408 /* ---- Socket is dead now and most probably destroyed ---- */
411 * Fixme: BSD difference: In BSD all sockets connected to use get
412 * ECONNRESET and we die on the spot. In Linux we behave
413 * like files and pipes do and wait for the last
416 * Can't we simply set sock->err?
418 * What the above comment does talk about? --ANK(980817)
421 if (atomic_read(&unix_tot_inflight))
422 unix_gc(); /* Garbage collect fds */
427 static int unix_listen(struct socket *sock, int backlog)
430 struct sock *sk = sock->sk;
431 struct unix_sock *u = unix_sk(sk);
434 if (sock->type!=SOCK_STREAM && sock->type!=SOCK_SEQPACKET)
435 goto out; /* Only stream/seqpacket sockets accept */
438 goto out; /* No listens on an unbound socket */
439 unix_state_wlock(sk);
440 if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
442 if (backlog > sk->sk_max_ack_backlog)
443 wake_up_interruptible_all(&u->peer_wait);
444 sk->sk_max_ack_backlog = backlog;
445 sk->sk_state = TCP_LISTEN;
446 /* set credentials so connect can copy them */
447 sk->sk_peercred.pid = current->tgid;
448 sk->sk_peercred.uid = current->euid;
449 sk->sk_peercred.gid = current->egid;
453 unix_state_wunlock(sk);
458 static int unix_release(struct socket *);
459 static int unix_bind(struct socket *, struct sockaddr *, int);
460 static int unix_stream_connect(struct socket *, struct sockaddr *,
461 int addr_len, int flags);
462 static int unix_socketpair(struct socket *, struct socket *);
463 static int unix_accept(struct socket *, struct socket *, int);
464 static int unix_getname(struct socket *, struct sockaddr *, int *, int);
465 static unsigned int unix_poll(struct file *, struct socket *, poll_table *);
466 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
467 static int unix_shutdown(struct socket *, int);
468 static int unix_stream_sendmsg(struct kiocb *, struct socket *,
469 struct msghdr *, size_t);
470 static int unix_stream_recvmsg(struct kiocb *, struct socket *,
471 struct msghdr *, size_t, int);
472 static int unix_dgram_sendmsg(struct kiocb *, struct socket *,
473 struct msghdr *, size_t);
474 static int unix_dgram_recvmsg(struct kiocb *, struct socket *,
475 struct msghdr *, size_t, int);
476 static int unix_dgram_connect(struct socket *, struct sockaddr *,
478 static int unix_seqpacket_sendmsg(struct kiocb *, struct socket *,
479 struct msghdr *, size_t);
481 static const struct proto_ops unix_stream_ops = {
483 .owner = THIS_MODULE,
484 .release = unix_release,
486 .connect = unix_stream_connect,
487 .socketpair = unix_socketpair,
488 .accept = unix_accept,
489 .getname = unix_getname,
492 .listen = unix_listen,
493 .shutdown = unix_shutdown,
494 .setsockopt = sock_no_setsockopt,
495 .getsockopt = sock_no_getsockopt,
496 .sendmsg = unix_stream_sendmsg,
497 .recvmsg = unix_stream_recvmsg,
498 .mmap = sock_no_mmap,
499 .sendpage = sock_no_sendpage,
502 static const struct proto_ops unix_dgram_ops = {
504 .owner = THIS_MODULE,
505 .release = unix_release,
507 .connect = unix_dgram_connect,
508 .socketpair = unix_socketpair,
509 .accept = sock_no_accept,
510 .getname = unix_getname,
511 .poll = datagram_poll,
513 .listen = sock_no_listen,
514 .shutdown = unix_shutdown,
515 .setsockopt = sock_no_setsockopt,
516 .getsockopt = sock_no_getsockopt,
517 .sendmsg = unix_dgram_sendmsg,
518 .recvmsg = unix_dgram_recvmsg,
519 .mmap = sock_no_mmap,
520 .sendpage = sock_no_sendpage,
523 static const struct proto_ops unix_seqpacket_ops = {
525 .owner = THIS_MODULE,
526 .release = unix_release,
528 .connect = unix_stream_connect,
529 .socketpair = unix_socketpair,
530 .accept = unix_accept,
531 .getname = unix_getname,
532 .poll = datagram_poll,
534 .listen = unix_listen,
535 .shutdown = unix_shutdown,
536 .setsockopt = sock_no_setsockopt,
537 .getsockopt = sock_no_getsockopt,
538 .sendmsg = unix_seqpacket_sendmsg,
539 .recvmsg = unix_dgram_recvmsg,
540 .mmap = sock_no_mmap,
541 .sendpage = sock_no_sendpage,
544 static struct proto unix_proto = {
546 .owner = THIS_MODULE,
547 .obj_size = sizeof(struct unix_sock),
550 static struct sock * unix_create1(struct socket *sock)
552 struct sock *sk = NULL;
555 if (atomic_read(&unix_nr_socks) >= 2*get_max_files())
558 sk = sk_alloc(PF_UNIX, GFP_KERNEL, &unix_proto, 1);
562 atomic_inc(&unix_nr_socks);
564 sock_init_data(sock,sk);
566 sk->sk_write_space = unix_write_space;
567 sk->sk_max_ack_backlog = sysctl_unix_max_dgram_qlen;
568 sk->sk_destruct = unix_sock_destructor;
572 spin_lock_init(&u->lock);
573 atomic_set(&u->inflight, sock ? 0 : -1);
574 mutex_init(&u->readlock); /* single task reading lock */
575 init_waitqueue_head(&u->peer_wait);
576 unix_insert_socket(unix_sockets_unbound, sk);
581 static int unix_create(struct socket *sock, int protocol)
583 if (protocol && protocol != PF_UNIX)
584 return -EPROTONOSUPPORT;
586 sock->state = SS_UNCONNECTED;
588 switch (sock->type) {
590 sock->ops = &unix_stream_ops;
593 * Believe it or not BSD has AF_UNIX, SOCK_RAW though
597 sock->type=SOCK_DGRAM;
599 sock->ops = &unix_dgram_ops;
602 sock->ops = &unix_seqpacket_ops;
605 return -ESOCKTNOSUPPORT;
608 return unix_create1(sock) ? 0 : -ENOMEM;
611 static int unix_release(struct socket *sock)
613 struct sock *sk = sock->sk;
620 return unix_release_sock (sk, 0);
623 static int unix_autobind(struct socket *sock)
625 struct sock *sk = sock->sk;
626 struct unix_sock *u = unix_sk(sk);
627 static u32 ordernum = 1;
628 struct unix_address * addr;
631 mutex_lock(&u->readlock);
638 addr = kmalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
642 memset(addr, 0, sizeof(*addr) + sizeof(short) + 16);
643 addr->name->sun_family = AF_UNIX;
644 atomic_set(&addr->refcnt, 1);
647 addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
648 addr->hash = unix_hash_fold(csum_partial((void*)addr->name, addr->len, 0));
650 spin_lock(&unix_table_lock);
651 ordernum = (ordernum+1)&0xFFFFF;
653 if (__unix_find_socket_byname(addr->name, addr->len, sock->type,
655 spin_unlock(&unix_table_lock);
656 /* Sanity yield. It is unusual case, but yet... */
657 if (!(ordernum&0xFF))
661 addr->hash ^= sk->sk_type;
663 __unix_remove_socket(sk);
665 __unix_insert_socket(&unix_socket_table[addr->hash], sk);
666 spin_unlock(&unix_table_lock);
669 out: mutex_unlock(&u->readlock);
673 static struct sock *unix_find_other(struct sockaddr_un *sunname, int len,
674 int type, unsigned hash, int *error)
680 if (sunname->sun_path[0]) {
681 err = path_lookup(sunname->sun_path, LOOKUP_FOLLOW, &nd);
684 err = vfs_permission(&nd, MAY_WRITE);
689 if (!S_ISSOCK(nd.dentry->d_inode->i_mode))
691 u=unix_find_socket_byinode(nd.dentry->d_inode);
695 if (u->sk_type == type)
696 touch_atime(nd.mnt, nd.dentry);
701 if (u->sk_type != type) {
707 u=unix_find_socket_byname(sunname, len, type, hash);
709 struct dentry *dentry;
710 dentry = unix_sk(u)->dentry;
712 touch_atime(unix_sk(u)->mnt, dentry);
726 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
728 struct sock *sk = sock->sk;
729 struct unix_sock *u = unix_sk(sk);
730 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
731 struct dentry * dentry = NULL;
735 struct unix_address *addr;
736 struct hlist_head *list;
739 if (sunaddr->sun_family != AF_UNIX)
742 if (addr_len==sizeof(short)) {
743 err = unix_autobind(sock);
747 err = unix_mkname(sunaddr, addr_len, &hash);
752 mutex_lock(&u->readlock);
759 addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
763 memcpy(addr->name, sunaddr, addr_len);
764 addr->len = addr_len;
765 addr->hash = hash ^ sk->sk_type;
766 atomic_set(&addr->refcnt, 1);
768 if (sunaddr->sun_path[0]) {
772 * Get the parent directory, calculate the hash for last
775 err = path_lookup(sunaddr->sun_path, LOOKUP_PARENT, &nd);
777 goto out_mknod_parent;
779 dentry = lookup_create(&nd, 0);
780 err = PTR_ERR(dentry);
782 goto out_mknod_unlock;
785 * All right, let's create it.
788 (SOCK_INODE(sock)->i_mode & ~current->fs->umask);
789 err = vfs_mknod(nd.dentry->d_inode, dentry, mode, 0, NULL);
792 mutex_unlock(&nd.dentry->d_inode->i_mutex);
796 addr->hash = UNIX_HASH_SIZE;
799 spin_lock(&unix_table_lock);
801 if (!sunaddr->sun_path[0]) {
803 if (__unix_find_socket_byname(sunaddr, addr_len,
804 sk->sk_type, hash)) {
805 unix_release_addr(addr);
809 list = &unix_socket_table[addr->hash];
811 list = &unix_socket_table[dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1)];
812 u->dentry = nd.dentry;
817 __unix_remove_socket(sk);
819 __unix_insert_socket(list, sk);
822 spin_unlock(&unix_table_lock);
824 mutex_unlock(&u->readlock);
831 mutex_unlock(&nd.dentry->d_inode->i_mutex);
836 unix_release_addr(addr);
840 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
843 struct sock *sk = sock->sk;
844 struct sockaddr_un *sunaddr=(struct sockaddr_un*)addr;
849 if (addr->sa_family != AF_UNSPEC) {
850 err = unix_mkname(sunaddr, alen, &hash);
855 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
856 !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
859 other=unix_find_other(sunaddr, alen, sock->type, hash, &err);
863 unix_state_wlock(sk);
866 if (!unix_may_send(sk, other))
869 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
875 * 1003.1g breaking connected state with AF_UNSPEC
878 unix_state_wlock(sk);
882 * If it was connected, reconnect.
885 struct sock *old_peer = unix_peer(sk);
887 unix_state_wunlock(sk);
889 if (other != old_peer)
890 unix_dgram_disconnected(sk, old_peer);
894 unix_state_wunlock(sk);
899 unix_state_wunlock(sk);
905 static long unix_wait_for_peer(struct sock *other, long timeo)
907 struct unix_sock *u = unix_sk(other);
911 prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
913 sched = !sock_flag(other, SOCK_DEAD) &&
914 !(other->sk_shutdown & RCV_SHUTDOWN) &&
915 (skb_queue_len(&other->sk_receive_queue) >
916 other->sk_max_ack_backlog);
918 unix_state_runlock(other);
921 timeo = schedule_timeout(timeo);
923 finish_wait(&u->peer_wait, &wait);
927 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
928 int addr_len, int flags)
930 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
931 struct sock *sk = sock->sk;
932 struct unix_sock *u = unix_sk(sk), *newu, *otheru;
933 struct sock *newsk = NULL;
934 struct sock *other = NULL;
935 struct sk_buff *skb = NULL;
941 err = unix_mkname(sunaddr, addr_len, &hash);
946 if (test_bit(SOCK_PASSCRED, &sock->flags)
947 && !u->addr && (err = unix_autobind(sock)) != 0)
950 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
952 /* First of all allocate resources.
953 If we will make it after state is locked,
954 we will have to recheck all again in any case.
959 /* create new sock for complete connection */
960 newsk = unix_create1(NULL);
964 /* Allocate skb for sending to listening sock */
965 skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
970 /* Find listening sock. */
971 other = unix_find_other(sunaddr, addr_len, sk->sk_type, hash, &err);
975 /* Latch state of peer */
976 unix_state_rlock(other);
978 /* Apparently VFS overslept socket death. Retry. */
979 if (sock_flag(other, SOCK_DEAD)) {
980 unix_state_runlock(other);
986 if (other->sk_state != TCP_LISTEN)
989 if (skb_queue_len(&other->sk_receive_queue) >
990 other->sk_max_ack_backlog) {
995 timeo = unix_wait_for_peer(other, timeo);
997 err = sock_intr_errno(timeo);
998 if (signal_pending(current))
1006 It is tricky place. We need to grab write lock and cannot
1007 drop lock on peer. It is dangerous because deadlock is
1008 possible. Connect to self case and simultaneous
1009 attempt to connect are eliminated by checking socket
1010 state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1011 check this before attempt to grab lock.
1013 Well, and we have to recheck the state after socket locked.
1019 /* This is ok... continue with connect */
1021 case TCP_ESTABLISHED:
1022 /* Socket is already connected */
1030 unix_state_wlock(sk);
1032 if (sk->sk_state != st) {
1033 unix_state_wunlock(sk);
1034 unix_state_runlock(other);
1039 err = security_unix_stream_connect(sock, other->sk_socket, newsk);
1041 unix_state_wunlock(sk);
1045 /* The way is open! Fastly set all the necessary fields... */
1048 unix_peer(newsk) = sk;
1049 newsk->sk_state = TCP_ESTABLISHED;
1050 newsk->sk_type = sk->sk_type;
1051 newsk->sk_peercred.pid = current->tgid;
1052 newsk->sk_peercred.uid = current->euid;
1053 newsk->sk_peercred.gid = current->egid;
1054 newu = unix_sk(newsk);
1055 newsk->sk_sleep = &newu->peer_wait;
1056 otheru = unix_sk(other);
1058 /* copy address information from listening to new sock*/
1060 atomic_inc(&otheru->addr->refcnt);
1061 newu->addr = otheru->addr;
1063 if (otheru->dentry) {
1064 newu->dentry = dget(otheru->dentry);
1065 newu->mnt = mntget(otheru->mnt);
1068 /* Set credentials */
1069 sk->sk_peercred = other->sk_peercred;
1071 sock->state = SS_CONNECTED;
1072 sk->sk_state = TCP_ESTABLISHED;
1075 smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */
1076 unix_peer(sk) = newsk;
1078 unix_state_wunlock(sk);
1080 /* take ten and and send info to listening sock */
1081 spin_lock(&other->sk_receive_queue.lock);
1082 __skb_queue_tail(&other->sk_receive_queue, skb);
1083 /* Undo artificially decreased inflight after embrion
1084 * is installed to listening socket. */
1085 atomic_inc(&newu->inflight);
1086 spin_unlock(&other->sk_receive_queue.lock);
1087 unix_state_runlock(other);
1088 other->sk_data_ready(other, 0);
1094 unix_state_runlock(other);
1100 unix_release_sock(newsk, 0);
1106 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1108 struct sock *ska=socka->sk, *skb = sockb->sk;
1110 /* Join our sockets back to back */
1115 ska->sk_peercred.pid = skb->sk_peercred.pid = current->tgid;
1116 ska->sk_peercred.uid = skb->sk_peercred.uid = current->euid;
1117 ska->sk_peercred.gid = skb->sk_peercred.gid = current->egid;
1119 if (ska->sk_type != SOCK_DGRAM) {
1120 ska->sk_state = TCP_ESTABLISHED;
1121 skb->sk_state = TCP_ESTABLISHED;
1122 socka->state = SS_CONNECTED;
1123 sockb->state = SS_CONNECTED;
1128 static int unix_accept(struct socket *sock, struct socket *newsock, int flags)
1130 struct sock *sk = sock->sk;
1132 struct sk_buff *skb;
1136 if (sock->type!=SOCK_STREAM && sock->type!=SOCK_SEQPACKET)
1140 if (sk->sk_state != TCP_LISTEN)
1143 /* If socket state is TCP_LISTEN it cannot change (for now...),
1144 * so that no locks are necessary.
1147 skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1149 /* This means receive shutdown. */
1156 skb_free_datagram(sk, skb);
1157 wake_up_interruptible(&unix_sk(sk)->peer_wait);
1159 /* attach accepted sock to socket */
1160 unix_state_wlock(tsk);
1161 newsock->state = SS_CONNECTED;
1162 sock_graft(tsk, newsock);
1163 unix_state_wunlock(tsk);
1171 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
1173 struct sock *sk = sock->sk;
1174 struct unix_sock *u;
1175 struct sockaddr_un *sunaddr=(struct sockaddr_un *)uaddr;
1179 sk = unix_peer_get(sk);
1190 unix_state_rlock(sk);
1192 sunaddr->sun_family = AF_UNIX;
1193 sunaddr->sun_path[0] = 0;
1194 *uaddr_len = sizeof(short);
1196 struct unix_address *addr = u->addr;
1198 *uaddr_len = addr->len;
1199 memcpy(sunaddr, addr->name, *uaddr_len);
1201 unix_state_runlock(sk);
1207 static void unix_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1211 scm->fp = UNIXCB(skb).fp;
1212 skb->destructor = sock_wfree;
1213 UNIXCB(skb).fp = NULL;
1215 for (i=scm->fp->count-1; i>=0; i--)
1216 unix_notinflight(scm->fp->fp[i]);
1219 static void unix_destruct_fds(struct sk_buff *skb)
1221 struct scm_cookie scm;
1222 memset(&scm, 0, sizeof(scm));
1223 unix_detach_fds(&scm, skb);
1225 /* Alas, it calls VFS */
1226 /* So fscking what? fput() had been SMP-safe since the last Summer */
1231 static void unix_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
1234 for (i=scm->fp->count-1; i>=0; i--)
1235 unix_inflight(scm->fp->fp[i]);
1236 UNIXCB(skb).fp = scm->fp;
1237 skb->destructor = unix_destruct_fds;
1242 * Send AF_UNIX data.
1245 static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
1246 struct msghdr *msg, size_t len)
1248 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1249 struct sock *sk = sock->sk;
1250 struct unix_sock *u = unix_sk(sk);
1251 struct sockaddr_un *sunaddr=msg->msg_name;
1252 struct sock *other = NULL;
1253 int namelen = 0; /* fake GCC */
1256 struct sk_buff *skb;
1258 struct scm_cookie tmp_scm;
1260 if (NULL == siocb->scm)
1261 siocb->scm = &tmp_scm;
1262 err = scm_send(sock, msg, siocb->scm);
1267 if (msg->msg_flags&MSG_OOB)
1270 if (msg->msg_namelen) {
1271 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1278 other = unix_peer_get(sk);
1283 if (test_bit(SOCK_PASSCRED, &sock->flags)
1284 && !u->addr && (err = unix_autobind(sock)) != 0)
1288 if (len > sk->sk_sndbuf - 32)
1291 skb = sock_alloc_send_skb(sk, len, msg->msg_flags&MSG_DONTWAIT, &err);
1295 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
1297 unix_attach_fds(siocb->scm, skb);
1299 skb->h.raw = skb->data;
1300 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
1304 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1309 if (sunaddr == NULL)
1312 other = unix_find_other(sunaddr, namelen, sk->sk_type,
1318 unix_state_rlock(other);
1320 if (!unix_may_send(sk, other))
1323 if (sock_flag(other, SOCK_DEAD)) {
1325 * Check with 1003.1g - what should
1328 unix_state_runlock(other);
1332 unix_state_wlock(sk);
1333 if (unix_peer(sk) == other) {
1335 unix_state_wunlock(sk);
1337 unix_dgram_disconnected(sk, other);
1339 err = -ECONNREFUSED;
1341 unix_state_wunlock(sk);
1351 if (other->sk_shutdown & RCV_SHUTDOWN)
1354 if (sk->sk_type != SOCK_SEQPACKET) {
1355 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1360 if (unix_peer(other) != sk &&
1361 (skb_queue_len(&other->sk_receive_queue) >
1362 other->sk_max_ack_backlog)) {
1368 timeo = unix_wait_for_peer(other, timeo);
1370 err = sock_intr_errno(timeo);
1371 if (signal_pending(current))
1377 skb_queue_tail(&other->sk_receive_queue, skb);
1378 unix_state_runlock(other);
1379 other->sk_data_ready(other, len);
1381 scm_destroy(siocb->scm);
1385 unix_state_runlock(other);
1391 scm_destroy(siocb->scm);
1396 static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1397 struct msghdr *msg, size_t len)
1399 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1400 struct sock *sk = sock->sk;
1401 struct sock *other = NULL;
1402 struct sockaddr_un *sunaddr=msg->msg_name;
1404 struct sk_buff *skb;
1406 struct scm_cookie tmp_scm;
1408 if (NULL == siocb->scm)
1409 siocb->scm = &tmp_scm;
1410 err = scm_send(sock, msg, siocb->scm);
1415 if (msg->msg_flags&MSG_OOB)
1418 if (msg->msg_namelen) {
1419 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1424 other = unix_peer(sk);
1429 if (sk->sk_shutdown & SEND_SHUTDOWN)
1435 * Optimisation for the fact that under 0.01% of X
1436 * messages typically need breaking up.
1441 /* Keep two messages in the pipe so it schedules better */
1442 if (size > ((sk->sk_sndbuf >> 1) - 64))
1443 size = (sk->sk_sndbuf >> 1) - 64;
1445 if (size > SKB_MAX_ALLOC)
1446 size = SKB_MAX_ALLOC;
1452 skb=sock_alloc_send_skb(sk,size,msg->msg_flags&MSG_DONTWAIT, &err);
1458 * If you pass two values to the sock_alloc_send_skb
1459 * it tries to grab the large buffer with GFP_NOFS
1460 * (which can fail easily), and if it fails grab the
1461 * fallback size buffer which is under a page and will
1464 size = min_t(int, size, skb_tailroom(skb));
1466 memcpy(UNIXCREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
1468 unix_attach_fds(siocb->scm, skb);
1470 if ((err = memcpy_fromiovec(skb_put(skb,size), msg->msg_iov, size)) != 0) {
1475 unix_state_rlock(other);
1477 if (sock_flag(other, SOCK_DEAD) ||
1478 (other->sk_shutdown & RCV_SHUTDOWN))
1481 skb_queue_tail(&other->sk_receive_queue, skb);
1482 unix_state_runlock(other);
1483 other->sk_data_ready(other, size);
1487 scm_destroy(siocb->scm);
1493 unix_state_runlock(other);
1496 if (sent==0 && !(msg->msg_flags&MSG_NOSIGNAL))
1497 send_sig(SIGPIPE,current,0);
1500 scm_destroy(siocb->scm);
1502 return sent ? : err;
1505 static int unix_seqpacket_sendmsg(struct kiocb *kiocb, struct socket *sock,
1506 struct msghdr *msg, size_t len)
1509 struct sock *sk = sock->sk;
1511 err = sock_error(sk);
1515 if (sk->sk_state != TCP_ESTABLISHED)
1518 if (msg->msg_namelen)
1519 msg->msg_namelen = 0;
1521 return unix_dgram_sendmsg(kiocb, sock, msg, len);
1524 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
1526 struct unix_sock *u = unix_sk(sk);
1528 msg->msg_namelen = 0;
1530 msg->msg_namelen = u->addr->len;
1531 memcpy(msg->msg_name, u->addr->name, u->addr->len);
1535 static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
1536 struct msghdr *msg, size_t size,
1539 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1540 struct scm_cookie tmp_scm;
1541 struct sock *sk = sock->sk;
1542 struct unix_sock *u = unix_sk(sk);
1543 int noblock = flags & MSG_DONTWAIT;
1544 struct sk_buff *skb;
1551 msg->msg_namelen = 0;
1553 mutex_lock(&u->readlock);
1555 skb = skb_recv_datagram(sk, flags, noblock, &err);
1559 wake_up_interruptible(&u->peer_wait);
1562 unix_copy_addr(msg, skb->sk);
1564 if (size > skb->len)
1566 else if (size < skb->len)
1567 msg->msg_flags |= MSG_TRUNC;
1569 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, size);
1574 siocb->scm = &tmp_scm;
1575 memset(&tmp_scm, 0, sizeof(tmp_scm));
1577 siocb->scm->creds = *UNIXCREDS(skb);
1579 if (!(flags & MSG_PEEK))
1582 unix_detach_fds(siocb->scm, skb);
1586 /* It is questionable: on PEEK we could:
1587 - do not return fds - good, but too simple 8)
1588 - return fds, and do not return them on read (old strategy,
1590 - clone fds (I chose it for now, it is the most universal
1593 POSIX 1003.1g does not actually define this clearly
1594 at all. POSIX 1003.1g doesn't define a lot of things
1599 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1603 scm_recv(sock, msg, siocb->scm, flags);
1606 skb_free_datagram(sk,skb);
1608 mutex_unlock(&u->readlock);
1614 * Sleep until data has arrive. But check for races..
1617 static long unix_stream_data_wait(struct sock * sk, long timeo)
1621 unix_state_rlock(sk);
1624 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1626 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1628 (sk->sk_shutdown & RCV_SHUTDOWN) ||
1629 signal_pending(current) ||
1633 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1634 unix_state_runlock(sk);
1635 timeo = schedule_timeout(timeo);
1636 unix_state_rlock(sk);
1637 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1640 finish_wait(sk->sk_sleep, &wait);
1641 unix_state_runlock(sk);
1647 static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
1648 struct msghdr *msg, size_t size,
1651 struct sock_iocb *siocb = kiocb_to_siocb(iocb);
1652 struct scm_cookie tmp_scm;
1653 struct sock *sk = sock->sk;
1654 struct unix_sock *u = unix_sk(sk);
1655 struct sockaddr_un *sunaddr=msg->msg_name;
1657 int check_creds = 0;
1663 if (sk->sk_state != TCP_ESTABLISHED)
1670 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
1671 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
1673 msg->msg_namelen = 0;
1675 /* Lock the socket to prevent queue disordering
1676 * while sleeps in memcpy_tomsg
1680 siocb->scm = &tmp_scm;
1681 memset(&tmp_scm, 0, sizeof(tmp_scm));
1684 mutex_lock(&u->readlock);
1689 struct sk_buff *skb;
1691 skb = skb_dequeue(&sk->sk_receive_queue);
1694 if (copied >= target)
1698 * POSIX 1003.1g mandates this order.
1701 if ((err = sock_error(sk)) != 0)
1703 if (sk->sk_shutdown & RCV_SHUTDOWN)
1708 mutex_unlock(&u->readlock);
1710 timeo = unix_stream_data_wait(sk, timeo);
1712 if (signal_pending(current)) {
1713 err = sock_intr_errno(timeo);
1716 mutex_lock(&u->readlock);
1721 /* Never glue messages from different writers */
1722 if (memcmp(UNIXCREDS(skb), &siocb->scm->creds, sizeof(siocb->scm->creds)) != 0) {
1723 skb_queue_head(&sk->sk_receive_queue, skb);
1727 /* Copy credentials */
1728 siocb->scm->creds = *UNIXCREDS(skb);
1732 /* Copy address just once */
1735 unix_copy_addr(msg, skb->sk);
1739 chunk = min_t(unsigned int, skb->len, size);
1740 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
1741 skb_queue_head(&sk->sk_receive_queue, skb);
1749 /* Mark read part of skb as used */
1750 if (!(flags & MSG_PEEK))
1752 skb_pull(skb, chunk);
1755 unix_detach_fds(siocb->scm, skb);
1757 /* put the skb back if we didn't use it up.. */
1760 skb_queue_head(&sk->sk_receive_queue, skb);
1771 /* It is questionable, see note in unix_dgram_recvmsg.
1774 siocb->scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1776 /* put message back and return */
1777 skb_queue_head(&sk->sk_receive_queue, skb);
1782 mutex_unlock(&u->readlock);
1783 scm_recv(sock, msg, siocb->scm, flags);
1785 return copied ? : err;
1788 static int unix_shutdown(struct socket *sock, int mode)
1790 struct sock *sk = sock->sk;
1793 mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
1796 unix_state_wlock(sk);
1797 sk->sk_shutdown |= mode;
1798 other=unix_peer(sk);
1801 unix_state_wunlock(sk);
1802 sk->sk_state_change(sk);
1805 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
1809 if (mode&RCV_SHUTDOWN)
1810 peer_mode |= SEND_SHUTDOWN;
1811 if (mode&SEND_SHUTDOWN)
1812 peer_mode |= RCV_SHUTDOWN;
1813 unix_state_wlock(other);
1814 other->sk_shutdown |= peer_mode;
1815 unix_state_wunlock(other);
1816 other->sk_state_change(other);
1817 read_lock(&other->sk_callback_lock);
1818 if (peer_mode == SHUTDOWN_MASK)
1819 sk_wake_async(other,1,POLL_HUP);
1820 else if (peer_mode & RCV_SHUTDOWN)
1821 sk_wake_async(other,1,POLL_IN);
1822 read_unlock(&other->sk_callback_lock);
1830 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1832 struct sock *sk = sock->sk;
1839 amount = atomic_read(&sk->sk_wmem_alloc);
1840 err = put_user(amount, (int __user *)arg);
1844 struct sk_buff *skb;
1846 if (sk->sk_state == TCP_LISTEN) {
1851 spin_lock(&sk->sk_receive_queue.lock);
1852 if (sk->sk_type == SOCK_STREAM ||
1853 sk->sk_type == SOCK_SEQPACKET) {
1854 skb_queue_walk(&sk->sk_receive_queue, skb)
1857 skb = skb_peek(&sk->sk_receive_queue);
1861 spin_unlock(&sk->sk_receive_queue.lock);
1862 err = put_user(amount, (int __user *)arg);
1873 static unsigned int unix_poll(struct file * file, struct socket *sock, poll_table *wait)
1875 struct sock *sk = sock->sk;
1878 poll_wait(file, sk->sk_sleep, wait);
1881 /* exceptional events? */
1884 if (sk->sk_shutdown == SHUTDOWN_MASK)
1886 if (sk->sk_shutdown & RCV_SHUTDOWN)
1890 if (!skb_queue_empty(&sk->sk_receive_queue) ||
1891 (sk->sk_shutdown & RCV_SHUTDOWN))
1892 mask |= POLLIN | POLLRDNORM;
1894 /* Connection-based need to check for termination and startup */
1895 if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) && sk->sk_state == TCP_CLOSE)
1899 * we set writable also when the other side has shut down the
1900 * connection. This prevents stuck sockets.
1902 if (unix_writable(sk))
1903 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
1909 #ifdef CONFIG_PROC_FS
1910 static struct sock *unix_seq_idx(int *iter, loff_t pos)
1915 for (s = first_unix_socket(iter); s; s = next_unix_socket(iter, s)) {
1924 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
1926 spin_lock(&unix_table_lock);
1927 return *pos ? unix_seq_idx(seq->private, *pos - 1) : ((void *) 1);
1930 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1935 return first_unix_socket(seq->private);
1936 return next_unix_socket(seq->private, v);
1939 static void unix_seq_stop(struct seq_file *seq, void *v)
1941 spin_unlock(&unix_table_lock);
1944 static int unix_seq_show(struct seq_file *seq, void *v)
1948 seq_puts(seq, "Num RefCount Protocol Flags Type St "
1952 struct unix_sock *u = unix_sk(s);
1953 unix_state_rlock(s);
1955 seq_printf(seq, "%p: %08X %08X %08X %04X %02X %5lu",
1957 atomic_read(&s->sk_refcnt),
1959 s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
1962 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
1963 (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
1971 len = u->addr->len - sizeof(short);
1972 if (!UNIX_ABSTRACT(s))
1978 for ( ; i < len; i++)
1979 seq_putc(seq, u->addr->name->sun_path[i]);
1981 unix_state_runlock(s);
1982 seq_putc(seq, '\n');
1988 static struct seq_operations unix_seq_ops = {
1989 .start = unix_seq_start,
1990 .next = unix_seq_next,
1991 .stop = unix_seq_stop,
1992 .show = unix_seq_show,
1996 static int unix_seq_open(struct inode *inode, struct file *file)
1998 struct seq_file *seq;
2000 int *iter = kmalloc(sizeof(int), GFP_KERNEL);
2005 rc = seq_open(file, &unix_seq_ops);
2009 seq = file->private_data;
2010 seq->private = iter;
2019 static struct file_operations unix_seq_fops = {
2020 .owner = THIS_MODULE,
2021 .open = unix_seq_open,
2023 .llseek = seq_lseek,
2024 .release = seq_release_private,
2029 static struct net_proto_family unix_family_ops = {
2031 .create = unix_create,
2032 .owner = THIS_MODULE,
2035 static int __init af_unix_init(void)
2038 struct sk_buff *dummy_skb;
2040 if (sizeof(struct unix_skb_parms) > sizeof(dummy_skb->cb)) {
2041 printk(KERN_CRIT "%s: panic\n", __FUNCTION__);
2045 rc = proto_register(&unix_proto, 1);
2047 printk(KERN_CRIT "%s: Cannot create unix_sock SLAB cache!\n",
2052 sock_register(&unix_family_ops);
2053 #ifdef CONFIG_PROC_FS
2054 proc_net_fops_create("unix", 0, &unix_seq_fops);
2056 unix_sysctl_register();
2061 static void __exit af_unix_exit(void)
2063 sock_unregister(PF_UNIX);
2064 unix_sysctl_unregister();
2065 proc_net_remove("unix");
2066 proto_unregister(&unix_proto);
2069 module_init(af_unix_init);
2070 module_exit(af_unix_exit);
2072 MODULE_LICENSE("GPL");
2073 MODULE_ALIAS_NETPROTO(PF_UNIX);