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: convert many more places to skb_put_zero()

There were many places that my previous spatch didn't find,
as pointed out by yuan linyu in various patches.

The following spatch found many more and also removes the
now unnecessary casts:

@@
identifier p, p2;
expression len;
expression skb;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_zero(skb, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_zero(skb, len);
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, len);
|
-memset(p, 0, len);
)

@@
type t, t2;
identifier p, p2;
expression skb;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_zero(skb, sizeof(t));
)
... when != p
(
p2 = (t2)p;
-memset(p2, 0, sizeof(*p));
|
-memset(p, 0, sizeof(*p));
)

@@
expression skb, len;
@@
-memset(skb_put(skb, len), 0, len);
+skb_put_zero(skb, len);

Apply it to the tree (with one manual fixup to keep the
comment in vxlan.c, which spatch removed.)

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 b080db58 61f73d1e

+89 -169
+2 -4
drivers/infiniband/hw/cxgb3/cxio_hal.c
··· 142 142 pr_debug("%s alloc_skb failed\n", __func__); 143 143 return -ENOMEM; 144 144 } 145 - wqe = (struct t3_modify_qp_wr *) skb_put(skb, sizeof(*wqe)); 146 - memset(wqe, 0, sizeof(*wqe)); 145 + wqe = skb_put_zero(skb, sizeof(*wqe)); 147 146 build_fw_riwrh((struct fw_riwrh *) wqe, T3_WR_QP_MOD, 148 147 T3_COMPLETION_FLAG | T3_NOTIFY_FLAG, 0, qpid, 7, 149 148 T3_SOPEOP); ··· 560 561 ctx1 |= ((u64) (V_EC_BASE_HI((u32) base_addr & 0xf) | V_EC_RESPQ(0) | 561 562 V_EC_TYPE(0) | V_EC_GEN(1) | 562 563 V_EC_UP_TOKEN(T3_CTL_QP_TID) | F_EC_VALID)) << 32; 563 - wqe = (struct t3_modify_qp_wr *) skb_put(skb, sizeof(*wqe)); 564 - memset(wqe, 0, sizeof(*wqe)); 564 + wqe = skb_put_zero(skb, sizeof(*wqe)); 565 565 build_fw_riwrh((struct fw_riwrh *) wqe, T3_WR_QP_MOD, 0, 0, 566 566 T3_CTL_QP_TID, 7, T3_SOPEOP); 567 567 wqe->flags = cpu_to_be32(MODQP_WRITE_EC);
+1 -2
drivers/infiniband/hw/cxgb3/iwch_cm.c
··· 417 417 } 418 418 skb->priority = CPL_PRIORITY_DATA; 419 419 set_arp_failure_handler(skb, abort_arp_failure); 420 - req = (struct cpl_abort_req *) skb_put(skb, sizeof(*req)); 421 - memset(req, 0, sizeof(*req)); 420 + req = skb_put_zero(skb, sizeof(*req)); 422 421 req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_HOST_ABORT_CON_REQ)); 423 422 req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid)); 424 423 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid));
+2 -4
drivers/infiniband/hw/cxgb3/iwch_qp.c
··· 670 670 pr_err("%s cannot send zb_read!!\n", __func__); 671 671 return -ENOMEM; 672 672 } 673 - wqe = (union t3_wr *)skb_put(skb, sizeof(struct t3_rdma_read_wr)); 674 - memset(wqe, 0, sizeof(struct t3_rdma_read_wr)); 673 + wqe = skb_put_zero(skb, sizeof(struct t3_rdma_read_wr)); 675 674 wqe->read.rdmaop = T3_READ_REQ; 676 675 wqe->read.reserved[0] = 0; 677 676 wqe->read.reserved[1] = 0; ··· 701 702 pr_err("%s cannot send TERMINATE!\n", __func__); 702 703 return -ENOMEM; 703 704 } 704 - wqe = (union t3_wr *)skb_put(skb, 40); 705 - memset(wqe, 0, 40); 705 + wqe = skb_put_zero(skb, 40); 706 706 wqe->send.rdmaop = T3_TERMINATE; 707 707 708 708 /* immediate data length */
+3 -6
drivers/infiniband/hw/cxgb4/cm.c
··· 927 927 } 928 928 set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx); 929 929 930 - req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen); 931 - memset(req, 0, wrlen); 930 + req = skb_put_zero(skb, wrlen); 932 931 req->op_to_immdlen = cpu_to_be32( 933 932 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) | 934 933 FW_WR_COMPL_F | ··· 1033 1034 } 1034 1035 set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx); 1035 1036 1036 - req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen); 1037 - memset(req, 0, wrlen); 1037 + req = skb_put_zero(skb, wrlen); 1038 1038 req->op_to_immdlen = cpu_to_be32( 1039 1039 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) | 1040 1040 FW_WR_COMPL_F | ··· 1113 1115 } 1114 1116 set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx); 1115 1117 1116 - req = (struct fw_ofld_tx_data_wr *) skb_put(skb, wrlen); 1117 - memset(req, 0, wrlen); 1118 + req = skb_put_zero(skb, wrlen); 1118 1119 req->op_to_immdlen = cpu_to_be32( 1119 1120 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) | 1120 1121 FW_WR_COMPL_F |
+1 -1
drivers/net/ethernet/mellanox/mlx5/core/en_selftest.c
··· 172 172 mlxh->magic = cpu_to_be64(MLX5E_TEST_MAGIC); 173 173 strlcpy(mlxh->text, mlx5e_test_text, sizeof(mlxh->text)); 174 174 datalen -= sizeof(*mlxh); 175 - memset(skb_put(skb, datalen), 0, datalen); 175 + skb_put_zero(skb, datalen); 176 176 177 177 skb->csum = 0; 178 178 skb->ip_summed = CHECKSUM_PARTIAL;
+2 -2
drivers/net/usb/cdc_ncm.c
··· 1017 1017 if (skb->len + align > max) 1018 1018 align = max - skb->len; 1019 1019 if (align && skb_tailroom(skb) >= align) 1020 - memset(skb_put(skb, align), 0, align); 1020 + skb_put_zero(skb, align); 1021 1021 } 1022 1022 1023 1023 /* return a pointer to a valid struct usb_cdc_ncm_ndp16 of type sign, possibly ··· 1247 1247 if (!(dev->driver_info->flags & FLAG_SEND_ZLP) && 1248 1248 skb_out->len > ctx->min_tx_pkt) { 1249 1249 padding_count = ctx->tx_max - skb_out->len; 1250 - memset(skb_put(skb_out, padding_count), 0, padding_count); 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 1253 *skb_put(skb_out, 1) = 0; /* force short packet */
+1 -1
drivers/net/usb/kalmia.c
··· 217 217 remainder = skb->len % KALMIA_ALIGN_SIZE; 218 218 if (remainder > 0) { 219 219 padlen = KALMIA_ALIGN_SIZE - remainder; 220 - memset(skb_put(skb, padlen), 0, padlen); 220 + skb_put_zero(skb, padlen); 221 221 } 222 222 223 223 netdev_dbg(dev->net,
+1 -3
drivers/net/vxlan.c
··· 1584 1584 skb_pull(reply, sizeof(struct ipv6hdr)); 1585 1585 skb_reset_transport_header(reply); 1586 1586 1587 - na = (struct nd_msg *)skb_put(reply, sizeof(*na) + na_olen); 1588 - 1589 1587 /* Neighbor Advertisement */ 1590 - memset(na, 0, sizeof(*na)+na_olen); 1588 + na = skb_put_zero(reply, sizeof(*na) + na_olen); 1591 1589 na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT; 1592 1590 na->icmph.icmp6_router = isrouter; 1593 1591 na->icmph.icmp6_override = 1;
+1 -2
drivers/net/wireless/ath/ath9k/channel.c
··· 1526 1526 hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2; 1527 1527 hdr[7] = noa_len; 1528 1528 1529 - noa = (void *) skb_put(skb, noa_len); 1530 - memset(noa, 0, noa_len); 1529 + noa = skb_put_zero(skb, noa_len); 1531 1530 1532 1531 noa->index = avp->noa_index; 1533 1532 noa->oppps_ctwindow = ath9k_get_ctwin(sc, avp);
+2 -5
drivers/net/wireless/intersil/hostap/hostap_ap.c
··· 998 998 999 999 fc = type_subtype; 1000 1000 hdrlen = hostap_80211_get_hdrlen(cpu_to_le16(type_subtype)); 1001 - hdr = (struct ieee80211_hdr *) skb_put(skb, hdrlen); 1001 + hdr = skb_put_zero(skb, hdrlen); 1002 1002 if (body) 1003 1003 memcpy(skb_put(skb, body_len), body, body_len); 1004 - 1005 - memset(hdr, 0, hdrlen); 1006 1004 1007 1005 /* FIX: ctrl::ack sending used special HFA384X_TX_CTRL_802_11 1008 1006 * tx_control instead of using local->tx_control */ ··· 1323 1325 } 1324 1326 1325 1327 skb_reserve(skb, ap->crypt->extra_mpdu_prefix_len); 1326 - memset(skb_put(skb, WLAN_AUTH_CHALLENGE_LEN), 0, 1327 - WLAN_AUTH_CHALLENGE_LEN); 1328 + skb_put_zero(skb, WLAN_AUTH_CHALLENGE_LEN); 1328 1329 if (ap->crypt->encrypt_mpdu(skb, 0, ap->crypt_priv)) { 1329 1330 dev_kfree_skb(skb); 1330 1331 kfree(tmpbuf);
+1 -3
drivers/net/wireless/intersil/hostap/hostap_main.c
··· 1039 1039 if (skb == NULL) 1040 1040 return -ENOMEM; 1041 1041 1042 - mgmt = (struct hostap_ieee80211_mgmt *) 1043 - skb_put(skb, IEEE80211_MGMT_HDR_LEN); 1044 - memset(mgmt, 0, IEEE80211_MGMT_HDR_LEN); 1042 + mgmt = skb_put_zero(skb, IEEE80211_MGMT_HDR_LEN); 1045 1043 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 1046 1044 memcpy(mgmt->da, dst, ETH_ALEN); 1047 1045 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
+1 -2
drivers/net/wireless/intersil/p54/txrx.c
··· 910 910 } 911 911 /* reserve some space for ICV */ 912 912 len += info->control.hw_key->icv_len; 913 - memset(skb_put(skb, info->control.hw_key->icv_len), 0, 914 - info->control.hw_key->icv_len); 913 + skb_put_zero(skb, info->control.hw_key->icv_len); 915 914 } else { 916 915 txhdr->key_type = 0; 917 916 txhdr->key_len = 0;
+1 -2
drivers/net/wireless/marvell/mwifiex/cmdevt.c
··· 622 622 return -1; 623 623 } 624 624 625 - memset(skb_put(cmd_node->cmd_skb, sizeof(struct host_cmd_ds_command)), 626 - 0, sizeof(struct host_cmd_ds_command)); 625 + skb_put_zero(cmd_node->cmd_skb, sizeof(struct host_cmd_ds_command)); 627 626 628 627 cmd_ptr = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data); 629 628 cmd_ptr->command = cpu_to_le16(cmd_no);
+1 -2
drivers/net/wireless/marvell/mwifiex/tdls.c
··· 388 388 u8 ac_be[] = {0x03, 0xa4, 0x00, 0x00}; 389 389 u8 ac_bk[] = {0x27, 0xa4, 0x00, 0x00}; 390 390 391 - wmm = (void *)skb_put(skb, sizeof(*wmm)); 392 - memset(wmm, 0, sizeof(*wmm)); 391 + wmm = skb_put_zero(skb, sizeof(*wmm)); 393 392 394 393 wmm->element_id = WLAN_EID_VENDOR_SPECIFIC; 395 394 wmm->len = sizeof(*wmm) - 2;
+3 -7
drivers/net/wireless/quantenna/qtnfmac/commands.c
··· 135 135 return NULL; 136 136 } 137 137 138 - memset(skb_put(cmd_skb, cmd_size), 0, cmd_size); 138 + skb_put_zero(cmd_skb, cmd_size); 139 139 140 140 cmd = (struct qlink_cmd *)cmd_skb->data; 141 141 cmd->mhdr.len = cpu_to_le16(cmd_skb->len); ··· 238 238 bss_cfg->bcn_period); 239 239 qtnf_cmd_skb_put_tlv_u8(cmd_skb, QTN_TLV_ID_DTIM, bss_cfg->dtim); 240 240 241 - qchan = (struct qlink_tlv_channel *)skb_put(cmd_skb, sizeof(*qchan)); 242 - 243 - memset(qchan, 0, sizeof(*qchan)); 241 + qchan = skb_put_zero(cmd_skb, sizeof(*qchan)); 244 242 qchan->hdr.type = cpu_to_le16(QTN_TLV_ID_CHANNEL); 245 243 qchan->hdr.len = cpu_to_le16(sizeof(*qchan) - 246 244 sizeof(struct qlink_tlv_hdr)); ··· 1792 1794 pr_debug("MAC%u: scan chan=%d, freq=%d, flags=%#x\n", 1793 1795 mac->macid, sc->hw_value, sc->center_freq, 1794 1796 sc->flags); 1795 - qchan = (struct qlink_tlv_channel *) 1796 - skb_put(cmd_skb, sizeof(*qchan)); 1797 - memset(qchan, 0, sizeof(*qchan)); 1797 + qchan = skb_put_zero(cmd_skb, sizeof(*qchan)); 1798 1798 flags = 0; 1799 1799 1800 1800 qchan->hdr.type = cpu_to_le16(QTN_TLV_ID_CHANNEL);
+2 -4
drivers/net/wireless/realtek/rtlwifi/base.c
··· 1875 1875 return NULL; 1876 1876 1877 1877 skb_reserve(skb, hw->extra_tx_headroom); 1878 - action_frame = (void *)skb_put(skb, 27); 1879 - memset(action_frame, 0, 27); 1878 + action_frame = skb_put_zero(skb, 27); 1880 1879 memcpy(action_frame->da, da, ETH_ALEN); 1881 1880 memcpy(action_frame->sa, rtlefuse->dev_addr, ETH_ALEN); 1882 1881 memcpy(action_frame->bssid, bssid, ETH_ALEN); ··· 2004 2005 return NULL; 2005 2006 2006 2007 skb_reserve(skb, hw->extra_tx_headroom); 2007 - action_frame = (void *)skb_put(skb, 34); 2008 - memset(action_frame, 0, 34); 2008 + action_frame = skb_put_zero(skb, 34); 2009 2009 memcpy(action_frame->sa, sa, ETH_ALEN); 2010 2010 memcpy(action_frame->da, rtlefuse->dev_addr, ETH_ALEN); 2011 2011 memcpy(action_frame->bssid, bssid, ETH_ALEN);
+1 -2
drivers/net/wireless/ti/wlcore/cmd.c
··· 1233 1233 1234 1234 skb_reserve(skb, sizeof(*hdr) + WL1271_EXTRA_SPACE_MAX); 1235 1235 1236 - tmpl = (struct wl12xx_arp_rsp_template *)skb_put(skb, sizeof(*tmpl)); 1237 - memset(tmpl, 0, sizeof(*tmpl)); 1236 + tmpl = skb_put_zero(skb, sizeof(*tmpl)); 1238 1237 1239 1238 /* llc layer */ 1240 1239 memcpy(tmpl->llc_hdr, rfc1042_header, sizeof(rfc1042_header));
+2 -3
drivers/net/wireless/ti/wlcore/main.c
··· 1308 1308 1309 1309 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr)); 1310 1310 1311 - hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr)); 1312 - memset(hdr, 0, sizeof(*hdr)); 1311 + hdr = skb_put_zero(skb, sizeof(*hdr)); 1313 1312 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 1314 1313 IEEE80211_STYPE_NULLFUNC | 1315 1314 IEEE80211_FCTL_TODS); 1316 1315 1317 - memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size); 1316 + skb_put_zero(skb, dummy_packet_size); 1318 1317 1319 1318 /* Dummy packets require the TID to be management */ 1320 1319 skb->priority = WL1271_TID_MGMT;
+1 -2
drivers/scsi/fcoe/fcoe_ctlr.c
··· 660 660 661 661 if (op != ELS_LS_RJT) { 662 662 dlen += sizeof(*mac); 663 - mac = (struct fip_mac_desc *)skb_put(skb, sizeof(*mac)); 664 - memset(mac, 0, sizeof(*mac)); 663 + mac = skb_put_zero(skb, sizeof(*mac)); 665 664 mac->fd_desc.fip_dtype = FIP_DT_MAC; 666 665 mac->fd_desc.fip_dlen = sizeof(*mac) / FIP_BPW; 667 666 if (dtype != FIP_DT_FLOGI && dtype != FIP_DT_FDISC) {
+1 -1
drivers/scsi/libfc/fc_libfc.c
··· 178 178 fill = -fr_len(fp) & 3; 179 179 if (fill) { 180 180 /* TODO, this may be a problem with fragmented skb */ 181 - memset(skb_put(fp_skb(fp), fill), 0, fill); 181 + skb_put_zero(fp_skb(fp), fill); 182 182 f_ctl |= fill; 183 183 } 184 184 fr_eof(fp) = FC_EOF_T;
+5 -10
drivers/usb/gadget/function/f_ncm.c
··· 1004 1004 } 1005 1005 1006 1006 /* Insert NDP alignment. */ 1007 - ntb_iter = (void *) skb_put(skb2, ndp_pad); 1008 - memset(ntb_iter, 0, ndp_pad); 1007 + ntb_iter = skb_put_zero(skb2, ndp_pad); 1009 1008 1010 1009 /* Copy NTB across. */ 1011 1010 ntb_iter = (void *) skb_put(skb2, ncm->skb_tx_ndp->len); ··· 1013 1014 ncm->skb_tx_ndp = NULL; 1014 1015 1015 1016 /* Insert zero'd datagram. */ 1016 - ntb_iter = (void *) skb_put(skb2, dgram_idx_len); 1017 - memset(ntb_iter, 0, dgram_idx_len); 1017 + ntb_iter = skb_put_zero(skb2, dgram_idx_len); 1018 1018 1019 1019 return skb2; 1020 1020 } ··· 1078 1080 goto err; 1079 1081 1080 1082 ncm->skb_tx_data->dev = ncm->netdev; 1081 - ntb_data = (void *) skb_put(ncm->skb_tx_data, ncb_len); 1082 - memset(ntb_data, 0, ncb_len); 1083 + ntb_data = skb_put_zero(ncm->skb_tx_data, ncb_len); 1083 1084 /* dwSignature */ 1084 1085 put_unaligned_le32(opts->nth_sign, ntb_data); 1085 1086 ntb_data += 2; ··· 1115 1118 HRTIMER_MODE_REL); 1116 1119 1117 1120 /* Add the datagram position entries */ 1118 - ntb_ndp = (void *) skb_put(ncm->skb_tx_ndp, dgram_idx_len); 1119 - memset(ntb_ndp, 0, dgram_idx_len); 1121 + ntb_ndp = skb_put_zero(ncm->skb_tx_ndp, dgram_idx_len); 1120 1122 1121 1123 ncb_len = ncm->skb_tx_data->len; 1122 1124 dgram_pad = ALIGN(ncb_len, div) + rem - ncb_len; ··· 1128 1132 ncm->ndp_dgram_count++; 1129 1133 1130 1134 /* Add the new data to the skb */ 1131 - ntb_data = (void *) skb_put(ncm->skb_tx_data, dgram_pad); 1132 - memset(ntb_data, 0, dgram_pad); 1135 + ntb_data = skb_put_zero(ncm->skb_tx_data, dgram_pad); 1133 1136 ntb_data = (void *) skb_put(ncm->skb_tx_data, skb->len); 1134 1137 memcpy(ntb_data, skb->data, skb->len); 1135 1138 dev_consume_skb_any(skb);
+1 -2
net/atm/signaling.c
··· 150 150 pr_debug("%d (0x%p)\n", (int)type, vcc); 151 151 while (!(skb = alloc_skb(sizeof(struct atmsvc_msg), GFP_KERNEL))) 152 152 schedule(); 153 - msg = (struct atmsvc_msg *)skb_put(skb, sizeof(struct atmsvc_msg)); 154 - memset(msg, 0, sizeof(*msg)); 153 + msg = skb_put_zero(skb, sizeof(struct atmsvc_msg)); 155 154 msg->type = type; 156 155 *(struct atm_vcc **) &msg->vcc = vcc; 157 156 *(struct atm_vcc **) &msg->listen_vcc = listen_vcc;
+1 -2
net/batman-adv/bat_v_elp.c
··· 346 346 goto out; 347 347 348 348 skb_reserve(hard_iface->bat_v.elp_skb, ETH_HLEN + NET_IP_ALIGN); 349 - elp_buff = skb_put(hard_iface->bat_v.elp_skb, BATADV_ELP_HLEN); 349 + elp_buff = skb_put_zero(hard_iface->bat_v.elp_skb, BATADV_ELP_HLEN); 350 350 elp_packet = (struct batadv_elp_packet *)elp_buff; 351 - memset(elp_packet, 0, BATADV_ELP_HLEN); 352 351 353 352 elp_packet->packet_type = BATADV_ELP; 354 353 elp_packet->version = BATADV_COMPAT_VERSION;
+2 -4
net/bridge/netfilter/nft_reject_bridge.c
··· 147 147 net->ipv4.sysctl_ip_default_ttl); 148 148 149 149 skb_reset_transport_header(nskb); 150 - icmph = (struct icmphdr *)skb_put(nskb, sizeof(struct icmphdr)); 151 - memset(icmph, 0, sizeof(*icmph)); 150 + icmph = skb_put_zero(nskb, sizeof(struct icmphdr)); 152 151 icmph->type = ICMP_DEST_UNREACH; 153 152 icmph->code = code; 154 153 ··· 274 275 net->ipv6.devconf_all->hop_limit); 275 276 276 277 skb_reset_transport_header(nskb); 277 - icmp6h = (struct icmp6hdr *)skb_put(nskb, sizeof(struct icmp6hdr)); 278 - memset(icmp6h, 0, sizeof(*icmp6h)); 278 + icmp6h = skb_put_zero(nskb, sizeof(struct icmp6hdr)); 279 279 icmp6h->icmp6_type = ICMPV6_DEST_UNREACH; 280 280 icmp6h->icmp6_code = code; 281 281
+2 -2
net/core/pktgen.c
··· 2718 2718 datalen -= sizeof(*pgh); 2719 2719 2720 2720 if (pkt_dev->nfrags <= 0) { 2721 - memset(skb_put(skb, datalen), 0, datalen); 2721 + skb_put_zero(skb, datalen); 2722 2722 } else { 2723 2723 int frags = pkt_dev->nfrags; 2724 2724 int i, len; ··· 2729 2729 frags = MAX_SKB_FRAGS; 2730 2730 len = datalen - frags * PAGE_SIZE; 2731 2731 if (len > 0) { 2732 - memset(skb_put(skb, len), 0, len); 2732 + skb_put_zero(skb, len); 2733 2733 datalen = frags * PAGE_SIZE; 2734 2734 } 2735 2735
+1 -2
net/ipv4/ipconfig.c
··· 813 813 if (!skb) 814 814 return; 815 815 skb_reserve(skb, hlen); 816 - b = (struct bootp_pkt *) skb_put(skb, sizeof(struct bootp_pkt)); 817 - memset(b, 0, sizeof(struct bootp_pkt)); 816 + b = skb_put_zero(skb, sizeof(struct bootp_pkt)); 818 817 819 818 /* Construct IP header */ 820 819 skb_reset_network_header(skb);
+1 -2
net/ipv4/netfilter/nf_reject_ipv4.c
··· 76 76 struct tcphdr *tcph; 77 77 78 78 skb_reset_transport_header(nskb); 79 - tcph = (struct tcphdr *)skb_put(nskb, sizeof(struct tcphdr)); 80 - memset(tcph, 0, sizeof(*tcph)); 79 + tcph = skb_put_zero(nskb, sizeof(struct tcphdr)); 81 80 tcph->source = oth->dest; 82 81 tcph->dest = oth->source; 83 82 tcph->doff = sizeof(struct tcphdr) / 4;
+1 -2
net/ipv6/mcast.c
··· 2008 2008 2009 2009 memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra)); 2010 2010 2011 - hdr = (struct mld_msg *) skb_put(skb, sizeof(struct mld_msg)); 2012 - memset(hdr, 0, sizeof(struct mld_msg)); 2011 + hdr = skb_put_zero(skb, sizeof(struct mld_msg)); 2013 2012 hdr->mld_type = type; 2014 2013 hdr->mld_mca = *addr; 2015 2014
+3 -6
net/key/af_key.c
··· 2934 2934 2935 2935 if (aalg_tmpl_set(t, aalg) && aalg->available) { 2936 2936 struct sadb_comb *c; 2937 - c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb)); 2938 - memset(c, 0, sizeof(*c)); 2937 + c = skb_put_zero(skb, sizeof(struct sadb_comb)); 2939 2938 p->sadb_prop_len += sizeof(struct sadb_comb)/8; 2940 2939 c->sadb_comb_auth = aalg->desc.sadb_alg_id; 2941 2940 c->sadb_comb_auth_minbits = aalg->desc.sadb_alg_minbits; ··· 3460 3461 size_req = (sizeof(struct sadb_x_kmaddress) + 3461 3462 pfkey_sockaddr_pair_size(family)); 3462 3463 3463 - kma = (struct sadb_x_kmaddress *)skb_put(skb, size_req); 3464 - memset(kma, 0, size_req); 3464 + kma = skb_put_zero(skb, size_req); 3465 3465 kma->sadb_x_kmaddress_len = size_req / 8; 3466 3466 kma->sadb_x_kmaddress_exttype = SADB_X_EXT_KMADDRESS; 3467 3467 kma->sadb_x_kmaddress_reserved = k->reserved; ··· 3486 3488 size_req = sizeof(struct sadb_x_ipsecrequest) + 3487 3489 pfkey_sockaddr_pair_size(family); 3488 3490 3489 - rq = (struct sadb_x_ipsecrequest *)skb_put(skb, size_req); 3490 - memset(rq, 0, size_req); 3491 + rq = skb_put_zero(skb, size_req); 3491 3492 rq->sadb_x_ipsecrequest_len = size_req; 3492 3493 rq->sadb_x_ipsecrequest_proto = proto; 3493 3494 rq->sadb_x_ipsecrequest_mode = mode;
+1 -2
net/mac80211/agg-rx.c
··· 213 213 return; 214 214 215 215 skb_reserve(skb, local->hw.extra_tx_headroom); 216 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 217 - memset(mgmt, 0, 24); 216 + mgmt = skb_put_zero(skb, 24); 218 217 memcpy(mgmt->da, da, ETH_ALEN); 219 218 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 220 219 if (sdata->vif.type == NL80211_IFTYPE_AP ||
+2 -4
net/mac80211/agg-tx.c
··· 76 76 return; 77 77 78 78 skb_reserve(skb, local->hw.extra_tx_headroom); 79 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 80 - memset(mgmt, 0, 24); 79 + mgmt = skb_put_zero(skb, 24); 81 80 memcpy(mgmt->da, da, ETH_ALEN); 82 81 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 83 82 if (sdata->vif.type == NL80211_IFTYPE_AP || ··· 124 125 return; 125 126 126 127 skb_reserve(skb, local->hw.extra_tx_headroom); 127 - bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar)); 128 - memset(bar, 0, sizeof(*bar)); 128 + bar = skb_put_zero(skb, sizeof(*bar)); 129 129 bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 130 130 IEEE80211_STYPE_BACK_REQ); 131 131 memcpy(bar->ra, ra, ETH_ALEN);
+2 -3
net/mac80211/debugfs_netdev.c
··· 330 330 return -ENOMEM; 331 331 skb_reserve(skb, local->hw.extra_tx_headroom); 332 332 333 - hdr = (struct ieee80211_hdr *) skb_put(skb, 24); 334 - memset(hdr, 0, 24); 333 + hdr = skb_put_zero(skb, 24); 335 334 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA); 336 335 337 336 switch (sdata->vif.type) { ··· 366 367 * The exact contents does not matter since the recipient is required 367 368 * to drop this because of the Michael MIC failure. 368 369 */ 369 - memset(skb_put(skb, 50), 0, 50); 370 + skb_put_zero(skb, 50); 370 371 371 372 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_TKIP_MIC_FAILURE; 372 373
+1 -2
net/mac80211/ht.c
··· 394 394 return; 395 395 396 396 skb_reserve(skb, local->hw.extra_tx_headroom); 397 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 398 - memset(mgmt, 0, 24); 397 + mgmt = skb_put_zero(skb, 24); 399 398 memcpy(mgmt->da, da, ETH_ALEN); 400 399 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 401 400 if (sdata->vif.type == NL80211_IFTYPE_AP ||
+1 -2
net/mac80211/mesh.c
··· 719 719 bcn->head = ((u8 *) bcn) + sizeof(*bcn); 720 720 721 721 /* fill in the head */ 722 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 723 - memset(mgmt, 0, hdr_len); 722 + mgmt = skb_put_zero(skb, hdr_len); 724 723 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 725 724 IEEE80211_STYPE_BEACON); 726 725 eth_broadcast_addr(mgmt->da);
+2 -4
net/mac80211/mesh_hwmp.c
··· 120 120 if (!skb) 121 121 return -1; 122 122 skb_reserve(skb, local->tx_headroom); 123 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 124 - memset(mgmt, 0, hdr_len); 123 + mgmt = skb_put_zero(skb, hdr_len); 125 124 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 126 125 IEEE80211_STYPE_ACTION); 127 126 ··· 256 257 if (!skb) 257 258 return -1; 258 259 skb_reserve(skb, local->tx_headroom + sdata->encrypt_headroom); 259 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 260 - memset(mgmt, 0, hdr_len); 260 + mgmt = skb_put_zero(skb, hdr_len); 261 261 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 262 262 IEEE80211_STYPE_ACTION); 263 263
+1 -2
net/mac80211/mesh_plink.c
··· 242 242 return err; 243 243 info = IEEE80211_SKB_CB(skb); 244 244 skb_reserve(skb, local->tx_headroom); 245 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 246 - memset(mgmt, 0, hdr_len); 245 + mgmt = skb_put_zero(skb, hdr_len); 247 246 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 248 247 IEEE80211_STYPE_ACTION); 249 248 memcpy(mgmt->da, da, ETH_ALEN);
+1 -1
net/mac80211/mesh_ps.c
··· 39 39 nullfunc->seq_ctrl = 0; 40 40 /* no address resolution for this frame -> set addr 1 immediately */ 41 41 memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN); 42 - memset(skb_put(skb, 2), 0, 2); /* append QoS control field */ 42 + skb_put_zero(skb, 2); /* append QoS control field */ 43 43 ieee80211_mps_set_frame_flags(sdata, sta, nullfunc); 44 44 45 45 return skb;
+2 -4
net/mac80211/mlme.c
··· 674 674 if (ifmgd->flags & IEEE80211_STA_ENABLE_RRM) 675 675 capab |= WLAN_CAPABILITY_RADIO_MEASURE; 676 676 677 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 678 - memset(mgmt, 0, 24); 677 + mgmt = skb_put_zero(skb, 24); 679 678 memcpy(mgmt->da, assoc_data->bss->bssid, ETH_ALEN); 680 679 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 681 680 memcpy(mgmt->bssid, assoc_data->bss->bssid, ETH_ALEN); ··· 948 949 949 950 skb_reserve(skb, local->hw.extra_tx_headroom); 950 951 951 - nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30); 952 - memset(nullfunc, 0, 30); 952 + nullfunc = skb_put_zero(skb, 30); 953 953 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC | 954 954 IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 955 955 nullfunc->frame_control = fc;
+1 -2
net/mac80211/rx.c
··· 2760 2760 return; 2761 2761 2762 2762 skb_reserve(skb, local->hw.extra_tx_headroom); 2763 - resp = (struct ieee80211_mgmt *) skb_put(skb, 24); 2764 - memset(resp, 0, 24); 2763 + resp = skb_put_zero(skb, 24); 2765 2764 memcpy(resp->da, mgmt->sa, ETH_ALEN); 2766 2765 memcpy(resp->sa, sdata->vif.addr, ETH_ALEN); 2767 2766 memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
+1 -2
net/mac80211/spectmgmt.c
··· 193 193 return; 194 194 195 195 skb_reserve(skb, local->hw.extra_tx_headroom); 196 - msr_report = (struct ieee80211_mgmt *)skb_put(skb, 24); 197 - memset(msr_report, 0, 24); 196 + msr_report = skb_put_zero(skb, 24); 198 197 memcpy(msr_report->da, da, ETH_ALEN); 199 198 memcpy(msr_report->sa, sdata->vif.addr, ETH_ALEN); 200 199 memcpy(msr_report->bssid, bssid, ETH_ALEN);
+2 -4
net/mac80211/tdls.c
··· 271 271 struct ieee80211_tx_queue_params *txq; 272 272 int i; 273 273 274 - wmm = (void *)skb_put(skb, sizeof(*wmm)); 275 - memset(wmm, 0, sizeof(*wmm)); 274 + wmm = skb_put_zero(skb, sizeof(*wmm)); 276 275 277 276 wmm->element_id = WLAN_EID_VENDOR_SPECIFIC; 278 277 wmm->len = sizeof(*wmm) - 2; ··· 837 838 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 838 839 struct ieee80211_mgmt *mgmt; 839 840 840 - mgmt = (void *)skb_put(skb, 24); 841 - memset(mgmt, 0, 24); 841 + mgmt = skb_put_zero(skb, 24); 842 842 memcpy(mgmt->da, peer, ETH_ALEN); 843 843 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 844 844 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
+4 -8
net/mac80211/tx.c
··· 3044 3044 3045 3045 if (padding) { 3046 3046 *subframe_len += padding; 3047 - memset(skb_put(skb, padding), 0, padding); 3047 + skb_put_zero(skb, padding); 3048 3048 } 3049 3049 3050 3050 return true; ··· 4370 4370 4371 4371 skb_reserve(skb, local->hw.extra_tx_headroom); 4372 4372 4373 - pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll)); 4374 - memset(pspoll, 0, sizeof(*pspoll)); 4373 + pspoll = skb_put_zero(skb, sizeof(*pspoll)); 4375 4374 pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL | 4376 4375 IEEE80211_STYPE_PSPOLL); 4377 4376 pspoll->aid = cpu_to_le16(ifmgd->aid); ··· 4407 4408 4408 4409 skb_reserve(skb, local->hw.extra_tx_headroom); 4409 4410 4410 - nullfunc = (struct ieee80211_hdr_3addr *) skb_put(skb, 4411 - sizeof(*nullfunc)); 4412 - memset(nullfunc, 0, sizeof(*nullfunc)); 4411 + nullfunc = skb_put_zero(skb, sizeof(*nullfunc)); 4413 4412 nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 4414 4413 IEEE80211_STYPE_NULLFUNC | 4415 4414 IEEE80211_FCTL_TODS); ··· 4439 4442 4440 4443 skb_reserve(skb, local->hw.extra_tx_headroom); 4441 4444 4442 - hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr)); 4443 - memset(hdr, 0, sizeof(*hdr)); 4445 + hdr = skb_put_zero(skb, sizeof(*hdr)); 4444 4446 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 4445 4447 IEEE80211_STYPE_PROBE_REQ); 4446 4448 eth_broadcast_addr(hdr->addr1);
+2 -4
net/mac80211/util.c
··· 1242 1242 1243 1243 skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN); 1244 1244 1245 - mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6); 1246 - memset(mgmt, 0, 24 + 6); 1245 + mgmt = skb_put_zero(skb, 24 + 6); 1247 1246 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 1248 1247 IEEE80211_STYPE_AUTH); 1249 1248 memcpy(mgmt->da, da, ETH_ALEN); ··· 2998 2999 return -ENOMEM; 2999 3000 3000 3001 skb_reserve(skb, local->tx_headroom); 3001 - mgmt = (struct ieee80211_mgmt *)skb_put(skb, hdr_len); 3002 - memset(mgmt, 0, hdr_len); 3002 + mgmt = skb_put_zero(skb, hdr_len); 3003 3003 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 3004 3004 IEEE80211_STYPE_ACTION); 3005 3005
+12 -24
net/ncsi/ncsi-cmd.c
··· 66 66 { 67 67 struct ncsi_cmd_pkt *cmd; 68 68 69 - cmd = (struct ncsi_cmd_pkt *)skb_put(skb, sizeof(*cmd)); 70 - memset(cmd, 0, sizeof(*cmd)); 69 + cmd = skb_put_zero(skb, sizeof(*cmd)); 71 70 ncsi_cmd_build_header(&cmd->cmd.common, nca); 72 71 73 72 return 0; ··· 77 78 { 78 79 struct ncsi_cmd_sp_pkt *cmd; 79 80 80 - cmd = (struct ncsi_cmd_sp_pkt *)skb_put(skb, sizeof(*cmd)); 81 - memset(cmd, 0, sizeof(*cmd)); 81 + cmd = skb_put_zero(skb, sizeof(*cmd)); 82 82 cmd->hw_arbitration = nca->bytes[0]; 83 83 ncsi_cmd_build_header(&cmd->cmd.common, nca); 84 84 ··· 89 91 { 90 92 struct ncsi_cmd_dc_pkt *cmd; 91 93 92 - cmd = (struct ncsi_cmd_dc_pkt *)skb_put(skb, sizeof(*cmd)); 93 - memset(cmd, 0, sizeof(*cmd)); 94 + cmd = skb_put_zero(skb, sizeof(*cmd)); 94 95 cmd->ald = nca->bytes[0]; 95 96 ncsi_cmd_build_header(&cmd->cmd.common, nca); 96 97 ··· 101 104 { 102 105 struct ncsi_cmd_rc_pkt *cmd; 103 106 104 - cmd = (struct ncsi_cmd_rc_pkt *)skb_put(skb, sizeof(*cmd)); 105 - memset(cmd, 0, sizeof(*cmd)); 107 + cmd = skb_put_zero(skb, sizeof(*cmd)); 106 108 ncsi_cmd_build_header(&cmd->cmd.common, nca); 107 109 108 110 return 0; ··· 112 116 { 113 117 struct ncsi_cmd_ae_pkt *cmd; 114 118 115 - cmd = (struct ncsi_cmd_ae_pkt *)skb_put(skb, sizeof(*cmd)); 116 - memset(cmd, 0, sizeof(*cmd)); 119 + cmd = skb_put_zero(skb, sizeof(*cmd)); 117 120 cmd->mc_id = nca->bytes[0]; 118 121 cmd->mode = htonl(nca->dwords[1]); 119 122 ncsi_cmd_build_header(&cmd->cmd.common, nca); ··· 125 130 { 126 131 struct ncsi_cmd_sl_pkt *cmd; 127 132 128 - cmd = (struct ncsi_cmd_sl_pkt *)skb_put(skb, sizeof(*cmd)); 129 - memset(cmd, 0, sizeof(*cmd)); 133 + cmd = skb_put_zero(skb, sizeof(*cmd)); 130 134 cmd->mode = htonl(nca->dwords[0]); 131 135 cmd->oem_mode = htonl(nca->dwords[1]); 132 136 ncsi_cmd_build_header(&cmd->cmd.common, nca); ··· 138 144 { 139 145 struct ncsi_cmd_svf_pkt *cmd; 140 146 141 - cmd = (struct ncsi_cmd_svf_pkt *)skb_put(skb, sizeof(*cmd)); 142 - memset(cmd, 0, sizeof(*cmd)); 147 + cmd = skb_put_zero(skb, sizeof(*cmd)); 143 148 cmd->vlan = htons(nca->words[0]); 144 149 cmd->index = nca->bytes[2]; 145 150 cmd->enable = nca->bytes[3]; ··· 152 159 { 153 160 struct ncsi_cmd_ev_pkt *cmd; 154 161 155 - cmd = (struct ncsi_cmd_ev_pkt *)skb_put(skb, sizeof(*cmd)); 156 - memset(cmd, 0, sizeof(*cmd)); 162 + cmd = skb_put_zero(skb, sizeof(*cmd)); 157 163 cmd->mode = nca->bytes[0]; 158 164 ncsi_cmd_build_header(&cmd->cmd.common, nca); 159 165 ··· 165 173 struct ncsi_cmd_sma_pkt *cmd; 166 174 int i; 167 175 168 - cmd = (struct ncsi_cmd_sma_pkt *)skb_put(skb, sizeof(*cmd)); 169 - memset(cmd, 0, sizeof(*cmd)); 176 + cmd = skb_put_zero(skb, sizeof(*cmd)); 170 177 for (i = 0; i < 6; i++) 171 178 cmd->mac[i] = nca->bytes[i]; 172 179 cmd->index = nca->bytes[6]; ··· 180 189 { 181 190 struct ncsi_cmd_ebf_pkt *cmd; 182 191 183 - cmd = (struct ncsi_cmd_ebf_pkt *)skb_put(skb, sizeof(*cmd)); 184 - memset(cmd, 0, sizeof(*cmd)); 192 + cmd = skb_put_zero(skb, sizeof(*cmd)); 185 193 cmd->mode = htonl(nca->dwords[0]); 186 194 ncsi_cmd_build_header(&cmd->cmd.common, nca); 187 195 ··· 192 202 { 193 203 struct ncsi_cmd_egmf_pkt *cmd; 194 204 195 - cmd = (struct ncsi_cmd_egmf_pkt *)skb_put(skb, sizeof(*cmd)); 196 - memset(cmd, 0, sizeof(*cmd)); 205 + cmd = skb_put_zero(skb, sizeof(*cmd)); 197 206 cmd->mode = htonl(nca->dwords[0]); 198 207 ncsi_cmd_build_header(&cmd->cmd.common, nca); 199 208 ··· 204 215 { 205 216 struct ncsi_cmd_snfc_pkt *cmd; 206 217 207 - cmd = (struct ncsi_cmd_snfc_pkt *)skb_put(skb, sizeof(*cmd)); 208 - memset(cmd, 0, sizeof(*cmd)); 218 + cmd = skb_put_zero(skb, sizeof(*cmd)); 209 219 cmd->mode = nca->bytes[0]; 210 220 ncsi_cmd_build_header(&cmd->cmd.common, nca); 211 221
+1 -1
net/openvswitch/datapath.c
··· 413 413 size_t plen = NLA_ALIGN(skb->len) - skb->len; 414 414 415 415 if (plen > 0) 416 - memset(skb_put(skb, plen), 0, plen); 416 + skb_put_zero(skb, plen); 417 417 } 418 418 } 419 419
+3 -6
net/qrtr/qrtr.c
··· 285 285 if (!skb) 286 286 return NULL; 287 287 288 - buf = (__le32 *)skb_put(skb, pkt_len); 289 - memset(buf, 0, pkt_len); 288 + buf = skb_put_zero(skb, pkt_len); 290 289 buf[0] = cpu_to_le32(QRTR_TYPE_RESUME_TX); 291 290 buf[1] = cpu_to_le32(src_node); 292 291 buf[2] = cpu_to_le32(port); ··· 305 306 if (!skb) 306 307 return NULL; 307 308 308 - buf = (__le32 *)skb_put(skb, pkt_len); 309 - memset(buf, 0, pkt_len); 309 + buf = skb_put_zero(skb, pkt_len); 310 310 buf[0] = cpu_to_le32(QRTR_TYPE_BYE); 311 311 312 312 return skb; ··· 322 324 if (!skb) 323 325 return NULL; 324 326 325 - buf = (__le32 *)skb_put(skb, pkt_len); 326 - memset(buf, 0, pkt_len); 327 + buf = skb_put_zero(skb, pkt_len); 327 328 buf[0] = cpu_to_le32(QRTR_TYPE_DEL_CLIENT); 328 329 buf[1] = cpu_to_le32(sq->sq_node); 329 330 buf[2] = cpu_to_le32(sq->sq_port);
+1 -1
net/rxrpc/sendmsg.c
··· 330 330 pad &= conn->size_align - 1; 331 331 _debug("pad %zu", pad); 332 332 if (pad) 333 - memset(skb_put(skb, pad), 0, pad); 333 + skb_put_zero(skb, pad); 334 334 } 335 335 336 336 seq = call->tx_top + 1;
+1 -1
net/sctp/output.c
··· 463 463 464 464 padding = SCTP_PAD4(chunk->skb->len) - chunk->skb->len; 465 465 if (padding) 466 - memset(skb_put(chunk->skb, padding), 0, padding); 466 + skb_put_zero(chunk->skb, padding); 467 467 468 468 if (chunk == packet->auth) 469 469 auth = (struct sctp_auth_chunk *)
+1 -2
net/sctp/sm_make_chunk.c
··· 1478 1478 int chunklen = ntohs(chunk->chunk_hdr->length); 1479 1479 int padlen = SCTP_PAD4(chunklen) - chunklen; 1480 1480 1481 - padding = skb_put(chunk->skb, padlen); 1481 + padding = skb_put_zero(chunk->skb, padlen); 1482 1482 target = skb_put(chunk->skb, len); 1483 1483 1484 - memset(padding, 0, padlen); 1485 1484 memcpy(target, data, len); 1486 1485 1487 1486 /* Adjust the chunk length field. */