Merge branch 'linus' into perfcounters/core-v2

Merge reason: we have gathered quite a few conflicts, need to merge upstream

Conflicts:
	arch/powerpc/kernel/Makefile
	arch/x86/ia32/ia32entry.S
	arch/x86/include/asm/hardirq.h
	arch/x86/include/asm/unistd_32.h
	arch/x86/include/asm/unistd_64.h
	arch/x86/kernel/cpu/common.c
	arch/x86/kernel/irq.c
	arch/x86/kernel/syscall_table_32.S
	arch/x86/mm/iomap_32.c
	include/linux/sched.h
	kernel/Makefile

Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 100 insertions, 116 deletions

diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index ff0a8f88de04..5fb3a8c9792e 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -3069,9 +3069,6 @@ static int sctp_setsockopt_maxburst(struct sock *sk,
         int val;
         int assoc_id = 0;
 
-        if (optlen < sizeof(int))
-                return -EINVAL;
-
         if (optlen == sizeof(int)) {
                 printk(KERN_WARNING
                    "SCTP: Use of int in max_burst socket option deprecated\n");
@@ -3939,7 +3936,6 @@ SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,
 {
         struct sock *sk = asoc->base.sk;
         struct socket *sock;
-        struct inet_sock *inetsk;
         struct sctp_af *af;
         int err = 0;
 
@@ -3954,18 +3950,18 @@ SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,
         if (err < 0)
                 return err;
 
-        /* Populate the fields of the newsk from the oldsk and migrate the
-         * asoc to the newsk.
-         */
-        sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
+        sctp_copy_sock(sock->sk, sk, asoc);
 
         /* Make peeled-off sockets more like 1-1 accepted sockets.
          * Set the daddr and initialize id to something more random
          */
         af = sctp_get_af_specific(asoc->peer.primary_addr.sa.sa_family);
         af->to_sk_daddr(&asoc->peer.primary_addr, sk);
-        inetsk = inet_sk(sock->sk);
-        inetsk->id = asoc->next_tsn ^ jiffies;
+
+        /* Populate the fields of the newsk from the oldsk and migrate the
+         * asoc to the newsk.
+         */
+        sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
 
         *sockp = sock;
 
@@ -5284,16 +5280,14 @@ static int sctp_getsockopt_maxburst(struct sock *sk, int len,
         struct sctp_sock *sp;
         struct sctp_association *asoc;
 
-        if (len < sizeof(int))
-                return -EINVAL;
-
         if (len == sizeof(int)) {
                 printk(KERN_WARNING
                    "SCTP: Use of int in max_burst socket option deprecated\n");
                 printk(KERN_WARNING
                    "SCTP: Use struct sctp_assoc_value instead\n");
                 params.assoc_id = 0;
-        } else if (len == sizeof (struct sctp_assoc_value)) {
+        } else if (len >= sizeof(struct sctp_assoc_value)) {
+                len = sizeof(struct sctp_assoc_value);
                 if (copy_from_user(&params, optval, len))
                         return -EFAULT;
         } else
@@ -5849,37 +5843,28 @@ static int sctp_get_port(struct sock *sk, unsigned short snum)
 }
 
 /*
- * 3.1.3 listen() - UDP Style Syntax
- *
- *   By default, new associations are not accepted for UDP style sockets.
- *   An application uses listen() to mark a socket as being able to
- *   accept new associations.
+ *  Move a socket to LISTENING state.
  */
-SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
+SCTP_STATIC int sctp_listen_start(struct sock *sk, int backlog)
 {
         struct sctp_sock *sp = sctp_sk(sk);
         struct sctp_endpoint *ep = sp->ep;
+        struct crypto_hash *tfm = NULL;
 
-        /* Only UDP style sockets that are not peeled off are allowed to
-         * listen().
-         */
-        if (!sctp_style(sk, UDP))
-                return -EINVAL;
-
-        /* If backlog is zero, disable listening. */
-        if (!backlog) {
-                if (sctp_sstate(sk, CLOSED))
-                        return 0;
-
-                sctp_unhash_endpoint(ep);
-                sk->sk_state = SCTP_SS_CLOSED;
-                return 0;
+        /* Allocate HMAC for generating cookie. */
+        if (!sctp_sk(sk)->hmac && sctp_hmac_alg) {
+                tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC);
+                if (IS_ERR(tfm)) {
+                        if (net_ratelimit()) {
+                                printk(KERN_INFO
+                                       "SCTP: failed to load transform for %s: %ld\n",
+                                        sctp_hmac_alg, PTR_ERR(tfm));
+                        }
+                        return -ENOSYS;
+                }
+                sctp_sk(sk)->hmac = tfm;
         }
 
-        /* Return if we are already listening. */
-        if (sctp_sstate(sk, LISTENING))
-                return 0;
-
         /*
          * If a bind() or sctp_bindx() is not called prior to a listen()
          * call that allows new associations to be accepted, the system
@@ -5890,7 +5875,6 @@ SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
          * extensions draft, but follows the practice as seen in TCP
          * sockets.
          *
-         * Additionally, turn off fastreuse flag since we are not listening
          */
         sk->sk_state = SCTP_SS_LISTENING;
         if (!ep->base.bind_addr.port) {
@@ -5901,113 +5885,71 @@ SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
                         sk->sk_state = SCTP_SS_CLOSED;
                         return -EADDRINUSE;
                 }
-                sctp_sk(sk)->bind_hash->fastreuse = 0;
         }
 
-        sctp_hash_endpoint(ep);
-        return 0;
-}
-
-/*
- * 4.1.3 listen() - TCP Style Syntax
- *
- *   Applications uses listen() to ready the SCTP endpoint for accepting
- *   inbound associations.
- */
-SCTP_STATIC int sctp_stream_listen(struct sock *sk, int backlog)
-{
-        struct sctp_sock *sp = sctp_sk(sk);
-        struct sctp_endpoint *ep = sp->ep;
-
-        /* If backlog is zero, disable listening. */
-        if (!backlog) {
-                if (sctp_sstate(sk, CLOSED))
-                        return 0;
-
-                sctp_unhash_endpoint(ep);
-                sk->sk_state = SCTP_SS_CLOSED;
-                return 0;
-        }
-
-        if (sctp_sstate(sk, LISTENING))
-                return 0;
-
-        /*
-         * If a bind() or sctp_bindx() is not called prior to a listen()
-         * call that allows new associations to be accepted, the system
-         * picks an ephemeral port and will choose an address set equivalent
-         * to binding with a wildcard address.
-         *
-         * This is not currently spelled out in the SCTP sockets
-         * extensions draft, but follows the practice as seen in TCP
-         * sockets.
-         */
-        sk->sk_state = SCTP_SS_LISTENING;
-        if (!ep->base.bind_addr.port) {
-                if (sctp_autobind(sk))
-                        return -EAGAIN;
-        } else
-                sctp_sk(sk)->bind_hash->fastreuse = 0;
-
         sk->sk_max_ack_backlog = backlog;
         sctp_hash_endpoint(ep);
         return 0;
 }
 
 /*
+ * 4.1.3 / 5.1.3 listen()
+ *
+ *   By default, new associations are not accepted for UDP style sockets.
+ *   An application uses listen() to mark a socket as being able to
+ *   accept new associations.
+ *
+ *   On TCP style sockets, applications use listen() to ready the SCTP
+ *   endpoint for accepting inbound associations.
+ *
+ *   On both types of endpoints a backlog of '0' disables listening.
+ *
  *  Move a socket to LISTENING state.
  */
 int sctp_inet_listen(struct socket *sock, int backlog)
 {
         struct sock *sk = sock->sk;
-        struct crypto_hash *tfm = NULL;
+        struct sctp_endpoint *ep = sctp_sk(sk)->ep;
         int err = -EINVAL;
 
         if (unlikely(backlog < 0))
-                goto out;
+                return err;
 
         sctp_lock_sock(sk);
 
+        /* Peeled-off sockets are not allowed to listen().  */
+        if (sctp_style(sk, UDP_HIGH_BANDWIDTH))
+                goto out;
+
         if (sock->state != SS_UNCONNECTED)
                 goto out;
 
-        /* Allocate HMAC for generating cookie. */
-        if (!sctp_sk(sk)->hmac && sctp_hmac_alg) {
-                tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(tfm)) {
-                        if (net_ratelimit()) {
-                                printk(KERN_INFO
-                                       "SCTP: failed to load transform for %s: %ld\n",
-                                        sctp_hmac_alg, PTR_ERR(tfm));
-                        }
-                        err = -ENOSYS;
+        /* If backlog is zero, disable listening. */
+        if (!backlog) {
+                if (sctp_sstate(sk, CLOSED))
                         goto out;
-                }
-        }
 
-        switch (sock->type) {
-        case SOCK_SEQPACKET:
-                err = sctp_seqpacket_listen(sk, backlog);
-                break;
-        case SOCK_STREAM:
-                err = sctp_stream_listen(sk, backlog);
-                break;
-        default:
-                break;
+                err = 0;
+                sctp_unhash_endpoint(ep);
+                sk->sk_state = SCTP_SS_CLOSED;
+                if (sk->sk_reuse)
+                        sctp_sk(sk)->bind_hash->fastreuse = 1;
+                goto out;
         }
 
-        if (err)
-                goto cleanup;
+        /* If we are already listening, just update the backlog */
+        if (sctp_sstate(sk, LISTENING))
+                sk->sk_max_ack_backlog = backlog;
+        else {
+                err = sctp_listen_start(sk, backlog);
+                if (err)
+                        goto out;
+        }
 
-        /* Store away the transform reference. */
-        if (!sctp_sk(sk)->hmac)
-                sctp_sk(sk)->hmac = tfm;
+        err = 0;
 out:
         sctp_release_sock(sk);
         return err;
-cleanup:
-        crypto_free_hash(tfm);
-        goto out;
 }
 
 /*
@@ -6700,6 +6642,48 @@ done:
         sctp_skb_set_owner_r(skb, sk);
 }
 
+void sctp_copy_sock(struct sock *newsk, struct sock *sk,
+                    struct sctp_association *asoc)
+{
+        struct inet_sock *inet = inet_sk(sk);
+        struct inet_sock *newinet = inet_sk(newsk);
+
+        newsk->sk_type = sk->sk_type;
+        newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
+        newsk->sk_flags = sk->sk_flags;
+        newsk->sk_no_check = sk->sk_no_check;
+        newsk->sk_reuse = sk->sk_reuse;
+
+        newsk->sk_shutdown = sk->sk_shutdown;
+        newsk->sk_destruct = inet_sock_destruct;
+        newsk->sk_family = sk->sk_family;
+        newsk->sk_protocol = IPPROTO_SCTP;
+        newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
+        newsk->sk_sndbuf = sk->sk_sndbuf;
+        newsk->sk_rcvbuf = sk->sk_rcvbuf;
+        newsk->sk_lingertime = sk->sk_lingertime;
+        newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
+        newsk->sk_sndtimeo = sk->sk_sndtimeo;
+
+        newinet = inet_sk(newsk);
+
+        /* Initialize sk's sport, dport, rcv_saddr and daddr for
+         * getsockname() and getpeername()
+         */
+        newinet->sport = inet->sport;
+        newinet->saddr = inet->saddr;
+        newinet->rcv_saddr = inet->rcv_saddr;
+        newinet->dport = htons(asoc->peer.port);
+        newinet->pmtudisc = inet->pmtudisc;
+        newinet->id = asoc->next_tsn ^ jiffies;
+
+        newinet->uc_ttl = inet->uc_ttl;
+        newinet->mc_loop = 1;
+        newinet->mc_ttl = 1;
+        newinet->mc_index = 0;
+        newinet->mc_list = NULL;
+}
+
 /* Populate the fields of the newsk from the oldsk and migrate the assoc
  * and its messages to the newsk.
  */