← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to net/socket.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/socket.c
98
98
 
99
99
#include <net/sock.h>
100
100
#include <linux/netfilter.h>
101
 
#include <trace/socket.h>
102
101
 
103
102
#include <linux/if_tun.h>
104
103
#include <linux/ipv6_route.h>
165
164
 
166
165
static DEFINE_PER_CPU(int, sockets_in_use);
167
166
 
168
 
DEFINE_TRACE(socket_create);
169
 
DEFINE_TRACE(socket_bind);
170
 
DEFINE_TRACE(socket_connect);
171
 
DEFINE_TRACE(socket_listen);
172
 
DEFINE_TRACE(socket_accept);
173
 
DEFINE_TRACE(socket_getsockname);
174
 
DEFINE_TRACE(socket_getpeername);
175
 
DEFINE_TRACE(socket_socketpair);
176
 
DEFINE_TRACE(socket_sendmsg);
177
 
DEFINE_TRACE(socket_recvmsg);
178
 
DEFINE_TRACE(socket_setsockopt);
179
 
DEFINE_TRACE(socket_getsockopt);
180
 
DEFINE_TRACE(socket_shutdown);
181
 
DEFINE_TRACE(socket_call);
182
 
 
183
167
/*
184
168
 * Support routines.
185
169
 * Move socket addresses back and forth across the kernel/user
256
240
static struct inode *sock_alloc_inode(struct super_block *sb)
257
241
{
258
242
        struct socket_alloc *ei;
 
243
        struct socket_wq *wq;
259
244
 
260
245
        ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
261
246
        if (!ei)
262
247
                return NULL;
263
 
        ei->socket.wq = kmalloc(sizeof(struct socket_wq), GFP_KERNEL);
264
 
        if (!ei->socket.wq) {
 
248
        wq = kmalloc(sizeof(*wq), GFP_KERNEL);
 
249
        if (!wq) {
265
250
                kmem_cache_free(sock_inode_cachep, ei);
266
251
                return NULL;
267
252
        }
268
 
        init_waitqueue_head(&ei->socket.wq->wait);
269
 
        ei->socket.wq->fasync_list = NULL;
 
253
        init_waitqueue_head(&wq->wait);
 
254
        wq->fasync_list = NULL;
 
255
        RCU_INIT_POINTER(ei->socket.wq, wq);
270
256
 
271
257
        ei->socket.state = SS_UNCONNECTED;
272
258
        ei->socket.flags = 0;
277
263
        return &ei->vfs_inode;
278
264
}
279
265
 
280
 
 
281
 
 
282
 
static void wq_free_rcu(struct rcu_head *head)
283
 
{
284
 
        struct socket_wq *wq = container_of(head, struct socket_wq, rcu);
285
 
 
286
 
        kfree(wq);
287
 
}
288
 
 
289
266
static void sock_destroy_inode(struct inode *inode)
290
267
{
291
268
        struct socket_alloc *ei;
 
269
        struct socket_wq *wq;
292
270
 
293
271
        ei = container_of(inode, struct socket_alloc, vfs_inode);
294
 
        call_rcu(&ei->socket.wq->rcu, wq_free_rcu);
 
272
        wq = rcu_dereference_protected(ei->socket.wq, 1);
 
273
        kfree_rcu(wq, rcu);
295
274
        kmem_cache_free(sock_inode_cachep, ei);
296
275
}
297
276
 
540
519
                module_put(owner);
541
520
        }
542
521
 
543
 
        if (sock->wq->fasync_list)
 
522
        if (rcu_dereference_protected(sock->wq, 1)->fasync_list)
544
523
                printk(KERN_ERR "sock_release: fasync list not empty!\n");
545
524
 
546
525
        percpu_sub(sockets_in_use, 1);
563
542
}
564
543
EXPORT_SYMBOL(sock_tx_timestamp);
565
544
 
 
545
static inline int __sock_sendmsg_nosec(struct kiocb *iocb, struct socket *sock,
 
546
                                       struct msghdr *msg, size_t size)
 
547
{
 
548
        struct sock_iocb *si = kiocb_to_siocb(iocb);
 
549
 
 
550
        sock_update_classid(sock->sk);
 
551
 
 
552
        si->sock = sock;
 
553
        si->scm = NULL;
 
554
        si->msg = msg;
 
555
        si->size = size;
 
556
 
 
557
        return sock->ops->sendmsg(iocb, sock, msg, size);
 
558
}
 
559
 
566
560
static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
567
561
                                 struct msghdr *msg, size_t size)
568
562
{
569
 
        struct sock_iocb *si = kiocb_to_siocb(iocb);
570
 
        int err;
571
 
 
572
 
        sock_update_classid(sock->sk);
573
 
 
574
 
        si->sock = sock;
575
 
        si->scm = NULL;
576
 
        si->msg = msg;
577
 
        si->size = size;
578
 
 
579
 
        err = security_socket_sendmsg(sock, msg, size);
580
 
        if (err)
581
 
                return err;
582
 
 
583
 
        err = sock->ops->sendmsg(iocb, sock, msg, size);
584
 
        trace_socket_sendmsg(sock, msg, size, err);
585
 
        return err;
 
563
        int err = security_socket_sendmsg(sock, msg, size);
 
564
 
 
565
        return err ?: __sock_sendmsg_nosec(iocb, sock, msg, size);
586
566
}
587
567
 
588
568
int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
600
580
}
601
581
EXPORT_SYMBOL(sock_sendmsg);
602
582
 
 
583
int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg, size_t size)
 
584
{
 
585
        struct kiocb iocb;
 
586
        struct sock_iocb siocb;
 
587
        int ret;
 
588
 
 
589
        init_sync_kiocb(&iocb, NULL);
 
590
        iocb.private = &siocb;
 
591
        ret = __sock_sendmsg_nosec(&iocb, sock, msg, size);
 
592
        if (-EIOCBQUEUED == ret)
 
593
                ret = wait_on_sync_kiocb(&iocb);
 
594
        return ret;
 
595
}
 
596
 
603
597
int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
604
598
                   struct kvec *vec, size_t num, size_t size)
605
599
{
700
694
                                       struct msghdr *msg, size_t size, int flags)
701
695
{
702
696
        struct sock_iocb *si = kiocb_to_siocb(iocb);
703
 
        int err;
704
697
 
705
698
        sock_update_classid(sock->sk);
706
699
 
710
703
        si->size = size;
711
704
        si->flags = flags;
712
705
 
713
 
        err = sock->ops->recvmsg(iocb, sock, msg, size, flags);
714
 
        trace_socket_recvmsg(sock, msg, size, flags, err);
715
 
        return err;
 
706
        return sock->ops->recvmsg(iocb, sock, msg, size, flags);
716
707
}
717
708
 
718
709
static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
1129
1120
{
1130
1121
        struct socket *sock = filp->private_data;
1131
1122
        struct sock *sk = sock->sk;
 
1123
        struct socket_wq *wq;
1132
1124
 
1133
1125
        if (sk == NULL)
1134
1126
                return -EINVAL;
1135
1127
 
1136
1128
        lock_sock(sk);
1137
 
 
1138
 
        fasync_helper(fd, filp, on, &sock->wq->fasync_list);
1139
 
 
1140
 
        if (!sock->wq->fasync_list)
 
1129
        wq = rcu_dereference_protected(sock->wq, sock_owned_by_user(sk));
 
1130
        fasync_helper(fd, filp, on, &wq->fasync_list);
 
1131
 
 
1132
        if (!wq->fasync_list)
1141
1133
                sock_reset_flag(sk, SOCK_FASYNC);
1142
1134
        else
1143
1135
                sock_set_flag(sk, SOCK_FASYNC);
1320
1312
        BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1321
1313
 
1322
1314
        flags = type & ~SOCK_TYPE_MASK;
1323
 
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) {
1324
 
                retval = -EINVAL;
1325
 
                goto out;
1326
 
        }
 
1315
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
 
1316
                return -EINVAL;
1327
1317
        type &= SOCK_TYPE_MASK;
1328
1318
 
1329
1319
        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1337
1327
        if (retval < 0)
1338
1328
                goto out_release;
1339
1329
 
1340
 
        goto out;
1341
 
out_release:
1342
 
        sock_release(sock);
1343
1330
out:
1344
 
        trace_socket_create(family, type, protocol, sock, retval);
1345
1331
        /* It may be already another descriptor 8) Not kernel problem. */
1346
1332
        return retval;
 
1333
 
 
1334
out_release:
 
1335
        sock_release(sock);
 
1336
        return retval;
1347
1337
}
1348
1338
 
1349
1339
/*
1359
1349
        int flags;
1360
1350
 
1361
1351
        flags = type & ~SOCK_TYPE_MASK;
1362
 
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) {
1363
 
                err = -EINVAL;
1364
 
                goto out;
1365
 
        }
 
1352
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
 
1353
                return -EINVAL;
1366
1354
        type &= SOCK_TYPE_MASK;
1367
1355
 
1368
1356
        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1411
1399
        if (!err)
1412
1400
                err = put_user(fd2, &usockvec[1]);
1413
1401
        if (!err)
1414
 
                goto out;
 
1402
                return 0;
1415
1403
 
1416
1404
        sys_close(fd2);
1417
1405
        sys_close(fd1);
1418
 
        goto out;
 
1406
        return err;
1419
1407
 
1420
1408
out_release_both:
1421
1409
        sock_release(sock2);
1422
1410
out_release_1:
1423
1411
        sock_release(sock1);
1424
1412
out:
1425
 
        trace_socket_socketpair(family, type, protocol, usockvec, err);
1426
1413
        return err;
1427
1414
}
1428
1415
 
1454
1441
                }
1455
1442
                fput_light(sock->file, fput_needed);
1456
1443
        }
1457
 
        trace_socket_bind(fd, umyaddr, addrlen, err);
1458
1444
        return err;
1459
1445
}
1460
1446
 
1482
1468
 
1483
1469
                fput_light(sock->file, fput_needed);
1484
1470
        }
1485
 
        trace_socket_listen(fd, backlog, err);
1486
1471
        return err;
1487
1472
}
1488
1473
 
1506
1491
        int err, len, newfd, fput_needed;
1507
1492
        struct sockaddr_storage address;
1508
1493
 
1509
 
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) {
1510
 
                err = -EINVAL;
1511
 
                goto out;
1512
 
        }
 
1494
        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
 
1495
                return -EINVAL;
1513
1496
 
1514
1497
        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1515
1498
                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1567
1550
out_put:
1568
1551
        fput_light(sock->file, fput_needed);
1569
1552
out:
1570
 
        trace_socket_accept(fd, upeer_sockaddr, upeer_addrlen, flags, err);
1571
1553
        return err;
1572
1554
out_fd:
1573
1555
        fput(newfile);
1617
1599
out_put:
1618
1600
        fput_light(sock->file, fput_needed);
1619
1601
out:
1620
 
        trace_socket_connect(fd, uservaddr, addrlen, err);
1621
1602
        return err;
1622
1603
}
1623
1604
 
1649
1630
out_put:
1650
1631
        fput_light(sock->file, fput_needed);
1651
1632
out:
1652
 
        trace_socket_getsockname(fd, usockaddr, usockaddr_len, err);
1653
1633
        return err;
1654
1634
}
1655
1635
 
1670
1650
                err = security_socket_getpeername(sock);
1671
1651
                if (err) {
1672
1652
                        fput_light(sock->file, fput_needed);
1673
 
                        goto out;
 
1653
                        return err;
1674
1654
                }
1675
1655
 
1676
1656
                err =
1681
1661
                                                usockaddr_len);
1682
1662
                fput_light(sock->file, fput_needed);
1683
1663
        }
1684
 
out:
1685
 
        trace_socket_getpeername(fd, usockaddr, usockaddr_len, err);
1686
1664
        return err;
1687
1665
}
1688
1666
 
1813
1791
        int err, fput_needed;
1814
1792
        struct socket *sock;
1815
1793
 
1816
 
        if (optlen < 0) {
1817
 
                err = -EINVAL;
1818
 
                goto out;
1819
 
        }
 
1794
        if (optlen < 0)
 
1795
                return -EINVAL;
1820
1796
 
1821
1797
        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1822
1798
        if (sock != NULL) {
1835
1811
out_put:
1836
1812
                fput_light(sock->file, fput_needed);
1837
1813
        }
1838
 
out:
1839
 
        trace_socket_setsockopt(fd, level, optname, optval, optlen, err);
1840
1814
        return err;
1841
1815
}
1842
1816
 
1868
1842
out_put:
1869
1843
                fput_light(sock->file, fput_needed);
1870
1844
        }
1871
 
        trace_socket_getsockopt(fd, level, optname, optval, optlen, err);
1872
1845
        return err;
1873
1846
}
1874
1847
 
1888
1861
                        err = sock->ops->shutdown(sock, how);
1889
1862
                fput_light(sock->file, fput_needed);
1890
1863
        }
1891
 
        trace_socket_shutdown(fd, how, err);
1892
1864
        return err;
1893
1865
}
1894
1866
 
1899
1871
#define COMPAT_NAMELEN(msg)     COMPAT_MSG(msg, msg_namelen)
1900
1872
#define COMPAT_FLAGS(msg)       COMPAT_MSG(msg, msg_flags)
1901
1873
 
1902
 
/*
1903
 
 *      BSD sendmsg interface
1904
 
 */
1905
 
 
1906
 
SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
 
1874
static int __sys_sendmsg(struct socket *sock, struct msghdr __user *msg,
 
1875
                         struct msghdr *msg_sys, unsigned flags, int nosec)
1907
1876
{
1908
1877
        struct compat_msghdr __user *msg_compat =
1909
1878
            (struct compat_msghdr __user *)msg;
1910
 
        struct socket *sock;
1911
1879
        struct sockaddr_storage address;
1912
1880
        struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1913
1881
        unsigned char ctl[sizeof(struct cmsghdr) + 20]
1914
1882
            __attribute__ ((aligned(sizeof(__kernel_size_t))));
1915
1883
        /* 20 is size of ipv6_pktinfo */
1916
1884
        unsigned char *ctl_buf = ctl;
1917
 
        struct msghdr msg_sys;
1918
1885
        int err, ctl_len, iov_size, total_len;
1919
 
        int fput_needed;
1920
1886
 
1921
1887
        err = -EFAULT;
1922
1888
        if (MSG_CMSG_COMPAT & flags) {
1923
 
                if (get_compat_msghdr(&msg_sys, msg_compat))
 
1889
                if (get_compat_msghdr(msg_sys, msg_compat))
1924
1890
                        return -EFAULT;
1925
 
        } else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
 
1891
        } else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr)))
1926
1892
                return -EFAULT;
1927
1893
 
1928
 
        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1929
 
        if (!sock)
1930
 
                goto out;
1931
 
 
1932
1894
        /* do not move before msg_sys is valid */
1933
1895
        err = -EMSGSIZE;
1934
 
        if (msg_sys.msg_iovlen > UIO_MAXIOV)
1935
 
                goto out_put;
 
1896
        if (msg_sys->msg_iovlen > UIO_MAXIOV)
 
1897
                goto out;
1936
1898
 
1937
1899
        /* Check whether to allocate the iovec area */
1938
1900
        err = -ENOMEM;
1939
 
        iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1940
 
        if (msg_sys.msg_iovlen > UIO_FASTIOV) {
 
1901
        iov_size = msg_sys->msg_iovlen * sizeof(struct iovec);
 
1902
        if (msg_sys->msg_iovlen > UIO_FASTIOV) {
1941
1903
                iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1942
1904
                if (!iov)
1943
 
                        goto out_put;
 
1905
                        goto out;
1944
1906
        }
1945
1907
 
1946
1908
        /* This will also move the address data into kernel space */
1947
1909
        if (MSG_CMSG_COMPAT & flags) {
1948
 
                err = verify_compat_iovec(&msg_sys, iov,
 
1910
                err = verify_compat_iovec(msg_sys, iov,
1949
1911
                                          (struct sockaddr *)&address,
1950
1912
                                          VERIFY_READ);
1951
1913
        } else
1952
 
                err = verify_iovec(&msg_sys, iov,
 
1914
                err = verify_iovec(msg_sys, iov,
1953
1915
                                   (struct sockaddr *)&address,
1954
1916
                                   VERIFY_READ);
1955
1917
        if (err < 0)
1958
1920
 
1959
1921
        err = -ENOBUFS;
1960
1922
 
1961
 
        if (msg_sys.msg_controllen > INT_MAX)
 
1923
        if (msg_sys->msg_controllen > INT_MAX)
1962
1924
                goto out_freeiov;
1963
 
        ctl_len = msg_sys.msg_controllen;
 
1925
        ctl_len = msg_sys->msg_controllen;
1964
1926
        if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
1965
1927
                err =
1966
 
                    cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
 
1928
                    cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
1967
1929
                                                     sizeof(ctl));
1968
1930
                if (err)
1969
1931
                        goto out_freeiov;
1970
 
                ctl_buf = msg_sys.msg_control;
1971
 
                ctl_len = msg_sys.msg_controllen;
 
1932
                ctl_buf = msg_sys->msg_control;
 
1933
                ctl_len = msg_sys->msg_controllen;
1972
1934
        } else if (ctl_len) {
1973
1935
                if (ctl_len > sizeof(ctl)) {
1974
1936
                        ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
1977
1939
                }
1978
1940
                err = -EFAULT;
1979
1941
                /*
1980
 
                 * Careful! Before this, msg_sys.msg_control contains a user pointer.
 
1942
                 * Careful! Before this, msg_sys->msg_control contains a user pointer.
1981
1943
                 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1982
1944
                 * checking falls down on this.
1983
1945
                 */
1984
1946
                if (copy_from_user(ctl_buf,
1985
 
                                   (void __user __force *)msg_sys.msg_control,
 
1947
                                   (void __user __force *)msg_sys->msg_control,
1986
1948
                                   ctl_len))
1987
1949
                        goto out_freectl;
1988
 
                msg_sys.msg_control = ctl_buf;
 
1950
                msg_sys->msg_control = ctl_buf;
1989
1951
        }
1990
 
        msg_sys.msg_flags = flags;
 
1952
        msg_sys->msg_flags = flags;
1991
1953
 
1992
1954
        if (sock->file->f_flags & O_NONBLOCK)
1993
 
                msg_sys.msg_flags |= MSG_DONTWAIT;
1994
 
        err = sock_sendmsg(sock, &msg_sys, total_len);
 
1955
                msg_sys->msg_flags |= MSG_DONTWAIT;
 
1956
        err = (nosec ? sock_sendmsg_nosec : sock_sendmsg)(sock, msg_sys,
 
1957
                                                          total_len);
1995
1958
 
1996
1959
out_freectl:
1997
1960
        if (ctl_buf != ctl)
1999
1962
out_freeiov:
2000
1963
        if (iov != iovstack)
2001
1964
                sock_kfree_s(sock->sk, iov, iov_size);
 
1965
out:
 
1966
        return err;
 
1967
}
 
1968
 
 
1969
/*
 
1970
 *      BSD sendmsg interface
 
1971
 */
 
1972
 
 
1973
SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
 
1974
{
 
1975
        int fput_needed, err;
 
1976
        struct msghdr msg_sys;
 
1977
        struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed);
 
1978
 
 
1979
        if (!sock)
 
1980
                goto out;
 
1981
 
 
1982
        err = __sys_sendmsg(sock, msg, &msg_sys, flags, 0);
 
1983
 
 
1984
        fput_light(sock->file, fput_needed);
 
1985
out:
 
1986
        return err;
 
1987
}
 
1988
 
 
1989
/*
 
1990
 *      Linux sendmmsg interface
 
1991
 */
 
1992
 
 
1993
int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
 
1994
                   unsigned int flags)
 
1995
{
 
1996
        int fput_needed, err, datagrams;
 
1997
        struct socket *sock;
 
1998
        struct mmsghdr __user *entry;
 
1999
        struct compat_mmsghdr __user *compat_entry;
 
2000
        struct msghdr msg_sys;
 
2001
 
 
2002
        datagrams = 0;
 
2003
 
 
2004
        sock = sockfd_lookup_light(fd, &err, &fput_needed);
 
2005
        if (!sock)
 
2006
                return err;
 
2007
 
 
2008
        err = sock_error(sock->sk);
 
2009
        if (err)
 
2010
                goto out_put;
 
2011
 
 
2012
        entry = mmsg;
 
2013
        compat_entry = (struct compat_mmsghdr __user *)mmsg;
 
2014
 
 
2015
        while (datagrams < vlen) {
 
2016
                /*
 
2017
                 * No need to ask LSM for more than the first datagram.
 
2018
                 */
 
2019
                if (MSG_CMSG_COMPAT & flags) {
 
2020
                        err = __sys_sendmsg(sock, (struct msghdr __user *)compat_entry,
 
2021
                                            &msg_sys, flags, datagrams);
 
2022
                        if (err < 0)
 
2023
                                break;
 
2024
                        err = __put_user(err, &compat_entry->msg_len);
 
2025
                        ++compat_entry;
 
2026
                } else {
 
2027
                        err = __sys_sendmsg(sock, (struct msghdr __user *)entry,
 
2028
                                            &msg_sys, flags, datagrams);
 
2029
                        if (err < 0)
 
2030
                                break;
 
2031
                        err = put_user(err, &entry->msg_len);
 
2032
                        ++entry;
 
2033
                }
 
2034
 
 
2035
                if (err)
 
2036
                        break;
 
2037
                ++datagrams;
 
2038
        }
 
2039
 
2002
2040
out_put:
2003
2041
        fput_light(sock->file, fput_needed);
2004
 
out:
 
2042
 
 
2043
        if (err == 0)
 
2044
                return datagrams;
 
2045
 
 
2046
        if (datagrams != 0) {
 
2047
                /*
 
2048
                 * We may send less entries than requested (vlen) if the
 
2049
                 * sock is non blocking...
 
2050
                 */
 
2051
                if (err != -EAGAIN) {
 
2052
                        /*
 
2053
                         * ... or if sendmsg returns an error after we
 
2054
                         * send some datagrams, where we record the
 
2055
                         * error to return on the next call or if the
 
2056
                         * app asks about it using getsockopt(SO_ERROR).
 
2057
                         */
 
2058
                        sock->sk->sk_err = -err;
 
2059
                }
 
2060
 
 
2061
                return datagrams;
 
2062
        }
 
2063
 
2005
2064
        return err;
2006
2065
}
2007
2066
 
 
2067
SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
 
2068
                unsigned int, vlen, unsigned int, flags)
 
2069
{
 
2070
        return __sys_sendmmsg(fd, mmsg, vlen, flags);
 
2071
}
 
2072
 
2008
2073
static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg,
2009
2074
                         struct msghdr *msg_sys, unsigned flags, int nosec)
2010
2075
{
2158
2223
                 */
2159
2224
                if (MSG_CMSG_COMPAT & flags) {
2160
2225
                        err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
2161
 
                                            &msg_sys, flags, datagrams);
 
2226
                                            &msg_sys, flags & ~MSG_WAITFORONE,
 
2227
                                            datagrams);
2162
2228
                        if (err < 0)
2163
2229
                                break;
2164
2230
                        err = __put_user(err, &compat_entry->msg_len);
2165
2231
                        ++compat_entry;
2166
2232
                } else {
2167
2233
                        err = __sys_recvmsg(sock, (struct msghdr __user *)entry,
2168
 
                                            &msg_sys, flags, datagrams);
 
2234
                                            &msg_sys, flags & ~MSG_WAITFORONE,
 
2235
                                            datagrams);
2169
2236
                        if (err < 0)
2170
2237
                                break;
2171
2238
                        err = put_user(err, &entry->msg_len);
2250
2317
#ifdef __ARCH_WANT_SYS_SOCKETCALL
2251
2318
/* Argument list sizes for sys_socketcall */
2252
2319
#define AL(x) ((x) * sizeof(unsigned long))
2253
 
static const unsigned char nargs[20] = {
 
2320
static const unsigned char nargs[21] = {
2254
2321
        AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
2255
2322
        AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
2256
2323
        AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
2257
 
        AL(4), AL(5)
 
2324
        AL(4), AL(5), AL(4)
2258
2325
};
2259
2326
 
2260
2327
#undef AL
2274
2341
        int err;
2275
2342
        unsigned int len;
2276
2343
 
2277
 
        if (call < 1 || call > SYS_RECVMMSG)
 
2344
        if (call < 1 || call > SYS_SENDMMSG)
2278
2345
                return -EINVAL;
2279
2346
 
2280
2347
        len = nargs[call];
2290
2357
        a0 = a[0];
2291
2358
        a1 = a[1];
2292
2359
 
2293
 
        trace_socket_call(call, a0);
2294
 
 
2295
2360
        switch (call) {
2296
2361
        case SYS_SOCKET:
2297
2362
                err = sys_socket(a0, a1, a[2]);
2351
2416
        case SYS_SENDMSG:
2352
2417
                err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2353
2418
                break;
 
2419
        case SYS_SENDMMSG:
 
2420
                err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
 
2421
                break;
2354
2422
        case SYS_RECVMSG:
2355
2423
                err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2356
2424
                break;
2681
2749
                return -EFAULT;
2682
2750
 
2683
2751
        if (convert_in) {
2684
 
                /* We expect there to be holes between fs.m_u and
 
2752
                /* We expect there to be holes between fs.m_ext and
2685
2753
                 * fs.ring_cookie and at the end of fs, but nowhere else.
2686
2754
                 */
2687
 
                BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_u) +
2688
 
                             sizeof(compat_rxnfc->fs.m_u) !=
2689
 
                             offsetof(struct ethtool_rxnfc, fs.m_u) +
2690
 
                             sizeof(rxnfc->fs.m_u));
 
2755
                BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +
 
2756
                             sizeof(compat_rxnfc->fs.m_ext) !=
 
2757
                             offsetof(struct ethtool_rxnfc, fs.m_ext) +
 
2758
                             sizeof(rxnfc->fs.m_ext));
2691
2759
                BUILD_BUG_ON(
2692
2760
                        offsetof(struct compat_ethtool_rxnfc, fs.location) -
2693
2761
                        offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=
2695
2763
                        offsetof(struct ethtool_rxnfc, fs.ring_cookie));
2696
2764
 
2697
2765
                if (copy_in_user(rxnfc, compat_rxnfc,
2698
 
                                 (void *)(&rxnfc->fs.m_u + 1) -
 
2766
                                 (void *)(&rxnfc->fs.m_ext + 1) -
2699
2767
                                 (void *)rxnfc) ||
2700
2768
                    copy_in_user(&rxnfc->fs.ring_cookie,
2701
2769
                                 &compat_rxnfc->fs.ring_cookie,
2712
2780
 
2713
2781
        if (convert_out) {
2714
2782
                if (copy_in_user(compat_rxnfc, rxnfc,
2715
 
                                 (const void *)(&rxnfc->fs.m_u + 1) -
 
2783
                                 (const void *)(&rxnfc->fs.m_ext + 1) -
2716
2784
                                 (const void *)rxnfc) ||
2717
2785
                    copy_in_user(&compat_rxnfc->fs.ring_cookie,
2718
2786
                                 &rxnfc->fs.ring_cookie,
2786
2854
 
2787
2855
                old_fs = get_fs();
2788
2856
                set_fs(KERNEL_DS);
2789
 
                err = dev_ioctl(net, cmd, &kifr);
 
2857
                err = dev_ioctl(net, cmd,
 
2858
                                (struct ifreq __user __force *) &kifr);
2790
2859
                set_fs(old_fs);
2791
2860
 
2792
2861
                return err;
2895
2964
 
2896
2965
        old_fs = get_fs();
2897
2966
        set_fs(KERNEL_DS);
2898
 
        err = dev_ioctl(net, cmd, (void __user *)&ifr);
 
2967
        err = dev_ioctl(net, cmd, (void  __user __force *)&ifr);
2899
2968
        set_fs(old_fs);
2900
2969
 
2901
2970
        if (cmd == SIOCGIFMAP && !err) {
3000
3069
                ret |= __get_user(rtdev, &(ur4->rt_dev));
3001
3070
                if (rtdev) {
3002
3071
                        ret |= copy_from_user(devname, compat_ptr(rtdev), 15);
3003
 
                        r4.rt_dev = devname; devname[15] = 0;
 
3072
                        r4.rt_dev = (char __user __force *)devname;
 
3073
                        devname[15] = 0;
3004
3074
                } else
3005
3075
                        r4.rt_dev = NULL;
3006
3076
 
3022
3092
 
3023
3093
/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
3024
3094
 * for some operations; this forces use of the newer bridge-utils that
3025
 
 * use compatiable ioctls
 
3095
 * use compatible ioctls
3026
3096
 */
3027
3097
static int old_bridge_ioctl(compat_ulong_t __user *argp)
3028
3098
{