Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

30 files changed, 364 insertions, 322 deletions

diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index fd55b5135de5..cc616974a447 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -45,7 +45,6 @@
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
-#include <linux/smp_lock.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/slab.h>
@@ -573,9 +572,9 @@ static int irda_find_lsap_sel(struct irda_sock *self, char *name)
                 /* Requested object/attribute doesn't exist */
                 if((self->errno == IAS_CLASS_UNKNOWN) ||
                    (self->errno == IAS_ATTRIB_UNKNOWN))
-                        return (-EADDRNOTAVAIL);
+                        return -EADDRNOTAVAIL;
                 else
-                        return (-EHOSTUNREACH);
+                        return -EHOSTUNREACH;
         }
 
         /* Get the remote TSAP selector */
@@ -663,7 +662,7 @@ static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
                                            __func__, name);
                                 self->daddr = DEV_ADDR_ANY;
                                 kfree(discoveries);
-                                return(-ENOTUNIQ);
+                                return -ENOTUNIQ;
                         }
                         /* First time we found that one, save it ! */
                         daddr = self->daddr;
@@ -677,7 +676,7 @@ static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
                         IRDA_DEBUG(0, "%s(), unexpected IAS query failure\n", __func__);
                         self->daddr = DEV_ADDR_ANY;
                         kfree(discoveries);
-                        return(-EHOSTUNREACH);
+                        return -EHOSTUNREACH;
                         break;
                 }
         }
@@ -689,7 +688,7 @@ static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
                 IRDA_DEBUG(1, "%s(), cannot discover service ''%s'' in any device !!!\n",
                            __func__, name);
                 self->daddr = DEV_ADDR_ANY;
-                return(-EADDRNOTAVAIL);
+                return -EADDRNOTAVAIL;
         }
 
         /* Revert back to discovered device & service */
@@ -715,14 +714,11 @@ 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)
-                        goto out;
+                        return -ENOTCONN;
 
                 saddr.sir_family = AF_IRDA;
                 saddr.sir_lsap_sel = self->dtsap_sel;
@@ -739,10 +735,8 @@ 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;
-out:
-        unlock_kernel();
-        return err;
+
+        return 0;
 }
 
 /*
@@ -758,7 +752,8 @@ static int irda_listen(struct socket *sock, int backlog)
 
         IRDA_DEBUG(2, "%s()\n", __func__);
 
-        lock_kernel();
+        lock_sock(sk);
+
         if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) &&
             (sk->sk_type != SOCK_DGRAM))
                 goto out;
@@ -770,7 +765,7 @@ static int irda_listen(struct socket *sock, int backlog)
                 err = 0;
         }
 out:
-        unlock_kernel();
+        release_sock(sk);
 
         return err;
 }
@@ -793,7 +788,7 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         if (addr_len != sizeof(struct sockaddr_irda))
                 return -EINVAL;
 
-        lock_kernel();
+        lock_sock(sk);
 #ifdef CONFIG_IRDA_ULTRA
         /* Special care for Ultra sockets */
         if ((sk->sk_type == SOCK_DGRAM) &&
@@ -836,7 +831,7 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 
         err = 0;
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err;
 }
 
@@ -856,12 +851,13 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
 
         IRDA_DEBUG(2, "%s()\n", __func__);
 
-        lock_kernel();
         err = irda_create(sock_net(sk), newsock, sk->sk_protocol, 0);
         if (err)
-                goto out;
+                return err;
 
         err = -EINVAL;
+
+        lock_sock(sk);
         if (sock->state != SS_UNCONNECTED)
                 goto out;
 
@@ -947,7 +943,7 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
         irda_connect_response(new);
         err = 0;
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err;
 }
 
@@ -981,7 +977,7 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
 
         IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 
-        lock_kernel();
+        lock_sock(sk);
         /* Don't allow connect for Ultra sockets */
         err = -ESOCKTNOSUPPORT;
         if ((sk->sk_type == SOCK_DGRAM) && (sk->sk_protocol == IRDAPROTO_ULTRA))
@@ -1072,6 +1068,8 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
 
         if (sk->sk_state != TCP_ESTABLISHED) {
                 sock->state = SS_UNCONNECTED;
+                if (sk->sk_prot->disconnect(sk, flags))
+                        sock->state = SS_DISCONNECTING;
                 err = sock_error(sk);
                 if (!err)
                         err = -ECONNRESET;
@@ -1084,7 +1082,7 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
         self->saddr = irttp_get_saddr(self->tsap);
         err = 0;
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err;
 }
 
@@ -1231,7 +1229,6 @@ 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;
@@ -1250,7 +1247,6 @@ 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
@@ -1298,14 +1294,14 @@ 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)) {
-                err = -EINVAL;
-                goto out;
+                return -EINVAL;
         }
 
+        lock_sock(sk);
+
         if (sk->sk_shutdown & SEND_SHUTDOWN)
                 goto out_err;
 
@@ -1361,14 +1357,14 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
                 goto out_err;
         }
 
-        unlock_kernel();
+        release_sock(sk);
         /* Tell client how much data we actually sent */
         return len;
 
 out_err:
         err = sk_stream_error(sk, msg->msg_flags, err);
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err;
 
 }
@@ -1390,14 +1386,10 @@ 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)
-                goto out;
-
         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
                                 flags & MSG_DONTWAIT, &err);
         if (!skb)
-                goto out;
+                return err;
 
         skb_reset_transport_header(skb);
         copied = skb->len;
@@ -1425,12 +1417,8 @@ 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;
+        return copied;
 }
 
 /*
@@ -1448,17 +1436,15 @@ 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)
-                goto out;
+                return err;
 
-        err = -EINVAL;
         if (sock->flags & __SO_ACCEPTCON)
-                goto out;
+                return -EINVAL;
 
         err =-EOPNOTSUPP;
         if (flags & MSG_OOB)
-                goto out;
+                return -EOPNOTSUPP;
 
         err = 0;
         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
@@ -1500,7 +1486,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                         finish_wait(sk_sleep(sk), &wait);
 
                         if (err)
-                                goto out;
+                                return err;
                         if (sk->sk_shutdown & RCV_SHUTDOWN)
                                 break;
 
@@ -1553,9 +1539,7 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                 }
         }
 
-out:
-        unlock_kernel();
-        return err ? : copied;
+        return copied;
 }
 
 /*
@@ -1573,13 +1557,12 @@ 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))
-                goto out;
+                return -EINVAL;
+
+        lock_sock(sk);
 
         if (sk->sk_shutdown & SEND_SHUTDOWN) {
                 send_sig(SIGPIPE, current, 0);
@@ -1630,10 +1613,12 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
                 IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
                 goto out;
         }
-        unlock_kernel();
+
+        release_sock(sk);
         return len;
+
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err;
 }
 
@@ -1656,10 +1641,11 @@ 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))
-                goto out;
+                return -EINVAL;
+
+        lock_sock(sk);
 
         err = -EPIPE;
         if (sk->sk_shutdown & SEND_SHUTDOWN) {
@@ -1732,7 +1718,7 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
         if (err)
                 IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
 out:
-        unlock_kernel();
+        release_sock(sk);
         return err ? : len;
 }
 #endif /* CONFIG_IRDA_ULTRA */
@@ -1747,7 +1733,7 @@ static int irda_shutdown(struct socket *sock, int how)
 
         IRDA_DEBUG(1, "%s(%p)\n", __func__, self);
 
-        lock_kernel();
+        lock_sock(sk);
 
         sk->sk_state       = TCP_CLOSE;
         sk->sk_shutdown   |= SEND_SHUTDOWN;
@@ -1769,7 +1755,7 @@ 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();
+        release_sock(sk);
 
         return 0;
 }
@@ -1786,7 +1772,6 @@ static unsigned int irda_poll(struct file * file, struct socket *sock,
 
         IRDA_DEBUG(4, "%s()\n", __func__);
 
-        lock_kernel();
         poll_wait(file, sk_sleep(sk), wait);
         mask = 0;
 
@@ -1834,20 +1819,8 @@ 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;
+        return mask;
 }
 
 /*
@@ -1860,7 +1833,6 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 
         IRDA_DEBUG(4, "%s(), cmd=%#x\n", __func__, cmd);
 
-        lock_kernel();
         err = -EINVAL;
         switch (cmd) {
         case TIOCOUTQ: {
@@ -1903,7 +1875,6 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                 IRDA_DEBUG(1, "%s(), doing device ioctl!\n", __func__);
                 err = -ENOIOCTLCMD;
         }
-        unlock_kernel();
 
         return err;
 }
@@ -1927,7 +1898,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;
@@ -1935,13 +1906,15 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
         struct irda_ias_set    *ias_opt;
         struct ias_object      *ias_obj;
         struct ias_attrib *     ias_attr;       /* Attribute in IAS object */
-        int opt, free_ias = 0;
+        int opt, free_ias = 0, err = 0;
 
         IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 
         if (level != SOL_IRLMP)
                 return -ENOPROTOOPT;
 
+        lock_sock(sk);
+
         switch (optname) {
         case IRLMP_IAS_SET:
                 /* The user want to add an attribute to an existing IAS object
@@ -1951,17 +1924,22 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                  * create the right attribute...
                  */
 
-                if (optlen != sizeof(struct irda_ias_set))
-                        return -EINVAL;
+                if (optlen != sizeof(struct irda_ias_set)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
-                if (ias_opt == NULL)
-                        return -ENOMEM;
+                if (ias_opt == NULL) {
+                        err = -ENOMEM;
+                        goto out;
+                }
 
                 /* Copy query to the driver. */
                 if (copy_from_user(ias_opt, optval, optlen)) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
 
                 /* Find the object we target.
@@ -1971,7 +1949,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                 if(ias_opt->irda_class_name[0] == '\0') {
                         if(self->ias_obj == NULL) {
                                 kfree(ias_opt);
-                                return -EINVAL;
+                                err = -EINVAL;
+                                goto out;
                         }
                         ias_obj = self->ias_obj;
                 } else
@@ -1983,7 +1962,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                 if((!capable(CAP_NET_ADMIN)) &&
                    ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
                         kfree(ias_opt);
-                        return -EPERM;
+                        err = -EPERM;
+                        goto out;
                 }
 
                 /* If the object doesn't exist, create it */
@@ -1993,7 +1973,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                                                    jiffies);
                         if (ias_obj == NULL) {
                                 kfree(ias_opt);
-                                return -ENOMEM;
+                                err = -ENOMEM;
+                                goto out;
                         }
                         free_ias = 1;
                 }
@@ -2005,7 +1986,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                                 kfree(ias_obj->name);
                                 kfree(ias_obj);
                         }
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
 
                 /* Look at the type */
@@ -2028,7 +2010,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                                         kfree(ias_obj);
                                 }
 
-                                return -EINVAL;
+                                err = -EINVAL;
+                                goto out;
                         }
                         /* Add an octet sequence attribute */
                         irias_add_octseq_attrib(
@@ -2060,7 +2043,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                                 kfree(ias_obj->name);
                                 kfree(ias_obj);
                         }
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
                 irias_insert_object(ias_obj);
                 kfree(ias_opt);
@@ -2071,17 +2055,22 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                  * object is not owned by the kernel and delete it.
                  */
 
-                if (optlen != sizeof(struct irda_ias_set))
-                        return -EINVAL;
+                if (optlen != sizeof(struct irda_ias_set)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
-                if (ias_opt == NULL)
-                        return -ENOMEM;
+                if (ias_opt == NULL) {
+                        err = -ENOMEM;
+                        goto out;
+                }
 
                 /* Copy query to the driver. */
                 if (copy_from_user(ias_opt, optval, optlen)) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
 
                 /* Find the object we target.
@@ -2094,7 +2083,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                         ias_obj = irias_find_object(ias_opt->irda_class_name);
                 if(ias_obj == (struct ias_object *) NULL) {
                         kfree(ias_opt);
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
 
                 /* Only ROOT can mess with the global IAS database.
@@ -2103,7 +2093,8 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                 if((!capable(CAP_NET_ADMIN)) &&
                    ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
                         kfree(ias_opt);
-                        return -EPERM;
+                        err = -EPERM;
+                        goto out;
                 }
 
                 /* Find the attribute (in the object) we target */
@@ -2111,14 +2102,16 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                                              ias_opt->irda_attrib_name);
                 if(ias_attr == (struct ias_attrib *) NULL) {
                         kfree(ias_opt);
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
 
                 /* Check is the user space own the object */
                 if(ias_attr->value->owner != IAS_USER_ATTR) {
                         IRDA_DEBUG(1, "%s(), attempting to delete a kernel attribute\n", __func__);
                         kfree(ias_opt);
-                        return -EPERM;
+                        err = -EPERM;
+                        goto out;
                 }
 
                 /* Remove the attribute (and maybe the object) */
@@ -2126,11 +2119,15 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                 kfree(ias_opt);
                 break;
         case IRLMP_MAX_SDU_SIZE:
-                if (optlen < sizeof(int))
-                        return -EINVAL;
+                if (optlen < sizeof(int)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
-                if (get_user(opt, (int __user *)optval))
-                        return -EFAULT;
+                if (get_user(opt, (int __user *)optval)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
                 /* Only possible for a seqpacket service (TTP with SAR) */
                 if (sk->sk_type != SOCK_SEQPACKET) {
@@ -2140,16 +2137,21 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                 } else {
                         IRDA_WARNING("%s: not allowed to set MAXSDUSIZE for this socket type!\n",
                                      __func__);
-                        return -ENOPROTOOPT;
+                        err = -ENOPROTOOPT;
+                        goto out;
                 }
                 break;
         case IRLMP_HINTS_SET:
-                if (optlen < sizeof(int))
-                        return -EINVAL;
+                if (optlen < sizeof(int)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 /* The input is really a (__u8 hints[2]), easier as an int */
-                if (get_user(opt, (int __user *)optval))
-                        return -EFAULT;
+                if (get_user(opt, (int __user *)optval)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
                 /* Unregister any old registration */
                 if (self->skey)
@@ -2163,12 +2165,16 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
                  * making a discovery (nodes which don't match any hint
                  * bit in the mask are not reported).
                  */
-                if (optlen < sizeof(int))
-                        return -EINVAL;
+                if (optlen < sizeof(int)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 /* The input is really a (__u8 hints[2]), easier as an int */
-                if (get_user(opt, (int __user *)optval))
-                        return -EFAULT;
+                if (get_user(opt, (int __user *)optval)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
                 /* Set the new hint mask */
                 self->mask.word = (__u16) opt;
@@ -2180,19 +2186,12 @@ static int __irda_setsockopt(struct socket *sock, int level, int optname,
 
                 break;
         default:
-                return -ENOPROTOOPT;
+                err = -ENOPROTOOPT;
+                break;
         }
-        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();
+out:
+        release_sock(sk);
 
         return err;
 }
@@ -2249,7 +2248,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;
@@ -2262,7 +2261,7 @@ static int __irda_getsockopt(struct socket *sock, int level, int optname,
         int daddr = DEV_ADDR_ANY;       /* Dest address for IAS queries */
         int val = 0;
         int len = 0;
-        int err;
+        int err = 0;
         int offset, total;
 
         IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
@@ -2276,29 +2275,35 @@ static int __irda_getsockopt(struct socket *sock, int level, int optname,
         if(len < 0)
                 return -EINVAL;
 
+        lock_sock(sk);
+
         switch (optname) {
         case IRLMP_ENUMDEVICES:
+
+                /* Offset to first device entry */
+                offset = sizeof(struct irda_device_list) -
+                        sizeof(struct irda_device_info);
+
+                if (len < offset) {
+                        err = -EINVAL;
+                        goto out;
+                }
+
                 /* Ask lmp for the current discovery log */
                 discoveries = irlmp_get_discoveries(&list.len, self->mask.word,
                                                     self->nslots);
                 /* Check if the we got some results */
-                if (discoveries == NULL)
-                        return -EAGAIN;         /* Didn't find any devices */
-                err = 0;
+                if (discoveries == NULL) {
+                        err = -EAGAIN;
+                        goto out;               /* Didn't find any devices */
+                }
 
                 /* Write total list length back to client */
-                if (copy_to_user(optval, &list,
-                                 sizeof(struct irda_device_list) -
-                                 sizeof(struct irda_device_info)))
+                if (copy_to_user(optval, &list, offset))
                         err = -EFAULT;
 
-                /* Offset to first device entry */
-                offset = sizeof(struct irda_device_list) -
-                        sizeof(struct irda_device_info);
-
                 /* Copy the list itself - watch for overflow */
-                if(list.len > 2048)
-                {
+                if (list.len > 2048) {
                         err = -EINVAL;
                         goto bed;
                 }
@@ -2314,17 +2319,20 @@ static int __irda_getsockopt(struct socket *sock, int level, int optname,
 bed:
                 /* Free up our buffer */
                 kfree(discoveries);
-                if (err)
-                        return err;
                 break;
         case IRLMP_MAX_SDU_SIZE:
                 val = self->max_data_size;
                 len = sizeof(int);
-                if (put_user(len, optlen))
-                        return -EFAULT;
+                if (put_user(len, optlen)) {
+                        err = -EFAULT;
+                        goto out;
+                }
+
+                if (copy_to_user(optval, &val, len)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
-                if (copy_to_user(optval, &val, len))
-                        return -EFAULT;
                 break;
         case IRLMP_IAS_GET:
                 /* The user want an object from our local IAS database.
@@ -2332,17 +2340,22 @@ bed:
                  * that we found */
 
                 /* Check that the user has allocated the right space for us */
-                if (len != sizeof(struct irda_ias_set))
-                        return -EINVAL;
+                if (len != sizeof(struct irda_ias_set)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
-                if (ias_opt == NULL)
-                        return -ENOMEM;
+                if (ias_opt == NULL) {
+                        err = -ENOMEM;
+                        goto out;
+                }
 
                 /* Copy query to the driver. */
                 if (copy_from_user(ias_opt, optval, len)) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
 
                 /* Find the object we target.
@@ -2355,7 +2368,8 @@ bed:
                         ias_obj = irias_find_object(ias_opt->irda_class_name);
                 if(ias_obj == (struct ias_object *) NULL) {
                         kfree(ias_opt);
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
 
                 /* Find the attribute (in the object) we target */
@@ -2363,21 +2377,23 @@ bed:
                                              ias_opt->irda_attrib_name);
                 if(ias_attr == (struct ias_attrib *) NULL) {
                         kfree(ias_opt);
-                        return -EINVAL;
+                        err = -EINVAL;
+                        goto out;
                 }
 
                 /* Translate from internal to user structure */
                 err = irda_extract_ias_value(ias_opt, ias_attr->value);
                 if(err) {
                         kfree(ias_opt);
-                        return err;
+                        goto out;
                 }
 
                 /* Copy reply to the user */
                 if (copy_to_user(optval, ias_opt,
                                  sizeof(struct irda_ias_set))) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
                 /* Note : don't need to put optlen, we checked it */
                 kfree(ias_opt);
@@ -2388,17 +2404,22 @@ bed:
                  * then wait for the answer to come back. */
 
                 /* Check that the user has allocated the right space for us */
-                if (len != sizeof(struct irda_ias_set))
-                        return -EINVAL;
+                if (len != sizeof(struct irda_ias_set)) {
+                        err = -EINVAL;
+                        goto out;
+                }
 
                 ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
-                if (ias_opt == NULL)
-                        return -ENOMEM;
+                if (ias_opt == NULL) {
+                        err = -ENOMEM;
+                        goto out;
+                }
 
                 /* Copy query to the driver. */
                 if (copy_from_user(ias_opt, optval, len)) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
 
                 /* At this point, there are two cases...
@@ -2419,7 +2440,8 @@ bed:
                         daddr = ias_opt->daddr;
                         if((!daddr) || (daddr == DEV_ADDR_ANY)) {
                                 kfree(ias_opt);
-                                return -EINVAL;
+                                err = -EINVAL;
+                                goto out;
                         }
                 }
 
@@ -2428,7 +2450,8 @@ bed:
                         IRDA_WARNING("%s: busy with a previous query\n",
                                      __func__);
                         kfree(ias_opt);
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
                 }
 
                 self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
@@ -2436,7 +2459,8 @@ bed:
 
                 if (self->iriap == NULL) {
                         kfree(ias_opt);
-                        return -ENOMEM;
+                        err = -ENOMEM;
+                        goto out;
                 }
 
                 /* Treat unexpected wakeup as disconnect */
@@ -2455,7 +2479,8 @@ bed:
                          * we can free it regardless! */
                         kfree(ias_opt);
                         /* Treat signals as disconnect */
-                        return -EHOSTUNREACH;
+                        err = -EHOSTUNREACH;
+                        goto out;
                 }
 
                 /* Check what happened */
@@ -2465,9 +2490,11 @@ bed:
                         /* Requested object/attribute doesn't exist */
                         if((self->errno == IAS_CLASS_UNKNOWN) ||
                            (self->errno == IAS_ATTRIB_UNKNOWN))
-                                return (-EADDRNOTAVAIL);
+                                err = -EADDRNOTAVAIL;
                         else
-                                return (-EHOSTUNREACH);
+                                err = -EHOSTUNREACH;
+
+                        goto out;
                 }
 
                 /* Translate from internal to user structure */
@@ -2476,14 +2503,15 @@ bed:
                         irias_delete_value(self->ias_result);
                 if (err) {
                         kfree(ias_opt);
-                        return err;
+                        goto out;
                 }
 
                 /* Copy reply to the user */
                 if (copy_to_user(optval, ias_opt,
                                  sizeof(struct irda_ias_set))) {
                         kfree(ias_opt);
-                        return -EFAULT;
+                        err = -EFAULT;
+                        goto out;
                 }
                 /* Note : don't need to put optlen, we checked it */
                 kfree(ias_opt);
@@ -2504,11 +2532,15 @@ bed:
                  */
 
                 /* Check that the user is passing us an int */
-                if (len != sizeof(int))
-                        return -EINVAL;
+                if (len != sizeof(int)) {
+                        err = -EINVAL;
+                        goto out;
+                }
                 /* Get timeout in ms (max time we block the caller) */
-                if (get_user(val, (int __user *)optval))
-                        return -EFAULT;
+                if (get_user(val, (int __user *)optval)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
                 /* Tell IrLMP we want to be notified */
                 irlmp_update_client(self->ckey, self->mask.word,
@@ -2520,8 +2552,6 @@ bed:
 
                 /* Wait until a node is discovered */
                 if (!self->cachedaddr) {
-                        int ret = 0;
-
                         IRDA_DEBUG(1, "%s(), nothing discovered yet, going to sleep...\n", __func__);
 
                         /* Set watchdog timer to expire in <val> ms. */
@@ -2534,7 +2564,7 @@ bed:
                         /* Wait for IR-LMP to call us back */
                         __wait_event_interruptible(self->query_wait,
                               (self->cachedaddr != 0 || self->errno == -ETIME),
-                                                   ret);
+                                                   err);
 
                         /* If watchdog is still activated, kill it! */
                         if(timer_pending(&(self->watchdog)))
@@ -2542,8 +2572,8 @@ bed:
 
                         IRDA_DEBUG(1, "%s(), ...waking up !\n", __func__);
 
-                        if (ret != 0)
-                                return ret;
+                        if (err != 0)
+                                goto out;
                 }
                 else
                         IRDA_DEBUG(1, "%s(), found immediately !\n",
@@ -2566,25 +2596,19 @@ bed:
                  * If the user want more details, he should query
                  * the whole discovery log and pick one device...
                  */
-                if (put_user(daddr, (int __user *)optval))
-                        return -EFAULT;
+                if (put_user(daddr, (int __user *)optval)) {
+                        err = -EFAULT;
+                        goto out;
+                }
 
                 break;
         default:
-                return -ENOPROTOOPT;
+                err = -ENOPROTOOPT;
         }
 
-        return 0;
-}
-
-static int irda_getsockopt(struct socket *sock, int level, int optname,
-                           char __user *optval, int __user *optlen)
-{
-        int err;
+out:
 
-        lock_kernel();
-        err = __irda_getsockopt(sock, level, optname, optval, optlen);
-        unlock_kernel();
+        release_sock(sk);
 
         return err;
 }
@@ -2628,7 +2652,7 @@ static const struct proto_ops irda_seqpacket_ops = {
         .socketpair =   sock_no_socketpair,
         .accept =       irda_accept,
         .getname =      irda_getname,
-        .poll =         irda_datagram_poll,
+        .poll =         datagram_poll,
         .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = irda_compat_ioctl,
@@ -2652,7 +2676,7 @@ static const struct proto_ops irda_dgram_ops = {
         .socketpair =   sock_no_socketpair,
         .accept =       irda_accept,
         .getname =      irda_getname,
-        .poll =         irda_datagram_poll,
+        .poll =         datagram_poll,
         .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = irda_compat_ioctl,
@@ -2677,7 +2701,7 @@ static const struct proto_ops irda_ultra_ops = {
         .socketpair =   sock_no_socketpair,
         .accept =       sock_no_accept,
         .getname =      irda_getname,
-        .poll =         irda_datagram_poll,
+        .poll =         datagram_poll,
         .ioctl =        irda_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = irda_compat_ioctl,
diff --git a/net/irda/discovery.c b/net/irda/discovery.c
index c1c8ae939126..36c3f037f172 100644
--- a/net/irda/discovery.c
+++ b/net/irda/discovery.c
@@ -315,7 +315,7 @@ struct irda_device_info *irlmp_copy_discoveries(hashbin_t *log, int *pn,
 
         /* Get the actual number of device in the buffer and return */
         *pn = i;
-        return(buffer);
+        return buffer;
 }
 
 #ifdef CONFIG_PROC_FS
diff --git a/net/irda/ircomm/Makefile b/net/irda/ircomm/Makefile
index 48689458c086..ab23b5ba7e33 100644
--- a/net/irda/ircomm/Makefile
+++ b/net/irda/ircomm/Makefile
@@ -4,5 +4,5 @@
 
 obj-$(CONFIG_IRCOMM) += ircomm.o ircomm-tty.o
 
-ircomm-objs := ircomm_core.o ircomm_event.o ircomm_lmp.o ircomm_ttp.o
-ircomm-tty-objs := ircomm_tty.o ircomm_tty_attach.o ircomm_tty_ioctl.o ircomm_param.o
+ircomm-y := ircomm_core.o ircomm_event.o ircomm_lmp.o ircomm_ttp.o
+ircomm-tty-y := ircomm_tty.o ircomm_tty_attach.o ircomm_tty_ioctl.o ircomm_param.o
diff --git a/net/irda/ircomm/ircomm_core.c b/net/irda/ircomm/ircomm_core.c
index e97082017f4f..52079f19bbbe 100644
--- a/net/irda/ircomm/ircomm_core.c
+++ b/net/irda/ircomm/ircomm_core.c
@@ -244,14 +244,8 @@ EXPORT_SYMBOL(ircomm_connect_request);
 void ircomm_connect_indication(struct ircomm_cb *self, struct sk_buff *skb,
                                struct ircomm_info *info)
 {
-        int clen = 0;
-
         IRDA_DEBUG(2, "%s()\n", __func__ );
 
-        /* Check if the packet contains data on the control channel */
-        if (skb->len > 0)
-                clen = skb->data[0];
-
         /*
          * If there are any data hiding in the control channel, we must
          * deliver it first. The side effect is that the control channel
diff --git a/net/irda/ircomm/ircomm_lmp.c b/net/irda/ircomm/ircomm_lmp.c
index 08fb54dc8c41..3b8095c771d4 100644
--- a/net/irda/ircomm/ircomm_lmp.c
+++ b/net/irda/ircomm/ircomm_lmp.c
@@ -75,7 +75,6 @@ static int ircomm_lmp_connect_response(struct ircomm_cb *self,
                                        struct sk_buff *userdata)
 {
         struct sk_buff *tx_skb;
-        int ret;
 
         IRDA_DEBUG(0, "%s()\n", __func__ );
 
@@ -100,9 +99,7 @@ static int ircomm_lmp_connect_response(struct ircomm_cb *self,
                 tx_skb = userdata;
         }
 
-        ret = irlmp_connect_response(self->lsap, tx_skb);
-
-        return 0;
+        return irlmp_connect_response(self->lsap, tx_skb);
 }
 
 static int ircomm_lmp_disconnect_request(struct ircomm_cb *self,
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index faa82ca2dfdc..b3cc8b3989a9 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -38,6 +38,7 @@
 #include <linux/seq_file.h>
 #include <linux/termios.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/device.h>               /* for MODULE_ALIAS_CHARDEV_MAJOR */
 
@@ -449,8 +450,8 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
                 }
 
 #ifdef SERIAL_DO_RESTART
-                return ((self->flags & ASYNC_HUP_NOTIFY) ?
-                        -EAGAIN : -ERESTARTSYS);
+                return (self->flags & ASYNC_HUP_NOTIFY) ?
+                        -EAGAIN : -ERESTARTSYS;
 #else
                 return -EAGAIN;
 #endif
@@ -1132,7 +1133,6 @@ static int ircomm_tty_data_indication(void *instance, void *sap,
                                       struct sk_buff *skb)
 {
         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
-        struct tty_ldisc *ld;
 
         IRDA_DEBUG(2, "%s()\n", __func__ );
 
@@ -1161,15 +1161,11 @@ static int ircomm_tty_data_indication(void *instance, void *sap,
         }
 
         /*
-         * Just give it over to the line discipline. There is no need to
-         * involve the flip buffers, since we are not running in an interrupt
-         * handler
+         * Use flip buffer functions since the code may be called from interrupt
+         * context
          */
-
-        ld = tty_ldisc_ref(self->tty);
-        if (ld)
-                ld->ops->receive_buf(self->tty, skb->data, NULL, skb->len);
-        tty_ldisc_deref(ld);
+        tty_insert_flip_string(self->tty, skb->data, skb->len);
+        tty_flip_buffer_push(self->tty);
 
         /* No need to kfree_skb - see ircomm_ttp_data_indication() */
 
diff --git a/net/irda/ircomm/ircomm_tty_ioctl.c b/net/irda/ircomm/ircomm_tty_ioctl.c
index 24cb3aa2bbfb..77c5e6499f8f 100644
--- a/net/irda/ircomm/ircomm_tty_ioctl.c
+++ b/net/irda/ircomm/ircomm_tty_ioctl.c
@@ -189,12 +189,12 @@ void ircomm_tty_set_termios(struct tty_struct *tty,
 }
 
 /*
- * Function ircomm_tty_tiocmget (tty, file)
+ * Function ircomm_tty_tiocmget (tty)
  *
  *
  *
  */
-int ircomm_tty_tiocmget(struct tty_struct *tty, struct file *file)
+int ircomm_tty_tiocmget(struct tty_struct *tty)
 {
         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
         unsigned int result;
@@ -214,12 +214,12 @@ int ircomm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 /*
- * Function ircomm_tty_tiocmset (tty, file, set, clear)
+ * Function ircomm_tty_tiocmset (tty, set, clear)
  *
  *
  *
  */
-int ircomm_tty_tiocmset(struct tty_struct *tty, struct file *file,
+int ircomm_tty_tiocmset(struct tty_struct *tty,
                         unsigned int set, unsigned int clear)
 {
         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
@@ -365,12 +365,12 @@ static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
 }
 
 /*
- * Function ircomm_tty_ioctl (tty, file, cmd, arg)
+ * Function ircomm_tty_ioctl (tty, cmd, arg)
  *
  *
  *
  */
-int ircomm_tty_ioctl(struct tty_struct *tty, struct file *file,
+int ircomm_tty_ioctl(struct tty_struct *tty,
                      unsigned int cmd, unsigned long arg)
 {
         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
diff --git a/net/irda/iriap.c b/net/irda/iriap.c
index fce364c6c71a..f876eed7d4aa 100644
--- a/net/irda/iriap.c
+++ b/net/irda/iriap.c
@@ -87,6 +87,8 @@ static inline void iriap_start_watchdog_timer(struct iriap_cb *self,
                          iriap_watchdog_timer_expired);
 }
 
+static struct lock_class_key irias_objects_key;
+
 /*
  * Function iriap_init (void)
  *
@@ -114,6 +116,9 @@ int __init iriap_init(void)
                 return -ENOMEM;
         }
 
+        lockdep_set_class_and_name(&irias_objects->hb_spinlock, &irias_objects_key,
+                                   "irias_objects");
+
         /*
          *  Register some default services for IrLMP
          */
@@ -502,7 +507,8 @@ static void iriap_getvaluebyclass_confirm(struct iriap_cb *self,
                 IRDA_DEBUG(4, "%s(), strlen=%d\n", __func__, value_len);
 
                 /* Make sure the string is null-terminated */
-                fp[n+value_len] = 0x00;
+                if (n + value_len < skb->len)
+                        fp[n + value_len] = 0x00;
                 IRDA_DEBUG(4, "Got string %s\n", fp+n);
 
                 /* Will truncate to IAS_MAX_STRING bytes */
@@ -655,10 +661,16 @@ static void iriap_getvaluebyclass_indication(struct iriap_cb *self,
         n = 1;
 
         name_len = fp[n++];
+
+        IRDA_ASSERT(name_len < IAS_MAX_CLASSNAME + 1, return;);
+
         memcpy(name, fp+n, name_len); n+=name_len;
         name[name_len] = '\0';
 
         attr_len = fp[n++];
+
+        IRDA_ASSERT(attr_len < IAS_MAX_ATTRIBNAME + 1, return;);
+
         memcpy(attr, fp+n, attr_len); n+=attr_len;
         attr[attr_len] = '\0';
 
diff --git a/net/irda/irlan/Makefile b/net/irda/irlan/Makefile
index 77549bc8641b..94eefbc8e6b9 100644
--- a/net/irda/irlan/Makefile
+++ b/net/irda/irlan/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_IRLAN) += irlan.o
 
-irlan-objs := irlan_common.o irlan_eth.o irlan_event.o irlan_client.o irlan_provider.o irlan_filter.o irlan_provider_event.o irlan_client_event.o
+irlan-y := irlan_common.o irlan_eth.o irlan_event.o irlan_client.o irlan_provider.o irlan_filter.o irlan_provider_event.o irlan_client_event.o
diff --git a/net/irda/irlan/irlan_eth.c b/net/irda/irlan/irlan_eth.c
index 5bb8353105cc..8ee1ff6c742f 100644
--- a/net/irda/irlan/irlan_eth.c
+++ b/net/irda/irlan/irlan_eth.c
@@ -45,13 +45,11 @@ static int  irlan_eth_close(struct net_device *dev);
 static netdev_tx_t  irlan_eth_xmit(struct sk_buff *skb,
                                          struct net_device *dev);
 static void irlan_eth_set_multicast_list( struct net_device *dev);
-static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev);
 
 static const struct net_device_ops irlan_eth_netdev_ops = {
         .ndo_open               = irlan_eth_open,
         .ndo_stop               = irlan_eth_close,
         .ndo_start_xmit         = irlan_eth_xmit,
-        .ndo_get_stats          = irlan_eth_get_stats,
         .ndo_set_multicast_list = irlan_eth_set_multicast_list,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
@@ -208,10 +206,10 @@ static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
                  * tried :-) DB
                  */
                 /* irttp_data_request already free the packet */
-                self->stats.tx_dropped++;
+                dev->stats.tx_dropped++;
         } else {
-                self->stats.tx_packets++;
-                self->stats.tx_bytes += len;
+                dev->stats.tx_packets++;
+                dev->stats.tx_bytes += len;
         }
 
         return NETDEV_TX_OK;
@@ -226,15 +224,16 @@ static netdev_tx_t irlan_eth_xmit(struct sk_buff *skb,
 int irlan_eth_receive(void *instance, void *sap, struct sk_buff *skb)
 {
         struct irlan_cb *self = instance;
+        struct net_device *dev = self->dev;
 
         if (skb == NULL) {
-                ++self->stats.rx_dropped;
+                dev->stats.rx_dropped++;
                 return 0;
         }
         if (skb->len < ETH_HLEN) {
                 IRDA_DEBUG(0, "%s() : IrLAN frame too short (%d)\n",
                            __func__, skb->len);
-                ++self->stats.rx_dropped;
+                dev->stats.rx_dropped++;
                 dev_kfree_skb(skb);
                 return 0;
         }
@@ -244,10 +243,10 @@ int irlan_eth_receive(void *instance, void *sap, struct sk_buff *skb)
          * might have been previously set by the low level IrDA network
          * device driver
          */
-        skb->protocol = eth_type_trans(skb, self->dev); /* Remove eth header */
+        skb->protocol = eth_type_trans(skb, dev); /* Remove eth header */
 
-        self->stats.rx_packets++;
-        self->stats.rx_bytes += skb->len;
+        dev->stats.rx_packets++;
+        dev->stats.rx_bytes += skb->len;
 
         netif_rx(skb);   /* Eat it! */
 
@@ -348,16 +347,3 @@ static void irlan_eth_set_multicast_list(struct net_device *dev)
         else
                 irlan_set_broadcast_filter(self, FALSE);
 }
-
-/*
- * Function irlan_get_stats (dev)
- *
- *    Get the current statistics for this device
- *
- */
-static struct net_device_stats *irlan_eth_get_stats(struct net_device *dev)
-{
-        struct irlan_cb *self = netdev_priv(dev);
-
-        return &self->stats;
-}
diff --git a/net/irda/irlan/irlan_event.c b/net/irda/irlan/irlan_event.c
index cbcb4eb54037..43f16040a6fe 100644
--- a/net/irda/irlan/irlan_event.c
+++ b/net/irda/irlan/irlan_event.c
@@ -24,7 +24,7 @@
 
 #include <net/irda/irlan_event.h>
 
-char *irlan_state[] = {
+const char * const irlan_state[] = {
         "IRLAN_IDLE",
         "IRLAN_QUERY",
         "IRLAN_CONN",
diff --git a/net/irda/irlan/irlan_filter.c b/net/irda/irlan/irlan_filter.c
index 9ff7823abec7..7977be7caf0f 100644
--- a/net/irda/irlan/irlan_filter.c
+++ b/net/irda/irlan/irlan_filter.c
@@ -143,12 +143,8 @@ void irlan_filter_request(struct irlan_cb *self, struct sk_buff *skb)
  */
 void irlan_check_command_param(struct irlan_cb *self, char *param, char *value)
 {
-        __u8 *bytes;
-
         IRDA_DEBUG(4, "%s()\n", __func__ );
 
-        bytes = value;
-
         IRDA_ASSERT(self != NULL, return;);
         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 
diff --git a/net/irda/irlan/irlan_provider.c b/net/irda/irlan/irlan_provider.c
index 5cf5e6c872bb..b8af74ab8b68 100644
--- a/net/irda/irlan/irlan_provider.c
+++ b/net/irda/irlan/irlan_provider.c
@@ -128,7 +128,6 @@ static void irlan_provider_connect_indication(void *instance, void *sap,
 {
         struct irlan_cb *self;
         struct tsap_cb *tsap;
-        __u32 saddr, daddr;
 
         IRDA_DEBUG(0, "%s()\n", __func__ );
 
@@ -141,8 +140,6 @@ static void irlan_provider_connect_indication(void *instance, void *sap,
         IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;);
         IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;);
 
-        daddr = irttp_get_daddr(tsap);
-        saddr = irttp_get_saddr(tsap);
         self->provider.max_sdu_size = max_sdu_size;
         self->provider.max_header_size = max_header_size;
 
diff --git a/net/irda/irlap.c b/net/irda/irlap.c
index 783c5f367d29..005b424494a0 100644
--- a/net/irda/irlap.c
+++ b/net/irda/irlap.c
@@ -165,7 +165,7 @@ struct irlap_cb *irlap_open(struct net_device *dev, struct qos_info *qos,
 
         irlap_apply_default_connection_parameters(self);
 
-        self->N3 = 3; /* # connections attemts to try before giving up */
+        self->N3 = 3; /* # connections attempts to try before giving up */
 
         self->state = LAP_NDM;
 
diff --git a/net/irda/irlap_event.c b/net/irda/irlap_event.c
index d434c8880745..ccd214f9d196 100644
--- a/net/irda/irlap_event.c
+++ b/net/irda/irlap_event.c
@@ -708,7 +708,7 @@ static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event,
 
                                 self->frame_sent = TRUE;
                         }
-                        /* Readjust our timer to accomodate devices
+                        /* Readjust our timer to accommodate devices
                          * doing faster or slower discovery than us...
                          * Jean II */
                         irlap_start_query_timer(self, info->S, info->s);
@@ -931,7 +931,7 @@ static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
                 irlap_send_rr_frame(self, CMD_FRAME);
 
                 /* The timer is set to half the normal timer to quickly
-                 * detect a failure to negociate the new connection
+                 * detect a failure to negotiate the new connection
                  * parameters. IrLAP 6.11.3.2, note 3.
                  * Note that currently we don't process this failure
                  * properly, as we should do a quick disconnect.
@@ -1052,7 +1052,7 @@ static int irlap_state_xmit_p(struct irlap_cb *self, IRLAP_EVENT event,
                                 return -EPROTO;
                         }
 
-                        /* Substract space used by this skb */
+                        /* Subtract space used by this skb */
                         self->bytes_left -= skb->len;
 #else   /* CONFIG_IRDA_DYNAMIC_WINDOW */
                         /* Window has been adjusted for the max packet
@@ -1808,7 +1808,7 @@ static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event,
 
                                 return -EPROTO; /* Try again later */
                         }
-                        /* Substract space used by this skb */
+                        /* Subtract space used by this skb */
                         self->bytes_left -= skb->len;
 #else   /* CONFIG_IRDA_DYNAMIC_WINDOW */
                         /* Window has been adjusted for the max packet
@@ -2227,8 +2227,6 @@ static int irlap_state_nrm_s(struct irlap_cb *self, IRLAP_EVENT event,
 static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event,
                               struct sk_buff *skb, struct irlap_info *info)
 {
-        int ret = 0;
-
         IRDA_DEBUG(1, "%s()\n", __func__);
 
         IRDA_ASSERT(self != NULL, return -ENODEV;);
@@ -2289,7 +2287,6 @@ static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event,
                 IRDA_DEBUG(1, "%s(), Unknown event %d, (%s)\n", __func__,
                            event, irlap_event[event]);
 
-                ret = -EINVAL;
                 break;
         }
 
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index 688222cbf55b..8c004161a843 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -848,7 +848,7 @@ void irlap_send_data_primary_poll(struct irlap_cb *self, struct sk_buff *skb)
          * though IrLAP is currently sending the *last* frame of the
          * tx-window, the driver most likely has only just started
          * sending the *first* frame of the same tx-window.
-         * I.e. we are always at the very begining of or Tx window.
+         * I.e. we are always at the very beginning of or Tx window.
          * Now, we are supposed to set the final timer from the end
          * of our tx-window to let the other peer reply. So, we need
          * to add extra time to compensate for the fact that we
diff --git a/net/irda/irlmp.c b/net/irda/irlmp.c
index 0e7d8bde145d..6115a44c0a24 100644
--- a/net/irda/irlmp.c
+++ b/net/irda/irlmp.c
@@ -939,7 +939,7 @@ struct irda_device_info *irlmp_get_discoveries(int *pn, __u16 mask, int nslots)
         }
 
         /* Return current cached discovery log */
-        return(irlmp_copy_discoveries(irlmp->cachelog, pn, mask, TRUE));
+        return irlmp_copy_discoveries(irlmp->cachelog, pn, mask, TRUE);
 }
 EXPORT_SYMBOL(irlmp_get_discoveries);
 
diff --git a/net/irda/irlmp_event.c b/net/irda/irlmp_event.c
index c1fb5db81042..9505a7d06f1a 100644
--- a/net/irda/irlmp_event.c
+++ b/net/irda/irlmp_event.c
@@ -498,7 +498,7 @@ static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event,
         switch (event) {
 #ifdef CONFIG_IRDA_ULTRA
         case LM_UDATA_INDICATION:
-                /* This is most bizzare. Those packets are  aka unreliable
+                /* This is most bizarre. Those packets are  aka unreliable
                  * connected, aka IrLPT or SOCK_DGRAM/IRDAPROTO_UNITDATA.
                  * Why do we pass them as Ultra ??? Jean II */
                 irlmp_connless_data_indication(self, skb);
diff --git a/net/irda/irlmp_frame.c b/net/irda/irlmp_frame.c
index 3750884094da..062e63b1c5c4 100644
--- a/net/irda/irlmp_frame.c
+++ b/net/irda/irlmp_frame.c
@@ -448,7 +448,7 @@ static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
             (self->cache.slsap_sel == slsap_sel) &&
             (self->cache.dlsap_sel == dlsap_sel))
         {
-                return (self->cache.lsap);
+                return self->cache.lsap;
         }
 #endif
 
diff --git a/net/irda/irnet/Makefile b/net/irda/irnet/Makefile
index b3ee01e0def3..61c365c8a2a0 100644
--- a/net/irda/irnet/Makefile
+++ b/net/irda/irnet/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_IRNET) += irnet.o
 
-irnet-objs := irnet_ppp.o irnet_irda.o
+irnet-y := irnet_ppp.o irnet_irda.o
diff --git a/net/irda/irnet/irnet.h b/net/irda/irnet/irnet.h
index 4300df35d37d..979ecb2435a7 100644
--- a/net/irda/irnet/irnet.h
+++ b/net/irda/irnet/irnet.h
@@ -73,7 +73,7 @@
  * Infinite thanks to those brave souls for providing the infrastructure
  * upon which IrNET is built.
  *
- * Thanks to all my collegues in HP for helping me. In particular,
+ * Thanks to all my colleagues in HP for helping me. In particular,
  * thanks to Salil Pradhan and Bill Serra for W2k testing...
  * Thanks to Luiz Magalhaes for irnetd and much testing...
  *
@@ -458,6 +458,8 @@ typedef struct irnet_socket
   int                   disco_index;    /* Last read in the discovery log */
   int                   disco_number;   /* Size of the discovery log */
 
+  struct mutex          lock;
+
 } irnet_socket;
 
 /*
diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index e98e40d76f4f..7f17a8020e8a 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -238,7 +238,7 @@ irnet_ias_to_tsap(irnet_socket *	self,
   DEXIT(IRDA_SR_TRACE, "\n");
 
   /* Return the TSAP */
-  return(dtsap_sel);
+  return dtsap_sel;
 }
 
 /*------------------------------------------------------------------*/
@@ -301,7 +301,7 @@ irnet_connect_tsap(irnet_socket *	self)
     {
       clear_bit(0, &self->ttp_connect);
       DERROR(IRDA_SR_ERROR, "connect aborted!\n");
-      return(err);
+      return err;
     }
 
   /* Connect to remote device */
@@ -312,7 +312,7 @@ irnet_connect_tsap(irnet_socket *	self)
     {
       clear_bit(0, &self->ttp_connect);
       DERROR(IRDA_SR_ERROR, "connect aborted!\n");
-      return(err);
+      return err;
     }
 
   /* The above call is non-blocking.
@@ -321,7 +321,7 @@ irnet_connect_tsap(irnet_socket *	self)
    * See you there ;-) */
 
   DEXIT(IRDA_SR_TRACE, "\n");
-  return(err);
+  return err;
 }
 
 /*------------------------------------------------------------------*/
@@ -362,10 +362,10 @@ irnet_discover_next_daddr(irnet_socket *	self)
       /* The above request is non-blocking.
        * After a while, IrDA will call us back in irnet_discovervalue_confirm()
        * We will then call irnet_ias_to_tsap() and come back here again... */
-      return(0);
+      return 0;
     }
   else
-    return(1);
+    return 1;
 }
 
 /*------------------------------------------------------------------*/
@@ -436,7 +436,7 @@ irnet_discover_daddr_and_lsap_sel(irnet_socket *	self)
   /* Follow me in irnet_discovervalue_confirm() */
 
   DEXIT(IRDA_SR_TRACE, "\n");
-  return(0);
+  return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -485,7 +485,7 @@ irnet_dname_to_daddr(irnet_socket *	self)
   /* No luck ! */
   DEBUG(IRDA_SR_INFO, "cannot discover device ``%s'' !!!\n", self->rname);
   kfree(discoveries);
-  return(-EADDRNOTAVAIL);
+  return -EADDRNOTAVAIL;
 }
 
 
@@ -527,7 +527,7 @@ irda_irnet_create(irnet_socket *	self)
   INIT_WORK(&self->disconnect_work, irnet_ppp_disconnect);
 
   DEXIT(IRDA_SOCK_TRACE, "\n");
-  return(0);
+  return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -601,7 +601,7 @@ irda_irnet_connect(irnet_socket *	self)
    * We will finish the connection procedure in irnet_connect_tsap().
    */
   DEXIT(IRDA_SOCK_TRACE, "\n");
-  return(0);
+  return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -733,7 +733,7 @@ irnet_daddr_to_dname(irnet_socket *	self)
   /* No luck ! */
   DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n", self->daddr);
   kfree(discoveries);
-  return(-EADDRNOTAVAIL);
+  return -EADDRNOTAVAIL;
 }
 
 /*------------------------------------------------------------------*/
diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c
index dfe7b38dd4af..2bb2beb6a373 100644
--- a/net/irda/irnet/irnet_ppp.c
+++ b/net/irda/irnet/irnet_ppp.c
@@ -15,7 +15,6 @@
 
 #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 */
 
@@ -106,6 +105,9 @@ irnet_ctrl_write(irnet_socket *	ap,
               while(isspace(start[length - 1]))
                 length--;
 
+              DABORT(length < 5 || length > NICKNAME_MAX_LEN + 5,
+                     -EINVAL, CTRL_ERROR, "Invalid nickname.\n");
+
               /* Copy the name for later reuse */
               memcpy(ap->rname, start + 5, length - 5);
               ap->rname[length - 5] = '\0';
@@ -166,7 +168,7 @@ irnet_ctrl_write(irnet_socket *	ap,
     }
 
   /* Success : we have parsed all commands successfully */
-  return(count);
+  return count;
 }
 
 #ifdef INITIAL_DISCOVERY
@@ -300,7 +302,7 @@ irnet_ctrl_read(irnet_socket *	ap,
         }
 
       DEXIT(CTRL_TRACE, "\n");
-      return(strlen(event));
+      return strlen(event);
     }
 #endif /* INITIAL_DISCOVERY */
 
@@ -409,7 +411,7 @@ irnet_ctrl_read(irnet_socket *	ap,
     }
 
   DEXIT(CTRL_TRACE, "\n");
-  return(strlen(event));
+  return strlen(event);
 }
 
 /*------------------------------------------------------------------*/
@@ -480,7 +482,6 @@ dev_irnet_open(struct inode *	inode,
   ap = kzalloc(sizeof(*ap), GFP_KERNEL);
   DABORT(ap == NULL, -ENOMEM, FS_ERROR, "Can't allocate struct irnet...\n");
 
-  lock_kernel();
   /* initialize the irnet structure */
   ap->file = file;
 
@@ -502,18 +503,20 @@ dev_irnet_open(struct inode *	inode,
     {
       DERROR(FS_ERROR, "Can't setup IrDA link...\n");
       kfree(ap);
-      unlock_kernel();
+
       return err;
     }
 
   /* For the control channel */
   ap->event_index = irnet_events.index; /* Cancel all past events */
 
+  mutex_init(&ap->lock);
+
   /* Put our stuff where we will be able to find it later */
   file->private_data = ap;
 
   DEXIT(FS_TRACE, " - ap=0x%p\n", ap);
-  unlock_kernel();
+
   return 0;
 }
 
@@ -623,7 +626,7 @@ dev_irnet_poll(struct file *	file,
     mask |= irnet_ctrl_poll(ap, file, wait);
 
   DEXIT(FS_TRACE, " - mask=0x%X\n", mask);
-  return(mask);
+  return mask;
 }
 
 /*------------------------------------------------------------------*/
@@ -663,8 +666,10 @@ dev_irnet_ioctl(
       if((val == N_SYNC_PPP) || (val == N_PPP))
         {
           DEBUG(FS_INFO, "Entering PPP discipline.\n");
-          /* PPP channel setup (ap->chan in configued in dev_irnet_open())*/
-          lock_kernel();
+          /* PPP channel setup (ap->chan in configured in dev_irnet_open())*/
+          if (mutex_lock_interruptible(&ap->lock))
+                  return -EINTR;
+
           err = ppp_register_channel(&ap->chan);
           if(err == 0)
             {
@@ -677,14 +682,17 @@ dev_irnet_ioctl(
             }
           else
             DERROR(FS_ERROR, "Can't setup PPP channel...\n");
-          unlock_kernel();
+
+          mutex_unlock(&ap->lock);
         }
       else
         {
           /* In theory, should be N_TTY */
           DEBUG(FS_INFO, "Exiting PPP discipline.\n");
           /* Disconnect from the generic PPP layer */
-          lock_kernel();
+          if (mutex_lock_interruptible(&ap->lock))
+                  return -EINTR;
+
           if(ap->ppp_open)
             {
               ap->ppp_open = 0;
@@ -693,24 +701,31 @@ dev_irnet_ioctl(
           else
             DERROR(FS_ERROR, "Channel not registered !\n");
           err = 0;
-          unlock_kernel();
+
+          mutex_unlock(&ap->lock);
         }
       break;
 
       /* Query PPP channel and unit number */
     case PPPIOCGCHAN:
-      lock_kernel();
+      if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
+
       if(ap->ppp_open && !put_user(ppp_channel_index(&ap->chan),
                                                 (int __user *)argp))
         err = 0;
-      unlock_kernel();
+
+      mutex_unlock(&ap->lock);
       break;
     case PPPIOCGUNIT:
-      lock_kernel();
+      if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
+
       if(ap->ppp_open && !put_user(ppp_unit_number(&ap->chan),
                                                 (int __user *)argp))
         err = 0;
-      unlock_kernel();
+
+      mutex_unlock(&ap->lock);
       break;
 
       /* All these ioctls can be passed both directly and from ppp_generic,
@@ -730,9 +745,12 @@ dev_irnet_ioctl(
       if(!capable(CAP_NET_ADMIN))
         err = -EPERM;
       else {
-        lock_kernel();
+        if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
+
         err = ppp_irnet_ioctl(&ap->chan, cmd, arg);
-        unlock_kernel();
+
+        mutex_unlock(&ap->lock);
       }
       break;
 
@@ -740,7 +758,9 @@ dev_irnet_ioctl(
       /* Get termios */
     case TCGETS:
       DEBUG(FS_INFO, "Get termios.\n");
-      lock_kernel();
+      if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
+
 #ifndef TCGETS2
       if(!kernel_termios_to_user_termios((struct termios __user *)argp, &ap->termios))
         err = 0;
@@ -748,12 +768,15 @@ dev_irnet_ioctl(
       if(kernel_termios_to_user_termios_1((struct termios __user *)argp, &ap->termios))
         err = 0;
 #endif
-      unlock_kernel();
+
+      mutex_unlock(&ap->lock);
       break;
       /* Set termios */
     case TCSETSF:
       DEBUG(FS_INFO, "Set termios.\n");
-      lock_kernel();
+      if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
+
 #ifndef TCGETS2
       if(!user_termios_to_kernel_termios(&ap->termios, (struct termios __user *)argp))
         err = 0;
@@ -761,7 +784,8 @@ dev_irnet_ioctl(
       if(!user_termios_to_kernel_termios_1(&ap->termios, (struct termios __user *)argp))
         err = 0;
 #endif
-      unlock_kernel();
+
+      mutex_unlock(&ap->lock);
       break;
 
       /* Set DTR/RTS */
@@ -784,9 +808,10 @@ dev_irnet_ioctl(
        * We should also worry that we don't accept junk here and that
        * we get rid of our own buffers */
 #ifdef FLUSH_TO_PPP
-      lock_kernel();
+      if (mutex_lock_interruptible(&ap->lock))
+              return -EINTR;
       ppp_output_wakeup(&ap->chan);
-      unlock_kernel();
+      mutex_unlock(&ap->lock);
 #endif /* FLUSH_TO_PPP */
       err = 0;
       break;
diff --git a/net/irda/irnet/irnet_ppp.h b/net/irda/irnet/irnet_ppp.h
index b5df2418f90c..940225866da0 100644
--- a/net/irda/irnet/irnet_ppp.h
+++ b/net/irda/irnet/irnet_ppp.h
@@ -103,7 +103,8 @@ static const struct file_operations irnet_device_fops =
         .poll           = dev_irnet_poll,
         .unlocked_ioctl = dev_irnet_ioctl,
         .open           = dev_irnet_open,
-        .release        = dev_irnet_close
+        .release        = dev_irnet_close,
+        .llseek         = noop_llseek,
   /* Also : llseek, readdir, mmap, flush, fsync, fasync, lock, readv, writev */
 };
 
diff --git a/net/irda/irproc.c b/net/irda/irproc.c
index 318766e5dbdf..b9ac598e2116 100644
--- a/net/irda/irproc.c
+++ b/net/irda/irproc.c
@@ -65,15 +65,14 @@ static const struct irda_entry irda_dirs[] = {
 void __init irda_proc_register(void)
 {
         int i;
-        struct proc_dir_entry *d;
 
         proc_irda = proc_mkdir("irda", init_net.proc_net);
         if (proc_irda == NULL)
                 return;
 
         for (i = 0; i < ARRAY_SIZE(irda_dirs); i++)
-                d = proc_create(irda_dirs[i].name, 0, proc_irda,
-                                irda_dirs[i].fops);
+                (void) proc_create(irda_dirs[i].name, 0, proc_irda,
+                                   irda_dirs[i].fops);
 }
 
 /*
diff --git a/net/irda/irqueue.c b/net/irda/irqueue.c
index 849aaf0dabb5..9715e6e5900b 100644
--- a/net/irda/irqueue.c
+++ b/net/irda/irqueue.c
@@ -40,7 +40,7 @@
  *      o the hash function for ints is pathetic (but could be changed)
  *      o locking is sometime suspicious (especially during enumeration)
  *      o most users have only a few elements (== overhead)
- *      o most users never use seach, so don't benefit from hashing
+ *      o most users never use search, so don't benefit from hashing
  * Problem already fixed :
  *      o not 64 bit compliant (most users do hashv = (int) self)
  *      o hashbin_remove() is broken => use hashbin_remove_this()
diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index 285761e77d90..9d9af4606970 100644
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -550,22 +550,30 @@ EXPORT_SYMBOL(irttp_close_tsap);
  */
 int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
 {
+        int ret;
+
         IRDA_ASSERT(self != NULL, return -1;);
         IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
         IRDA_ASSERT(skb != NULL, return -1;);
 
         IRDA_DEBUG(4, "%s()\n", __func__);
 
+        /* Take shortcut on zero byte packets */
+        if (skb->len == 0) {
+                ret = 0;
+                goto err;
+        }
+
         /* Check that nothing bad happens */
-        if ((skb->len == 0) || (!self->connected)) {
-                IRDA_DEBUG(1, "%s(), No data, or not connected\n",
-                           __func__);
+        if (!self->connected) {
+                IRDA_WARNING("%s(), Not connected\n", __func__);
+                ret = -ENOTCONN;
                 goto err;
         }
 
         if (skb->len > self->max_seg_size) {
-                IRDA_DEBUG(1, "%s(), UData is too large for IrLAP!\n",
-                           __func__);
+                IRDA_ERROR("%s(), UData is too large for IrLAP!\n", __func__);
+                ret = -EMSGSIZE;
                 goto err;
         }
 
@@ -576,7 +584,7 @@ int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
 
 err:
         dev_kfree_skb(skb);
-        return -1;
+        return ret;
 }
 EXPORT_SYMBOL(irttp_udata_request);
 
@@ -599,9 +607,15 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
         IRDA_DEBUG(2, "%s() : queue len = %d\n", __func__,
                    skb_queue_len(&self->tx_queue));
 
+        /* Take shortcut on zero byte packets */
+        if (skb->len == 0) {
+                ret = 0;
+                goto err;
+        }
+
         /* Check that nothing bad happens */
-        if ((skb->len == 0) || (!self->connected)) {
-                IRDA_WARNING("%s: No data, or not connected\n", __func__);
+        if (!self->connected) {
+                IRDA_WARNING("%s: Not connected\n", __func__);
                 ret = -ENOTCONN;
                 goto err;
         }
@@ -1179,7 +1193,7 @@ EXPORT_SYMBOL(irttp_connect_request);
 /*
  * Function irttp_connect_confirm (handle, qos, skb)
  *
- *    Sevice user confirms TSAP connection with peer.
+ *    Service user confirms TSAP connection with peer.
  *
  */
 static void irttp_connect_confirm(void *instance, void *sap,
diff --git a/net/irda/parameters.c b/net/irda/parameters.c
index fc1a20565e2d..71cd38c1a67f 100644
--- a/net/irda/parameters.c
+++ b/net/irda/parameters.c
@@ -298,6 +298,8 @@ static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi,
 
         p.pi = pi;     /* In case handler needs to know */
         p.pl = buf[1]; /* Extract length of value */
+        if (p.pl > 32)
+                p.pl = 32;
 
         IRDA_DEBUG(2, "%s(), pi=%#x, pl=%d\n", __func__,
                    p.pi, p.pl);
@@ -318,7 +320,7 @@ static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi,
                    (__u8) str[0], (__u8) str[1]);
 
         /* Null terminate string */
-        str[p.pl+1] = '\0';
+        str[p.pl] = '\0';
 
         p.pv.c = str; /* Handler will need to take a copy */
 
diff --git a/net/irda/qos.c b/net/irda/qos.c
index 2b00974e5bae..1b51bcf42394 100644
--- a/net/irda/qos.c
+++ b/net/irda/qos.c
@@ -39,16 +39,16 @@
 #include <net/irda/irlap_frame.h>
 
 /*
- * Maximum values of the baud rate we negociate with the other end.
+ * Maximum values of the baud rate we negotiate with the other end.
  * Most often, you don't have to change that, because Linux-IrDA will
  * use the maximum offered by the link layer, which usually works fine.
  * In some very rare cases, you may want to limit it to lower speeds...
  */
 int sysctl_max_baud_rate = 16000000;
 /*
- * Maximum value of the lap disconnect timer we negociate with the other end.
+ * Maximum value of the lap disconnect timer we negotiate with the other end.
  * Most often, the value below represent the best compromise, but some user
- * may want to keep the LAP alive longuer or shorter in case of link failure.
+ * may want to keep the LAP alive longer or shorter in case of link failure.
  * Remember that the threshold time (early warning) is fixed to 3s...
  */
 int sysctl_max_noreply_time = 12;
@@ -411,7 +411,7 @@ static void irlap_adjust_qos_settings(struct qos_info *qos)
          * Fix tx data size according to user limits - Jean II
          */
         if (qos->data_size.value > sysctl_max_tx_data_size)
-                /* Allow non discrete adjustement to avoid loosing capacity */
+                /* Allow non discrete adjustement to avoid losing capacity */
                 qos->data_size.value = sysctl_max_tx_data_size;
         /*
          * Override Tx window if user request it. - Jean II
diff --git a/net/irda/timer.c b/net/irda/timer.c
index 0335ba0cc593..f418cb2ad49c 100644
--- a/net/irda/timer.c
+++ b/net/irda/timer.c
@@ -59,7 +59,7 @@ void irlap_start_query_timer(struct irlap_cb *self, int S, int s)
          * slot time, plus add some extra time to properly receive the last
          * discovery packet (which is longer due to extra discovery info),
          * to avoid messing with for incomming connections requests and
-         * to accomodate devices that perform discovery slower than us.
+         * to accommodate devices that perform discovery slower than us.
          * Jean II */
         timeout = ((sysctl_slot_timeout * HZ / 1000) * (S - s)
                    + XIDEXTRA_TIMEOUT + SMALLBUSY_TIMEOUT);