+5

CREDITS

reviewed

··· 2981 2981 S: Potsdam, New York 13676 2982 2982 S: USA 2983 2983 2984 2984 + N: Shannon Nelson 2985 2985 + E: sln@onemain.com 2986 2986 + D: Worked on several network drivers including 2987 2987 + D: ixgbe, i40e, ionic, pds_core, pds_vdpa, pds_fwctl 2988 2988 + 2984 2989 N: Dave Neuer 2985 2990 E: dave.neuer@pobox.com 2986 2991 D: Helped implement support for Compaq's H31xx series iPAQs

+9 -6

Documentation/netlink/genetlink-legacy.yaml

reviewed

··· 6 6 7 7 # Common defines 8 8 $defs: 9 9 + name: 10 10 + type: string 11 11 + pattern: ^[0-9a-z-]+$ 9 12 uint: 10 13 type: integer 11 14 minimum: 0 ··· 79 76 additionalProperties: False 80 77 properties: 81 78 name: 82 82 - type: string 79 79 + $ref: '#/$defs/name' 83 80 header: 84 81 description: For C-compatible languages, header which already defines this value. 85 82 type: string ··· 106 103 additionalProperties: False 107 104 properties: 108 105 name: 109 109 - type: string 106 106 + $ref: '#/$defs/name' 110 107 value: 111 108 type: integer 112 109 doc: ··· 135 132 additionalProperties: False 136 133 properties: 137 134 name: 138 138 - type: string 135 135 + $ref: '#/$defs/name' 139 136 type: 140 137 description: The netlink attribute type 141 138 enum: [ u8, u16, u32, u64, s8, s16, s32, s64, string, binary ] ··· 172 169 name: 173 170 description: | 174 171 Name used when referring to this space in other definitions, not used outside of the spec. 175 175 - type: string 172 172 + $ref: '#/$defs/name' 176 173 name-prefix: 177 174 description: | 178 175 Prefix for the C enum name of the attributes. Default family[name]-set[name]-a- ··· 209 206 additionalProperties: False 210 207 properties: 211 208 name: 212 212 - type: string 209 209 + $ref: '#/$defs/name' 213 210 type: &attr-type 214 211 description: The netlink attribute type 215 212 enum: [ unused, pad, flag, binary, bitfield32, ··· 351 348 properties: 352 349 name: 353 350 description: Name of the operation, also defining its C enum value in uAPI. 354 354 - type: string 351 351 + $ref: '#/$defs/name' 355 352 doc: 356 353 description: Documentation for the command. 357 354 type: string

+10 -7

Documentation/netlink/genetlink.yaml

reviewed

··· 6 6 7 7 # Common defines 8 8 $defs: 9 9 + name: 10 10 + type: string 11 11 + pattern: ^[0-9a-z-]+$ 9 12 uint: 10 13 type: integer 11 14 minimum: 0 ··· 32 29 properties: 33 30 name: 34 31 description: Name of the genetlink family. 35 35 - type: string 32 32 + $ref: '#/$defs/name' 36 33 doc: 37 34 type: string 38 35 protocol: ··· 51 48 additionalProperties: False 52 49 properties: 53 50 name: 54 54 - type: string 51 51 + $ref: '#/$defs/name' 55 52 header: 56 53 description: For C-compatible languages, header which already defines this value. 57 54 type: string ··· 78 75 additionalProperties: False 79 76 properties: 80 77 name: 81 81 - type: string 78 78 + $ref: '#/$defs/name' 82 79 value: 83 80 type: integer 84 81 doc: ··· 99 96 name: 100 97 description: | 101 98 Name used when referring to this space in other definitions, not used outside of the spec. 102 102 - type: string 99 99 + $ref: '#/$defs/name' 103 100 name-prefix: 104 101 description: | 105 102 Prefix for the C enum name of the attributes. Default family[name]-set[name]-a- ··· 124 121 additionalProperties: False 125 122 properties: 126 123 name: 127 127 - type: string 124 124 + $ref: '#/$defs/name' 128 125 type: &attr-type 129 126 enum: [ unused, pad, flag, binary, 130 127 uint, sint, u8, u16, u32, u64, s8, s16, s32, s64, ··· 246 243 properties: 247 244 name: 248 245 description: Name of the operation, also defining its C enum value in uAPI. 249 249 - type: string 246 246 + $ref: '#/$defs/name' 250 247 doc: 251 248 description: Documentation for the command. 252 249 type: string ··· 330 327 name: 331 328 description: | 332 329 The name for the group, used to form the define and the value of the define. 333 333 - type: string 330 330 + $ref: '#/$defs/name' 334 331 flags: *cmd_flags 335 332 336 333 kernel-family:

+12 -6

Documentation/netlink/netlink-raw.yaml

reviewed

··· 6 6 7 7 # Common defines 8 8 $defs: 9 9 + name: 10 10 + type: string 11 11 + pattern: ^[0-9a-z-]+$ 12 12 + name-cap: 13 13 + type: string 14 14 + pattern: ^[0-9a-zA-Z-]+$ 9 15 uint: 10 16 type: integer 11 17 minimum: 0 ··· 77 71 additionalProperties: False 78 72 properties: 79 73 name: 80 80 - type: string 74 74 + $ref: '#/$defs/name' 81 75 header: 82 76 description: For C-compatible languages, header which already defines this value. 83 77 type: string ··· 104 98 additionalProperties: False 105 99 properties: 106 100 name: 107 107 - type: string 101 101 + $ref: '#/$defs/name' 108 102 value: 109 103 type: integer 110 104 doc: ··· 130 124 additionalProperties: False 131 125 properties: 132 126 name: 133 133 - type: string 127 127 + $ref: '#/$defs/name-cap' 134 128 type: 135 129 description: | 136 130 The netlink attribute type. Members of type 'binary' or 'pad' ··· 189 183 name: 190 184 description: | 191 185 Name used when referring to this space in other definitions, not used outside of the spec. 192 192 - type: string 186 186 + $ref: '#/$defs/name' 193 187 name-prefix: 194 188 description: | 195 189 Prefix for the C enum name of the attributes. Default family[name]-set[name]-a- ··· 226 220 additionalProperties: False 227 221 properties: 228 222 name: 229 229 - type: string 223 223 + $ref: '#/$defs/name' 230 224 type: &attr-type 231 225 description: The netlink attribute type 232 226 enum: [ unused, pad, flag, binary, bitfield32, ··· 414 408 properties: 415 409 name: 416 410 description: Name of the operation, also defining its C enum value in uAPI. 417 417 - type: string 411 411 + $ref: '#/$defs/name' 418 412 doc: 419 413 description: Documentation for the command. 420 414 type: string

+4 -4

Documentation/netlink/specs/devlink.yaml

reviewed

··· 38 38 - 39 39 name: dsa 40 40 - 41 41 - name: pci_pf 41 41 + name: pci-pf 42 42 - 43 43 - name: pci_vf 43 43 + name: pci-vf 44 44 - 45 45 name: virtual 46 46 - 47 47 name: unused 48 48 - 49 49 - name: pci_sf 49 49 + name: pci-sf 50 50 - 51 51 type: enum 52 52 name: port-fn-state ··· 220 220 - 221 221 name: flag 222 222 - 223 223 - name: nul_string 223 223 + name: nul-string 224 224 value: 10 225 225 - 226 226 name: binary

+1 -1

Documentation/netlink/specs/dpll.yaml

reviewed

··· 188 188 value: 10000 189 189 - 190 190 type: const 191 191 - name: pin-frequency-77_5-khz 191 191 + name: pin-frequency-77-5-khz 192 192 value: 77500 193 193 - 194 194 type: const

+3 -3

Documentation/netlink/specs/ethtool.yaml

reviewed

··· 48 48 name: started 49 49 doc: The firmware flashing process has started. 50 50 - 51 51 - name: in_progress 51 51 + name: in-progress 52 52 doc: The firmware flashing process is in progress. 53 53 - 54 54 name: completed ··· 1422 1422 name: hkey 1423 1423 type: binary 1424 1424 - 1425 1425 - name: input_xfrm 1425 1425 + name: input-xfrm 1426 1426 type: u32 1427 1427 - 1428 1428 name: start-context ··· 2238 2238 - hfunc 2239 2239 - indir 2240 2240 - hkey 2241 2241 - - input_xfrm 2241 2241 + - input-xfrm 2242 2242 dump: 2243 2243 request: 2244 2244 attributes:

+18 -18

Documentation/netlink/specs/fou.yaml

reviewed

··· 15 15 definitions: 16 16 - 17 17 type: enum 18 18 - name: encap_type 18 18 + name: encap-type 19 19 name-prefix: fou-encap- 20 20 enum-name: 21 21 entries: [ unspec, direct, gue ] ··· 43 43 name: type 44 44 type: u8 45 45 - 46 46 - name: remcsum_nopartial 46 46 + name: remcsum-nopartial 47 47 type: flag 48 48 - 49 49 - name: local_v4 49 49 + name: local-v4 50 50 type: u32 51 51 - 52 52 - name: local_v6 52 52 + name: local-v6 53 53 type: binary 54 54 checks: 55 55 min-len: 16 56 56 - 57 57 - name: peer_v4 57 57 + name: peer-v4 58 58 type: u32 59 59 - 60 60 - name: peer_v6 60 60 + name: peer-v6 61 61 type: binary 62 62 checks: 63 63 min-len: 16 64 64 - 65 65 - name: peer_port 65 65 + name: peer-port 66 66 type: u16 67 67 byte-order: big-endian 68 68 - ··· 90 90 - port 91 91 - ipproto 92 92 - type 93 93 - - remcsum_nopartial 94 94 - - local_v4 95 95 - - peer_v4 96 96 - - local_v6 97 97 - - peer_v6 98 98 - - peer_port 93 93 + - remcsum-nopartial 94 94 + - local-v4 95 95 + - peer-v4 96 96 + - local-v6 97 97 + - peer-v6 98 98 + - peer-port 99 99 - ifindex 100 100 101 101 - ··· 112 112 - af 113 113 - ifindex 114 114 - port 115 115 - - peer_port 116 116 - - local_v4 117 117 - - peer_v4 118 118 - - local_v6 119 119 - - peer_v6 115 115 + - peer-port 116 116 + - local-v4 117 117 + - peer-v4 118 118 + - local-v6 119 119 + - peer-v6 120 120 121 121 - 122 122 name: get

+4 -4

Documentation/netlink/specs/mptcp_pm.yaml

reviewed

··· 57 57 doc: >- 58 58 A new subflow has been established. 'error' should not be set. 59 59 Attributes: token, family, loc_id, rem_id, saddr4 | saddr6, daddr4 | 60 60 - daddr6, sport, dport, backup, if_idx [, error]. 60 60 + daddr6, sport, dport, backup, if-idx [, error]. 61 61 - 62 62 name: sub-closed 63 63 doc: >- 64 64 A subflow has been closed. An error (copy of sk_err) could be set if an 65 65 error has been detected for this subflow. 66 66 Attributes: token, family, loc_id, rem_id, saddr4 | saddr6, daddr4 | 67 67 - daddr6, sport, dport, backup, if_idx [, error]. 67 67 + daddr6, sport, dport, backup, if-idx [, error]. 68 68 - 69 69 name: sub-priority 70 70 value: 13 71 71 doc: >- 72 72 The priority of a subflow has changed. 'error' should not be set. 73 73 Attributes: token, family, loc_id, rem_id, saddr4 | saddr6, daddr4 | 74 74 - daddr6, sport, dport, backup, if_idx [, error]. 74 74 + daddr6, sport, dport, backup, if-idx [, error]. 75 75 - 76 76 name: listener-created 77 77 value: 15 ··· 255 255 name: timeout 256 256 type: u32 257 257 - 258 258 - name: if_idx 258 258 + name: if-idx 259 259 type: u32 260 260 - 261 261 name: reset-reason

+2 -2

Documentation/netlink/specs/nfsd.yaml

reviewed

··· 27 27 name: proc 28 28 type: u32 29 29 - 30 30 - name: service_time 30 30 + name: service-time 31 31 type: s64 32 32 - 33 33 name: pad ··· 139 139 - prog 140 140 - version 141 141 - proc 142 142 - - service_time 142 142 + - service-time 143 143 - saddr4 144 144 - daddr4 145 145 - saddr6

+3 -3

Documentation/netlink/specs/ovs_flow.yaml

reviewed

··· 216 216 type: struct 217 217 members: 218 218 - 219 219 - name: nd_target 219 219 + name: nd-target 220 220 type: binary 221 221 len: 16 222 222 byte-order: big-endian ··· 258 258 type: struct 259 259 members: 260 260 - 261 261 - name: vlan_tpid 261 261 + name: vlan-tpid 262 262 type: u16 263 263 byte-order: big-endian 264 264 doc: Tag protocol identifier (TPID) to push. 265 265 - 266 266 - name: vlan_tci 266 266 + name: vlan-tci 267 267 type: u16 268 268 byte-order: big-endian 269 269 doc: Tag control identifier (TCI) to push.

+2 -2

Documentation/netlink/specs/rt-link.yaml

reviewed

··· 603 603 name: optmask 604 604 type: u32 605 605 - 606 606 - name: if_stats_msg 606 606 + name: if-stats-msg 607 607 type: struct 608 608 members: 609 609 - ··· 2486 2486 name: getstats 2487 2487 doc: Get / dump link stats. 2488 2488 attribute-set: stats-attrs 2489 2489 - fixed-header: if_stats_msg 2489 2489 + fixed-header: if-stats-msg 2490 2490 do: 2491 2491 request: 2492 2492 value: 94

+2 -2

Documentation/netlink/specs/tc.yaml

reviewed

··· 232 232 type: u8 233 233 doc: log(P_max / (qth-max - qth-min)) 234 234 - 235 235 - name: Scell_log 235 235 + name: Scell-log 236 236 type: u8 237 237 doc: cell size for idle damping 238 238 - ··· 253 253 name: DPs 254 254 type: u32 255 255 - 256 256 - name: def_DP 256 256 + name: def-DP 257 257 type: u32 258 258 - 259 259 name: grio

+1 -1

Documentation/networking/device_drivers/ethernet/marvell/octeontx2.rst

reviewed

··· 66 66 As mentioned above RVU PF0 is called the admin function (AF), this driver 67 67 supports resource provisioning and configuration of functional blocks. 68 68 Doesn't handle any I/O. It sets up few basic stuff but most of the 69 69 - funcionality is achieved via configuration requests from PFs and VFs. 69 69 + functionality is achieved via configuration requests from PFs and VFs. 70 70 71 71 PF/VFs communicates with AF via a shared memory region (mailbox). Upon 72 72 receiving requests AF does resource provisioning and other HW configuration.

+5

drivers/atm/idt77252.c

reviewed

··· 852 852 853 853 IDT77252_PRV_PADDR(skb) = dma_map_single(&card->pcidev->dev, skb->data, 854 854 skb->len, DMA_TO_DEVICE); 855 855 + if (dma_mapping_error(&card->pcidev->dev, IDT77252_PRV_PADDR(skb))) 856 856 + return -ENOMEM; 855 857 856 858 error = -EINVAL; 857 859 ··· 1859 1857 paddr = dma_map_single(&card->pcidev->dev, skb->data, 1860 1858 skb_end_pointer(skb) - skb->data, 1861 1859 DMA_FROM_DEVICE); 1860 1860 + if (dma_mapping_error(&card->pcidev->dev, paddr)) 1861 1861 + goto outpoolrm; 1862 1862 IDT77252_PRV_PADDR(skb) = paddr; 1863 1863 1864 1864 if (push_rx_skb(card, skb, queue)) { ··· 1875 1871 dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1876 1872 skb_end_pointer(skb) - skb->data, DMA_FROM_DEVICE); 1877 1873 1874 1874 + outpoolrm: 1878 1875 handle = IDT77252_PRV_POOL(skb); 1879 1876 card->sbpool[POOL_QUEUE(handle)].skb[POOL_INDEX(handle)] = NULL; 1880 1877

+31 -2

drivers/bluetooth/btintel_pcie.c

reviewed

··· 2033 2033 data->hdev = NULL; 2034 2034 } 2035 2035 2036 2036 + static void btintel_pcie_disable_interrupts(struct btintel_pcie_data *data) 2037 2037 + { 2038 2038 + spin_lock(&data->irq_lock); 2039 2039 + btintel_pcie_wr_reg32(data, BTINTEL_PCIE_CSR_MSIX_FH_INT_MASK, data->fh_init_mask); 2040 2040 + btintel_pcie_wr_reg32(data, BTINTEL_PCIE_CSR_MSIX_HW_INT_MASK, data->hw_init_mask); 2041 2041 + spin_unlock(&data->irq_lock); 2042 2042 + } 2043 2043 + 2044 2044 + static void btintel_pcie_enable_interrupts(struct btintel_pcie_data *data) 2045 2045 + { 2046 2046 + spin_lock(&data->irq_lock); 2047 2047 + btintel_pcie_wr_reg32(data, BTINTEL_PCIE_CSR_MSIX_FH_INT_MASK, ~data->fh_init_mask); 2048 2048 + btintel_pcie_wr_reg32(data, BTINTEL_PCIE_CSR_MSIX_HW_INT_MASK, ~data->hw_init_mask); 2049 2049 + spin_unlock(&data->irq_lock); 2050 2050 + } 2051 2051 + 2052 2052 + static void btintel_pcie_synchronize_irqs(struct btintel_pcie_data *data) 2053 2053 + { 2054 2054 + for (int i = 0; i < data->alloc_vecs; i++) 2055 2055 + synchronize_irq(data->msix_entries[i].vector); 2056 2056 + } 2057 2057 + 2036 2058 static int btintel_pcie_setup_internal(struct hci_dev *hdev) 2037 2059 { 2038 2060 struct btintel_pcie_data *data = hci_get_drvdata(hdev); ··· 2174 2152 bt_dev_err(hdev, "Firmware download retry count: %d", 2175 2153 fw_dl_retry); 2176 2154 btintel_pcie_dump_debug_registers(hdev); 2155 2155 + btintel_pcie_disable_interrupts(data); 2156 2156 + btintel_pcie_synchronize_irqs(data); 2177 2157 err = btintel_pcie_reset_bt(data); 2178 2158 if (err) { 2179 2159 bt_dev_err(hdev, "Failed to do shr reset: %d", err); ··· 2183 2159 } 2184 2160 usleep_range(10000, 12000); 2185 2161 btintel_pcie_reset_ia(data); 2162 2162 + btintel_pcie_enable_interrupts(data); 2186 2163 btintel_pcie_config_msix(data); 2187 2164 err = btintel_pcie_enable_bt(data); 2188 2165 if (err) { ··· 2316 2291 2317 2292 data = pci_get_drvdata(pdev); 2318 2293 2294 2294 + btintel_pcie_disable_interrupts(data); 2295 2295 + 2296 2296 + btintel_pcie_synchronize_irqs(data); 2297 2297 + 2298 2298 + flush_work(&data->rx_work); 2299 2299 + 2319 2300 btintel_pcie_reset_bt(data); 2320 2301 for (int i = 0; i < data->alloc_vecs; i++) { 2321 2302 struct msix_entry *msix_entry; ··· 2333 2302 pci_free_irq_vectors(pdev); 2334 2303 2335 2304 btintel_pcie_release_hdev(data); 2336 2336 - 2337 2337 - flush_work(&data->rx_work); 2338 2305 2339 2306 destroy_workqueue(data->workqueue); 2340 2307

+10 -3

drivers/bluetooth/hci_qca.c

reviewed

··· 2392 2392 */ 2393 2393 qcadev->bt_power->pwrseq = devm_pwrseq_get(&serdev->dev, 2394 2394 "bluetooth"); 2395 2395 - if (IS_ERR(qcadev->bt_power->pwrseq)) 2396 2396 - return PTR_ERR(qcadev->bt_power->pwrseq); 2397 2395 2398 2398 - break; 2396 2396 + /* 2397 2397 + * Some modules have BT_EN enabled via a hardware pull-up, 2398 2398 + * meaning it is not defined in the DTS and is not controlled 2399 2399 + * through the power sequence. In such cases, fall through 2400 2400 + * to follow the legacy flow. 2401 2401 + */ 2402 2402 + if (IS_ERR(qcadev->bt_power->pwrseq)) 2403 2403 + qcadev->bt_power->pwrseq = NULL; 2404 2404 + else 2405 2405 + break; 2399 2406 } 2400 2407 fallthrough; 2401 2408 case QCA_WCN3950:

+4 -1

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

reviewed

··· 2989 2989 { 2990 2990 struct bnxt_napi *bnapi = cpr->bnapi; 2991 2991 u32 raw_cons = cpr->cp_raw_cons; 2992 2992 + bool flush_xdp = false; 2992 2993 u32 cons; 2993 2994 int rx_pkts = 0; 2994 2995 u8 event = 0; ··· 3043 3042 else 3044 3043 rc = bnxt_force_rx_discard(bp, cpr, &raw_cons, 3045 3044 &event); 3045 3045 + if (event & BNXT_REDIRECT_EVENT) 3046 3046 + flush_xdp = true; 3046 3047 if (likely(rc >= 0)) 3047 3048 rx_pkts += rc; 3048 3049 /* Increment rx_pkts when rc is -ENOMEM to count towards ··· 3069 3066 } 3070 3067 } 3071 3068 3072 3072 - if (event & BNXT_REDIRECT_EVENT) { 3069 3069 + if (flush_xdp) { 3073 3070 xdp_do_flush(); 3074 3071 event &= ~BNXT_REDIRECT_EVENT; 3075 3072 }

+1 -1

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

reviewed

··· 507 507 tmp = ioread32(reg + 4); 508 508 } while (high != tmp); 509 509 510 510 - return le64_to_cpu((__le64)high << 32 | low); 510 510 + return (u64)high << 32 | low; 511 511 } 512 512 #endif 513 513

+3

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

reviewed

··· 31 31 gc->db_page_base = gc->bar0_va + 32 32 mana_gd_r64(gc, GDMA_PF_REG_DB_PAGE_OFF); 33 33 34 34 + gc->phys_db_page_base = gc->bar0_pa + 35 35 + mana_gd_r64(gc, GDMA_PF_REG_DB_PAGE_OFF); 36 36 + 34 37 sriov_base_off = mana_gd_r64(gc, GDMA_SRIOV_REG_CFG_BASE_OFF); 35 38 36 39 sriov_base_va = gc->bar0_va + sriov_base_off;

+6 -6

drivers/net/ethernet/pensando/ionic/ionic_txrx.c

reviewed

··· 321 321 len, DMA_TO_DEVICE); 322 322 } else /* XDP_REDIRECT */ { 323 323 dma_addr = ionic_tx_map_single(q, frame->data, len); 324 324 - if (!dma_addr) 324 324 + if (dma_addr == DMA_MAPPING_ERROR) 325 325 return -EIO; 326 326 } 327 327 ··· 357 357 } else { 358 358 dma_addr = ionic_tx_map_frag(q, frag, 0, 359 359 skb_frag_size(frag)); 360 360 - if (dma_mapping_error(q->dev, dma_addr)) { 360 360 + if (dma_addr == DMA_MAPPING_ERROR) { 361 361 ionic_tx_desc_unmap_bufs(q, desc_info); 362 362 return -EIO; 363 363 } ··· 1083 1083 net_warn_ratelimited("%s: DMA single map failed on %s!\n", 1084 1084 dev_name(dev), q->name); 1085 1085 q_to_tx_stats(q)->dma_map_err++; 1086 1086 - return 0; 1086 1086 + return DMA_MAPPING_ERROR; 1087 1087 } 1088 1088 return dma_addr; 1089 1089 } ··· 1100 1100 net_warn_ratelimited("%s: DMA frag map failed on %s!\n", 1101 1101 dev_name(dev), q->name); 1102 1102 q_to_tx_stats(q)->dma_map_err++; 1103 1103 - return 0; 1103 1103 + return DMA_MAPPING_ERROR; 1104 1104 } 1105 1105 return dma_addr; 1106 1106 } ··· 1116 1116 int frag_idx; 1117 1117 1118 1118 dma_addr = ionic_tx_map_single(q, skb->data, skb_headlen(skb)); 1119 1119 - if (!dma_addr) 1119 1119 + if (dma_addr == DMA_MAPPING_ERROR) 1120 1120 return -EIO; 1121 1121 buf_info->dma_addr = dma_addr; 1122 1122 buf_info->len = skb_headlen(skb); ··· 1126 1126 nfrags = skb_shinfo(skb)->nr_frags; 1127 1127 for (frag_idx = 0; frag_idx < nfrags; frag_idx++, frag++) { 1128 1128 dma_addr = ionic_tx_map_frag(q, frag, 0, skb_frag_size(frag)); 1129 1129 - if (!dma_addr) 1129 1129 + if (dma_addr == DMA_MAPPING_ERROR) 1130 1130 goto dma_fail; 1131 1131 buf_info->dma_addr = dma_addr; 1132 1132 buf_info->len = skb_frag_size(frag);

+4 -4

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

reviewed

··· 242 242 } 243 243 244 244 /* Returns size of the data buffer or, -1 in case TLV data is not available. */ 245 245 - static int 245 245 + static noinline_for_stack int 246 246 qed_mfw_get_gen_tlv_value(struct qed_drv_tlv_hdr *p_tlv, 247 247 struct qed_mfw_tlv_generic *p_drv_buf, 248 248 struct qed_tlv_parsed_buf *p_buf) ··· 304 304 return -1; 305 305 } 306 306 307 307 - static int 307 307 + static noinline_for_stack int 308 308 qed_mfw_get_eth_tlv_value(struct qed_drv_tlv_hdr *p_tlv, 309 309 struct qed_mfw_tlv_eth *p_drv_buf, 310 310 struct qed_tlv_parsed_buf *p_buf) ··· 438 438 return QED_MFW_TLV_TIME_SIZE; 439 439 } 440 440 441 441 - static int 441 441 + static noinline_for_stack int 442 442 qed_mfw_get_fcoe_tlv_value(struct qed_drv_tlv_hdr *p_tlv, 443 443 struct qed_mfw_tlv_fcoe *p_drv_buf, 444 444 struct qed_tlv_parsed_buf *p_buf) ··· 1073 1073 return -1; 1074 1074 } 1075 1075 1076 1076 - static int 1076 1076 + static noinline_for_stack int 1077 1077 qed_mfw_get_iscsi_tlv_value(struct qed_drv_tlv_hdr *p_tlv, 1078 1078 struct qed_mfw_tlv_iscsi *p_drv_buf, 1079 1079 struct qed_tlv_parsed_buf *p_buf)

+1 -1

drivers/net/ethernet/wangxun/libwx/wx_lib.c

reviewed

··· 2623 2623 struct page_pool_params pp_params = { 2624 2624 .flags = PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV, 2625 2625 .order = 0, 2626 2626 - .pool_size = rx_ring->size, 2626 2626 + .pool_size = rx_ring->count, 2627 2627 .nid = dev_to_node(rx_ring->dev), 2628 2628 .dev = rx_ring->dev, 2629 2629 .dma_dir = DMA_FROM_DEVICE,

+1

drivers/net/usb/qmi_wwan.c

reviewed

··· 1426 1426 {QMI_QUIRK_SET_DTR(0x22de, 0x9051, 2)}, /* Hucom Wireless HM-211S/K */ 1427 1427 {QMI_FIXED_INTF(0x22de, 0x9061, 3)}, /* WeTelecom WPD-600N */ 1428 1428 {QMI_QUIRK_SET_DTR(0x1e0e, 0x9001, 5)}, /* SIMCom 7100E, 7230E, 7600E ++ */ 1429 1429 + {QMI_QUIRK_SET_DTR(0x1e0e, 0x9071, 3)}, /* SIMCom 8230C ++ */ 1429 1430 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0121, 4)}, /* Quectel EC21 Mini PCIe */ 1430 1431 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0191, 4)}, /* Quectel EG91 */ 1431 1432 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0195, 4)}, /* Quectel EG95 */

+2 -1

drivers/net/wireless/intel/iwlegacy/4965-rs.c

reviewed

··· 203 203 return (u8) (rate_n_flags & 0xFF); 204 204 } 205 205 206 206 - static void 206 206 + /* noinline works around https://github.com/llvm/llvm-project/issues/143908 */ 207 207 + static noinline_for_stack void 207 208 il4965_rs_rate_scale_clear_win(struct il_rate_scale_data *win) 208 209 { 209 210 win->data = 0;

+2 -2

drivers/net/wireless/intel/iwlwifi/mvm/mld-mac.c

reviewed

··· 32 32 unsigned int link_id; 33 33 int cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw, 34 34 WIDE_ID(MAC_CONF_GROUP, 35 35 - MAC_CONFIG_CMD), 0); 35 35 + MAC_CONFIG_CMD), 1); 36 36 37 37 - if (WARN_ON(cmd_ver < 1 || cmd_ver > 3)) 37 37 + if (WARN_ON(cmd_ver > 3)) 38 38 return; 39 39 40 40 cmd->id_and_color = cpu_to_le32(mvmvif->id);

+2

include/net/bluetooth/hci_core.h

reviewed

··· 29 29 #include <linux/idr.h> 30 30 #include <linux/leds.h> 31 31 #include <linux/rculist.h> 32 32 + #include <linux/srcu.h> 32 33 33 34 #include <net/bluetooth/hci.h> 34 35 #include <net/bluetooth/hci_drv.h> ··· 348 347 349 348 struct hci_dev { 350 349 struct list_head list; 350 350 + struct srcu_struct srcu; 351 351 struct mutex lock; 352 352 353 353 struct ida unset_handle_ida;

+3 -3

include/uapi/linux/mptcp_pm.h

reviewed

··· 27 27 * token, rem_id. 28 28 * @MPTCP_EVENT_SUB_ESTABLISHED: A new subflow has been established. 'error' 29 29 * should not be set. Attributes: token, family, loc_id, rem_id, saddr4 | 30 30 - * saddr6, daddr4 | daddr6, sport, dport, backup, if_idx [, error]. 30 30 + * saddr6, daddr4 | daddr6, sport, dport, backup, if-idx [, error]. 31 31 * @MPTCP_EVENT_SUB_CLOSED: A subflow has been closed. An error (copy of 32 32 * sk_err) could be set if an error has been detected for this subflow. 33 33 * Attributes: token, family, loc_id, rem_id, saddr4 | saddr6, daddr4 | 34 34 - * daddr6, sport, dport, backup, if_idx [, error]. 34 34 + * daddr6, sport, dport, backup, if-idx [, error]. 35 35 * @MPTCP_EVENT_SUB_PRIORITY: The priority of a subflow has changed. 'error' 36 36 * should not be set. Attributes: token, family, loc_id, rem_id, saddr4 | 37 37 - * saddr6, daddr4 | daddr6, sport, dport, backup, if_idx [, error]. 37 37 + * saddr6, daddr4 | daddr6, sport, dport, backup, if-idx [, error]. 38 38 * @MPTCP_EVENT_LISTENER_CREATED: A new PM listener is created. Attributes: 39 39 * family, sport, saddr4 | saddr6. 40 40 * @MPTCP_EVENT_LISTENER_CLOSED: A PM listener is closed. Attributes: family,

+4

include/uapi/linux/vm_sockets.h

reviewed

··· 17 17 #ifndef _UAPI_VM_SOCKETS_H 18 18 #define _UAPI_VM_SOCKETS_H 19 19 20 20 + #ifndef __KERNEL__ 21 21 + #include <sys/socket.h> /* for struct sockaddr and sa_family_t */ 22 22 + #endif 23 23 + 20 24 #include <linux/socket.h> 21 25 #include <linux/types.h> 22 26

+5 -6

net/atm/clip.c

reviewed

··· 193 193 194 194 pr_debug("\n"); 195 195 196 196 - if (!clip_devs) { 197 197 - atm_return(vcc, skb->truesize); 198 198 - kfree_skb(skb); 199 199 - return; 200 200 - } 201 201 - 202 196 if (!skb) { 203 197 pr_debug("removing VCC %p\n", clip_vcc); 204 198 if (clip_vcc->entry) ··· 202 208 return; 203 209 } 204 210 atm_return(vcc, skb->truesize); 211 211 + if (!clip_devs) { 212 212 + kfree_skb(skb); 213 213 + return; 214 214 + } 215 215 + 205 216 skb->dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : clip_devs; 206 217 /* clip_vcc->entry == NULL if we don't have an IP address yet */ 207 218 if (!skb->dev) {

+1 -2

net/atm/resources.c

reviewed

··· 146 146 */ 147 147 mutex_lock(&atm_dev_mutex); 148 148 list_del(&dev->dev_list); 149 149 - mutex_unlock(&atm_dev_mutex); 150 150 - 151 149 atm_dev_release_vccs(dev); 152 150 atm_unregister_sysfs(dev); 153 151 atm_proc_dev_deregister(dev); 152 152 + mutex_unlock(&atm_dev_mutex); 154 153 155 154 atm_dev_put(dev); 156 155 }

+30 -4

net/bluetooth/hci_core.c

reviewed

··· 64 64 65 65 /* Get HCI device by index. 66 66 * Device is held on return. */ 67 67 - struct hci_dev *hci_dev_get(int index) 67 67 + static struct hci_dev *__hci_dev_get(int index, int *srcu_index) 68 68 { 69 69 struct hci_dev *hdev = NULL, *d; 70 70 ··· 77 77 list_for_each_entry(d, &hci_dev_list, list) { 78 78 if (d->id == index) { 79 79 hdev = hci_dev_hold(d); 80 80 + if (srcu_index) 81 81 + *srcu_index = srcu_read_lock(&d->srcu); 80 82 break; 81 83 } 82 84 } 83 85 read_unlock(&hci_dev_list_lock); 84 86 return hdev; 87 87 + } 88 88 + 89 89 + struct hci_dev *hci_dev_get(int index) 90 90 + { 91 91 + return __hci_dev_get(index, NULL); 92 92 + } 93 93 + 94 94 + static struct hci_dev *hci_dev_get_srcu(int index, int *srcu_index) 95 95 + { 96 96 + return __hci_dev_get(index, srcu_index); 97 97 + } 98 98 + 99 99 + static void hci_dev_put_srcu(struct hci_dev *hdev, int srcu_index) 100 100 + { 101 101 + srcu_read_unlock(&hdev->srcu, srcu_index); 102 102 + hci_dev_put(hdev); 85 103 } 86 104 87 105 /* ---- Inquiry support ---- */ ··· 586 568 int hci_dev_reset(__u16 dev) 587 569 { 588 570 struct hci_dev *hdev; 589 589 - int err; 571 571 + int err, srcu_index; 590 572 591 591 - hdev = hci_dev_get(dev); 573 573 + hdev = hci_dev_get_srcu(dev, &srcu_index); 592 574 if (!hdev) 593 575 return -ENODEV; 594 576 ··· 610 592 err = hci_dev_do_reset(hdev); 611 593 612 594 done: 613 613 - hci_dev_put(hdev); 595 595 + hci_dev_put_srcu(hdev, srcu_index); 614 596 return err; 615 597 } 616 598 ··· 2451 2433 if (!hdev) 2452 2434 return NULL; 2453 2435 2436 2436 + if (init_srcu_struct(&hdev->srcu)) { 2437 2437 + kfree(hdev); 2438 2438 + return NULL; 2439 2439 + } 2440 2440 + 2454 2441 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2455 2442 hdev->esco_type = (ESCO_HV1); 2456 2443 hdev->link_mode = (HCI_LM_ACCEPT); ··· 2700 2677 write_lock(&hci_dev_list_lock); 2701 2678 list_del(&hdev->list); 2702 2679 write_unlock(&hci_dev_list_lock); 2680 2680 + 2681 2681 + synchronize_srcu(&hdev->srcu); 2682 2682 + cleanup_srcu_struct(&hdev->srcu); 2703 2683 2704 2684 disable_work_sync(&hdev->rx_work); 2705 2685 disable_work_sync(&hdev->cmd_work);

+8 -1

net/bluetooth/l2cap_core.c

reviewed

··· 3415 3415 struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 3416 3416 struct l2cap_conf_efs efs; 3417 3417 u8 remote_efs = 0; 3418 3418 - u16 mtu = L2CAP_DEFAULT_MTU; 3418 3418 + u16 mtu = 0; 3419 3419 u16 result = L2CAP_CONF_SUCCESS; 3420 3420 u16 size; 3421 3421 ··· 3519 3519 if (result == L2CAP_CONF_SUCCESS) { 3520 3520 /* Configure output options and let the other side know 3521 3521 * which ones we don't like. */ 3522 3522 + 3523 3523 + /* If MTU is not provided in configure request, use the most recently 3524 3524 + * explicitly or implicitly accepted value for the other direction, 3525 3525 + * or the default value. 3526 3526 + */ 3527 3527 + if (mtu == 0) 3528 3528 + mtu = chan->imtu ? chan->imtu : L2CAP_DEFAULT_MTU; 3522 3529 3523 3530 if (mtu < L2CAP_DEFAULT_MIN_MTU) 3524 3531 result = L2CAP_CONF_UNACCEPT;

+9

net/bridge/br_multicast.c

reviewed

··· 2015 2015 2016 2016 void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx) 2017 2017 { 2018 2018 + struct net_bridge *br = pmctx->port->br; 2019 2019 + bool del = false; 2020 2020 + 2018 2021 #if IS_ENABLED(CONFIG_IPV6) 2019 2022 timer_delete_sync(&pmctx->ip6_mc_router_timer); 2020 2023 #endif 2021 2024 timer_delete_sync(&pmctx->ip4_mc_router_timer); 2025 2025 + 2026 2026 + spin_lock_bh(&br->multicast_lock); 2027 2027 + del |= br_ip6_multicast_rport_del(pmctx); 2028 2028 + del |= br_ip4_multicast_rport_del(pmctx); 2029 2029 + br_multicast_rport_del_notify(pmctx, del); 2030 2030 + spin_unlock_bh(&br->multicast_lock); 2022 2031 } 2023 2032 2024 2033 int br_multicast_add_port(struct net_bridge_port *port)

+1 -1

net/core/netpoll.c

reviewed

··· 432 432 udph->dest = htons(np->remote_port); 433 433 udph->len = htons(udp_len); 434 434 435 435 + udph->check = 0; 435 436 if (np->ipv6) { 436 437 udph->check = csum_ipv6_magic(&np->local_ip.in6, 437 438 &np->remote_ip.in6, ··· 461 460 skb_reset_mac_header(skb); 462 461 skb->protocol = eth->h_proto = htons(ETH_P_IPV6); 463 462 } else { 464 464 - udph->check = 0; 465 463 udph->check = csum_tcpudp_magic(np->local_ip.ip, 466 464 np->remote_ip.ip, 467 465 udp_len, IPPROTO_UDP,

+3 -2

net/core/selftests.c

reviewed

··· 160 160 skb->csum = 0; 161 161 skb->ip_summed = CHECKSUM_PARTIAL; 162 162 if (attr->tcp) { 163 163 - thdr->check = ~tcp_v4_check(skb->len, ihdr->saddr, 164 164 - ihdr->daddr, 0); 163 163 + int l4len = skb->len - skb_transport_offset(skb); 164 164 + 165 165 + thdr->check = ~tcp_v4_check(l4len, ihdr->saddr, ihdr->daddr, 0); 165 166 skb->csum_start = skb_transport_header(skb) - skb->head; 166 167 skb->csum_offset = offsetof(struct tcphdr, check); 167 168 } else {

+3 -3

net/mac80211/link.c

reviewed

··· 93 93 if (link_id < 0) 94 94 link_id = 0; 95 95 96 96 - rcu_assign_pointer(sdata->vif.link_conf[link_id], link_conf); 97 97 - rcu_assign_pointer(sdata->link[link_id], link); 98 98 - 99 96 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 100 97 struct ieee80211_sub_if_data *ap_bss; 101 98 struct ieee80211_bss_conf *ap_bss_conf; ··· 142 145 143 146 ieee80211_link_debugfs_add(link); 144 147 } 148 148 + 149 149 + rcu_assign_pointer(sdata->vif.link_conf[link_id], link_conf); 150 150 + rcu_assign_pointer(sdata->link[link_id], link); 145 151 } 146 152 147 153 void ieee80211_link_stop(struct ieee80211_link_data *link)

+1 -1

net/mac80211/util.c

reviewed

··· 3884 3884 { 3885 3885 u64 tsf = drv_get_tsf(local, sdata); 3886 3886 u64 dtim_count = 0; 3887 3887 - u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024; 3887 3887 + u32 beacon_int = sdata->vif.bss_conf.beacon_int * 1024; 3888 3888 u8 dtim_period = sdata->vif.bss_conf.dtim_period; 3889 3889 struct ps_data *ps; 3890 3890 u8 bcns_from_dtim;

+23 -8

net/unix/af_unix.c

reviewed

··· 660 660 #endif 661 661 } 662 662 663 663 + static unsigned int unix_skb_len(const struct sk_buff *skb) 664 664 + { 665 665 + return skb->len - UNIXCB(skb).consumed; 666 666 + } 667 667 + 663 668 static void unix_release_sock(struct sock *sk, int embrion) 664 669 { 665 670 struct unix_sock *u = unix_sk(sk); ··· 699 694 700 695 if (skpair != NULL) { 701 696 if (sk->sk_type == SOCK_STREAM || sk->sk_type == SOCK_SEQPACKET) { 697 697 + struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); 698 698 + 699 699 + #if IS_ENABLED(CONFIG_AF_UNIX_OOB) 700 700 + if (skb && !unix_skb_len(skb)) 701 701 + skb = skb_peek_next(skb, &sk->sk_receive_queue); 702 702 + #endif 702 703 unix_state_lock(skpair); 703 704 /* No more writes */ 704 705 WRITE_ONCE(skpair->sk_shutdown, SHUTDOWN_MASK); 705 705 - if (!skb_queue_empty_lockless(&sk->sk_receive_queue) || embrion) 706 706 + if (skb || embrion) 706 707 WRITE_ONCE(skpair->sk_err, ECONNRESET); 707 708 unix_state_unlock(skpair); 708 709 skpair->sk_state_change(skpair); ··· 2672 2661 return timeo; 2673 2662 } 2674 2663 2675 2675 - static unsigned int unix_skb_len(const struct sk_buff *skb) 2676 2676 - { 2677 2677 - return skb->len - UNIXCB(skb).consumed; 2678 2678 - } 2679 2679 - 2680 2664 struct unix_stream_read_state { 2681 2665 int (*recv_actor)(struct sk_buff *, int, int, 2682 2666 struct unix_stream_read_state *); ··· 2686 2680 #if IS_ENABLED(CONFIG_AF_UNIX_OOB) 2687 2681 static int unix_stream_recv_urg(struct unix_stream_read_state *state) 2688 2682 { 2683 2683 + struct sk_buff *oob_skb, *read_skb = NULL; 2689 2684 struct socket *sock = state->socket; 2690 2685 struct sock *sk = sock->sk; 2691 2686 struct unix_sock *u = unix_sk(sk); 2692 2687 int chunk = 1; 2693 2693 - struct sk_buff *oob_skb; 2694 2688 2695 2689 mutex_lock(&u->iolock); 2696 2690 unix_state_lock(sk); ··· 2705 2699 2706 2700 oob_skb = u->oob_skb; 2707 2701 2708 2708 - if (!(state->flags & MSG_PEEK)) 2702 2702 + if (!(state->flags & MSG_PEEK)) { 2709 2703 WRITE_ONCE(u->oob_skb, NULL); 2704 2704 + 2705 2705 + if (oob_skb->prev != (struct sk_buff *)&sk->sk_receive_queue && 2706 2706 + !unix_skb_len(oob_skb->prev)) { 2707 2707 + read_skb = oob_skb->prev; 2708 2708 + __skb_unlink(read_skb, &sk->sk_receive_queue); 2709 2709 + } 2710 2710 + } 2710 2711 2711 2712 spin_unlock(&sk->sk_receive_queue.lock); 2712 2713 unix_state_unlock(sk); ··· 2724 2711 UNIXCB(oob_skb).consumed += 1; 2725 2712 2726 2713 mutex_unlock(&u->iolock); 2714 2714 + 2715 2715 + consume_skb(read_skb); 2727 2716 2728 2717 if (chunk < 0) 2729 2718 return -EFAULT;

+1 -1

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

reviewed

··· 38 38 raise KsftSkipEx("socket.SO_INCOMING_CPU was added in Python 3.11") 39 39 40 40 input_xfrm = cfg.ethnl.rss_get( 41 41 - {'header': {'dev-name': cfg.ifname}}).get('input_xfrm') 41 41 + {'header': {'dev-name': cfg.ifname}}).get('input-xfrm') 42 42 43 43 # Check for symmetric xor/or-xor 44 44 if not input_xfrm or (input_xfrm != 1 and input_xfrm != 2):

+138 -4

tools/testing/selftests/net/af_unix/msg_oob.c

reviewed

··· 210 210 static void __recvpair(struct __test_metadata *_metadata, 211 211 FIXTURE_DATA(msg_oob) *self, 212 212 const char *expected_buf, int expected_len, 213 213 - int buf_len, int flags) 213 213 + int buf_len, int flags, bool is_sender) 214 214 { 215 215 int i, ret[2], recv_errno[2], expected_errno = 0; 216 216 char recv_buf[2][BUF_SZ] = {}; ··· 221 221 errno = 0; 222 222 223 223 for (i = 0; i < 2; i++) { 224 224 - ret[i] = recv(self->fd[i * 2 + 1], recv_buf[i], buf_len, flags); 224 224 + int index = is_sender ? i * 2 : i * 2 + 1; 225 225 + 226 226 + ret[i] = recv(self->fd[index], recv_buf[i], buf_len, flags); 225 227 recv_errno[i] = errno; 226 228 } 227 229 ··· 310 308 ASSERT_EQ(answ[0], answ[1]); 311 309 } 312 310 311 311 + static void __resetpair(struct __test_metadata *_metadata, 312 312 + FIXTURE_DATA(msg_oob) *self, 313 313 + const FIXTURE_VARIANT(msg_oob) *variant, 314 314 + bool reset) 315 315 + { 316 316 + int i; 317 317 + 318 318 + for (i = 0; i < 2; i++) 319 319 + close(self->fd[i * 2 + 1]); 320 320 + 321 321 + __recvpair(_metadata, self, "", reset ? -ECONNRESET : 0, 1, 322 322 + variant->peek ? MSG_PEEK : 0, true); 323 323 + } 324 324 + 313 325 #define sendpair(buf, len, flags) \ 314 326 __sendpair(_metadata, self, buf, len, flags) 315 327 ··· 332 316 if (variant->peek) \ 333 317 __recvpair(_metadata, self, \ 334 318 expected_buf, expected_len, \ 335 335 - buf_len, (flags) | MSG_PEEK); \ 319 319 + buf_len, (flags) | MSG_PEEK, false); \ 336 320 __recvpair(_metadata, self, \ 337 337 - expected_buf, expected_len, buf_len, flags); \ 321 321 + expected_buf, expected_len, \ 322 322 + buf_len, flags, false); \ 338 323 } while (0) 339 324 340 325 #define epollpair(oob_remaining) \ ··· 346 329 347 330 #define setinlinepair() \ 348 331 __setinlinepair(_metadata, self) 332 332 + 333 333 + #define resetpair(reset) \ 334 334 + __resetpair(_metadata, self, variant, reset) 349 335 350 336 #define tcp_incompliant \ 351 337 for (self->tcp_compliant = false; \ ··· 364 344 recvpair("", -EINVAL, 1, MSG_OOB); 365 345 epollpair(false); 366 346 siocatmarkpair(false); 347 347 + 348 348 + resetpair(true); 349 349 + } 350 350 + 351 351 + TEST_F(msg_oob, non_oob_no_reset) 352 352 + { 353 353 + sendpair("x", 1, 0); 354 354 + epollpair(false); 355 355 + siocatmarkpair(false); 356 356 + 357 357 + recvpair("x", 1, 1, 0); 358 358 + epollpair(false); 359 359 + siocatmarkpair(false); 360 360 + 361 361 + resetpair(false); 367 362 } 368 363 369 364 TEST_F(msg_oob, oob) ··· 390 355 recvpair("x", 1, 1, MSG_OOB); 391 356 epollpair(false); 392 357 siocatmarkpair(true); 358 358 + 359 359 + tcp_incompliant { 360 360 + resetpair(false); /* TCP sets -ECONNRESET for ex-OOB. */ 361 361 + } 362 362 + } 363 363 + 364 364 + TEST_F(msg_oob, oob_reset) 365 365 + { 366 366 + sendpair("x", 1, MSG_OOB); 367 367 + epollpair(true); 368 368 + siocatmarkpair(true); 369 369 + 370 370 + resetpair(true); 393 371 } 394 372 395 373 TEST_F(msg_oob, oob_drop) ··· 418 370 recvpair("", -EINVAL, 1, MSG_OOB); 419 371 epollpair(false); 420 372 siocatmarkpair(false); 373 373 + 374 374 + resetpair(false); 421 375 } 422 376 423 377 TEST_F(msg_oob, oob_ahead) ··· 435 385 recvpair("hell", 4, 4, 0); 436 386 epollpair(false); 437 387 siocatmarkpair(true); 388 388 + 389 389 + tcp_incompliant { 390 390 + resetpair(false); /* TCP sets -ECONNRESET for ex-OOB. */ 391 391 + } 438 392 } 439 393 440 394 TEST_F(msg_oob, oob_break) ··· 457 403 458 404 recvpair("", -EAGAIN, 1, 0); 459 405 siocatmarkpair(false); 406 406 + 407 407 + resetpair(false); 460 408 } 461 409 462 410 TEST_F(msg_oob, oob_ahead_break) ··· 482 426 recvpair("world", 5, 5, 0); 483 427 epollpair(false); 484 428 siocatmarkpair(false); 429 429 + 430 430 + resetpair(false); 485 431 } 486 432 487 433 TEST_F(msg_oob, oob_break_drop) ··· 507 449 recvpair("", -EINVAL, 1, MSG_OOB); 508 450 epollpair(false); 509 451 siocatmarkpair(false); 452 452 + 453 453 + resetpair(false); 510 454 } 511 455 512 456 TEST_F(msg_oob, ex_oob_break) ··· 536 476 recvpair("ld", 2, 2, 0); 537 477 epollpair(false); 538 478 siocatmarkpair(false); 479 479 + 480 480 + resetpair(false); 539 481 } 540 482 541 483 TEST_F(msg_oob, ex_oob_drop) ··· 560 498 epollpair(false); 561 499 siocatmarkpair(true); 562 500 } 501 501 + 502 502 + resetpair(false); 563 503 } 564 504 565 505 TEST_F(msg_oob, ex_oob_drop_2) ··· 587 523 epollpair(false); 588 524 siocatmarkpair(true); 589 525 } 526 526 + 527 527 + resetpair(false); 590 528 } 591 529 592 530 TEST_F(msg_oob, ex_oob_oob) ··· 612 546 recvpair("", -EINVAL, 1, MSG_OOB); 613 547 epollpair(false); 614 548 siocatmarkpair(false); 549 549 + 550 550 + resetpair(false); 551 551 + } 552 552 + 553 553 + TEST_F(msg_oob, ex_oob_ex_oob) 554 554 + { 555 555 + sendpair("x", 1, MSG_OOB); 556 556 + epollpair(true); 557 557 + siocatmarkpair(true); 558 558 + 559 559 + recvpair("x", 1, 1, MSG_OOB); 560 560 + epollpair(false); 561 561 + siocatmarkpair(true); 562 562 + 563 563 + sendpair("y", 1, MSG_OOB); 564 564 + epollpair(true); 565 565 + siocatmarkpair(true); 566 566 + 567 567 + recvpair("y", 1, 1, MSG_OOB); 568 568 + epollpair(false); 569 569 + siocatmarkpair(true); 570 570 + 571 571 + tcp_incompliant { 572 572 + resetpair(false); /* TCP sets -ECONNRESET for ex-OOB. */ 573 573 + } 574 574 + } 575 575 + 576 576 + TEST_F(msg_oob, ex_oob_ex_oob_oob) 577 577 + { 578 578 + sendpair("x", 1, MSG_OOB); 579 579 + epollpair(true); 580 580 + siocatmarkpair(true); 581 581 + 582 582 + recvpair("x", 1, 1, MSG_OOB); 583 583 + epollpair(false); 584 584 + siocatmarkpair(true); 585 585 + 586 586 + sendpair("y", 1, MSG_OOB); 587 587 + epollpair(true); 588 588 + siocatmarkpair(true); 589 589 + 590 590 + recvpair("y", 1, 1, MSG_OOB); 591 591 + epollpair(false); 592 592 + siocatmarkpair(true); 593 593 + 594 594 + sendpair("z", 1, MSG_OOB); 595 595 + epollpair(true); 596 596 + siocatmarkpair(true); 615 597 } 616 598 617 599 TEST_F(msg_oob, ex_oob_ahead_break) ··· 690 576 recvpair("d", 1, 1, MSG_OOB); 691 577 epollpair(false); 692 578 siocatmarkpair(true); 579 579 + 580 580 + tcp_incompliant { 581 581 + resetpair(false); /* TCP sets -ECONNRESET for ex-OOB. */ 582 582 + } 693 583 } 694 584 695 585 TEST_F(msg_oob, ex_oob_siocatmark) ··· 713 595 recvpair("hell", 4, 4, 0); /* Intentionally stop at ex-OOB. */ 714 596 epollpair(true); 715 597 siocatmarkpair(false); 598 598 + 599 599 + resetpair(true); 716 600 } 717 601 718 602 TEST_F(msg_oob, inline_oob) ··· 732 612 recvpair("x", 1, 1, 0); 733 613 epollpair(false); 734 614 siocatmarkpair(false); 615 615 + 616 616 + resetpair(false); 735 617 } 736 618 737 619 TEST_F(msg_oob, inline_oob_break) ··· 755 633 recvpair("o", 1, 1, 0); 756 634 epollpair(false); 757 635 siocatmarkpair(false); 636 636 + 637 637 + resetpair(false); 758 638 } 759 639 760 640 TEST_F(msg_oob, inline_oob_ahead_break) ··· 785 661 786 662 epollpair(false); 787 663 siocatmarkpair(false); 664 664 + 665 665 + resetpair(false); 788 666 } 789 667 790 668 TEST_F(msg_oob, inline_ex_oob_break) ··· 812 686 recvpair("rld", 3, 3, 0); 813 687 epollpair(false); 814 688 siocatmarkpair(false); 689 689 + 690 690 + resetpair(false); 815 691 } 816 692 817 693 TEST_F(msg_oob, inline_ex_oob_no_drop) ··· 835 707 recvpair("y", 1, 1, 0); 836 708 epollpair(false); 837 709 siocatmarkpair(false); 710 710 + 711 711 + resetpair(false); 838 712 } 839 713 840 714 TEST_F(msg_oob, inline_ex_oob_drop) ··· 861 731 epollpair(false); 862 732 siocatmarkpair(false); 863 733 } 734 734 + 735 735 + resetpair(false); 864 736 } 865 737 866 738 TEST_F(msg_oob, inline_ex_oob_siocatmark) ··· 884 752 recvpair("hell", 4, 4, 0); /* Intentionally stop at ex-OOB. */ 885 753 epollpair(true); 886 754 siocatmarkpair(false); 755 755 + 756 756 + resetpair(true); 887 757 } 888 758 889 759 TEST_HARNESS_MAIN