12 files changed, 97 insertions, 135 deletions

diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index 0eb7d596d470..06c97c60d542 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -89,7 +89,6 @@ static int irda_data_indication(void *instance, void *sap, struct sk_buff *skb)
 
         self = instance;
         sk = instance;
-        IRDA_ASSERT(sk != NULL, return -1;);
 
         err = sock_queue_rcv_skb(sk, skb);
         if (err) {
@@ -131,14 +130,12 @@ static void irda_disconnect_indication(void *instance, void *sap,
         }
 
         /* Prevent race conditions with irda_release() and irda_shutdown() */
+        bh_lock_sock(sk);
         if (!sock_flag(sk, SOCK_DEAD) && sk->sk_state != TCP_CLOSE) {
-                lock_sock(sk);
                 sk->sk_state     = TCP_CLOSE;
-                sk->sk_err       = ECONNRESET;
                 sk->sk_shutdown |= SEND_SHUTDOWN;
 
                 sk->sk_state_change(sk);
-                release_sock(sk);
 
                 /* Close our TSAP.
                  * If we leave it open, IrLMP put it back into the list of
@@ -158,6 +155,7 @@ static void irda_disconnect_indication(void *instance, void *sap,
                         self->tsap = NULL;
                 }
         }
+        bh_unlock_sock(sk);
 
         /* Note : once we are there, there is not much you want to do
          * with the socket anymore, apart from closing it.
@@ -220,7 +218,7 @@ static void irda_connect_confirm(void *instance, void *sap,
                 break;
         default:
                 self->max_data_size = irttp_get_max_seg_size(self->tsap);
-        };
+        }
 
         IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __FUNCTION__,
                    self->max_data_size);
@@ -283,7 +281,7 @@ static void irda_connect_indication(void *instance, void *sap,
                 break;
         default:
                 self->max_data_size = irttp_get_max_seg_size(self->tsap);
-        };
+        }
 
         IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __FUNCTION__,
                    self->max_data_size);
@@ -306,8 +304,6 @@ static void irda_connect_response(struct irda_sock *self)
 
         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
-        IRDA_ASSERT(self != NULL, return;);
-
         skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
                         GFP_ATOMIC);
         if (skb == NULL) {
@@ -337,7 +333,7 @@ static void irda_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 
         self = instance;
         sk = instance;
-        IRDA_ASSERT(sk != NULL, return;);
+        BUG_ON(sk == NULL);
 
         switch (flow) {
         case FLOW_STOP:
@@ -449,7 +445,7 @@ static void irda_discovery_timeout(u_long priv)
         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
         self = (struct irda_sock *) priv;
-        IRDA_ASSERT(self != NULL, return;);
+        BUG_ON(self == NULL);
 
         /* Nothing for the caller */
         self->cachelog = NULL;
@@ -546,8 +542,6 @@ static int irda_find_lsap_sel(struct irda_sock *self, char *name)
 {
         IRDA_DEBUG(2, "%s(%p, %s)\n", __FUNCTION__, self, name);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         if (self->iriap) {
                 IRDA_WARNING("%s(): busy with a previous query\n",
                              __FUNCTION__);
@@ -635,8 +629,6 @@ static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
 
         IRDA_DEBUG(2, "%s(), name=%s\n", __FUNCTION__, name);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         /* Ask lmp for the current discovery log
          * Note : we have to use irlmp_get_discoveries(), as opposed
          * to play with the cachelog directly, because while we are
@@ -784,8 +776,6 @@ static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         struct irda_sock *self = irda_sk(sk);
         int err;
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         IRDA_DEBUG(2, "%s(%p)\n", __FUNCTION__, self);
 
         if (addr_len != sizeof(struct sockaddr_irda))
@@ -841,8 +831,6 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
 
         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         err = irda_create(newsock, sk->sk_protocol);
         if (err)
                 return err;
@@ -873,44 +861,28 @@ static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
          * calling us, the data is waiting for us ;-)
          * Jean II
          */
-        skb = skb_dequeue(&sk->sk_receive_queue);
-        if (skb == NULL) {
-                int ret = 0;
-                DECLARE_WAITQUEUE(waitq, current);
+        while (1) {
+                skb = skb_dequeue(&sk->sk_receive_queue);
+                if (skb)
+                        break;
 
                 /* Non blocking operation */
                 if (flags & O_NONBLOCK)
                         return -EWOULDBLOCK;
 
-                /* The following code is a cut'n'paste of the
-                 * wait_event_interruptible() macro.
-                 * We don't us the macro because the condition has
-                 * side effects : we want to make sure that only one
-                 * skb get dequeued - Jean II */
-                add_wait_queue(sk->sk_sleep, &waitq);
-                for (;;) {
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        skb = skb_dequeue(&sk->sk_receive_queue);
-                        if (skb != NULL)
-                                break;
-                        if (!signal_pending(current)) {
-                                schedule();
-                                continue;
-                        }
-                        ret = -ERESTARTSYS;
-                        break;
-                }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &waitq);
-                if(ret)
-                        return -ERESTARTSYS;
+                err = wait_event_interruptible(*(sk->sk_sleep),
+                                        skb_peek(&sk->sk_receive_queue));
+                if (err)
+                        return err;
         }
 
         newsk = newsock->sk;
+        if (newsk == NULL)
+                return -EIO;
+
         newsk->sk_state = TCP_ESTABLISHED;
 
         new = irda_sk(newsk);
-        IRDA_ASSERT(new != NULL, return -1;);
 
         /* Now attach up the new socket */
         new->tsap = irttp_dup(self->tsap, new);
@@ -1061,7 +1033,8 @@ static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
 
         if (sk->sk_state != TCP_ESTABLISHED) {
                 sock->state = SS_UNCONNECTED;
-                return sock_error(sk);  /* Always set at this point */
+                err = sock_error(sk);
+                return err? err : -ECONNRESET;
         }
 
         sock->state = SS_CONNECTED;
@@ -1171,8 +1144,6 @@ static void irda_destroy_socket(struct irda_sock *self)
 {
         IRDA_DEBUG(2, "%s(%p)\n", __FUNCTION__, self);
 
-        IRDA_ASSERT(self != NULL, return;);
-
         /* Unregister with IrLMP */
         irlmp_unregister_client(self->ckey);
         irlmp_unregister_service(self->skey);
@@ -1274,7 +1245,6 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
         struct sock *sk = sock->sk;
         struct irda_sock *self;
         struct sk_buff *skb;
-        unsigned char *asmptr;
         int err;
 
         IRDA_DEBUG(4, "%s(), len=%zd\n", __FUNCTION__, len);
@@ -1292,7 +1262,6 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
                 return -ENOTCONN;
 
         self = irda_sk(sk);
-        IRDA_ASSERT(self != NULL, return -1;);
 
         /* Check if IrTTP is wants us to slow down */
 
@@ -1317,9 +1286,9 @@ static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
                 return -ENOBUFS;
 
         skb_reserve(skb, self->max_header_size + 16);
-
-        asmptr = skb->h.raw = skb_put(skb, len);
-        err = memcpy_fromiovec(asmptr, msg->msg_iov, len);
+        skb_reset_transport_header(skb);
+        skb_put(skb, len);
+        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
         if (err) {
                 kfree_skb(skb);
                 return err;
@@ -1355,16 +1324,16 @@ static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
 
         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-        IRDA_ASSERT(!sock_error(sk), return -1;);
+        if ((err = sock_error(sk)) < 0)
+                return err;
 
         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
                                 flags & MSG_DONTWAIT, &err);
         if (!skb)
                 return err;
 
-        skb->h.raw = skb->data;
-        copied     = skb->len;
+        skb_reset_transport_header(skb);
+        copied = skb->len;
 
         if (copied > size) {
                 IRDA_DEBUG(2, "%s(), Received truncated frame (%zd < %zd)!\n",
@@ -1403,13 +1372,13 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
         struct irda_sock *self = irda_sk(sk);
         int noblock = flags & MSG_DONTWAIT;
         size_t copied = 0;
-        int target = 1;
-        DECLARE_WAITQUEUE(waitq, current);
+        int target, err;
+        long timeo;
 
         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-        IRDA_ASSERT(!sock_error(sk), return -1;);
+        if ((err = sock_error(sk)) < 0)
+                return err;
 
         if (sock->flags & __SO_ACCEPTCON)
                 return(-EINVAL);
@@ -1417,8 +1386,8 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
         if (flags & MSG_OOB)
                 return -EOPNOTSUPP;
 
-        if (flags & MSG_WAITALL)
-                target = size;
+        target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
+        timeo = sock_rcvtimeo(sk, noblock);
 
         msg->msg_namelen = 0;
 
@@ -1426,19 +1395,14 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                 int chunk;
                 struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
 
-                if (skb==NULL) {
+                if (skb == NULL) {
+                        DEFINE_WAIT(wait);
                         int ret = 0;
 
                         if (copied >= target)
                                 break;
 
-                        /* The following code is a cut'n'paste of the
-                         * wait_event_interruptible() macro.
-                         * We don't us the macro because the test condition
-                         * is messy. - Jean II */
-                        set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
-                        add_wait_queue(sk->sk_sleep, &waitq);
-                        set_current_state(TASK_INTERRUPTIBLE);
+                        prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
 
                         /*
                          *      POSIX 1003.1g mandates this order.
@@ -1451,17 +1415,17 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
                         else if (noblock)
                                 ret = -EAGAIN;
                         else if (signal_pending(current))
-                                ret = -ERESTARTSYS;
+                                ret = sock_intr_errno(timeo);
+                        else if (sk->sk_state != TCP_ESTABLISHED)
+                                ret = -ENOTCONN;
                         else if (skb_peek(&sk->sk_receive_queue) == NULL)
                                 /* Wait process until data arrives */
                                 schedule();
 
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &waitq);
-                        clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
+                        finish_wait(sk->sk_sleep, &wait);
 
-                        if(ret)
-                                return(ret);
+                        if (ret)
+                                return ret;
                         if (sk->sk_shutdown & RCV_SHUTDOWN)
                                 break;
 
@@ -1530,7 +1494,6 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
         struct sock *sk = sock->sk;
         struct irda_sock *self;
         struct sk_buff *skb;
-        unsigned char *asmptr;
         int err;
 
         IRDA_DEBUG(4, "%s(), len=%zd\n", __FUNCTION__, len);
@@ -1547,7 +1510,6 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
                 return -ENOTCONN;
 
         self = irda_sk(sk);
-        IRDA_ASSERT(self != NULL, return -1;);
 
         /*
          * Check that we don't send out too big frames. This is an unreliable
@@ -1566,10 +1528,11 @@ static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
                 return -ENOBUFS;
 
         skb_reserve(skb, self->max_header_size);
+        skb_reset_transport_header(skb);
 
         IRDA_DEBUG(4, "%s(), appending user data\n", __FUNCTION__);
-        asmptr = skb->h.raw = skb_put(skb, len);
-        err = memcpy_fromiovec(asmptr, msg->msg_iov, len);
+        skb_put(skb, len);
+        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
         if (err) {
                 kfree_skb(skb);
                 return err;
@@ -1602,7 +1565,6 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
         __u8 pid = 0;
         int bound = 0;
         struct sk_buff *skb;
-        unsigned char *asmptr;
         int err;
 
         IRDA_DEBUG(4, "%s(), len=%zd\n", __FUNCTION__, len);
@@ -1616,7 +1578,6 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
         }
 
         self = irda_sk(sk);
-        IRDA_ASSERT(self != NULL, return -1;);
 
         /* Check if an address was specified with sendto. Jean II */
         if (msg->msg_name) {
@@ -1662,10 +1623,11 @@ static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
                 return -ENOBUFS;
 
         skb_reserve(skb, self->max_header_size);
+        skb_reset_transport_header(skb);
 
         IRDA_DEBUG(4, "%s(), appending user data\n", __FUNCTION__);
-        asmptr = skb->h.raw = skb_put(skb, len);
-        err = memcpy_fromiovec(asmptr, msg->msg_iov, len);
+        skb_put(skb, len);
+        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
         if (err) {
                 kfree_skb(skb);
                 return err;
@@ -1689,8 +1651,6 @@ static int irda_shutdown(struct socket *sock, int how)
         struct sock *sk = sock->sk;
         struct irda_sock *self = irda_sk(sk);
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         IRDA_DEBUG(1, "%s(%p)\n", __FUNCTION__, self);
 
         sk->sk_state       = TCP_CLOSE;
@@ -1863,8 +1823,6 @@ static int irda_setsockopt(struct socket *sock, int level, int optname,
         struct ias_attrib *     ias_attr;       /* Attribute in IAS object */
         int opt;
 
-        IRDA_ASSERT(self != NULL, return -1;);
-
         IRDA_DEBUG(2, "%s(%p)\n", __FUNCTION__, self);
 
         if (level != SOL_IRLMP)
diff --git a/net/irda/ircomm/ircomm_param.c b/net/irda/ircomm/ircomm_param.c
index 01d7c9c7b3b4..e5e4792a0314 100644
--- a/net/irda/ircomm/ircomm_param.c
+++ b/net/irda/ircomm/ircomm_param.c
@@ -133,8 +133,8 @@ int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush)
          * Inserting is a little bit tricky since we don't know how much
          * room we will need. But this should hopefully work OK
          */
-        count = irda_param_insert(self, pi, skb->tail, skb_tailroom(skb),
-                                  &ircomm_param_info);
+        count = irda_param_insert(self, pi, skb_tail_pointer(skb),
+                                  skb_tailroom(skb), &ircomm_param_info);
         if (count < 0) {
                 IRDA_WARNING("%s(), no room for parameter!\n", __FUNCTION__);
                 spin_unlock_irqrestore(&self->spinlock, flags);
diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c
index e717801b38f9..7b5def1ea633 100644
--- a/net/irda/irda_device.c
+++ b/net/irda/irda_device.c
@@ -375,7 +375,7 @@ EXPORT_SYMBOL(alloc_irdadev);
 dongle_t *irda_device_dongle_init(struct net_device *dev, int type)
 {
         struct dongle_reg *reg;
-        dongle_t *dongle = NULL;
+        dongle_t *dongle = kzalloc(sizeof(dongle_t), GFP_KERNEL);
 
         might_sleep();
 
@@ -397,19 +397,14 @@ dongle_t *irda_device_dongle_init(struct net_device *dev, int type)
         if (!reg || !try_module_get(reg->owner) ) {
                 IRDA_ERROR("IrDA: Unable to find requested dongle type %x\n",
                            type);
-                goto out;
+                kfree(dongle);
+                dongle = NULL;
+        }
+        if (dongle) {
+                /* Bind the registration info to this particular instance */
+                dongle->issue = reg;
+                dongle->dev = dev;
         }
-
-        /* Allocate dongle info for this instance */
-        dongle = kzalloc(sizeof(dongle_t), GFP_KERNEL);
-        if (!dongle)
-                goto out;
-
-        /* Bind the registration info to this particular instance */
-        dongle->issue = reg;
-        dongle->dev = dev;
-
- out:
         spin_unlock(&dongles->hb_spinlock);
         return dongle;
 }
diff --git a/net/irda/irlan/irlan_common.c b/net/irda/irlan/irlan_common.c
index fcf9d6599628..ed69773b0f8e 100644
--- a/net/irda/irlan/irlan_common.c
+++ b/net/irda/irlan/irlan_common.c
@@ -1039,7 +1039,7 @@ static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
         }
 
         /* Insert at end of sk-buffer */
-        frame = skb->tail;
+        frame = skb_tail_pointer(skb);
 
         /* Make space for data */
         if (skb_tailroom(skb) < (param_len+value_len+3)) {
diff --git a/net/irda/irlan/irlan_eth.c b/net/irda/irlan/irlan_eth.c
index 672ab3f69033..c421521c0a99 100644
--- a/net/irda/irlan/irlan_eth.c
+++ b/net/irda/irlan/irlan_eth.c
@@ -234,8 +234,7 @@ 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->dev = self->dev;
-        skb->protocol=eth_type_trans(skb, skb->dev); /* Remove eth header */
+        skb->protocol = eth_type_trans(skb, self->dev); /* Remove eth header */
 
         self->stats.rx_packets++;
         self->stats.rx_bytes += skb->len;
diff --git a/net/irda/irlap_event.c b/net/irda/irlap_event.c
index 7b6433fe1dc2..0b02073ffdf3 100644
--- a/net/irda/irlap_event.c
+++ b/net/irda/irlap_event.c
@@ -590,7 +590,7 @@ static int irlap_state_query(struct irlap_cb *self, IRLAP_EVENT event,
                 if (!self->discovery_log) {
                         IRDA_WARNING("%s: discovery log is gone! "
                                      "maybe the discovery timeout has been set"
-                                     " to short?\n", __FUNCTION__);
+                                     " too short?\n", __FUNCTION__);
                         break;
                 }
                 hashbin_insert(self->discovery_log,
diff --git a/net/irda/irlap_frame.c b/net/irda/irlap_frame.c
index 0b04603e9c47..3c5a68e36414 100644
--- a/net/irda/irlap_frame.c
+++ b/net/irda/irlap_frame.c
@@ -93,7 +93,9 @@ void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb)
 {
         /* Some common init stuff */
         skb->dev = self->netdev;
-        skb->h.raw = skb->nh.raw = skb->mac.raw = skb->data;
+        skb_reset_mac_header(skb);
+        skb_reset_network_header(skb);
+        skb_reset_transport_header(skb);
         skb->protocol = htons(ETH_P_IRDA);
         skb->priority = TC_PRIO_BESTEFFORT;
 
@@ -411,7 +413,7 @@ static void irlap_recv_discovery_xid_rsp(struct irlap_cb *self,
         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
 
         if (!pskb_may_pull(skb, sizeof(struct xid_frame))) {
-                IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
+                IRDA_ERROR("%s: frame too short!\n", __FUNCTION__);
                 return;
         }
 
@@ -482,7 +484,7 @@ static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self,
         char *text;
 
         if (!pskb_may_pull(skb, sizeof(struct xid_frame))) {
-                IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
+                IRDA_ERROR("%s: frame too short!\n", __FUNCTION__);
                 return;
         }
 
@@ -526,7 +528,7 @@ static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self,
                 /* Check if things are sane at this point... */
                 if((discovery_info == NULL) ||
                    !pskb_may_pull(skb, 3)) {
-                        IRDA_ERROR("%s: discovery frame to short!\n",
+                        IRDA_ERROR("%s: discovery frame too short!\n",
                                    __FUNCTION__);
                         return;
                 }
@@ -1171,7 +1173,7 @@ static void irlap_recv_frmr_frame(struct irlap_cb *self, struct sk_buff *skb,
         IRDA_ASSERT(info != NULL, return;);
 
         if (!pskb_may_pull(skb, 4)) {
-                IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
+                IRDA_ERROR("%s: frame too short!\n", __FUNCTION__);
                 return;
         }
 
@@ -1260,7 +1262,7 @@ static void irlap_recv_test_frame(struct irlap_cb *self, struct sk_buff *skb,
         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
         if (!pskb_may_pull(skb, sizeof(*frame))) {
-                IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
+                IRDA_ERROR("%s: frame too short!\n", __FUNCTION__);
                 return;
         }
         frame = (struct test_frame *) skb->data;
@@ -1268,7 +1270,7 @@ static void irlap_recv_test_frame(struct irlap_cb *self, struct sk_buff *skb,
         /* Broadcast frames must carry saddr and daddr fields */
         if (info->caddr == CBROADCAST) {
                 if (skb->len < sizeof(struct test_frame)) {
-                        IRDA_DEBUG(0, "%s() test frame to short!\n",
+                        IRDA_DEBUG(0, "%s() test frame too short!\n",
                                    __FUNCTION__);
                         return;
                 }
@@ -1334,7 +1336,7 @@ int irlap_driver_rcv(struct sk_buff *skb, struct net_device *dev,
 
         /* Check if frame is large enough for parsing */
         if (!pskb_may_pull(skb, 2)) {
-                IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
+                IRDA_ERROR("%s: frame too short!\n", __FUNCTION__);
                 dev_kfree_skb(skb);
                 return -1;
         }
diff --git a/net/irda/irqueue.c b/net/irda/irqueue.c
index 92662330dbcf..d058b467f9e4 100644
--- a/net/irda/irqueue.c
+++ b/net/irda/irqueue.c
@@ -384,6 +384,9 @@ EXPORT_SYMBOL(hashbin_new);
  *    for deallocating this structure if it's complex. If not the user can
  *    just supply kfree, which should take care of the job.
  */
+#ifdef CONFIG_LOCKDEP
+static int hashbin_lock_depth = 0;
+#endif
 int hashbin_delete( hashbin_t* hashbin, FREE_FUNC free_func)
 {
         irda_queue_t* queue;
@@ -395,7 +398,8 @@ int hashbin_delete( hashbin_t* hashbin, FREE_FUNC free_func)
 
         /* Synchronize */
         if ( hashbin->hb_type & HB_LOCK ) {
-                spin_lock_irqsave(&hashbin->hb_spinlock, flags);
+                spin_lock_irqsave_nested(&hashbin->hb_spinlock, flags,
+                                         hashbin_lock_depth++);
         }
 
         /*
@@ -419,6 +423,9 @@ int hashbin_delete( hashbin_t* hashbin, FREE_FUNC free_func)
         /* Release lock */
         if ( hashbin->hb_type & HB_LOCK) {
                 spin_unlock_irqrestore(&hashbin->hb_spinlock, flags);
+#ifdef CONFIG_LOCKDEP
+                hashbin_lock_depth--;
+#endif
         }
 
         /*
diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index da3f2bc1b6f6..7069e4a58257 100644
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -256,7 +256,7 @@ static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self)
          *  Copy all fragments to a new buffer
          */
         while ((frag = skb_dequeue(&self->rx_fragments)) != NULL) {
-                memcpy(skb->data+n, frag->data, frag->len);
+                skb_copy_to_linear_data_offset(skb, n, frag->data, frag->len);
                 n += frag->len;
 
                 dev_kfree_skb(frag);
@@ -314,8 +314,8 @@ static inline void irttp_fragment_skb(struct tsap_cb *self,
                 skb_reserve(frag, self->max_header_size);
 
                 /* Copy data from the original skb into this fragment. */
-                memcpy(skb_put(frag, self->max_seg_size), skb->data,
-                       self->max_seg_size);
+                skb_copy_from_linear_data(skb, skb_put(frag, self->max_seg_size),
+                              self->max_seg_size);
 
                 /* Insert TTP header, with the more bit set */
                 frame = skb_push(frag, TTP_HEADER);
@@ -551,7 +551,7 @@ int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
         }
 
         if (skb->len > self->max_seg_size) {
-                IRDA_DEBUG(1, "%s(), UData is to large for IrLAP!\n",
+                IRDA_DEBUG(1, "%s(), UData is too large for IrLAP!\n",
                            __FUNCTION__);
                 goto err;
         }
@@ -598,7 +598,7 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
          *  inside an IrLAP frame
          */
         if ((self->tx_max_sdu_size == 0) && (skb->len > self->max_seg_size)) {
-                IRDA_ERROR("%s: SAR disabled, and data is to large for IrLAP!\n",
+                IRDA_ERROR("%s: SAR disabled, and data is too large for IrLAP!\n",
                            __FUNCTION__);
                 ret = -EMSGSIZE;
                 goto err;
diff --git a/net/irda/parameters.c b/net/irda/parameters.c
index 75a72d203b01..2627dad7cd87 100644
--- a/net/irda/parameters.c
+++ b/net/irda/parameters.c
@@ -160,7 +160,7 @@ static int irda_insert_integer(void *self, __u8 *buf, int len, __u8 pi,
         }
         /* Check if buffer is long enough for insertion */
         if (len < (2+p.pl)) {
-                IRDA_WARNING("%s: buffer to short for insertion!\n",
+                IRDA_WARNING("%s: buffer too short for insertion!\n",
                              __FUNCTION__);
                 return -1;
         }
@@ -216,7 +216,7 @@ static int irda_extract_integer(void *self, __u8 *buf, int len, __u8 pi,
 
         /* Check if buffer is long enough for parsing */
         if (len < (2+p.pl)) {
-                IRDA_WARNING("%s: buffer to short for parsing! "
+                IRDA_WARNING("%s: buffer too short for parsing! "
                              "Need %d bytes, but len is only %d\n",
                              __FUNCTION__, p.pl, len);
                 return -1;
@@ -304,7 +304,7 @@ static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi,
 
         /* Check if buffer is long enough for parsing */
         if (len < (2+p.pl)) {
-                IRDA_WARNING("%s: buffer to short for parsing! "
+                IRDA_WARNING("%s: buffer too short for parsing! "
                              "Need %d bytes, but len is only %d\n",
                              __FUNCTION__, p.pl, len);
                 return -1;
@@ -343,7 +343,7 @@ static int irda_extract_octseq(void *self, __u8 *buf, int len, __u8 pi,
 
         /* Check if buffer is long enough for parsing */
         if (len < (2+p.pl)) {
-                IRDA_WARNING("%s: buffer to short for parsing! "
+                IRDA_WARNING("%s: buffer too short for parsing! "
                              "Need %d bytes, but len is only %d\n",
                              __FUNCTION__, p.pl, len);
                 return -1;
diff --git a/net/irda/qos.c b/net/irda/qos.c
index 349012c926b7..aeb18cf1dcae 100644
--- a/net/irda/qos.c
+++ b/net/irda/qos.c
@@ -469,49 +469,49 @@ int irlap_insert_qos_negotiation_params(struct irlap_cb *self,
         int ret;
 
         /* Insert data rate */
-        ret = irda_param_insert(self, PI_BAUD_RATE, skb->tail,
+        ret = irda_param_insert(self, PI_BAUD_RATE, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert max turnaround time */
-        ret = irda_param_insert(self, PI_MAX_TURN_TIME, skb->tail,
+        ret = irda_param_insert(self, PI_MAX_TURN_TIME, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert data size */
-        ret = irda_param_insert(self, PI_DATA_SIZE, skb->tail,
+        ret = irda_param_insert(self, PI_DATA_SIZE, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert window size */
-        ret = irda_param_insert(self, PI_WINDOW_SIZE, skb->tail,
+        ret = irda_param_insert(self, PI_WINDOW_SIZE, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert additional BOFs */
-        ret = irda_param_insert(self, PI_ADD_BOFS, skb->tail,
+        ret = irda_param_insert(self, PI_ADD_BOFS, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert minimum turnaround time */
-        ret = irda_param_insert(self, PI_MIN_TURN_TIME, skb->tail,
+        ret = irda_param_insert(self, PI_MIN_TURN_TIME, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
         skb_put(skb, ret);
 
         /* Insert link disconnect/threshold time */
-        ret = irda_param_insert(self, PI_LINK_DISC, skb->tail,
+        ret = irda_param_insert(self, PI_LINK_DISC, skb_tail_pointer(skb),
                                 skb_tailroom(skb), &irlap_param_info);
         if (ret < 0)
                 return ret;
diff --git a/net/irda/wrapper.c b/net/irda/wrapper.c
index 5abfb71aae8d..a7a7f191f1a8 100644
--- a/net/irda/wrapper.c
+++ b/net/irda/wrapper.c
@@ -239,7 +239,8 @@ async_bump(struct net_device *dev,
 
         if(docopy) {
                 /* Copy data without CRC (lenght already checked) */
-                memcpy(newskb->data, rx_buff->data, rx_buff->len - 2);
+                skb_copy_to_linear_data(newskb, rx_buff->data,
+                                        rx_buff->len - 2);
                 /* Deliver this skb */
                 dataskb = newskb;
         } else {
@@ -256,7 +257,7 @@ async_bump(struct net_device *dev,
 
         /* Feed it to IrLAP layer */
         dataskb->dev = dev;
-        dataskb->mac.raw  = dataskb->data;
+        skb_reset_mac_header(dataskb);
         dataskb->protocol = htons(ETH_P_IRDA);
 
         netif_rx(dataskb);