tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

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>

authored by

Johannes Berg and committed by
David S. Miller 634fef61 d58ff351

+106 -100
+1 -1
drivers/bluetooth/bluecard_cs.c
··· 448 448 449 449 } else { 450 450 451 - *(u8 *)skb_put(info->rx_skb, 1) = buf[i]; 451 + skb_put_u8(info->rx_skb, buf[i]); 452 452 info->rx_count--; 453 453 454 454 if (info->rx_count == 0) {
+1 -1
drivers/bluetooth/bt3c_cs.c
··· 282 282 283 283 __u8 x = inb(iobase + DATA_L); 284 284 285 - *(u8 *)skb_put(info->rx_skb, 1) = x; 285 + skb_put_u8(info->rx_skb, x); 286 286 inb(iobase + DATA_H); 287 287 info->rx_count--; 288 288
+1 -1
drivers/bluetooth/btuart_cs.c
··· 233 233 234 234 } else { 235 235 236 - *(u8 *)skb_put(info->rx_skb, 1) = inb(iobase + UART_RX); 236 + skb_put_u8(info->rx_skb, inb(iobase + UART_RX)); 237 237 info->rx_count--; 238 238 239 239 if (info->rx_count == 0) {
+3 -3
drivers/bluetooth/btusb.c
··· 1844 1844 evt->ncmd = 0x01; 1845 1845 evt->opcode = cpu_to_le16(opcode); 1846 1846 1847 - *(u8 *)skb_put(skb, 1) = 0x00; 1847 + skb_put_u8(skb, 0x00); 1848 1848 1849 1849 hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 1850 1850 ··· 2767 2767 return ERR_PTR(-ENOMEM); 2768 2768 } 2769 2769 2770 - *(u8 *)skb_put(skb, 1) = 0xf0; 2771 - *(u8 *)skb_put(skb, 1) = enable; 2770 + skb_put_u8(skb, 0xf0); 2771 + skb_put_u8(skb, enable); 2772 2772 2773 2773 pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress); 2774 2774
+2 -2
drivers/bluetooth/dtl1_cs.c
··· 226 226 } 227 227 } 228 228 229 - *(u8 *)skb_put(info->rx_skb, 1) = inb(iobase + UART_RX); 229 + skb_put_u8(info->rx_skb, inb(iobase + UART_RX)); 230 230 nsh = (struct nsh *)info->rx_skb->data; 231 231 232 232 info->rx_count--; ··· 414 414 skb_reserve(s, NSHL); 415 415 skb_copy_from_linear_data(skb, skb_put(s, skb->len), skb->len); 416 416 if (skb->len & 0x0001) 417 - *(u8 *)skb_put(s, 1) = 0; /* PAD */ 417 + skb_put_u8(s, 0); /* PAD */ 418 418 419 419 /* Prepend skb with Nokia frame header and queue */ 420 420 memcpy(skb_push(s, NSHL), &nsh, NSHL);
+3 -3
drivers/bluetooth/hci_bcm.c
··· 262 262 if (!skb) 263 263 return -ENOMEM; 264 264 265 - *(u8 *)skb_put(skb, 1) = BCM_LM_DIAG_PKT; 266 - *(u8 *)skb_put(skb, 1) = 0xf0; 267 - *(u8 *)skb_put(skb, 1) = enable; 265 + skb_put_u8(skb, BCM_LM_DIAG_PKT); 266 + skb_put_u8(skb, 0xf0); 267 + skb_put_u8(skb, enable); 268 268 269 269 skb_queue_tail(&bcm->txq, skb); 270 270 hci_uart_tx_wakeup(hu);
+1 -1
drivers/bluetooth/hci_intel.c
··· 470 470 evt->ncmd = 0x01; 471 471 evt->opcode = cpu_to_le16(opcode); 472 472 473 - *(u8 *)skb_put(skb, 1) = 0x00; 473 + skb_put_u8(skb, 0x00); 474 474 475 475 hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 476 476
+1 -1
drivers/bluetooth/hci_nokia.c
··· 532 532 err = skb_pad(skb, 1); 533 533 if (err) 534 534 return err; 535 - *(u8 *)skb_put(skb, 1) = 0x00; 535 + skb_put_u8(skb, 0x00); 536 536 } 537 537 538 538 skb_queue_tail(&btdev->txq, skb);
+1 -1
drivers/bluetooth/hci_qca.c
··· 215 215 } 216 216 217 217 /* Assign HCI_IBS type */ 218 - *(u8 *)skb_put(skb, 1) = cmd; 218 + skb_put_u8(skb, cmd); 219 219 220 220 skb_queue_tail(&qca->txq, skb); 221 221
+2 -2
drivers/bluetooth/hci_vhci.c
··· 146 146 147 147 hci_skb_pkt_type(skb) = HCI_VENDOR_PKT; 148 148 149 - *(u8 *)skb_put(skb, 1) = 0xff; 150 - *(u8 *)skb_put(skb, 1) = opcode; 149 + skb_put_u8(skb, 0xff); 150 + skb_put_u8(skb, opcode); 151 151 put_unaligned_le16(hdev->id, skb_put(skb, 2)); 152 152 skb_queue_tail(&data->readq, skb); 153 153
+2 -2
drivers/isdn/capi/capi.c
··· 1082 1082 skb = mp->outskb; 1083 1083 if (skb) { 1084 1084 if (skb_tailroom(skb) > 0) { 1085 - *(u8 *)skb_put(skb, 1) = ch; 1085 + skb_put_u8(skb, ch); 1086 1086 goto unlock_out; 1087 1087 } 1088 1088 mp->outskb = NULL; ··· 1094 1094 skb = alloc_skb(CAPI_DATA_B3_REQ_LEN + CAPI_MAX_BLKSIZE, GFP_ATOMIC); 1095 1095 if (skb) { 1096 1096 skb_reserve(skb, CAPI_DATA_B3_REQ_LEN); 1097 - *(u8 *)skb_put(skb, 1) = ch; 1097 + skb_put_u8(skb, ch); 1098 1098 mp->outskb = skb; 1099 1099 } else { 1100 1100 printk(KERN_ERR "capinc_put_char: char %u lost\n", ch);
+11 -11
drivers/isdn/gigaset/asyncdata.c
··· 492 492 hdlc_skb->mac_len = skb->mac_len; 493 493 494 494 /* Add flag sequence in front of everything.. */ 495 - *(u8 *)skb_put(hdlc_skb, 1) = PPP_FLAG; 495 + skb_put_u8(hdlc_skb, PPP_FLAG); 496 496 497 497 /* Perform byte stuffing while copying data. */ 498 498 while (skb->len--) { 499 499 if (muststuff(*skb->data)) { 500 - *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE; 501 - *(u8 *)skb_put(hdlc_skb, 1) = (*skb->data++) ^ PPP_TRANS; 500 + skb_put_u8(hdlc_skb, PPP_ESCAPE); 501 + skb_put_u8(hdlc_skb, (*skb->data++) ^ PPP_TRANS); 502 502 } else 503 - *(u8 *)skb_put(hdlc_skb, 1) = *skb->data++; 503 + skb_put_u8(hdlc_skb, *skb->data++); 504 504 } 505 505 506 506 /* Finally add FCS (byte stuffed) and flag sequence */ 507 507 c = (fcs & 0x00ff); /* least significant byte first */ 508 508 if (muststuff(c)) { 509 - *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE; 509 + skb_put_u8(hdlc_skb, PPP_ESCAPE); 510 510 c ^= PPP_TRANS; 511 511 } 512 - *(u8 *)skb_put(hdlc_skb, 1) = c; 512 + skb_put_u8(hdlc_skb, c); 513 513 514 514 c = ((fcs >> 8) & 0x00ff); 515 515 if (muststuff(c)) { 516 - *(u8 *)skb_put(hdlc_skb, 1) = PPP_ESCAPE; 516 + skb_put_u8(hdlc_skb, PPP_ESCAPE); 517 517 c ^= PPP_TRANS; 518 518 } 519 - *(u8 *)skb_put(hdlc_skb, 1) = c; 519 + skb_put_u8(hdlc_skb, c); 520 520 521 - *(u8 *)skb_put(hdlc_skb, 1) = PPP_FLAG; 521 + skb_put_u8(hdlc_skb, PPP_FLAG); 522 522 523 523 dev_kfree_skb_any(skb); 524 524 return hdlc_skb; ··· 561 561 while (len--) { 562 562 c = bitrev8(*cp++); 563 563 if (c == DLE_FLAG) 564 - *(u8 *)skb_put(iraw_skb, 1) = c; 565 - *(u8 *)skb_put(iraw_skb, 1) = c; 564 + skb_put_u8(iraw_skb, c); 565 + skb_put_u8(iraw_skb, c); 566 566 } 567 567 dev_kfree_skb_any(skb); 568 568 return iraw_skb;
+4 -3
drivers/isdn/i4l/isdn_bsdcomp.c
··· 602 602 * Do not emit a completely useless byte of ones. 603 603 */ 604 604 if (bitno < 32 && skb_out && skb_tailroom(skb_out) > 0) 605 - *(u8 *)skb_put(skb_out, 1) = (unsigned char)((accm | (0xff << (bitno - 8))) >> 24); 605 + skb_put_u8(skb_out, 606 + (unsigned char)((accm | (0xff << (bitno - 8))) >> 24)); 606 607 607 608 /* 608 609 * Increase code size if we would have without the packet ··· 699 698 db->bytes_out += ilen; 700 699 701 700 if (skb_tailroom(skb_out) > 0) 702 - *(u8 *)skb_put(skb_out, 1) = 0; 701 + skb_put_u8(skb_out, 0); 703 702 else 704 703 return DECOMP_ERR_NOMEM; 705 704 ··· 817 816 #endif 818 817 819 818 if (extra) /* the KwKwK case again */ 820 - *(u8 *)skb_put(skb_out, 1) = finchar; 819 + skb_put_u8(skb_out, finchar); 821 820 822 821 /* 823 822 * If not first code in a packet, and
+2 -2
drivers/isdn/i4l/isdn_x25iface.c
··· 224 224 225 225 skb = dev_alloc_skb(1); 226 226 if (skb) { 227 - *(u8 *)skb_put(skb, 1) = X25_IFACE_CONNECT; 227 + skb_put_u8(skb, X25_IFACE_CONNECT); 228 228 skb->protocol = x25_type_trans(skb, cprot->net_dev); 229 229 netif_rx(skb); 230 230 return 0; ··· 253 253 *state_p = WAN_DISCONNECTED; 254 254 skb = dev_alloc_skb(1); 255 255 if (skb) { 256 - *(u8 *)skb_put(skb, 1) = X25_IFACE_DISCONNECT; 256 + skb_put_u8(skb, X25_IFACE_DISCONNECT); 257 257 skb->protocol = x25_type_trans(skb, cprot->net_dev); 258 258 netif_rx(skb); 259 259 return 0;
+2 -2
drivers/net/hamradio/scc.c
··· 540 540 } 541 541 542 542 scc->rx_buff = skb; 543 - *(u8 *)skb_put(skb, 1) = 0; /* KISS data */ 543 + skb_put_u8(skb, 0); /* KISS data */ 544 544 } 545 545 546 546 if (skb->len >= scc->stat.bufsize) ··· 555 555 return; 556 556 } 557 557 558 - *(u8 *)skb_put(skb, 1) = Inb(scc->data); 558 + skb_put_u8(skb, Inb(scc->data)); 559 559 } 560 560 561 561
+1 -1
drivers/net/usb/cdc_ncm.c
··· 1250 1250 skb_put_zero(skb_out, padding_count); 1251 1251 } else if (skb_out->len < ctx->tx_max && 1252 1252 (skb_out->len % dev->maxpacket) == 0) { 1253 - *(u8 *)skb_put(skb_out, 1) = 0; /* force short packet */ 1253 + skb_put_u8(skb_out, 0); /* force short packet */ 1254 1254 } 1255 1255 1256 1256 /* set final frame length */
+1 -1
drivers/net/usb/net1080.c
··· 473 473 474 474 /* maybe pad; then trailer */ 475 475 if (!((skb->len + sizeof *trailer) & 0x01)) 476 - *(u8 *)skb_put(skb, 1) = PAD_BYTE; 476 + skb_put_u8(skb, PAD_BYTE); 477 477 trailer = skb_put(skb, sizeof *trailer); 478 478 put_unaligned(header->packet_id, &trailer->packet_id); 479 479 #if 0
+4 -4
drivers/net/usb/zaurus.c
··· 74 74 fcs = crc32_le(~0, skb->data, skb->len); 75 75 fcs = ~fcs; 76 76 77 - *(u8 *)skb_put(skb, 1) = fcs & 0xff; 78 - *(u8 *)skb_put(skb, 1) = (fcs>> 8) & 0xff; 79 - *(u8 *)skb_put(skb, 1) = (fcs>>16) & 0xff; 80 - *(u8 *)skb_put(skb, 1) = (fcs>>24) & 0xff; 77 + skb_put_u8(skb, fcs & 0xff); 78 + skb_put_u8(skb, (fcs >> 8) & 0xff); 79 + skb_put_u8(skb, (fcs >> 16) & 0xff); 80 + skb_put_u8(skb, (fcs >> 24) & 0xff); 81 81 } 82 82 return skb; 83 83 }
+1 -1
drivers/nfc/fdp/i2c.c
··· 86 86 for (i = 0; i < len + 2; i++) 87 87 lrc ^= skb->data[i]; 88 88 89 - *(u8 *)skb_put(skb, 1) = lrc; 89 + skb_put_u8(skb, lrc); 90 90 } 91 91 92 92 static void fdp_nci_i2c_remove_len_lrc(struct sk_buff *skb)
+2 -2
drivers/nfc/microread/i2c.c
··· 75 75 for (i = 0; i < skb->len; i++) 76 76 crc = crc ^ skb->data[i]; 77 77 78 - *(u8 *)skb_put(skb, 1) = crc; 78 + skb_put_u8(skb, crc); 79 79 } 80 80 81 81 static void microread_i2c_remove_len_crc(struct sk_buff *skb) ··· 173 173 goto flush; 174 174 } 175 175 176 - *(u8 *)skb_put(*skb, 1) = len; 176 + skb_put_u8(*skb, len); 177 177 178 178 r = i2c_master_recv(client, skb_put(*skb, len), len); 179 179 if (r != len) {
+2 -2
drivers/nfc/microread/microread.c
··· 441 441 442 442 crc = crc_ccitt(0xffff, skb->data, skb->len); 443 443 crc = ~crc; 444 - *(u8 *)skb_put(skb, 1) = crc & 0xff; 445 - *(u8 *)skb_put(skb, 1) = crc >> 8; 444 + skb_put_u8(skb, crc & 0xff); 445 + skb_put_u8(skb, crc >> 8); 446 446 break; 447 447 case MICROREAD_GATE_ID_MREAD_NFC_T3: 448 448 control_bits = 0xDB;
+2 -2
drivers/nfc/nfcmrvl/fw_dnld.c
··· 292 292 out_skb = alloc_lc_skb(priv, 1); 293 293 if (!out_skb) 294 294 return -ENOMEM; 295 - *(u8 *)skb_put(out_skb, 1) = 0xBF; 295 + skb_put_u8(out_skb, 0xBF); 296 296 nci_send_frame(priv->ndev, out_skb); 297 297 priv->fw_dnld.substate = SUBSTATE_WAIT_NACK_CREDIT; 298 298 return 0; ··· 301 301 out_skb = alloc_lc_skb(priv, 1); 302 302 if (!out_skb) 303 303 return -ENOMEM; 304 - *(u8 *)skb_put(out_skb, 1) = HELPER_ACK_PACKET_FORMAT; 304 + skb_put_u8(out_skb, HELPER_ACK_PACKET_FORMAT); 305 305 nci_send_frame(priv->ndev, out_skb); 306 306 priv->fw_dnld.substate = SUBSTATE_WAIT_ACK_CREDIT; 307 307 break;
+16 -16
drivers/nfc/pn533/pn533.c
··· 1032 1032 return NULL; 1033 1033 1034 1034 /* DEP support only */ 1035 - *(u8 *)skb_put(skb, 1) = PN533_INIT_TARGET_DEP; 1035 + skb_put_u8(skb, PN533_INIT_TARGET_DEP); 1036 1036 1037 1037 /* MIFARE params */ 1038 1038 skb_put_data(skb, mifare_params, 6); ··· 1046 1046 memcpy(nfcid3, felica, 8); 1047 1047 1048 1048 /* General bytes */ 1049 - *(u8 *)skb_put(skb, 1) = gbytes_len; 1049 + skb_put_u8(skb, gbytes_len); 1050 1050 1051 1051 gb = skb_put_data(skb, gbytes, gbytes_len); 1052 1052 1053 1053 /* Len Tk */ 1054 - *(u8 *)skb_put(skb, 1) = 0; 1054 + skb_put_u8(skb, 0); 1055 1055 1056 1056 return skb; 1057 1057 } ··· 1280 1280 if (!skb) 1281 1281 return; 1282 1282 1283 - *(u8 *)skb_put(skb, 1) = PN533_CFGITEM_RF_FIELD; 1284 - *(u8 *)skb_put(skb, 1) = PN533_CFGITEM_RF_FIELD_AUTO_RFCA; 1283 + skb_put_u8(skb, PN533_CFGITEM_RF_FIELD); 1284 + skb_put_u8(skb, PN533_CFGITEM_RF_FIELD_AUTO_RFCA); 1285 1285 1286 1286 rc = pn533_send_cmd_async(dev, PN533_CMD_RF_CONFIGURATION, skb, 1287 1287 pn533_rf_complete, NULL); ··· 1375 1375 if (!skb) 1376 1376 return -ENOMEM; 1377 1377 1378 - *(u8 *)skb_put(skb, 1) = 0x01; /* Active */ 1379 - *(u8 *)skb_put(skb, 1) = 0x02; /* 424 kbps */ 1378 + skb_put_u8(skb, 0x01); /* Active */ 1379 + skb_put_u8(skb, 0x02); /* 424 kbps */ 1380 1380 1381 1381 next = skb_put(skb, 1); /* Next */ 1382 1382 *next = 0; ··· 1620 1620 if (!skb) 1621 1621 return -ENOMEM; 1622 1622 1623 - *(u8 *)skb_put(skb, sizeof(u8)) = 1; /* TG */ 1624 - *(u8 *)skb_put(skb, sizeof(u8)) = 0; /* Next */ 1623 + skb_put_u8(skb, 1); /* TG */ 1624 + skb_put_u8(skb, 0); /* Next */ 1625 1625 1626 1626 resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_ATR, skb); 1627 1627 if (IS_ERR(resp)) ··· 1737 1737 if (!skb) 1738 1738 return; 1739 1739 1740 - *(u8 *)skb_put(skb, 1) = 1; /* TG*/ 1740 + skb_put_u8(skb, 1); /* TG*/ 1741 1741 1742 1742 rc = pn533_send_cmd_async(dev, PN533_CMD_IN_RELEASE, skb, 1743 1743 pn533_deactivate_target_complete, NULL); ··· 1848 1848 if (!skb) 1849 1849 return -ENOMEM; 1850 1850 1851 - *(u8 *)skb_put(skb, 1) = !comm_mode; /* ActPass */ 1852 - *(u8 *)skb_put(skb, 1) = 0x02; /* 424 kbps */ 1851 + skb_put_u8(skb, !comm_mode); /* ActPass */ 1852 + skb_put_u8(skb, 0x02); /* 424 kbps */ 1853 1853 1854 1854 next = skb_put(skb, 1); /* Next */ 1855 1855 *next = 0; ··· 2274 2274 break; 2275 2275 } 2276 2276 default: 2277 - *(u8 *)skb_put(skb, sizeof(u8)) = 1; /*TG*/ 2277 + skb_put_u8(skb, 1); /*TG*/ 2278 2278 2279 2279 rc = pn533_send_cmd_direct_async(dev, 2280 2280 PN533_CMD_IN_DATA_EXCHANGE, ··· 2370 2370 if (!skb) 2371 2371 return -ENOMEM; 2372 2372 2373 - *(u8 *)skb_put(skb, sizeof(cfgitem)) = cfgitem; 2373 + skb_put_u8(skb, cfgitem); 2374 2374 skb_put_data(skb, cfgdata, cfgdata_len); 2375 2375 2376 2376 resp = pn533_send_cmd_sync(dev, PN533_CMD_RF_CONFIGURATION, skb); ··· 2415 2415 if (!skb) 2416 2416 return -ENOMEM; 2417 2417 2418 - *(u8 *)skb_put(skb, sizeof(u8)) = 0x1; 2418 + skb_put_u8(skb, 0x1); 2419 2419 2420 2420 resp = pn533_send_cmd_sync(dev, 0x18, skb); 2421 2421 if (IS_ERR(resp)) ··· 2454 2454 if (!skb) 2455 2455 return -ENOMEM; 2456 2456 2457 - *(u8 *)skb_put(skb, 1) = 0x01; 2457 + skb_put_u8(skb, 0x01); 2458 2458 2459 2459 resp = pn533_send_cmd_sync(dev, PN533_CMD_SAM_CONFIGURATION, skb); 2460 2460 if (IS_ERR(resp))
+3 -3
drivers/nfc/pn544/i2c.c
··· 287 287 288 288 crc = crc_ccitt(0xffff, skb->data, skb->len); 289 289 crc = ~crc; 290 - *(u8 *)skb_put(skb, 1) = crc & 0xff; 291 - *(u8 *)skb_put(skb, 1) = crc >> 8; 290 + skb_put_u8(skb, crc & 0xff); 291 + skb_put_u8(skb, crc >> 8); 292 292 } 293 293 294 294 static void pn544_hci_i2c_remove_len_crc(struct sk_buff *skb) ··· 391 391 goto flush; 392 392 } 393 393 394 - *(u8 *)skb_put(*skb, 1) = len; 394 + skb_put_u8(*skb, len); 395 395 396 396 r = i2c_master_recv(client, skb_put(*skb, len), len); 397 397 if (r != len) {
+2 -2
drivers/nfc/port100.c
··· 991 991 if (!skb) 992 992 return -ENOMEM; 993 993 994 - *(u8 *)skb_put(skb, sizeof(u8)) = command_type; 994 + skb_put_u8(skb, command_type); 995 995 996 996 resp = port100_send_cmd_sync(dev, PORT100_CMD_SET_COMMAND_TYPE, skb); 997 997 if (IS_ERR(resp)) ··· 1059 1059 if (!skb) 1060 1060 return -ENOMEM; 1061 1061 1062 - *(u8 *)skb_put(skb, 1) = on ? 1 : 0; 1062 + skb_put_u8(skb, on ? 1 : 0); 1063 1063 1064 1064 /* Cancel the last command if the device is being switched off */ 1065 1065 if (!on)
+3 -3
drivers/nfc/st21nfca/i2c.c
··· 177 177 crc = ~crc; 178 178 179 179 tmp = crc & 0x00ff; 180 - *(u8 *)skb_put(skb, 1) = tmp; 180 + skb_put_u8(skb, tmp); 181 181 182 182 tmp = (crc >> 8) & 0x00ff; 183 - *(u8 *)skb_put(skb, 1) = tmp; 183 + skb_put_u8(skb, tmp); 184 184 } 185 185 186 186 static void st21nfca_hci_remove_len_crc(struct sk_buff *skb) ··· 214 214 st21nfca_hci_add_len_crc(skb); 215 215 216 216 /* add ST21NFCA_SOF_EOF on tail */ 217 - *(u8 *)skb_put(skb, 1) = ST21NFCA_SOF_EOF; 217 + skb_put_u8(skb, ST21NFCA_SOF_EOF); 218 218 /* add ST21NFCA_SOF_EOF on head */ 219 219 *(u8 *)skb_push(skb, 1) = ST21NFCA_SOF_EOF; 220 220
+1 -1
drivers/nfc/st95hf/core.c
··· 949 949 switch (stcontext->current_rf_tech) { 950 950 case NFC_DIGITAL_RF_TECH_106A: 951 951 len_data_to_tag = skb->len + 1; 952 - *(u8 *)skb_put(skb, 1) = stcontext->sendrcv_trflag; 952 + skb_put_u8(skb, stcontext->sendrcv_trflag); 953 953 break; 954 954 case NFC_DIGITAL_RF_TECH_106B: 955 955 case NFC_DIGITAL_RF_TECH_ISO15693:
+5
include/linux/skbuff.h
··· 1923 1923 return tmp; 1924 1924 } 1925 1925 1926 + static inline void skb_put_u8(struct sk_buff *skb, u8 val) 1927 + { 1928 + *(u8 *)skb_put(skb, 1) = val; 1929 + } 1930 + 1926 1931 void *skb_push(struct sk_buff *skb, unsigned int len); 1927 1932 static inline void *__skb_push(struct sk_buff *skb, unsigned int len) 1928 1933 {
+1 -1
net/bluetooth/hci_sock.c
··· 517 517 put_unaligned_le16(format, skb_put(skb, 2)); 518 518 skb_put_data(skb, ver, sizeof(ver)); 519 519 put_unaligned_le32(flags, skb_put(skb, 4)); 520 - *(u8 *)skb_put(skb, 1) = TASK_COMM_LEN; 520 + skb_put_u8(skb, TASK_COMM_LEN); 521 521 skb_put_data(skb, hci_pi(sk)->comm, TASK_COMM_LEN); 522 522 523 523 __net_timestamp(skb);
+1 -1
net/bluetooth/hidp/core.c
··· 112 112 return -ENOMEM; 113 113 } 114 114 115 - *(u8 *)skb_put(skb, 1) = hdr; 115 + skb_put_u8(skb, hdr); 116 116 if (data && size > 0) 117 117 skb_put_data(skb, data, size); 118 118
+6 -6
net/decnet/dn_nsp_out.c
··· 530 530 msg->info = scp->info_loc; 531 531 msg->segsize = cpu_to_le16(scp->segsize_loc); 532 532 533 - *(u8 *)skb_put(skb, 1) = len; 533 + skb_put_u8(skb, len); 534 534 535 535 if (len > 0) 536 536 skb_put_data(skb, scp->conndata_out.opt_data, len); ··· 686 686 if (scp->peer.sdn_flags & SDF_UICPROXY) 687 687 menuver |= DN_MENUVER_UIC; 688 688 689 - *(u8 *)skb_put(skb, 1) = menuver; /* Menu Version */ 689 + skb_put_u8(skb, menuver); /* Menu Version */ 690 690 691 691 aux = scp->accessdata.acc_userl; 692 - *(u8 *)skb_put(skb, 1) = aux; 692 + skb_put_u8(skb, aux); 693 693 if (aux > 0) 694 694 skb_put_data(skb, scp->accessdata.acc_user, aux); 695 695 696 696 aux = scp->accessdata.acc_passl; 697 - *(u8 *)skb_put(skb, 1) = aux; 697 + skb_put_u8(skb, aux); 698 698 if (aux > 0) 699 699 skb_put_data(skb, scp->accessdata.acc_pass, aux); 700 700 701 701 aux = scp->accessdata.acc_accl; 702 - *(u8 *)skb_put(skb, 1) = aux; 702 + skb_put_u8(skb, aux); 703 703 if (aux > 0) 704 704 skb_put_data(skb, scp->accessdata.acc_acc, aux); 705 705 706 706 aux = (__u8)le16_to_cpu(scp->conndata_out.opt_optl); 707 - *(u8 *)skb_put(skb, 1) = aux; 707 + skb_put_u8(skb, aux); 708 708 if (aux > 0) 709 709 skb_put_data(skb, scp->conndata_out.opt_data, aux); 710 710
+2 -2
net/nfc/digital_core.c
··· 74 74 if (msb_first) 75 75 crc = __fswab16(crc); 76 76 77 - *(u8 *)skb_put(skb, 1) = crc & 0xFF; 78 - *(u8 *)skb_put(skb, 1) = (crc >> 8) & 0xFF; 77 + skb_put_u8(skb, crc & 0xFF); 78 + skb_put_u8(skb, (crc >> 8) & 0xFF); 79 79 } 80 80 81 81 int digital_skb_check_crc(struct sk_buff *skb, crc_func_t crc_func,
+1 -1
net/nfc/digital_dep.c
··· 654 654 if (!skb) 655 655 return -ENOMEM; 656 656 657 - *(u8 *)skb_put(skb, 1) = rtox; 657 + skb_put_u8(skb, rtox); 658 658 659 659 skb_push(skb, sizeof(struct digital_dep_req_res)); 660 660
+6 -6
net/nfc/digital_technology.c
··· 266 266 if (!skb) 267 267 return -ENOMEM; 268 268 269 - *(u8 *)skb_put(skb, 1) = DIGITAL_RATS_BYTE1; 270 - *(u8 *)skb_put(skb, 1) = DIGITAL_RATS_PARAM; 269 + skb_put_u8(skb, DIGITAL_RATS_BYTE1); 270 + skb_put_u8(skb, DIGITAL_RATS_PARAM); 271 271 272 272 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats, 273 273 target); ··· 470 470 else 471 471 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3; 472 472 473 - *(u8 *)skb_put(skb, sizeof(u8)) = sel_cmd; 474 - *(u8 *)skb_put(skb, sizeof(u8)) = DIGITAL_SDD_REQ_SEL_PAR; 473 + skb_put_u8(skb, sel_cmd); 474 + skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR); 475 475 476 476 return digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res, 477 477 target); ··· 541 541 if (!skb) 542 542 return -ENOMEM; 543 543 544 - *(u8 *)skb_put(skb, sizeof(u8)) = DIGITAL_CMD_SENS_REQ; 544 + skb_put_u8(skb, DIGITAL_CMD_SENS_REQ); 545 545 546 546 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL); 547 547 if (rc) ··· 937 937 if (!skb) 938 938 return -ENOMEM; 939 939 940 - *(u8 *)skb_put(skb, 1) = DIGITAL_SEL_RES_NFC_DEP; 940 + skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP); 941 941 942 942 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) 943 943 digital_skb_add_crc_a(skb);
+1 -1
net/nfc/hci/core.c
··· 874 874 return; 875 875 } 876 876 877 - *(u8 *)skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe; 877 + skb_put_u8(hcp_skb, pipe); 878 878 879 879 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) { 880 880 msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN;
+2 -2
net/nfc/hci/llc_shdlc.c
··· 382 382 if (skb == NULL) 383 383 return -ENOMEM; 384 384 385 - *(u8 *)skb_put(skb, 1) = SHDLC_MAX_WINDOW; 386 - *(u8 *)skb_put(skb, 1) = SHDLC_SREJ_SUPPORT ? 1 : 0; 385 + skb_put_u8(skb, SHDLC_MAX_WINDOW); 386 + skb_put_u8(skb, SHDLC_SREJ_SUPPORT ? 1 : 0); 387 387 388 388 return llc_shdlc_send_u_frame(shdlc, skb, U_FRAME_RSET); 389 389 }
+1 -1
net/nfc/nci/hci.c
··· 472 472 return; 473 473 } 474 474 475 - *(u8 *)skb_put(hcp_skb, NCI_HCI_HCP_PACKET_HEADER_LEN) = pipe; 475 + skb_put_u8(hcp_skb, pipe); 476 476 477 477 skb_queue_walk(&ndev->hci_dev->rx_hcp_frags, frag_skb) { 478 478 msg_len = frag_skb->len - NCI_HCI_HCP_PACKET_HEADER_LEN;
+4 -4
net/nfc/nci/spi.c
··· 86 86 u16 crc; 87 87 88 88 crc = crc_ccitt(CRC_INIT, skb->data, skb->len); 89 - *(u8 *)skb_put(skb, 1) = crc >> 8; 90 - *(u8 *)skb_put(skb, 1) = crc & 0xFF; 89 + skb_put_u8(skb, crc >> 8); 90 + skb_put_u8(skb, crc & 0xFF); 91 91 } 92 92 93 93 if (write_handshake_completion) { ··· 172 172 hdr[3] = 0; 173 173 174 174 crc = crc_ccitt(CRC_INIT, skb->data, skb->len); 175 - *(u8 *)skb_put(skb, 1) = crc >> 8; 176 - *(u8 *)skb_put(skb, 1) = crc & 0xFF; 175 + skb_put_u8(skb, crc >> 8); 176 + skb_put_u8(skb, crc & 0xFF); 177 177 178 178 ret = __nci_spi_send(nspi, skb, 0); 179 179
+1 -1
net/nfc/nci/uart.c
··· 355 355 356 356 /* Eat byte after byte till full packet header is received */ 357 357 if (nu->rx_skb->len < NCI_CTRL_HDR_SIZE) { 358 - *(u8 *)skb_put(nu->rx_skb, 1) = *data++; 358 + skb_put_u8(nu->rx_skb, *data++); 359 359 --count; 360 360 continue; 361 361 }