Merge tag 'net-6.13-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

+6 -5

Documentation/networking/bareudp.rst

··· 6 6 7 7 There are various L3 encapsulation standards using UDP being discussed to 8 8 leverage the UDP based load balancing capability of different networks. 9 - MPLSoUDP (__ https://tools.ietf.org/html/rfc7510) is one among them. 9 + MPLSoUDP (https://tools.ietf.org/html/rfc7510) is one among them. 10 10 11 11 The Bareudp tunnel module provides a generic L3 encapsulation support for 12 12 tunnelling different L3 protocols like MPLS, IP, NSH etc. inside a UDP tunnel. 13 13 14 14 Special Handling 15 15 ---------------- 16 + 16 17 The bareudp device supports special handling for MPLS & IP as they can have 17 18 multiple ethertypes. 18 - MPLS procotcol can have ethertypes ETH_P_MPLS_UC (unicast) & ETH_P_MPLS_MC (multicast). 19 + The MPLS protocol can have ethertypes ETH_P_MPLS_UC (unicast) & ETH_P_MPLS_MC (multicast). 19 20 IP protocol can have ethertypes ETH_P_IP (v4) & ETH_P_IPV6 (v6). 20 21 This special handling can be enabled only for ethertypes ETH_P_IP & ETH_P_MPLS_UC 21 22 with a flag called multiproto mode. ··· 53 52 3) Device Usage 54 53 55 54 The bareudp device could be used along with OVS or flower filter in TC. 56 - The OVS or TC flower layer must set the tunnel information in SKB dst field before 57 - sending packet buffer to the bareudp device for transmission. On reception the 58 - bareudp device extracts and stores the tunnel information in SKB dst field before 55 + The OVS or TC flower layer must set the tunnel information in the SKB dst field before 56 + sending the packet buffer to the bareudp device for transmission. On reception, the 57 + bareUDP device extracts and stores the tunnel information in the SKB dst field before 59 58 passing the packet buffer to the network stack.

+1

MAINTAINERS

··· 16267 16267 F: Documentation/networking/net_cachelines/net_device.rst 16268 16268 F: drivers/connector/ 16269 16269 F: drivers/net/ 16270 + F: drivers/ptp/ 16270 16271 F: include/dt-bindings/net/ 16271 16272 F: include/linux/cn_proc.h 16272 16273 F: include/linux/etherdevice.h

+17 -9

drivers/net/can/c_can/c_can_main.c

··· 1014 1014 1015 1015 /* propagate the error condition to the CAN stack */ 1016 1016 skb = alloc_can_err_skb(dev, &cf); 1017 - if (unlikely(!skb)) 1018 - return 0; 1019 1017 1020 1018 /* check for 'last error code' which tells us the 1021 1019 * type of the last error to occur on the CAN bus 1022 1020 */ 1023 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 1021 + if (likely(skb)) 1022 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 1024 1023 1025 1024 switch (lec_type) { 1026 1025 case LEC_STUFF_ERROR: 1027 1026 netdev_dbg(dev, "stuff error\n"); 1028 - cf->data[2] |= CAN_ERR_PROT_STUFF; 1027 + if (likely(skb)) 1028 + cf->data[2] |= CAN_ERR_PROT_STUFF; 1029 1029 stats->rx_errors++; 1030 1030 break; 1031 1031 case LEC_FORM_ERROR: 1032 1032 netdev_dbg(dev, "form error\n"); 1033 - cf->data[2] |= CAN_ERR_PROT_FORM; 1033 + if (likely(skb)) 1034 + cf->data[2] |= CAN_ERR_PROT_FORM; 1034 1035 stats->rx_errors++; 1035 1036 break; 1036 1037 case LEC_ACK_ERROR: 1037 1038 netdev_dbg(dev, "ack error\n"); 1038 - cf->data[3] = CAN_ERR_PROT_LOC_ACK; 1039 + if (likely(skb)) 1040 + cf->data[3] = CAN_ERR_PROT_LOC_ACK; 1039 1041 stats->tx_errors++; 1040 1042 break; 1041 1043 case LEC_BIT1_ERROR: 1042 1044 netdev_dbg(dev, "bit1 error\n"); 1043 - cf->data[2] |= CAN_ERR_PROT_BIT1; 1045 + if (likely(skb)) 1046 + cf->data[2] |= CAN_ERR_PROT_BIT1; 1044 1047 stats->tx_errors++; 1045 1048 break; 1046 1049 case LEC_BIT0_ERROR: 1047 1050 netdev_dbg(dev, "bit0 error\n"); 1048 - cf->data[2] |= CAN_ERR_PROT_BIT0; 1051 + if (likely(skb)) 1052 + cf->data[2] |= CAN_ERR_PROT_BIT0; 1049 1053 stats->tx_errors++; 1050 1054 break; 1051 1055 case LEC_CRC_ERROR: 1052 1056 netdev_dbg(dev, "CRC error\n"); 1053 - cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 1057 + if (likely(skb)) 1058 + cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 1054 1059 stats->rx_errors++; 1055 1060 break; 1056 1061 default: 1057 1062 break; 1058 1063 } 1064 + 1065 + if (unlikely(!skb)) 1066 + return 0; 1059 1067 1060 1068 netif_receive_skb(skb); 1061 1069 return 1;

+1 -1

drivers/net/can/dev/dev.c

··· 468 468 else 469 469 set = 0; 470 470 471 - gpiod_set_value(priv->termination_gpio, set); 471 + gpiod_set_value_cansleep(priv->termination_gpio, set); 472 472 473 473 return 0; 474 474 }

+40 -18

drivers/net/can/ifi_canfd/ifi_canfd.c

··· 390 390 return 0; 391 391 392 392 priv->can.can_stats.bus_error++; 393 - stats->rx_errors++; 394 393 395 394 /* Propagate the error condition to the CAN stack. */ 396 395 skb = alloc_can_err_skb(ndev, &cf); 397 - if (unlikely(!skb)) 398 - return 0; 399 396 400 397 /* Read the error counter register and check for new errors. */ 401 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 398 + if (likely(skb)) 399 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 402 400 403 - if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST) 404 - cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 401 + if (errctr & IFI_CANFD_ERROR_CTR_OVERLOAD_FIRST) { 402 + stats->rx_errors++; 403 + if (likely(skb)) 404 + cf->data[2] |= CAN_ERR_PROT_OVERLOAD; 405 + } 405 406 406 - if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST) 407 - cf->data[3] = CAN_ERR_PROT_LOC_ACK; 407 + if (errctr & IFI_CANFD_ERROR_CTR_ACK_ERROR_FIRST) { 408 + stats->tx_errors++; 409 + if (likely(skb)) 410 + cf->data[3] = CAN_ERR_PROT_LOC_ACK; 411 + } 408 412 409 - if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST) 410 - cf->data[2] |= CAN_ERR_PROT_BIT0; 413 + if (errctr & IFI_CANFD_ERROR_CTR_BIT0_ERROR_FIRST) { 414 + stats->tx_errors++; 415 + if (likely(skb)) 416 + cf->data[2] |= CAN_ERR_PROT_BIT0; 417 + } 411 418 412 - if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST) 413 - cf->data[2] |= CAN_ERR_PROT_BIT1; 419 + if (errctr & IFI_CANFD_ERROR_CTR_BIT1_ERROR_FIRST) { 420 + stats->tx_errors++; 421 + if (likely(skb)) 422 + cf->data[2] |= CAN_ERR_PROT_BIT1; 423 + } 414 424 415 - if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST) 416 - cf->data[2] |= CAN_ERR_PROT_STUFF; 425 + if (errctr & IFI_CANFD_ERROR_CTR_STUFF_ERROR_FIRST) { 426 + stats->rx_errors++; 427 + if (likely(skb)) 428 + cf->data[2] |= CAN_ERR_PROT_STUFF; 429 + } 417 430 418 - if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST) 419 - cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 431 + if (errctr & IFI_CANFD_ERROR_CTR_CRC_ERROR_FIRST) { 432 + stats->rx_errors++; 433 + if (likely(skb)) 434 + cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 435 + } 420 436 421 - if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST) 422 - cf->data[2] |= CAN_ERR_PROT_FORM; 437 + if (errctr & IFI_CANFD_ERROR_CTR_FORM_ERROR_FIRST) { 438 + stats->rx_errors++; 439 + if (likely(skb)) 440 + cf->data[2] |= CAN_ERR_PROT_FORM; 441 + } 423 442 424 443 /* Reset the error counter, ack the IRQ and re-enable the counter. */ 425 444 writel(IFI_CANFD_ERROR_CTR_ER_RESET, priv->base + IFI_CANFD_ERROR_CTR); 426 445 writel(IFI_CANFD_INTERRUPT_ERROR_COUNTER, 427 446 priv->base + IFI_CANFD_INTERRUPT); 428 447 writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); 448 + 449 + if (unlikely(!skb)) 450 + return 0; 429 451 430 452 netif_receive_skb(skb); 431 453

+23 -10

drivers/net/can/m_can/m_can.c

··· 695 695 u32 timestamp = 0; 696 696 697 697 cdev->can.can_stats.bus_error++; 698 - stats->rx_errors++; 699 698 700 699 /* propagate the error condition to the CAN stack */ 701 700 skb = alloc_can_err_skb(dev, &cf); 702 - if (unlikely(!skb)) 703 - return 0; 704 701 705 702 /* check for 'last error code' which tells us the 706 703 * type of the last error to occur on the CAN bus 707 704 */ 708 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 705 + if (likely(skb)) 706 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 709 707 710 708 switch (lec_type) { 711 709 case LEC_STUFF_ERROR: 712 710 netdev_dbg(dev, "stuff error\n"); 713 - cf->data[2] |= CAN_ERR_PROT_STUFF; 711 + stats->rx_errors++; 712 + if (likely(skb)) 713 + cf->data[2] |= CAN_ERR_PROT_STUFF; 714 714 break; 715 715 case LEC_FORM_ERROR: 716 716 netdev_dbg(dev, "form error\n"); 717 - cf->data[2] |= CAN_ERR_PROT_FORM; 717 + stats->rx_errors++; 718 + if (likely(skb)) 719 + cf->data[2] |= CAN_ERR_PROT_FORM; 718 720 break; 719 721 case LEC_ACK_ERROR: 720 722 netdev_dbg(dev, "ack error\n"); 721 - cf->data[3] = CAN_ERR_PROT_LOC_ACK; 723 + stats->tx_errors++; 724 + if (likely(skb)) 725 + cf->data[3] = CAN_ERR_PROT_LOC_ACK; 722 726 break; 723 727 case LEC_BIT1_ERROR: 724 728 netdev_dbg(dev, "bit1 error\n"); 725 - cf->data[2] |= CAN_ERR_PROT_BIT1; 729 + stats->tx_errors++; 730 + if (likely(skb)) 731 + cf->data[2] |= CAN_ERR_PROT_BIT1; 726 732 break; 727 733 case LEC_BIT0_ERROR: 728 734 netdev_dbg(dev, "bit0 error\n"); 729 - cf->data[2] |= CAN_ERR_PROT_BIT0; 735 + stats->tx_errors++; 736 + if (likely(skb)) 737 + cf->data[2] |= CAN_ERR_PROT_BIT0; 730 738 break; 731 739 case LEC_CRC_ERROR: 732 740 netdev_dbg(dev, "CRC error\n"); 733 - cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 741 + stats->rx_errors++; 742 + if (likely(skb)) 743 + cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 734 744 break; 735 745 default: 736 746 break; 737 747 } 748 + 749 + if (unlikely(!skb)) 750 + return 0; 738 751 739 752 if (cdev->is_peripheral) 740 753 timestamp = m_can_get_timestamp(cdev);

+38 -27

drivers/net/can/sja1000/sja1000.c

··· 416 416 int ret = 0; 417 417 418 418 skb = alloc_can_err_skb(dev, &cf); 419 - if (skb == NULL) 420 - return -ENOMEM; 421 419 422 420 txerr = priv->read_reg(priv, SJA1000_TXERR); 423 421 rxerr = priv->read_reg(priv, SJA1000_RXERR); ··· 423 425 if (isrc & IRQ_DOI) { 424 426 /* data overrun interrupt */ 425 427 netdev_dbg(dev, "data overrun interrupt\n"); 426 - cf->can_id |= CAN_ERR_CRTL; 427 - cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 428 + if (skb) { 429 + cf->can_id |= CAN_ERR_CRTL; 430 + cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 431 + } 432 + 428 433 stats->rx_over_errors++; 429 434 stats->rx_errors++; 430 435 sja1000_write_cmdreg(priv, CMD_CDO); /* clear bit */ ··· 453 452 else 454 453 state = CAN_STATE_ERROR_ACTIVE; 455 454 } 456 - if (state != CAN_STATE_BUS_OFF) { 455 + if (state != CAN_STATE_BUS_OFF && skb) { 457 456 cf->can_id |= CAN_ERR_CNT; 458 457 cf->data[6] = txerr; 459 458 cf->data[7] = rxerr; ··· 461 460 if (isrc & IRQ_BEI) { 462 461 /* bus error interrupt */ 463 462 priv->can.can_stats.bus_error++; 464 - stats->rx_errors++; 465 463 466 464 ecc = priv->read_reg(priv, SJA1000_ECC); 465 + if (skb) { 466 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 467 467 468 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 468 + /* set error type */ 469 + switch (ecc & ECC_MASK) { 470 + case ECC_BIT: 471 + cf->data[2] |= CAN_ERR_PROT_BIT; 472 + break; 473 + case ECC_FORM: 474 + cf->data[2] |= CAN_ERR_PROT_FORM; 475 + break; 476 + case ECC_STUFF: 477 + cf->data[2] |= CAN_ERR_PROT_STUFF; 478 + break; 479 + default: 480 + break; 481 + } 469 482 470 - /* set error type */ 471 - switch (ecc & ECC_MASK) { 472 - case ECC_BIT: 473 - cf->data[2] |= CAN_ERR_PROT_BIT; 474 - break; 475 - case ECC_FORM: 476 - cf->data[2] |= CAN_ERR_PROT_FORM; 477 - break; 478 - case ECC_STUFF: 479 - cf->data[2] |= CAN_ERR_PROT_STUFF; 480 - break; 481 - default: 482 - break; 483 + /* set error location */ 484 + cf->data[3] = ecc & ECC_SEG; 483 485 } 484 486 485 - /* set error location */ 486 - cf->data[3] = ecc & ECC_SEG; 487 - 488 487 /* Error occurred during transmission? */ 489 - if ((ecc & ECC_DIR) == 0) 490 - cf->data[2] |= CAN_ERR_PROT_TX; 488 + if ((ecc & ECC_DIR) == 0) { 489 + stats->tx_errors++; 490 + if (skb) 491 + cf->data[2] |= CAN_ERR_PROT_TX; 492 + } else { 493 + stats->rx_errors++; 494 + } 491 495 } 492 496 if (isrc & IRQ_EPI) { 493 497 /* error passive interrupt */ ··· 508 502 netdev_dbg(dev, "arbitration lost interrupt\n"); 509 503 alc = priv->read_reg(priv, SJA1000_ALC); 510 504 priv->can.can_stats.arbitration_lost++; 511 - cf->can_id |= CAN_ERR_LOSTARB; 512 - cf->data[0] = alc & 0x1f; 505 + if (skb) { 506 + cf->can_id |= CAN_ERR_LOSTARB; 507 + cf->data[0] = alc & 0x1f; 508 + } 513 509 } 514 510 515 511 if (state != priv->can.state) { ··· 523 515 if(state == CAN_STATE_BUS_OFF) 524 516 can_bus_off(dev); 525 517 } 518 + 519 + if (!skb) 520 + return -ENOMEM; 526 521 527 522 netif_rx(skb); 528 523

+32 -21

drivers/net/can/spi/hi311x.c

··· 663 663 u8 rxerr, txerr; 664 664 665 665 skb = alloc_can_err_skb(net, &cf); 666 - if (!skb) 667 - break; 668 666 669 667 txerr = hi3110_read(spi, HI3110_READ_TEC); 670 668 rxerr = hi3110_read(spi, HI3110_READ_REC); 671 669 tx_state = txerr >= rxerr ? new_state : 0; 672 670 rx_state = txerr <= rxerr ? new_state : 0; 673 671 can_change_state(net, cf, tx_state, rx_state); 674 - netif_rx(skb); 675 672 676 673 if (new_state == CAN_STATE_BUS_OFF) { 674 + if (skb) 675 + netif_rx(skb); 677 676 can_bus_off(net); 678 677 if (priv->can.restart_ms == 0) { 679 678 priv->force_quit = 1; 680 679 hi3110_hw_sleep(spi); 681 680 break; 682 681 } 683 - } else { 682 + } else if (skb) { 684 683 cf->can_id |= CAN_ERR_CNT; 685 684 cf->data[6] = txerr; 686 685 cf->data[7] = rxerr; 686 + netif_rx(skb); 687 687 } 688 688 } 689 689 ··· 696 696 /* Check for protocol errors */ 697 697 if (eflag & HI3110_ERR_PROTOCOL_MASK) { 698 698 skb = alloc_can_err_skb(net, &cf); 699 - if (!skb) 700 - break; 699 + if (skb) 700 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 701 701 702 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 703 702 priv->can.can_stats.bus_error++; 704 - priv->net->stats.rx_errors++; 705 - if (eflag & HI3110_ERR_BITERR) 706 - cf->data[2] |= CAN_ERR_PROT_BIT; 707 - else if (eflag & HI3110_ERR_FRMERR) 708 - cf->data[2] |= CAN_ERR_PROT_FORM; 709 - else if (eflag & HI3110_ERR_STUFERR) 710 - cf->data[2] |= CAN_ERR_PROT_STUFF; 711 - else if (eflag & HI3110_ERR_CRCERR) 712 - cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ; 713 - else if (eflag & HI3110_ERR_ACKERR) 714 - cf->data[3] |= CAN_ERR_PROT_LOC_ACK; 703 + if (eflag & HI3110_ERR_BITERR) { 704 + priv->net->stats.tx_errors++; 705 + if (skb) 706 + cf->data[2] |= CAN_ERR_PROT_BIT; 707 + } else if (eflag & HI3110_ERR_FRMERR) { 708 + priv->net->stats.rx_errors++; 709 + if (skb) 710 + cf->data[2] |= CAN_ERR_PROT_FORM; 711 + } else if (eflag & HI3110_ERR_STUFERR) { 712 + priv->net->stats.rx_errors++; 713 + if (skb) 714 + cf->data[2] |= CAN_ERR_PROT_STUFF; 715 + } else if (eflag & HI3110_ERR_CRCERR) { 716 + priv->net->stats.rx_errors++; 717 + if (skb) 718 + cf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ; 719 + } else if (eflag & HI3110_ERR_ACKERR) { 720 + priv->net->stats.tx_errors++; 721 + if (skb) 722 + cf->data[3] |= CAN_ERR_PROT_LOC_ACK; 723 + } 715 724 716 - cf->data[6] = hi3110_read(spi, HI3110_READ_TEC); 717 - cf->data[7] = hi3110_read(spi, HI3110_READ_REC); 718 725 netdev_dbg(priv->net, "Bus Error\n"); 719 - netif_rx(skb); 726 + if (skb) { 727 + cf->data[6] = hi3110_read(spi, HI3110_READ_TEC); 728 + cf->data[7] = hi3110_read(spi, HI3110_READ_REC); 729 + netif_rx(skb); 730 + } 720 731 } 721 732 } 722 733

+28 -1

drivers/net/can/spi/mcp251xfd/mcp251xfd-tef.c

··· 21 21 return fifo_sta & MCP251XFD_REG_FIFOSTA_TFERFFIF; 22 22 } 23 23 24 + static inline bool mcp251xfd_tx_fifo_sta_less_than_half_full(u32 fifo_sta) 25 + { 26 + return fifo_sta & MCP251XFD_REG_FIFOSTA_TFHRFHIF; 27 + } 28 + 24 29 static inline int 25 30 mcp251xfd_tef_tail_get_from_chip(const struct mcp251xfd_priv *priv, 26 31 u8 *tef_tail) ··· 152 147 BUILD_BUG_ON(sizeof(tx_ring->obj_num) != sizeof(len)); 153 148 154 149 len = (chip_tx_tail << shift) - (tail << shift); 155 - *len_p = len >> shift; 150 + len >>= shift; 151 + 152 + /* According to mcp2518fd erratum DS80000789E 6. the FIFOCI 153 + * bits of a FIFOSTA register, here the TX-FIFO tail index 154 + * might be corrupted. 155 + * 156 + * However here it seems the bit indicating that the TX-FIFO 157 + * is empty (MCP251XFD_REG_FIFOSTA_TFERFFIF) is not correct 158 + * while the TX-FIFO tail index is. 159 + * 160 + * We assume the TX-FIFO is empty, i.e. all pending CAN frames 161 + * haven been send, if: 162 + * - Chip's head and tail index are equal (len == 0). 163 + * - The TX-FIFO is less than half full. 164 + * (The TX-FIFO empty case has already been checked at the 165 + * beginning of this function.) 166 + * - No free buffers in the TX ring. 167 + */ 168 + if (len == 0 && mcp251xfd_tx_fifo_sta_less_than_half_full(fifo_sta) && 169 + mcp251xfd_get_tx_free(tx_ring) == 0) 170 + len = tx_ring->obj_num; 171 + 172 + *len_p = len; 156 173 157 174 return 0; 158 175 }

+13 -9

drivers/net/can/sun4i_can.c

··· 579 579 /* bus error interrupt */ 580 580 netdev_dbg(dev, "bus error interrupt\n"); 581 581 priv->can.can_stats.bus_error++; 582 - stats->rx_errors++; 582 + ecc = readl(priv->base + SUN4I_REG_STA_ADDR); 583 583 584 584 if (likely(skb)) { 585 - ecc = readl(priv->base + SUN4I_REG_STA_ADDR); 586 - 587 585 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 588 586 589 587 switch (ecc & SUN4I_STA_MASK_ERR) { ··· 599 601 >> 16; 600 602 break; 601 603 } 602 - /* error occurred during transmission? */ 603 - if ((ecc & SUN4I_STA_ERR_DIR) == 0) 604 + } 605 + 606 + /* error occurred during transmission? */ 607 + if ((ecc & SUN4I_STA_ERR_DIR) == 0) { 608 + if (likely(skb)) 604 609 cf->data[2] |= CAN_ERR_PROT_TX; 610 + stats->tx_errors++; 611 + } else { 612 + stats->rx_errors++; 605 613 } 606 614 } 607 615 if (isrc & SUN4I_INT_ERR_PASSIVE) { ··· 633 629 tx_state = txerr >= rxerr ? state : 0; 634 630 rx_state = txerr <= rxerr ? state : 0; 635 631 636 - if (likely(skb)) 637 - can_change_state(dev, cf, tx_state, rx_state); 638 - else 639 - priv->can.state = state; 632 + /* The skb allocation might fail, but can_change_state() 633 + * handles cf == NULL. 634 + */ 635 + can_change_state(dev, cf, tx_state, rx_state); 640 636 if (state == CAN_STATE_BUS_OFF) 641 637 can_bus_off(dev); 642 638 }

+33 -25

drivers/net/can/usb/ems_usb.c

··· 335 335 struct net_device_stats *stats = &dev->netdev->stats; 336 336 337 337 skb = alloc_can_err_skb(dev->netdev, &cf); 338 - if (skb == NULL) 339 - return; 340 338 341 339 if (msg->type == CPC_MSG_TYPE_CAN_STATE) { 342 340 u8 state = msg->msg.can_state; 343 341 344 342 if (state & SJA1000_SR_BS) { 345 343 dev->can.state = CAN_STATE_BUS_OFF; 346 - cf->can_id |= CAN_ERR_BUSOFF; 344 + if (skb) 345 + cf->can_id |= CAN_ERR_BUSOFF; 347 346 348 347 dev->can.can_stats.bus_off++; 349 348 can_bus_off(dev->netdev); ··· 360 361 361 362 /* bus error interrupt */ 362 363 dev->can.can_stats.bus_error++; 363 - stats->rx_errors++; 364 364 365 - cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 365 + if (skb) { 366 + cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 366 367 367 - switch (ecc & SJA1000_ECC_MASK) { 368 - case SJA1000_ECC_BIT: 369 - cf->data[2] |= CAN_ERR_PROT_BIT; 370 - break; 371 - case SJA1000_ECC_FORM: 372 - cf->data[2] |= CAN_ERR_PROT_FORM; 373 - break; 374 - case SJA1000_ECC_STUFF: 375 - cf->data[2] |= CAN_ERR_PROT_STUFF; 376 - break; 377 - default: 378 - cf->data[3] = ecc & SJA1000_ECC_SEG; 379 - break; 368 + switch (ecc & SJA1000_ECC_MASK) { 369 + case SJA1000_ECC_BIT: 370 + cf->data[2] |= CAN_ERR_PROT_BIT; 371 + break; 372 + case SJA1000_ECC_FORM: 373 + cf->data[2] |= CAN_ERR_PROT_FORM; 374 + break; 375 + case SJA1000_ECC_STUFF: 376 + cf->data[2] |= CAN_ERR_PROT_STUFF; 377 + break; 378 + default: 379 + cf->data[3] = ecc & SJA1000_ECC_SEG; 380 + break; 381 + } 380 382 } 381 383 382 384 /* Error occurred during transmission? */ 383 - if ((ecc & SJA1000_ECC_DIR) == 0) 384 - cf->data[2] |= CAN_ERR_PROT_TX; 385 + if ((ecc & SJA1000_ECC_DIR) == 0) { 386 + stats->tx_errors++; 387 + if (skb) 388 + cf->data[2] |= CAN_ERR_PROT_TX; 389 + } else { 390 + stats->rx_errors++; 391 + } 385 392 386 - if (dev->can.state == CAN_STATE_ERROR_WARNING || 387 - dev->can.state == CAN_STATE_ERROR_PASSIVE) { 393 + if (skb && (dev->can.state == CAN_STATE_ERROR_WARNING || 394 + dev->can.state == CAN_STATE_ERROR_PASSIVE)) { 388 395 cf->can_id |= CAN_ERR_CRTL; 389 396 cf->data[1] = (txerr > rxerr) ? 390 397 CAN_ERR_CRTL_TX_PASSIVE : CAN_ERR_CRTL_RX_PASSIVE; 391 398 } 392 399 } else if (msg->type == CPC_MSG_TYPE_OVERRUN) { 393 - cf->can_id |= CAN_ERR_CRTL; 394 - cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 400 + if (skb) { 401 + cf->can_id |= CAN_ERR_CRTL; 402 + cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 403 + } 395 404 396 405 stats->rx_over_errors++; 397 406 stats->rx_errors++; 398 407 } 399 408 400 - netif_rx(skb); 409 + if (skb) 410 + netif_rx(skb); 401 411 } 402 412 403 413 /*

+7 -3

drivers/net/can/usb/f81604.c

··· 526 526 netdev_dbg(netdev, "bus error interrupt\n"); 527 527 528 528 priv->can.can_stats.bus_error++; 529 - stats->rx_errors++; 530 529 531 530 if (skb) { 532 531 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; ··· 547 548 548 549 /* set error location */ 549 550 cf->data[3] = data->ecc & F81604_SJA1000_ECC_SEG; 551 + } 550 552 551 - /* Error occurred during transmission? */ 552 - if ((data->ecc & F81604_SJA1000_ECC_DIR) == 0) 553 + /* Error occurred during transmission? */ 554 + if ((data->ecc & F81604_SJA1000_ECC_DIR) == 0) { 555 + stats->tx_errors++; 556 + if (skb) 553 557 cf->data[2] |= CAN_ERR_PROT_TX; 558 + } else { 559 + stats->rx_errors++; 554 560 } 555 561 556 562 set_bit(F81604_CLEAR_ECC, &priv->clear_flags);

+18 -7

drivers/net/can/usb/gs_usb.c

··· 43 43 #define USB_XYLANTA_SAINT3_VENDOR_ID 0x16d0 44 44 #define USB_XYLANTA_SAINT3_PRODUCT_ID 0x0f30 45 45 46 - #define GS_USB_ENDPOINT_IN 1 47 - #define GS_USB_ENDPOINT_OUT 2 48 - 49 46 /* Timestamp 32 bit timer runs at 1 MHz (1 µs tick). Worker accounts 50 47 * for timer overflow (will be after ~71 minutes) 51 48 */ ··· 333 336 334 337 unsigned int hf_size_rx; 335 338 u8 active_channels; 339 + 340 + unsigned int pipe_in; 341 + unsigned int pipe_out; 336 342 }; 337 343 338 344 /* 'allocate' a tx context. ··· 687 687 688 688 resubmit_urb: 689 689 usb_fill_bulk_urb(urb, parent->udev, 690 - usb_rcvbulkpipe(parent->udev, GS_USB_ENDPOINT_IN), 690 + parent->pipe_in, 691 691 hf, dev->parent->hf_size_rx, 692 692 gs_usb_receive_bulk_callback, parent); 693 693 ··· 819 819 } 820 820 821 821 usb_fill_bulk_urb(urb, dev->udev, 822 - usb_sndbulkpipe(dev->udev, GS_USB_ENDPOINT_OUT), 822 + dev->parent->pipe_out, 823 823 hf, dev->hf_size_tx, 824 824 gs_usb_xmit_callback, txc); 825 825 ··· 925 925 /* fill, anchor, and submit rx urb */ 926 926 usb_fill_bulk_urb(urb, 927 927 dev->udev, 928 - usb_rcvbulkpipe(dev->udev, 929 - GS_USB_ENDPOINT_IN), 928 + dev->parent->pipe_in, 930 929 buf, 931 930 dev->parent->hf_size_rx, 932 931 gs_usb_receive_bulk_callback, parent); ··· 1412 1413 const struct usb_device_id *id) 1413 1414 { 1414 1415 struct usb_device *udev = interface_to_usbdev(intf); 1416 + struct usb_endpoint_descriptor *ep_in, *ep_out; 1415 1417 struct gs_host_frame *hf; 1416 1418 struct gs_usb *parent; 1417 1419 struct gs_host_config hconf = { ··· 1421 1421 struct gs_device_config dconf; 1422 1422 unsigned int icount, i; 1423 1423 int rc; 1424 + 1425 + rc = usb_find_common_endpoints(intf->cur_altsetting, 1426 + &ep_in, &ep_out, NULL, NULL); 1427 + if (rc) { 1428 + dev_err(&intf->dev, "Required endpoints not found\n"); 1429 + return rc; 1430 + } 1424 1431 1425 1432 /* send host config */ 1426 1433 rc = usb_control_msg_send(udev, 0, ··· 1472 1465 1473 1466 usb_set_intfdata(intf, parent); 1474 1467 parent->udev = udev; 1468 + 1469 + /* store the detected endpoints */ 1470 + parent->pipe_in = usb_rcvbulkpipe(parent->udev, ep_in->bEndpointAddress); 1471 + parent->pipe_out = usb_sndbulkpipe(parent->udev, ep_out->bEndpointAddress); 1475 1472 1476 1473 for (i = 0; i < icount; i++) { 1477 1474 unsigned int hf_size_rx = 0;

+2 -8

drivers/net/can/vxcan.c

··· 172 172 /* forward declaration for rtnl_create_link() */ 173 173 static struct rtnl_link_ops vxcan_link_ops; 174 174 175 - static int vxcan_newlink(struct net *net, struct net_device *dev, 175 + static int vxcan_newlink(struct net *peer_net, struct net_device *dev, 176 176 struct nlattr *tb[], struct nlattr *data[], 177 177 struct netlink_ext_ack *extack) 178 178 { 179 179 struct vxcan_priv *priv; 180 180 struct net_device *peer; 181 - struct net *peer_net; 182 181 183 182 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp = tb; 184 183 char ifname[IFNAMSIZ]; ··· 202 203 name_assign_type = NET_NAME_ENUM; 203 204 } 204 205 205 - peer_net = rtnl_link_get_net(net, tbp); 206 206 peer = rtnl_create_link(peer_net, ifname, name_assign_type, 207 207 &vxcan_link_ops, tbp, extack); 208 - if (IS_ERR(peer)) { 209 - put_net(peer_net); 208 + if (IS_ERR(peer)) 210 209 return PTR_ERR(peer); 211 - } 212 210 213 211 if (ifmp && dev->ifindex) 214 212 peer->ifindex = ifmp->ifi_index; 215 213 216 214 err = register_netdevice(peer); 217 - put_net(peer_net); 218 - peer_net = NULL; 219 215 if (err < 0) { 220 216 free_netdev(peer); 221 217 return err;

+129 -76

drivers/net/ethernet/broadcom/bnxt/bnxt.c

··· 3421 3421 } 3422 3422 } 3423 3423 3424 - static void bnxt_free_one_rx_ring_skbs(struct bnxt *bp, int ring_nr) 3424 + static void bnxt_free_one_tpa_info_data(struct bnxt *bp, 3425 + struct bnxt_rx_ring_info *rxr) 3425 3426 { 3426 - struct bnxt_rx_ring_info *rxr = &bp->rx_ring[ring_nr]; 3427 - struct bnxt_tpa_idx_map *map; 3428 3427 int i; 3429 - 3430 - if (!rxr->rx_tpa) 3431 - goto skip_rx_tpa_free; 3432 3428 3433 3429 for (i = 0; i < bp->max_tpa; i++) { 3434 3430 struct bnxt_tpa_info *tpa_info = &rxr->rx_tpa[i]; ··· 3436 3440 tpa_info->data = NULL; 3437 3441 page_pool_free_va(rxr->head_pool, data, false); 3438 3442 } 3443 + } 3444 + 3445 + static void bnxt_free_one_rx_ring_skbs(struct bnxt *bp, 3446 + struct bnxt_rx_ring_info *rxr) 3447 + { 3448 + struct bnxt_tpa_idx_map *map; 3449 + 3450 + if (!rxr->rx_tpa) 3451 + goto skip_rx_tpa_free; 3452 + 3453 + bnxt_free_one_tpa_info_data(bp, rxr); 3439 3454 3440 3455 skip_rx_tpa_free: 3441 3456 if (!rxr->rx_buf_ring) ··· 3474 3467 return; 3475 3468 3476 3469 for (i = 0; i < bp->rx_nr_rings; i++) 3477 - bnxt_free_one_rx_ring_skbs(bp, i); 3470 + bnxt_free_one_rx_ring_skbs(bp, &bp->rx_ring[i]); 3478 3471 } 3479 3472 3480 3473 static void bnxt_free_skbs(struct bnxt *bp) ··· 3615 3608 return 0; 3616 3609 } 3617 3610 3611 + static void bnxt_free_one_tpa_info(struct bnxt *bp, 3612 + struct bnxt_rx_ring_info *rxr) 3613 + { 3614 + int i; 3615 + 3616 + kfree(rxr->rx_tpa_idx_map); 3617 + rxr->rx_tpa_idx_map = NULL; 3618 + if (rxr->rx_tpa) { 3619 + for (i = 0; i < bp->max_tpa; i++) { 3620 + kfree(rxr->rx_tpa[i].agg_arr); 3621 + rxr->rx_tpa[i].agg_arr = NULL; 3622 + } 3623 + } 3624 + kfree(rxr->rx_tpa); 3625 + rxr->rx_tpa = NULL; 3626 + } 3627 + 3618 3628 static void bnxt_free_tpa_info(struct bnxt *bp) 3619 3629 { 3620 - int i, j; 3630 + int i; 3621 3631 3622 3632 for (i = 0; i < bp->rx_nr_rings; i++) { 3623 3633 struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i]; 3624 3634 3625 - kfree(rxr->rx_tpa_idx_map); 3626 - rxr->rx_tpa_idx_map = NULL; 3627 - if (rxr->rx_tpa) { 3628 - for (j = 0; j < bp->max_tpa; j++) { 3629 - kfree(rxr->rx_tpa[j].agg_arr); 3630 - rxr->rx_tpa[j].agg_arr = NULL; 3631 - } 3632 - } 3633 - kfree(rxr->rx_tpa); 3634 - rxr->rx_tpa = NULL; 3635 + bnxt_free_one_tpa_info(bp, rxr); 3635 3636 } 3637 + } 3638 + 3639 + static int bnxt_alloc_one_tpa_info(struct bnxt *bp, 3640 + struct bnxt_rx_ring_info *rxr) 3641 + { 3642 + struct rx_agg_cmp *agg; 3643 + int i; 3644 + 3645 + rxr->rx_tpa = kcalloc(bp->max_tpa, sizeof(struct bnxt_tpa_info), 3646 + GFP_KERNEL); 3647 + if (!rxr->rx_tpa) 3648 + return -ENOMEM; 3649 + 3650 + if (!(bp->flags & BNXT_FLAG_CHIP_P5_PLUS)) 3651 + return 0; 3652 + for (i = 0; i < bp->max_tpa; i++) { 3653 + agg = kcalloc(MAX_SKB_FRAGS, sizeof(*agg), GFP_KERNEL); 3654 + if (!agg) 3655 + return -ENOMEM; 3656 + rxr->rx_tpa[i].agg_arr = agg; 3657 + } 3658 + rxr->rx_tpa_idx_map = kzalloc(sizeof(*rxr->rx_tpa_idx_map), 3659 + GFP_KERNEL); 3660 + if (!rxr->rx_tpa_idx_map) 3661 + return -ENOMEM; 3662 + 3663 + return 0; 3636 3664 } 3637 3665 3638 3666 static int bnxt_alloc_tpa_info(struct bnxt *bp) 3639 3667 { 3640 - int i, j; 3668 + int i, rc; 3641 3669 3642 3670 bp->max_tpa = MAX_TPA; 3643 3671 if (bp->flags & BNXT_FLAG_CHIP_P5_PLUS) { ··· 3683 3641 3684 3642 for (i = 0; i < bp->rx_nr_rings; i++) { 3685 3643 struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i]; 3686 - struct rx_agg_cmp *agg; 3687 3644 3688 - rxr->rx_tpa = kcalloc(bp->max_tpa, sizeof(struct bnxt_tpa_info), 3689 - GFP_KERNEL); 3690 - if (!rxr->rx_tpa) 3691 - return -ENOMEM; 3692 - 3693 - if (!(bp->flags & BNXT_FLAG_CHIP_P5_PLUS)) 3694 - continue; 3695 - for (j = 0; j < bp->max_tpa; j++) { 3696 - agg = kcalloc(MAX_SKB_FRAGS, sizeof(*agg), GFP_KERNEL); 3697 - if (!agg) 3698 - return -ENOMEM; 3699 - rxr->rx_tpa[j].agg_arr = agg; 3700 - } 3701 - rxr->rx_tpa_idx_map = kzalloc(sizeof(*rxr->rx_tpa_idx_map), 3702 - GFP_KERNEL); 3703 - if (!rxr->rx_tpa_idx_map) 3704 - return -ENOMEM; 3645 + rc = bnxt_alloc_one_tpa_info(bp, rxr); 3646 + if (rc) 3647 + return rc; 3705 3648 } 3706 3649 return 0; 3707 3650 } ··· 3710 3683 xdp_rxq_info_unreg(&rxr->xdp_rxq); 3711 3684 3712 3685 page_pool_destroy(rxr->page_pool); 3713 - if (rxr->page_pool != rxr->head_pool) 3686 + if (bnxt_separate_head_pool()) 3714 3687 page_pool_destroy(rxr->head_pool); 3715 3688 rxr->page_pool = rxr->head_pool = NULL; 3716 3689 ··· 3764 3737 return PTR_ERR(pool); 3765 3738 } 3766 3739 3740 + static int bnxt_alloc_rx_agg_bmap(struct bnxt *bp, struct bnxt_rx_ring_info *rxr) 3741 + { 3742 + u16 mem_size; 3743 + 3744 + rxr->rx_agg_bmap_size = bp->rx_agg_ring_mask + 1; 3745 + mem_size = rxr->rx_agg_bmap_size / 8; 3746 + rxr->rx_agg_bmap = kzalloc(mem_size, GFP_KERNEL); 3747 + if (!rxr->rx_agg_bmap) 3748 + return -ENOMEM; 3749 + 3750 + return 0; 3751 + } 3752 + 3767 3753 static int bnxt_alloc_rx_rings(struct bnxt *bp) 3768 3754 { 3769 3755 int numa_node = dev_to_node(&bp->pdev->dev); ··· 3821 3781 3822 3782 ring->grp_idx = i; 3823 3783 if (agg_rings) { 3824 - u16 mem_size; 3825 - 3826 3784 ring = &rxr->rx_agg_ring_struct; 3827 3785 rc = bnxt_alloc_ring(bp, &ring->ring_mem); 3828 3786 if (rc) 3829 3787 return rc; 3830 3788 3831 3789 ring->grp_idx = i; 3832 - rxr->rx_agg_bmap_size = bp->rx_agg_ring_mask + 1; 3833 - mem_size = rxr->rx_agg_bmap_size / 8; 3834 - rxr->rx_agg_bmap = kzalloc(mem_size, GFP_KERNEL); 3835 - if (!rxr->rx_agg_bmap) 3836 - return -ENOMEM; 3790 + rc = bnxt_alloc_rx_agg_bmap(bp, rxr); 3791 + if (rc) 3792 + return rc; 3837 3793 } 3838 3794 } 3839 3795 if (bp->flags & BNXT_FLAG_TPA) ··· 4304 4268 rxr->rx_agg_prod = prod; 4305 4269 } 4306 4270 4271 + static int bnxt_alloc_one_tpa_info_data(struct bnxt *bp, 4272 + struct bnxt_rx_ring_info *rxr) 4273 + { 4274 + dma_addr_t mapping; 4275 + u8 *data; 4276 + int i; 4277 + 4278 + for (i = 0; i < bp->max_tpa; i++) { 4279 + data = __bnxt_alloc_rx_frag(bp, &mapping, rxr, 4280 + GFP_KERNEL); 4281 + if (!data) 4282 + return -ENOMEM; 4283 + 4284 + rxr->rx_tpa[i].data = data; 4285 + rxr->rx_tpa[i].data_ptr = data + bp->rx_offset; 4286 + rxr->rx_tpa[i].mapping = mapping; 4287 + } 4288 + 4289 + return 0; 4290 + } 4291 + 4307 4292 static int bnxt_alloc_one_rx_ring(struct bnxt *bp, int ring_nr) 4308 4293 { 4309 4294 struct bnxt_rx_ring_info *rxr = &bp->rx_ring[ring_nr]; 4310 - int i; 4295 + int rc; 4311 4296 4312 4297 bnxt_alloc_one_rx_ring_skb(bp, rxr, ring_nr); 4313 4298 ··· 4338 4281 bnxt_alloc_one_rx_ring_page(bp, rxr, ring_nr); 4339 4282 4340 4283 if (rxr->rx_tpa) { 4341 - dma_addr_t mapping; 4342 - u8 *data; 4343 - 4344 - for (i = 0; i < bp->max_tpa; i++) { 4345 - data = __bnxt_alloc_rx_frag(bp, &mapping, rxr, 4346 - GFP_KERNEL); 4347 - if (!data) 4348 - return -ENOMEM; 4349 - 4350 - rxr->rx_tpa[i].data = data; 4351 - rxr->rx_tpa[i].data_ptr = data + bp->rx_offset; 4352 - rxr->rx_tpa[i].mapping = mapping; 4353 - } 4284 + rc = bnxt_alloc_one_tpa_info_data(bp, rxr); 4285 + if (rc) 4286 + return rc; 4354 4287 } 4355 4288 return 0; 4356 4289 } ··· 13710 13663 bnxt_reset_task(bp, true); 13711 13664 break; 13712 13665 } 13713 - bnxt_free_one_rx_ring_skbs(bp, i); 13666 + bnxt_free_one_rx_ring_skbs(bp, rxr); 13714 13667 rxr->rx_prod = 0; 13715 13668 rxr->rx_agg_prod = 0; 13716 13669 rxr->rx_sw_agg_prod = 0; ··· 15340 15293 .get_base_stats = bnxt_get_base_stats, 15341 15294 }; 15342 15295 15343 - static int bnxt_alloc_rx_agg_bmap(struct bnxt *bp, struct bnxt_rx_ring_info *rxr) 15344 - { 15345 - u16 mem_size; 15346 - 15347 - rxr->rx_agg_bmap_size = bp->rx_agg_ring_mask + 1; 15348 - mem_size = rxr->rx_agg_bmap_size / 8; 15349 - rxr->rx_agg_bmap = kzalloc(mem_size, GFP_KERNEL); 15350 - if (!rxr->rx_agg_bmap) 15351 - return -ENOMEM; 15352 - 15353 - return 0; 15354 - } 15355 - 15356 15296 static int bnxt_queue_mem_alloc(struct net_device *dev, void *qmem, int idx) 15357 15297 { 15358 15298 struct bnxt_rx_ring_info *rxr, *clone; ··· 15388 15354 goto err_free_rx_agg_ring; 15389 15355 } 15390 15356 15357 + if (bp->flags & BNXT_FLAG_TPA) { 15358 + rc = bnxt_alloc_one_tpa_info(bp, clone); 15359 + if (rc) 15360 + goto err_free_tpa_info; 15361 + } 15362 + 15391 15363 bnxt_init_one_rx_ring_rxbd(bp, clone); 15392 15364 bnxt_init_one_rx_agg_ring_rxbd(bp, clone); 15393 15365 15394 15366 bnxt_alloc_one_rx_ring_skb(bp, clone, idx); 15395 15367 if (bp->flags & BNXT_FLAG_AGG_RINGS) 15396 15368 bnxt_alloc_one_rx_ring_page(bp, clone, idx); 15369 + if (bp->flags & BNXT_FLAG_TPA) 15370 + bnxt_alloc_one_tpa_info_data(bp, clone); 15397 15371 15398 15372 return 0; 15399 15373 15374 + err_free_tpa_info: 15375 + bnxt_free_one_tpa_info(bp, clone); 15400 15376 err_free_rx_agg_ring: 15401 15377 bnxt_free_ring(bp, &clone->rx_agg_ring_struct.ring_mem); 15402 15378 err_free_rx_ring: ··· 15414 15370 err_rxq_info_unreg: 15415 15371 xdp_rxq_info_unreg(&clone->xdp_rxq); 15416 15372 err_page_pool_destroy: 15417 - clone->page_pool->p.napi = NULL; 15418 15373 page_pool_destroy(clone->page_pool); 15374 + if (bnxt_separate_head_pool()) 15375 + page_pool_destroy(clone->head_pool); 15419 15376 clone->page_pool = NULL; 15377 + clone->head_pool = NULL; 15420 15378 return rc; 15421 15379 } 15422 15380 ··· 15428 15382 struct bnxt *bp = netdev_priv(dev); 15429 15383 struct bnxt_ring_struct *ring; 15430 15384 15431 - bnxt_free_one_rx_ring(bp, rxr); 15432 - bnxt_free_one_rx_agg_ring(bp, rxr); 15385 + bnxt_free_one_rx_ring_skbs(bp, rxr); 15433 15386 15434 15387 xdp_rxq_info_unreg(&rxr->xdp_rxq); 15435 15388 15436 15389 page_pool_destroy(rxr->page_pool); 15390 + if (bnxt_separate_head_pool()) 15391 + page_pool_destroy(rxr->head_pool); 15437 15392 rxr->page_pool = NULL; 15393 + rxr->head_pool = NULL; 15438 15394 15439 15395 ring = &rxr->rx_ring_struct; 15440 15396 bnxt_free_ring(bp, &ring->ring_mem); ··· 15518 15470 rxr->rx_agg_prod = clone->rx_agg_prod; 15519 15471 rxr->rx_sw_agg_prod = clone->rx_sw_agg_prod; 15520 15472 rxr->rx_next_cons = clone->rx_next_cons; 15473 + rxr->rx_tpa = clone->rx_tpa; 15474 + rxr->rx_tpa_idx_map = clone->rx_tpa_idx_map; 15521 15475 rxr->page_pool = clone->page_pool; 15476 + rxr->head_pool = clone->head_pool; 15522 15477 rxr->xdp_rxq = clone->xdp_rxq; 15523 15478 15524 15479 bnxt_copy_rx_ring(bp, rxr, clone); ··· 15580 15529 bnxt_hwrm_rx_agg_ring_free(bp, rxr, false); 15581 15530 rxr->rx_next_cons = 0; 15582 15531 page_pool_disable_direct_recycling(rxr->page_pool); 15532 + if (bnxt_separate_head_pool()) 15533 + page_pool_disable_direct_recycling(rxr->head_pool); 15583 15534 15584 15535 memcpy(qmem, rxr, sizeof(*rxr)); 15585 15536 bnxt_init_rx_ring_struct(bp, qmem);

+6 -2

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

··· 1187 1187 } 1188 1188 } 1189 1189 1190 - if (fltr->base.flags & BNXT_ACT_DROP) 1190 + if (fltr->base.flags & BNXT_ACT_DROP) { 1191 1191 fs->ring_cookie = RX_CLS_FLOW_DISC; 1192 - else 1192 + } else if (fltr->base.flags & BNXT_ACT_RSS_CTX) { 1193 + fs->flow_type |= FLOW_RSS; 1194 + cmd->rss_context = fltr->base.fw_vnic_id; 1195 + } else { 1193 1196 fs->ring_cookie = fltr->base.rxq; 1197 + } 1194 1198 rc = 0; 1195 1199 1196 1200 fltr_err:

+3 -9

drivers/net/ethernet/freescale/enetc/enetc.c

··· 29 29 static void enetc_change_preemptible_tcs(struct enetc_ndev_priv *priv, 30 30 u8 preemptible_tcs) 31 31 { 32 + if (!(priv->si->hw_features & ENETC_SI_F_QBU)) 33 + return; 34 + 32 35 priv->preemptible_tcs = preemptible_tcs; 33 36 enetc_mm_commit_preemptible_tcs(priv); 34 37 } ··· 1759 1756 rss = enetc_rd(hw, ENETC_SIRSSCAPR); 1760 1757 si->num_rss = ENETC_SIRSSCAPR_GET_NUM_RSS(rss); 1761 1758 } 1762 - 1763 - if (val & ENETC_SIPCAPR0_QBV) 1764 - si->hw_features |= ENETC_SI_F_QBV; 1765 - 1766 - if (val & ENETC_SIPCAPR0_QBU) 1767 - si->hw_features |= ENETC_SI_F_QBU; 1768 - 1769 - if (val & ENETC_SIPCAPR0_PSFP) 1770 - si->hw_features |= ENETC_SI_F_PSFP; 1771 1759 } 1772 1760 EXPORT_SYMBOL_GPL(enetc_get_si_caps); 1773 1761

+3 -3

drivers/net/ethernet/freescale/enetc/enetc_hw.h

··· 23 23 #define ENETC_SICTR0 0x18 24 24 #define ENETC_SICTR1 0x1c 25 25 #define ENETC_SIPCAPR0 0x20 26 - #define ENETC_SIPCAPR0_PSFP BIT(9) 27 26 #define ENETC_SIPCAPR0_RSS BIT(8) 28 - #define ENETC_SIPCAPR0_QBV BIT(4) 29 - #define ENETC_SIPCAPR0_QBU BIT(3) 30 27 #define ENETC_SIPCAPR0_RFS BIT(2) 31 28 #define ENETC_SIPCAPR1 0x24 32 29 #define ENETC_SITGTGR 0x30 ··· 191 194 #define ENETC_PCAPR0 0x0900 192 195 #define ENETC_PCAPR0_RXBDR(val) ((val) >> 24) 193 196 #define ENETC_PCAPR0_TXBDR(val) (((val) >> 16) & 0xff) 197 + #define ENETC_PCAPR0_PSFP BIT(9) 198 + #define ENETC_PCAPR0_QBV BIT(4) 199 + #define ENETC_PCAPR0_QBU BIT(3) 194 200 #define ENETC_PCAPR1 0x0904 195 201 #define ENETC_PSICFGR0(n) (0x0940 + (n) * 0xc) /* n = SI index */ 196 202 #define ENETC_PSICFGR0_SET_TXBDR(val) ((val) & 0xff)

+19

drivers/net/ethernet/freescale/enetc/enetc_pf.c

··· 409 409 enetc_port_wr(hw, ENETC_PRFSMR, ENETC_PRFSMR_RFSE); 410 410 } 411 411 412 + static void enetc_port_get_caps(struct enetc_si *si) 413 + { 414 + struct enetc_hw *hw = &si->hw; 415 + u32 val; 416 + 417 + val = enetc_port_rd(hw, ENETC_PCAPR0); 418 + 419 + if (val & ENETC_PCAPR0_QBV) 420 + si->hw_features |= ENETC_SI_F_QBV; 421 + 422 + if (val & ENETC_PCAPR0_QBU) 423 + si->hw_features |= ENETC_SI_F_QBU; 424 + 425 + if (val & ENETC_PCAPR0_PSFP) 426 + si->hw_features |= ENETC_SI_F_PSFP; 427 + } 428 + 412 429 static void enetc_port_si_configure(struct enetc_si *si) 413 430 { 414 431 struct enetc_pf *pf = enetc_si_priv(si); 415 432 struct enetc_hw *hw = &si->hw; 416 433 int num_rings, i; 417 434 u32 val; 435 + 436 + enetc_port_get_caps(si); 418 437 419 438 val = enetc_port_rd(hw, ENETC_PCAPR0); 420 439 num_rings = min(ENETC_PCAPR0_RXBDR(val), ENETC_PCAPR0_TXBDR(val));

+17 -8

drivers/net/ethernet/intel/ice/ice_common.c

··· 542 542 /** 543 543 * ice_find_netlist_node 544 544 * @hw: pointer to the hw struct 545 - * @node_type_ctx: type of netlist node to look for 545 + * @node_type: type of netlist node to look for 546 + * @ctx: context of the search 546 547 * @node_part_number: node part number to look for 547 548 * @node_handle: output parameter if node found - optional 548 549 * ··· 553 552 * valid if the function returns zero, and should be ignored on any non-zero 554 553 * return value. 555 554 * 556 - * Returns: 0 if the node is found, -ENOENT if no handle was found, and 557 - * a negative error code on failure to access the AQ. 555 + * Return: 556 + * * 0 if the node is found, 557 + * * -ENOENT if no handle was found, 558 + * * negative error code on failure to access the AQ. 558 559 */ 559 - static int ice_find_netlist_node(struct ice_hw *hw, u8 node_type_ctx, 560 + static int ice_find_netlist_node(struct ice_hw *hw, u8 node_type, u8 ctx, 560 561 u8 node_part_number, u16 *node_handle) 561 562 { 562 563 u8 idx; ··· 569 566 int status; 570 567 571 568 cmd.addr.topo_params.node_type_ctx = 572 - FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_TYPE_M, 573 - node_type_ctx); 569 + FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_TYPE_M, node_type) | 570 + FIELD_PREP(ICE_AQC_LINK_TOPO_NODE_CTX_M, ctx); 574 571 cmd.addr.topo_params.index = idx; 575 572 576 573 status = ice_aq_get_netlist_node(hw, &cmd, ··· 2750 2747 */ 2751 2748 bool ice_is_phy_rclk_in_netlist(struct ice_hw *hw) 2752 2749 { 2753 - if (ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_CLK_CTRL, 2750 + if (ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_PHY, 2751 + ICE_AQC_LINK_TOPO_NODE_CTX_PORT, 2754 2752 ICE_AQC_GET_LINK_TOPO_NODE_NR_C827, NULL) && 2755 - ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_CLK_CTRL, 2753 + ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_PHY, 2754 + ICE_AQC_LINK_TOPO_NODE_CTX_PORT, 2756 2755 ICE_AQC_GET_LINK_TOPO_NODE_NR_E822_PHY, NULL)) 2757 2756 return false; 2758 2757 ··· 2770 2765 bool ice_is_clock_mux_in_netlist(struct ice_hw *hw) 2771 2766 { 2772 2767 if (ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_CLK_MUX, 2768 + ICE_AQC_LINK_TOPO_NODE_CTX_GLOBAL, 2773 2769 ICE_AQC_GET_LINK_TOPO_NODE_NR_GEN_CLK_MUX, 2774 2770 NULL)) 2775 2771 return false; ··· 2791 2785 bool ice_is_cgu_in_netlist(struct ice_hw *hw) 2792 2786 { 2793 2787 if (!ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_CLK_CTRL, 2788 + ICE_AQC_LINK_TOPO_NODE_CTX_GLOBAL, 2794 2789 ICE_AQC_GET_LINK_TOPO_NODE_NR_ZL30632_80032, 2795 2790 NULL)) { 2796 2791 hw->cgu_part_number = ICE_AQC_GET_LINK_TOPO_NODE_NR_ZL30632_80032; 2797 2792 return true; 2798 2793 } else if (!ice_find_netlist_node(hw, 2799 2794 ICE_AQC_LINK_TOPO_NODE_TYPE_CLK_CTRL, 2795 + ICE_AQC_LINK_TOPO_NODE_CTX_GLOBAL, 2800 2796 ICE_AQC_GET_LINK_TOPO_NODE_NR_SI5383_5384, 2801 2797 NULL)) { 2802 2798 hw->cgu_part_number = ICE_AQC_GET_LINK_TOPO_NODE_NR_SI5383_5384; ··· 2817 2809 bool ice_is_gps_in_netlist(struct ice_hw *hw) 2818 2810 { 2819 2811 if (ice_find_netlist_node(hw, ICE_AQC_LINK_TOPO_NODE_TYPE_GPS, 2812 + ICE_AQC_LINK_TOPO_NODE_CTX_GLOBAL, 2820 2813 ICE_AQC_GET_LINK_TOPO_NODE_NR_GEN_GPS, NULL)) 2821 2814 return false; 2822 2815

+5 -3

drivers/net/ethernet/intel/ice/ice_main.c

··· 6408 6408 int err = 0; 6409 6409 6410 6410 /* support Single VLAN Mode (SVM) and Double VLAN Mode (DVM) by checking 6411 - * if either bit is set 6411 + * if either bit is set. In switchdev mode Rx filtering should never be 6412 + * enabled. 6412 6413 */ 6413 - if (features & 6414 - (NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)) 6414 + if ((features & 6415 + (NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)) && 6416 + !ice_is_eswitch_mode_switchdev(vsi->back)) 6415 6417 err = vlan_ops->ena_rx_filtering(vsi); 6416 6418 else 6417 6419 err = vlan_ops->dis_rx_filtering(vsi);

+2 -1

drivers/net/ethernet/intel/ice/ice_ptp_hw.c

··· 1518 1518 * lower 8 bits in the low register, and the upper 32 bits in the high 1519 1519 * register. 1520 1520 */ 1521 - *tstamp = ((u64)hi) << TS_PHY_HIGH_S | ((u64)lo & TS_PHY_LOW_M); 1521 + *tstamp = FIELD_PREP(TS_PHY_HIGH_M, hi) | 1522 + FIELD_PREP(TS_PHY_LOW_M, lo); 1522 1523 1523 1524 return 0; 1524 1525 }

+2 -3

drivers/net/ethernet/intel/ice/ice_ptp_hw.h

··· 682 682 #define TS_HIGH_M 0xFF 683 683 #define TS_HIGH_S 32 684 684 685 - #define TS_PHY_LOW_M 0xFF 686 - #define TS_PHY_HIGH_M 0xFFFFFFFF 687 - #define TS_PHY_HIGH_S 8 685 + #define TS_PHY_LOW_M GENMASK(7, 0) 686 + #define TS_PHY_HIGH_M GENMASK_ULL(39, 8) 688 687 689 688 #define BYTES_PER_IDX_ADDR_L_U 8 690 689 #define BYTES_PER_IDX_ADDR_L 4

+6

drivers/net/ethernet/intel/ice/ice_virtchnl.c

··· 4128 4128 .get_qos_caps = ice_vc_get_qos_caps, 4129 4129 .cfg_q_bw = ice_vc_cfg_q_bw, 4130 4130 .cfg_q_quanta = ice_vc_cfg_q_quanta, 4131 + /* If you add a new op here please make sure to add it to 4132 + * ice_virtchnl_repr_ops as well. 4133 + */ 4131 4134 }; 4132 4135 4133 4136 /** ··· 4261 4258 .dis_vlan_stripping_v2_msg = ice_vc_dis_vlan_stripping_v2_msg, 4262 4259 .ena_vlan_insertion_v2_msg = ice_vc_ena_vlan_insertion_v2_msg, 4263 4260 .dis_vlan_insertion_v2_msg = ice_vc_dis_vlan_insertion_v2_msg, 4261 + .get_qos_caps = ice_vc_get_qos_caps, 4262 + .cfg_q_bw = ice_vc_cfg_q_bw, 4263 + .cfg_q_quanta = ice_vc_cfg_q_quanta, 4264 4264 }; 4265 4265 4266 4266 /**

+1

drivers/net/ethernet/intel/idpf/idpf_txrx.c

··· 2448 2448 * rest of the packet. 2449 2449 */ 2450 2450 tx_buf->type = LIBETH_SQE_EMPTY; 2451 + idpf_tx_buf_compl_tag(tx_buf) = params->compl_tag; 2451 2452 2452 2453 /* Adjust the DMA offset and the remaining size of the 2453 2454 * fragment. On the first iteration of this loop,

+4

drivers/net/ethernet/intel/igb/igb_main.c

··· 637 637 dca_register_notify(&dca_notifier); 638 638 #endif 639 639 ret = pci_register_driver(&igb_driver); 640 + #ifdef CONFIG_IGB_DCA 641 + if (ret) 642 + dca_unregister_notify(&dca_notifier); 643 + #endif 640 644 return ret; 641 645 } 642 646

+2

drivers/net/ethernet/intel/ixgbe/ixgbe_common.h

··· 194 194 dev_err(&adapter->pdev->dev, format, ## arg) 195 195 #define e_dev_notice(format, arg...) \ 196 196 dev_notice(&adapter->pdev->dev, format, ## arg) 197 + #define e_dbg(msglvl, format, arg...) \ 198 + netif_dbg(adapter, msglvl, adapter->netdev, format, ## arg) 197 199 #define e_info(msglvl, format, arg...) \ 198 200 netif_info(adapter, msglvl, adapter->netdev, format, ## arg) 199 201 #define e_err(msglvl, format, arg...) \

+1 -1

drivers/net/ethernet/intel/ixgbe/ixgbe_phy.h

··· 40 40 #define IXGBE_SFF_1GBASESX_CAPABLE 0x1 41 41 #define IXGBE_SFF_1GBASELX_CAPABLE 0x2 42 42 #define IXGBE_SFF_1GBASET_CAPABLE 0x8 43 - #define IXGBE_SFF_BASEBX10_CAPABLE 0x64 43 + #define IXGBE_SFF_BASEBX10_CAPABLE 0x40 44 44 #define IXGBE_SFF_10GBASESR_CAPABLE 0x10 45 45 #define IXGBE_SFF_10GBASELR_CAPABLE 0x20 46 46 #define IXGBE_SFF_SOFT_RS_SELECT_MASK 0x8

+1 -1

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

··· 1048 1048 break; 1049 1049 } 1050 1050 1051 - e_info(drv, "VF %d requested invalid api version %u\n", vf, api); 1051 + e_dbg(drv, "VF %d requested unsupported api version %u\n", vf, api); 1052 1052 1053 1053 return -1; 1054 1054 }

-1

drivers/net/ethernet/intel/ixgbevf/ipsec.c

··· 629 629 630 630 switch (adapter->hw.api_version) { 631 631 case ixgbe_mbox_api_14: 632 - case ixgbe_mbox_api_15: 633 632 break; 634 633 default: 635 634 return;

+1

drivers/net/ethernet/marvell/octeontx2/af/common.h

··· 159 159 #define SDP_HW_MIN_FRS 16 160 160 #define CN10K_LMAC_LINK_MAX_FRS 16380 /* 16k - FCS */ 161 161 #define CN10K_LBK_LINK_MAX_FRS 65535 /* 64k */ 162 + #define SDP_LINK_CREDIT 0x320202 162 163 163 164 /* NIX RX action operation*/ 164 165 #define NIX_RX_ACTIONOP_DROP (0x0ull)

+3

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

··· 4672 4672 rvu_get_lbk_link_max_frs(rvu, &lbk_max_frs); 4673 4673 rvu_get_lmac_link_max_frs(rvu, &lmac_max_frs); 4674 4674 4675 + /* Set SDP link credit */ 4676 + rvu_write64(rvu, blkaddr, NIX_AF_SDP_LINK_CREDIT, SDP_LINK_CREDIT); 4677 + 4675 4678 /* Set default min/max packet lengths allowed on NIX Rx links. 4676 4679 * 4677 4680 * With HW reset minlen value of 60byte, HW will treat ARP pkts

+11 -2

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_encap.c

··· 5 5 #include <net/nexthop.h> 6 6 #include <net/ip_tunnels.h> 7 7 #include "tc_tun_encap.h" 8 + #include "fs_core.h" 8 9 #include "en_tc.h" 9 10 #include "tc_tun.h" 10 11 #include "rep/tc.h" ··· 25 24 26 25 route_dev = dev_get_by_index(dev_net(e->out_dev), e->route_dev_ifindex); 27 26 28 - if (!route_dev || !netif_is_ovs_master(route_dev) || 29 - attr->parse_attr->filter_dev == e->out_dev) 27 + if (!route_dev || !netif_is_ovs_master(route_dev)) 30 28 goto out; 29 + 30 + if (priv->mdev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_DMFS && 31 + mlx5e_eswitch_uplink_rep(attr->parse_attr->filter_dev) && 32 + (attr->esw_attr->dests[out_index].flags & MLX5_ESW_DEST_ENCAP)) { 33 + mlx5_core_warn(priv->mdev, 34 + "Matching on external port with encap + fwd to table actions is not allowed for firmware steering\n"); 35 + err = -EINVAL; 36 + goto out; 37 + } 31 38 32 39 err = mlx5e_set_fwd_to_int_port_actions(priv, attr, e->route_dev_ifindex, 33 40 MLX5E_TC_INT_PORT_EGRESS,

+17 -15

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

··· 2680 2680 2681 2681 static int mlx5e_open_channel(struct mlx5e_priv *priv, int ix, 2682 2682 struct mlx5e_params *params, 2683 - struct mlx5e_channel_param *cparam, 2684 2683 struct xsk_buff_pool *xsk_pool, 2685 2684 struct mlx5e_channel **cp) 2686 2685 { 2687 2686 struct net_device *netdev = priv->netdev; 2687 + struct mlx5e_channel_param *cparam; 2688 2688 struct mlx5_core_dev *mdev; 2689 2689 struct mlx5e_xsk_param xsk; 2690 2690 struct mlx5e_channel *c; ··· 2706 2706 return err; 2707 2707 2708 2708 c = kvzalloc_node(sizeof(*c), GFP_KERNEL, cpu_to_node(cpu)); 2709 - if (!c) 2710 - return -ENOMEM; 2709 + cparam = kvzalloc(sizeof(*cparam), GFP_KERNEL); 2710 + if (!c || !cparam) { 2711 + err = -ENOMEM; 2712 + goto err_free; 2713 + } 2714 + 2715 + err = mlx5e_build_channel_param(mdev, params, cparam); 2716 + if (err) 2717 + goto err_free; 2711 2718 2712 2719 c->priv = priv; 2713 2720 c->mdev = mdev; ··· 2748 2741 2749 2742 *cp = c; 2750 2743 2744 + kvfree(cparam); 2751 2745 return 0; 2752 2746 2753 2747 err_close_queues: ··· 2757 2749 err_napi_del: 2758 2750 netif_napi_del(&c->napi); 2759 2751 2752 + err_free: 2753 + kvfree(cparam); 2760 2754 kvfree(c); 2761 2755 2762 2756 return err; ··· 2817 2807 int mlx5e_open_channels(struct mlx5e_priv *priv, 2818 2808 struct mlx5e_channels *chs) 2819 2809 { 2820 - struct mlx5e_channel_param *cparam; 2821 2810 int err = -ENOMEM; 2822 2811 int i; 2823 2812 2824 2813 chs->num = chs->params.num_channels; 2825 2814 2826 2815 chs->c = kcalloc(chs->num, sizeof(struct mlx5e_channel *), GFP_KERNEL); 2827 - cparam = kvzalloc(sizeof(struct mlx5e_channel_param), GFP_KERNEL); 2828 - if (!chs->c || !cparam) 2829 - goto err_free; 2830 - 2831 - err = mlx5e_build_channel_param(priv->mdev, &chs->params, cparam); 2832 - if (err) 2833 - goto err_free; 2816 + if (!chs->c) 2817 + goto err_out; 2834 2818 2835 2819 for (i = 0; i < chs->num; i++) { 2836 2820 struct xsk_buff_pool *xsk_pool = NULL; ··· 2832 2828 if (chs->params.xdp_prog) 2833 2829 xsk_pool = mlx5e_xsk_get_pool(&chs->params, chs->params.xsk, i); 2834 2830 2835 - err = mlx5e_open_channel(priv, i, &chs->params, cparam, xsk_pool, &chs->c[i]); 2831 + err = mlx5e_open_channel(priv, i, &chs->params, xsk_pool, &chs->c[i]); 2836 2832 if (err) 2837 2833 goto err_close_channels; 2838 2834 } ··· 2850 2846 } 2851 2847 2852 2848 mlx5e_health_channels_update(priv); 2853 - kvfree(cparam); 2854 2849 return 0; 2855 2850 2856 2851 err_close_ptp: ··· 2860 2857 for (i--; i >= 0; i--) 2861 2858 mlx5e_close_channel(chs->c[i]); 2862 2859 2863 - err_free: 2864 2860 kfree(chs->c); 2865 - kvfree(cparam); 2861 + err_out: 2866 2862 chs->num = 0; 2867 2863 return err; 2868 2864 }

+3 -2

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c

··· 2335 2335 static void esw_mode_change(struct mlx5_eswitch *esw, u16 mode) 2336 2336 { 2337 2337 mlx5_devcom_comp_lock(esw->dev->priv.hca_devcom_comp); 2338 - 2339 - if (esw->dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_IB_ADEV) { 2338 + if (esw->dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_IB_ADEV || 2339 + mlx5_core_mp_enabled(esw->dev)) { 2340 2340 esw->mode = mode; 2341 + mlx5_rescan_drivers_locked(esw->dev); 2341 2342 mlx5_devcom_comp_unlock(esw->dev->priv.hca_devcom_comp); 2342 2343 return; 2343 2344 }

+2

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/bwc_complex.c

··· 39 39 } else { 40 40 mlx5hws_err(ctx, "Failed to calculate matcher definer layout\n"); 41 41 } 42 + } else { 43 + kfree(mt->fc); 42 44 } 43 45 44 46 mlx5hws_match_template_destroy(mt);

+1

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/send.c

··· 990 990 for (i = 0; i < bwc_queues; i++) { 991 991 mutex_init(&ctx->bwc_send_queue_locks[i]); 992 992 lockdep_register_key(ctx->bwc_lock_class_keys + i); 993 + lockdep_set_class(ctx->bwc_send_queue_locks + i, ctx->bwc_lock_class_keys + i); 993 994 } 994 995 995 996 return 0;

+5 -1

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_flex_keys.c

··· 324 324 MLXSW_AFK_ELEMENT_INST_EXT_U32(SRC_SYS_PORT, 0x04, 0, 9, -1, true), /* RX_ACL_SYSTEM_PORT */ 325 325 }; 326 326 327 + static const struct mlxsw_afk_element_inst mlxsw_sp_afk_element_info_ipv4_1b[] = { 328 + MLXSW_AFK_ELEMENT_INST_BUF(SRC_IP_0_31, 0x04, 4), 329 + }; 330 + 327 331 static const struct mlxsw_afk_element_inst mlxsw_sp_afk_element_info_ipv4_5b[] = { 328 332 MLXSW_AFK_ELEMENT_INST_U32(VIRT_ROUTER, 0x04, 20, 12), 329 333 }; ··· 345 341 MLXSW_AFK_BLOCK(0x14, mlxsw_sp_afk_element_info_mac_4), 346 342 MLXSW_AFK_BLOCK_HIGH_ENTROPY(0x1A, mlxsw_sp_afk_element_info_mac_5b), 347 343 MLXSW_AFK_BLOCK_HIGH_ENTROPY(0x38, mlxsw_sp_afk_element_info_ipv4_0), 348 - MLXSW_AFK_BLOCK_HIGH_ENTROPY(0x39, mlxsw_sp_afk_element_info_ipv4_1), 344 + MLXSW_AFK_BLOCK_HIGH_ENTROPY(0x3F, mlxsw_sp_afk_element_info_ipv4_1b), 349 345 MLXSW_AFK_BLOCK(0x3A, mlxsw_sp_afk_element_info_ipv4_2), 350 346 MLXSW_AFK_BLOCK(0x36, mlxsw_sp_afk_element_info_ipv4_5b), 351 347 MLXSW_AFK_BLOCK(0x40, mlxsw_sp_afk_element_info_ipv6_0),

+1

drivers/net/ethernet/microsoft/mana/mana_en.c

··· 2536 2536 2537 2537 mana_gd_init_req_hdr(&req.hdr, MANA_QUERY_GF_STAT, 2538 2538 sizeof(req), sizeof(resp)); 2539 + req.hdr.resp.msg_version = GDMA_MESSAGE_V2; 2539 2540 req.req_stats = STATISTICS_FLAGS_RX_DISCARDS_NO_WQE | 2540 2541 STATISTICS_FLAGS_RX_ERRORS_VPORT_DISABLED | 2541 2542 STATISTICS_FLAGS_HC_RX_BYTES |

+3 -1

drivers/net/ethernet/qlogic/qed/qed_mcp.c

··· 3301 3301 if (rc) 3302 3302 return rc; 3303 3303 3304 - if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK)) 3304 + if (((rsp & FW_MSG_CODE_MASK) == FW_MSG_CODE_UNSUPPORTED)) 3305 + rc = -EOPNOTSUPP; 3306 + else if (((rsp & FW_MSG_CODE_MASK) != FW_MSG_CODE_OK)) 3305 3307 rc = -EINVAL; 3306 3308 3307 3309 return rc;

+1 -1

drivers/net/geneve.c

··· 895 895 if (geneve->cfg.df == GENEVE_DF_SET) { 896 896 df = htons(IP_DF); 897 897 } else if (geneve->cfg.df == GENEVE_DF_INHERIT) { 898 - struct ethhdr *eth = eth_hdr(skb); 898 + struct ethhdr *eth = skb_eth_hdr(skb); 899 899 900 900 if (ntohs(eth->h_proto) == ETH_P_IPV6) { 901 901 df = htons(IP_DF);

+3 -8

drivers/net/netkit.c

··· 327 327 328 328 static struct rtnl_link_ops netkit_link_ops; 329 329 330 - static int netkit_new_link(struct net *src_net, struct net_device *dev, 330 + static int netkit_new_link(struct net *peer_net, struct net_device *dev, 331 331 struct nlattr *tb[], struct nlattr *data[], 332 332 struct netlink_ext_ack *extack) 333 333 { ··· 342 342 struct net_device *peer; 343 343 char ifname[IFNAMSIZ]; 344 344 struct netkit *nk; 345 - struct net *net; 346 345 int err; 347 346 348 347 if (data) { ··· 384 385 (tb[IFLA_ADDRESS] || tbp[IFLA_ADDRESS])) 385 386 return -EOPNOTSUPP; 386 387 387 - net = rtnl_link_get_net(src_net, tbp); 388 - peer = rtnl_create_link(net, ifname, ifname_assign_type, 388 + peer = rtnl_create_link(peer_net, ifname, ifname_assign_type, 389 389 &netkit_link_ops, tbp, extack); 390 - if (IS_ERR(peer)) { 391 - put_net(net); 390 + if (IS_ERR(peer)) 392 391 return PTR_ERR(peer); 393 - } 394 392 395 393 netif_inherit_tso_max(peer, dev); 396 394 ··· 404 408 bpf_mprog_bundle_init(&nk->bundle); 405 409 406 410 err = register_netdevice(peer); 407 - put_net(net); 408 411 if (err < 0) 409 412 goto err_register_peer; 410 413 netif_carrier_off(peer);

+21

drivers/net/phy/microchip.c

··· 351 351 static void lan88xx_link_change_notify(struct phy_device *phydev) 352 352 { 353 353 int temp; 354 + int ret; 355 + 356 + /* Reset PHY to ensure MII_LPA provides up-to-date information. This 357 + * issue is reproducible only after parallel detection, as described 358 + * in IEEE 802.3-2022, Section 28.2.3.1 ("Parallel detection function"), 359 + * where the link partner does not support auto-negotiation. 360 + */ 361 + if (phydev->state == PHY_NOLINK) { 362 + ret = phy_init_hw(phydev); 363 + if (ret < 0) 364 + goto link_change_notify_failed; 365 + 366 + ret = _phy_start_aneg(phydev); 367 + if (ret < 0) 368 + goto link_change_notify_failed; 369 + } 354 370 355 371 /* At forced 100 F/H mode, chip may fail to set mode correctly 356 372 * when cable is switched between long(~50+m) and short one. ··· 393 377 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_; 394 378 phy_write(phydev, LAN88XX_INT_MASK, temp); 395 379 } 380 + 381 + return; 382 + 383 + link_change_notify_failed: 384 + phydev_err(phydev, "Link change process failed %pe\n", ERR_PTR(ret)); 396 385 } 397 386 398 387 /**

+3 -9

drivers/net/veth.c

··· 1765 1765 return 0; 1766 1766 } 1767 1767 1768 - static int veth_newlink(struct net *src_net, struct net_device *dev, 1768 + static int veth_newlink(struct net *peer_net, struct net_device *dev, 1769 1769 struct nlattr *tb[], struct nlattr *data[], 1770 1770 struct netlink_ext_ack *extack) 1771 1771 { ··· 1776 1776 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp; 1777 1777 unsigned char name_assign_type; 1778 1778 struct ifinfomsg *ifmp; 1779 - struct net *net; 1780 1779 1781 1780 /* 1782 1781 * create and register peer first ··· 1799 1800 name_assign_type = NET_NAME_ENUM; 1800 1801 } 1801 1802 1802 - net = rtnl_link_get_net(src_net, tbp); 1803 - peer = rtnl_create_link(net, ifname, name_assign_type, 1803 + peer = rtnl_create_link(peer_net, ifname, name_assign_type, 1804 1804 &veth_link_ops, tbp, extack); 1805 - if (IS_ERR(peer)) { 1806 - put_net(net); 1805 + if (IS_ERR(peer)) 1807 1806 return PTR_ERR(peer); 1808 - } 1809 1807 1810 1808 if (!ifmp || !tbp[IFLA_ADDRESS]) 1811 1809 eth_hw_addr_random(peer); ··· 1813 1817 netif_inherit_tso_max(peer, dev); 1814 1818 1815 1819 err = register_netdevice(peer); 1816 - put_net(net); 1817 - net = NULL; 1818 1820 if (err < 0) 1819 1821 goto err_register_peer; 1820 1822

+2 -1

drivers/ptp/ptp_clock.c

··· 150 150 if (ppb > ops->max_adj || ppb < -ops->max_adj) 151 151 return -ERANGE; 152 152 err = ops->adjfine(ops, tx->freq); 153 - ptp->dialed_frequency = tx->freq; 153 + if (!err) 154 + ptp->dialed_frequency = tx->freq; 154 155 } else if (tx->modes & ADJ_OFFSET) { 155 156 if (ops->adjphase) { 156 157 s32 max_phase_adj = ops->getmaxphase(ops);

+2

include/net/inet_timewait_sock.h

··· 45 45 #define tw_node __tw_common.skc_nulls_node 46 46 #define tw_bind_node __tw_common.skc_bind_node 47 47 #define tw_refcnt __tw_common.skc_refcnt 48 + #define tw_tx_queue_mapping __tw_common.skc_tx_queue_mapping 49 + #define tw_rx_queue_mapping __tw_common.skc_rx_queue_mapping 48 50 #define tw_hash __tw_common.skc_hash 49 51 #define tw_prot __tw_common.skc_prot 50 52 #define tw_net __tw_common.skc_net

+5

include/net/net_namespace.h

··· 325 325 #define net_drop_ns NULL 326 326 #endif 327 327 328 + /* Returns true if the netns initialization is completed successfully */ 329 + static inline bool net_initialized(const struct net *net) 330 + { 331 + return READ_ONCE(net->list.next); 332 + } 328 333 329 334 static inline void __netns_tracker_alloc(struct net *net, 330 335 netns_tracker *tracker,

+1

include/net/netfilter/nf_tables_core.h

··· 161 161 }; 162 162 163 163 struct nft_inner_tun_ctx { 164 + unsigned long cookie; 164 165 u16 type; 165 166 u16 inner_tunoff; 166 167 u16 inner_lloff;

+1 -1

net/can/j1939/transport.c

··· 1505 1505 session->state = J1939_SESSION_NEW; 1506 1506 1507 1507 skb_queue_head_init(&session->skb_queue); 1508 - skb_queue_tail(&session->skb_queue, skb); 1508 + skb_queue_tail(&session->skb_queue, skb_get(skb)); 1509 1509 1510 1510 skcb = j1939_skb_to_cb(skb); 1511 1511 memcpy(&session->skcb, skcb, sizeof(session->skcb));

+12 -6

net/core/dev.c

··· 6557 6557 static void napi_hash_add_with_id(struct napi_struct *napi, 6558 6558 unsigned int napi_id) 6559 6559 { 6560 - spin_lock(&napi_hash_lock); 6560 + unsigned long flags; 6561 + 6562 + spin_lock_irqsave(&napi_hash_lock, flags); 6561 6563 WARN_ON_ONCE(napi_by_id(napi_id)); 6562 6564 __napi_hash_add_with_id(napi, napi_id); 6563 - spin_unlock(&napi_hash_lock); 6565 + spin_unlock_irqrestore(&napi_hash_lock, flags); 6564 6566 } 6565 6567 6566 6568 static void napi_hash_add(struct napi_struct *napi) 6567 6569 { 6570 + unsigned long flags; 6571 + 6568 6572 if (test_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state)) 6569 6573 return; 6570 6574 6571 - spin_lock(&napi_hash_lock); 6575 + spin_lock_irqsave(&napi_hash_lock, flags); 6572 6576 6573 6577 /* 0..NR_CPUS range is reserved for sender_cpu use */ 6574 6578 do { ··· 6582 6578 6583 6579 __napi_hash_add_with_id(napi, napi_gen_id); 6584 6580 6585 - spin_unlock(&napi_hash_lock); 6581 + spin_unlock_irqrestore(&napi_hash_lock, flags); 6586 6582 } 6587 6583 6588 6584 /* Warning : caller is responsible to make sure rcu grace period ··· 6590 6586 */ 6591 6587 static void napi_hash_del(struct napi_struct *napi) 6592 6588 { 6593 - spin_lock(&napi_hash_lock); 6589 + unsigned long flags; 6590 + 6591 + spin_lock_irqsave(&napi_hash_lock, flags); 6594 6592 6595 6593 hlist_del_init_rcu(&napi->napi_hash_node); 6596 6594 6597 - spin_unlock(&napi_hash_lock); 6595 + spin_unlock_irqrestore(&napi_hash_lock, flags); 6598 6596 } 6599 6597 6600 6598 static enum hrtimer_restart napi_watchdog(struct hrtimer *timer)

+6 -1

net/core/link_watch.c

··· 45 45 int iflink = dev_get_iflink(dev); 46 46 struct net_device *peer; 47 47 48 - if (iflink == dev->ifindex) 48 + /* If called from netdev_run_todo()/linkwatch_sync_dev(), 49 + * dev_net(dev) can be already freed, and RTNL is not held. 50 + */ 51 + if (dev->reg_state == NETREG_UNREGISTERED || 52 + iflink == dev->ifindex) 49 53 return IF_OPER_DOWN; 50 54 55 + ASSERT_RTNL(); 51 56 peer = __dev_get_by_index(dev_net(dev), iflink); 52 57 if (!peer) 53 58 return IF_OPER_DOWN;

+23 -21

net/core/rtnetlink.c

··· 3746 3746 static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm, 3747 3747 const struct rtnl_link_ops *ops, 3748 3748 struct net *tgt_net, struct net *link_net, 3749 + struct net *peer_net, 3749 3750 const struct nlmsghdr *nlh, 3750 3751 struct nlattr **tb, struct nlattr **data, 3751 3752 struct netlink_ext_ack *extack) ··· 3777 3776 3778 3777 dev->ifindex = ifm->ifi_index; 3779 3778 3779 + if (link_net) 3780 + net = link_net; 3781 + if (peer_net) 3782 + net = peer_net; 3783 + 3780 3784 if (ops->newlink) 3781 - err = ops->newlink(link_net ? : net, dev, tb, data, extack); 3785 + err = ops->newlink(net, dev, tb, data, extack); 3782 3786 else 3783 3787 err = register_netdevice(dev); 3784 3788 if (err < 0) { ··· 3818 3812 goto out; 3819 3813 } 3820 3814 3821 - static int rtnl_add_peer_net(struct rtnl_nets *rtnl_nets, 3822 - const struct rtnl_link_ops *ops, 3823 - struct nlattr *data[], 3824 - struct netlink_ext_ack *extack) 3815 + static struct net *rtnl_get_peer_net(const struct rtnl_link_ops *ops, 3816 + struct nlattr *data[], 3817 + struct netlink_ext_ack *extack) 3825 3818 { 3826 3819 struct nlattr *tb[IFLA_MAX + 1]; 3827 - struct net *net; 3828 3820 int err; 3829 3821 3830 3822 if (!data || !data[ops->peer_type]) 3831 - return 0; 3823 + return NULL; 3832 3824 3833 3825 err = rtnl_nla_parse_ifinfomsg(tb, data[ops->peer_type], extack); 3834 3826 if (err < 0) 3835 - return err; 3827 + return ERR_PTR(err); 3836 3828 3837 3829 if (ops->validate) { 3838 3830 err = ops->validate(tb, NULL, extack); 3839 3831 if (err < 0) 3840 - return err; 3832 + return ERR_PTR(err); 3841 3833 } 3842 3834 3843 - net = rtnl_link_get_net_ifla(tb); 3844 - if (IS_ERR(net)) 3845 - return PTR_ERR(net); 3846 - if (net) 3847 - rtnl_nets_add(rtnl_nets, net); 3848 - 3849 - return 0; 3835 + return rtnl_link_get_net_ifla(tb); 3850 3836 } 3851 3837 3852 3838 static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3853 3839 const struct rtnl_link_ops *ops, 3854 3840 struct net *tgt_net, struct net *link_net, 3841 + struct net *peer_net, 3855 3842 struct rtnl_newlink_tbs *tbs, 3856 3843 struct nlattr **data, 3857 3844 struct netlink_ext_ack *extack) ··· 3893 3894 return -EOPNOTSUPP; 3894 3895 } 3895 3896 3896 - return rtnl_newlink_create(skb, ifm, ops, tgt_net, link_net, nlh, tb, data, extack); 3897 + return rtnl_newlink_create(skb, ifm, ops, tgt_net, link_net, peer_net, nlh, 3898 + tb, data, extack); 3897 3899 } 3898 3900 3899 3901 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3900 3902 struct netlink_ext_ack *extack) 3901 3903 { 3904 + struct net *tgt_net, *link_net = NULL, *peer_net = NULL; 3902 3905 struct nlattr **tb, **linkinfo, **data = NULL; 3903 - struct net *tgt_net, *link_net = NULL; 3904 3906 struct rtnl_link_ops *ops = NULL; 3905 3907 struct rtnl_newlink_tbs *tbs; 3906 3908 struct rtnl_nets rtnl_nets; ··· 3971 3971 } 3972 3972 3973 3973 if (ops->peer_type) { 3974 - ret = rtnl_add_peer_net(&rtnl_nets, ops, data, extack); 3975 - if (ret < 0) 3974 + peer_net = rtnl_get_peer_net(ops, data, extack); 3975 + if (IS_ERR(peer_net)) 3976 3976 goto put_ops; 3977 + if (peer_net) 3978 + rtnl_nets_add(&rtnl_nets, peer_net); 3977 3979 } 3978 3980 } 3979 3981 ··· 4006 4004 } 4007 4005 4008 4006 rtnl_nets_lock(&rtnl_nets); 4009 - ret = __rtnl_newlink(skb, nlh, ops, tgt_net, link_net, tbs, data, extack); 4007 + ret = __rtnl_newlink(skb, nlh, ops, tgt_net, link_net, peer_net, tbs, data, extack); 4010 4008 rtnl_nets_unlock(&rtnl_nets); 4011 4009 4012 4010 put_net:

+5 -1

net/dccp/feat.c

··· 1166 1166 goto not_valid_or_not_known; 1167 1167 } 1168 1168 1169 - return dccp_feat_push_confirm(fn, feat, local, &fval); 1169 + if (dccp_feat_push_confirm(fn, feat, local, &fval)) { 1170 + kfree(fval.sp.vec); 1171 + return DCCP_RESET_CODE_TOO_BUSY; 1172 + } 1170 1173 1174 + return 0; 1171 1175 } else if (entry->state == FEAT_UNSTABLE) { /* 6.6.2 */ 1172 1176 return 0; 1173 1177 }

+44 -4

net/ethtool/bitset.c

··· 425 425 return 0; 426 426 } 427 427 428 + /** 429 + * ethnl_bitmap32_equal() - Compare two bitmaps 430 + * @map1: first bitmap 431 + * @map2: second bitmap 432 + * @nbits: bit size to compare 433 + * 434 + * Return: true if first @nbits are equal, false if not 435 + */ 436 + static bool ethnl_bitmap32_equal(const u32 *map1, const u32 *map2, 437 + unsigned int nbits) 438 + { 439 + if (memcmp(map1, map2, nbits / 32 * sizeof(u32))) 440 + return false; 441 + if (nbits % 32 == 0) 442 + return true; 443 + return !((map1[nbits / 32] ^ map2[nbits / 32]) & 444 + ethnl_lower_bits(nbits % 32)); 445 + } 446 + 428 447 static int 429 448 ethnl_update_bitset32_verbose(u32 *bitmap, unsigned int nbits, 430 449 const struct nlattr *attr, struct nlattr **tb, 431 450 ethnl_string_array_t names, 432 451 struct netlink_ext_ack *extack, bool *mod) 433 452 { 453 + u32 *saved_bitmap = NULL; 434 454 struct nlattr *bit_attr; 435 455 bool no_mask; 436 456 int rem; ··· 468 448 } 469 449 470 450 no_mask = tb[ETHTOOL_A_BITSET_NOMASK]; 471 - if (no_mask) 472 - ethnl_bitmap32_clear(bitmap, 0, nbits, mod); 451 + if (no_mask) { 452 + unsigned int nwords = DIV_ROUND_UP(nbits, 32); 453 + unsigned int nbytes = nwords * sizeof(u32); 454 + bool dummy; 455 + 456 + /* The bitmap size is only the size of the map part without 457 + * its mask part. 458 + */ 459 + saved_bitmap = kcalloc(nwords, sizeof(u32), GFP_KERNEL); 460 + if (!saved_bitmap) 461 + return -ENOMEM; 462 + memcpy(saved_bitmap, bitmap, nbytes); 463 + ethnl_bitmap32_clear(bitmap, 0, nbits, &dummy); 464 + } 473 465 474 466 nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) { 475 467 bool old_val, new_val; ··· 490 458 if (nla_type(bit_attr) != ETHTOOL_A_BITSET_BITS_BIT) { 491 459 NL_SET_ERR_MSG_ATTR(extack, bit_attr, 492 460 "only ETHTOOL_A_BITSET_BITS_BIT allowed in ETHTOOL_A_BITSET_BITS"); 461 + kfree(saved_bitmap); 493 462 return -EINVAL; 494 463 } 495 464 ret = ethnl_parse_bit(&idx, &new_val, nbits, bit_attr, no_mask, 496 465 names, extack); 497 - if (ret < 0) 466 + if (ret < 0) { 467 + kfree(saved_bitmap); 498 468 return ret; 469 + } 499 470 old_val = bitmap[idx / 32] & ((u32)1 << (idx % 32)); 500 471 if (new_val != old_val) { 501 472 if (new_val) 502 473 bitmap[idx / 32] |= ((u32)1 << (idx % 32)); 503 474 else 504 475 bitmap[idx / 32] &= ~((u32)1 << (idx % 32)); 505 - *mod = true; 476 + if (!no_mask) 477 + *mod = true; 506 478 } 507 479 } 508 480 481 + if (no_mask && !ethnl_bitmap32_equal(saved_bitmap, bitmap, nbits)) 482 + *mod = true; 483 + 484 + kfree(saved_bitmap); 509 485 return 0; 510 486 } 511 487

+2 -1

net/ethtool/ioctl.c

··· 993 993 return rc; 994 994 995 995 /* Nonzero ring with RSS only makes sense if NIC adds them together */ 996 - if (info.flow_type & FLOW_RSS && !ops->cap_rss_rxnfc_adds && 996 + if (cmd == ETHTOOL_SRXCLSRLINS && info.flow_type & FLOW_RSS && 997 + !ops->cap_rss_rxnfc_adds && 997 998 ethtool_get_flow_spec_ring(info.fs.ring_cookie)) 998 999 return -EINVAL; 999 1000

+13 -6

net/hsr/hsr_device.c

··· 246 246 .parse = eth_header_parse, 247 247 }; 248 248 249 - static struct sk_buff *hsr_init_skb(struct hsr_port *master) 249 + static struct sk_buff *hsr_init_skb(struct hsr_port *master, int extra) 250 250 { 251 251 struct hsr_priv *hsr = master->hsr; 252 252 struct sk_buff *skb; 253 253 int hlen, tlen; 254 + int len; 254 255 255 256 hlen = LL_RESERVED_SPACE(master->dev); 256 257 tlen = master->dev->needed_tailroom; 258 + len = sizeof(struct hsr_sup_tag) + sizeof(struct hsr_sup_payload); 257 259 /* skb size is same for PRP/HSR frames, only difference 258 260 * being, for PRP it is a trailer and for HSR it is a 259 - * header 261 + * header. 262 + * RedBox might use @extra more bytes. 260 263 */ 261 - skb = dev_alloc_skb(sizeof(struct hsr_sup_tag) + 262 - sizeof(struct hsr_sup_payload) + hlen + tlen); 264 + skb = dev_alloc_skb(len + extra + hlen + tlen); 263 265 264 266 if (!skb) 265 267 return skb; ··· 297 295 struct hsr_sup_tlv *hsr_stlv; 298 296 struct hsr_sup_tag *hsr_stag; 299 297 struct sk_buff *skb; 298 + int extra = 0; 300 299 301 300 *interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); 302 301 if (hsr->announce_count < 3 && hsr->prot_version == 0) { ··· 306 303 hsr->announce_count++; 307 304 } 308 305 309 - skb = hsr_init_skb(port); 306 + if (hsr->redbox) 307 + extra = sizeof(struct hsr_sup_tlv) + 308 + sizeof(struct hsr_sup_payload); 309 + 310 + skb = hsr_init_skb(port, extra); 310 311 if (!skb) { 311 312 netdev_warn_once(port->dev, "HSR: Could not send supervision frame\n"); 312 313 return; ··· 369 362 struct hsr_sup_tag *hsr_stag; 370 363 struct sk_buff *skb; 371 364 372 - skb = hsr_init_skb(master); 365 + skb = hsr_init_skb(master, 0); 373 366 if (!skb) { 374 367 netdev_warn_once(master->dev, "PRP: Could not send supervision frame\n"); 375 368 return;

+2

net/hsr/hsr_forward.c

··· 700 700 frame->is_vlan = true; 701 701 702 702 if (frame->is_vlan) { 703 + if (skb->mac_len < offsetofend(struct hsr_vlan_ethhdr, vlanhdr)) 704 + return -EINVAL; 703 705 vlan_hdr = (struct hsr_vlan_ethhdr *)ethhdr; 704 706 proto = vlan_hdr->vlanhdr.h_vlan_encapsulated_proto; 705 707 }

+3

net/ipv4/icmp.c

··· 517 517 if (!IS_ERR(dst)) { 518 518 if (rt != rt2) 519 519 return rt; 520 + if (inet_addr_type_dev_table(net, route_lookup_dev, 521 + fl4->daddr) == RTN_LOCAL) 522 + return rt; 520 523 } else if (PTR_ERR(dst) == -EPERM) { 521 524 rt = NULL; 522 525 } else {

+1 -1

net/ipv4/ipmr.c

··· 122 122 123 123 static bool ipmr_can_free_table(struct net *net) 124 124 { 125 - return !check_net(net) || !net->ipv4.mr_rules_ops; 125 + return !check_net(net) || !net_initialized(net); 126 126 } 127 127 128 128 static struct mr_table *ipmr_mr_table_iter(struct net *net,

+4

net/ipv4/tcp_minisocks.c

··· 326 326 tcptw->tw_last_oow_ack_time = 0; 327 327 tcptw->tw_tx_delay = tp->tcp_tx_delay; 328 328 tw->tw_txhash = sk->sk_txhash; 329 + tw->tw_tx_queue_mapping = sk->sk_tx_queue_mapping; 330 + #ifdef CONFIG_SOCK_RX_QUEUE_MAPPING 331 + tw->tw_rx_queue_mapping = sk->sk_rx_queue_mapping; 332 + #endif 329 333 #if IS_ENABLED(CONFIG_IPV6) 330 334 if (tw->tw_family == PF_INET6) { 331 335 struct ipv6_pinfo *np = inet6_sk(sk);

+3 -11

net/ipv4/udp.c

··· 1674 1674 struct sk_buff_head *list = &sk->sk_receive_queue; 1675 1675 int rmem, err = -ENOMEM; 1676 1676 spinlock_t *busy = NULL; 1677 - bool becomes_readable; 1678 1677 int size, rcvbuf; 1679 1678 1680 1679 /* Immediately drop when the receive queue is full. ··· 1714 1715 */ 1715 1716 sock_skb_set_dropcount(sk, skb); 1716 1717 1717 - becomes_readable = skb_queue_empty(list); 1718 1718 __skb_queue_tail(list, skb); 1719 1719 spin_unlock(&list->lock); 1720 1720 1721 - if (!sock_flag(sk, SOCK_DEAD)) { 1722 - if (becomes_readable || 1723 - sk->sk_data_ready != sock_def_readable || 1724 - READ_ONCE(sk->sk_peek_off) >= 0) 1725 - INDIRECT_CALL_1(sk->sk_data_ready, 1726 - sock_def_readable, sk); 1727 - else 1728 - sk_wake_async_rcu(sk, SOCK_WAKE_WAITD, POLL_IN); 1729 - } 1721 + if (!sock_flag(sk, SOCK_DEAD)) 1722 + INDIRECT_CALL_1(sk->sk_data_ready, sock_def_readable, sk); 1723 + 1730 1724 busylock_release(busy); 1731 1725 return 0; 1732 1726

+7 -6

net/ipv6/addrconf.c

··· 4821 4821 ifm->ifa_prefixlen, extack); 4822 4822 } 4823 4823 4824 - static int modify_prefix_route(struct inet6_ifaddr *ifp, 4824 + static int modify_prefix_route(struct net *net, struct inet6_ifaddr *ifp, 4825 4825 unsigned long expires, u32 flags, 4826 4826 bool modify_peer) 4827 4827 { ··· 4845 4845 ifp->prefix_len, 4846 4846 ifp->rt_priority, ifp->idev->dev, 4847 4847 expires, flags, GFP_KERNEL); 4848 - } else { 4848 + return 0; 4849 + } 4850 + if (f6i != net->ipv6.fib6_null_entry) { 4849 4851 table = f6i->fib6_table; 4850 4852 spin_lock_bh(&table->tb6_lock); 4851 4853 ··· 4860 4858 } 4861 4859 4862 4860 spin_unlock_bh(&table->tb6_lock); 4863 - 4864 - fib6_info_release(f6i); 4865 4861 } 4862 + fib6_info_release(f6i); 4866 4863 4867 4864 return 0; 4868 4865 } ··· 4940 4939 int rc = -ENOENT; 4941 4940 4942 4941 if (had_prefixroute) 4943 - rc = modify_prefix_route(ifp, expires, flags, false); 4942 + rc = modify_prefix_route(net, ifp, expires, flags, false); 4944 4943 4945 4944 /* prefix route could have been deleted; if so restore it */ 4946 4945 if (rc == -ENOENT) { ··· 4950 4949 } 4951 4950 4952 4951 if (had_prefixroute && !ipv6_addr_any(&ifp->peer_addr)) 4953 - rc = modify_prefix_route(ifp, expires, flags, true); 4952 + rc = modify_prefix_route(net, ifp, expires, flags, true); 4954 4953 4955 4954 if (rc == -ENOENT && !ipv6_addr_any(&ifp->peer_addr)) { 4956 4955 addrconf_prefix_route(&ifp->peer_addr, ifp->prefix_len,

+1 -1

net/ipv6/ip6mr.c

··· 110 110 111 111 static bool ip6mr_can_free_table(struct net *net) 112 112 { 113 - return !check_net(net) || !net->ipv6.mr6_rules_ops; 113 + return !check_net(net) || !net_initialized(net); 114 114 } 115 115 116 116 static struct mr_table *ip6mr_mr_table_iter(struct net *net,

+3 -3

net/ipv6/route.c

··· 2780 2780 if (rt->rt6i_flags & RTF_CACHE) { 2781 2781 rcu_read_lock(); 2782 2782 if (rt6_check_expired(rt)) { 2783 - /* counteract the dst_release() in sk_dst_reset() */ 2784 - dst_hold(dst); 2783 + /* rt/dst can not be destroyed yet, 2784 + * because of rcu_read_lock() 2785 + */ 2785 2786 sk_dst_reset(sk); 2786 - 2787 2787 rt6_remove_exception_rt(rt); 2788 2788 } 2789 2789 rcu_read_unlock();

+5

net/netfilter/ipset/ip_set_core.c

··· 104 104 static bool 105 105 load_settype(const char *name) 106 106 { 107 + if (!try_module_get(THIS_MODULE)) 108 + return false; 109 + 107 110 nfnl_unlock(NFNL_SUBSYS_IPSET); 108 111 pr_debug("try to load ip_set_%s\n", name); 109 112 if (request_module("ip_set_%s", name) < 0) { 110 113 pr_warn("Can't find ip_set type %s\n", name); 111 114 nfnl_lock(NFNL_SUBSYS_IPSET); 115 + module_put(THIS_MODULE); 112 116 return false; 113 117 } 114 118 nfnl_lock(NFNL_SUBSYS_IPSET); 119 + module_put(THIS_MODULE); 115 120 return true; 116 121 } 117 122

+1 -3

net/netfilter/ipvs/ip_vs_proto.c

··· 340 340 341 341 int __init ip_vs_protocol_init(void) 342 342 { 343 - char protocols[64]; 343 + char protocols[64] = { 0 }; 344 344 #define REGISTER_PROTOCOL(p) \ 345 345 do { \ 346 346 register_ip_vs_protocol(p); \ ··· 348 348 strcat(protocols, (p)->name); \ 349 349 } while (0) 350 350 351 - protocols[0] = '\0'; 352 - protocols[2] = '\0'; 353 351 #ifdef CONFIG_IP_VS_PROTO_TCP 354 352 REGISTER_PROTOCOL(&ip_vs_protocol_tcp); 355 353 #endif

+46 -13

net/netfilter/nft_inner.c

··· 210 210 struct nft_pktinfo *pkt, 211 211 struct nft_inner_tun_ctx *tun_ctx) 212 212 { 213 - struct nft_inner_tun_ctx ctx = {}; 214 213 u32 off = pkt->inneroff; 215 214 216 215 if (priv->flags & NFT_INNER_HDRSIZE && 217 - nft_inner_parse_tunhdr(priv, pkt, &ctx, &off) < 0) 216 + nft_inner_parse_tunhdr(priv, pkt, tun_ctx, &off) < 0) 218 217 return -1; 219 218 220 219 if (priv->flags & (NFT_INNER_LL | NFT_INNER_NH)) { 221 - if (nft_inner_parse_l2l3(priv, pkt, &ctx, off) < 0) 220 + if (nft_inner_parse_l2l3(priv, pkt, tun_ctx, off) < 0) 222 221 return -1; 223 222 } else if (priv->flags & NFT_INNER_TH) { 224 - ctx.inner_thoff = off; 225 - ctx.flags |= NFT_PAYLOAD_CTX_INNER_TH; 223 + tun_ctx->inner_thoff = off; 224 + tun_ctx->flags |= NFT_PAYLOAD_CTX_INNER_TH; 226 225 } 227 226 228 - *tun_ctx = ctx; 229 227 tun_ctx->type = priv->type; 228 + tun_ctx->cookie = (unsigned long)pkt->skb; 230 229 pkt->flags |= NFT_PKTINFO_INNER_FULL; 231 230 232 231 return 0; 233 232 } 234 233 235 - static bool nft_inner_parse_needed(const struct nft_inner *priv, 236 - const struct nft_pktinfo *pkt, 234 + static bool nft_inner_restore_tun_ctx(const struct nft_pktinfo *pkt, 235 + struct nft_inner_tun_ctx *tun_ctx) 236 + { 237 + struct nft_inner_tun_ctx *this_cpu_tun_ctx; 238 + 239 + local_bh_disable(); 240 + this_cpu_tun_ctx = this_cpu_ptr(&nft_pcpu_tun_ctx); 241 + if (this_cpu_tun_ctx->cookie != (unsigned long)pkt->skb) { 242 + local_bh_enable(); 243 + return false; 244 + } 245 + *tun_ctx = *this_cpu_tun_ctx; 246 + local_bh_enable(); 247 + 248 + return true; 249 + } 250 + 251 + static void nft_inner_save_tun_ctx(const struct nft_pktinfo *pkt, 237 252 const struct nft_inner_tun_ctx *tun_ctx) 238 253 { 254 + struct nft_inner_tun_ctx *this_cpu_tun_ctx; 255 + 256 + local_bh_disable(); 257 + this_cpu_tun_ctx = this_cpu_ptr(&nft_pcpu_tun_ctx); 258 + if (this_cpu_tun_ctx->cookie != tun_ctx->cookie) 259 + *this_cpu_tun_ctx = *tun_ctx; 260 + local_bh_enable(); 261 + } 262 + 263 + static bool nft_inner_parse_needed(const struct nft_inner *priv, 264 + const struct nft_pktinfo *pkt, 265 + struct nft_inner_tun_ctx *tun_ctx) 266 + { 239 267 if (!(pkt->flags & NFT_PKTINFO_INNER_FULL)) 268 + return true; 269 + 270 + if (!nft_inner_restore_tun_ctx(pkt, tun_ctx)) 240 271 return true; 241 272 242 273 if (priv->type != tun_ctx->type) ··· 279 248 static void nft_inner_eval(const struct nft_expr *expr, struct nft_regs *regs, 280 249 const struct nft_pktinfo *pkt) 281 250 { 282 - struct nft_inner_tun_ctx *tun_ctx = this_cpu_ptr(&nft_pcpu_tun_ctx); 283 251 const struct nft_inner *priv = nft_expr_priv(expr); 252 + struct nft_inner_tun_ctx tun_ctx = {}; 284 253 285 254 if (nft_payload_inner_offset(pkt) < 0) 286 255 goto err; 287 256 288 - if (nft_inner_parse_needed(priv, pkt, tun_ctx) && 289 - nft_inner_parse(priv, (struct nft_pktinfo *)pkt, tun_ctx) < 0) 257 + if (nft_inner_parse_needed(priv, pkt, &tun_ctx) && 258 + nft_inner_parse(priv, (struct nft_pktinfo *)pkt, &tun_ctx) < 0) 290 259 goto err; 291 260 292 261 switch (priv->expr_type) { 293 262 case NFT_INNER_EXPR_PAYLOAD: 294 - nft_payload_inner_eval((struct nft_expr *)&priv->expr, regs, pkt, tun_ctx); 263 + nft_payload_inner_eval((struct nft_expr *)&priv->expr, regs, pkt, &tun_ctx); 295 264 break; 296 265 case NFT_INNER_EXPR_META: 297 - nft_meta_inner_eval((struct nft_expr *)&priv->expr, regs, pkt, tun_ctx); 266 + nft_meta_inner_eval((struct nft_expr *)&priv->expr, regs, pkt, &tun_ctx); 298 267 break; 299 268 default: 300 269 WARN_ON_ONCE(1); 301 270 goto err; 302 271 } 272 + nft_inner_save_tun_ctx(pkt, &tun_ctx); 273 + 303 274 return; 304 275 err: 305 276 regs->verdict.code = NFT_BREAK;

+16

net/netfilter/nft_set_hash.c

··· 24 24 struct nft_rhash { 25 25 struct rhashtable ht; 26 26 struct delayed_work gc_work; 27 + u32 wq_gc_seq; 27 28 }; 28 29 29 30 struct nft_rhash_elem { 30 31 struct nft_elem_priv priv; 31 32 struct rhash_head node; 33 + u32 wq_gc_seq; 32 34 struct nft_set_ext ext; 33 35 }; 34 36 ··· 340 338 if (!gc) 341 339 goto done; 342 340 341 + /* Elements never collected use a zero gc worker sequence number. */ 342 + if (unlikely(++priv->wq_gc_seq == 0)) 343 + priv->wq_gc_seq++; 344 + 343 345 rhashtable_walk_enter(&priv->ht, &hti); 344 346 rhashtable_walk_start(&hti); 345 347 ··· 361 355 goto try_later; 362 356 } 363 357 358 + /* rhashtable walk is unstable, already seen in this gc run? 359 + * Then, skip this element. In case of (unlikely) sequence 360 + * wraparound and stale element wq_gc_seq, next gc run will 361 + * just find this expired element. 362 + */ 363 + if (he->wq_gc_seq == priv->wq_gc_seq) 364 + continue; 365 + 364 366 if (nft_set_elem_is_dead(&he->ext)) 365 367 goto dead_elem; 366 368 ··· 385 371 if (!gc) 386 372 goto try_later; 387 373 374 + /* annotate gc sequence for this attempt. */ 375 + he->wq_gc_seq = priv->wq_gc_seq; 388 376 nft_trans_gc_elem_add(gc, he); 389 377 } 390 378

+1 -1

net/netfilter/nft_socket.c

··· 68 68 69 69 cgroup_put(cgrp); 70 70 71 - if (WARN_ON_ONCE(level > 255)) 71 + if (level > 255) 72 72 return -ERANGE; 73 73 74 74 if (WARN_ON_ONCE(level < 0))

+3 -1

net/netfilter/xt_LED.c

··· 96 96 struct xt_led_info_internal *ledinternal; 97 97 int err; 98 98 99 - if (ledinfo->id[0] == '\0') 99 + /* Bail out if empty string or not a string at all. */ 100 + if (ledinfo->id[0] == '\0' || 101 + !memchr(ledinfo->id, '\0', sizeof(ledinfo->id))) 100 102 return -EINVAL; 101 103 102 104 mutex_lock(&xt_led_mutex);

+3 -2

net/sched/cls_flower.c

··· 1369 1369 int err; 1370 1370 1371 1371 md = (struct erspan_metadata *)&key->enc_opts.data[key->enc_opts.len]; 1372 - memset(md, 0xff, sizeof(*md)); 1373 1372 md->version = 1; 1374 1373 1375 1374 if (!depth) ··· 1397 1398 NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option index"); 1398 1399 return -EINVAL; 1399 1400 } 1401 + memset(&md->u.index, 0xff, sizeof(md->u.index)); 1400 1402 if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]) { 1401 1403 nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]; 1402 - memset(&md->u, 0x00, sizeof(md->u)); 1403 1404 md->u.index = nla_get_be32(nla); 1404 1405 } 1405 1406 } else if (md->version == 2) { ··· 1408 1409 NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option dir or hwid"); 1409 1410 return -EINVAL; 1410 1411 } 1412 + md->u.md2.dir = 1; 1411 1413 if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR]) { 1412 1414 nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_DIR]; 1413 1415 md->u.md2.dir = nla_get_u8(nla); 1414 1416 } 1417 + set_hwid(&md->u.md2, 0xff); 1415 1418 if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID]) { 1416 1419 nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_HWID]; 1417 1420 set_hwid(&md->u.md2, nla_get_u8(nla));

+1 -1

net/sched/sch_cake.c

··· 1525 1525 b->backlogs[idx] -= len; 1526 1526 b->tin_backlog -= len; 1527 1527 sch->qstats.backlog -= len; 1528 - qdisc_tree_reduce_backlog(sch, 1, len); 1529 1528 1530 1529 flow->dropped++; 1531 1530 b->tin_dropped++; ··· 1535 1536 1536 1537 __qdisc_drop(skb, to_free); 1537 1538 sch->q.qlen--; 1539 + qdisc_tree_reduce_backlog(sch, 1, len); 1538 1540 1539 1541 cake_heapify(q, 0); 1540 1542

+1 -1

net/sched/sch_choke.c

··· 123 123 if (idx == q->tail) 124 124 choke_zap_tail_holes(q); 125 125 126 + --sch->q.qlen; 126 127 qdisc_qstats_backlog_dec(sch, skb); 127 128 qdisc_tree_reduce_backlog(sch, 1, qdisc_pkt_len(skb)); 128 129 qdisc_drop(skb, sch, to_free); 129 - --sch->q.qlen; 130 130 } 131 131 132 132 struct choke_skb_cb {

+12 -6

net/sched/sch_tbf.c

··· 208 208 struct tbf_sched_data *q = qdisc_priv(sch); 209 209 struct sk_buff *segs, *nskb; 210 210 netdev_features_t features = netif_skb_features(skb); 211 - unsigned int len = 0, prev_len = qdisc_pkt_len(skb); 211 + unsigned int len = 0, prev_len = qdisc_pkt_len(skb), seg_len; 212 212 int ret, nb; 213 213 214 214 segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); ··· 219 219 nb = 0; 220 220 skb_list_walk_safe(segs, segs, nskb) { 221 221 skb_mark_not_on_list(segs); 222 - qdisc_skb_cb(segs)->pkt_len = segs->len; 223 - len += segs->len; 222 + seg_len = segs->len; 223 + qdisc_skb_cb(segs)->pkt_len = seg_len; 224 224 ret = qdisc_enqueue(segs, q->qdisc, to_free); 225 225 if (ret != NET_XMIT_SUCCESS) { 226 226 if (net_xmit_drop_count(ret)) 227 227 qdisc_qstats_drop(sch); 228 228 } else { 229 229 nb++; 230 + len += seg_len; 230 231 } 231 232 } 232 233 sch->q.qlen += nb; 233 - if (nb > 1) 234 + sch->qstats.backlog += len; 235 + if (nb > 0) { 234 236 qdisc_tree_reduce_backlog(sch, 1 - nb, prev_len - len); 235 - consume_skb(skb); 236 - return nb > 0 ? NET_XMIT_SUCCESS : NET_XMIT_DROP; 237 + consume_skb(skb); 238 + return NET_XMIT_SUCCESS; 239 + } 240 + 241 + kfree_skb(skb); 242 + return NET_XMIT_DROP; 237 243 } 238 244 239 245 static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch,

+3 -3

net/smc/af_smc.c

··· 383 383 smc->limit_smc_hs = net->smc.limit_smc_hs; 384 384 smc->use_fallback = false; /* assume rdma capability first */ 385 385 smc->fallback_rsn = 0; 386 + smc_close_init(smc); 386 387 } 387 388 388 389 static struct sock *smc_sock_alloc(struct net *net, struct socket *sock, ··· 1300 1299 goto connect_abort; 1301 1300 } 1302 1301 1303 - smc_close_init(smc); 1304 1302 smc_rx_init(smc); 1305 1303 1306 1304 if (ini->first_contact_local) { ··· 1435 1435 goto connect_abort; 1436 1436 } 1437 1437 } 1438 - smc_close_init(smc); 1439 1438 smc_rx_init(smc); 1440 1439 smc_tx_init(smc); 1441 1440 ··· 1900 1901 if (tcp_sk(new_smc->clcsock->sk)->syn_smc) 1901 1902 atomic_dec(&lsmc->queued_smc_hs); 1902 1903 1904 + release_sock(newsmcsk); /* lock in smc_listen_work() */ 1903 1905 if (lsmc->sk.sk_state == SMC_LISTEN) { 1904 1906 lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING); 1905 1907 smc_accept_enqueue(&lsmc->sk, newsmcsk); ··· 2422 2422 u8 accept_version; 2423 2423 int rc = 0; 2424 2424 2425 + lock_sock(&new_smc->sk); /* release in smc_listen_out() */ 2425 2426 if (new_smc->listen_smc->sk.sk_state != SMC_LISTEN) 2426 2427 return smc_listen_out_err(new_smc); 2427 2428 ··· 2480 2479 goto out_decl; 2481 2480 2482 2481 mutex_lock(&smc_server_lgr_pending); 2483 - smc_close_init(new_smc); 2484 2482 smc_rx_init(new_smc); 2485 2483 smc_tx_init(new_smc); 2486 2484

+1 -1

net/tipc/udp_media.c

··· 814 814 kfree_rcu(rcast, rcu); 815 815 } 816 816 817 - atomic_dec(&tipc_net(sock_net(ub->ubsock->sk))->wq_count); 818 817 dst_cache_destroy(&ub->rcast.dst_cache); 819 818 udp_tunnel_sock_release(ub->ubsock); 820 819 synchronize_net(); 820 + atomic_dec(&tipc_net(sock_net(ub->ubsock->sk))->wq_count); 821 821 kfree(ub); 822 822 } 823 823

+1 -1

security/selinux/hooks.c

··· 5738 5738 /* we do this in the LOCAL_OUT path and not the POST_ROUTING path 5739 5739 * because we want to make sure we apply the necessary labeling 5740 5740 * before IPsec is applied so we can leverage AH protection */ 5741 - sk = skb->sk; 5741 + sk = sk_to_full_sk(skb->sk); 5742 5742 if (sk) { 5743 5743 struct sk_security_struct *sksec; 5744 5744

+11 -1

tools/testing/selftests/drivers/net/hw/rss_ctx.py

··· 3 3 4 4 import datetime 5 5 import random 6 - from lib.py import ksft_run, ksft_pr, ksft_exit, ksft_eq, ksft_ne, ksft_ge, ksft_lt 6 + import re 7 + from lib.py import ksft_run, ksft_pr, ksft_exit, ksft_eq, ksft_ne, ksft_ge, ksft_lt, ksft_true 7 8 from lib.py import NetDrvEpEnv 8 9 from lib.py import EthtoolFamily, NetdevFamily 9 10 from lib.py import KsftSkipEx, KsftFailEx ··· 95 94 if params.get('empty'): 96 95 ksft_eq(sum(cnts[i] for i in params['empty']), 0, 97 96 f"traffic on inactive queues ({name}): " + str(cnts)) 97 + 98 + 99 + def _ntuple_rule_check(cfg, rule_id, ctx_id): 100 + """Check that ntuple rule references RSS context ID""" 101 + text = ethtool(f"-n {cfg.ifname} rule {rule_id}").stdout 102 + pattern = f"RSS Context (ID: )?{ctx_id}" 103 + ksft_true(re.search(pattern, text), "RSS context not referenced in ntuple rule") 98 104 99 105 100 106 def test_rss_key_indir(cfg): ··· 466 458 flow = f"flow-type tcp{cfg.addr_ipver} dst-ip {cfg.addr} dst-port {ports[i]} context {ctx_id}" 467 459 ntuple = ethtool_create(cfg, "-N", flow) 468 460 defer(ethtool, f"-N {cfg.ifname} delete {ntuple}") 461 + 462 + _ntuple_rule_check(cfg, ntuple, ctx_id) 469 463 470 464 for i in range(ctx_cnt): 471 465 _send_traffic_check(cfg, ports[i], f"context {i}",

+3 -6

tools/testing/vsock/control.c

··· 27 27 28 28 #include "timeout.h" 29 29 #include "control.h" 30 + #include "util.h" 30 31 31 32 static int control_fd = -1; 32 33 ··· 51 50 52 51 for (ai = result; ai; ai = ai->ai_next) { 53 52 int fd; 54 - int val = 1; 55 53 56 54 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); 57 55 if (fd < 0) ··· 65 65 break; 66 66 } 67 67 68 - if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 69 - &val, sizeof(val)) < 0) { 70 - perror("setsockopt"); 71 - exit(EXIT_FAILURE); 72 - } 68 + setsockopt_int_check(fd, SOL_SOCKET, SO_REUSEADDR, 1, 69 + "setsockopt SO_REUSEADDR"); 73 70 74 71 if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0) 75 72 goto next;

-10

tools/testing/vsock/msg_zerocopy_common.c

··· 14 14 15 15 #include "msg_zerocopy_common.h" 16 16 17 - void enable_so_zerocopy(int fd) 18 - { 19 - int val = 1; 20 - 21 - if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val))) { 22 - perror("setsockopt"); 23 - exit(EXIT_FAILURE); 24 - } 25 - } 26 - 27 17 void vsock_recv_completion(int fd, const bool *zerocopied) 28 18 { 29 19 struct sock_extended_err *serr;

-1

tools/testing/vsock/msg_zerocopy_common.h

··· 12 12 #define VSOCK_RECVERR 1 13 13 #endif 14 14 15 - void enable_so_zerocopy(int fd); 16 15 void vsock_recv_completion(int fd, const bool *zerocopied); 17 16 18 17 #endif /* MSG_ZEROCOPY_COMMON_H */

+142

tools/testing/vsock/util.c

··· 651 651 652 652 free(iovec); 653 653 } 654 + 655 + /* Set "unsigned long long" socket option and check that it's indeed set */ 656 + void setsockopt_ull_check(int fd, int level, int optname, 657 + unsigned long long val, char const *errmsg) 658 + { 659 + unsigned long long chkval; 660 + socklen_t chklen; 661 + int err; 662 + 663 + err = setsockopt(fd, level, optname, &val, sizeof(val)); 664 + if (err) { 665 + fprintf(stderr, "setsockopt err: %s (%d)\n", 666 + strerror(errno), errno); 667 + goto fail; 668 + } 669 + 670 + chkval = ~val; /* just make storage != val */ 671 + chklen = sizeof(chkval); 672 + 673 + err = getsockopt(fd, level, optname, &chkval, &chklen); 674 + if (err) { 675 + fprintf(stderr, "getsockopt err: %s (%d)\n", 676 + strerror(errno), errno); 677 + goto fail; 678 + } 679 + 680 + if (chklen != sizeof(chkval)) { 681 + fprintf(stderr, "size mismatch: set %zu got %d\n", sizeof(val), 682 + chklen); 683 + goto fail; 684 + } 685 + 686 + if (chkval != val) { 687 + fprintf(stderr, "value mismatch: set %llu got %llu\n", val, 688 + chkval); 689 + goto fail; 690 + } 691 + return; 692 + fail: 693 + fprintf(stderr, "%s val %llu\n", errmsg, val); 694 + exit(EXIT_FAILURE); 695 + ; 696 + } 697 + 698 + /* Set "int" socket option and check that it's indeed set */ 699 + void setsockopt_int_check(int fd, int level, int optname, int val, 700 + char const *errmsg) 701 + { 702 + int chkval; 703 + socklen_t chklen; 704 + int err; 705 + 706 + err = setsockopt(fd, level, optname, &val, sizeof(val)); 707 + if (err) { 708 + fprintf(stderr, "setsockopt err: %s (%d)\n", 709 + strerror(errno), errno); 710 + goto fail; 711 + } 712 + 713 + chkval = ~val; /* just make storage != val */ 714 + chklen = sizeof(chkval); 715 + 716 + err = getsockopt(fd, level, optname, &chkval, &chklen); 717 + if (err) { 718 + fprintf(stderr, "getsockopt err: %s (%d)\n", 719 + strerror(errno), errno); 720 + goto fail; 721 + } 722 + 723 + if (chklen != sizeof(chkval)) { 724 + fprintf(stderr, "size mismatch: set %zu got %d\n", sizeof(val), 725 + chklen); 726 + goto fail; 727 + } 728 + 729 + if (chkval != val) { 730 + fprintf(stderr, "value mismatch: set %d got %d\n", val, chkval); 731 + goto fail; 732 + } 733 + return; 734 + fail: 735 + fprintf(stderr, "%s val %d\n", errmsg, val); 736 + exit(EXIT_FAILURE); 737 + } 738 + 739 + static void mem_invert(unsigned char *mem, size_t size) 740 + { 741 + size_t i; 742 + 743 + for (i = 0; i < size; i++) 744 + mem[i] = ~mem[i]; 745 + } 746 + 747 + /* Set "timeval" socket option and check that it's indeed set */ 748 + void setsockopt_timeval_check(int fd, int level, int optname, 749 + struct timeval val, char const *errmsg) 750 + { 751 + struct timeval chkval; 752 + socklen_t chklen; 753 + int err; 754 + 755 + err = setsockopt(fd, level, optname, &val, sizeof(val)); 756 + if (err) { 757 + fprintf(stderr, "setsockopt err: %s (%d)\n", 758 + strerror(errno), errno); 759 + goto fail; 760 + } 761 + 762 + /* just make storage != val */ 763 + chkval = val; 764 + mem_invert((unsigned char *)&chkval, sizeof(chkval)); 765 + chklen = sizeof(chkval); 766 + 767 + err = getsockopt(fd, level, optname, &chkval, &chklen); 768 + if (err) { 769 + fprintf(stderr, "getsockopt err: %s (%d)\n", 770 + strerror(errno), errno); 771 + goto fail; 772 + } 773 + 774 + if (chklen != sizeof(chkval)) { 775 + fprintf(stderr, "size mismatch: set %zu got %d\n", sizeof(val), 776 + chklen); 777 + goto fail; 778 + } 779 + 780 + if (memcmp(&chkval, &val, sizeof(val)) != 0) { 781 + fprintf(stderr, "value mismatch: set %ld:%ld got %ld:%ld\n", 782 + val.tv_sec, val.tv_usec, chkval.tv_sec, chkval.tv_usec); 783 + goto fail; 784 + } 785 + return; 786 + fail: 787 + fprintf(stderr, "%s val %ld:%ld\n", errmsg, val.tv_sec, val.tv_usec); 788 + exit(EXIT_FAILURE); 789 + } 790 + 791 + void enable_so_zerocopy_check(int fd) 792 + { 793 + setsockopt_int_check(fd, SOL_SOCKET, SO_ZEROCOPY, 1, 794 + "setsockopt SO_ZEROCOPY"); 795 + }

+7

tools/testing/vsock/util.h

··· 68 68 struct iovec *alloc_test_iovec(const struct iovec *test_iovec, int iovnum); 69 69 void free_test_iovec(const struct iovec *test_iovec, 70 70 struct iovec *iovec, int iovnum); 71 + void setsockopt_ull_check(int fd, int level, int optname, 72 + unsigned long long val, char const *errmsg); 73 + void setsockopt_int_check(int fd, int level, int optname, int val, 74 + char const *errmsg); 75 + void setsockopt_timeval_check(int fd, int level, int optname, 76 + struct timeval val, char const *errmsg); 77 + void enable_so_zerocopy_check(int fd); 71 78 #endif /* UTIL_H */

+15 -5

tools/testing/vsock/vsock_perf.c

··· 33 33 34 34 static unsigned int port = DEFAULT_PORT; 35 35 static unsigned long buf_size_bytes = DEFAULT_BUF_SIZE_BYTES; 36 - static unsigned long vsock_buf_bytes = DEFAULT_VSOCK_BUF_BYTES; 36 + static unsigned long long vsock_buf_bytes = DEFAULT_VSOCK_BUF_BYTES; 37 37 static bool zerocopy; 38 38 39 39 static void error(const char *s) ··· 133 133 ((float)ns_delta / NSEC_PER_SEC); 134 134 } 135 135 136 - static void run_receiver(unsigned long rcvlowat_bytes) 136 + static void run_receiver(int rcvlowat_bytes) 137 137 { 138 138 unsigned int read_cnt; 139 139 time_t rx_begin_ns; ··· 162 162 printf("Run as receiver\n"); 163 163 printf("Listen port %u\n", port); 164 164 printf("RX buffer %lu bytes\n", buf_size_bytes); 165 - printf("vsock buffer %lu bytes\n", vsock_buf_bytes); 166 - printf("SO_RCVLOWAT %lu bytes\n", rcvlowat_bytes); 165 + printf("vsock buffer %llu bytes\n", vsock_buf_bytes); 166 + printf("SO_RCVLOWAT %d bytes\n", rcvlowat_bytes); 167 167 168 168 fd = socket(AF_VSOCK, SOCK_STREAM, 0); 169 169 ··· 249 249 free(data); 250 250 close(client_fd); 251 251 close(fd); 252 + } 253 + 254 + static void enable_so_zerocopy(int fd) 255 + { 256 + int val = 1; 257 + 258 + if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val))) { 259 + perror("setsockopt"); 260 + exit(EXIT_FAILURE); 261 + } 252 262 } 253 263 254 264 static void run_sender(int peer_cid, unsigned long to_send_bytes) ··· 449 439 int main(int argc, char **argv) 450 440 { 451 441 unsigned long to_send_bytes = DEFAULT_TO_SEND_BYTES; 452 - unsigned long rcvlowat_bytes = DEFAULT_RCVLOWAT_BYTES; 442 + int rcvlowat_bytes = DEFAULT_RCVLOWAT_BYTES; 453 443 int peer_cid = -1; 454 444 bool sender = false; 455 445

+35 -40

tools/testing/vsock/vsock_test.c

··· 429 429 430 430 static void test_seqpacket_msg_bounds_server(const struct test_opts *opts) 431 431 { 432 - unsigned long sock_buf_size; 432 + unsigned long long sock_buf_size; 433 433 unsigned long remote_hash; 434 434 unsigned long curr_hash; 435 435 int fd; ··· 444 444 445 445 sock_buf_size = SOCK_BUF_SIZE; 446 446 447 - if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_MAX_SIZE, 448 - &sock_buf_size, sizeof(sock_buf_size))) { 449 - perror("setsockopt(SO_VM_SOCKETS_BUFFER_MAX_SIZE)"); 450 - exit(EXIT_FAILURE); 451 - } 447 + setsockopt_ull_check(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_MAX_SIZE, 448 + sock_buf_size, 449 + "setsockopt(SO_VM_SOCKETS_BUFFER_MAX_SIZE)"); 452 450 453 - if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, 454 - &sock_buf_size, sizeof(sock_buf_size))) { 455 - perror("setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)"); 456 - exit(EXIT_FAILURE); 457 - } 451 + setsockopt_ull_check(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, 452 + sock_buf_size, 453 + "setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)"); 458 454 459 455 /* Ready to receive data. */ 460 456 control_writeln("SRVREADY"); ··· 582 586 tv.tv_sec = RCVTIMEO_TIMEOUT_SEC; 583 587 tv.tv_usec = 0; 584 588 585 - if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv)) == -1) { 586 - perror("setsockopt(SO_RCVTIMEO)"); 587 - exit(EXIT_FAILURE); 588 - } 589 + setsockopt_timeval_check(fd, SOL_SOCKET, SO_RCVTIMEO, tv, 590 + "setsockopt(SO_RCVTIMEO)"); 589 591 590 592 read_enter_ns = current_nsec(); 591 593 ··· 628 634 629 635 static void test_seqpacket_bigmsg_client(const struct test_opts *opts) 630 636 { 631 - unsigned long sock_buf_size; 637 + unsigned long long sock_buf_size; 638 + size_t buf_size; 632 639 socklen_t len; 633 640 void *data; 634 641 int fd; ··· 650 655 651 656 sock_buf_size++; 652 657 653 - data = malloc(sock_buf_size); 658 + /* size_t can be < unsigned long long */ 659 + buf_size = (size_t)sock_buf_size; 660 + if (buf_size != sock_buf_size) { 661 + fprintf(stderr, "Returned BUFFER_SIZE too large\n"); 662 + exit(EXIT_FAILURE); 663 + } 664 + 665 + data = malloc(buf_size); 654 666 if (!data) { 655 667 perror("malloc"); 656 668 exit(EXIT_FAILURE); 657 669 } 658 670 659 - send_buf(fd, data, sock_buf_size, 0, -EMSGSIZE); 671 + send_buf(fd, data, buf_size, 0, -EMSGSIZE); 660 672 661 673 control_writeln("CLISENT"); 662 674 ··· 837 835 838 836 static void test_stream_poll_rcvlowat_client(const struct test_opts *opts) 839 837 { 840 - unsigned long lowat_val = RCVLOWAT_BUF_SIZE; 838 + int lowat_val = RCVLOWAT_BUF_SIZE; 841 839 char buf[RCVLOWAT_BUF_SIZE]; 842 840 struct pollfd fds; 843 841 short poll_flags; ··· 849 847 exit(EXIT_FAILURE); 850 848 } 851 849 852 - if (setsockopt(fd, SOL_SOCKET, SO_RCVLOWAT, 853 - &lowat_val, sizeof(lowat_val))) { 854 - perror("setsockopt(SO_RCVLOWAT)"); 855 - exit(EXIT_FAILURE); 856 - } 850 + setsockopt_int_check(fd, SOL_SOCKET, SO_RCVLOWAT, 851 + lowat_val, "setsockopt(SO_RCVLOWAT)"); 857 852 858 853 control_expectln("SRVSENT"); 859 854 ··· 1356 1357 static void test_stream_credit_update_test(const struct test_opts *opts, 1357 1358 bool low_rx_bytes_test) 1358 1359 { 1359 - size_t recv_buf_size; 1360 + int recv_buf_size; 1360 1361 struct pollfd fds; 1361 1362 size_t buf_size; 1363 + unsigned long long sock_buf_size; 1362 1364 void *buf; 1363 1365 int fd; 1364 1366 ··· 1371 1371 1372 1372 buf_size = RCVLOWAT_CREDIT_UPD_BUF_SIZE; 1373 1373 1374 - if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, 1375 - &buf_size, sizeof(buf_size))) { 1376 - perror("setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)"); 1377 - exit(EXIT_FAILURE); 1378 - } 1374 + /* size_t can be < unsigned long long */ 1375 + sock_buf_size = buf_size; 1376 + 1377 + setsockopt_ull_check(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, 1378 + sock_buf_size, 1379 + "setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)"); 1379 1380 1380 1381 if (low_rx_bytes_test) { 1381 1382 /* Set new SO_RCVLOWAT here. This enables sending credit ··· 1385 1384 */ 1386 1385 recv_buf_size = 1 + VIRTIO_VSOCK_MAX_PKT_BUF_SIZE; 1387 1386 1388 - if (setsockopt(fd, SOL_SOCKET, SO_RCVLOWAT, 1389 - &recv_buf_size, sizeof(recv_buf_size))) { 1390 - perror("setsockopt(SO_RCVLOWAT)"); 1391 - exit(EXIT_FAILURE); 1392 - } 1387 + setsockopt_int_check(fd, SOL_SOCKET, SO_RCVLOWAT, 1388 + recv_buf_size, "setsockopt(SO_RCVLOWAT)"); 1393 1389 } 1394 1390 1395 1391 /* Send one dummy byte here, because 'setsockopt()' above also ··· 1428 1430 recv_buf_size++; 1429 1431 1430 1432 /* Updating SO_RCVLOWAT will send credit update. */ 1431 - if (setsockopt(fd, SOL_SOCKET, SO_RCVLOWAT, 1432 - &recv_buf_size, sizeof(recv_buf_size))) { 1433 - perror("setsockopt(SO_RCVLOWAT)"); 1434 - exit(EXIT_FAILURE); 1435 - } 1433 + setsockopt_int_check(fd, SOL_SOCKET, SO_RCVLOWAT, 1434 + recv_buf_size, "setsockopt(SO_RCVLOWAT)"); 1436 1435 } 1437 1436 1438 1437 fds.fd = fd;

+1 -1

tools/testing/vsock/vsock_test_zerocopy.c

··· 162 162 } 163 163 164 164 if (test_data->so_zerocopy) 165 - enable_so_zerocopy(fd); 165 + enable_so_zerocopy_check(fd); 166 166 167 167 iovec = alloc_test_iovec(test_data->vecs, test_data->vecs_cnt); 168 168

+1 -1

tools/testing/vsock/vsock_uring_test.c

··· 73 73 } 74 74 75 75 if (msg_zerocopy) 76 - enable_so_zerocopy(fd); 76 + enable_so_zerocopy_check(fd); 77 77 78 78 iovec = alloc_test_iovec(test_data->vecs, test_data->vecs_cnt); 79 79

Configure Feed

Configure Feed