+9 -22

drivers/net/can/dev/skb.c

reviewed

··· 206 206 EXPORT_SYMBOL_GPL(can_free_echo_skb); 207 207 208 208 /* fill common values for CAN sk_buffs */ 209 209 - static void init_can_skb_reserve(struct sk_buff *skb) 209 209 + static void init_can_skb(struct sk_buff *skb) 210 210 { 211 211 skb->pkt_type = PACKET_BROADCAST; 212 212 skb->ip_summed = CHECKSUM_UNNECESSARY; 213 213 - 214 214 - skb_reset_mac_header(skb); 215 215 - skb_reset_network_header(skb); 216 216 - skb_reset_transport_header(skb); 217 217 - 218 218 - can_skb_reserve(skb); 219 213 } 220 214 221 215 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf) ··· 217 223 struct sk_buff *skb; 218 224 struct can_skb_ext *csx; 219 225 220 220 - skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) + 221 221 - sizeof(struct can_frame)); 226 226 + skb = netdev_alloc_skb(dev, sizeof(struct can_frame)); 222 227 if (unlikely(!skb)) 223 228 goto out_error_cc; 224 229 ··· 228 235 } 229 236 230 237 skb->protocol = htons(ETH_P_CAN); 231 231 - init_can_skb_reserve(skb); 238 238 + init_can_skb(skb); 232 239 csx->can_iif = dev->ifindex; 233 240 234 241 *cf = skb_put_zero(skb, sizeof(struct can_frame)); ··· 248 255 struct sk_buff *skb; 249 256 struct can_skb_ext *csx; 250 257 251 251 - skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) + 252 252 - sizeof(struct canfd_frame)); 258 258 + skb = netdev_alloc_skb(dev, sizeof(struct canfd_frame)); 253 259 if (unlikely(!skb)) 254 260 goto out_error_fd; 255 261 ··· 259 267 } 260 268 261 269 skb->protocol = htons(ETH_P_CANFD); 262 262 - init_can_skb_reserve(skb); 270 270 + init_can_skb(skb); 263 271 csx->can_iif = dev->ifindex; 264 272 265 273 *cfd = skb_put_zero(skb, sizeof(struct canfd_frame)); ··· 286 294 if (data_len < CANXL_MIN_DLEN || data_len > CANXL_MAX_DLEN) 287 295 goto out_error_xl; 288 296 289 289 - skb = netdev_alloc_skb(dev, sizeof(struct can_skb_priv) + 290 290 - CANXL_HDR_SIZE + data_len); 297 297 + skb = netdev_alloc_skb(dev, CANXL_HDR_SIZE + data_len); 291 298 if (unlikely(!skb)) 292 299 goto out_error_xl; 293 300 ··· 297 306 } 298 307 299 308 skb->protocol = htons(ETH_P_CANXL); 300 300 - init_can_skb_reserve(skb); 309 309 + init_can_skb(skb); 301 310 csx->can_iif = dev->ifindex; 302 311 303 312 *cxl = skb_put_zero(skb, CANXL_HDR_SIZE + data_len); ··· 331 340 EXPORT_SYMBOL_GPL(alloc_can_err_skb); 332 341 333 342 /* Check for outgoing skbs that have not been created by the CAN subsystem */ 334 334 - static bool can_skb_headroom_valid(struct net_device *dev, struct sk_buff *skb) 343 343 + static bool can_skb_init_valid(struct net_device *dev, struct sk_buff *skb) 335 344 { 336 345 struct can_skb_ext *csx = can_skb_ext_find(skb); 337 337 - 338 338 - /* af_packet creates a headroom of HH_DATA_MOD bytes which is fine */ 339 339 - if (WARN_ON_ONCE(skb_headroom(skb) < sizeof(struct can_skb_priv))) 340 340 - return false; 341 346 342 347 /* af_packet does not apply CAN skb specific settings */ 343 348 if (skb->ip_summed == CHECKSUM_NONE || !csx) { ··· 392 405 goto inval_skb; 393 406 } 394 407 395 395 - if (!can_skb_headroom_valid(dev, skb)) 408 408 + if (!can_skb_init_valid(dev, skb)) 396 409 goto inval_skb; 397 410 398 411 return false;

-31

include/linux/can/skb.h

reviewed

··· 38 38 struct can_frame **cf); 39 39 bool can_dropped_invalid_skb(struct net_device *dev, struct sk_buff *skb); 40 40 41 41 - /* 42 42 - * The struct can_skb_priv is used to transport additional information along 43 43 - * with the stored struct can(fd)_frame that can not be contained in existing 44 44 - * struct sk_buff elements. 45 45 - * N.B. that this information must not be modified in cloned CAN sk_buffs. 46 46 - * To modify the CAN frame content or the struct can_skb_priv content 47 47 - * skb_copy() needs to be used instead of skb_clone(). 48 48 - */ 49 49 - 50 50 - /** 51 51 - * struct can_skb_priv - private additional data inside CAN sk_buffs 52 52 - * @ifindex: ifindex of the first interface the CAN frame appeared on 53 53 - * @frame_len: length of CAN frame in data link layer 54 54 - * @cf: align to the following CAN frame at skb->data 55 55 - */ 56 56 - struct can_skb_priv { 57 57 - int ifindex; 58 58 - unsigned int frame_len; 59 59 - struct can_frame cf[]; 60 60 - }; 61 61 - 62 62 - static inline struct can_skb_priv *can_skb_prv(struct sk_buff *skb) 63 63 - { 64 64 - return (struct can_skb_priv *)(skb->head); 65 65 - } 66 66 - 67 67 - static inline void can_skb_reserve(struct sk_buff *skb) 68 68 - { 69 69 - skb_reserve(skb, sizeof(struct can_skb_priv)); 70 70 - } 71 71 - 72 41 static inline struct can_skb_ext *can_skb_ext_add(struct sk_buff *skb) 73 42 { 74 43 struct can_skb_ext *csx = skb_ext_add(skb, SKB_EXT_CAN);

+2 -5

net/can/bcm.c

reviewed

··· 312 312 return; 313 313 } 314 314 315 315 - skb = alloc_skb(op->cfsiz + sizeof(struct can_skb_priv), gfp_any()); 315 315 + skb = alloc_skb(op->cfsiz, gfp_any()); 316 316 if (!skb) 317 317 goto out; 318 318 ··· 322 322 goto out; 323 323 } 324 324 325 325 - can_skb_reserve(skb); 326 325 csx->can_iif = dev->ifindex; 327 326 328 327 skb_put_data(skb, cf, op->cfsiz); ··· 1332 1333 if (!ifindex) 1333 1334 return -ENODEV; 1334 1335 1335 1335 - skb = alloc_skb(cfsiz + sizeof(struct can_skb_priv), GFP_KERNEL); 1336 1336 + skb = alloc_skb(cfsiz, GFP_KERNEL); 1336 1337 if (!skb) 1337 1338 return -ENOMEM; 1338 1339 ··· 1341 1342 kfree_skb(skb); 1342 1343 return -ENOMEM; 1343 1344 } 1344 1344 - 1345 1345 - can_skb_reserve(skb); 1346 1345 1347 1346 err = memcpy_from_msg(skb_put(skb, cfsiz), msg, cfsiz); 1348 1347 if (err < 0) {

+4 -8

net/can/isotp.c

reviewed

··· 220 220 struct isotp_sock *so = isotp_sk(sk); 221 221 int can_send_ret; 222 222 223 223 - nskb = alloc_skb(so->ll.mtu + sizeof(struct can_skb_priv), gfp_any()); 223 223 + nskb = alloc_skb(so->ll.mtu, gfp_any()); 224 224 if (!nskb) 225 225 return 1; 226 226 ··· 236 236 return 1; 237 237 } 238 238 239 239 - can_skb_reserve(nskb); 240 239 csx->can_iif = dev->ifindex; 241 241 - 242 240 nskb->dev = dev; 243 241 can_skb_set_owner(nskb, sk); 244 242 ncf = (struct canfd_frame *)nskb->data; ··· 778 780 if (!dev) 779 781 return; 780 782 781 781 - skb = alloc_skb(so->ll.mtu + sizeof(struct can_skb_priv), GFP_ATOMIC); 783 783 + skb = alloc_skb(so->ll.mtu, GFP_ATOMIC); 782 784 if (!skb) { 783 785 dev_put(dev); 784 786 return; ··· 791 793 return; 792 794 } 793 795 794 794 - can_skb_reserve(skb); 795 796 csx->can_iif = dev->ifindex; 796 797 797 798 cf = (struct canfd_frame *)skb->data; ··· 1012 1015 goto err_out_drop; 1013 1016 } 1014 1017 1015 1015 - skb = sock_alloc_send_skb(sk, so->ll.mtu + sizeof(struct can_skb_priv), 1016 1016 - msg->msg_flags & MSG_DONTWAIT, &err); 1018 1018 + skb = sock_alloc_send_skb(sk, so->ll.mtu, msg->msg_flags & MSG_DONTWAIT, 1019 1019 + &err); 1017 1020 if (!skb) { 1018 1021 dev_put(dev); 1019 1022 goto err_out_drop; ··· 1027 1030 goto err_out_drop; 1028 1031 } 1029 1032 1030 1030 - can_skb_reserve(skb); 1031 1033 csx->can_iif = dev->ifindex; 1032 1034 1033 1035 so->tx.len = size;

+1 -3

net/can/j1939/socket.c

reviewed

··· 891 891 skb = sock_alloc_send_skb(sk, 892 892 size + 893 893 sizeof(struct can_frame) - 894 894 - sizeof(((struct can_frame *)NULL)->data) + 895 895 - sizeof(struct can_skb_priv), 894 894 + sizeof(((struct can_frame *)NULL)->data), 896 895 msg->msg_flags & MSG_DONTWAIT, &ret); 897 896 if (!skb) 898 897 goto failure; ··· 903 904 goto failure; 904 905 } 905 906 906 906 - can_skb_reserve(skb); 907 907 csx->can_iif = ndev->ifindex; 908 908 skb_reserve(skb, offsetof(struct can_frame, data)); 909 909

+2 -5

net/can/j1939/transport.c

reviewed

··· 595 595 struct can_skb_ext *csx; 596 596 struct j1939_sk_buff_cb *skcb; 597 597 598 598 - skb = alloc_skb(sizeof(struct can_frame) + sizeof(struct can_skb_priv), 599 599 - GFP_ATOMIC); 598 598 + skb = alloc_skb(sizeof(struct can_frame), GFP_ATOMIC); 600 599 if (unlikely(!skb)) 601 600 return ERR_PTR(-ENOMEM); 602 601 ··· 606 607 } 607 608 608 609 skb->dev = priv->ndev; 609 609 - can_skb_reserve(skb); 610 610 csx->can_iif = priv->ndev->ifindex; 611 611 /* reserve CAN header */ 612 612 skb_reserve(skb, offsetof(struct can_frame, data)); ··· 1546 1548 struct j1939_sk_buff_cb *skcb; 1547 1549 struct j1939_session *session; 1548 1550 1549 1549 - skb = alloc_skb(size + sizeof(struct can_skb_priv), GFP_ATOMIC); 1551 1551 + skb = alloc_skb(size, GFP_ATOMIC); 1550 1552 if (unlikely(!skb)) 1551 1553 return NULL; 1552 1554 ··· 1557 1559 } 1558 1560 1559 1561 skb->dev = priv->ndev; 1560 1560 - can_skb_reserve(skb); 1561 1562 csx->can_iif = priv->ndev->ifindex; 1562 1563 skcb = j1939_skb_to_cb(skb); 1563 1564 memcpy(skcb, rel_skcb, sizeof(*skcb));

+2 -3

net/can/raw.c

reviewed

··· 953 953 goto put_dev; 954 954 } 955 955 956 956 - skb = sock_alloc_send_skb(sk, size + sizeof(struct can_skb_priv), 957 957 - msg->msg_flags & MSG_DONTWAIT, &err); 956 956 + skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, 957 957 + &err); 958 958 if (!skb) 959 959 goto put_dev; 960 960 ··· 965 965 goto put_dev; 966 966 } 967 967 968 968 - can_skb_reserve(skb); 969 968 csx->can_iif = dev->ifindex; 970 969 971 970 /* fill the skb before testing for valid CAN frames */