net/unix/af_unix.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * NET4:        Implementation of BSD Unix domain sockets.
   4  *
   5  * Authors:     Alan Cox, <alan@lxorguk.ukuu.org.uk>
   6  *
   7  * Fixes:
   8  *              Linus Torvalds  :       Assorted bug cures.
   9  *              Niibe Yutaka    :       async I/O support.
  10  *              Carsten Paeth   :       PF_UNIX check, address fixes.
  11  *              Alan Cox        :       Limit size of allocated blocks.
  12  *              Alan Cox        :       Fixed the stupid socketpair bug.
  13  *              Alan Cox        :       BSD compatibility fine tuning.
  14  *              Alan Cox        :       Fixed a bug in connect when interrupted.
  15  *              Alan Cox        :       Sorted out a proper draft version of
  16  *                                      file descriptor passing hacked up from
  17  *                                      Mike Shaver's work.
  18  *              Marty Leisner   :       Fixes to fd passing
  19  *              Nick Nevin      :       recvmsg bugfix.
  20  *              Alan Cox        :       Started proper garbage collector
  21  *              Heiko EiBfeldt  :       Missing verify_area check
  22  *              Alan Cox        :       Started POSIXisms
  23  *              Andreas Schwab  :       Replace inode by dentry for proper
  24  *                                      reference counting
  25  *              Kirk Petersen   :       Made this a module
  26  *          Christoph Rohland   :       Elegant non-blocking accept/connect algorithm.
  27  *                                      Lots of bug fixes.
  28  *           Alexey Kuznetosv   :       Repaired (I hope) bugs introduces
  29  *                                      by above two patches.
  30  *           Andrea Arcangeli   :       If possible we block in connect(2)
  31  *                                      if the max backlog of the listen socket
  32  *                                      is been reached. This won't break
  33  *                                      old apps and it will avoid huge amount
  34  *                                      of socks hashed (this for unix_gc()
  35  *                                      performances reasons).
  36  *                                      Security fix that limits the max
  37  *                                      number of socks to 2*max_files and
  38  *                                      the number of skb queueable in the
  39  *                                      dgram receiver.
  40  *              Artur Skawina   :       Hash function optimizations
  41  *           Alexey Kuznetsov   :       Full scale SMP. Lot of bugs are introduced 8)
  42  *            Malcolm Beattie   :       Set peercred for socketpair
  43  *           Michal Ostrowski   :       Module initialization cleanup.
  44  *           Arnaldo C. Melo    :       Remove MOD_{INC,DEC}_USE_COUNT,
  45  *                                      the core infrastructure is doing that
  46  *                                      for all net proto families now (2.5.69+)
  47  *
  48  * Known differences from reference BSD that was tested:
  49  *
  50  *      [TO FIX]
  51  *      ECONNREFUSED is not returned from one end of a connected() socket to the
  52  *              other the moment one end closes.
  53  *      fstat() doesn't return st_dev=0, and give the blksize as high water mark
  54  *              and a fake inode identifier (nor the BSD first socket fstat twice bug).
  55  *      [NOT TO FIX]
  56  *      accept() returns a path name even if the connecting socket has closed
  57  *              in the meantime (BSD loses the path and gives up).
  58  *      accept() returns 0 length path for an unbound connector. BSD returns 16
  59  *              and a null first byte in the path (but not for gethost/peername - BSD bug ??)
  60  *      socketpair(...SOCK_RAW..) doesn't panic the kernel.
  61  *      BSD af_unix apparently has connect forgetting to block properly.
  62  *              (need to check this with the POSIX spec in detail)
  63  *
  64  * Differences from 2.0.0-11-... (ANK)
  65  *      Bug fixes and improvements.
  66  *              - client shutdown killed server socket.
  67  *              - removed all useless cli/sti pairs.
  68  *
  69  *      Semantic changes/extensions.
  70  *              - generic control message passing.
  71  *              - SCM_CREDENTIALS control message.
  72  *              - "Abstract" (not FS based) socket bindings.
  73  *                Abstract names are sequences of bytes (not zero terminated)
  74  *                started by 0, so that this name space does not intersect
  75  *                with BSD names.
  76  */
  77
  78 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  79
  80 #include <linux/module.h>
  81 #include <linux/kernel.h>
  82 #include <linux/signal.h>
  83 #include <linux/sched/signal.h>
  84 #include <linux/errno.h>
  85 #include <linux/string.h>
  86 #include <linux/stat.h>
  87 #include <linux/dcache.h>
  88 #include <linux/namei.h>
  89 #include <linux/socket.h>
  90 #include <linux/un.h>
  91 #include <linux/fcntl.h>
  92 #include <linux/termios.h>
  93 #include <linux/sockios.h>
  94 #include <linux/net.h>
  95 #include <linux/in.h>
  96 #include <linux/fs.h>
  97 #include <linux/slab.h>
  98 #include <linux/uaccess.h>
  99 #include <linux/skbuff.h>
 100 #include <linux/netdevice.h>
 101 #include <net/net_namespace.h>
 102 #include <net/sock.h>
 103 #include <net/tcp_states.h>
 104 #include <net/af_unix.h>
 105 #include <linux/proc_fs.h>
 106 #include <linux/seq_file.h>
 107 #include <net/scm.h>
 108 #include <linux/init.h>
 109 #include <linux/poll.h>
 110 #include <linux/rtnetlink.h>
 111 #include <linux/mount.h>
 112 #include <net/checksum.h>
 113 #include <linux/security.h>
 114 #include <linux/freezer.h>
 115 #include <linux/file.h>
 116
 117 #include "scm.h"
 118
 119 struct hlist_head unix_socket_table[2 * UNIX_HASH_SIZE];
 120 EXPORT_SYMBOL_GPL(unix_socket_table);
 121 DEFINE_SPINLOCK(unix_table_lock);
 122 EXPORT_SYMBOL_GPL(unix_table_lock);
 123 static atomic_long_t unix_nr_socks;
 124
 125
 126 static struct hlist_head *unix_sockets_unbound(void *addr)
 127 {
 128         unsigned long hash = (unsigned long)addr;
 129
 130         hash ^= hash >> 16;
 131         hash ^= hash >> 8;
 132         hash %= UNIX_HASH_SIZE;
 133         return &unix_socket_table[UNIX_HASH_SIZE + hash];
 134 }
 135
 136 #define UNIX_ABSTRACT(sk)       (unix_sk(sk)->addr->hash < UNIX_HASH_SIZE)
 137
 138 #ifdef CONFIG_SECURITY_NETWORK
 139 static void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 140 {
 141         UNIXCB(skb).secid = scm->secid;
 142 }
 143
 144 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 145 {
 146         scm->secid = UNIXCB(skb).secid;
 147 }
 148
 149 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
 150 {
 151         return (scm->secid == UNIXCB(skb).secid);
 152 }
 153 #else
 154 static inline void unix_get_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 155 { }
 156
 157 static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
 158 { }
 159
 160 static inline bool unix_secdata_eq(struct scm_cookie *scm, struct sk_buff *skb)
 161 {
 162         return true;
 163 }
 164 #endif /* CONFIG_SECURITY_NETWORK */
 165
 166 /*
 167  *  SMP locking strategy:
 168  *    hash table is protected with spinlock unix_table_lock
 169  *    each socket state is protected by separate spin lock.
 170  */
 171
 172 static inline unsigned int unix_hash_fold(__wsum n)
 173 {
 174         unsigned int hash = (__force unsigned int)csum_fold(n);
 175
 176         hash ^= hash>>8;
 177         return hash&(UNIX_HASH_SIZE-1);
 178 }
 179
 180 #define unix_peer(sk) (unix_sk(sk)->peer)
 181
 182 static inline int unix_our_peer(struct sock *sk, struct sock *osk)
 183 {
 184         return unix_peer(osk) == sk;
 185 }
 186
 187 static inline int unix_may_send(struct sock *sk, struct sock *osk)
 188 {
 189         return unix_peer(osk) == NULL || unix_our_peer(sk, osk);
 190 }
 191
 192 static inline int unix_recvq_full(const struct sock *sk)
 193 {
 194         return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
 195 }
 196
 197 static inline int unix_recvq_full_lockless(const struct sock *sk)
 198 {
 199         return skb_queue_len_lockless(&sk->sk_receive_queue) >
 200                 READ_ONCE(sk->sk_max_ack_backlog);
 201 }
 202
 203 struct sock *unix_peer_get(struct sock *s)
 204 {
 205         struct sock *peer;
 206
 207         unix_state_lock(s);
 208         peer = unix_peer(s);
 209         if (peer)
 210                 sock_hold(peer);
 211         unix_state_unlock(s);
 212         return peer;
 213 }
 214 EXPORT_SYMBOL_GPL(unix_peer_get);
 215
 216 static inline void unix_release_addr(struct unix_address *addr)
 217 {
 218         if (refcount_dec_and_test(&addr->refcnt))
 219                 kfree(addr);
 220 }
 221
 222 /*
 223  *      Check unix socket name:
 224  *              - should be not zero length.
 225  *              - if started by not zero, should be NULL terminated (FS object)
 226  *              - if started by zero, it is abstract name.
 227  */
 228
 229 static int unix_mkname(struct sockaddr_un *sunaddr, int len, unsigned int *hashp)
 230 {
 231         *hashp = 0;
 232
 233         if (len <= sizeof(short) || len > sizeof(*sunaddr))
 234                 return -EINVAL;
 235         if (!sunaddr || sunaddr->sun_family != AF_UNIX)
 236                 return -EINVAL;
 237         if (sunaddr->sun_path[0]) {
 238                 /*
 239                  * This may look like an off by one error but it is a bit more
 240                  * subtle. 108 is the longest valid AF_UNIX path for a binding.
 241                  * sun_path[108] doesn't as such exist.  However in kernel space
 242                  * we are guaranteed that it is a valid memory location in our
 243                  * kernel address buffer.
 244                  */
 245                 ((char *)sunaddr)[len] = 0;
 246                 len = strlen(sunaddr->sun_path)+1+sizeof(short);
 247                 return len;
 248         }
 249
 250         *hashp = unix_hash_fold(csum_partial(sunaddr, len, 0));
 251         return len;
 252 }
 253
 254 static void __unix_remove_socket(struct sock *sk)
 255 {
 256         sk_del_node_init(sk);
 257 }
 258
 259 static void __unix_insert_socket(struct hlist_head *list, struct sock *sk)
 260 {
 261         WARN_ON(!sk_unhashed(sk));
 262         sk_add_node(sk, list);
 263 }
 264
 265 static inline void unix_remove_socket(struct sock *sk)
 266 {
 267         spin_lock(&unix_table_lock);
 268         __unix_remove_socket(sk);
 269         spin_unlock(&unix_table_lock);
 270 }
 271
 272 static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk)
 273 {
 274         spin_lock(&unix_table_lock);
 275         __unix_insert_socket(list, sk);
 276         spin_unlock(&unix_table_lock);
 277 }
 278
 279 static struct sock *__unix_find_socket_byname(struct net *net,
 280                                               struct sockaddr_un *sunname,
 281                                               int len, int type, unsigned int hash)
 282 {
 283         struct sock *s;
 284
 285         sk_for_each(s, &unix_socket_table[hash ^ type]) {
 286                 struct unix_sock *u = unix_sk(s);
 287
 288                 if (!net_eq(sock_net(s), net))
 289                         continue;
 290
 291                 if (u->addr->len == len &&
 292                     !memcmp(u->addr->name, sunname, len))
 293                         goto found;
 294         }
 295         s = NULL;
 296 found:
 297         return s;
 298 }
 299
 300 static inline struct sock *unix_find_socket_byname(struct net *net,
 301                                                    struct sockaddr_un *sunname,
 302                                                    int len, int type,
 303                                                    unsigned int hash)
 304 {
 305         struct sock *s;
 306
 307         spin_lock(&unix_table_lock);
 308         s = __unix_find_socket_byname(net, sunname, len, type, hash);
 309         if (s)
 310                 sock_hold(s);
 311         spin_unlock(&unix_table_lock);
 312         return s;
 313 }
 314
 315 static struct sock *unix_find_socket_byinode(struct inode *i)
 316 {
 317         struct sock *s;
 318
 319         spin_lock(&unix_table_lock);
 320         sk_for_each(s,
 321                     &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
 322                 struct dentry *dentry = unix_sk(s)->path.dentry;
 323
 324                 if (dentry && d_backing_inode(dentry) == i) {
 325                         sock_hold(s);
 326                         goto found;
 327                 }
 328         }
 329         s = NULL;
 330 found:
 331         spin_unlock(&unix_table_lock);
 332         return s;
 333 }
 334
 335 /* Support code for asymmetrically connected dgram sockets
 336  *
 337  * If a datagram socket is connected to a socket not itself connected
 338  * to the first socket (eg, /dev/log), clients may only enqueue more
 339  * messages if the present receive queue of the server socket is not
 340  * "too large". This means there's a second writeability condition
 341  * poll and sendmsg need to test. The dgram recv code will do a wake
 342  * up on the peer_wait wait queue of a socket upon reception of a
 343  * datagram which needs to be propagated to sleeping would-be writers
 344  * since these might not have sent anything so far. This can't be
 345  * accomplished via poll_wait because the lifetime of the server
 346  * socket might be less than that of its clients if these break their
 347  * association with it or if the server socket is closed while clients
 348  * are still connected to it and there's no way to inform "a polling
 349  * implementation" that it should let go of a certain wait queue
 350  *
 351  * In order to propagate a wake up, a wait_queue_entry_t of the client
 352  * socket is enqueued on the peer_wait queue of the server socket
 353  * whose wake function does a wake_up on the ordinary client socket
 354  * wait queue. This connection is established whenever a write (or
 355  * poll for write) hit the flow control condition and broken when the
 356  * association to the server socket is dissolved or after a wake up
 357  * was relayed.
 358  */
 359
 360 static int unix_dgram_peer_wake_relay(wait_queue_entry_t *q, unsigned mode, int flags,
 361                                       void *key)
 362 {
 363         struct unix_sock *u;
 364         wait_queue_head_t *u_sleep;
 365
 366         u = container_of(q, struct unix_sock, peer_wake);
 367
 368         __remove_wait_queue(&unix_sk(u->peer_wake.private)->peer_wait,
 369                             q);
 370         u->peer_wake.private = NULL;
 371
 372         /* relaying can only happen while the wq still exists */
 373         u_sleep = sk_sleep(&u->sk);
 374         if (u_sleep)
 375                 wake_up_interruptible_poll(u_sleep, key_to_poll(key));
 376
 377         return 0;
 378 }
 379
 380 static int unix_dgram_peer_wake_connect(struct sock *sk, struct sock *other)
 381 {
 382         struct unix_sock *u, *u_other;
 383         int rc;
 384
 385         u = unix_sk(sk);
 386         u_other = unix_sk(other);
 387         rc = 0;
 388         spin_lock(&u_other->peer_wait.lock);
 389
 390         if (!u->peer_wake.private) {
 391                 u->peer_wake.private = other;
 392                 __add_wait_queue(&u_other->peer_wait, &u->peer_wake);
 393
 394                 rc = 1;
 395         }
 396
 397         spin_unlock(&u_other->peer_wait.lock);
 398         return rc;
 399 }
 400
 401 static void unix_dgram_peer_wake_disconnect(struct sock *sk,
 402                                             struct sock *other)
 403 {
 404         struct unix_sock *u, *u_other;
 405
 406         u = unix_sk(sk);
 407         u_other = unix_sk(other);
 408         spin_lock(&u_other->peer_wait.lock);
 409
 410         if (u->peer_wake.private == other) {
 411                 __remove_wait_queue(&u_other->peer_wait, &u->peer_wake);
 412                 u->peer_wake.private = NULL;
 413         }
 414
 415         spin_unlock(&u_other->peer_wait.lock);
 416 }
 417
 418 static void unix_dgram_peer_wake_disconnect_wakeup(struct sock *sk,
 419                                                    struct sock *other)
 420 {
 421         unix_dgram_peer_wake_disconnect(sk, other);
 422         wake_up_interruptible_poll(sk_sleep(sk),
 423                                    EPOLLOUT |
 424                                    EPOLLWRNORM |
 425                                    EPOLLWRBAND);
 426 }
 427
 428 /* preconditions:
 429  *      - unix_peer(sk) == other
 430  *      - association is stable
 431  */
 432 static int unix_dgram_peer_wake_me(struct sock *sk, struct sock *other)
 433 {
 434         int connected;
 435
 436         connected = unix_dgram_peer_wake_connect(sk, other);
 437
 438         /* If other is SOCK_DEAD, we want to make sure we signal
 439          * POLLOUT, such that a subsequent write() can get a
 440          * -ECONNREFUSED. Otherwise, if we haven't queued any skbs
 441          * to other and its full, we will hang waiting for POLLOUT.
 442          */
 443         if (unix_recvq_full_lockless(other) && !sock_flag(other, SOCK_DEAD))
 444                 return 1;
 445
 446         if (connected)
 447                 unix_dgram_peer_wake_disconnect(sk, other);
 448
 449         return 0;
 450 }
 451
 452 static int unix_writable(const struct sock *sk)
 453 {
 454         return sk->sk_state != TCP_LISTEN &&
 455                (refcount_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
 456 }
 457
 458 static void unix_write_space(struct sock *sk)
 459 {
 460         struct socket_wq *wq;
 461
 462         rcu_read_lock();
 463         if (unix_writable(sk)) {
 464                 wq = rcu_dereference(sk->sk_wq);
 465                 if (skwq_has_sleeper(wq))
 466                         wake_up_interruptible_sync_poll(&wq->wait,
 467                                 EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND);
 468                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 469         }
 470         rcu_read_unlock();
 471 }
 472
 473 /* When dgram socket disconnects (or changes its peer), we clear its receive
 474  * queue of packets arrived from previous peer. First, it allows to do
 475  * flow control based only on wmem_alloc; second, sk connected to peer
 476  * may receive messages only from that peer. */
 477 static void unix_dgram_disconnected(struct sock *sk, struct sock *other)
 478 {
 479         if (!skb_queue_empty(&sk->sk_receive_queue)) {
 480                 skb_queue_purge(&sk->sk_receive_queue);
 481                 wake_up_interruptible_all(&unix_sk(sk)->peer_wait);
 482
 483                 /* If one link of bidirectional dgram pipe is disconnected,
 484                  * we signal error. Messages are lost. Do not make this,
 485                  * when peer was not connected to us.
 486                  */
 487                 if (!sock_flag(other, SOCK_DEAD) && unix_peer(other) == sk) {
 488                         other->sk_err = ECONNRESET;
 489                         other->sk_error_report(other);
 490                 }
 491         }
 492 }
 493
 494 static void unix_sock_destructor(struct sock *sk)
 495 {
 496         struct unix_sock *u = unix_sk(sk);
 497
 498         skb_queue_purge(&sk->sk_receive_queue);
 499
 500         WARN_ON(refcount_read(&sk->sk_wmem_alloc));
 501         WARN_ON(!sk_unhashed(sk));
 502         WARN_ON(sk->sk_socket);
 503         if (!sock_flag(sk, SOCK_DEAD)) {
 504                 pr_info("Attempt to release alive unix socket: %p\n", sk);
 505                 return;
 506         }
 507
 508         if (u->addr)
 509                 unix_release_addr(u->addr);
 510
 511         atomic_long_dec(&unix_nr_socks);
 512         local_bh_disable();
 513         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
 514         local_bh_enable();
 515 #ifdef UNIX_REFCNT_DEBUG
 516         pr_debug("UNIX %p is destroyed, %ld are still alive.\n", sk,
 517                 atomic_long_read(&unix_nr_socks));
 518 #endif
 519 }
 520
 521 static void unix_release_sock(struct sock *sk, int embrion)
 522 {
 523         struct unix_sock *u = unix_sk(sk);
 524         struct path path;
 525         struct sock *skpair;
 526         struct sk_buff *skb;
 527         int state;
 528
 529         unix_remove_socket(sk);
 530
 531         /* Clear state */
 532         unix_state_lock(sk);
 533         sock_orphan(sk);
 534         WRITE_ONCE(sk->sk_shutdown, SHUTDOWN_MASK);
 535         path         = u->path;
 536         u->path.dentry = NULL;
 537         u->path.mnt = NULL;
 538         state = sk->sk_state;
 539         sk->sk_state = TCP_CLOSE;
 540
 541         skpair = unix_peer(sk);
 542         unix_peer(sk) = NULL;
 543
 544         unix_state_unlock(sk);
 545
 546         wake_up_interruptible_all(&u->peer_wait);
 547
 548         if (skpair != NULL) {
 549                 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) {
 550                         unix_state_lock(skpair);
 551                         /* No more writes */
 552                         WRITE_ONCE(skpair->sk_shutdown, SHUTDOWN_MASK);
 553                         if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
 554                                 skpair->sk_err = ECONNRESET;
 555                         unix_state_unlock(skpair);
 556                         skpair->sk_state_change(skpair);
 557                         sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
 558                 }
 559
 560                 unix_dgram_peer_wake_disconnect(sk, skpair);
 561                 sock_put(skpair); /* It may now die */
 562         }
 563
 564         /* Try to flush out this socket. Throw out buffers at least */
 565
 566         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 567                 if (state == TCP_LISTEN)
 568                         unix_release_sock(skb->sk, 1);
 569                 /* passed fds are erased in the kfree_skb hook        */
 570                 UNIXCB(skb).consumed = skb->len;
 571                 kfree_skb(skb);
 572         }
 573
 574         if (path.dentry)
 575                 path_put(&path);
 576
 577         sock_put(sk);
 578
 579         /* ---- Socket is dead now and most probably destroyed ---- */
 580
 581         /*
 582          * Fixme: BSD difference: In BSD all sockets connected to us get
 583          *        ECONNRESET and we die on the spot. In Linux we behave
 584          *        like files and pipes do and wait for the last
 585          *        dereference.
 586          *
 587          * Can't we simply set sock->err?
 588          *
 589          *        What the above comment does talk about? --ANK(980817)
 590          */
 591
 592         if (READ_ONCE(unix_tot_inflight))
 593                 unix_gc();              /* Garbage collect fds */
 594 }
 595
 596 static void init_peercred(struct sock *sk)
 597 {
 598         const struct cred *old_cred;
 599         struct pid *old_pid;
 600
 601         spin_lock(&sk->sk_peer_lock);
 602         old_pid = sk->sk_peer_pid;
 603         old_cred = sk->sk_peer_cred;
 604         sk->sk_peer_pid  = get_pid(task_tgid(current));
 605         sk->sk_peer_cred = get_current_cred();
 606         spin_unlock(&sk->sk_peer_lock);
 607
 608         put_pid(old_pid);
 609         put_cred(old_cred);
 610 }
 611
 612 static void copy_peercred(struct sock *sk, struct sock *peersk)
 613 {
 614         const struct cred *old_cred;
 615         struct pid *old_pid;
 616
 617         if (sk < peersk) {
 618                 spin_lock(&sk->sk_peer_lock);
 619                 spin_lock_nested(&peersk->sk_peer_lock, SINGLE_DEPTH_NESTING);
 620         } else {
 621                 spin_lock(&peersk->sk_peer_lock);
 622                 spin_lock_nested(&sk->sk_peer_lock, SINGLE_DEPTH_NESTING);
 623         }
 624         old_pid = sk->sk_peer_pid;
 625         old_cred = sk->sk_peer_cred;
 626         sk->sk_peer_pid  = get_pid(peersk->sk_peer_pid);
 627         sk->sk_peer_cred = get_cred(peersk->sk_peer_cred);
 628
 629         spin_unlock(&sk->sk_peer_lock);
 630         spin_unlock(&peersk->sk_peer_lock);
 631
 632         put_pid(old_pid);
 633         put_cred(old_cred);
 634 }
 635
 636 static int unix_listen(struct socket *sock, int backlog)
 637 {
 638         int err;
 639         struct sock *sk = sock->sk;
 640         struct unix_sock *u = unix_sk(sk);
 641         struct pid *old_pid = NULL;
 642
 643         err = -EOPNOTSUPP;
 644         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
 645                 goto out;       /* Only stream/seqpacket sockets accept */
 646         err = -EINVAL;
 647         if (!u->addr)
 648                 goto out;       /* No listens on an unbound socket */
 649         unix_state_lock(sk);
 650         if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
 651                 goto out_unlock;
 652         if (backlog > sk->sk_max_ack_backlog)
 653                 wake_up_interruptible_all(&u->peer_wait);
 654         sk->sk_max_ack_backlog  = backlog;
 655         sk->sk_state            = TCP_LISTEN;
 656         /* set credentials so connect can copy them */
 657         init_peercred(sk);
 658         err = 0;
 659
 660 out_unlock:
 661         unix_state_unlock(sk);
 662         put_pid(old_pid);
 663 out:
 664         return err;
 665 }
 666
 667 static int unix_release(struct socket *);
 668 static int unix_bind(struct socket *, struct sockaddr *, int);
 669 static int unix_stream_connect(struct socket *, struct sockaddr *,
 670                                int addr_len, int flags);
 671 static int unix_socketpair(struct socket *, struct socket *);
 672 static int unix_accept(struct socket *, struct socket *, int, bool);
 673 static int unix_getname(struct socket *, struct sockaddr *, int);
 674 static __poll_t unix_poll(struct file *, struct socket *, poll_table *);
 675 static __poll_t unix_dgram_poll(struct file *, struct socket *,
 676                                     poll_table *);
 677 static int unix_ioctl(struct socket *, unsigned int, unsigned long);
 678 #ifdef CONFIG_COMPAT
 679 static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
 680 #endif
 681 static int unix_shutdown(struct socket *, int);
 682 static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
 683 static int unix_stream_recvmsg(struct socket *, struct msghdr *, size_t, int);
 684 static ssize_t unix_stream_sendpage(struct socket *, struct page *, int offset,
 685                                     size_t size, int flags);
 686 static ssize_t unix_stream_splice_read(struct socket *,  loff_t *ppos,
 687                                        struct pipe_inode_info *, size_t size,
 688                                        unsigned int flags);
 689 static int unix_dgram_sendmsg(struct socket *, struct msghdr *, size_t);
 690 static int unix_dgram_recvmsg(struct socket *, struct msghdr *, size_t, int);
 691 static int unix_dgram_connect(struct socket *, struct sockaddr *,
 692                               int, int);
 693 static int unix_seqpacket_sendmsg(struct socket *, struct msghdr *, size_t);
 694 static int unix_seqpacket_recvmsg(struct socket *, struct msghdr *, size_t,
 695                                   int);
 696
 697 static int unix_set_peek_off(struct sock *sk, int val)
 698 {
 699         struct unix_sock *u = unix_sk(sk);
 700
 701         if (mutex_lock_interruptible(&u->iolock))
 702                 return -EINTR;
 703
 704         WRITE_ONCE(sk->sk_peek_off, val);
 705         mutex_unlock(&u->iolock);
 706
 707         return 0;
 708 }
 709
 710
 711 static const struct proto_ops unix_stream_ops = {
 712         .family =       PF_UNIX,
 713         .owner =        THIS_MODULE,
 714         .release =      unix_release,
 715         .bind =         unix_bind,
 716         .connect =      unix_stream_connect,
 717         .socketpair =   unix_socketpair,
 718         .accept =       unix_accept,
 719         .getname =      unix_getname,
 720         .poll =         unix_poll,
 721         .ioctl =        unix_ioctl,
 722 #ifdef CONFIG_COMPAT
 723         .compat_ioctl = unix_compat_ioctl,
 724 #endif
 725         .listen =       unix_listen,
 726         .shutdown =     unix_shutdown,
 727         .setsockopt =   sock_no_setsockopt,
 728         .getsockopt =   sock_no_getsockopt,
 729         .sendmsg =      unix_stream_sendmsg,
 730         .recvmsg =      unix_stream_recvmsg,
 731         .mmap =         sock_no_mmap,
 732         .sendpage =     unix_stream_sendpage,
 733         .splice_read =  unix_stream_splice_read,
 734         .set_peek_off = unix_set_peek_off,
 735 };
 736
 737 static const struct proto_ops unix_dgram_ops = {
 738         .family =       PF_UNIX,
 739         .owner =        THIS_MODULE,
 740         .release =      unix_release,
 741         .bind =         unix_bind,
 742         .connect =      unix_dgram_connect,
 743         .socketpair =   unix_socketpair,
 744         .accept =       sock_no_accept,
 745         .getname =      unix_getname,
 746         .poll =         unix_dgram_poll,
 747         .ioctl =        unix_ioctl,
 748 #ifdef CONFIG_COMPAT
 749         .compat_ioctl = unix_compat_ioctl,
 750 #endif
 751         .listen =       sock_no_listen,
 752         .shutdown =     unix_shutdown,
 753         .setsockopt =   sock_no_setsockopt,
 754         .getsockopt =   sock_no_getsockopt,
 755         .sendmsg =      unix_dgram_sendmsg,
 756         .recvmsg =      unix_dgram_recvmsg,
 757         .mmap =         sock_no_mmap,
 758         .sendpage =     sock_no_sendpage,
 759         .set_peek_off = unix_set_peek_off,
 760 };
 761
 762 static const struct proto_ops unix_seqpacket_ops = {
 763         .family =       PF_UNIX,
 764         .owner =        THIS_MODULE,
 765         .release =      unix_release,
 766         .bind =         unix_bind,
 767         .connect =      unix_stream_connect,
 768         .socketpair =   unix_socketpair,
 769         .accept =       unix_accept,
 770         .getname =      unix_getname,
 771         .poll =         unix_dgram_poll,
 772         .ioctl =        unix_ioctl,
 773 #ifdef CONFIG_COMPAT
 774         .compat_ioctl = unix_compat_ioctl,
 775 #endif
 776         .listen =       unix_listen,
 777         .shutdown =     unix_shutdown,
 778         .setsockopt =   sock_no_setsockopt,
 779         .getsockopt =   sock_no_getsockopt,
 780         .sendmsg =      unix_seqpacket_sendmsg,
 781         .recvmsg =      unix_seqpacket_recvmsg,
 782         .mmap =         sock_no_mmap,
 783         .sendpage =     sock_no_sendpage,
 784         .set_peek_off = unix_set_peek_off,
 785 };
 786
 787 static struct proto unix_proto = {
 788         .name                   = "UNIX",
 789         .owner                  = THIS_MODULE,
 790         .obj_size               = sizeof(struct unix_sock),
 791 };
 792
 793 static struct sock *unix_create1(struct net *net, struct socket *sock, int kern)
 794 {
 795         struct sock *sk = NULL;
 796         struct unix_sock *u;
 797
 798         atomic_long_inc(&unix_nr_socks);
 799         if (atomic_long_read(&unix_nr_socks) > 2 * get_max_files())
 800                 goto out;
 801
 802         sk = sk_alloc(net, PF_UNIX, GFP_KERNEL, &unix_proto, kern);
 803         if (!sk)
 804                 goto out;
 805
 806         sock_init_data(sock, sk);
 807
 808         sk->sk_allocation       = GFP_KERNEL_ACCOUNT;
 809         sk->sk_write_space      = unix_write_space;
 810         sk->sk_max_ack_backlog  = net->unx.sysctl_max_dgram_qlen;
 811         sk->sk_destruct         = unix_sock_destructor;
 812         u         = unix_sk(sk);
 813         u->path.dentry = NULL;
 814         u->path.mnt = NULL;
 815         spin_lock_init(&u->lock);
 816         atomic_long_set(&u->inflight, 0);
 817         INIT_LIST_HEAD(&u->link);
 818         mutex_init(&u->iolock); /* single task reading lock */
 819         mutex_init(&u->bindlock); /* single task binding lock */
 820         init_waitqueue_head(&u->peer_wait);
 821         init_waitqueue_func_entry(&u->peer_wake, unix_dgram_peer_wake_relay);
 822         unix_insert_socket(unix_sockets_unbound(sk), sk);
 823 out:
 824         if (sk == NULL)
 825                 atomic_long_dec(&unix_nr_socks);
 826         else {
 827                 local_bh_disable();
 828                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
 829                 local_bh_enable();
 830         }
 831         return sk;
 832 }
 833
 834 static int unix_create(struct net *net, struct socket *sock, int protocol,
 835                        int kern)
 836 {
 837         if (protocol && protocol != PF_UNIX)
 838                 return -EPROTONOSUPPORT;
 839
 840         sock->state = SS_UNCONNECTED;
 841
 842         switch (sock->type) {
 843         case SOCK_STREAM:
 844                 sock->ops = &unix_stream_ops;
 845                 break;
 846                 /*
 847                  *      Believe it or not BSD has AF_UNIX, SOCK_RAW though
 848                  *      nothing uses it.
 849                  */
 850         case SOCK_RAW:
 851                 sock->type = SOCK_DGRAM;
 852                 /* fall through */
 853         case SOCK_DGRAM:
 854                 sock->ops = &unix_dgram_ops;
 855                 break;
 856         case SOCK_SEQPACKET:
 857                 sock->ops = &unix_seqpacket_ops;
 858                 break;
 859         default:
 860                 return -ESOCKTNOSUPPORT;
 861         }
 862
 863         return unix_create1(net, sock, kern) ? 0 : -ENOMEM;
 864 }
 865
 866 static int unix_release(struct socket *sock)
 867 {
 868         struct sock *sk = sock->sk;
 869
 870         if (!sk)
 871                 return 0;
 872
 873         unix_release_sock(sk, 0);
 874         sock->sk = NULL;
 875
 876         return 0;
 877 }
 878
 879 static int unix_autobind(struct socket *sock)
 880 {
 881         struct sock *sk = sock->sk;
 882         struct net *net = sock_net(sk);
 883         struct unix_sock *u = unix_sk(sk);
 884         static u32 ordernum = 1;
 885         struct unix_address *addr;
 886         int err;
 887         unsigned int retries = 0;
 888
 889         err = mutex_lock_interruptible(&u->bindlock);
 890         if (err)
 891                 return err;
 892
 893         err = 0;
 894         if (u->addr)
 895                 goto out;
 896
 897         err = -ENOMEM;
 898         addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
 899         if (!addr)
 900                 goto out;
 901
 902         addr->name->sun_family = AF_UNIX;
 903         refcount_set(&addr->refcnt, 1);
 904
 905 retry:
 906         addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
 907         addr->hash = unix_hash_fold(csum_partial(addr->name, addr->len, 0));
 908
 909         spin_lock(&unix_table_lock);
 910         ordernum = (ordernum+1)&0xFFFFF;
 911
 912         if (__unix_find_socket_byname(net, addr->name, addr->len, sock->type,
 913                                       addr->hash)) {
 914                 spin_unlock(&unix_table_lock);
 915                 /*
 916                  * __unix_find_socket_byname() may take long time if many names
 917                  * are already in use.
 918                  */
 919                 cond_resched();
 920                 /* Give up if all names seems to be in use. */
 921                 if (retries++ == 0xFFFFF) {
 922                         err = -ENOSPC;
 923                         kfree(addr);
 924                         goto out;
 925                 }
 926                 goto retry;
 927         }
 928         addr->hash ^= sk->sk_type;
 929
 930         __unix_remove_socket(sk);
 931         smp_store_release(&u->addr, addr);
 932         __unix_insert_socket(&unix_socket_table[addr->hash], sk);
 933         spin_unlock(&unix_table_lock);
 934         err = 0;
 935
 936 out:    mutex_unlock(&u->bindlock);
 937         return err;
 938 }
 939
 940 static struct sock *unix_find_other(struct net *net,
 941                                     struct sockaddr_un *sunname, int len,
 942                                     int type, unsigned int hash, int *error)
 943 {
 944         struct sock *u;
 945         struct path path;
 946         int err = 0;
 947
 948         if (sunname->sun_path[0]) {
 949                 struct inode *inode;
 950                 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
 951                 if (err)
 952                         goto fail;
 953                 inode = d_backing_inode(path.dentry);
 954                 err = inode_permission(inode, MAY_WRITE);
 955                 if (err)
 956                         goto put_fail;
 957
 958                 err = -ECONNREFUSED;
 959                 if (!S_ISSOCK(inode->i_mode))
 960                         goto put_fail;
 961                 u = unix_find_socket_byinode(inode);
 962                 if (!u)
 963                         goto put_fail;
 964
 965                 if (u->sk_type == type)
 966                         touch_atime(&path);
 967
 968                 path_put(&path);
 969
 970                 err = -EPROTOTYPE;
 971                 if (u->sk_type != type) {
 972                         sock_put(u);
 973                         goto fail;
 974                 }
 975         } else {
 976                 err = -ECONNREFUSED;
 977                 u = unix_find_socket_byname(net, sunname, len, type, hash);
 978                 if (u) {
 979                         struct dentry *dentry;
 980                         dentry = unix_sk(u)->path.dentry;
 981                         if (dentry)
 982                                 touch_atime(&unix_sk(u)->path);
 983                 } else
 984                         goto fail;
 985         }
 986         return u;
 987
 988 put_fail:
 989         path_put(&path);
 990 fail:
 991         *error = err;
 992         return NULL;
 993 }
 994
 995 static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
 996 {
 997         struct dentry *dentry;
 998         struct path path;
 999         int err = 0;
1000         /*
1001          * Get the parent directory, calculate the hash for last
1002          * component.
1003          */
1004         dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
1005         err = PTR_ERR(dentry);
1006         if (IS_ERR(dentry))
1007                 return err;
1008
1009         /*
1010          * All right, let's create it.
1011          */
1012         err = security_path_mknod(&path, dentry, mode, 0);
1013         if (!err) {
1014                 err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
1015                 if (!err) {
1016                         res->mnt = mntget(path.mnt);
1017                         res->dentry = dget(dentry);
1018                 }
1019         }
1020         done_path_create(&path, dentry);
1021         return err;
1022 }
1023
1024 static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1025 {
1026         struct sock *sk = sock->sk;
1027         struct net *net = sock_net(sk);
1028         struct unix_sock *u = unix_sk(sk);
1029         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1030         char *sun_path = sunaddr->sun_path;
1031         int err;
1032         unsigned int hash;
1033         struct unix_address *addr;
1034         struct hlist_head *list;
1035         struct path path = { };
1036
1037         err = -EINVAL;
1038         if (addr_len < offsetofend(struct sockaddr_un, sun_family) ||
1039             sunaddr->sun_family != AF_UNIX)
1040                 goto out;
1041
1042         if (addr_len == sizeof(short)) {
1043                 err = unix_autobind(sock);
1044                 goto out;
1045         }
1046
1047         err = unix_mkname(sunaddr, addr_len, &hash);
1048         if (err < 0)
1049                 goto out;
1050         addr_len = err;
1051
1052         if (sun_path[0]) {
1053                 umode_t mode = S_IFSOCK |
1054                        (SOCK_INODE(sock)->i_mode & ~current_umask());
1055                 err = unix_mknod(sun_path, mode, &path);
1056                 if (err) {
1057                         if (err == -EEXIST)
1058                                 err = -EADDRINUSE;
1059                         goto out;
1060                 }
1061         }
1062
1063         err = mutex_lock_interruptible(&u->bindlock);
1064         if (err)
1065                 goto out_put;
1066
1067         err = -EINVAL;
1068         if (u->addr)
1069                 goto out_up;
1070
1071         err = -ENOMEM;
1072         addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
1073         if (!addr)
1074                 goto out_up;
1075
1076         memcpy(addr->name, sunaddr, addr_len);
1077         addr->len = addr_len;
1078         addr->hash = hash ^ sk->sk_type;
1079         refcount_set(&addr->refcnt, 1);
1080
1081         if (sun_path[0]) {
1082                 addr->hash = UNIX_HASH_SIZE;
1083                 hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE - 1);
1084                 spin_lock(&unix_table_lock);
1085                 u->path = path;
1086                 list = &unix_socket_table[hash];
1087         } else {
1088                 spin_lock(&unix_table_lock);
1089                 err = -EADDRINUSE;
1090                 if (__unix_find_socket_byname(net, sunaddr, addr_len,
1091                                               sk->sk_type, hash)) {
1092                         unix_release_addr(addr);
1093                         goto out_unlock;
1094                 }
1095
1096                 list = &unix_socket_table[addr->hash];
1097         }
1098
1099         err = 0;
1100         __unix_remove_socket(sk);
1101         smp_store_release(&u->addr, addr);
1102         __unix_insert_socket(list, sk);
1103
1104 out_unlock:
1105         spin_unlock(&unix_table_lock);
1106 out_up:
1107         mutex_unlock(&u->bindlock);
1108 out_put:
1109         if (err)
1110                 path_put(&path);
1111 out:
1112         return err;
1113 }
1114
1115 static void unix_state_double_lock(struct sock *sk1, struct sock *sk2)
1116 {
1117         if (unlikely(sk1 == sk2) || !sk2) {
1118                 unix_state_lock(sk1);
1119                 return;
1120         }
1121         if (sk1 < sk2) {
1122                 unix_state_lock(sk1);
1123                 unix_state_lock_nested(sk2);
1124         } else {
1125                 unix_state_lock(sk2);
1126                 unix_state_lock_nested(sk1);
1127         }
1128 }
1129
1130 static void unix_state_double_unlock(struct sock *sk1, struct sock *sk2)
1131 {
1132         if (unlikely(sk1 == sk2) || !sk2) {
1133                 unix_state_unlock(sk1);
1134                 return;
1135         }
1136         unix_state_unlock(sk1);
1137         unix_state_unlock(sk2);
1138 }
1139
1140 static int unix_dgram_connect(struct socket *sock, struct sockaddr *addr,
1141                               int alen, int flags)
1142 {
1143         struct sock *sk = sock->sk;
1144         struct net *net = sock_net(sk);
1145         struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr;
1146         struct sock *other;
1147         unsigned int hash;
1148         int err;
1149
1150         err = -EINVAL;
1151         if (alen < offsetofend(struct sockaddr, sa_family))
1152                 goto out;
1153
1154         if (addr->sa_family != AF_UNSPEC) {
1155                 err = unix_mkname(sunaddr, alen, &hash);
1156                 if (err < 0)
1157                         goto out;
1158                 alen = err;
1159
1160                 if (test_bit(SOCK_PASSCRED, &sock->flags) &&
1161                     !unix_sk(sk)->addr && (err = unix_autobind(sock)) != 0)
1162                         goto out;
1163
1164 restart:
1165                 other = unix_find_other(net, sunaddr, alen, sock->type, hash, &err);
1166                 if (!other)
1167                         goto out;
1168
1169                 unix_state_double_lock(sk, other);
1170
1171                 /* Apparently VFS overslept socket death. Retry. */
1172                 if (sock_flag(other, SOCK_DEAD)) {
1173                         unix_state_double_unlock(sk, other);
1174                         sock_put(other);
1175                         goto restart;
1176                 }
1177
1178                 err = -EPERM;
1179                 if (!unix_may_send(sk, other))
1180                         goto out_unlock;
1181
1182                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1183                 if (err)
1184                         goto out_unlock;
1185
1186         } else {
1187                 /*
1188                  *      1003.1g breaking connected state with AF_UNSPEC
1189                  */
1190                 other = NULL;
1191                 unix_state_double_lock(sk, other);
1192         }
1193
1194         /*
1195          * If it was connected, reconnect.
1196          */
1197         if (unix_peer(sk)) {
1198                 struct sock *old_peer = unix_peer(sk);
1199                 unix_peer(sk) = other;
1200                 unix_dgram_peer_wake_disconnect_wakeup(sk, old_peer);
1201
1202                 unix_state_double_unlock(sk, other);
1203
1204                 if (other != old_peer)
1205                         unix_dgram_disconnected(sk, old_peer);
1206                 sock_put(old_peer);
1207         } else {
1208                 unix_peer(sk) = other;
1209                 unix_state_double_unlock(sk, other);
1210         }
1211         return 0;
1212
1213 out_unlock:
1214         unix_state_double_unlock(sk, other);
1215         sock_put(other);
1216 out:
1217         return err;
1218 }
1219
1220 static long unix_wait_for_peer(struct sock *other, long timeo)
1221 {
1222         struct unix_sock *u = unix_sk(other);
1223         int sched;
1224         DEFINE_WAIT(wait);
1225
1226         prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
1227
1228         sched = !sock_flag(other, SOCK_DEAD) &&
1229                 !(other->sk_shutdown & RCV_SHUTDOWN) &&
1230                 unix_recvq_full_lockless(other);
1231
1232         unix_state_unlock(other);
1233
1234         if (sched)
1235                 timeo = schedule_timeout(timeo);
1236
1237         finish_wait(&u->peer_wait, &wait);
1238         return timeo;
1239 }
1240
1241 static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr,
1242                                int addr_len, int flags)
1243 {
1244         struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
1245         struct sock *sk = sock->sk;
1246         struct net *net = sock_net(sk);
1247         struct unix_sock *u = unix_sk(sk), *newu, *otheru;
1248         struct sock *newsk = NULL;
1249         struct sock *other = NULL;
1250         struct sk_buff *skb = NULL;
1251         unsigned int hash;
1252         int st;
1253         int err;
1254         long timeo;
1255
1256         err = unix_mkname(sunaddr, addr_len, &hash);
1257         if (err < 0)
1258                 goto out;
1259         addr_len = err;
1260
1261         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
1262             (err = unix_autobind(sock)) != 0)
1263                 goto out;
1264
1265         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
1266
1267         /* First of all allocate resources.
1268            If we will make it after state is locked,
1269            we will have to recheck all again in any case.
1270          */
1271
1272         err = -ENOMEM;
1273
1274         /* create new sock for complete connection */
1275         newsk = unix_create1(sock_net(sk), NULL, 0);
1276         if (newsk == NULL)
1277                 goto out;
1278
1279         /* Allocate skb for sending to listening sock */
1280         skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
1281         if (skb == NULL)
1282                 goto out;
1283
1284 restart:
1285         /*  Find listening sock. */
1286         other = unix_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
1287         if (!other)
1288                 goto out;
1289
1290         /* Latch state of peer */
1291         unix_state_lock(other);
1292
1293         /* Apparently VFS overslept socket death. Retry. */
1294         if (sock_flag(other, SOCK_DEAD)) {
1295                 unix_state_unlock(other);
1296                 sock_put(other);
1297                 goto restart;
1298         }
1299
1300         err = -ECONNREFUSED;
1301         if (other->sk_state != TCP_LISTEN)
1302                 goto out_unlock;
1303         if (other->sk_shutdown & RCV_SHUTDOWN)
1304                 goto out_unlock;
1305
1306         if (unix_recvq_full(other)) {
1307                 err = -EAGAIN;
1308                 if (!timeo)
1309                         goto out_unlock;
1310
1311                 timeo = unix_wait_for_peer(other, timeo);
1312
1313                 err = sock_intr_errno(timeo);
1314                 if (signal_pending(current))
1315                         goto out;
1316                 sock_put(other);
1317                 goto restart;
1318         }
1319
1320         /* Latch our state.
1321
1322            It is tricky place. We need to grab our state lock and cannot
1323            drop lock on peer. It is dangerous because deadlock is
1324            possible. Connect to self case and simultaneous
1325            attempt to connect are eliminated by checking socket
1326            state. other is TCP_LISTEN, if sk is TCP_LISTEN we
1327            check this before attempt to grab lock.
1328
1329            Well, and we have to recheck the state after socket locked.
1330          */
1331         st = sk->sk_state;
1332
1333         switch (st) {
1334         case TCP_CLOSE:
1335                 /* This is ok... continue with connect */
1336                 break;
1337         case TCP_ESTABLISHED:
1338                 /* Socket is already connected */
1339                 err = -EISCONN;
1340                 goto out_unlock;
1341         default:
1342                 err = -EINVAL;
1343                 goto out_unlock;
1344         }
1345
1346         unix_state_lock_nested(sk);
1347
1348         if (sk->sk_state != st) {
1349                 unix_state_unlock(sk);
1350                 unix_state_unlock(other);
1351                 sock_put(other);
1352                 goto restart;
1353         }
1354
1355         err = security_unix_stream_connect(sk, other, newsk);
1356         if (err) {
1357                 unix_state_unlock(sk);
1358                 goto out_unlock;
1359         }
1360
1361         /* The way is open! Fastly set all the necessary fields... */
1362
1363         sock_hold(sk);
1364         unix_peer(newsk)        = sk;
1365         newsk->sk_state         = TCP_ESTABLISHED;
1366         newsk->sk_type          = sk->sk_type;
1367         init_peercred(newsk);
1368         newu = unix_sk(newsk);
1369         RCU_INIT_POINTER(newsk->sk_wq, &newu->peer_wq);
1370         otheru = unix_sk(other);
1371
1372         /* copy address information from listening to new sock
1373          *
1374          * The contents of *(otheru->addr) and otheru->path
1375          * are seen fully set up here, since we have found
1376          * otheru in hash under unix_table_lock.  Insertion
1377          * into the hash chain we'd found it in had been done
1378          * in an earlier critical area protected by unix_table_lock,
1379          * the same one where we'd set *(otheru->addr) contents,
1380          * as well as otheru->path and otheru->addr itself.
1381          *
1382          * Using smp_store_release() here to set newu->addr
1383          * is enough to make those stores, as well as stores
1384          * to newu->path visible to anyone who gets newu->addr
1385          * by smp_load_acquire().  IOW, the same warranties
1386          * as for unix_sock instances bound in unix_bind() or
1387          * in unix_autobind().
1388          */
1389         if (otheru->path.dentry) {
1390                 path_get(&otheru->path);
1391                 newu->path = otheru->path;
1392         }
1393         refcount_inc(&otheru->addr->refcnt);
1394         smp_store_release(&newu->addr, otheru->addr);
1395
1396         /* Set credentials */
1397         copy_peercred(sk, other);
1398
1399         sock->state     = SS_CONNECTED;
1400         sk->sk_state    = TCP_ESTABLISHED;
1401         sock_hold(newsk);
1402
1403         smp_mb__after_atomic(); /* sock_hold() does an atomic_inc() */
1404         unix_peer(sk)   = newsk;
1405
1406         unix_state_unlock(sk);
1407
1408         /* take ten and and send info to listening sock */
1409         spin_lock(&other->sk_receive_queue.lock);
1410         __skb_queue_tail(&other->sk_receive_queue, skb);
1411         spin_unlock(&other->sk_receive_queue.lock);
1412         unix_state_unlock(other);
1413         other->sk_data_ready(other);
1414         sock_put(other);
1415         return 0;
1416
1417 out_unlock:
1418         if (other)
1419                 unix_state_unlock(other);
1420
1421 out:
1422         kfree_skb(skb);
1423         if (newsk)
1424                 unix_release_sock(newsk, 0);
1425         if (other)
1426                 sock_put(other);
1427         return err;
1428 }
1429
1430 static int unix_socketpair(struct socket *socka, struct socket *sockb)
1431 {
1432         struct sock *ska = socka->sk, *skb = sockb->sk;
1433
1434         /* Join our sockets back to back */
1435         sock_hold(ska);
1436         sock_hold(skb);
1437         unix_peer(ska) = skb;
1438         unix_peer(skb) = ska;
1439         init_peercred(ska);
1440         init_peercred(skb);
1441
1442         if (ska->sk_type != SOCK_DGRAM) {
1443                 ska->sk_state = TCP_ESTABLISHED;
1444                 skb->sk_state = TCP_ESTABLISHED;
1445                 socka->state  = SS_CONNECTED;
1446                 sockb->state  = SS_CONNECTED;
1447         }
1448         return 0;
1449 }
1450
1451 static void unix_sock_inherit_flags(const struct socket *old,
1452                                     struct socket *new)
1453 {
1454         if (test_bit(SOCK_PASSCRED, &old->flags))
1455                 set_bit(SOCK_PASSCRED, &new->flags);
1456         if (test_bit(SOCK_PASSSEC, &old->flags))
1457                 set_bit(SOCK_PASSSEC, &new->flags);
1458 }
1459
1460 static int unix_accept(struct socket *sock, struct socket *newsock, int flags,
1461                        bool kern)
1462 {
1463         struct sock *sk = sock->sk;
1464         struct sock *tsk;
1465         struct sk_buff *skb;
1466         int err;
1467
1468         err = -EOPNOTSUPP;
1469         if (sock->type != SOCK_STREAM && sock->type != SOCK_SEQPACKET)
1470                 goto out;
1471
1472         err = -EINVAL;
1473         if (sk->sk_state != TCP_LISTEN)
1474                 goto out;
1475
1476         /* If socket state is TCP_LISTEN it cannot change (for now...),
1477          * so that no locks are necessary.
1478          */
1479
1480         skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
1481         if (!skb) {
1482                 /* This means receive shutdown. */
1483                 if (err == 0)
1484                         err = -EINVAL;
1485                 goto out;
1486         }
1487
1488         tsk = skb->sk;
1489         skb_free_datagram(sk, skb);
1490         wake_up_interruptible(&unix_sk(sk)->peer_wait);
1491
1492         /* attach accepted sock to socket */
1493         unix_state_lock(tsk);
1494         newsock->state = SS_CONNECTED;
1495         unix_sock_inherit_flags(sock, newsock);
1496         sock_graft(tsk, newsock);
1497         unix_state_unlock(tsk);
1498         return 0;
1499
1500 out:
1501         return err;
1502 }
1503
1504
1505 static int unix_getname(struct socket *sock, struct sockaddr *uaddr, int peer)
1506 {
1507         struct sock *sk = sock->sk;
1508         struct unix_address *addr;
1509         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
1510         int err = 0;
1511
1512         if (peer) {
1513                 sk = unix_peer_get(sk);
1514
1515                 err = -ENOTCONN;
1516                 if (!sk)
1517                         goto out;
1518                 err = 0;
1519         } else {
1520                 sock_hold(sk);
1521         }
1522
1523         addr = smp_load_acquire(&unix_sk(sk)->addr);
1524         if (!addr) {
1525                 sunaddr->sun_family = AF_UNIX;
1526                 sunaddr->sun_path[0] = 0;
1527                 err = sizeof(short);
1528         } else {
1529                 err = addr->len;
1530                 memcpy(sunaddr, addr->name, addr->len);
1531         }
1532         sock_put(sk);
1533 out:
1534         return err;
1535 }
1536
1537 static void unix_peek_fds(struct scm_cookie *scm, struct sk_buff *skb)
1538 {
1539         scm->fp = scm_fp_dup(UNIXCB(skb).fp);
1540
1541         /*
1542          * Garbage collection of unix sockets starts by selecting a set of
1543          * candidate sockets which have reference only from being in flight
1544          * (total_refs == inflight_refs).  This condition is checked once during
1545          * the candidate collection phase, and candidates are marked as such, so
1546          * that non-candidates can later be ignored.  While inflight_refs is
1547          * protected by unix_gc_lock, total_refs (file count) is not, hence this
1548          * is an instantaneous decision.
1549          *
1550          * Once a candidate, however, the socket must not be reinstalled into a
1551          * file descriptor while the garbage collection is in progress.
1552          *
1553          * If the above conditions are met, then the directed graph of
1554          * candidates (*) does not change while unix_gc_lock is held.
1555          *
1556          * Any operations that changes the file count through file descriptors
1557          * (dup, close, sendmsg) does not change the graph since candidates are
1558          * not installed in fds.
1559          *
1560          * Dequeing a candidate via recvmsg would install it into an fd, but
1561          * that takes unix_gc_lock to decrement the inflight count, so it's
1562          * serialized with garbage collection.
1563          *
1564          * MSG_PEEK is special in that it does not change the inflight count,
1565          * yet does install the socket into an fd.  The following lock/unlock
1566          * pair is to ensure serialization with garbage collection.  It must be
1567          * done between incrementing the file count and installing the file into
1568          * an fd.
1569          *
1570          * If garbage collection starts after the barrier provided by the
1571          * lock/unlock, then it will see the elevated refcount and not mark this
1572          * as a candidate.  If a garbage collection is already in progress
1573          * before the file count was incremented, then the lock/unlock pair will
1574          * ensure that garbage collection is finished before progressing to
1575          * installing the fd.
1576          *
1577          * (*) A -> B where B is on the queue of A or B is on the queue of C
1578          * which is on the queue of listening socket A.
1579          */
1580         spin_lock(&unix_gc_lock);
1581         spin_unlock(&unix_gc_lock);
1582 }
1583
1584 static int unix_scm_to_skb(struct scm_cookie *scm, struct sk_buff *skb, bool send_fds)
1585 {
1586         int err = 0;
1587
1588         UNIXCB(skb).pid  = get_pid(scm->pid);
1589         UNIXCB(skb).uid = scm->creds.uid;
1590         UNIXCB(skb).gid = scm->creds.gid;
1591         UNIXCB(skb).fp = NULL;
1592         unix_get_secdata(scm, skb);
1593         if (scm->fp && send_fds)
1594                 err = unix_attach_fds(scm, skb);
1595
1596         skb->destructor = unix_destruct_scm;
1597         return err;
1598 }
1599
1600 static bool unix_passcred_enabled(const struct socket *sock,
1601                                   const struct sock *other)
1602 {
1603         return test_bit(SOCK_PASSCRED, &sock->flags) ||
1604                !other->sk_socket ||
1605                test_bit(SOCK_PASSCRED, &other->sk_socket->flags);
1606 }
1607
1608 /*
1609  * Some apps rely on write() giving SCM_CREDENTIALS
1610  * We include credentials if source or destination socket
1611  * asserted SOCK_PASSCRED.
1612  */
1613 static void maybe_add_creds(struct sk_buff *skb, const struct socket *sock,
1614                             const struct sock *other)
1615 {
1616         if (UNIXCB(skb).pid)
1617                 return;
1618         if (unix_passcred_enabled(sock, other)) {
1619                 UNIXCB(skb).pid  = get_pid(task_tgid(current));
1620                 current_uid_gid(&UNIXCB(skb).uid, &UNIXCB(skb).gid);
1621         }
1622 }
1623
1624 static int maybe_init_creds(struct scm_cookie *scm,
1625                             struct socket *socket,
1626                             const struct sock *other)
1627 {
1628         int err;
1629         struct msghdr msg = { .msg_controllen = 0 };
1630
1631         err = scm_send(socket, &msg, scm, false);
1632         if (err)
1633                 return err;
1634
1635         if (unix_passcred_enabled(socket, other)) {
1636                 scm->pid = get_pid(task_tgid(current));
1637                 current_uid_gid(&scm->creds.uid, &scm->creds.gid);
1638         }
1639         return err;
1640 }
1641
1642 static bool unix_skb_scm_eq(struct sk_buff *skb,
1643                             struct scm_cookie *scm)
1644 {
1645         const struct unix_skb_parms *u = &UNIXCB(skb);
1646
1647         return u->pid == scm->pid &&
1648                uid_eq(u->uid, scm->creds.uid) &&
1649                gid_eq(u->gid, scm->creds.gid) &&
1650                unix_secdata_eq(scm, skb);
1651 }
1652
1653 /*
1654  *      Send AF_UNIX data.
1655  */
1656
1657 static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
1658                               size_t len)
1659 {
1660         struct sock *sk = sock->sk;
1661         struct net *net = sock_net(sk);
1662         struct unix_sock *u = unix_sk(sk);
1663         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
1664         struct sock *other = NULL;
1665         int namelen = 0; /* fake GCC */
1666         int err;
1667         unsigned int hash;
1668         struct sk_buff *skb;
1669         long timeo;
1670         struct scm_cookie scm;
1671         int data_len = 0;
1672         int sk_locked;
1673
1674         wait_for_unix_gc();
1675         err = scm_send(sock, msg, &scm, false);
1676         if (err < 0)
1677                 return err;
1678
1679         err = -EOPNOTSUPP;
1680         if (msg->msg_flags&MSG_OOB)
1681                 goto out;
1682
1683         if (msg->msg_namelen) {
1684                 err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
1685                 if (err < 0)
1686                         goto out;
1687                 namelen = err;
1688         } else {
1689                 sunaddr = NULL;
1690                 err = -ENOTCONN;
1691                 other = unix_peer_get(sk);
1692                 if (!other)
1693                         goto out;
1694         }
1695
1696         if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
1697             && (err = unix_autobind(sock)) != 0)
1698                 goto out;
1699
1700         err = -EMSGSIZE;
1701         if (len > sk->sk_sndbuf - 32)
1702                 goto out;
1703
1704         if (len > SKB_MAX_ALLOC) {
1705                 data_len = min_t(size_t,
1706                                  len - SKB_MAX_ALLOC,
1707                                  MAX_SKB_FRAGS * PAGE_SIZE);
1708                 data_len = PAGE_ALIGN(data_len);
1709
1710                 BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
1711         }
1712
1713         skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
1714                                    msg->msg_flags & MSG_DONTWAIT, &err,
1715                                    PAGE_ALLOC_COSTLY_ORDER);
1716         if (skb == NULL)
1717                 goto out;
1718
1719         err = unix_scm_to_skb(&scm, skb, true);
1720         if (err < 0)
1721                 goto out_free;
1722
1723         skb_put(skb, len - data_len);
1724         skb->data_len = data_len;
1725         skb->len = len;
1726         err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);
1727         if (err)
1728                 goto out_free;
1729
1730         timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1731
1732 restart:
1733         if (!other) {
1734                 err = -ECONNRESET;
1735                 if (sunaddr == NULL)
1736                         goto out_free;
1737
1738                 other = unix_find_other(net, sunaddr, namelen, sk->sk_type,
1739                                         hash, &err);
1740                 if (other == NULL)
1741                         goto out_free;
1742         }
1743
1744         if (sk_filter(other, skb) < 0) {
1745                 /* Toss the packet but do not return any error to the sender */
1746                 err = len;
1747                 goto out_free;
1748         }
1749
1750         sk_locked = 0;
1751         unix_state_lock(other);
1752 restart_locked:
1753         err = -EPERM;
1754         if (!unix_may_send(sk, other))
1755                 goto out_unlock;
1756
1757         if (unlikely(sock_flag(other, SOCK_DEAD))) {
1758                 /*
1759                  *      Check with 1003.1g - what should
1760                  *      datagram error
1761                  */
1762                 unix_state_unlock(other);
1763                 sock_put(other);
1764
1765                 if (!sk_locked)
1766                         unix_state_lock(sk);
1767
1768                 err = 0;
1769                 if (unix_peer(sk) == other) {
1770                         unix_peer(sk) = NULL;
1771                         unix_dgram_peer_wake_disconnect_wakeup(sk, other);
1772
1773                         unix_state_unlock(sk);
1774
1775                         unix_dgram_disconnected(sk, other);
1776                         sock_put(other);
1777                         err = -ECONNREFUSED;
1778                 } else {
1779                         unix_state_unlock(sk);
1780                 }
1781
1782                 other = NULL;
1783                 if (err)
1784                         goto out_free;
1785                 goto restart;
1786         }
1787
1788         err = -EPIPE;
1789         if (other->sk_shutdown & RCV_SHUTDOWN)
1790                 goto out_unlock;
1791
1792         if (sk->sk_type != SOCK_SEQPACKET) {
1793                 err = security_unix_may_send(sk->sk_socket, other->sk_socket);
1794                 if (err)
1795                         goto out_unlock;
1796         }
1797
1798         /* other == sk && unix_peer(other) != sk if
1799          * - unix_peer(sk) == NULL, destination address bound to sk
1800          * - unix_peer(sk) == sk by time of get but disconnected before lock
1801          */
1802         if (other != sk &&
1803             unlikely(unix_peer(other) != sk &&
1804             unix_recvq_full_lockless(other))) {
1805                 if (timeo) {
1806                         timeo = unix_wait_for_peer(other, timeo);
1807
1808                         err = sock_intr_errno(timeo);
1809                         if (signal_pending(current))
1810                                 goto out_free;
1811
1812                         goto restart;
1813                 }
1814
1815                 if (!sk_locked) {
1816                         unix_state_unlock(other);
1817                         unix_state_double_lock(sk, other);
1818                 }
1819
1820                 if (unix_peer(sk) != other ||
1821                     unix_dgram_peer_wake_me(sk, other)) {
1822                         err = -EAGAIN;
1823                         sk_locked = 1;
1824                         goto out_unlock;
1825                 }
1826
1827                 if (!sk_locked) {
1828                         sk_locked = 1;
1829                         goto restart_locked;
1830                 }
1831         }
1832
1833         if (unlikely(sk_locked))
1834                 unix_state_unlock(sk);
1835
1836         if (sock_flag(other, SOCK_RCVTSTAMP))
1837                 __net_timestamp(skb);
1838         maybe_add_creds(skb, sock, other);
1839         skb_queue_tail(&other->sk_receive_queue, skb);
1840         unix_state_unlock(other);
1841         other->sk_data_ready(other);
1842         sock_put(other);
1843         scm_destroy(&scm);
1844         return len;
1845
1846 out_unlock:
1847         if (sk_locked)
1848                 unix_state_unlock(sk);
1849         unix_state_unlock(other);
1850 out_free:
1851         kfree_skb(skb);
1852 out:
1853         if (other)
1854                 sock_put(other);
1855         scm_destroy(&scm);
1856         return err;
1857 }
1858
1859 /* We use paged skbs for stream sockets, and limit occupancy to 32768
1860  * bytes, and a minimum of a full page.
1861  */
1862 #define UNIX_SKB_FRAGS_SZ (PAGE_SIZE << get_order(32768))
1863
1864 static int unix_stream_sendmsg(struct socket *sock, struct msghdr *msg,
1865                                size_t len)
1866 {
1867         struct sock *sk = sock->sk;
1868         struct sock *other = NULL;
1869         int err, size;
1870         struct sk_buff *skb;
1871         int sent = 0;
1872         struct scm_cookie scm;
1873         bool fds_sent = false;
1874         int data_len;
1875
1876         wait_for_unix_gc();
1877         err = scm_send(sock, msg, &scm, false);
1878         if (err < 0)
1879                 return err;
1880
1881         err = -EOPNOTSUPP;
1882         if (msg->msg_flags&MSG_OOB)
1883                 goto out_err;
1884
1885         if (msg->msg_namelen) {
1886                 err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
1887                 goto out_err;
1888         } else {
1889                 err = -ENOTCONN;
1890                 other = unix_peer(sk);
1891                 if (!other)
1892                         goto out_err;
1893         }
1894
1895         if (sk->sk_shutdown & SEND_SHUTDOWN)
1896                 goto pipe_err;
1897
1898         while (sent < len) {
1899                 size = len - sent;
1900
1901                 /* Keep two messages in the pipe so it schedules better */
1902                 size = min_t(int, size, (sk->sk_sndbuf >> 1) - 64);
1903
1904                 /* allow fallback to order-0 allocations */
1905                 size = min_t(int, size, SKB_MAX_HEAD(0) + UNIX_SKB_FRAGS_SZ);
1906
1907                 data_len = max_t(int, 0, size - SKB_MAX_HEAD(0));
1908
1909                 data_len = min_t(size_t, size, PAGE_ALIGN(data_len));
1910
1911                 skb = sock_alloc_send_pskb(sk, size - data_len, data_len,
1912                                            msg->msg_flags & MSG_DONTWAIT, &err,
1913                                            get_order(UNIX_SKB_FRAGS_SZ));
1914                 if (!skb)
1915                         goto out_err;
1916
1917                 /* Only send the fds in the first buffer */
1918                 err = unix_scm_to_skb(&scm, skb, !fds_sent);
1919                 if (err < 0) {
1920                         kfree_skb(skb);
1921                         goto out_err;
1922                 }
1923                 fds_sent = true;
1924
1925                 skb_put(skb, size - data_len);
1926                 skb->data_len = data_len;
1927                 skb->len = size;
1928                 err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
1929                 if (err) {
1930                         kfree_skb(skb);
1931                         goto out_err;
1932                 }
1933
1934                 unix_state_lock(other);
1935
1936                 if (sock_flag(other, SOCK_DEAD) ||
1937                     (other->sk_shutdown & RCV_SHUTDOWN))
1938                         goto pipe_err_free;
1939
1940                 maybe_add_creds(skb, sock, other);
1941                 skb_queue_tail(&other->sk_receive_queue, skb);
1942                 unix_state_unlock(other);
1943                 other->sk_data_ready(other);
1944                 sent += size;
1945         }
1946
1947         scm_destroy(&scm);
1948
1949         return sent;
1950
1951 pipe_err_free:
1952         unix_state_unlock(other);
1953         kfree_skb(skb);
1954 pipe_err:
1955         if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
1956                 send_sig(SIGPIPE, current, 0);
1957         err = -EPIPE;
1958 out_err:
1959         scm_destroy(&scm);
1960         return sent ? : err;
1961 }
1962
1963 static ssize_t unix_stream_sendpage(struct socket *socket, struct page *page,
1964                                     int offset, size_t size, int flags)
1965 {
1966         int err;
1967         bool send_sigpipe = false;
1968         bool init_scm = true;
1969         struct scm_cookie scm;
1970         struct sock *other, *sk = socket->sk;
1971         struct sk_buff *skb, *newskb = NULL, *tail = NULL;
1972
1973         if (flags & MSG_OOB)
1974                 return -EOPNOTSUPP;
1975
1976         other = unix_peer(sk);
1977         if (!other || sk->sk_state != TCP_ESTABLISHED)
1978                 return -ENOTCONN;
1979
1980         if (false) {
1981 alloc_skb:
1982                 spin_unlock(&other->sk_receive_queue.lock);
1983                 unix_state_unlock(other);
1984                 mutex_unlock(&unix_sk(other)->iolock);
1985                 newskb = sock_alloc_send_pskb(sk, 0, 0, flags & MSG_DONTWAIT,
1986                                               &err, 0);
1987                 if (!newskb)
1988                         goto err;
1989         }
1990
1991         /* we must acquire iolock as we modify already present
1992          * skbs in the sk_receive_queue and mess with skb->len
1993          */
1994         err = mutex_lock_interruptible(&unix_sk(other)->iolock);
1995         if (err) {
1996                 err = flags & MSG_DONTWAIT ? -EAGAIN : -ERESTARTSYS;
1997                 goto err;
1998         }
1999
2000         if (sk->sk_shutdown & SEND_SHUTDOWN) {
2001                 err = -EPIPE;
2002                 send_sigpipe = true;
2003                 goto err_unlock;
2004         }
2005
2006         unix_state_lock(other);
2007
2008         if (sock_flag(other, SOCK_DEAD) ||
2009             other->sk_shutdown & RCV_SHUTDOWN) {
2010                 err = -EPIPE;
2011                 send_sigpipe = true;
2012                 goto err_state_unlock;
2013         }
2014
2015         if (init_scm) {
2016                 err = maybe_init_creds(&scm, socket, other);
2017                 if (err)
2018                         goto err_state_unlock;
2019                 init_scm = false;
2020         }
2021
2022         spin_lock(&other->sk_receive_queue.lock);
2023         skb = skb_peek_tail(&other->sk_receive_queue);
2024         if (tail && tail == skb) {
2025                 skb = newskb;
2026         } else if (!skb || !unix_skb_scm_eq(skb, &scm)) {
2027                 if (newskb) {
2028                         skb = newskb;
2029                 } else {
2030                         tail = skb;
2031                         goto alloc_skb;
2032                 }
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
2037                  */
2038                 consume_skb(newskb);
2039                 newskb = NULL;
2040         }
2041
2042         if (skb_append_pagefrags(skb, page, offset, size)) {
2043                 tail = skb;
2044                 goto alloc_skb;
2045         }
2046
2047         skb->len += size;
2048         skb->data_len += size;
2049         skb->truesize += size;
2050         refcount_add(size, &sk->sk_wmem_alloc);
2051
2052         if (newskb) {
2053                 unix_scm_to_skb(&scm, skb, false);
2054                 __skb_queue_tail(&other->sk_receive_queue, newskb);
2055         }
2056
2057         spin_unlock(&other->sk_receive_queue.lock);
2058         unix_state_unlock(other);
2059         mutex_unlock(&unix_sk(other)->iolock);
2060
2061         other->sk_data_ready(other);
2062         scm_destroy(&scm);
2063         return size;
2064
2065 err_state_unlock:
2066         unix_state_unlock(other);
2067 err_unlock:
2068         mutex_unlock(&unix_sk(other)->iolock);
2069 err:
2070         kfree_skb(newskb);
2071         if (send_sigpipe && !(flags & MSG_NOSIGNAL))
2072                 send_sig(SIGPIPE, current, 0);
2073         if (!init_scm)
2074                 scm_destroy(&scm);
2075         return err;
2076 }
2077
2078 static int unix_seqpacket_sendmsg(struct socket *sock, struct msghdr *msg,
2079                                   size_t len)
2080 {
2081         int err;
2082         struct sock *sk = sock->sk;
2083
2084         err = sock_error(sk);
2085         if (err)
2086                 return err;
2087
2088         if (sk->sk_state != TCP_ESTABLISHED)
2089                 return -ENOTCONN;
2090
2091         if (msg->msg_namelen)
2092                 msg->msg_namelen = 0;
2093
2094         return unix_dgram_sendmsg(sock, msg, len);
2095 }
2096
2097 static int unix_seqpacket_recvmsg(struct socket *sock, struct msghdr *msg,
2098                                   size_t size, int flags)
2099 {
2100         struct sock *sk = sock->sk;
2101
2102         if (sk->sk_state != TCP_ESTABLISHED)
2103                 return -ENOTCONN;
2104
2105         return unix_dgram_recvmsg(sock, msg, size, flags);
2106 }
2107
2108 static void unix_copy_addr(struct msghdr *msg, struct sock *sk)
2109 {
2110         struct unix_address *addr = smp_load_acquire(&unix_sk(sk)->addr);
2111
2112         if (addr) {
2113                 msg->msg_namelen = addr->len;
2114                 memcpy(msg->msg_name, addr->name, addr->len);
2115         }
2116 }
2117
2118 static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
2119                               size_t size, int flags)
2120 {
2121         struct scm_cookie scm;
2122         struct sock *sk = sock->sk;
2123         struct unix_sock *u = unix_sk(sk);
2124         struct sk_buff *skb, *last;
2125         long timeo;
2126         int skip;
2127         int err;
2128
2129         err = -EOPNOTSUPP;
2130         if (flags&MSG_OOB)
2131                 goto out;
2132
2133         timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
2134
2135         do {
2136                 mutex_lock(&u->iolock);
2137
2138                 skip = sk_peek_offset(sk, flags);
2139                 skb = __skb_try_recv_datagram(sk, flags, NULL, &skip, &err,
2140                                               &last);
2141                 if (skb)
2142                         break;
2143
2144                 mutex_unlock(&u->iolock);
2145
2146                 if (err != -EAGAIN)
2147                         break;
2148         } while (timeo &&
2149                  !__skb_wait_for_more_packets(sk, &err, &timeo, last));
2150
2151         if (!skb) { /* implies iolock unlocked */
2152                 unix_state_lock(sk);
2153                 /* Signal EOF on disconnected non-blocking SEQPACKET socket. */
2154                 if (sk->sk_type == SOCK_SEQPACKET && err == -EAGAIN &&
2155                     (sk->sk_shutdown & RCV_SHUTDOWN))
2156                         err = 0;
2157                 unix_state_unlock(sk);
2158                 goto out;
2159         }
2160
2161         if (wq_has_sleeper(&u->peer_wait))
2162                 wake_up_interruptible_sync_poll(&u->peer_wait,
2163                                                 EPOLLOUT | EPOLLWRNORM |
2164                                                 EPOLLWRBAND);
2165
2166         if (msg->msg_name)
2167                 unix_copy_addr(msg, skb->sk);
2168
2169         if (size > skb->len - skip)
2170                 size = skb->len - skip;
2171         else if (size < skb->len - skip)
2172                 msg->msg_flags |= MSG_TRUNC;
2173
2174         err = skb_copy_datagram_msg(skb, skip, msg, size);
2175         if (err)
2176                 goto out_free;
2177
2178         if (sock_flag(sk, SOCK_RCVTSTAMP))
2179                 __sock_recv_timestamp(msg, sk, skb);
2180
2181         memset(&scm, 0, sizeof(scm));
2182
2183         scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2184         unix_set_secdata(&scm, skb);
2185
2186         if (!(flags & MSG_PEEK)) {
2187                 if (UNIXCB(skb).fp)
2188                         unix_detach_fds(&scm, skb);
2189
2190                 sk_peek_offset_bwd(sk, skb->len);
2191         } else {
2192                 /* It is questionable: on PEEK we could:
2193                    - do not return fds - good, but too simple 8)
2194                    - return fds, and do not return them on read (old strategy,
2195                      apparently wrong)
2196                    - clone fds (I chose it for now, it is the most universal
2197                      solution)
2198
2199                    POSIX 1003.1g does not actually define this clearly
2200                    at all. POSIX 1003.1g doesn't define a lot of things
2201                    clearly however!
2202
2203                 */
2204
2205                 sk_peek_offset_fwd(sk, size);
2206
2207                 if (UNIXCB(skb).fp)
2208                         unix_peek_fds(&scm, skb);
2209         }
2210         err = (flags & MSG_TRUNC) ? skb->len - skip : size;
2211
2212         scm_recv(sock, msg, &scm, flags);
2213
2214 out_free:
2215         skb_free_datagram(sk, skb);
2216         mutex_unlock(&u->iolock);
2217 out:
2218         return err;
2219 }
2220
2221 /*
2222  *      Sleep until more data has arrived. But check for races..
2223  */
2224 static long unix_stream_data_wait(struct sock *sk, long timeo,
2225                                   struct sk_buff *last, unsigned int last_len,
2226                                   bool freezable)
2227 {
2228         struct sk_buff *tail;
2229         DEFINE_WAIT(wait);
2230
2231         unix_state_lock(sk);
2232
2233         for (;;) {
2234                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2235
2236                 tail = skb_peek_tail(&sk->sk_receive_queue);
2237                 if (tail != last ||
2238                     (tail && tail->len != last_len) ||
2239                     sk->sk_err ||
2240                     (sk->sk_shutdown & RCV_SHUTDOWN) ||
2241                     signal_pending(current) ||
2242                     !timeo)
2243                         break;
2244
2245                 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2246                 unix_state_unlock(sk);
2247                 if (freezable)
2248                         timeo = freezable_schedule_timeout(timeo);
2249                 else
2250                         timeo = schedule_timeout(timeo);
2251                 unix_state_lock(sk);
2252
2253                 if (sock_flag(sk, SOCK_DEAD))
2254                         break;
2255
2256                 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2257         }
2258
2259         finish_wait(sk_sleep(sk), &wait);
2260         unix_state_unlock(sk);
2261         return timeo;
2262 }
2263
2264 static unsigned int unix_skb_len(const struct sk_buff *skb)
2265 {
2266         return skb->len - UNIXCB(skb).consumed;
2267 }
2268
2269 struct unix_stream_read_state {
2270         int (*recv_actor)(struct sk_buff *, int, int,
2271                           struct unix_stream_read_state *);
2272         struct socket *socket;
2273         struct msghdr *msg;
2274         struct pipe_inode_info *pipe;
2275         size_t size;
2276         int flags;
2277         unsigned int splice_flags;
2278 };
2279
2280 static int unix_stream_read_generic(struct unix_stream_read_state *state,
2281                                     bool freezable)
2282 {
2283         struct scm_cookie scm;
2284         struct socket *sock = state->socket;
2285         struct sock *sk = sock->sk;
2286         struct unix_sock *u = unix_sk(sk);
2287         int copied = 0;
2288         int flags = state->flags;
2289         int noblock = flags & MSG_DONTWAIT;
2290         bool check_creds = false;
2291         int target;
2292         int err = 0;
2293         long timeo;
2294         int skip;
2295         size_t size = state->size;
2296         unsigned int last_len;
2297
2298         if (unlikely(sk->sk_state != TCP_ESTABLISHED)) {
2299                 err = -EINVAL;
2300                 goto out;
2301         }
2302
2303         if (unlikely(flags & MSG_OOB)) {
2304                 err = -EOPNOTSUPP;
2305                 goto out;
2306         }
2307
2308         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
2309         timeo = sock_rcvtimeo(sk, noblock);
2310
2311         memset(&scm, 0, sizeof(scm));
2312
2313         /* Lock the socket to prevent queue disordering
2314          * while sleeps in memcpy_tomsg
2315          */
2316         mutex_lock(&u->iolock);
2317
2318         skip = max(sk_peek_offset(sk, flags), 0);
2319
2320         do {
2321                 int chunk;
2322                 bool drop_skb;
2323                 struct sk_buff *skb, *last;
2324
2325 redo:
2326                 unix_state_lock(sk);
2327                 if (sock_flag(sk, SOCK_DEAD)) {
2328                         err = -ECONNRESET;
2329                         goto unlock;
2330                 }
2331                 last = skb = skb_peek(&sk->sk_receive_queue);
2332                 last_len = last ? last->len : 0;
2333 again:
2334                 if (skb == NULL) {
2335                         if (copied >= target)
2336                                 goto unlock;
2337
2338                         /*
2339                          *      POSIX 1003.1g mandates this order.
2340                          */
2341
2342                         err = sock_error(sk);
2343                         if (err)
2344                                 goto unlock;
2345                         if (sk->sk_shutdown & RCV_SHUTDOWN)
2346                                 goto unlock;
2347
2348                         unix_state_unlock(sk);
2349                         if (!timeo) {
2350                                 err = -EAGAIN;
2351                                 break;
2352                         }
2353
2354                         mutex_unlock(&u->iolock);
2355
2356                         timeo = unix_stream_data_wait(sk, timeo, last,
2357                                                       last_len, freezable);
2358
2359                         if (signal_pending(current)) {
2360                                 err = sock_intr_errno(timeo);
2361                                 scm_destroy(&scm);
2362                                 goto out;
2363                         }
2364
2365                         mutex_lock(&u->iolock);
2366                         goto redo;
2367 unlock:
2368                         unix_state_unlock(sk);
2369                         break;
2370                 }
2371
2372                 while (skip >= unix_skb_len(skb)) {
2373                         skip -= unix_skb_len(skb);
2374                         last = skb;
2375                         last_len = skb->len;
2376                         skb = skb_peek_next(skb, &sk->sk_receive_queue);
2377                         if (!skb)
2378                                 goto again;
2379                 }
2380
2381                 unix_state_unlock(sk);
2382
2383                 if (check_creds) {
2384                         /* Never glue messages from different writers */
2385                         if (!unix_skb_scm_eq(skb, &scm))
2386                                 break;
2387                 } else if (test_bit(SOCK_PASSCRED, &sock->flags)) {
2388                         /* Copy credentials */
2389                         scm_set_cred(&scm, UNIXCB(skb).pid, UNIXCB(skb).uid, UNIXCB(skb).gid);
2390                         unix_set_secdata(&scm, skb);
2391                         check_creds = true;
2392                 }
2393
2394                 /* Copy address just once */
2395                 if (state->msg && state->msg->msg_name) {
2396                         DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr,
2397                                          state->msg->msg_name);
2398                         unix_copy_addr(state->msg, skb->sk);
2399                         sunaddr = NULL;
2400                 }
2401
2402                 chunk = min_t(unsigned int, unix_skb_len(skb) - skip, size);
2403                 skb_get(skb);
2404                 chunk = state->recv_actor(skb, skip, chunk, state);
2405                 drop_skb = !unix_skb_len(skb);
2406                 /* skb is only safe to use if !drop_skb */
2407                 consume_skb(skb);
2408                 if (chunk < 0) {
2409                         if (copied == 0)
2410                                 copied = -EFAULT;
2411                         break;
2412                 }
2413                 copied += chunk;
2414                 size -= chunk;
2415
2416                 if (drop_skb) {
2417                         /* the skb was touched by a concurrent reader;
2418                          * we should not expect anything from this skb
2419                          * anymore and assume it invalid - we can be
2420                          * sure it was dropped from the socket queue
2421                          *
2422                          * let's report a short read
2423                          */
2424                         err = 0;
2425                         break;
2426                 }
2427
2428                 /* Mark read part of skb as used */
2429                 if (!(flags & MSG_PEEK)) {
2430                         UNIXCB(skb).consumed += chunk;
2431
2432                         sk_peek_offset_bwd(sk, chunk);
2433
2434                         if (UNIXCB(skb).fp)
2435                                 unix_detach_fds(&scm, skb);
2436
2437                         if (unix_skb_len(skb))
2438                                 break;
2439
2440                         skb_unlink(skb, &sk->sk_receive_queue);
2441                         consume_skb(skb);
2442
2443                         if (scm.fp)
2444                                 break;
2445                 } else {
2446                         /* It is questionable, see note in unix_dgram_recvmsg.
2447                          */
2448                         if (UNIXCB(skb).fp)
2449                                 unix_peek_fds(&scm, skb);
2450
2451                         sk_peek_offset_fwd(sk, chunk);
2452
2453                         if (UNIXCB(skb).fp)
2454                                 break;
2455
2456                         skip = 0;
2457                         last = skb;
2458                         last_len = skb->len;
2459                         unix_state_lock(sk);
2460                         skb = skb_peek_next(skb, &sk->sk_receive_queue);
2461                         if (skb)
2462                                 goto again;
2463                         unix_state_unlock(sk);
2464                         break;
2465                 }
2466         } while (size);
2467
2468         mutex_unlock(&u->iolock);
2469         if (state->msg)
2470                 scm_recv(sock, state->msg, &scm, flags);
2471         else
2472                 scm_destroy(&scm);
2473 out:
2474         return copied ? : err;
2475 }
2476
2477 static int unix_stream_read_actor(struct sk_buff *skb,
2478                                   int skip, int chunk,
2479                                   struct unix_stream_read_state *state)
2480 {
2481         int ret;
2482
2483         ret = skb_copy_datagram_msg(skb, UNIXCB(skb).consumed + skip,
2484                                     state->msg, chunk);
2485         return ret ?: chunk;
2486 }
2487
2488 static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
2489                                size_t size, int flags)
2490 {
2491         struct unix_stream_read_state state = {
2492                 .recv_actor = unix_stream_read_actor,
2493                 .socket = sock,
2494                 .msg = msg,
2495                 .size = size,
2496                 .flags = flags
2497         };
2498
2499         return unix_stream_read_generic(&state, true);
2500 }
2501
2502 static int unix_stream_splice_actor(struct sk_buff *skb,
2503                                     int skip, int chunk,
2504                                     struct unix_stream_read_state *state)
2505 {
2506         return skb_splice_bits(skb, state->socket->sk,
2507                                UNIXCB(skb).consumed + skip,
2508                                state->pipe, chunk, state->splice_flags);
2509 }
2510
2511 static ssize_t unix_stream_splice_read(struct socket *sock,  loff_t *ppos,
2512                                        struct pipe_inode_info *pipe,
2513                                        size_t size, unsigned int flags)
2514 {
2515         struct unix_stream_read_state state = {
2516                 .recv_actor = unix_stream_splice_actor,
2517                 .socket = sock,
2518                 .pipe = pipe,
2519                 .size = size,
2520                 .splice_flags = flags,
2521         };
2522
2523         if (unlikely(*ppos))
2524                 return -ESPIPE;
2525
2526         if (sock->file->f_flags & O_NONBLOCK ||
2527             flags & SPLICE_F_NONBLOCK)
2528                 state.flags = MSG_DONTWAIT;
2529
2530         return unix_stream_read_generic(&state, false);
2531 }
2532
2533 static int unix_shutdown(struct socket *sock, int mode)
2534 {
2535         struct sock *sk = sock->sk;
2536         struct sock *other;
2537
2538         if (mode < SHUT_RD || mode > SHUT_RDWR)
2539                 return -EINVAL;
2540         /* This maps:
2541          * SHUT_RD   (0) -> RCV_SHUTDOWN  (1)
2542          * SHUT_WR   (1) -> SEND_SHUTDOWN (2)
2543          * SHUT_RDWR (2) -> SHUTDOWN_MASK (3)
2544          */
2545         ++mode;
2546
2547         unix_state_lock(sk);
2548         WRITE_ONCE(sk->sk_shutdown, sk->sk_shutdown | mode);
2549         other = unix_peer(sk);
2550         if (other)
2551                 sock_hold(other);
2552         unix_state_unlock(sk);
2553         sk->sk_state_change(sk);
2554
2555         if (other &&
2556                 (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET)) {
2557
2558                 int peer_mode = 0;
2559
2560                 if (mode&RCV_SHUTDOWN)
2561                         peer_mode |= SEND_SHUTDOWN;
2562                 if (mode&SEND_SHUTDOWN)
2563                         peer_mode |= RCV_SHUTDOWN;
2564                 unix_state_lock(other);
2565                 WRITE_ONCE(other->sk_shutdown, other->sk_shutdown | peer_mode);
2566                 unix_state_unlock(other);
2567                 other->sk_state_change(other);
2568                 if (peer_mode == SHUTDOWN_MASK)
2569                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
2570                 else if (peer_mode & RCV_SHUTDOWN)
2571                         sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
2572         }
2573         if (other)
2574                 sock_put(other);
2575
2576         return 0;
2577 }
2578
2579 long unix_inq_len(struct sock *sk)
2580 {
2581         struct sk_buff *skb;
2582         long amount = 0;
2583
2584         if (sk->sk_state == TCP_LISTEN)
2585                 return -EINVAL;
2586
2587         spin_lock(&sk->sk_receive_queue.lock);
2588         if (sk->sk_type == SOCK_STREAM ||
2589             sk->sk_type == SOCK_SEQPACKET) {
2590                 skb_queue_walk(&sk->sk_receive_queue, skb)
2591                         amount += unix_skb_len(skb);
2592         } else {
2593                 skb = skb_peek(&sk->sk_receive_queue);
2594                 if (skb)
2595                         amount = skb->len;
2596         }
2597         spin_unlock(&sk->sk_receive_queue.lock);
2598
2599         return amount;
2600 }
2601 EXPORT_SYMBOL_GPL(unix_inq_len);
2602
2603 long unix_outq_len(struct sock *sk)
2604 {
2605         return sk_wmem_alloc_get(sk);
2606 }
2607 EXPORT_SYMBOL_GPL(unix_outq_len);
2608
2609 static int unix_open_file(struct sock *sk)
2610 {
2611         struct path path;
2612         struct file *f;
2613         int fd;
2614
2615         if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2616                 return -EPERM;
2617
2618         if (!smp_load_acquire(&unix_sk(sk)->addr))
2619                 return -ENOENT;
2620
2621         path = unix_sk(sk)->path;
2622         if (!path.dentry)
2623                 return -ENOENT;
2624
2625         path_get(&path);
2626
2627         fd = get_unused_fd_flags(O_CLOEXEC);
2628         if (fd < 0)
2629                 goto out;
2630
2631         f = dentry_open(&path, O_PATH, current_cred());
2632         if (IS_ERR(f)) {
2633                 put_unused_fd(fd);
2634                 fd = PTR_ERR(f);
2635                 goto out;
2636         }
2637
2638         fd_install(fd, f);
2639 out:
2640         path_put(&path);
2641
2642         return fd;
2643 }
2644
2645 static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2646 {
2647         struct sock *sk = sock->sk;
2648         long amount = 0;
2649         int err;
2650
2651         switch (cmd) {
2652         case SIOCOUTQ:
2653                 amount = unix_outq_len(sk);
2654                 err = put_user(amount, (int __user *)arg);
2655                 break;
2656         case SIOCINQ:
2657                 amount = unix_inq_len(sk);
2658                 if (amount < 0)
2659                         err = amount;
2660                 else
2661                         err = put_user(amount, (int __user *)arg);
2662                 break;
2663         case SIOCUNIXFILE:
2664                 err = unix_open_file(sk);
2665                 break;
2666         default:
2667                 err = -ENOIOCTLCMD;
2668                 break;
2669         }
2670         return err;
2671 }
2672
2673 #ifdef CONFIG_COMPAT
2674 static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2675 {
2676         return unix_ioctl(sock, cmd, (unsigned long)compat_ptr(arg));
2677 }
2678 #endif
2679
2680 static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wait)
2681 {
2682         struct sock *sk = sock->sk;
2683         __poll_t mask;
2684         u8 shutdown;
2685
2686         sock_poll_wait(file, sock, wait);
2687         mask = 0;
2688         shutdown = READ_ONCE(sk->sk_shutdown);
2689
2690         /* exceptional events? */
2691         if (sk->sk_err)
2692                 mask |= EPOLLERR;
2693         if (shutdown == SHUTDOWN_MASK)
2694                 mask |= EPOLLHUP;
2695         if (shutdown & RCV_SHUTDOWN)
2696                 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
2697
2698         /* readable? */
2699         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2700                 mask |= EPOLLIN | EPOLLRDNORM;
2701
2702         /* Connection-based need to check for termination and startup */
2703         if ((sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) &&
2704             sk->sk_state == TCP_CLOSE)
2705                 mask |= EPOLLHUP;
2706
2707         /*
2708          * we set writable also when the other side has shut down the
2709          * connection. This prevents stuck sockets.
2710          */
2711         if (unix_writable(sk))
2712                 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
2713
2714         return mask;
2715 }
2716
2717 static __poll_t unix_dgram_poll(struct file *file, struct socket *sock,
2718                                     poll_table *wait)
2719 {
2720         struct sock *sk = sock->sk, *other;
2721         unsigned int writable;
2722         __poll_t mask;
2723         u8 shutdown;
2724
2725         sock_poll_wait(file, sock, wait);
2726         mask = 0;
2727         shutdown = READ_ONCE(sk->sk_shutdown);
2728
2729         /* exceptional events? */
2730         if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
2731                 mask |= EPOLLERR |
2732                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
2733
2734         if (shutdown & RCV_SHUTDOWN)
2735                 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
2736         if (shutdown == SHUTDOWN_MASK)
2737                 mask |= EPOLLHUP;
2738
2739         /* readable? */
2740         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
2741                 mask |= EPOLLIN | EPOLLRDNORM;
2742
2743         /* Connection-based need to check for termination and startup */
2744         if (sk->sk_type == SOCK_SEQPACKET) {
2745                 if (sk->sk_state == TCP_CLOSE)
2746                         mask |= EPOLLHUP;
2747                 /* connection hasn't started yet? */
2748                 if (sk->sk_state == TCP_SYN_SENT)
2749                         return mask;
2750         }
2751
2752         /* No write status requested, avoid expensive OUT tests. */
2753         if (!(poll_requested_events(wait) & (EPOLLWRBAND|EPOLLWRNORM|EPOLLOUT)))
2754                 return mask;
2755
2756         writable = unix_writable(sk);
2757         if (writable) {
2758                 unix_state_lock(sk);
2759
2760                 other = unix_peer(sk);
2761                 if (other && unix_peer(other) != sk &&
2762                     unix_recvq_full_lockless(other) &&
2763                     unix_dgram_peer_wake_me(sk, other))
2764                         writable = 0;
2765
2766                 unix_state_unlock(sk);
2767         }
2768
2769         if (writable)
2770                 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
2771         else
2772                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2773
2774         return mask;
2775 }
2776
2777 #ifdef CONFIG_PROC_FS
2778
2779 #define BUCKET_SPACE (BITS_PER_LONG - (UNIX_HASH_BITS + 1) - 1)
2780
2781 #define get_bucket(x) ((x) >> BUCKET_SPACE)
2782 #define get_offset(x) ((x) & ((1L << BUCKET_SPACE) - 1))
2783 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
2784
2785 static struct sock *unix_from_bucket(struct seq_file *seq, loff_t *pos)
2786 {
2787         unsigned long offset = get_offset(*pos);
2788         unsigned long bucket = get_bucket(*pos);
2789         struct sock *sk;
2790         unsigned long count = 0;
2791
2792         for (sk = sk_head(&unix_socket_table[bucket]); sk; sk = sk_next(sk)) {
2793                 if (sock_net(sk) != seq_file_net(seq))
2794                         continue;
2795                 if (++count == offset)
2796                         break;
2797         }
2798
2799         return sk;
2800 }
2801
2802 static struct sock *unix_next_socket(struct seq_file *seq,
2803                                      struct sock *sk,
2804                                      loff_t *pos)
2805 {
2806         unsigned long bucket;
2807
2808         while (sk > (struct sock *)SEQ_START_TOKEN) {
2809                 sk = sk_next(sk);
2810                 if (!sk)
2811                         goto next_bucket;
2812                 if (sock_net(sk) == seq_file_net(seq))
2813                         return sk;
2814         }
2815
2816         do {
2817                 sk = unix_from_bucket(seq, pos);
2818                 if (sk)
2819                         return sk;
2820
2821 next_bucket:
2822                 bucket = get_bucket(*pos) + 1;
2823                 *pos = set_bucket_offset(bucket, 1);
2824         } while (bucket < ARRAY_SIZE(unix_socket_table));
2825
2826         return NULL;
2827 }
2828
2829 static void *unix_seq_start(struct seq_file *seq, loff_t *pos)
2830         __acquires(unix_table_lock)
2831 {
2832         spin_lock(&unix_table_lock);
2833
2834         if (!*pos)
2835                 return SEQ_START_TOKEN;
2836
2837         if (get_bucket(*pos) >= ARRAY_SIZE(unix_socket_table))
2838                 return NULL;
2839
2840         return unix_next_socket(seq, NULL, pos);
2841 }
2842
2843 static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2844 {
2845         ++*pos;
2846         return unix_next_socket(seq, v, pos);
2847 }
2848
2849 static void unix_seq_stop(struct seq_file *seq, void *v)
2850         __releases(unix_table_lock)
2851 {
2852         spin_unlock(&unix_table_lock);
2853 }
2854
2855 static int unix_seq_show(struct seq_file *seq, void *v)
2856 {
2857
2858         if (v == SEQ_START_TOKEN)
2859                 seq_puts(seq, "Num       RefCount Protocol Flags    Type St "
2860                          "Inode Path\n");
2861         else {
2862                 struct sock *s = v;
2863                 struct unix_sock *u = unix_sk(s);
2864                 unix_state_lock(s);
2865
2866                 seq_printf(seq, "%pK: %08X %08X %08X %04X %02X %5lu",
2867                         s,
2868                         refcount_read(&s->sk_refcnt),
2869                         0,
2870                         s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
2871                         s->sk_type,
2872                         s->sk_socket ?
2873                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
2874                         (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
2875                         sock_i_ino(s));
2876
2877                 if (u->addr) {  // under unix_table_lock here
2878                         int i, len;
2879                         seq_putc(seq, ' ');
2880
2881                         i = 0;
2882                         len = u->addr->len - sizeof(short);
2883                         if (!UNIX_ABSTRACT(s))
2884                                 len--;
2885                         else {
2886                                 seq_putc(seq, '@');
2887                                 i++;
2888                         }
2889                         for ( ; i < len; i++)
2890                                 seq_putc(seq, u->addr->name->sun_path[i] ?:
2891                                          '@');
2892                 }
2893                 unix_state_unlock(s);
2894                 seq_putc(seq, '\n');
2895         }
2896
2897         return 0;
2898 }
2899
2900 static const struct seq_operations unix_seq_ops = {
2901         .start  = unix_seq_start,
2902         .next   = unix_seq_next,
2903         .stop   = unix_seq_stop,
2904         .show   = unix_seq_show,
2905 };
2906 #endif
2907
2908 static const struct net_proto_family unix_family_ops = {
2909         .family = PF_UNIX,
2910         .create = unix_create,
2911         .owner  = THIS_MODULE,
2912 };
2913
2914
2915 static int __net_init unix_net_init(struct net *net)
2916 {
2917         int error = -ENOMEM;
2918
2919         net->unx.sysctl_max_dgram_qlen = 10;
2920         if (unix_sysctl_register(net))
2921                 goto out;
2922
2923 #ifdef CONFIG_PROC_FS
2924         if (!proc_create_net("unix", 0, net->proc_net, &unix_seq_ops,
2925                         sizeof(struct seq_net_private))) {
2926                 unix_sysctl_unregister(net);
2927                 goto out;
2928         }
2929 #endif
2930         error = 0;
2931 out:
2932         return error;
2933 }
2934
2935 static void __net_exit unix_net_exit(struct net *net)
2936 {
2937         unix_sysctl_unregister(net);
2938         remove_proc_entry("unix", net->proc_net);
2939 }
2940
2941 static struct pernet_operations unix_net_ops = {
2942         .init = unix_net_init,
2943         .exit = unix_net_exit,
2944 };
2945
2946 static int __init af_unix_init(void)
2947 {
2948         int rc = -1;
2949
2950         BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
2951
2952         rc = proto_register(&unix_proto, 1);
2953         if (rc != 0) {
2954                 pr_crit("%s: Cannot create unix_sock SLAB cache!\n", __func__);
2955                 goto out;
2956         }
2957
2958         sock_register(&unix_family_ops);
2959         register_pernet_subsys(&unix_net_ops);
2960 out:
2961         return rc;
2962 }
2963
2964 static void __exit af_unix_exit(void)
2965 {
2966         sock_unregister(PF_UNIX);
2967         proto_unregister(&unix_proto);
2968         unregister_pernet_subsys(&unix_net_ops);
2969 }
2970
2971 /* Earlier than device_initcall() so that other drivers invoking
2972    request_module() don't end up in a loop when modprobe tries
2973    to use a UNIX socket. But later than subsys_initcall() because
2974    we depend on stuff initialised there */
2975 fs_initcall(af_unix_init);
2976 module_exit(af_unix_exit);
2977
2978 MODULE_LICENSE("GPL");
2979 MODULE_ALIAS_NETPROTO(PF_UNIX);