networking: add and use skb_put_u8()

Joe and Bjørn suggested that it'd be nicer to not have the
cast in the fairly common case of doing
	*(u8 *)skb_put(skb, 1) = c;

Add skb_put_u8() for this case, and use it across the code,
using the following spatch:

    @@
    expression SKB, C, S;
    typedef u8;
    identifier fn = {skb_put};
    fresh identifier fn2 = fn ## "_u8";
    @@
    - *(u8 *)fn(SKB, S) = C;
    + fn2(SKB, C);

Note that due to the "S", the spatch isn't perfect, it should
have checked that S is 1, but there's also places that use a
sizeof expression like sizeof(var) or sizeof(u8) etc. Turns
out that nobody ever did something like
	*(u8 *)skb_put(skb, 2) = c;

which would be wrong anyway since the second byte wouldn't be
initialized.

Suggested-by: Joe Perches <joe@perches.com>
Suggested-by: Bjørn Mork <bjorn@mork.no>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 11 insertions, 11 deletions

diff --git a/drivers/isdn/gigaset/asyncdata.c b/drivers/isdn/gigaset/asyncdata.c
index 03ac9fbfe318..4caecdcc6f29 100644
--- a/drivers/isdn/gigaset/asyncdata.c
+++ b/drivers/isdn/gigaset/asyncdata.c
@@ -492,33 +492,33 @@ static struct sk_buff *HDLC_Encode(struct sk_buff *skb)
         hdlc_skb->mac_len = skb->mac_len;
 
         /* Add flag sequence in front of everything.. */
-        *(u8 *)skb_put(hdlc_skb, 1) = PPP_FLAG;
+        skb_put_u8(hdlc_skb, PPP_FLAG);
 
         /* Perform byte stuffing while copying data. */
         while (skb->len--) {
                 if (muststuff(*skb->data)) {
-                        *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE;
-                        *(u8 *)skb_put(hdlc_skb, 1) = (*skb->data++) ^ PPP_TRANS;
+                        skb_put_u8(hdlc_skb, PPP_ESCAPE);
+                        skb_put_u8(hdlc_skb, (*skb->data++) ^ PPP_TRANS);
                 } else
-                        *(u8 *)skb_put(hdlc_skb, 1) = *skb->data++;
+                        skb_put_u8(hdlc_skb, *skb->data++);
         }
 
         /* Finally add FCS (byte stuffed) and flag sequence */
         c = (fcs & 0x00ff);     /* least significant byte first */
         if (muststuff(c)) {
-                *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE;
+                skb_put_u8(hdlc_skb, PPP_ESCAPE);
                 c ^= PPP_TRANS;
         }
-        *(u8 *)skb_put(hdlc_skb, 1) = c;
+        skb_put_u8(hdlc_skb, c);
 
         c = ((fcs >> 8) & 0x00ff);
         if (muststuff(c)) {
-                *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE;
+                skb_put_u8(hdlc_skb, PPP_ESCAPE);
                 c ^= PPP_TRANS;
         }
-        *(u8 *)skb_put(hdlc_skb, 1) = c;
+        skb_put_u8(hdlc_skb, c);
 
-        *(u8 *)skb_put(hdlc_skb, 1) = PPP_FLAG;
+        skb_put_u8(hdlc_skb, PPP_FLAG);
 
         dev_kfree_skb_any(skb);
         return hdlc_skb;
@@ -561,8 +561,8 @@ static struct sk_buff *iraw_encode(struct sk_buff *skb)
         while (len--) {
                 c = bitrev8(*cp++);
                 if (c == DLE_FLAG)
-                        *(u8 *)skb_put(iraw_skb, 1) = c;
-                *(u8 *)skb_put(iraw_skb, 1) = c;
+                        skb_put_u8(iraw_skb, c);
+                skb_put_u8(iraw_skb, c);
         }
         dev_kfree_skb_any(skb);
         return iraw_skb;