net/core/datagram.c

   1 /*
   2  *      SUCS NET3:
   3  *
   4  *      Generic datagram handling routines. These are generic for all
   5  *      protocols. Possibly a generic IP version on top of these would
   6  *      make sense. Not tonight however 8-).
   7  *      This is used because UDP, RAW, PACKET, DDP, IPX, AX.25 and
   8  *      NetROM layer all have identical poll code and mostly
   9  *      identical recvmsg() code. So we share it here. The poll was
  10  *      shared before but buried in udp.c so I moved it.
  11  *
  12  *      Authors:        Alan Cox <alan@lxorguk.ukuu.org.uk>. (datagram_poll() from old
  13  *                                                   udp.c code)
  14  *
  15  *      Fixes:
  16  *              Alan Cox        :       NULL return from skb_peek_copy()
  17  *                                      understood
  18  *              Alan Cox        :       Rewrote skb_read_datagram to avoid the
  19  *                                      skb_peek_copy stuff.
  20  *              Alan Cox        :       Added support for SOCK_SEQPACKET.
  21  *                                      IPX can no longer use the SO_TYPE hack
  22  *                                      but AX.25 now works right, and SPX is
  23  *                                      feasible.
  24  *              Alan Cox        :       Fixed write poll of non IP protocol
  25  *                                      crash.
  26  *              Florian  La Roche:      Changed for my new skbuff handling.
  27  *              Darryl Miles    :       Fixed non-blocking SOCK_SEQPACKET.
  28  *              Linus Torvalds  :       BSD semantic fixes.
  29  *              Alan Cox        :       Datagram iovec handling
  30  *              Darryl Miles    :       Fixed non-blocking SOCK_STREAM.
  31  *              Alan Cox        :       POSIXisms
  32  *              Pete Wyckoff    :       Unconnected accept() fix.
  33  *
  34  */
  35
  36 #include <linux/module.h>
  37 #include <linux/types.h>
  38 #include <linux/kernel.h>
  39 #include <asm/uaccess.h>
  40 #include <linux/mm.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/errno.h>
  43 #include <linux/sched.h>
  44 #include <linux/inet.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/rtnetlink.h>
  47 #include <linux/poll.h>
  48 #include <linux/highmem.h>
  49 #include <linux/spinlock.h>
  50 #include <linux/slab.h>
  51
  52 #include <net/protocol.h>
  53 #include <linux/skbuff.h>
  54
  55 #include <net/checksum.h>
  56 #include <net/sock.h>
  57 #include <net/tcp_states.h>
  58 #include <trace/events/skb.h>
  59
  60 /*
  61  *      Is a socket 'connection oriented' ?
  62  */
  63 static inline int connection_based(struct sock *sk)
  64 {
  65         return sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM;
  66 }
  67
  68 static int receiver_wake_function(wait_queue_t *wait, unsigned int mode, int sync,
  69                                   void *key)
  70 {
  71         unsigned long bits = (unsigned long)key;
  72
  73         /*
  74          * Avoid a wakeup if event not interesting for us
  75          */
  76         if (bits && !(bits & (POLLIN | POLLERR)))
  77                 return 0;
  78         return autoremove_wake_function(wait, mode, sync, key);
  79 }
  80 /*
  81  * Wait for the last received packet to be different from skb
  82  */
  83 static int wait_for_more_packets(struct sock *sk, int *err, long *timeo_p,
  84                                  const struct sk_buff *skb)
  85 {
  86         int error;
  87         DEFINE_WAIT_FUNC(wait, receiver_wake_function);
  88
  89         prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  90
  91         /* Socket errors? */
  92         error = sock_error(sk);
  93         if (error)
  94                 goto out_err;
  95
  96         if (sk->sk_receive_queue.prev != skb)
  97                 goto out;
  98
  99         /* Socket shut down? */
 100         if (sk->sk_shutdown & RCV_SHUTDOWN)
 101                 goto out_noerr;
 102
 103         /* Sequenced packets can come disconnected.
 104          * If so we report the problem
 105          */
 106         error = -ENOTCONN;
 107         if (connection_based(sk) &&
 108             !(sk->sk_state == TCP_ESTABLISHED || sk->sk_state == TCP_LISTEN))
 109                 goto out_err;
 110
 111         /* handle signals */
 112         if (signal_pending(current))
 113                 goto interrupted;
 114
 115         error = 0;
 116         *timeo_p = schedule_timeout(*timeo_p);
 117 out:
 118         finish_wait(sk_sleep(sk), &wait);
 119         return error;
 120 interrupted:
 121         error = sock_intr_errno(*timeo_p);
 122 out_err:
 123         *err = error;
 124         goto out;
 125 out_noerr:
 126         *err = 0;
 127         error = 1;
 128         goto out;
 129 }
 130
 131 static int skb_set_peeked(struct sk_buff *skb)
 132 {
 133         struct sk_buff *nskb;
 134
 135         if (skb->peeked)
 136                 return 0;
 137
 138         /* We have to unshare an skb before modifying it. */
 139         if (!skb_shared(skb))
 140                 goto done;
 141
 142         nskb = skb_clone(skb, GFP_ATOMIC);
 143         if (!nskb)
 144                 return -ENOMEM;
 145
 146         skb->prev->next = nskb;
 147         skb->next->prev = nskb;
 148         nskb->prev = skb->prev;
 149         nskb->next = skb->next;
 150
 151         consume_skb(skb);
 152         skb = nskb;
 153
 154 done:
 155         skb->peeked = 1;
 156
 157         return 0;
 158 }
 159
 160 /**
 161  *      __skb_recv_datagram - Receive a datagram skbuff
 162  *      @sk: socket
 163  *      @flags: MSG_ flags
 164  *      @peeked: returns non-zero if this packet has been seen before
 165  *      @off: an offset in bytes to peek skb from. Returns an offset
 166  *            within an skb where data actually starts
 167  *      @err: error code returned
 168  *
 169  *      Get a datagram skbuff, understands the peeking, nonblocking wakeups
 170  *      and possible races. This replaces identical code in packet, raw and
 171  *      udp, as well as the IPX AX.25 and Appletalk. It also finally fixes
 172  *      the long standing peek and read race for datagram sockets. If you
 173  *      alter this routine remember it must be re-entrant.
 174  *
 175  *      This function will lock the socket if a skb is returned, so the caller
 176  *      needs to unlock the socket in that case (usually by calling
 177  *      skb_free_datagram)
 178  *
 179  *      * It does not lock socket since today. This function is
 180  *      * free of race conditions. This measure should/can improve
 181  *      * significantly datagram socket latencies at high loads,
 182  *      * when data copying to user space takes lots of time.
 183  *      * (BTW I've just killed the last cli() in IP/IPv6/core/netlink/packet
 184  *      *  8) Great win.)
 185  *      *                                           --ANK (980729)
 186  *
 187  *      The order of the tests when we find no data waiting are specified
 188  *      quite explicitly by POSIX 1003.1g, don't change them without having
 189  *      the standard around please.
 190  */
 191 struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned int flags,
 192                                     int *peeked, int *off, int *err)
 193 {
 194         struct sk_buff_head *queue = &sk->sk_receive_queue;
 195         struct sk_buff *skb, *last;
 196         unsigned long cpu_flags;
 197         long timeo;
 198         /*
 199          * Caller is allowed not to check sk->sk_err before skb_recv_datagram()
 200          */
 201         int error = sock_error(sk);
 202
 203         if (error)
 204                 goto no_packet;
 205
 206         timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 207
 208         do {
 209                 /* Again only user level code calls this function, so nothing
 210                  * interrupt level will suddenly eat the receive_queue.
 211                  *
 212                  * Look at current nfs client by the way...
 213                  * However, this function was correct in any case. 8)
 214                  */
 215                 int _off = *off;
 216
 217                 last = (struct sk_buff *)queue;
 218                 spin_lock_irqsave(&queue->lock, cpu_flags);
 219                 skb_queue_walk(queue, skb) {
 220                         last = skb;
 221                         *peeked = skb->peeked;
 222                         if (flags & MSG_PEEK) {
 223                                 if (_off >= skb->len && (skb->len || _off ||
 224                                                          skb->peeked)) {
 225                                         _off -= skb->len;
 226                                         continue;
 227                                 }
 228
 229                                 error = skb_set_peeked(skb);
 230                                 if (error)
 231                                         goto unlock_err;
 232
 233                                 atomic_inc(&skb->users);
 234                         } else
 235                                 __skb_unlink(skb, queue);
 236
 237                         spin_unlock_irqrestore(&queue->lock, cpu_flags);
 238                         *off = _off;
 239                         return skb;
 240                 }
 241                 spin_unlock_irqrestore(&queue->lock, cpu_flags);
 242
 243                 /* User doesn't want to wait */
 244                 error = -EAGAIN;
 245                 if (!timeo)
 246                         goto no_packet;
 247
 248         } while (!wait_for_more_packets(sk, err, &timeo, last));
 249
 250         return NULL;
 251
 252 unlock_err:
 253         spin_unlock_irqrestore(&queue->lock, cpu_flags);
 254 no_packet:
 255         *err = error;
 256         return NULL;
 257 }
 258 EXPORT_SYMBOL(__skb_recv_datagram);
 259
 260 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned int flags,
 261                                   int noblock, int *err)
 262 {
 263         int peeked, off = 0;
 264
 265         return __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
 266                                    &peeked, &off, err);
 267 }
 268 EXPORT_SYMBOL(skb_recv_datagram);
 269
 270 void skb_free_datagram(struct sock *sk, struct sk_buff *skb)
 271 {
 272         consume_skb(skb);
 273         sk_mem_reclaim_partial(sk);
 274 }
 275 EXPORT_SYMBOL(skb_free_datagram);
 276
 277 void skb_free_datagram_locked(struct sock *sk, struct sk_buff *skb)
 278 {
 279         bool slow;
 280
 281         if (likely(atomic_read(&skb->users) == 1))
 282                 smp_rmb();
 283         else if (likely(!atomic_dec_and_test(&skb->users)))
 284                 return;
 285
 286         slow = lock_sock_fast(sk);
 287         skb_orphan(skb);
 288         sk_mem_reclaim_partial(sk);
 289         unlock_sock_fast(sk, slow);
 290
 291         /* skb is now orphaned, can be freed outside of locked section */
 292         __kfree_skb(skb);
 293 }
 294 EXPORT_SYMBOL(skb_free_datagram_locked);
 295
 296 /**
 297  *      skb_kill_datagram - Free a datagram skbuff forcibly
 298  *      @sk: socket
 299  *      @skb: datagram skbuff
 300  *      @flags: MSG_ flags
 301  *
 302  *      This function frees a datagram skbuff that was received by
 303  *      skb_recv_datagram.  The flags argument must match the one
 304  *      used for skb_recv_datagram.
 305  *
 306  *      If the MSG_PEEK flag is set, and the packet is still on the
 307  *      receive queue of the socket, it will be taken off the queue
 308  *      before it is freed.
 309  *
 310  *      This function currently only disables BH when acquiring the
 311  *      sk_receive_queue lock.  Therefore it must not be used in a
 312  *      context where that lock is acquired in an IRQ context.
 313  *
 314  *      It returns 0 if the packet was removed by us.
 315  */
 316
 317 int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags)
 318 {
 319         int err = 0;
 320
 321         if (flags & MSG_PEEK) {
 322                 err = -ENOENT;
 323                 spin_lock_bh(&sk->sk_receive_queue.lock);
 324                 if (skb == skb_peek(&sk->sk_receive_queue)) {
 325                         __skb_unlink(skb, &sk->sk_receive_queue);
 326                         atomic_dec(&skb->users);
 327                         err = 0;
 328                 }
 329                 spin_unlock_bh(&sk->sk_receive_queue.lock);
 330         }
 331
 332         kfree_skb(skb);
 333         atomic_inc(&sk->sk_drops);
 334         sk_mem_reclaim_partial(sk);
 335
 336         return err;
 337 }
 338 EXPORT_SYMBOL(skb_kill_datagram);
 339
 340 /**
 341  *      skb_copy_datagram_iovec - Copy a datagram to an iovec.
 342  *      @skb: buffer to copy
 343  *      @offset: offset in the buffer to start copying from
 344  *      @to: io vector to copy to
 345  *      @len: amount of data to copy from buffer to iovec
 346  *
 347  *      Note: the iovec is modified during the copy.
 348  */
 349 int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,
 350                             struct iovec *to, int len)
 351 {
 352         int start = skb_headlen(skb);
 353         int i, copy = start - offset;
 354         struct sk_buff *frag_iter;
 355
 356         trace_skb_copy_datagram_iovec(skb, len);
 357
 358         /* Copy header. */
 359         if (copy > 0) {
 360                 if (copy > len)
 361                         copy = len;
 362                 if (memcpy_toiovec(to, skb->data + offset, copy))
 363                         goto fault;
 364                 if ((len -= copy) == 0)
 365                         return 0;
 366                 offset += copy;
 367         }
 368
 369         /* Copy paged appendix. Hmm... why does this look so complicated? */
 370         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 371                 int end;
 372                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 373
 374                 WARN_ON(start > offset + len);
 375
 376                 end = start + skb_frag_size(frag);
 377                 if ((copy = end - offset) > 0) {
 378                         int err;
 379                         u8  *vaddr;
 380                         struct page *page = skb_frag_page(frag);
 381
 382                         if (copy > len)
 383                                 copy = len;
 384                         vaddr = kmap(page);
 385                         err = memcpy_toiovec(to, vaddr + frag->page_offset +
 386                                              offset - start, copy);
 387                         kunmap(page);
 388                         if (err)
 389                                 goto fault;
 390                         if (!(len -= copy))
 391                                 return 0;
 392                         offset += copy;
 393                 }
 394                 start = end;
 395         }
 396
 397         skb_walk_frags(skb, frag_iter) {
 398                 int end;
 399
 400                 WARN_ON(start > offset + len);
 401
 402                 end = start + frag_iter->len;
 403                 if ((copy = end - offset) > 0) {
 404                         if (copy > len)
 405                                 copy = len;
 406                         if (skb_copy_datagram_iovec(frag_iter,
 407                                                     offset - start,
 408                                                     to, copy))
 409                                 goto fault;
 410                         if ((len -= copy) == 0)
 411                                 return 0;
 412                         offset += copy;
 413                 }
 414                 start = end;
 415         }
 416         if (!len)
 417                 return 0;
 418
 419 fault:
 420         return -EFAULT;
 421 }
 422 EXPORT_SYMBOL(skb_copy_datagram_iovec);
 423
 424 /**
 425  *      skb_copy_datagram_const_iovec - Copy a datagram to an iovec.
 426  *      @skb: buffer to copy
 427  *      @offset: offset in the buffer to start copying from
 428  *      @to: io vector to copy to
 429  *      @to_offset: offset in the io vector to start copying to
 430  *      @len: amount of data to copy from buffer to iovec
 431  *
 432  *      Returns 0 or -EFAULT.
 433  *      Note: the iovec is not modified during the copy.
 434  */
 435 int skb_copy_datagram_const_iovec(const struct sk_buff *skb, int offset,
 436                                   const struct iovec *to, int to_offset,
 437                                   int len)
 438 {
 439         int start = skb_headlen(skb);
 440         int i, copy = start - offset;
 441         struct sk_buff *frag_iter;
 442
 443         /* Copy header. */
 444         if (copy > 0) {
 445                 if (copy > len)
 446                         copy = len;
 447                 if (memcpy_toiovecend(to, skb->data + offset, to_offset, copy))
 448                         goto fault;
 449                 if ((len -= copy) == 0)
 450                         return 0;
 451                 offset += copy;
 452                 to_offset += copy;
 453         }
 454
 455         /* Copy paged appendix. Hmm... why does this look so complicated? */
 456         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 457                 int end;
 458                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 459
 460                 WARN_ON(start > offset + len);
 461
 462                 end = start + skb_frag_size(frag);
 463                 if ((copy = end - offset) > 0) {
 464                         int err;
 465                         u8  *vaddr;
 466                         struct page *page = skb_frag_page(frag);
 467
 468                         if (copy > len)
 469                                 copy = len;
 470                         vaddr = kmap(page);
 471                         err = memcpy_toiovecend(to, vaddr + frag->page_offset +
 472                                                 offset - start, to_offset, copy);
 473                         kunmap(page);
 474                         if (err)
 475                                 goto fault;
 476                         if (!(len -= copy))
 477                                 return 0;
 478                         offset += copy;
 479                         to_offset += copy;
 480                 }
 481                 start = end;
 482         }
 483
 484         skb_walk_frags(skb, frag_iter) {
 485                 int end;
 486
 487                 WARN_ON(start > offset + len);
 488
 489                 end = start + frag_iter->len;
 490                 if ((copy = end - offset) > 0) {
 491                         if (copy > len)
 492                                 copy = len;
 493                         if (skb_copy_datagram_const_iovec(frag_iter,
 494                                                           offset - start,
 495                                                           to, to_offset,
 496                                                           copy))
 497                                 goto fault;
 498                         if ((len -= copy) == 0)
 499                                 return 0;
 500                         offset += copy;
 501                         to_offset += copy;
 502                 }
 503                 start = end;
 504         }
 505         if (!len)
 506                 return 0;
 507
 508 fault:
 509         return -EFAULT;
 510 }
 511 EXPORT_SYMBOL(skb_copy_datagram_const_iovec);
 512
 513 /**
 514  *      skb_copy_datagram_from_iovec - Copy a datagram from an iovec.
 515  *      @skb: buffer to copy
 516  *      @offset: offset in the buffer to start copying to
 517  *      @from: io vector to copy to
 518  *      @from_offset: offset in the io vector to start copying from
 519  *      @len: amount of data to copy to buffer from iovec
 520  *
 521  *      Returns 0 or -EFAULT.
 522  *      Note: the iovec is not modified during the copy.
 523  */
 524 int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
 525                                  const struct iovec *from, int from_offset,
 526                                  int len)
 527 {
 528         int start = skb_headlen(skb);
 529         int i, copy = start - offset;
 530         struct sk_buff *frag_iter;
 531
 532         /* Copy header. */
 533         if (copy > 0) {
 534                 if (copy > len)
 535                         copy = len;
 536                 if (memcpy_fromiovecend(skb->data + offset, from, from_offset,
 537                                         copy))
 538                         goto fault;
 539                 if ((len -= copy) == 0)
 540                         return 0;
 541                 offset += copy;
 542                 from_offset += copy;
 543         }
 544
 545         /* Copy paged appendix. Hmm... why does this look so complicated? */
 546         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 547                 int end;
 548                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 549
 550                 WARN_ON(start > offset + len);
 551
 552                 end = start + skb_frag_size(frag);
 553                 if ((copy = end - offset) > 0) {
 554                         int err;
 555                         u8  *vaddr;
 556                         struct page *page = skb_frag_page(frag);
 557
 558                         if (copy > len)
 559                                 copy = len;
 560                         vaddr = kmap(page);
 561                         err = memcpy_fromiovecend(vaddr + frag->page_offset +
 562                                                   offset - start,
 563                                                   from, from_offset, copy);
 564                         kunmap(page);
 565                         if (err)
 566                                 goto fault;
 567
 568                         if (!(len -= copy))
 569                                 return 0;
 570                         offset += copy;
 571                         from_offset += copy;
 572                 }
 573                 start = end;
 574         }
 575
 576         skb_walk_frags(skb, frag_iter) {
 577                 int end;
 578
 579                 WARN_ON(start > offset + len);
 580
 581                 end = start + frag_iter->len;
 582                 if ((copy = end - offset) > 0) {
 583                         if (copy > len)
 584                                 copy = len;
 585                         if (skb_copy_datagram_from_iovec(frag_iter,
 586                                                          offset - start,
 587                                                          from,
 588                                                          from_offset,
 589                                                          copy))
 590                                 goto fault;
 591                         if ((len -= copy) == 0)
 592                                 return 0;
 593                         offset += copy;
 594                         from_offset += copy;
 595                 }
 596                 start = end;
 597         }
 598         if (!len)
 599                 return 0;
 600
 601 fault:
 602         return -EFAULT;
 603 }
 604 EXPORT_SYMBOL(skb_copy_datagram_from_iovec);
 605
 606 static int skb_copy_and_csum_datagram(const struct sk_buff *skb, int offset,
 607                                       u8 __user *to, int len,
 608                                       __wsum *csump)
 609 {
 610         int start = skb_headlen(skb);
 611         int i, copy = start - offset;
 612         struct sk_buff *frag_iter;
 613         int pos = 0;
 614
 615         /* Copy header. */
 616         if (copy > 0) {
 617                 int err = 0;
 618                 if (copy > len)
 619                         copy = len;
 620                 *csump = csum_and_copy_to_user(skb->data + offset, to, copy,
 621                                                *csump, &err);
 622                 if (err)
 623                         goto fault;
 624                 if ((len -= copy) == 0)
 625                         return 0;
 626                 offset += copy;
 627                 to += copy;
 628                 pos = copy;
 629         }
 630
 631         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 632                 int end;
 633                 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 634
 635                 WARN_ON(start > offset + len);
 636
 637                 end = start + skb_frag_size(frag);
 638                 if ((copy = end - offset) > 0) {
 639                         __wsum csum2;
 640                         int err = 0;
 641                         u8  *vaddr;
 642                         struct page *page = skb_frag_page(frag);
 643
 644                         if (copy > len)
 645                                 copy = len;
 646                         vaddr = kmap(page);
 647                         csum2 = csum_and_copy_to_user(vaddr +
 648                                                         frag->page_offset +
 649                                                         offset - start,
 650                                                       to, copy, 0, &err);
 651                         kunmap(page);
 652                         if (err)
 653                                 goto fault;
 654                         *csump = csum_block_add(*csump, csum2, pos);
 655                         if (!(len -= copy))
 656                                 return 0;
 657                         offset += copy;
 658                         to += copy;
 659                         pos += copy;
 660                 }
 661                 start = end;
 662         }
 663
 664         skb_walk_frags(skb, frag_iter) {
 665                 int end;
 666
 667                 WARN_ON(start > offset + len);
 668
 669                 end = start + frag_iter->len;
 670                 if ((copy = end - offset) > 0) {
 671                         __wsum csum2 = 0;
 672                         if (copy > len)
 673                                 copy = len;
 674                         if (skb_copy_and_csum_datagram(frag_iter,
 675                                                        offset - start,
 676                                                        to, copy,
 677                                                        &csum2))
 678                                 goto fault;
 679                         *csump = csum_block_add(*csump, csum2, pos);
 680                         if ((len -= copy) == 0)
 681                                 return 0;
 682                         offset += copy;
 683                         to += copy;
 684                         pos += copy;
 685                 }
 686                 start = end;
 687         }
 688         if (!len)
 689                 return 0;
 690
 691 fault:
 692         return -EFAULT;
 693 }
 694
 695 __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len)
 696 {
 697         __sum16 sum;
 698
 699         sum = csum_fold(skb_checksum(skb, 0, len, skb->csum));
 700         if (likely(!sum)) {
 701                 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE))
 702                         netdev_rx_csum_fault(skb->dev);
 703                 if (!skb_shared(skb))
 704                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 705         }
 706         return sum;
 707 }
 708 EXPORT_SYMBOL(__skb_checksum_complete_head);
 709
 710 __sum16 __skb_checksum_complete(struct sk_buff *skb)
 711 {
 712         return __skb_checksum_complete_head(skb, skb->len);
 713 }
 714 EXPORT_SYMBOL(__skb_checksum_complete);
 715
 716 /**
 717  *      skb_copy_and_csum_datagram_iovec - Copy and checkum skb to user iovec.
 718  *      @skb: skbuff
 719  *      @hlen: hardware length
 720  *      @iov: io vector
 721  *
 722  *      Caller _must_ check that skb will fit to this iovec.
 723  *
 724  *      Returns: 0       - success.
 725  *               -EINVAL - checksum failure.
 726  *               -EFAULT - fault during copy. Beware, in this case iovec
 727  *                         can be modified!
 728  */
 729 int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
 730                                      int hlen, struct iovec *iov)
 731 {
 732         __wsum csum;
 733         int chunk = skb->len - hlen;
 734
 735         if (!chunk)
 736                 return 0;
 737
 738         /* Skip filled elements.
 739          * Pretty silly, look at memcpy_toiovec, though 8)
 740          */
 741         while (!iov->iov_len)
 742                 iov++;
 743
 744         if (iov->iov_len < chunk) {
 745                 if (__skb_checksum_complete(skb))
 746                         goto csum_error;
 747                 if (skb_copy_datagram_iovec(skb, hlen, iov, chunk))
 748                         goto fault;
 749         } else {
 750                 csum = csum_partial(skb->data, hlen, skb->csum);
 751                 if (skb_copy_and_csum_datagram(skb, hlen, iov->iov_base,
 752                                                chunk, &csum))
 753                         goto fault;
 754                 if (csum_fold(csum))
 755                         goto csum_error;
 756                 if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE))
 757                         netdev_rx_csum_fault(skb->dev);
 758                 iov->iov_len -= chunk;
 759                 iov->iov_base += chunk;
 760         }
 761         return 0;
 762 csum_error:
 763         return -EINVAL;
 764 fault:
 765         return -EFAULT;
 766 }
 767 EXPORT_SYMBOL(skb_copy_and_csum_datagram_iovec);
 768
 769 /**
 770  *      datagram_poll - generic datagram poll
 771  *      @file: file struct
 772  *      @sock: socket
 773  *      @wait: poll table
 774  *
 775  *      Datagram poll: Again totally generic. This also handles
 776  *      sequenced packet sockets providing the socket receive queue
 777  *      is only ever holding data ready to receive.
 778  *
 779  *      Note: when you _don't_ use this routine for this protocol,
 780  *      and you use a different write policy from sock_writeable()
 781  *      then please supply your own write_space callback.
 782  */
 783 unsigned int datagram_poll(struct file *file, struct socket *sock,
 784                            poll_table *wait)
 785 {
 786         struct sock *sk = sock->sk;
 787         unsigned int mask;
 788
 789         sock_poll_wait(file, sk_sleep(sk), wait);
 790         mask = 0;
 791
 792         /* exceptional events? */
 793         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 794                 mask |= POLLERR |
 795                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
 796
 797         if (sk->sk_shutdown & RCV_SHUTDOWN)
 798                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 799         if (sk->sk_shutdown == SHUTDOWN_MASK)
 800                 mask |= POLLHUP;
 801
 802         /* readable? */
 803         if (!skb_queue_empty(&sk->sk_receive_queue))
 804                 mask |= POLLIN | POLLRDNORM;
 805
 806         /* Connection-based need to check for termination and startup */
 807         if (connection_based(sk)) {
 808                 if (sk->sk_state == TCP_CLOSE)
 809                         mask |= POLLHUP;
 810                 /* connection hasn't started yet? */
 811                 if (sk->sk_state == TCP_SYN_SENT)
 812                         return mask;
 813         }
 814
 815         /* writable? */
 816         if (sock_writeable(sk))
 817                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 818         else
 819                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 820
 821         return mask;
 822 }
 823 EXPORT_SYMBOL(datagram_poll);