Ignore:
Timestamp:
Apr 16, 2017, 3:07:01 PM (3 months ago)
Author:
brainslayer
Message:

update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-3.18/net/netlink/af_netlink.c

    r30256 r31869  
    235235        dev_hold(dev);
    236236
    237         if (netlink_skb_is_mmaped(skb) || is_vmalloc_addr(skb->head))
     237        if (is_vmalloc_addr(skb->head))
    238238                nskb = netlink_to_full_skb(skb, GFP_ATOMIC);
    239239        else
     
    309309}
    310310
    311 #ifdef CONFIG_NETLINK_MMAP
    312 static bool netlink_rx_is_mmaped(struct sock *sk)
    313 {
    314         return nlk_sk(sk)->rx_ring.pg_vec != NULL;
    315 }
    316 
    317 static bool netlink_tx_is_mmaped(struct sock *sk)
    318 {
    319         return nlk_sk(sk)->tx_ring.pg_vec != NULL;
    320 }
    321 
    322 static __pure struct page *pgvec_to_page(const void *addr)
    323 {
    324         if (is_vmalloc_addr(addr))
    325                 return vmalloc_to_page(addr);
    326         else
    327                 return virt_to_page(addr);
    328 }
    329 
    330 static void free_pg_vec(void **pg_vec, unsigned int order, unsigned int len)
    331 {
    332         unsigned int i;
    333 
    334         for (i = 0; i < len; i++) {
    335                 if (pg_vec[i] != NULL) {
    336                         if (is_vmalloc_addr(pg_vec[i]))
    337                                 vfree(pg_vec[i]);
    338                         else
    339                                 free_pages((unsigned long)pg_vec[i], order);
    340                 }
    341         }
    342         kfree(pg_vec);
    343 }
    344 
    345 static void *alloc_one_pg_vec_page(unsigned long order)
    346 {
    347         void *buffer;
    348         gfp_t gfp_flags = GFP_KERNEL | __GFP_COMP | __GFP_ZERO |
    349                           __GFP_NOWARN | __GFP_NORETRY;
    350 
    351         buffer = (void *)__get_free_pages(gfp_flags, order);
    352         if (buffer != NULL)
    353                 return buffer;
    354 
    355         buffer = vzalloc((1 << order) * PAGE_SIZE);
    356         if (buffer != NULL)
    357                 return buffer;
    358 
    359         gfp_flags &= ~__GFP_NORETRY;
    360         return (void *)__get_free_pages(gfp_flags, order);
    361 }
    362 
    363 static void **alloc_pg_vec(struct netlink_sock *nlk,
    364                            struct nl_mmap_req *req, unsigned int order)
    365 {
    366         unsigned int block_nr = req->nm_block_nr;
    367         unsigned int i;
    368         void **pg_vec;
    369 
    370         pg_vec = kcalloc(block_nr, sizeof(void *), GFP_KERNEL);
    371         if (pg_vec == NULL)
    372                 return NULL;
    373 
    374         for (i = 0; i < block_nr; i++) {
    375                 pg_vec[i] = alloc_one_pg_vec_page(order);
    376                 if (pg_vec[i] == NULL)
    377                         goto err1;
    378         }
    379 
    380         return pg_vec;
    381 err1:
    382         free_pg_vec(pg_vec, order, block_nr);
    383         return NULL;
    384 }
    385 
    386 
    387 static void
    388 __netlink_set_ring(struct sock *sk, struct nl_mmap_req *req, bool tx_ring, void **pg_vec,
    389                    unsigned int order)
    390 {
    391         struct netlink_sock *nlk = nlk_sk(sk);
    392         struct sk_buff_head *queue;
    393         struct netlink_ring *ring;
    394 
    395         queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
    396         ring  = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;
    397 
    398         spin_lock_bh(&queue->lock);
    399 
    400         ring->frame_max         = req->nm_frame_nr - 1;
    401         ring->head              = 0;
    402         ring->frame_size        = req->nm_frame_size;
    403         ring->pg_vec_pages      = req->nm_block_size / PAGE_SIZE;
    404 
    405         swap(ring->pg_vec_len, req->nm_block_nr);
    406         swap(ring->pg_vec_order, order);
    407         swap(ring->pg_vec, pg_vec);
    408 
    409         __skb_queue_purge(queue);
    410         spin_unlock_bh(&queue->lock);
    411 
    412         WARN_ON(atomic_read(&nlk->mapped));
    413 
    414         if (pg_vec)
    415                 free_pg_vec(pg_vec, order, req->nm_block_nr);
    416 }
    417 
    418 static int netlink_set_ring(struct sock *sk, struct nl_mmap_req *req,
    419                             bool tx_ring)
    420 {
    421         struct netlink_sock *nlk = nlk_sk(sk);
    422         struct netlink_ring *ring;
    423         void **pg_vec = NULL;
    424         unsigned int order = 0;
    425 
    426         ring  = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;
    427 
    428         if (atomic_read(&nlk->mapped))
    429                 return -EBUSY;
    430         if (atomic_read(&ring->pending))
    431                 return -EBUSY;
    432 
    433         if (req->nm_block_nr) {
    434                 if (ring->pg_vec != NULL)
    435                         return -EBUSY;
    436 
    437                 if ((int)req->nm_block_size <= 0)
    438                         return -EINVAL;
    439                 if (!PAGE_ALIGNED(req->nm_block_size))
    440                         return -EINVAL;
    441                 if (req->nm_frame_size < NL_MMAP_HDRLEN)
    442                         return -EINVAL;
    443                 if (!IS_ALIGNED(req->nm_frame_size, NL_MMAP_MSG_ALIGNMENT))
    444                         return -EINVAL;
    445 
    446                 ring->frames_per_block = req->nm_block_size /
    447                                          req->nm_frame_size;
    448                 if (ring->frames_per_block == 0)
    449                         return -EINVAL;
    450                 if (ring->frames_per_block * req->nm_block_nr !=
    451                     req->nm_frame_nr)
    452                         return -EINVAL;
    453 
    454                 order = get_order(req->nm_block_size);
    455                 pg_vec = alloc_pg_vec(nlk, req, order);
    456                 if (pg_vec == NULL)
    457                         return -ENOMEM;
    458         } else {
    459                 if (req->nm_frame_nr)
    460                         return -EINVAL;
    461         }
    462 
    463         mutex_lock(&nlk->pg_vec_lock);
    464         if (atomic_read(&nlk->mapped) == 0) {
    465                 __netlink_set_ring(sk, req, tx_ring, pg_vec, order);
    466                 mutex_unlock(&nlk->pg_vec_lock);
    467                 return 0;
    468         }
    469 
    470         mutex_unlock(&nlk->pg_vec_lock);
    471 
    472         if (pg_vec)
    473                 free_pg_vec(pg_vec, order, req->nm_block_nr);
    474 
    475         return -EBUSY;
    476 }
    477 
    478 static void netlink_mm_open(struct vm_area_struct *vma)
    479 {
    480         struct file *file = vma->vm_file;
    481         struct socket *sock = file->private_data;
    482         struct sock *sk = sock->sk;
    483 
    484         if (sk)
    485                 atomic_inc(&nlk_sk(sk)->mapped);
    486 }
    487 
    488 static void netlink_mm_close(struct vm_area_struct *vma)
    489 {
    490         struct file *file = vma->vm_file;
    491         struct socket *sock = file->private_data;
    492         struct sock *sk = sock->sk;
    493 
    494         if (sk)
    495                 atomic_dec(&nlk_sk(sk)->mapped);
    496 }
    497 
    498 static const struct vm_operations_struct netlink_mmap_ops = {
    499         .open   = netlink_mm_open,
    500         .close  = netlink_mm_close,
    501 };
    502 
    503 static int netlink_mmap(struct file *file, struct socket *sock,
    504                         struct vm_area_struct *vma)
    505 {
    506         struct sock *sk = sock->sk;
    507         struct netlink_sock *nlk = nlk_sk(sk);
    508         struct netlink_ring *ring;
    509         unsigned long start, size, expected;
    510         unsigned int i;
    511         int err = -EINVAL;
    512 
    513         if (vma->vm_pgoff)
    514                 return -EINVAL;
    515 
    516         mutex_lock(&nlk->pg_vec_lock);
    517 
    518         expected = 0;
    519         for (ring = &nlk->rx_ring; ring <= &nlk->tx_ring; ring++) {
    520                 if (ring->pg_vec == NULL)
    521                         continue;
    522                 expected += ring->pg_vec_len * ring->pg_vec_pages * PAGE_SIZE;
    523         }
    524 
    525         if (expected == 0)
    526                 goto out;
    527 
    528         size = vma->vm_end - vma->vm_start;
    529         if (size != expected)
    530                 goto out;
    531 
    532         start = vma->vm_start;
    533         for (ring = &nlk->rx_ring; ring <= &nlk->tx_ring; ring++) {
    534                 if (ring->pg_vec == NULL)
    535                         continue;
    536 
    537                 for (i = 0; i < ring->pg_vec_len; i++) {
    538                         struct page *page;
    539                         void *kaddr = ring->pg_vec[i];
    540                         unsigned int pg_num;
    541 
    542                         for (pg_num = 0; pg_num < ring->pg_vec_pages; pg_num++) {
    543                                 page = pgvec_to_page(kaddr);
    544                                 err = vm_insert_page(vma, start, page);
    545                                 if (err < 0)
    546                                         goto out;
    547                                 start += PAGE_SIZE;
    548                                 kaddr += PAGE_SIZE;
    549                         }
    550                 }
    551         }
    552 
    553         atomic_inc(&nlk->mapped);
    554         vma->vm_ops = &netlink_mmap_ops;
    555         err = 0;
    556 out:
    557         mutex_unlock(&nlk->pg_vec_lock);
    558         return err;
    559 }
    560 
    561 static void netlink_frame_flush_dcache(const struct nl_mmap_hdr *hdr, unsigned int nm_len)
    562 {
    563 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1
    564         struct page *p_start, *p_end;
    565 
    566         /* First page is flushed through netlink_{get,set}_status */
    567         p_start = pgvec_to_page(hdr + PAGE_SIZE);
    568         p_end   = pgvec_to_page((void *)hdr + NL_MMAP_HDRLEN + nm_len - 1);
    569         while (p_start <= p_end) {
    570                 flush_dcache_page(p_start);
    571                 p_start++;
    572         }
    573 #endif
    574 }
    575 
    576 static enum nl_mmap_status netlink_get_status(const struct nl_mmap_hdr *hdr)
    577 {
    578         smp_rmb();
    579         flush_dcache_page(pgvec_to_page(hdr));
    580         return hdr->nm_status;
    581 }
    582 
    583 static void netlink_set_status(struct nl_mmap_hdr *hdr,
    584                                enum nl_mmap_status status)
    585 {
    586         smp_mb();
    587         hdr->nm_status = status;
    588         flush_dcache_page(pgvec_to_page(hdr));
    589 }
    590 
    591 static struct nl_mmap_hdr *
    592 __netlink_lookup_frame(const struct netlink_ring *ring, unsigned int pos)
    593 {
    594         unsigned int pg_vec_pos, frame_off;
    595 
    596         pg_vec_pos = pos / ring->frames_per_block;
    597         frame_off  = pos % ring->frames_per_block;
    598 
    599         return ring->pg_vec[pg_vec_pos] + (frame_off * ring->frame_size);
    600 }
    601 
    602 static struct nl_mmap_hdr *
    603 netlink_lookup_frame(const struct netlink_ring *ring, unsigned int pos,
    604                      enum nl_mmap_status status)
    605 {
    606         struct nl_mmap_hdr *hdr;
    607 
    608         hdr = __netlink_lookup_frame(ring, pos);
    609         if (netlink_get_status(hdr) != status)
    610                 return NULL;
    611 
    612         return hdr;
    613 }
    614 
    615 static struct nl_mmap_hdr *
    616 netlink_current_frame(const struct netlink_ring *ring,
    617                       enum nl_mmap_status status)
    618 {
    619         return netlink_lookup_frame(ring, ring->head, status);
    620 }
    621 
    622 static struct nl_mmap_hdr *
    623 netlink_previous_frame(const struct netlink_ring *ring,
    624                        enum nl_mmap_status status)
    625 {
    626         unsigned int prev;
    627 
    628         prev = ring->head ? ring->head - 1 : ring->frame_max;
    629         return netlink_lookup_frame(ring, prev, status);
    630 }
    631 
    632 static void netlink_increment_head(struct netlink_ring *ring)
    633 {
    634         ring->head = ring->head != ring->frame_max ? ring->head + 1 : 0;
    635 }
    636 
    637 static void netlink_forward_ring(struct netlink_ring *ring)
    638 {
    639         unsigned int head = ring->head, pos = head;
    640         const struct nl_mmap_hdr *hdr;
    641 
    642         do {
    643                 hdr = __netlink_lookup_frame(ring, pos);
    644                 if (hdr->nm_status == NL_MMAP_STATUS_UNUSED)
    645                         break;
    646                 if (hdr->nm_status != NL_MMAP_STATUS_SKIP)
    647                         break;
    648                 netlink_increment_head(ring);
    649         } while (ring->head != head);
    650 }
    651 
    652 static bool netlink_dump_space(struct netlink_sock *nlk)
    653 {
    654         struct netlink_ring *ring = &nlk->rx_ring;
    655         struct nl_mmap_hdr *hdr;
    656         unsigned int n;
    657 
    658         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
    659         if (hdr == NULL)
    660                 return false;
    661 
    662         n = ring->head + ring->frame_max / 2;
    663         if (n > ring->frame_max)
    664                 n -= ring->frame_max;
    665 
    666         hdr = __netlink_lookup_frame(ring, n);
    667 
    668         return hdr->nm_status == NL_MMAP_STATUS_UNUSED;
    669 }
    670 
    671 static unsigned int netlink_poll(struct file *file, struct socket *sock,
    672                                  poll_table *wait)
    673 {
    674         struct sock *sk = sock->sk;
    675         struct netlink_sock *nlk = nlk_sk(sk);
    676         unsigned int mask;
    677         int err;
    678 
    679         if (nlk->rx_ring.pg_vec != NULL) {
    680                 /* Memory mapped sockets don't call recvmsg(), so flow control
    681                  * for dumps is performed here. A dump is allowed to continue
    682                  * if at least half the ring is unused.
    683                  */
    684                 while (nlk->cb_running && netlink_dump_space(nlk)) {
    685                         err = netlink_dump(sk);
    686                         if (err < 0) {
    687                                 sk->sk_err = -err;
    688                                 sk->sk_error_report(sk);
    689                                 break;
    690                         }
    691                 }
    692                 netlink_rcv_wake(sk);
    693         }
    694 
    695         mask = datagram_poll(file, sock, wait);
    696 
    697         spin_lock_bh(&sk->sk_receive_queue.lock);
    698         if (nlk->rx_ring.pg_vec) {
    699                 netlink_forward_ring(&nlk->rx_ring);
    700                 if (!netlink_previous_frame(&nlk->rx_ring, NL_MMAP_STATUS_UNUSED))
    701                         mask |= POLLIN | POLLRDNORM;
    702         }
    703         spin_unlock_bh(&sk->sk_receive_queue.lock);
    704 
    705         spin_lock_bh(&sk->sk_write_queue.lock);
    706         if (nlk->tx_ring.pg_vec) {
    707                 if (netlink_current_frame(&nlk->tx_ring, NL_MMAP_STATUS_UNUSED))
    708                         mask |= POLLOUT | POLLWRNORM;
    709         }
    710         spin_unlock_bh(&sk->sk_write_queue.lock);
    711 
    712         return mask;
    713 }
    714 
    715 static struct nl_mmap_hdr *netlink_mmap_hdr(struct sk_buff *skb)
    716 {
    717         return (struct nl_mmap_hdr *)(skb->head - NL_MMAP_HDRLEN);
    718 }
    719 
    720 static void netlink_ring_setup_skb(struct sk_buff *skb, struct sock *sk,
    721                                    struct netlink_ring *ring,
    722                                    struct nl_mmap_hdr *hdr)
    723 {
    724         unsigned int size;
    725         void *data;
    726 
    727         size = ring->frame_size - NL_MMAP_HDRLEN;
    728         data = (void *)hdr + NL_MMAP_HDRLEN;
    729 
    730         skb->head       = data;
    731         skb->data       = data;
    732         skb_reset_tail_pointer(skb);
    733         skb->end        = skb->tail + size;
    734         skb->len        = 0;
    735 
    736         skb->destructor = netlink_skb_destructor;
    737         NETLINK_CB(skb).flags |= NETLINK_SKB_MMAPED;
    738         NETLINK_CB(skb).sk = sk;
    739 }
    740 
    741 static int netlink_mmap_sendmsg(struct sock *sk, struct msghdr *msg,
    742                                 u32 dst_portid, u32 dst_group,
    743                                 struct sock_iocb *siocb)
    744 {
    745         struct netlink_sock *nlk = nlk_sk(sk);
    746         struct netlink_ring *ring;
    747         struct nl_mmap_hdr *hdr;
    748         struct sk_buff *skb;
    749         unsigned int maxlen;
    750         int err = 0, len = 0;
    751 
    752         mutex_lock(&nlk->pg_vec_lock);
    753 
    754         ring   = &nlk->tx_ring;
    755         maxlen = ring->frame_size - NL_MMAP_HDRLEN;
    756 
    757         do {
    758                 unsigned int nm_len;
    759 
    760                 hdr = netlink_current_frame(ring, NL_MMAP_STATUS_VALID);
    761                 if (hdr == NULL) {
    762                         if (!(msg->msg_flags & MSG_DONTWAIT) &&
    763                             atomic_read(&nlk->tx_ring.pending))
    764                                 schedule();
    765                         continue;
    766                 }
    767 
    768                 nm_len = ACCESS_ONCE(hdr->nm_len);
    769                 if (nm_len > maxlen) {
    770                         err = -EINVAL;
    771                         goto out;
    772                 }
    773 
    774                 netlink_frame_flush_dcache(hdr, nm_len);
    775 
    776                 skb = alloc_skb(nm_len, GFP_KERNEL);
    777                 if (skb == NULL) {
    778                         err = -ENOBUFS;
    779                         goto out;
    780                 }
    781                 __skb_put(skb, nm_len);
    782                 memcpy(skb->data, (void *)hdr + NL_MMAP_HDRLEN, nm_len);
    783                 netlink_set_status(hdr, NL_MMAP_STATUS_UNUSED);
    784 
    785                 netlink_increment_head(ring);
    786 
    787                 NETLINK_CB(skb).portid    = nlk->portid;
    788                 NETLINK_CB(skb).dst_group = dst_group;
    789                 NETLINK_CB(skb).creds     = siocb->scm->creds;
    790 
    791                 err = security_netlink_send(sk, skb);
    792                 if (err) {
    793                         kfree_skb(skb);
    794                         goto out;
    795                 }
    796 
    797                 if (unlikely(dst_group)) {
    798                         atomic_inc(&skb->users);
    799                         netlink_broadcast(sk, skb, dst_portid, dst_group,
    800                                           GFP_KERNEL);
    801                 }
    802                 err = netlink_unicast(sk, skb, dst_portid,
    803                                       msg->msg_flags & MSG_DONTWAIT);
    804                 if (err < 0)
    805                         goto out;
    806                 len += err;
    807 
    808         } while (hdr != NULL ||
    809                  (!(msg->msg_flags & MSG_DONTWAIT) &&
    810                   atomic_read(&nlk->tx_ring.pending)));
    811 
    812         if (len > 0)
    813                 err = len;
    814 out:
    815         mutex_unlock(&nlk->pg_vec_lock);
    816         return err;
    817 }
    818 
    819 static void netlink_queue_mmaped_skb(struct sock *sk, struct sk_buff *skb)
    820 {
    821         struct nl_mmap_hdr *hdr;
    822 
    823         hdr = netlink_mmap_hdr(skb);
    824         hdr->nm_len     = skb->len;
    825         hdr->nm_group   = NETLINK_CB(skb).dst_group;
    826         hdr->nm_pid     = NETLINK_CB(skb).creds.pid;
    827         hdr->nm_uid     = from_kuid(sk_user_ns(sk), NETLINK_CB(skb).creds.uid);
    828         hdr->nm_gid     = from_kgid(sk_user_ns(sk), NETLINK_CB(skb).creds.gid);
    829         netlink_frame_flush_dcache(hdr, hdr->nm_len);
    830         netlink_set_status(hdr, NL_MMAP_STATUS_VALID);
    831 
    832         NETLINK_CB(skb).flags |= NETLINK_SKB_DELIVERED;
    833         kfree_skb(skb);
    834 }
    835 
    836 static void netlink_ring_set_copied(struct sock *sk, struct sk_buff *skb)
    837 {
    838         struct netlink_sock *nlk = nlk_sk(sk);
    839         struct netlink_ring *ring = &nlk->rx_ring;
    840         struct nl_mmap_hdr *hdr;
    841 
    842         spin_lock_bh(&sk->sk_receive_queue.lock);
    843         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
    844         if (hdr == NULL) {
    845                 spin_unlock_bh(&sk->sk_receive_queue.lock);
    846                 kfree_skb(skb);
    847                 netlink_overrun(sk);
    848                 return;
    849         }
    850         netlink_increment_head(ring);
    851         __skb_queue_tail(&sk->sk_receive_queue, skb);
    852         spin_unlock_bh(&sk->sk_receive_queue.lock);
    853 
    854         hdr->nm_len     = skb->len;
    855         hdr->nm_group   = NETLINK_CB(skb).dst_group;
    856         hdr->nm_pid     = NETLINK_CB(skb).creds.pid;
    857         hdr->nm_uid     = from_kuid(sk_user_ns(sk), NETLINK_CB(skb).creds.uid);
    858         hdr->nm_gid     = from_kgid(sk_user_ns(sk), NETLINK_CB(skb).creds.gid);
    859         netlink_set_status(hdr, NL_MMAP_STATUS_COPY);
    860 }
    861 
    862 #else /* CONFIG_NETLINK_MMAP */
    863 #define netlink_rx_is_mmaped(sk)        false
    864 #define netlink_tx_is_mmaped(sk)        false
    865 #define netlink_mmap                    sock_no_mmap
    866 #define netlink_poll                    datagram_poll
    867 #define netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group, siocb)     0
    868 #endif /* CONFIG_NETLINK_MMAP */
    869 
    870311static void netlink_skb_destructor(struct sk_buff *skb)
    871312{
    872 #ifdef CONFIG_NETLINK_MMAP
    873         struct nl_mmap_hdr *hdr;
    874         struct netlink_ring *ring;
    875         struct sock *sk;
    876 
    877         /* If a packet from the kernel to userspace was freed because of an
    878          * error without being delivered to userspace, the kernel must reset
    879          * the status. In the direction userspace to kernel, the status is
    880          * always reset here after the packet was processed and freed.
    881          */
    882         if (netlink_skb_is_mmaped(skb)) {
    883                 hdr = netlink_mmap_hdr(skb);
    884                 sk = NETLINK_CB(skb).sk;
    885 
    886                 if (NETLINK_CB(skb).flags & NETLINK_SKB_TX) {
    887                         netlink_set_status(hdr, NL_MMAP_STATUS_UNUSED);
    888                         ring = &nlk_sk(sk)->tx_ring;
    889                 } else {
    890                         if (!(NETLINK_CB(skb).flags & NETLINK_SKB_DELIVERED)) {
    891                                 hdr->nm_len = 0;
    892                                 netlink_set_status(hdr, NL_MMAP_STATUS_VALID);
    893                         }
    894                         ring = &nlk_sk(sk)->rx_ring;
    895                 }
    896 
    897                 WARN_ON(atomic_read(&ring->pending) == 0);
    898                 atomic_dec(&ring->pending);
    899                 sock_put(sk);
    900 
    901                 skb->head = NULL;
    902         }
    903 #endif
    904313        if (is_vmalloc_addr(skb->head)) {
    905314                if (!skb->cloned ||
     
    935344
    936345        skb_queue_purge(&sk->sk_receive_queue);
    937 #ifdef CONFIG_NETLINK_MMAP
    938         if (1) {
    939                 struct nl_mmap_req req;
    940 
    941                 memset(&req, 0, sizeof(req));
    942                 if (nlk->rx_ring.pg_vec)
    943                         __netlink_set_ring(sk, &req, false, NULL, 0);
    944                 memset(&req, 0, sizeof(req));
    945                 if (nlk->tx_ring.pg_vec)
    946                         __netlink_set_ring(sk, &req, true, NULL, 0);
    947         }
    948 #endif /* CONFIG_NETLINK_MMAP */
    949346
    950347        if (!sock_flag(sk, SOCK_DEAD)) {
     
    1154551        }
    1155552        init_waitqueue_head(&nlk->wait);
    1156 #ifdef CONFIG_NETLINK_MMAP
    1157         mutex_init(&nlk->pg_vec_lock);
    1158 #endif
    1159553
    1160554        sk->sk_destruct = netlink_sock_destruct;
     
    16541048        nlk = nlk_sk(sk);
    16551049
    1656         if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
    1657              test_bit(NETLINK_CONGESTED, &nlk->state)) &&
    1658             !netlink_skb_is_mmaped(skb)) {
     1050        if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
     1051            test_bit(NETLINK_CONGESTED, &nlk->state)) {
    16591052                DECLARE_WAITQUEUE(wait, current);
    16601053                if (!*timeo) {
     
    16941087        netlink_deliver_tap(skb);
    16951088
    1696 #ifdef CONFIG_NETLINK_MMAP
    1697         if (netlink_skb_is_mmaped(skb))
    1698                 netlink_queue_mmaped_skb(sk, skb);
    1699         else if (netlink_rx_is_mmaped(sk))
    1700                 netlink_ring_set_copied(sk, skb);
    1701         else
    1702 #endif /* CONFIG_NETLINK_MMAP */
    1703                 skb_queue_tail(&sk->sk_receive_queue, skb);
     1089        skb_queue_tail(&sk->sk_receive_queue, skb);
    17041090        sk->sk_data_ready(sk);
    17051091        return len;
     
    17861172                                  u32 dst_portid, gfp_t gfp_mask)
    17871173{
    1788 #ifdef CONFIG_NETLINK_MMAP
    1789         struct sock *sk = NULL;
    1790         struct sk_buff *skb;
    1791         struct netlink_ring *ring;
    1792         struct nl_mmap_hdr *hdr;
    1793         unsigned int maxlen;
    1794 
    1795         sk = netlink_getsockbyportid(ssk, dst_portid);
    1796         if (IS_ERR(sk))
    1797                 goto out;
    1798 
    1799         ring = &nlk_sk(sk)->rx_ring;
    1800         /* fast-path without atomic ops for common case: non-mmaped receiver */
    1801         if (ring->pg_vec == NULL)
    1802                 goto out_put;
    1803 
    1804         if (ring->frame_size - NL_MMAP_HDRLEN < size)
    1805                 goto out_put;
    1806 
    1807         skb = alloc_skb_head(gfp_mask);
    1808         if (skb == NULL)
    1809                 goto err1;
    1810 
    1811         spin_lock_bh(&sk->sk_receive_queue.lock);
    1812         /* check again under lock */
    1813         if (ring->pg_vec == NULL)
    1814                 goto out_free;
    1815 
    1816         /* check again under lock */
    1817         maxlen = ring->frame_size - NL_MMAP_HDRLEN;
    1818         if (maxlen < size)
    1819                 goto out_free;
    1820 
    1821         netlink_forward_ring(ring);
    1822         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
    1823         if (hdr == NULL)
    1824                 goto err2;
    1825         netlink_ring_setup_skb(skb, sk, ring, hdr);
    1826         netlink_set_status(hdr, NL_MMAP_STATUS_RESERVED);
    1827         atomic_inc(&ring->pending);
    1828         netlink_increment_head(ring);
    1829 
    1830         spin_unlock_bh(&sk->sk_receive_queue.lock);
    1831         return skb;
    1832 
    1833 err2:
    1834         kfree_skb(skb);
    1835         spin_unlock_bh(&sk->sk_receive_queue.lock);
    1836         netlink_overrun(sk);
    1837 err1:
    1838         sock_put(sk);
    1839         return NULL;
    1840 
    1841 out_free:
    1842         kfree_skb(skb);
    1843         spin_unlock_bh(&sk->sk_receive_queue.lock);
    1844 out_put:
    1845         sock_put(sk);
    1846 out:
    1847 #endif
    18481174        return alloc_skb(size, gfp_mask);
    18491175}
     
    21071433                return -ENOPROTOOPT;
    21081434
    2109         if (optname != NETLINK_RX_RING && optname != NETLINK_TX_RING &&
    2110             optlen >= sizeof(int) &&
     1435        if (optlen >= sizeof(int) &&
    21111436            get_user(val, (unsigned int __user *)optval))
    21121437                return -EFAULT;
     
    21611486                err = 0;
    21621487                break;
    2163 #ifdef CONFIG_NETLINK_MMAP
    2164         case NETLINK_RX_RING:
    2165         case NETLINK_TX_RING: {
    2166                 struct nl_mmap_req req;
    2167 
    2168                 /* Rings might consume more memory than queue limits, require
    2169                  * CAP_NET_ADMIN.
    2170                  */
    2171                 if (!capable(CAP_NET_ADMIN))
    2172                         return -EPERM;
    2173                 if (optlen < sizeof(req))
    2174                         return -EINVAL;
    2175                 if (copy_from_user(&req, optval, sizeof(req)))
    2176                         return -EFAULT;
    2177                 err = netlink_set_ring(sk, &req,
    2178                                        optname == NETLINK_TX_RING);
    2179                 break;
    2180         }
    2181 #endif /* CONFIG_NETLINK_MMAP */
    21821488        default:
    21831489                err = -ENOPROTOOPT;
     
    22921598        }
    22931599
    2294         if (netlink_tx_is_mmaped(sk) &&
    2295             msg->msg_iov->iov_base == NULL) {
    2296                 err = netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group,
    2297                                            siocb);
    2298                 goto out;
    2299         }
    2300 
    23011600        err = -EMSGSIZE;
    23021601        if (len > sk->sk_sndbuf - 32)
     
    23791678        nlk->max_recvmsg_len = max(nlk->max_recvmsg_len, len);
    23801679        nlk->max_recvmsg_len = min_t(size_t, nlk->max_recvmsg_len,
    2381                                      16384);
     1680                                     SKB_WITH_OVERHEAD(32768));
    23821681
    23831682        copied = data_skb->len;
     
    26241923        alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
    26251924
    2626         if (!netlink_rx_is_mmaped(sk) &&
    2627             atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
     1925        if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
    26281926                goto errout_skb;
    26291927
     
    26371935                                        nlk->max_recvmsg_len,
    26381936                                        nlk->portid,
    2639                                         GFP_KERNEL |
    2640                                         __GFP_NOWARN |
    2641                                         __GFP_NORETRY);
     1937                                        (GFP_KERNEL & ~__GFP_WAIT) |
     1938                                        __GFP_NOWARN | __GFP_NORETRY);
    26421939                /* available room should be exact amount to avoid MSG_TRUNC */
    26431940                if (skb)
     
    26471944        if (!skb)
    26481945                skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,
    2649                                         GFP_KERNEL);
     1946                                        (GFP_KERNEL & ~__GFP_WAIT));
    26501947        if (!skb)
    26511948                goto errout_skb;
     
    27032000        int ret;
    27042001
    2705         /* Memory mapped dump requests need to be copied to avoid looping
    2706          * on the pending state in netlink_mmap_sendmsg() while the CB hold
    2707          * a reference to the skb.
    2708          */
    2709         if (netlink_skb_is_mmaped(skb)) {
    2710                 skb = skb_copy(skb, GFP_KERNEL);
    2711                 if (skb == NULL)
    2712                         return -ENOBUFS;
    2713         } else
    2714                 atomic_inc(&skb->users);
     2002        atomic_inc(&skb->users);
    27152003
    27162004        sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid);
     
    30532341        .accept =       sock_no_accept,
    30542342        .getname =      netlink_getname,
    3055         .poll =         netlink_poll,
     2343        .poll =         datagram_poll,
    30562344        .ioctl =        sock_no_ioctl,
    30572345        .listen =       sock_no_listen,
     
    30612349        .sendmsg =      netlink_sendmsg,
    30622350        .recvmsg =      netlink_recvmsg,
    3063         .mmap =         netlink_mmap,
     2351        .mmap =         sock_no_mmap,
    30642352        .sendpage =     sock_no_sendpage,
    30652353};
Note: See TracChangeset for help on using the changeset viewer.