25 files changed, 281 insertions, 190 deletions
diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index dd35641835f4..2a4efcea3423 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -48,6 +48,7 @@
 #include <linux/smp_lock.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/net.h>
 #include <linux/irda.h>
@@ -61,7 +62,7 @@
 #include <net/irda/af_irda.h>
-static int irda_create(struct net *net, struct socket *sock, int protocol);
+static int irda_create(struct net *net, struct socket *sock, int protocol, int kern);
 static const struct proto_ops irda_stream_ops;
 static const struct proto_ops irda_seqpacket_ops;
@@ -714,11 +715,14 @@ static int irda_getname(struct socket *sock, struct sockaddr *uaddr,
        struct sockaddr_irda saddr;
        struct sock *sk = sock->sk;
        struct irda_sock *self = irda_sk(sk);
+        int err;
+        lock_kernel();
        memset(&saddr, 0, sizeof(saddr));
        if (peer) {
+                err  = -ENOTCONN;
                if (sk->sk_state != TCP_ESTABLISHED)
-                        return -ENOTCONN;
+                        goto out;
                saddr.sir_family = AF_IRDA;
                saddr.sir_lsap_sel = self->dtsap_sel;
@@ -735,8 +739,10 @@ static int irda_getname(struct socket *sock, struct sockaddr *uaddr,
        /* uaddr_len come to us uninitialised */
        *uaddr_len = sizeof (struct sockaddr_irda);
        memcpy(uaddr, &saddr, *uaddr_len);
+        err = 0;
-        return 0;
+out:
+        unlock_kernel();
+        return err;
 }
 /*
@@ -748,21 +754,25 @@ static int irda_getname(struct socket *sock, struct sockaddr *uaddr,
 static int irda_listen(struct socket *sock, int backlog)
 {
        struct sock *sk = sock->sk;
+        int err = -EOPNOTSUPP;
        IRDA_DEBUG(2, "%s()\n", __func__);
+        lock_kernel();
        if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) &&
            (sk->sk_type != SOCK_DGRAM))
-                return -EOPNOTSUPP;
+                goto out;
        if (sk->sk_state != TCP_LISTEN) {
                sk->sk_max_ack_backlog = backlog;
                sk->sk_state           = TCP_LISTEN;
-                return 0;
+                err = 0;
        }
+out:
+        unlock_kernel();
-        return -EOPNOTSUPP;
+        return err;
 }
 /*
@@ -783,36 +793,40 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
        if (addr_len != sizeof(struct sockaddr_irda))
                return -EINVAL;
+        lock_kernel();
 #ifdef CONFIG_IRDA_ULTRA
        /* Special care for Ultra sockets */
        if ((sk->sk_type == SOCK_DGRAM) &&
            (sk->sk_protocol == IRDAPROTO_ULTRA)) {
                self->pid = addr->sir_lsap_sel;
+                err = -EOPNOTSUPP;
                if (self->pid & 0x80) {
                        IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__);
-                        return -EOPNOTSUPP;
+                        goto out;
                }
                err = irda_open_lsap(self, self->pid);
                if (err < 0)
-                        return err;
+                        goto out;
                /* Pretend we are connected */
                sock->state = SS_CONNECTED;
                sk->sk_state   = TCP_ESTABLISHED;
+                err = 0;
-                return 0;
+                goto out;
        }
 #endif /* CONFIG_IRDA_ULTRA */
        self->ias_obj = irias_new_object(addr->sir_name, jiffies);
+        err = -ENOMEM;
        if (self->ias_obj == NULL)
-                return -ENOMEM;
+                goto out;
        err = irda_open_tsap(self, addr->sir_lsap_sel, addr->sir_name);
        if (err < 0) {
                kfree(self->ias_obj->name);
                kfree(self->ias_obj);
-                return err;
+                goto out;
        }
        /*  Register with LM-IAS */
@@ -820,7 +834,10 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                                 self->stsap_sel, IAS_KERNEL_ATTR);
        irias_insert_object(self->ias_obj);
-        return 0;
+        err = 0;
+out:
+        unlock_kernel();
+        return err;
 }
 /*
@@ -839,22 +856,26 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
        IRDA_DEBUG(2, "%s()\n", __func__);
-        err = irda_create(sock_net(sk), newsock, sk->sk_protocol);
+        lock_kernel();
+        err = irda_create(sock_net(sk), newsock, sk->sk_protocol, 0);
        if (err)
-                return err;
+                goto out;
+        err = -EINVAL;
        if (sock->state != SS_UNCONNECTED)
-                return -EINVAL;
+                goto out;
        if ((sk = sock->sk) == NULL)
-                return -EINVAL;
+                goto out;
+        err = -EOPNOTSUPP;
        if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) &&
            (sk->sk_type != SOCK_DGRAM))
-                return -EOPNOTSUPP;
+                goto out;
+        err = -EINVAL;
        if (sk->sk_state != TCP_LISTEN)
-                return -EINVAL;
+                goto out;
        /*
         *      The read queue this time is holding sockets ready to use
@@ -875,18 +896,20 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
                        break;
                /* Non blocking operation */
+                err = -EWOULDBLOCK;
                if (flags & O_NONBLOCK)
-                        return -EWOULDBLOCK;
+                        goto out;
                err = wait_event_interruptible(*(sk->sk_sleep),
                                        skb_peek(&sk->sk_receive_queue));
                if (err)
-                        return err;
+                        goto out;
        }
        newsk = newsock->sk;
+        err = -EIO;
        if (newsk == NULL)
-                return -EIO;
+                goto out;
        newsk->sk_state = TCP_ESTABLISHED;
@@ -894,10 +917,11 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
        /* Now attach up the new socket */
        new->tsap = irttp_dup(self->tsap, new);
+        err = -EPERM; /* value does not seem to make sense. -arnd */
        if (!new->tsap) {
                IRDA_DEBUG(0, "%s(), dup failed!\n", __func__);
                kfree_skb(skb);
-                return -1;
+                goto out;
        }
        new->stsap_sel = new->tsap->stsap_sel;
@@ -921,8 +945,10 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
        newsock->state = SS_CONNECTED;
        irda_connect_response(new);
+        err = 0;
-        return 0;
+out:
+        unlock_kernel();
+        return err;
 }
 /*
@@ -955,28 +981,34 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
        IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
+        lock_kernel();
        /* Don't allow connect for Ultra sockets */
+        err = -ESOCKTNOSUPPORT;
        if ((sk->sk_type == SOCK_DGRAM) && (sk->sk_protocol == IRDAPROTO_ULTRA))
-                return -ESOCKTNOSUPPORT;
+                goto out;
        if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
                sock->state = SS_CONNECTED;
-                return 0;   /* Connect completed during a ERESTARTSYS event */
+                err = 0;
+                goto out;   /* Connect completed during a ERESTARTSYS event */
        }
        if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
                sock->state = SS_UNCONNECTED;
-                return -ECONNREFUSED;
+                err = -ECONNREFUSED;
+                goto out;
        }
+        err = -EISCONN;      /* No reconnect on a seqpacket socket */
        if (sk->sk_state == TCP_ESTABLISHED)
-                return -EISCONN;      /* No reconnect on a seqpacket socket */
+                goto out;
        sk->sk_state   = TCP_CLOSE;
        sock->state = SS_UNCONNECTED;
+        err = -EINVAL;
        if (addr_len != sizeof(struct sockaddr_irda))
-                return -EINVAL;
+                goto out;
        /* Check if user supplied any destination device address */
        if ((!addr->sir_addr) || (addr->sir_addr == DEV_ADDR_ANY)) {
@@ -984,7 +1016,7 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
                err = irda_discover_daddr_and_lsap_sel(self, addr->sir_name);
                if (err) {
                        IRDA_DEBUG(0, "%s(), auto-connect failed!\n", __func__);
-                        return err;
+                        goto out;
                }
        } else {
                /* Use the one provided by the user */
@@ -1000,7 +1032,7 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
                        err = irda_find_lsap_sel(self, addr->sir_name);
                        if (err) {
                                IRDA_DEBUG(0, "%s(), connect failed!\n", __func__);
-                                return err;
+                                goto out;
                        }
                } else {
                        /* Directly connect to the remote LSAP
@@ -1025,29 +1057,35 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
                                    self->max_sdu_size_rx, NULL);
        if (err) {
                IRDA_DEBUG(0, "%s(), connect failed!\n", __func__);
-                return err;
+                goto out;
        }
        /* Now the loop */
+        err = -EINPROGRESS;
        if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
-                return -EINPROGRESS;
+                goto out;
+        err = -ERESTARTSYS;
        if (wait_event_interruptible(*(sk->sk_sleep),
                                     (sk->sk_state != TCP_SYN_SENT)))
-                return -ERESTARTSYS;
+                goto out;
        if (sk->sk_state != TCP_ESTABLISHED) {
                sock->state = SS_UNCONNECTED;
                err = sock_error(sk);
-                return err? err : -ECONNRESET;
+                if (!err)
+                        err = -ECONNRESET;
+                goto out;
        }
        sock->state = SS_CONNECTED;
        /* At this point, IrLMP has assigned our source address */
        self->saddr = irttp_get_saddr(self->tsap);
+        err = 0;
-        return 0;
+out:
+        unlock_kernel();
+        return err;
 }
 static struct proto irda_proto = {
@@ -1062,7 +1100,8 @@ static struct proto irda_proto = {
 *    Create IrDA socket
 *
 */
-static int irda_create(struct net *net, struct socket *sock, int protocol)
+static int irda_create(struct net *net, struct socket *sock, int protocol,
+                       int kern)
 {
        struct sock *sk;
        struct irda_sock *self;
@@ -1192,6 +1231,7 @@ static int irda_release(struct socket *sock)
        if (sk == NULL)
                return 0;
+        lock_kernel();
        lock_sock(sk);
        sk->sk_state       = TCP_CLOSE;
        sk->sk_shutdown   |= SEND_SHUTDOWN;
@@ -1210,6 +1250,7 @@ static int irda_release(struct socket *sock)
        /* Destroy networking socket if we are the last reference on it,
         * i.e. if(sk->sk_refcnt == 0) -> sk_free(sk) */
        sock_put(sk);
+        unlock_kernel();
        /* Notes on socket locking and deallocation... - Jean II
         * In theory we should put pairs of sock_hold() / sock_put() to
@@ -1257,28 +1298,37 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
        IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
+        lock_kernel();
        /* Note : socket.c set MSG_EOR on SEQPACKET sockets */
        if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_EOR | MSG_CMSG_COMPAT |
-                               MSG_NOSIGNAL))
+                               MSG_NOSIGNAL)) {
-                return -EINVAL;
+                err = -EINVAL;
+                goto out;
+        }
        if (sk->sk_shutdown & SEND_SHUTDOWN)
                goto out_err;
-        if (sk->sk_state != TCP_ESTABLISHED)
+        if (sk->sk_state != TCP_ESTABLISHED) {
-                return -ENOTCONN;
+                err = -ENOTCONN;
+                goto out;
+        }
        self = irda_sk(sk);
        /* Check if IrTTP is wants us to slow down */
        if (wait_event_interruptible(*(sk->sk_sleep),
-            (self->tx_flow != FLOW_STOP  ||  sk->sk_state != TCP_ESTABLISHED)))
+            (self->tx_flow != FLOW_STOP  ||  sk->sk_state != TCP_ESTABLISHED))) {
-                return -ERESTARTSYS;
+                err = -ERESTARTSYS;
+                goto out;
+        }
        /* Check if we are still connected */
-        if (sk->sk_state != TCP_ESTABLISHED)
+        if (sk->sk_state != TCP_ESTABLISHED) {
-                return -ENOTCONN;
+                err = -ENOTCONN;
+                goto out;
+        }
        /* Check that we don't send out too big frames */
        if (len > self->max_data_size) {
@@ -1310,11 +1360,16 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
                IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
                goto out_err;
        }
+        unlock_kernel();
        /* Tell client how much data we actually sent */
        return len;
- out_err:
+out_err:
-        return sk_stream_error(sk, msg->msg_flags, err);
+        err = sk_stream_error(sk, msg->msg_flags, err);
+out:
+        unlock_kernel();
+        return err;
 }
@@ -1335,13 +1390,14 @@ static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
        IRDA_DEBUG(4, "%s()\n", __func__);
+        lock_kernel();
        if ((err = sock_error(sk)) < 0)
-                return err;
+                goto out;
        skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
                                flags & MSG_DONTWAIT, &err);
        if (!skb)
-                return err;
+                goto out;
        skb_reset_transport_header(skb);
        copied = skb->len;
@@ -1369,8 +1425,12 @@ static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
                        irttp_flow_request(self->tsap, FLOW_START);
                }
        }
+        unlock_kernel();
        return copied;
+out:
+        unlock_kernel();
+        return err;
 }
 /*
@@ -1388,15 +1448,19 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
        IRDA_DEBUG(3, "%s()\n", __func__);
+        lock_kernel();
        if ((err = sock_error(sk)) < 0)
-                return err;
+                goto out;
+        err = -EINVAL;
        if (sock->flags & __SO_ACCEPTCON)
-                return(-EINVAL);
+                goto out;
+        err =-EOPNOTSUPP;
        if (flags & MSG_OOB)
-                return -EOPNOTSUPP;
+                goto out;
+        err = 0;
        target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
        timeo = sock_rcvtimeo(sk, noblock);
@@ -1408,7 +1472,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                if (skb == NULL) {
                        DEFINE_WAIT(wait);
-                        int ret = 0;
+                        err = 0;
                        if (copied >= target)
                                break;
@@ -1418,25 +1482,25 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                        /*
                         *      POSIX 1003.1g mandates this order.
                         */
-                        ret = sock_error(sk);
+                        err = sock_error(sk);
-                        if (ret)
+                        if (err)
                                ;
                        else if (sk->sk_shutdown & RCV_SHUTDOWN)
                                ;
                        else if (noblock)
-                                ret = -EAGAIN;
+                                err = -EAGAIN;
                        else if (signal_pending(current))
-                                ret = sock_intr_errno(timeo);
+                                err = sock_intr_errno(timeo);
                        else if (sk->sk_state != TCP_ESTABLISHED)
-                                ret = -ENOTCONN;
+                                err = -ENOTCONN;
                        else if (skb_peek(&sk->sk_receive_queue) == NULL)
                                /* Wait process until data arrives */
                                schedule();
                        finish_wait(sk->sk_sleep, &wait);
-                        if (ret)
+                        if (err)
-                                return ret;
+                                goto out;
                        if (sk->sk_shutdown & RCV_SHUTDOWN)
                                break;
@@ -1489,7 +1553,9 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                }
        }
-        return copied;
+out:
+        unlock_kernel();
+        return err ? : copied;
 }
 /*
@@ -1507,18 +1573,23 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
        struct sk_buff *skb;
        int err;
+        lock_kernel();
        IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
+        err = -EINVAL;
        if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
-                return -EINVAL;
+                goto out;
        if (sk->sk_shutdown & SEND_SHUTDOWN) {
                send_sig(SIGPIPE, current, 0);
-                return -EPIPE;
+                err = -EPIPE;
+                goto out;
        }
+        err = -ENOTCONN;
        if (sk->sk_state != TCP_ESTABLISHED)
-                return -ENOTCONN;
+                goto out;
        self = irda_sk(sk);
@@ -1535,8 +1606,9 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
        skb = sock_alloc_send_skb(sk, len + self->max_header_size,
                                  msg->msg_flags & MSG_DONTWAIT, &err);
+        err = -ENOBUFS;
        if (!skb)
-                return -ENOBUFS;
+                goto out;
        skb_reserve(skb, self->max_header_size);
        skb_reset_transport_header(skb);
@@ -1546,7 +1618,7 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
        if (err) {
                kfree_skb(skb);
-                return err;
+                goto out;
        }
        /*
@@ -1556,9 +1628,13 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
        err = irttp_udata_request(self->tsap, skb);
        if (err) {
                IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
-                return err;
+                goto out;
        }
+        unlock_kernel();
        return len;
+out:
+        unlock_kernel();
+        return err;
 }
 /*
@@ -1580,12 +1656,15 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
        IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
+        lock_kernel();
+        err = -EINVAL;
        if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
-                return -EINVAL;
+                goto out;
+        err = -EPIPE;
        if (sk->sk_shutdown & SEND_SHUTDOWN) {
                send_sig(SIGPIPE, current, 0);
-                return -EPIPE;
+                goto out;
        }
        self = irda_sk(sk);
@@ -1593,16 +1672,18 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
        /* Check if an address was specified with sendto. Jean II */
        if (msg->msg_name) {
                struct sockaddr_irda *addr = (struct sockaddr_irda *) msg->msg_name;
+                err = -EINVAL;
                /* Check address, extract pid. Jean II */
                if (msg->msg_namelen < sizeof(*addr))
-                        return -EINVAL;
+                        goto out;
                if (addr->sir_family != AF_IRDA)
-                        return -EINVAL;
+                        goto out;
                pid = addr->sir_lsap_sel;
                if (pid & 0x80) {
                        IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__);
-                        return -EOPNOTSUPP;
+                        err = -EOPNOTSUPP;
+                        goto out;
                }
        } else {
                /* Check that the socket is properly bound to an Ultra
@@ -1611,7 +1692,8 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
                    (sk->sk_state != TCP_ESTABLISHED)) {
                        IRDA_DEBUG(0, "%s(), socket not bound to Ultra PID.\n",
                                   __func__);
-                        return -ENOTCONN;
+                        err = -ENOTCONN;
+                        goto out;
                }
                /* Use PID from socket */
                bound = 1;
@@ -1630,8 +1712,9 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
        skb = sock_alloc_send_skb(sk, len + self->max_header_size,
                                  msg->msg_flags & MSG_DONTWAIT, &err);
+        err = -ENOBUFS;
        if (!skb)
-                return -ENOBUFS;
+                goto out;
        skb_reserve(skb, self->max_header_size);
        skb_reset_transport_header(skb);
@@ -1641,16 +1724,16 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
        if (err) {
                kfree_skb(skb);
-                return err;
+                goto out;
        }
        err = irlmp_connless_data_request((bound ? self->lsap : NULL),
                                          skb, pid);
-        if (err) {
+        if (err)
                IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
-                return err;
+out:
-        }
+        unlock_kernel();
-        return len;
+        return err ? : len;
 }
 #endif /* CONFIG_IRDA_ULTRA */
@@ -1664,6 +1747,8 @@ static int irda_shutdown(struct socket *sock, int how)
        IRDA_DEBUG(1, "%s(%p)\n", __func__, self);
+        lock_kernel();
        sk->sk_state       = TCP_CLOSE;
        sk->sk_shutdown   |= SEND_SHUTDOWN;
        sk->sk_state_change(sk);
@@ -1684,6 +1769,8 @@ static int irda_shutdown(struct socket *sock, int how)
        self->daddr = DEV_ADDR_ANY;     /* Until we get re-connected */
        self->saddr = 0x0;              /* so IrLMP assign us any link */
+        unlock_kernel();
        return 0;
 }
@@ -1699,6 +1786,7 @@ static unsigned int irda_poll(struct file * file, struct socket *sock,
        IRDA_DEBUG(4, "%s()\n", __func__);
+        lock_kernel();
        poll_wait(file, sk->sk_sleep, wait);
        mask = 0;
@@ -1746,18 +1834,34 @@ static unsigned int irda_poll(struct file * file, struct socket *sock,
        default:
                break;
        }
+        unlock_kernel();
        return mask;
 }
+static unsigned int irda_datagram_poll(struct file *file, struct socket *sock,
+                           poll_table *wait)
+{
+        int err;
+        lock_kernel();
+        err = datagram_poll(file, sock, wait);
+        unlock_kernel();
+        return err;
+}
 /*
 * Function irda_ioctl (sock, cmd, arg)
 */
 static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
        struct sock *sk = sock->sk;
+        int err;
        IRDA_DEBUG(4, "%s(), cmd=%#x\n", __func__, cmd);
+        lock_kernel();
+        err = -EINVAL;
        switch (cmd) {
        case TIOCOUTQ: {
                long amount;
@@ -1765,9 +1869,8 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
                if (amount < 0)
                        amount = 0;
-                if (put_user(amount, (unsigned int __user *)arg))
+                err = put_user(amount, (unsigned int __user *)arg);
-                        return -EFAULT;
+                break;
-                return 0;
        }
        case TIOCINQ: {
@@ -1776,15 +1879,14 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                /* These two are safe on a single CPU system as only user tasks fiddle here */
                if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
                        amount = skb->len;
-                if (put_user(amount, (unsigned int __user *)arg))
+                err = put_user(amount, (unsigned int __user *)arg);
-                        return -EFAULT;
+                break;
-                return 0;
        }
        case SIOCGSTAMP:
                if (sk != NULL)
-                        return sock_get_timestamp(sk, (struct timeval __user *)arg);
+                        err = sock_get_timestamp(sk, (struct timeval __user *)arg);
-                return -EINVAL;
+                break;
        case SIOCGIFADDR:
        case SIOCSIFADDR:
@@ -1796,14 +1898,14 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
        case SIOCSIFNETMASK:
        case SIOCGIFMETRIC:
        case SIOCSIFMETRIC:
-                return -EINVAL;
+                break;
        default:
                IRDA_DEBUG(1, "%s(), doing device ioctl!\n", __func__);
-                return -ENOIOCTLCMD;
+                err = -ENOIOCTLCMD;
        }
+        unlock_kernel();
-        /*NOTREACHED*/
+        return err;
-        return 0;
 }
 #ifdef CONFIG_COMPAT
@@ -1825,7 +1927,7 @@ static int irda_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned lon
 *    Set some options for the socket
 *
 */
-static int irda_setsockopt(struct socket *sock, int level, int optname,
+static int __irda_setsockopt(struct socket *sock, int level, int optname,
                           char __user *optval, unsigned int optlen)
 {
        struct sock *sk = sock->sk;
@@ -2083,6 +2185,18 @@ static int irda_setsockopt(struct socket *sock, int level, int optname,
        return 0;
 }
+static int irda_setsockopt(struct socket *sock, int level, int optname,
+                           char __user *optval, unsigned int optlen)
+{
+        int err;
+        lock_kernel();
+        err = __irda_setsockopt(sock, level, optname, optval, optlen);
+        unlock_kernel();
+        return err;
+}
 /*
 * Function irda_extract_ias_value(ias_opt, ias_value)
 *
@@ -2135,7 +2249,7 @@ static int irda_extract_ias_value(struct irda_ias_set *ias_opt,
 /*
 * Function irda_getsockopt (sock, level, optname, optval, optlen)
 */
-static int irda_getsockopt(struct socket *sock, int level, int optname,
+static int __irda_getsockopt(struct socket *sock, int level, int optname,
                           char __user *optval, int __user *optlen)
 {
        struct sock *sk = sock->sk;
@@ -2463,13 +2577,25 @@ bed:
        return 0;
 }
-static struct net_proto_family irda_family_ops = {
+static int irda_getsockopt(struct socket *sock, int level, int optname,
+                           char __user *optval, int __user *optlen)
+{
+        int err;
+        lock_kernel();
+        err = __irda_getsockopt(sock, level, optname, optval, optlen);
+        unlock_kernel();
+        return err;
+}
+static const struct net_proto_family irda_family_ops = {
        .family = PF_IRDA,
        .create = irda_create,
        .owner  = THIS_MODULE,
 };
-static const struct proto_ops SOCKOPS_WRAPPED(irda_stream_ops) = {
+static const struct proto_ops irda_stream_ops = {
        .family =       PF_IRDA,
        .owner =        THIS_MODULE,
        .release =      irda_release,
@@ -2493,7 +2619,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_stream_ops) = {
        .sendpage =     sock_no_sendpage,
 };
-static const struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = {
+static const struct proto_ops irda_seqpacket_ops = {
        .family =       PF_IRDA,
        .owner =        THIS_MODULE,
        .release =      irda_release,
@@ -2502,7 +2628,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = {
        .socketpair =   sock_no_socketpair,
        .accept =       irda_accept,
        .getname =      irda_getname,
-        .poll =         datagram_poll,
+        .poll =         irda_datagram_poll,
        .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
        .compat_ioctl = irda_compat_ioctl,
@@ -2517,7 +2643,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = {
        .sendpage =     sock_no_sendpage,
 };
-static const struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = {
+static const struct proto_ops irda_dgram_ops = {
        .family =       PF_IRDA,
        .owner =        THIS_MODULE,
        .release =      irda_release,
@@ -2526,7 +2652,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = {
        .socketpair =   sock_no_socketpair,
        .accept =       irda_accept,
        .getname =      irda_getname,
-        .poll =         datagram_poll,
+        .poll =         irda_datagram_poll,
        .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
        .compat_ioctl = irda_compat_ioctl,
@@ -2542,7 +2668,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = {
 };
 #ifdef CONFIG_IRDA_ULTRA
-static const struct proto_ops SOCKOPS_WRAPPED(irda_ultra_ops) = {
+static const struct proto_ops irda_ultra_ops = {
        .family =       PF_IRDA,
        .owner =        THIS_MODULE,
        .release =      irda_release,
@@ -2551,7 +2677,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_ultra_ops) = {
        .socketpair =   sock_no_socketpair,
        .accept =       sock_no_accept,
        .getname =      irda_getname,
-        .poll =         datagram_poll,
+        .poll =         irda_datagram_poll,
        .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
        .compat_ioctl = irda_compat_ioctl,
@@ -2567,13 +2693,6 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_ultra_ops) = {
 };
 #endif /* CONFIG_IRDA_ULTRA */
-SOCKOPS_WRAP(irda_stream, PF_IRDA);
-SOCKOPS_WRAP(irda_seqpacket, PF_IRDA);
-SOCKOPS_WRAP(irda_dgram, PF_IRDA);
-#ifdef CONFIG_IRDA_ULTRA
-SOCKOPS_WRAP(irda_ultra, PF_IRDA);
-#endif /* CONFIG_IRDA_ULTRA */
 /*
 * Function irsock_init (pro)
 *
diff --git a/net/irda/discovery.c b/net/irda/discovery.c
index a6f99b5a1499..c1c8ae939126 100644
--- a/net/irda/discovery.c
+++ b/net/irda/discovery.c
@@ -34,6 +34,7 @@
 #include <linux/socket.h>
 #include <linux/fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c
index 018c92941aba..e97082017f4f 100644
--- a/net/irda/ircomm/ircomm_core.c
+++ b/net/irda/ircomm/ircomm_core.c
@@ -33,6 +33,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <net/irda/irda.h>
 #include <net/irda/irmod.h>
diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c
index 7ba96618660e..08fb54dc8c41 100644
--- a/net/irda/ircomm/ircomm_lmp.c
+++ b/net/irda/ircomm/ircomm_lmp.c
@@ -31,6 +31,7 @@
 ********************************************************************/
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
diff --git a/net/irda/ircomm/ircomm_param.c b/net/irda/ircomm/ircomm_param.c
index d57aefd9fe77..e2e893b474e9 100644
--- a/net/irda/ircomm/ircomm_param.c
+++ b/net/irda/ircomm/ircomm_param.c
@@ -28,6 +28,7 @@
 *
 ********************************************************************/
+#include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index 811984d9324b..faa82ca2dfdc 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -33,6 +33,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/termios.h>
@@ -496,9 +497,6 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
        IRDA_DEBUG(0, "%s()\n", __func__ );
-        if (!tty)
-                return;
        IRDA_ASSERT(self != NULL, return;);
        IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
@@ -1007,9 +1005,6 @@ static void ircomm_tty_hangup(struct tty_struct *tty)
        IRDA_ASSERT(self != NULL, return;);
        IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
-        if (!tty)
-                return;
        /* ircomm_tty_flush_buffer(tty); */
        ircomm_tty_shutdown(self);
diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c
index bf92e1473447..25cc2e695158 100644
--- a/net/irda/irda_device.c
+++ b/net/irda/irda_device.c
@@ -41,6 +41,7 @@
 #include <linux/tty.h>
 #include <linux/kmod.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <asm/ioctls.h>
 #include <asm/uaccess.h>
diff --git a/net/irda/iriap.c b/net/irda/iriap.c
index 294e34d3517c..79a1e5a23e10 100644
--- a/net/irda/iriap.c
+++ b/net/irda/iriap.c
@@ -31,6 +31,7 @@
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
diff --git a/net/irda/iriap_event.c b/net/irda/iriap_event.c
index a301cbd93785..703774e29e32 100644
--- a/net/irda/iriap_event.c
+++ b/net/irda/iriap_event.c
@@ -24,6 +24,8 @@
 *
 ********************************************************************/
+#include <linux/slab.h>
 #include <net/irda/irda.h>
 #include <net/irda/irlmp.h>
 #include <net/irda/iriap.h>
diff --git a/net/irda/irias_object.c b/net/irda/irias_object.c
index 99ebb96f1386..f07ed9fd5792 100644
--- a/net/irda/irias_object.c
+++ b/net/irda/irias_object.c
@@ -22,6 +22,7 @@
 *
 ********************************************************************/
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/module.h>
diff --git a/net/irda/irlan/irlan_client.c b/net/irda/irlan/irlan_client.c
index 42f7d960d055..7ed3af957935 100644
--- a/net/irda/irlan/irlan_client.c
+++ b/net/irda/irlan/irlan_client.c
@@ -28,6 +28,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
diff --git a/net/irda/irlan/irlan_common.c b/net/irda/irlan/irlan_common.c
index 315ead3cb926..a788f9e9427d 100644
--- a/net/irda/irlan/irlan_common.c
+++ b/net/irda/irlan/irlan_common.c
@@ -27,6 +27,7 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/proc_fs.h>
@@ -1128,34 +1129,14 @@ int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len)
 */
 static void *irlan_seq_start(struct seq_file *seq, loff_t *pos)
 {
-        int i = 1;
-        struct irlan_cb *self;
        rcu_read_lock();
-        if (*pos == 0)
+        return seq_list_start_head(&irlans, *pos);
-                return SEQ_START_TOKEN;
-        list_for_each_entry(self, &irlans, dev_list) {
-                if (*pos == i)
-                        return self;
-                ++i;
-        }
-        return NULL;
 }
 /* Return entry after v, and increment pos */
 static void *irlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        struct list_head *nxt;
+        return seq_list_next(v, &irlans, pos);
-        ++*pos;
-        if (v == SEQ_START_TOKEN)
-                nxt = irlans.next;
-        else
-                nxt = ((struct irlan_cb *)v)->dev_list.next;
-        return (nxt == &irlans) ? NULL
-                : list_entry(nxt, struct irlan_cb, dev_list);
 }
 /* End of reading /proc file */
@@ -1170,10 +1151,10 @@ static void irlan_seq_stop(struct seq_file *seq, void *v)
 */
 static int irlan_seq_show(struct seq_file *seq, void *v)
 {
-        if (v == SEQ_START_TOKEN)
+        if (v == &irlans)
                seq_puts(seq, "IrLAN instances:\n");
        else {
-                struct irlan_cb *self = v;
+                struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list);
                IRDA_ASSERT(self != NULL, return -1;);
                IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
diff --git a/net/irda/irlan/irlan_eth.c b/net/irda/irlan/irlan_eth.c
index d340110f5c0c..9616c32d1076 100644
--- a/net/irda/irlan/irlan_eth.c
+++ b/net/irda/irlan/irlan_eth.c
@@ -321,14 +321,15 @@ static void irlan_eth_set_multicast_list(struct net_device *dev)
                /* Enable promiscuous mode */
                IRDA_WARNING("Promiscuous mode not implemented by IrLAN!\n");
        }
-        else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > HW_MAX_ADDRS) {
+        else if ((dev->flags & IFF_ALLMULTI) ||
+                 netdev_mc_count(dev) > HW_MAX_ADDRS) {
                /* Disable promiscuous mode, use normal mode. */
                IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __func__ );
                /* hardware_set_filter(NULL); */
                irlan_set_multicast_filter(self, TRUE);
        }
-        else if (dev->mc_count) {
+        else if (!netdev_mc_empty(dev)) {
                IRDA_DEBUG(4, "%s(), Setting multicast filter\n", __func__ );
                /* Walk the address list, and load the filter */
                /* hardware_set_filter(dev->mc_list); */
diff --git a/net/irda/irlan/irlan_provider.c b/net/irda/irlan/irlan_provider.c
index 3f81f81b2dfa..5cf5e6c872bb 100644
--- a/net/irda/irlan/irlan_provider.c
+++ b/net/irda/irlan/irlan_provider.c
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/random.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 #include <asm/system.h>
 #include <asm/byteorder.h>
diff --git a/net/irda/irlap.c b/net/irda/irlap.c
index 356e65b1dc42..783c5f367d29 100644
--- a/net/irda/irlap.c
+++ b/net/irda/irlap.c
@@ -450,10 +450,10 @@ void irlap_disconnect_request(struct irlap_cb *self)
        /* Check if we are in the right state for disconnecting */
        switch (self->state) {
-        case LAP_XMIT_P:        /* FALLTROUGH */
+        case LAP_XMIT_P:        /* FALLTHROUGH */
-        case LAP_XMIT_S:        /* FALLTROUGH */
+        case LAP_XMIT_S:        /* FALLTHROUGH */
-        case LAP_CONN:          /* FALLTROUGH */
+        case LAP_CONN:          /* FALLTHROUGH */
-        case LAP_RESET_WAIT:    /* FALLTROUGH */
+        case LAP_RESET_WAIT:    /* FALLTHROUGH */
        case LAP_RESET_CHECK:
                irlap_do_event(self, DISCONNECT_REQUEST, NULL, NULL);
                break;
@@ -485,9 +485,9 @@ void irlap_disconnect_indication(struct irlap_cb *self, LAP_REASON reason)
                IRDA_DEBUG(1, "%s(), Sending reset request!\n", __func__);
                irlap_do_event(self, RESET_REQUEST, NULL, NULL);
                break;
-        case LAP_NO_RESPONSE:      /* FALLTROUGH */
+        case LAP_NO_RESPONSE:      /* FALLTHROUGH */
-        case LAP_DISC_INDICATION:  /* FALLTROUGH */
+        case LAP_DISC_INDICATION:  /* FALLTHROUGH */
-        case LAP_FOUND_NONE:       /* FALLTROUGH */
+        case LAP_FOUND_NONE:       /* FALLTHROUGH */
        case LAP_MEDIA_BUSY:
                irlmp_link_disconnect_indication(self->notify.instance, self,
                                                 reason, NULL);
diff --git a/net/irda/irlap_event.c b/net/irda/irlap_event.c
index c5c51959e3ce..d434c8880745 100644
--- a/net/irda/irlap_event.c
+++ b/net/irda/irlap_event.c
@@ -29,6 +29,7 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/skbuff.h>
+#include <linux/slab.h>
 #include <net/irda/irda.h>
 #include <net/irda/irlap_event.h>
@@ -1741,7 +1742,7 @@ static int irlap_state_reset(struct irlap_cb *self, IRLAP_EVENT event,
 * Function irlap_state_xmit_s (event, skb, info)
 *
 *   XMIT_S, The secondary station has been given the right to transmit,
- *   and we therefor do not expect to receive any transmissions from other
+ *   and we therefore do not expect to receive any transmissions from other
 *   stations.
 */
 static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event,
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index 7af2e74deda8..688222cbf55b 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -29,6 +29,7 @@
 #include <linux/if_ether.h>
 #include <linux/netdevice.h>
 #include <linux/irda.h>
+#include <linux/slab.h>
 #include <net/pkt_sched.h>
 #include <net/sock.h>
diff --git a/net/irda/irlmp.c b/net/irda/irlmp.c
index 7bf5b913828b..0e7d8bde145d 100644
--- a/net/irda/irlmp.c
+++ b/net/irda/irlmp.c
@@ -105,7 +105,7 @@ int __init irlmp_init(void)
        init_timer(&irlmp->discovery_timer);
-        /* Do discovery every 3 seconds, conditionaly */
+        /* Do discovery every 3 seconds, conditionally */
        if (sysctl_discovery)
                irlmp_start_discovery_timer(irlmp,
                                            sysctl_discovery_timeout*HZ);
@@ -1842,7 +1842,7 @@ LM_REASON irlmp_convert_lap_reason( LAP_REASON lap_reason)
                reason = LM_CONNECT_FAILURE;
                break;
        default:
-                IRDA_DEBUG(1, "%s(), Unknow IrLAP disconnect reason %d!\n",
+                IRDA_DEBUG(1, "%s(), Unknown IrLAP disconnect reason %d!\n",
                           __func__, lap_reason);
                reason = LM_LAP_DISCONNECT;
                break;
diff --git a/net/irda/irnet/irnet.h b/net/irda/irnet/irnet.h
index b001c361ad30..4300df35d37d 100644
--- a/net/irda/irnet/irnet.h
+++ b/net/irda/irnet/irnet.h
@@ -249,6 +249,7 @@
 #include <linux/poll.h>
 #include <linux/capability.h>
 #include <linux/ctype.h>        /* isspace() */
+#include <linux/string.h>       /* skip_spaces() */
 #include <asm/uaccess.h>
 #include <linux/init.h>
diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index cccc2e93234f..df18ab4b6c5e 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -11,6 +11,7 @@
 #include "irnet_irda.h"         /* Private header */
 #include <linux/sched.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 /*
@@ -1403,8 +1404,8 @@ irnet_connect_indication(void *		instance,
  /* Socket already connecting ? On primary ? */
  if(0
 #ifdef ALLOW_SIMULT_CONNECT
-     || ((irttp_is_primary(server->tsap) == 1)  /* primary */
+     || ((irttp_is_primary(server->tsap) == 1) &&       /* primary */
-         && (test_and_clear_bit(0, &new->ttp_connect)))
+         (test_and_clear_bit(0, &new->ttp_connect)))
 #endif /* ALLOW_SIMULT_CONNECT */
     )
    {
diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c
index 7dea882dbb75..6a1a202710c5 100644
--- a/net/irda/irnet/irnet_ppp.c
+++ b/net/irda/irnet/irnet_ppp.c
@@ -14,6 +14,7 @@
 */
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include "irnet_ppp.h"          /* Private header */
 /* Please put other headers in irnet.h - Thanks */
@@ -76,9 +77,8 @@ irnet_ctrl_write(irnet_socket *	ap,
      /* Look at the next command */
      start = next;
-      /* Scrap whitespaces before the command */
+        /* Scrap whitespaces before the command */
-      while(isspace(*start))
+        start = skip_spaces(start);
-        start++;
      /* ',' is our command separator */
      next = strchr(start, ',');
@@ -133,8 +133,7 @@ irnet_ctrl_write(irnet_socket *	ap,
              char *    endp;
              /* Scrap whitespaces before the command */
-              while(isspace(*begp))
+              begp = skip_spaces(begp);
-                begp++;
              /* Convert argument to a number (last arg is the base) */
              addr = simple_strtoul(begp, &endp, 16);
@@ -700,15 +699,18 @@ dev_irnet_ioctl(
      /* Query PPP channel and unit number */
    case PPPIOCGCHAN:
+      lock_kernel();
      if(ap->ppp_open && !put_user(ppp_channel_index(&ap->chan),
                                                (int __user *)argp))
        err = 0;
+      unlock_kernel();
      break;
    case PPPIOCGUNIT:
      lock_kernel();
      if(ap->ppp_open && !put_user(ppp_unit_number(&ap->chan),
                                                (int __user *)argp))
-      err = 0;
+        err = 0;
+      unlock_kernel();
      break;
      /* All these ioctls can be passed both directly and from ppp_generic,
diff --git a/net/irda/irnetlink.c b/net/irda/irnetlink.c
index 476b307bd801..6c7c4b92e4f8 100644
--- a/net/irda/irnetlink.c
+++ b/net/irda/irnetlink.c
@@ -15,6 +15,7 @@
 #include <linux/socket.h>
 #include <linux/irda.h>
+#include <linux/gfp.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/irda/irda.h>
@@ -124,7 +125,7 @@ static int irda_nl_get_mode(struct sk_buff *skb, struct genl_info *info)
        return ret;
 }
-static struct nla_policy irda_nl_policy[IRDA_NL_ATTR_MAX + 1] = {
+static const struct nla_policy irda_nl_policy[IRDA_NL_ATTR_MAX + 1] = {
        [IRDA_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
                                  .len = IFNAMSIZ-1 },
        [IRDA_NL_ATTR_MODE] = { .type = NLA_U32 },
diff --git a/net/irda/irqueue.c b/net/irda/irqueue.c
index ba01938becb5..849aaf0dabb5 100644
--- a/net/irda/irqueue.c
+++ b/net/irda/irqueue.c
@@ -192,6 +192,7 @@
 * Jean II
 */
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <net/irda/irda.h>
 #include <net/irda/irqueue.h>
diff --git a/net/irda/irsysctl.c b/net/irda/irsysctl.c
index 5c86567e5a78..d0b70dadf73b 100644
--- a/net/irda/irsysctl.c
+++ b/net/irda/irsysctl.c
@@ -113,26 +113,21 @@ static int do_discovery(ctl_table *table, int write,
 /* One file */
 static ctl_table irda_table[] = {
        {
-                .ctl_name       = NET_IRDA_DISCOVERY,
                .procname       = "discovery",
                .data           = &sysctl_discovery,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = do_discovery,
-                .strategy       = sysctl_intvec
        },
        {
-                .ctl_name       = NET_IRDA_DEVNAME,
                .procname       = "devname",
                .data           = sysctl_devname,
                .maxlen         = 65,
                .mode           = 0644,
                .proc_handler   = do_devname,
-                .strategy       = sysctl_string
        },
 #ifdef CONFIG_IRDA_DEBUG
        {
-                .ctl_name       = NET_IRDA_DEBUG,
                .procname       = "debug",
                .data           = &irda_debug,
                .maxlen         = sizeof(int),
@@ -142,7 +137,6 @@ static ctl_table irda_table[] = {
 #endif
 #ifdef CONFIG_IRDA_FAST_RR
        {
-                .ctl_name       = NET_IRDA_FAST_POLL,
                .procname       = "fast_poll_increase",
                .data           = &sysctl_fast_poll_increase,
                .maxlen         = sizeof(int),
@@ -151,18 +145,15 @@ static ctl_table irda_table[] = {
        },
 #endif
        {
-                .ctl_name       = NET_IRDA_DISCOVERY_SLOTS,
                .procname       = "discovery_slots",
                .data           = &sysctl_discovery_slots,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_discovery_slots,
                .extra2         = &max_discovery_slots
        },
        {
-                .ctl_name       = NET_IRDA_DISCOVERY_TIMEOUT,
                .procname       = "discovery_timeout",
                .data           = &sysctl_discovery_timeout,
                .maxlen         = sizeof(int),
@@ -170,99 +161,83 @@ static ctl_table irda_table[] = {
                .proc_handler   = proc_dointvec
        },
        {
-                .ctl_name       = NET_IRDA_SLOT_TIMEOUT,
                .procname       = "slot_timeout",
                .data           = &sysctl_slot_timeout,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_slot_timeout,
                .extra2         = &max_slot_timeout
        },
        {
-                .ctl_name       = NET_IRDA_MAX_BAUD_RATE,
                .procname       = "max_baud_rate",
                .data           = &sysctl_max_baud_rate,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_max_baud_rate,
                .extra2         = &max_max_baud_rate
        },
        {
-                .ctl_name       = NET_IRDA_MIN_TX_TURN_TIME,
                .procname       = "min_tx_turn_time",
                .data           = &sysctl_min_tx_turn_time,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_min_tx_turn_time,
                .extra2         = &max_min_tx_turn_time
        },
        {
-                .ctl_name       = NET_IRDA_MAX_TX_DATA_SIZE,
                .procname       = "max_tx_data_size",
                .data           = &sysctl_max_tx_data_size,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_max_tx_data_size,
                .extra2         = &max_max_tx_data_size
        },
        {
-                .ctl_name       = NET_IRDA_MAX_TX_WINDOW,
                .procname       = "max_tx_window",
                .data           = &sysctl_max_tx_window,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_max_tx_window,
                .extra2         = &max_max_tx_window
        },
        {
-                .ctl_name       = NET_IRDA_MAX_NOREPLY_TIME,
                .procname       = "max_noreply_time",
                .data           = &sysctl_max_noreply_time,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_max_noreply_time,
                .extra2         = &max_max_noreply_time
        },
        {
-                .ctl_name       = NET_IRDA_WARN_NOREPLY_TIME,
                .procname       = "warn_noreply_time",
                .data           = &sysctl_warn_noreply_time,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_warn_noreply_time,
                .extra2         = &max_warn_noreply_time
        },
        {
-                .ctl_name       = NET_IRDA_LAP_KEEPALIVE_TIME,
                .procname       = "lap_keepalive_time",
                .data           = &sysctl_lap_keepalive_time,
                .maxlen         = sizeof(int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec_minmax,
-                .strategy       = sysctl_intvec,
                .extra1         = &min_lap_keepalive_time,
                .extra2         = &max_lap_keepalive_time
        },
-        { .ctl_name = 0 }
+        { }
 };
 static struct ctl_path irda_path[] = {
-        { .procname = "net", .ctl_name = CTL_NET, },
+        { .procname = "net", },
-        { .procname = "irda", .ctl_name = NET_IRDA, },
+        { .procname = "irda", },
        { }
 };
diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index 9cb79f95bf63..47db1d8a0d92 100644
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>