Unified · Split
| @@ -156,6 +156,8 @@ Morten Welinder <welinder@darter.rentec.com> · 155 unmodified lines | ||
| 156 | 156 | Morten Welinder <welinder@troll.com> |
| 157 | 157 | Mythri P K <mythripk@ti.com> |
| 158 | 158 | Nguyen Anh Quynh <aquynh@gmail.com> |
| 159 | +Nicolas Pitre <nico@fluxnic.net> <nicolas.pitre@linaro.org> | |
| 160 | +Nicolas Pitre <nico@fluxnic.net> <nico@linaro.org> | |
| 159 | 161 | Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it> |
| 160 | 162 | Patrick Mochel <mochel@digitalimplant.org> |
| 161 | 163 | Paul Burton <paul.burton@mips.com> <paul.burton@imgtec.com> |
| @@ -56,12 +56,12 @@ situation from a state where some tasks are stalled but the CPU is · 55 unmodified lines | ||
| 56 | 56 | still doing productive work. As such, time spent in this subset of the |
| 57 | 57 | stall state is tracked separately and exported in the "full" averages. |
| 58 | 58 | |
| 59 | −The ratios are tracked as recent trends over ten, sixty, and three | |
| 60 | −hundred second windows, which gives insight into short term events as | |
| 61 | −well as medium and long term trends. The total absolute stall time is | |
| 62 | −tracked and exported as well, to allow detection of latency spikes | |
| 63 | −which wouldn't necessarily make a dent in the time averages, or to | |
| 64 | −average trends over custom time frames. | |
| 59 | +The ratios (in %) are tracked as recent trends over ten, sixty, and | |
| 60 | +three hundred second windows, which gives insight into short term events | |
| 61 | +as well as medium and long term trends. The total absolute stall time | |
| 62 | +(in us) is tracked and exported as well, to allow detection of latency | |
| 63 | +spikes which wouldn't necessarily make a dent in the time averages, | |
| 64 | +or to average trends over custom time frames. | |
| 65 | 65 | |
| 66 | 66 | Cgroup2 interface |
| 67 | 67 | ================= |
| @@ -148,16 +148,16 @@ The ``btf_type.size * 8`` must be equal to or greater than ``BTF_INT_BITS()`` · 147 unmodified lines | ||
| 148 | 148 | for the type. The maximum value of ``BTF_INT_BITS()`` is 128. |
| 149 | 149 | |
| 150 | 150 | The ``BTF_INT_OFFSET()`` specifies the starting bit offset to calculate values |
| 151 | −for this int. For example, a bitfield struct member has: * btf member bit | |
| 152 | −offset 100 from the start of the structure, * btf member pointing to an int | |
| 153 | −type, * the int type has ``BTF_INT_OFFSET() = 2`` and ``BTF_INT_BITS() = 4`` | |
| 151 | +for this int. For example, a bitfield struct member has: | |
| 152 | + * btf member bit offset 100 from the start of the structure, | |
| 153 | + * btf member pointing to an int type, | |
| 154 | + * the int type has ``BTF_INT_OFFSET() = 2`` and ``BTF_INT_BITS() = 4`` | |
| 154 | 155 | |
| 155 | 156 | Then in the struct memory layout, this member will occupy ``4`` bits starting |
| 156 | 157 | from bits ``100 + 2 = 102``. |
| 157 | 158 | |
| 158 | 159 | Alternatively, the bitfield struct member can be the following to access the |
| 159 | 160 | same bits as the above: |
| 160 | − | |
| 161 | 161 | * btf member bit offset 102, |
| 162 | 162 | * btf member pointing to an int type, |
| 163 | 163 | * the int type has ``BTF_INT_OFFSET() = 0`` and ``BTF_INT_BITS() = 4`` |
| @@ -228,7 +228,7 @@ patternProperties: · 227 unmodified lines | ||
| 228 | 228 | - renesas,r9a06g032-smp |
| 229 | 229 | - rockchip,rk3036-smp |
| 230 | 230 | - rockchip,rk3066-smp |
| 231 | − - socionext,milbeaut-m10v-smp | |
| 231 | + - socionext,milbeaut-m10v-smp | |
| 232 | 232 | - ste,dbx500-smp |
| 233 | 233 | |
| 234 | 234 | cpu-release-addr: |
| @@ -26,7 +26,7 @@ Required node properties: · 25 unmodified lines | ||
| 26 | 26 | |
| 27 | 27 | Optional node properties: |
| 28 | 28 | |
| 29 | − - ti,mode: Operation mode (see above). | |
| 29 | + - ti,mode: Operation mode (u8) (see above). | |
| 30 | 30 | |
| 31 | 31 | |
| 32 | 32 | Example (operation mode 2): |
| @@ -34,5 +34,5 @@ Example (operation mode 2): · 1 unmodified line | ||
| 34 | 34 | adc128d818@1d { |
| 35 | 35 | compatible = "ti,adc128d818"; |
| 36 | 36 | reg = <0x1d>; |
| 37 | − ti,mode = <2>; | |
| 37 | + ti,mode = /bits/ 8 <2>; | |
| 38 | 38 | }; |
| @@ -102,9 +102,11 @@ Byte sequences · 101 unmodified lines | ||
| 102 | 102 | dictionary which is empty, and that it will always be |
| 103 | 103 | invalid at this place. |
| 104 | 104 | |
| 105 | − 17 : bitstream version. If the first byte is 17, the next byte | |
| 106 | − gives the bitstream version (version 1 only). If the first byte | |
| 107 | − is not 17, the bitstream version is 0. | |
| 105 | + 17 : bitstream version. If the first byte is 17, and compressed | |
| 106 | + stream length is at least 5 bytes (length of shortest possible | |
| 107 | + versioned bitstream), the next byte gives the bitstream version | |
| 108 | + (version 1 only). | |
| 109 | + Otherwise, the bitstream version is 0. | |
| 108 | 110 | |
| 109 | 111 | 18..21 : copy 0..3 literals |
| 110 | 112 | state = (byte - 17) = 0..3 [ copy <state> literals ] |
| @@ -0,0 +1,126 @@ | ||
| 1 | +.. SPDX-License-Identifier: GPL-2.0 | |
| 2 | + | |
| 3 | +================== | |
| 4 | +BPF Flow Dissector | |
| 5 | +================== | |
| 6 | + | |
| 7 | +Overview | |
| 8 | +======== | |
| 9 | + | |
| 10 | +Flow dissector is a routine that parses metadata out of the packets. It's | |
| 11 | +used in the various places in the networking subsystem (RFS, flow hash, etc). | |
| 12 | + | |
| 13 | +BPF flow dissector is an attempt to reimplement C-based flow dissector logic | |
| 14 | +in BPF to gain all the benefits of BPF verifier (namely, limits on the | |
| 15 | +number of instructions and tail calls). | |
| 16 | + | |
| 17 | +API | |
| 18 | +=== | |
| 19 | + | |
| 20 | +BPF flow dissector programs operate on an ``__sk_buff``. However, only the | |
| 21 | +limited set of fields is allowed: ``data``, ``data_end`` and ``flow_keys``. | |
| 22 | +``flow_keys`` is ``struct bpf_flow_keys`` and contains flow dissector input | |
| 23 | +and output arguments. | |
| 24 | + | |
| 25 | +The inputs are: | |
| 26 | + * ``nhoff`` - initial offset of the networking header | |
| 27 | + * ``thoff`` - initial offset of the transport header, initialized to nhoff | |
| 28 | + * ``n_proto`` - L3 protocol type, parsed out of L2 header | |
| 29 | + | |
| 30 | +Flow dissector BPF program should fill out the rest of the ``struct | |
| 31 | +bpf_flow_keys`` fields. Input arguments ``nhoff/thoff/n_proto`` should be | |
| 32 | +also adjusted accordingly. | |
| 33 | + | |
| 34 | +The return code of the BPF program is either BPF_OK to indicate successful | |
| 35 | +dissection, or BPF_DROP to indicate parsing error. | |
| 36 | + | |
| 37 | +__sk_buff->data | |
| 38 | +=============== | |
| 39 | + | |
| 40 | +In the VLAN-less case, this is what the initial state of the BPF flow | |
| 41 | +dissector looks like:: | |
| 42 | + | |
| 43 | + +------+------+------------+-----------+ | |
| 44 | + | DMAC | SMAC | ETHER_TYPE | L3_HEADER | | |
| 45 | + +------+------+------------+-----------+ | |
| 46 | + ^ | |
| 47 | + | | |
| 48 | + +-- flow dissector starts here | |
| 49 | + | |
| 50 | + | |
| 51 | +.. code:: c | |
| 52 | + | |
| 53 | + skb->data + flow_keys->nhoff point to the first byte of L3_HEADER | |
| 54 | + flow_keys->thoff = nhoff | |
| 55 | + flow_keys->n_proto = ETHER_TYPE | |
| 56 | + | |
| 57 | +In case of VLAN, flow dissector can be called with the two different states. | |
| 58 | + | |
| 59 | +Pre-VLAN parsing:: | |
| 60 | + | |
| 61 | + +------+------+------+-----+-----------+-----------+ | |
| 62 | + | DMAC | SMAC | TPID | TCI |ETHER_TYPE | L3_HEADER | | |
| 63 | + +------+------+------+-----+-----------+-----------+ | |
| 64 | + ^ | |
| 65 | + | | |
| 66 | + +-- flow dissector starts here | |
| 67 | + | |
| 68 | +.. code:: c | |
| 69 | + | |
| 70 | + skb->data + flow_keys->nhoff point the to first byte of TCI | |
| 71 | + flow_keys->thoff = nhoff | |
| 72 | + flow_keys->n_proto = TPID | |
| 73 | + | |
| 74 | +Please note that TPID can be 802.1AD and, hence, BPF program would | |
| 75 | +have to parse VLAN information twice for double tagged packets. | |
| 76 | + | |
| 77 | + | |
| 78 | +Post-VLAN parsing:: | |
| 79 | + | |
| 80 | + +------+------+------+-----+-----------+-----------+ | |
| 81 | + | DMAC | SMAC | TPID | TCI |ETHER_TYPE | L3_HEADER | | |
| 82 | + +------+------+------+-----+-----------+-----------+ | |
| 83 | + ^ | |
| 84 | + | | |
| 85 | + +-- flow dissector starts here | |
| 86 | + | |
| 87 | +.. code:: c | |
| 88 | + | |
| 89 | + skb->data + flow_keys->nhoff point the to first byte of L3_HEADER | |
| 90 | + flow_keys->thoff = nhoff | |
| 91 | + flow_keys->n_proto = ETHER_TYPE | |
| 92 | + | |
| 93 | +In this case VLAN information has been processed before the flow dissector | |
| 94 | +and BPF flow dissector is not required to handle it. | |
| 95 | + | |
| 96 | + | |
| 97 | +The takeaway here is as follows: BPF flow dissector program can be called with | |
| 98 | +the optional VLAN header and should gracefully handle both cases: when single | |
| 99 | +or double VLAN is present and when it is not present. The same program | |
| 100 | +can be called for both cases and would have to be written carefully to | |
| 101 | +handle both cases. | |
| 102 | + | |
| 103 | + | |
| 104 | +Reference Implementation | |
| 105 | +======================== | |
| 106 | + | |
| 107 | +See ``tools/testing/selftests/bpf/progs/bpf_flow.c`` for the reference | |
| 108 | +implementation and ``tools/testing/selftests/bpf/flow_dissector_load.[hc]`` | |
| 109 | +for the loader. bpftool can be used to load BPF flow dissector program as well. | |
| 110 | + | |
| 111 | +The reference implementation is organized as follows: | |
| 112 | + * ``jmp_table`` map that contains sub-programs for each supported L3 protocol | |
| 113 | + * ``_dissect`` routine - entry point; it does input ``n_proto`` parsing and | |
| 114 | + does ``bpf_tail_call`` to the appropriate L3 handler | |
| 115 | + | |
| 116 | +Since BPF at this point doesn't support looping (or any jumping back), | |
| 117 | +jmp_table is used instead to handle multiple levels of encapsulation (and | |
| 118 | +IPv6 options). | |
| 119 | + | |
| 120 | + | |
| 121 | +Current Limitations | |
| 122 | +=================== | |
| 123 | +BPF flow dissector doesn't support exporting all the metadata that in-kernel | |
| 124 | +C-based implementation can export. Notable example is single VLAN (802.1Q) | |
| 125 | +and double VLAN (802.1AD) tags. Please refer to the ``struct bpf_flow_keys`` | |
| 126 | +for a set of information that's currently can be exported from the BPF context. | |
| @@ -9,6 +9,7 @@ Contents: · 8 unmodified lines | ||
| 9 | 9 | netdev-FAQ |
| 10 | 10 | af_xdp |
| 11 | 11 | batman-adv |
| 12 | + bpf_flow_dissector | |
| 12 | 13 | can |
| 13 | 14 | can_ucan_protocol |
| 14 | 15 | device_drivers/freescale/dpaa2/index |
| @@ -1893,14 +1893,15 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-nomadik.git · 1892 unmodified lines | ||
| 1893 | 1893 | ARM/NUVOTON NPCM ARCHITECTURE |
| 1894 | 1894 | M: Avi Fishman <avifishman70@gmail.com> |
| 1895 | 1895 | M: Tomer Maimon <tmaimon77@gmail.com> |
| 1896 | +M: Tali Perry <tali.perry1@gmail.com> | |
| 1896 | 1897 | R: Patrick Venture <venture@google.com> |
| 1897 | 1898 | R: Nancy Yuen <yuenn@google.com> |
| 1898 | −R: Brendan Higgins <brendanhiggins@google.com> | |
| 1899 | +R: Benjamin Fair <benjaminfair@google.com> | |
| 1899 | 1900 | L: openbmc@lists.ozlabs.org (moderated for non-subscribers) |
| 1900 | 1901 | S: Supported |
| 1901 | 1902 | F: arch/arm/mach-npcm/ |
| 1902 | 1903 | F: arch/arm/boot/dts/nuvoton-npcm* |
| 1903 | −F: include/dt-bindings/clock/nuvoton,npcm7xx-clks.h | |
| 1904 | +F: include/dt-bindings/clock/nuvoton,npcm7xx-clock.h | |
| 1904 | 1905 | F: drivers/*/*npcm* |
| 1905 | 1906 | F: Documentation/devicetree/bindings/*/*npcm* |
| 1906 | 1907 | F: Documentation/devicetree/bindings/*/*/*npcm* |
| @@ -4129,7 +4130,7 @@ F: drivers/cpuidle/* · 2222 unmodified lines | ||
| 4129 | 4130 | F: include/linux/cpuidle.h |
| 4130 | 4131 | |
| 4131 | 4132 | CRAMFS FILESYSTEM |
| 4132 | −M: Nicolas Pitre <nico@linaro.org> | |
| 4133 | +M: Nicolas Pitre <nico@fluxnic.net> | |
| 4133 | 4134 | S: Maintained |
| 4134 | 4135 | F: Documentation/filesystems/cramfs.txt |
| 4135 | 4136 | F: fs/cramfs/ |
| @@ -5833,7 +5834,7 @@ L: netdev@vger.kernel.org · 1697 unmodified lines | ||
| 5833 | 5834 | S: Maintained |
| 5834 | 5835 | F: Documentation/ABI/testing/sysfs-bus-mdio |
| 5835 | 5836 | F: Documentation/devicetree/bindings/net/mdio* |
| 5836 | −F: Documentation/networking/phy.txt | |
| 5837 | +F: Documentation/networking/phy.rst | |
| 5837 | 5838 | F: drivers/net/phy/ |
| 5838 | 5839 | F: drivers/of/of_mdio.c |
| 5839 | 5840 | F: drivers/of/of_net.c |
| @@ -7515,7 +7516,7 @@ F: include/net/mac802154.h · 1675 unmodified lines | ||
| 7515 | 7516 | F: include/net/af_ieee802154.h |
| 7516 | 7517 | F: include/net/cfg802154.h |
| 7517 | 7518 | F: include/net/ieee802154_netdev.h |
| 7518 | −F: Documentation/networking/ieee802154.txt | |
| 7519 | +F: Documentation/networking/ieee802154.rst | |
| 7519 | 7520 | |
| 7520 | 7521 | IFE PROTOCOL |
| 7521 | 7522 | M: Yotam Gigi <yotam.gi@gmail.com> |
| @@ -13980,7 +13981,7 @@ F: drivers/media/rc/serial_ir.c · 6458 unmodified lines | ||
| 13980 | 13981 | SFC NETWORK DRIVER |
| 13981 | 13982 | M: Solarflare linux maintainers <linux-net-drivers@solarflare.com> |
| 13982 | 13983 | M: Edward Cree <ecree@solarflare.com> |
| 13983 | −M: Bert Kenward <bkenward@solarflare.com> | |
| 13984 | +M: Martin Habets <mhabets@solarflare.com> | |
| 13984 | 13985 | L: netdev@vger.kernel.org |
| 13985 | 13986 | S: Supported |
| 13986 | 13987 | F: drivers/net/ethernet/sfc/ |
| @@ -2,7 +2,7 @@ · 1 unmodified line | ||
| 2 | 2 | VERSION = 5 |
| 3 | 3 | PATCHLEVEL = 1 |
| 4 | 4 | SUBLEVEL = 0 |
| 5 | −EXTRAVERSION = -rc3 | |
| 5 | +EXTRAVERSION = -rc4 | |
| 6 | 6 | NAME = Shy Crocodile |
| 7 | 7 | |
| 8 | 8 | # *DOCUMENTATION* |
| @@ -55,12 +55,11 @@ syscall_set_return_value(struct task_struct *task, struct pt_regs *regs, · 54 unmodified lines | ||
| 55 | 55 | */ |
| 56 | 56 | static inline void |
| 57 | 57 | syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 58 | − unsigned int i, unsigned int n, unsigned long *args) | |
| 58 | + unsigned long *args) | |
| 59 | 59 | { |
| 60 | 60 | unsigned long *inside_ptregs = &(regs->r0); |
| 61 | − inside_ptregs -= i; | |
| 62 | − | |
| 63 | − BUG_ON((i + n) > 6); | |
| 61 | + unsigned int n = 6; | |
| 62 | + unsigned int i = 0; | |
| 64 | 63 | |
| 65 | 64 | while (n--) { |
| 66 | 65 | args[i++] = (*inside_ptregs); |
| @@ -57,6 +57,24 @@ · 56 unmodified lines | ||
| 57 | 57 | enable-active-high; |
| 58 | 58 | }; |
| 59 | 59 | |
| 60 | + /* TPS79501 */ | |
| 61 | + v1_8d_reg: fixedregulator-v1_8d { | |
| 62 | + compatible = "regulator-fixed"; | |
| 63 | + regulator-name = "v1_8d"; | |
| 64 | + vin-supply = <&vbat>; | |
| 65 | + regulator-min-microvolt = <1800000>; | |
| 66 | + regulator-max-microvolt = <1800000>; | |
| 67 | + }; | |
| 68 | + | |
| 69 | + /* TPS79501 */ | |
| 70 | + v3_3d_reg: fixedregulator-v3_3d { | |
| 71 | + compatible = "regulator-fixed"; | |
| 72 | + regulator-name = "v3_3d"; | |
| 73 | + vin-supply = <&vbat>; | |
| 74 | + regulator-min-microvolt = <3300000>; | |
| 75 | + regulator-max-microvolt = <3300000>; | |
| 76 | + }; | |
| 77 | + | |
| 60 | 78 | matrix_keypad: matrix_keypad0 { |
| 61 | 79 | compatible = "gpio-matrix-keypad"; |
| 62 | 80 | debounce-delay-ms = <5>; |
| @@ -499,10 +517,10 @@ · 436 unmodified lines | ||
| 499 | 517 | status = "okay"; |
| 500 | 518 | |
| 501 | 519 | /* Regulators */ |
| 502 | − AVDD-supply = <&vaux2_reg>; | |
| 503 | − IOVDD-supply = <&vaux2_reg>; | |
| 504 | − DRVDD-supply = <&vaux2_reg>; | |
| 505 | − DVDD-supply = <&vbat>; | |
| 520 | + AVDD-supply = <&v3_3d_reg>; | |
| 521 | + IOVDD-supply = <&v3_3d_reg>; | |
| 522 | + DRVDD-supply = <&v3_3d_reg>; | |
| 523 | + DVDD-supply = <&v1_8d_reg>; | |
| 506 | 524 | }; |
| 507 | 525 | }; |
| 508 | 526 | |
| @@ -73,6 +73,24 @@ · 72 unmodified lines | ||
| 73 | 73 | enable-active-high; |
| 74 | 74 | }; |
| 75 | 75 | |
| 76 | + /* TPS79518 */ | |
| 77 | + v1_8d_reg: fixedregulator-v1_8d { | |
| 78 | + compatible = "regulator-fixed"; | |
| 79 | + regulator-name = "v1_8d"; | |
| 80 | + vin-supply = <&vbat>; | |
| 81 | + regulator-min-microvolt = <1800000>; | |
| 82 | + regulator-max-microvolt = <1800000>; | |
| 83 | + }; | |
| 84 | + | |
| 85 | + /* TPS78633 */ | |
| 86 | + v3_3d_reg: fixedregulator-v3_3d { | |
| 87 | + compatible = "regulator-fixed"; | |
| 88 | + regulator-name = "v3_3d"; | |
| 89 | + vin-supply = <&vbat>; | |
| 90 | + regulator-min-microvolt = <3300000>; | |
| 91 | + regulator-max-microvolt = <3300000>; | |
| 92 | + }; | |
| 93 | + | |
| 76 | 94 | leds { |
| 77 | 95 | pinctrl-names = "default"; |
| 78 | 96 | pinctrl-0 = <&user_leds_s0>; |
| @@ -501,10 +519,10 @@ · 422 unmodified lines | ||
| 501 | 519 | status = "okay"; |
| 502 | 520 | |
| 503 | 521 | /* Regulators */ |
| 504 | − AVDD-supply = <&vaux2_reg>; | |
| 505 | − IOVDD-supply = <&vaux2_reg>; | |
| 506 | − DRVDD-supply = <&vaux2_reg>; | |
| 507 | − DVDD-supply = <&vbat>; | |
| 522 | + AVDD-supply = <&v3_3d_reg>; | |
| 523 | + IOVDD-supply = <&v3_3d_reg>; | |
| 524 | + DRVDD-supply = <&v3_3d_reg>; | |
| 525 | + DVDD-supply = <&v1_8d_reg>; | |
| 508 | 526 | }; |
| 509 | 527 | }; |
| 510 | 528 | |
| @@ -1762,7 +1762,7 @@ · 1761 unmodified lines | ||
| 1762 | 1762 | reg = <0xcc000 0x4>; |
| 1763 | 1763 | reg-names = "rev"; |
| 1764 | 1764 | /* Domains (P, C): per_pwrdm, l4ls_clkdm */ |
| 1765 | − clocks = <&l4ls_clkctrl AM3_D_CAN0_CLKCTRL 0>; | |
| 1765 | + clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN0_CLKCTRL 0>; | |
| 1766 | 1766 | clock-names = "fck"; |
| 1767 | 1767 | #address-cells = <1>; |
| 1768 | 1768 | #size-cells = <1>; |
| @@ -1785,7 +1785,7 @@ · 16 unmodified lines | ||
| 1785 | 1785 | reg = <0xd0000 0x4>; |
| 1786 | 1786 | reg-names = "rev"; |
| 1787 | 1787 | /* Domains (P, C): per_pwrdm, l4ls_clkdm */ |
| 1788 | − clocks = <&l4ls_clkctrl AM3_D_CAN1_CLKCTRL 0>; | |
| 1788 | + clocks = <&l4ls_clkctrl AM3_L4LS_D_CAN1_CLKCTRL 0>; | |
| 1789 | 1789 | clock-names = "fck"; |
| 1790 | 1790 | #address-cells = <1>; |
| 1791 | 1791 | #size-cells = <1>; |
| @@ -254,6 +254,7 @@ · 253 unmodified lines | ||
| 254 | 254 | }; |
| 255 | 255 | |
| 256 | 256 | vccio_sd: LDO_REG5 { |
| 257 | + regulator-boot-on; | |
| 257 | 258 | regulator-min-microvolt = <1800000>; |
| 258 | 259 | regulator-max-microvolt = <3300000>; |
| 259 | 260 | regulator-name = "vccio_sd"; |
| @@ -430,7 +431,7 @@ · 170 unmodified lines | ||
| 430 | 431 | bus-width = <4>; |
| 431 | 432 | cap-mmc-highspeed; |
| 432 | 433 | cap-sd-highspeed; |
| 433 | − card-detect-delay = <200>; | |
| 434 | + broken-cd; | |
| 434 | 435 | disable-wp; /* wp not hooked up */ |
| 435 | 436 | pinctrl-names = "default"; |
| 436 | 437 | pinctrl-0 = <&sdmmc_clk &sdmmc_cmd &sdmmc_cd &sdmmc_bus4>; |
| @@ -25,8 +25,6 @@ · 24 unmodified lines | ||
| 25 | 25 | |
| 26 | 26 | gpio_keys: gpio-keys { |
| 27 | 27 | compatible = "gpio-keys"; |
| 28 | − #address-cells = <1>; | |
| 29 | − #size-cells = <0>; | |
| 30 | 28 | |
| 31 | 29 | pinctrl-names = "default"; |
| 32 | 30 | pinctrl-0 = <&pwr_key_l>; |
| @@ -70,7 +70,7 @@ · 69 unmodified lines | ||
| 70 | 70 | compatible = "arm,cortex-a12"; |
| 71 | 71 | reg = <0x501>; |
| 72 | 72 | resets = <&cru SRST_CORE1>; |
| 73 | − operating-points = <&cpu_opp_table>; | |
| 73 | + operating-points-v2 = <&cpu_opp_table>; | |
| 74 | 74 | #cooling-cells = <2>; /* min followed by max */ |
| 75 | 75 | clock-latency = <40000>; |
| 76 | 76 | clocks = <&cru ARMCLK>; |
| @@ -80,7 +80,7 @@ · 3 unmodified lines | ||
| 80 | 80 | compatible = "arm,cortex-a12"; |
| 81 | 81 | reg = <0x502>; |
| 82 | 82 | resets = <&cru SRST_CORE2>; |
| 83 | − operating-points = <&cpu_opp_table>; | |
| 83 | + operating-points-v2 = <&cpu_opp_table>; | |
| 84 | 84 | #cooling-cells = <2>; /* min followed by max */ |
| 85 | 85 | clock-latency = <40000>; |
| 86 | 86 | clocks = <&cru ARMCLK>; |
| @@ -90,7 +90,7 @@ · 3 unmodified lines | ||
| 90 | 90 | compatible = "arm,cortex-a12"; |
| 91 | 91 | reg = <0x503>; |
| 92 | 92 | resets = <&cru SRST_CORE3>; |
| 93 | − operating-points = <&cpu_opp_table>; | |
| 93 | + operating-points-v2 = <&cpu_opp_table>; | |
| 94 | 94 | #cooling-cells = <2>; /* min followed by max */ |
| 95 | 95 | clock-latency = <40000>; |
| 96 | 96 | clocks = <&cru ARMCLK>; |
| @@ -1119,8 +1119,6 @@ · 1022 unmodified lines | ||
| 1119 | 1119 | clock-names = "ref", "pclk"; |
| 1120 | 1120 | power-domains = <&power RK3288_PD_VIO>; |
| 1121 | 1121 | rockchip,grf = <&grf>; |
| 1122 | − #address-cells = <1>; | |
| 1123 | − #size-cells = <0>; | |
| 1124 | 1122 | status = "disabled"; |
| 1125 | 1123 | |
| 1126 | 1124 | ports { |
| @@ -1282,27 +1280,27 @@ · 155 unmodified lines | ||
| 1282 | 1280 | gpu_opp_table: gpu-opp-table { |
| 1283 | 1281 | compatible = "operating-points-v2"; |
| 1284 | 1282 | |
| 1285 | − opp@100000000 { | |
| 1283 | + opp-100000000 { | |
| 1286 | 1284 | opp-hz = /bits/ 64 <100000000>; |
| 1287 | 1285 | opp-microvolt = <950000>; |
| 1288 | 1286 | }; |
| 1289 | − opp@200000000 { | |
| 1287 | + opp-200000000 { | |
| 1290 | 1288 | opp-hz = /bits/ 64 <200000000>; |
| 1291 | 1289 | opp-microvolt = <950000>; |
| 1292 | 1290 | }; |
| 1293 | − opp@300000000 { | |
| 1291 | + opp-300000000 { | |
| 1294 | 1292 | opp-hz = /bits/ 64 <300000000>; |
| 1295 | 1293 | opp-microvolt = <1000000>; |
| 1296 | 1294 | }; |
| 1297 | − opp@400000000 { | |
| 1295 | + opp-400000000 { | |
| 1298 | 1296 | opp-hz = /bits/ 64 <400000000>; |
| 1299 | 1297 | opp-microvolt = <1100000>; |
| 1300 | 1298 | }; |
| 1301 | − opp@500000000 { | |
| 1299 | + opp-500000000 { | |
| 1302 | 1300 | opp-hz = /bits/ 64 <500000000>; |
| 1303 | 1301 | opp-microvolt = <1200000>; |
| 1304 | 1302 | }; |
| 1305 | − opp@600000000 { | |
| 1303 | + opp-600000000 { | |
| 1306 | 1304 | opp-hz = /bits/ 64 <600000000>; |
| 1307 | 1305 | opp-microvolt = <1250000>; |
| 1308 | 1306 | }; |
| @@ -518,7 +518,7 @@ · 517 unmodified lines | ||
| 518 | 518 | #define PIN_PC9__GPIO PINMUX_PIN(PIN_PC9, 0, 0) |
| 519 | 519 | #define PIN_PC9__FIQ PINMUX_PIN(PIN_PC9, 1, 3) |
| 520 | 520 | #define PIN_PC9__GTSUCOMP PINMUX_PIN(PIN_PC9, 2, 1) |
| 521 | −#define PIN_PC9__ISC_D0 PINMUX_PIN(PIN_PC9, 2, 1) | |
| 521 | +#define PIN_PC9__ISC_D0 PINMUX_PIN(PIN_PC9, 3, 1) | |
| 522 | 522 | #define PIN_PC9__TIOA4 PINMUX_PIN(PIN_PC9, 4, 2) |
| 523 | 523 | #define PIN_PC10 74 |
| 524 | 524 | #define PIN_PC10__GPIO PINMUX_PIN(PIN_PC10, 0, 0) |
| @@ -213,13 +213,12 @@ · 212 unmodified lines | ||
| 213 | 213 | gpio-sck = <&gpio0 5 GPIO_ACTIVE_HIGH>; |
| 214 | 214 | gpio-mosi = <&gpio0 4 GPIO_ACTIVE_HIGH>; |
| 215 | 215 | /* |
| 216 | − * This chipselect is active high. Just setting the flags | |
| 217 | − * to GPIO_ACTIVE_HIGH is not enough for the SPI DT bindings, | |
| 218 | − * it will be ignored, only the special "spi-cs-high" flag | |
| 219 | − * really counts. | |
| 216 | + * It's not actually active high, but the frameworks assume | |
| 217 | + * the polarity of the passed-in GPIO is "normal" (active | |
| 218 | + * high) then actively drives the line low to select the | |
| 219 | + * chip. | |
| 220 | 220 | */ |
| 221 | 221 | cs-gpios = <&gpio0 6 GPIO_ACTIVE_HIGH>; |
| 222 | − spi-cs-high; | |
| 223 | 222 | num-chipselects = <1>; |
| 224 | 223 | |
| 225 | 224 | /* |
| @@ -55,53 +55,22 @@ static inline void syscall_set_return_value(struct task_struct *task, · 54 unmodified lines | ||
| 55 | 55 | |
| 56 | 56 | static inline void syscall_get_arguments(struct task_struct *task, |
| 57 | 57 | struct pt_regs *regs, |
| 58 | − unsigned int i, unsigned int n, | |
| 59 | 58 | unsigned long *args) |
| 60 | 59 | { |
| 61 | − if (n == 0) | |
| 62 | − return; | |
| 63 | − | |
| 64 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 65 | − unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i; | |
| 66 | − unsigned int n_bad = n + i - SYSCALL_MAX_ARGS; | |
| 67 | − pr_warn("%s called with max args %d, handling only %d\n", | |
| 68 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 69 | − memset(args_bad, 0, n_bad * sizeof(args[0])); | |
| 70 | − n = SYSCALL_MAX_ARGS - i; | |
| 71 | − } | |
| 72 | − | |
| 73 | − if (i == 0) { | |
| 74 | − args[0] = regs->ARM_ORIG_r0; | |
| 75 | − args++; | |
| 76 | − i++; | |
| 77 | − n--; | |
| 78 | − } | |
| 79 | − | |
| 80 | − memcpy(args, ®s->ARM_r0 + i, n * sizeof(args[0])); | |
| 60 | + args[0] = regs->ARM_ORIG_r0; | |
| 61 | + args++; | |
| 62 | + | |
| 63 | + memcpy(args, ®s->ARM_r0 + 1, 5 * sizeof(args[0])); | |
| 81 | 64 | } |
| 82 | 65 | |
| 83 | 66 | static inline void syscall_set_arguments(struct task_struct *task, |
| 84 | 67 | struct pt_regs *regs, |
| 85 | − unsigned int i, unsigned int n, | |
| 86 | 68 | const unsigned long *args) |
| 87 | 69 | { |
| 88 | − if (n == 0) | |
| 89 | − return; | |
| 90 | − | |
| 91 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 92 | − pr_warn("%s called with max args %d, handling only %d\n", | |
| 93 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 94 | − n = SYSCALL_MAX_ARGS - i; | |
| 95 | − } | |
| 96 | − | |
| 97 | − if (i == 0) { | |
| 98 | − regs->ARM_ORIG_r0 = args[0]; | |
| 99 | − args++; | |
| 100 | − i++; | |
| 101 | − n--; | |
| 102 | − } | |
| 103 | − | |
| 104 | − memcpy(®s->ARM_r0 + i, args, n * sizeof(args[0])); | |
| 70 | + regs->ARM_ORIG_r0 = args[0]; | |
| 71 | + args++; | |
| 72 | + | |
| 73 | + memcpy(®s->ARM_r0 + 1, args, 5 * sizeof(args[0])); | |
| 105 | 74 | } |
| 106 | 75 | |
| 107 | 76 | static inline int syscall_get_arch(void) |
| @@ -591,13 +591,13 @@ static int __init at91_pm_backup_init(void) · 590 unmodified lines | ||
| 591 | 591 | |
| 592 | 592 | np = of_find_compatible_node(NULL, NULL, "atmel,sama5d2-securam"); |
| 593 | 593 | if (!np) |
| 594 | − goto securam_fail; | |
| 594 | + goto securam_fail_no_ref_dev; | |
| 595 | 595 | |
| 596 | 596 | pdev = of_find_device_by_node(np); |
| 597 | 597 | of_node_put(np); |
| 598 | 598 | if (!pdev) { |
| 599 | 599 | pr_warn("%s: failed to find securam device!\n", __func__); |
| 600 | − goto securam_fail; | |
| 600 | + goto securam_fail_no_ref_dev; | |
| 601 | 601 | } |
| 602 | 602 | |
| 603 | 603 | sram_pool = gen_pool_get(&pdev->dev, NULL); |
| @@ -620,6 +620,8 @@ static int __init at91_pm_backup_init(void) · 16 unmodified lines | ||
| 620 | 620 | return 0; |
| 621 | 621 | |
| 622 | 622 | securam_fail: |
| 623 | + put_device(&pdev->dev); | |
| 624 | +securam_fail_no_ref_dev: | |
| 623 | 625 | iounmap(pm_data.sfrbu); |
| 624 | 626 | pm_data.sfrbu = NULL; |
| 625 | 627 | return ret; |
| @@ -300,7 +300,7 @@ static struct resource iop13xx_adma_2_resources[] = { · 299 unmodified lines | ||
| 300 | 300 | } |
| 301 | 301 | }; |
| 302 | 302 | |
| 303 | −static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(64); | |
| 303 | +static u64 iop13xx_adma_dmamask = DMA_BIT_MASK(32); | |
| 304 | 304 | static struct iop_adma_platform_data iop13xx_adma_0_data = { |
| 305 | 305 | .hw_id = 0, |
| 306 | 306 | .pool_size = PAGE_SIZE, |
| @@ -324,7 +324,7 @@ static struct platform_device iop13xx_adma_0_channel = { · 17 unmodified lines | ||
| 324 | 324 | .resource = iop13xx_adma_0_resources, |
| 325 | 325 | .dev = { |
| 326 | 326 | .dma_mask = &iop13xx_adma_dmamask, |
| 327 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 327 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 328 | 328 | .platform_data = (void *) &iop13xx_adma_0_data, |
| 329 | 329 | }, |
| 330 | 330 | }; |
| @@ -336,7 +336,7 @@ static struct platform_device iop13xx_adma_1_channel = { · 5 unmodified lines | ||
| 336 | 336 | .resource = iop13xx_adma_1_resources, |
| 337 | 337 | .dev = { |
| 338 | 338 | .dma_mask = &iop13xx_adma_dmamask, |
| 339 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 339 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 340 | 340 | .platform_data = (void *) &iop13xx_adma_1_data, |
| 341 | 341 | }, |
| 342 | 342 | }; |
| @@ -348,7 +348,7 @@ static struct platform_device iop13xx_adma_2_channel = { · 5 unmodified lines | ||
| 348 | 348 | .resource = iop13xx_adma_2_resources, |
| 349 | 349 | .dev = { |
| 350 | 350 | .dma_mask = &iop13xx_adma_dmamask, |
| 351 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 351 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 352 | 352 | .platform_data = (void *) &iop13xx_adma_2_data, |
| 353 | 353 | }, |
| 354 | 354 | }; |
| @@ -152,7 +152,7 @@ static struct resource iop13xx_tpmi_3_resources[] = { · 151 unmodified lines | ||
| 152 | 152 | } |
| 153 | 153 | }; |
| 154 | 154 | |
| 155 | −u64 iop13xx_tpmi_mask = DMA_BIT_MASK(64); | |
| 155 | +u64 iop13xx_tpmi_mask = DMA_BIT_MASK(32); | |
| 156 | 156 | static struct platform_device iop13xx_tpmi_0_device = { |
| 157 | 157 | .name = "iop-tpmi", |
| 158 | 158 | .id = 0, |
| @@ -160,7 +160,7 @@ static struct platform_device iop13xx_tpmi_0_device = { · 1 unmodified line | ||
| 160 | 160 | .resource = iop13xx_tpmi_0_resources, |
| 161 | 161 | .dev = { |
| 162 | 162 | .dma_mask = &iop13xx_tpmi_mask, |
| 163 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 163 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 164 | 164 | }, |
| 165 | 165 | }; |
| 166 | 166 | |
| @@ -171,7 +171,7 @@ static struct platform_device iop13xx_tpmi_1_device = { · 4 unmodified lines | ||
| 171 | 171 | .resource = iop13xx_tpmi_1_resources, |
| 172 | 172 | .dev = { |
| 173 | 173 | .dma_mask = &iop13xx_tpmi_mask, |
| 174 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 174 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 175 | 175 | }, |
| 176 | 176 | }; |
| 177 | 177 | |
| @@ -182,7 +182,7 @@ static struct platform_device iop13xx_tpmi_2_device = { · 4 unmodified lines | ||
| 182 | 182 | .resource = iop13xx_tpmi_2_resources, |
| 183 | 183 | .dev = { |
| 184 | 184 | .dma_mask = &iop13xx_tpmi_mask, |
| 185 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 185 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 186 | 186 | }, |
| 187 | 187 | }; |
| 188 | 188 | |
| @@ -193,7 +193,7 @@ static struct platform_device iop13xx_tpmi_3_device = { · 4 unmodified lines | ||
| 193 | 193 | .resource = iop13xx_tpmi_3_resources, |
| 194 | 194 | .dev = { |
| 195 | 195 | .dma_mask = &iop13xx_tpmi_mask, |
| 196 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 196 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 197 | 197 | }, |
| 198 | 198 | }; |
| 199 | 199 | |
| @@ -65,6 +65,7 @@ static void m10v_smp_init(unsigned int max_cpus) · 64 unmodified lines | ||
| 65 | 65 | writel(KERNEL_UNBOOT_FLAG, m10v_smp_base + cpu * 4); |
| 66 | 66 | } |
| 67 | 67 | |
| 68 | +#ifdef CONFIG_HOTPLUG_CPU | |
| 68 | 69 | static void m10v_cpu_die(unsigned int l_cpu) |
| 69 | 70 | { |
| 70 | 71 | gic_cpu_if_down(0); |
| @@ -83,12 +84,15 @@ static int m10v_cpu_kill(unsigned int l_cpu) · 12 unmodified lines | ||
| 83 | 84 | |
| 84 | 85 | return 1; |
| 85 | 86 | } |
| 87 | +#endif | |
| 86 | 88 | |
| 87 | 89 | static struct smp_operations m10v_smp_ops __initdata = { |
| 88 | 90 | .smp_prepare_cpus = m10v_smp_init, |
| 89 | 91 | .smp_boot_secondary = m10v_boot_secondary, |
| 92 | +#ifdef CONFIG_HOTPLUG_CPU | |
| 90 | 93 | .cpu_die = m10v_cpu_die, |
| 91 | 94 | .cpu_kill = m10v_cpu_kill, |
| 95 | +#endif | |
| 92 | 96 | }; |
| 93 | 97 | CPU_METHOD_OF_DECLARE(m10v_smp, "socionext,milbeaut-m10v-smp", &m10v_smp_ops); |
| 94 | 98 | |
| @@ -182,6 +182,7 @@ static struct resource latch1_resources[] = { · 181 unmodified lines | ||
| 182 | 182 | |
| 183 | 183 | static struct bgpio_pdata latch1_pdata = { |
| 184 | 184 | .label = LATCH1_LABEL, |
| 185 | + .base = -1, | |
| 185 | 186 | .ngpio = LATCH1_NGPIO, |
| 186 | 187 | }; |
| 187 | 188 | |
| @@ -219,6 +220,7 @@ static struct resource latch2_resources[] = { · 31 unmodified lines | ||
| 219 | 220 | |
| 220 | 221 | static struct bgpio_pdata latch2_pdata = { |
| 221 | 222 | .label = LATCH2_LABEL, |
| 223 | + .base = -1, | |
| 222 | 224 | .ngpio = LATCH2_NGPIO, |
| 223 | 225 | }; |
| 224 | 226 | |
| @@ -250,8 +250,10 @@ static int __init omapdss_init_of(void) · 249 unmodified lines | ||
| 250 | 250 | if (!node) |
| 251 | 251 | return 0; |
| 252 | 252 | |
| 253 | − if (!of_device_is_available(node)) | |
| 253 | + if (!of_device_is_available(node)) { | |
| 254 | + of_node_put(node); | |
| 254 | 255 | return 0; |
| 256 | + } | |
| 255 | 257 | |
| 256 | 258 | pdev = of_find_device_by_node(node); |
| 257 | 259 | |
| @@ -143,7 +143,7 @@ struct platform_device iop3xx_dma_0_channel = { · 142 unmodified lines | ||
| 143 | 143 | .resource = iop3xx_dma_0_resources, |
| 144 | 144 | .dev = { |
| 145 | 145 | .dma_mask = &iop3xx_adma_dmamask, |
| 146 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 146 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 147 | 147 | .platform_data = (void *) &iop3xx_dma_0_data, |
| 148 | 148 | }, |
| 149 | 149 | }; |
| @@ -155,7 +155,7 @@ struct platform_device iop3xx_dma_1_channel = { · 5 unmodified lines | ||
| 155 | 155 | .resource = iop3xx_dma_1_resources, |
| 156 | 156 | .dev = { |
| 157 | 157 | .dma_mask = &iop3xx_adma_dmamask, |
| 158 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 158 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 159 | 159 | .platform_data = (void *) &iop3xx_dma_1_data, |
| 160 | 160 | }, |
| 161 | 161 | }; |
| @@ -167,7 +167,7 @@ struct platform_device iop3xx_aau_channel = { · 5 unmodified lines | ||
| 167 | 167 | .resource = iop3xx_aau_resources, |
| 168 | 168 | .dev = { |
| 169 | 169 | .dma_mask = &iop3xx_adma_dmamask, |
| 170 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 170 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 171 | 171 | .platform_data = (void *) &iop3xx_aau_data, |
| 172 | 172 | }, |
| 173 | 173 | }; |
| @@ -622,7 +622,7 @@ static struct platform_device orion_xor0_shared = { · 621 unmodified lines | ||
| 622 | 622 | .resource = orion_xor0_shared_resources, |
| 623 | 623 | .dev = { |
| 624 | 624 | .dma_mask = &orion_xor_dmamask, |
| 625 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 625 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 626 | 626 | .platform_data = &orion_xor0_pdata, |
| 627 | 627 | }, |
| 628 | 628 | }; |
| @@ -683,7 +683,7 @@ static struct platform_device orion_xor1_shared = { · 54 unmodified lines | ||
| 683 | 683 | .resource = orion_xor1_shared_resources, |
| 684 | 684 | .dev = { |
| 685 | 685 | .dma_mask = &orion_xor_dmamask, |
| 686 | − .coherent_dma_mask = DMA_BIT_MASK(64), | |
| 686 | + .coherent_dma_mask = DMA_BIT_MASK(32), | |
| 687 | 687 | .platform_data = &orion_xor1_pdata, |
| 688 | 688 | }, |
| 689 | 689 | }; |
| @@ -162,6 +162,7 @@ · 161 unmodified lines | ||
| 162 | 162 | rx-fifo-depth = <16384>; |
| 163 | 163 | snps,multicast-filter-bins = <256>; |
| 164 | 164 | iommus = <&smmu 1>; |
| 165 | + altr,sysmgr-syscon = <&sysmgr 0x44 0>; | |
| 165 | 166 | status = "disabled"; |
| 166 | 167 | }; |
| 167 | 168 | |
| @@ -179,6 +180,7 @@ · 11 unmodified lines | ||
| 179 | 180 | rx-fifo-depth = <16384>; |
| 180 | 181 | snps,multicast-filter-bins = <256>; |
| 181 | 182 | iommus = <&smmu 2>; |
| 183 | + altr,sysmgr-syscon = <&sysmgr 0x48 0>; | |
| 182 | 184 | status = "disabled"; |
| 183 | 185 | }; |
| 184 | 186 | |
| @@ -196,6 +198,7 @@ · 11 unmodified lines | ||
| 196 | 198 | rx-fifo-depth = <16384>; |
| 197 | 199 | snps,multicast-filter-bins = <256>; |
| 198 | 200 | iommus = <&smmu 3>; |
| 201 | + altr,sysmgr-syscon = <&sysmgr 0x4c 0>; | |
| 199 | 202 | status = "disabled"; |
| 200 | 203 | }; |
| 201 | 204 | |
| @@ -108,8 +108,8 @@ · 107 unmodified lines | ||
| 108 | 108 | snps,reset-gpio = <&gpio1 RK_PC2 GPIO_ACTIVE_LOW>; |
| 109 | 109 | snps,reset-active-low; |
| 110 | 110 | snps,reset-delays-us = <0 10000 50000>; |
| 111 | − tx_delay = <0x25>; | |
| 112 | − rx_delay = <0x11>; | |
| 111 | + tx_delay = <0x24>; | |
| 112 | + rx_delay = <0x18>; | |
| 113 | 113 | status = "okay"; |
| 114 | 114 | }; |
| 115 | 115 | |
| @@ -46,8 +46,7 @@ · 45 unmodified lines | ||
| 46 | 46 | |
| 47 | 47 | vcc_host1_5v: vcc_otg_5v: vcc-host1-5v-regulator { |
| 48 | 48 | compatible = "regulator-fixed"; |
| 49 | − enable-active-high; | |
| 50 | − gpio = <&gpio0 RK_PA2 GPIO_ACTIVE_HIGH>; | |
| 49 | + gpio = <&gpio0 RK_PA2 GPIO_ACTIVE_LOW>; | |
| 51 | 50 | pinctrl-names = "default"; |
| 52 | 51 | pinctrl-0 = <&usb20_host_drv>; |
| 53 | 52 | regulator-name = "vcc_host1_5v"; |
| @@ -1445,11 +1445,11 @@ · 1444 unmodified lines | ||
| 1445 | 1445 | |
| 1446 | 1446 | sdmmc0 { |
| 1447 | 1447 | sdmmc0_clk: sdmmc0-clk { |
| 1448 | − rockchip,pins = <1 RK_PA6 1 &pcfg_pull_none_4ma>; | |
| 1448 | + rockchip,pins = <1 RK_PA6 1 &pcfg_pull_none_8ma>; | |
| 1449 | 1449 | }; |
| 1450 | 1450 | |
| 1451 | 1451 | sdmmc0_cmd: sdmmc0-cmd { |
| 1452 | − rockchip,pins = <1 RK_PA4 1 &pcfg_pull_up_4ma>; | |
| 1452 | + rockchip,pins = <1 RK_PA4 1 &pcfg_pull_up_8ma>; | |
| 1453 | 1453 | }; |
| 1454 | 1454 | |
| 1455 | 1455 | sdmmc0_dectn: sdmmc0-dectn { |
| @@ -1461,14 +1461,14 @@ · 5 unmodified lines | ||
| 1461 | 1461 | }; |
| 1462 | 1462 | |
| 1463 | 1463 | sdmmc0_bus1: sdmmc0-bus1 { |
| 1464 | − rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_4ma>; | |
| 1464 | + rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_8ma>; | |
| 1465 | 1465 | }; |
| 1466 | 1466 | |
| 1467 | 1467 | sdmmc0_bus4: sdmmc0-bus4 { |
| 1468 | − rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_4ma>, | |
| 1469 | − <1 RK_PA1 1 &pcfg_pull_up_4ma>, | |
| 1470 | − <1 RK_PA2 1 &pcfg_pull_up_4ma>, | |
| 1471 | − <1 RK_PA3 1 &pcfg_pull_up_4ma>; | |
| 1468 | + rockchip,pins = <1 RK_PA0 1 &pcfg_pull_up_8ma>, | |
| 1469 | + <1 RK_PA1 1 &pcfg_pull_up_8ma>, | |
| 1470 | + <1 RK_PA2 1 &pcfg_pull_up_8ma>, | |
| 1471 | + <1 RK_PA3 1 &pcfg_pull_up_8ma>; | |
| 1472 | 1472 | }; |
| 1473 | 1473 | |
| 1474 | 1474 | sdmmc0_gpio: sdmmc0-gpio { |
| @@ -1642,50 +1642,50 @@ · 167 unmodified lines | ||
| 1642 | 1642 | rgmiim1_pins: rgmiim1-pins { |
| 1643 | 1643 | rockchip,pins = |
| 1644 | 1644 | /* mac_txclk */ |
| 1645 | − <1 RK_PB4 2 &pcfg_pull_none_12ma>, | |
| 1645 | + <1 RK_PB4 2 &pcfg_pull_none_8ma>, | |
| 1646 | 1646 | /* mac_rxclk */ |
| 1647 | − <1 RK_PB5 2 &pcfg_pull_none_2ma>, | |
| 1647 | + <1 RK_PB5 2 &pcfg_pull_none_4ma>, | |
| 1648 | 1648 | /* mac_mdio */ |
| 1649 | − <1 RK_PC3 2 &pcfg_pull_none_2ma>, | |
| 1649 | + <1 RK_PC3 2 &pcfg_pull_none_4ma>, | |
| 1650 | 1650 | /* mac_txen */ |
| 1651 | − <1 RK_PD1 2 &pcfg_pull_none_12ma>, | |
| 1651 | + <1 RK_PD1 2 &pcfg_pull_none_8ma>, | |
| 1652 | 1652 | /* mac_clk */ |
| 1653 | − <1 RK_PC5 2 &pcfg_pull_none_2ma>, | |
| 1653 | + <1 RK_PC5 2 &pcfg_pull_none_4ma>, | |
| 1654 | 1654 | /* mac_rxdv */ |
| 1655 | − <1 RK_PC6 2 &pcfg_pull_none_2ma>, | |
| 1655 | + <1 RK_PC6 2 &pcfg_pull_none_4ma>, | |
| 1656 | 1656 | /* mac_mdc */ |
| 1657 | − <1 RK_PC7 2 &pcfg_pull_none_2ma>, | |
| 1657 | + <1 RK_PC7 2 &pcfg_pull_none_4ma>, | |
| 1658 | 1658 | /* mac_rxd1 */ |
| 1659 | − <1 RK_PB2 2 &pcfg_pull_none_2ma>, | |
| 1659 | + <1 RK_PB2 2 &pcfg_pull_none_4ma>, | |
| 1660 | 1660 | /* mac_rxd0 */ |
| 1661 | − <1 RK_PB3 2 &pcfg_pull_none_2ma>, | |
| 1661 | + <1 RK_PB3 2 &pcfg_pull_none_4ma>, | |
| 1662 | 1662 | /* mac_txd1 */ |
| 1663 | − <1 RK_PB0 2 &pcfg_pull_none_12ma>, | |
| 1663 | + <1 RK_PB0 2 &pcfg_pull_none_8ma>, | |
| 1664 | 1664 | /* mac_txd0 */ |
| 1665 | − <1 RK_PB1 2 &pcfg_pull_none_12ma>, | |
| 1665 | + <1 RK_PB1 2 &pcfg_pull_none_8ma>, | |
| 1666 | 1666 | /* mac_rxd3 */ |
| 1667 | − <1 RK_PB6 2 &pcfg_pull_none_2ma>, | |
| 1667 | + <1 RK_PB6 2 &pcfg_pull_none_4ma>, | |
| 1668 | 1668 | /* mac_rxd2 */ |
| 1669 | − <1 RK_PB7 2 &pcfg_pull_none_2ma>, | |
| 1669 | + <1 RK_PB7 2 &pcfg_pull_none_4ma>, | |
| 1670 | 1670 | /* mac_txd3 */ |
| 1671 | − <1 RK_PC0 2 &pcfg_pull_none_12ma>, | |
| 1671 | + <1 RK_PC0 2 &pcfg_pull_none_8ma>, | |
| 1672 | 1672 | /* mac_txd2 */ |
| 1673 | − <1 RK_PC1 2 &pcfg_pull_none_12ma>, | |
| 1673 | + <1 RK_PC1 2 &pcfg_pull_none_8ma>, | |
| 1674 | 1674 | |
| 1675 | 1675 | /* mac_txclk */ |
| 1676 | − <0 RK_PB0 1 &pcfg_pull_none>, | |
| 1676 | + <0 RK_PB0 1 &pcfg_pull_none_8ma>, | |
| 1677 | 1677 | /* mac_txen */ |
| 1678 | − <0 RK_PB4 1 &pcfg_pull_none>, | |
| 1678 | + <0 RK_PB4 1 &pcfg_pull_none_8ma>, | |
| 1679 | 1679 | /* mac_clk */ |
| 1680 | − <0 RK_PD0 1 &pcfg_pull_none>, | |
| 1680 | + <0 RK_PD0 1 &pcfg_pull_none_4ma>, | |
| 1681 | 1681 | /* mac_txd1 */ |
| 1682 | − <0 RK_PC0 1 &pcfg_pull_none>, | |
| 1682 | + <0 RK_PC0 1 &pcfg_pull_none_8ma>, | |
| 1683 | 1683 | /* mac_txd0 */ |
| 1684 | − <0 RK_PC1 1 &pcfg_pull_none>, | |
| 1684 | + <0 RK_PC1 1 &pcfg_pull_none_8ma>, | |
| 1685 | 1685 | /* mac_txd3 */ |
| 1686 | − <0 RK_PC7 1 &pcfg_pull_none>, | |
| 1686 | + <0 RK_PC7 1 &pcfg_pull_none_8ma>, | |
| 1687 | 1687 | /* mac_txd2 */ |
| 1688 | − <0 RK_PC6 1 &pcfg_pull_none>; | |
| 1688 | + <0 RK_PC6 1 &pcfg_pull_none_8ma>; | |
| 1689 | 1689 | }; |
| 1690 | 1690 | |
| 1691 | 1691 | rmiim1_pins: rmiim1-pins { |
| @@ -158,6 +158,7 @@ · 157 unmodified lines | ||
| 158 | 158 | }; |
| 159 | 159 | |
| 160 | 160 | &hdmi { |
| 161 | + ddc-i2c-bus = <&i2c3>; | |
| 161 | 162 | pinctrl-names = "default"; |
| 162 | 163 | pinctrl-0 = <&hdmi_cec>; |
| 163 | 164 | status = "okay"; |
| @@ -65,52 +65,22 @@ static inline void syscall_set_return_value(struct task_struct *task, · 64 unmodified lines | ||
| 65 | 65 | |
| 66 | 66 | static inline void syscall_get_arguments(struct task_struct *task, |
| 67 | 67 | struct pt_regs *regs, |
| 68 | − unsigned int i, unsigned int n, | |
| 69 | 68 | unsigned long *args) |
| 70 | 69 | { |
| 71 | − if (n == 0) | |
| 72 | − return; | |
| 73 | − | |
| 74 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 75 | − unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i; | |
| 76 | − unsigned int n_bad = n + i - SYSCALL_MAX_ARGS; | |
| 77 | − pr_warning("%s called with max args %d, handling only %d\n", | |
| 78 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 79 | − memset(args_bad, 0, n_bad * sizeof(args[0])); | |
| 80 | − } | |
| 81 | − | |
| 82 | − if (i == 0) { | |
| 83 | − args[0] = regs->orig_x0; | |
| 84 | − args++; | |
| 85 | − i++; | |
| 86 | − n--; | |
| 87 | − } | |
| 88 | − | |
| 89 | − memcpy(args, ®s->regs[i], n * sizeof(args[0])); | |
| 70 | + args[0] = regs->orig_x0; | |
| 71 | + args++; | |
| 72 | + | |
| 73 | + memcpy(args, ®s->regs[1], 5 * sizeof(args[0])); | |
| 90 | 74 | } |
| 91 | 75 | |
| 92 | 76 | static inline void syscall_set_arguments(struct task_struct *task, |
| 93 | 77 | struct pt_regs *regs, |
| 94 | − unsigned int i, unsigned int n, | |
| 95 | 78 | const unsigned long *args) |
| 96 | 79 | { |
| 97 | − if (n == 0) | |
| 98 | − return; | |
| 99 | − | |
| 100 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 101 | − pr_warning("%s called with max args %d, handling only %d\n", | |
| 102 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 103 | − n = SYSCALL_MAX_ARGS - i; | |
| 104 | − } | |
| 105 | − | |
| 106 | − if (i == 0) { | |
| 107 | − regs->orig_x0 = args[0]; | |
| 108 | − args++; | |
| 109 | − i++; | |
| 110 | − n--; | |
| 111 | − } | |
| 112 | − | |
| 113 | − memcpy(®s->regs[i], args, n * sizeof(args[0])); | |
| 80 | + regs->orig_x0 = args[0]; | |
| 81 | + args++; | |
| 82 | + | |
| 83 | + memcpy(®s->regs[1], args, 5 * sizeof(args[0])); | |
| 114 | 84 | } |
| 115 | 85 | |
| 116 | 86 | /* |
| @@ -94,6 +94,9 @@ static bool on_sdei_normal_stack(unsigned long sp, struct stack_info *info) · 93 unmodified lines | ||
| 94 | 94 | unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_normal_ptr); |
| 95 | 95 | unsigned long high = low + SDEI_STACK_SIZE; |
| 96 | 96 | |
| 97 | + if (!low) | |
| 98 | + return false; | |
| 99 | + | |
| 97 | 100 | if (sp < low || sp >= high) |
| 98 | 101 | return false; |
| 99 | 102 | |
| @@ -111,6 +114,9 @@ static bool on_sdei_critical_stack(unsigned long sp, struct stack_info *info) · 11 unmodified lines | ||
| 111 | 114 | unsigned long low = (unsigned long)raw_cpu_read(sdei_stack_critical_ptr); |
| 112 | 115 | unsigned long high = low + SDEI_STACK_SIZE; |
| 113 | 116 | |
| 117 | + if (!low) | |
| 118 | + return false; | |
| 119 | + | |
| 114 | 120 | if (sp < low || sp >= high) |
| 115 | 121 | return false; |
| 116 | 122 | |
| @@ -46,78 +46,27 @@ static inline void syscall_set_return_value(struct task_struct *task, · 45 unmodified lines | ||
| 46 | 46 | } |
| 47 | 47 | |
| 48 | 48 | static inline void syscall_get_arguments(struct task_struct *task, |
| 49 | − struct pt_regs *regs, unsigned int i, | |
| 50 | − unsigned int n, unsigned long *args) | |
| 49 | + struct pt_regs *regs, | |
| 50 | + unsigned long *args) | |
| 51 | 51 | { |
| 52 | − switch (i) { | |
| 53 | − case 0: | |
| 54 | − if (!n--) | |
| 55 | − break; | |
| 56 | − *args++ = regs->a4; | |
| 57 | − case 1: | |
| 58 | − if (!n--) | |
| 59 | − break; | |
| 60 | − *args++ = regs->b4; | |
| 61 | − case 2: | |
| 62 | − if (!n--) | |
| 63 | − break; | |
| 64 | − *args++ = regs->a6; | |
| 65 | − case 3: | |
| 66 | − if (!n--) | |
| 67 | − break; | |
| 68 | − *args++ = regs->b6; | |
| 69 | − case 4: | |
| 70 | − if (!n--) | |
| 71 | − break; | |
| 72 | − *args++ = regs->a8; | |
| 73 | − case 5: | |
| 74 | − if (!n--) | |
| 75 | − break; | |
| 76 | − *args++ = regs->b8; | |
| 77 | − case 6: | |
| 78 | − if (!n--) | |
| 79 | − break; | |
| 80 | − default: | |
| 81 | − BUG(); | |
| 82 | − } | |
| 52 | + *args++ = regs->a4; | |
| 53 | + *args++ = regs->b4; | |
| 54 | + *args++ = regs->a6; | |
| 55 | + *args++ = regs->b6; | |
| 56 | + *args++ = regs->a8; | |
| 57 | + *args = regs->b8; | |
| 83 | 58 | } |
| 84 | 59 | |
| 85 | 60 | static inline void syscall_set_arguments(struct task_struct *task, |
| 86 | 61 | struct pt_regs *regs, |
| 87 | − unsigned int i, unsigned int n, | |
| 88 | 62 | const unsigned long *args) |
| 89 | 63 | { |
| 90 | − switch (i) { | |
| 91 | − case 0: | |
| 92 | − if (!n--) | |
| 93 | − break; | |
| 94 | − regs->a4 = *args++; | |
| 95 | − case 1: | |
| 96 | − if (!n--) | |
| 97 | − break; | |
| 98 | − regs->b4 = *args++; | |
| 99 | − case 2: | |
| 100 | − if (!n--) | |
| 101 | − break; | |
| 102 | − regs->a6 = *args++; | |
| 103 | − case 3: | |
| 104 | − if (!n--) | |
| 105 | − break; | |
| 106 | − regs->b6 = *args++; | |
| 107 | − case 4: | |
| 108 | − if (!n--) | |
| 109 | − break; | |
| 110 | − regs->a8 = *args++; | |
| 111 | − case 5: | |
| 112 | − if (!n--) | |
| 113 | − break; | |
| 114 | − regs->a9 = *args++; | |
| 115 | − case 6: | |
| 116 | − if (!n) | |
| 117 | − break; | |
| 118 | − default: | |
| 119 | − BUG(); | |
| 120 | − } | |
| 64 | + regs->a4 = *args++; | |
| 65 | + regs->b4 = *args++; | |
| 66 | + regs->a6 = *args++; | |
| 67 | + regs->b6 = *args++; | |
| 68 | + regs->a8 = *args++; | |
| 69 | + regs->a9 = *args; | |
| 121 | 70 | } |
| 122 | 71 | |
| 123 | 72 | #endif /* __ASM_C6X_SYSCALLS_H */ |
| @@ -43,30 +43,20 @@ syscall_set_return_value(struct task_struct *task, struct pt_regs *regs, · 42 unmodified lines | ||
| 43 | 43 | |
| 44 | 44 | static inline void |
| 45 | 45 | syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 46 | − unsigned int i, unsigned int n, unsigned long *args) | |
| 46 | + unsigned long *args) | |
| 47 | 47 | { |
| 48 | − BUG_ON(i + n > 6); | |
| 49 | − if (i == 0) { | |
| 50 | − args[0] = regs->orig_a0; | |
| 51 | − args++; | |
| 52 | − i++; | |
| 53 | − n--; | |
| 54 | − } | |
| 55 | − memcpy(args, ®s->a1 + i * sizeof(regs->a1), n * sizeof(args[0])); | |
| 48 | + args[0] = regs->orig_a0; | |
| 49 | + args++; | |
| 50 | + memcpy(args, ®s->a1, 5 * sizeof(args[0])); | |
| 56 | 51 | } |
| 57 | 52 | |
| 58 | 53 | static inline void |
| 59 | 54 | syscall_set_arguments(struct task_struct *task, struct pt_regs *regs, |
| 60 | − unsigned int i, unsigned int n, const unsigned long *args) | |
| 55 | + const unsigned long *args) | |
| 61 | 56 | { |
| 62 | − BUG_ON(i + n > 6); | |
| 63 | − if (i == 0) { | |
| 64 | − regs->orig_a0 = args[0]; | |
| 65 | − args++; | |
| 66 | − i++; | |
| 67 | − n--; | |
| 68 | − } | |
| 69 | − memcpy(®s->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0)); | |
| 57 | + regs->orig_a0 = args[0]; | |
| 58 | + args++; | |
| 59 | + memcpy(®s->a1, args, 5 * sizeof(regs->a1)); | |
| 70 | 60 | } |
| 71 | 61 | |
| 72 | 62 | static inline int |
| @@ -17,34 +17,14 @@ syscall_get_nr(struct task_struct *task, struct pt_regs *regs) · 16 unmodified lines | ||
| 17 | 17 | |
| 18 | 18 | static inline void |
| 19 | 19 | syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 20 | − unsigned int i, unsigned int n, unsigned long *args) | |
| 20 | + unsigned long *args) | |
| 21 | 21 | { |
| 22 | − BUG_ON(i + n > 6); | |
| 23 | − | |
| 24 | − while (n > 0) { | |
| 25 | − switch (i) { | |
| 26 | − case 0: | |
| 27 | − *args++ = regs->er1; | |
| 28 | − break; | |
| 29 | − case 1: | |
| 30 | − *args++ = regs->er2; | |
| 31 | − break; | |
| 32 | − case 2: | |
| 33 | − *args++ = regs->er3; | |
| 34 | − break; | |
| 35 | − case 3: | |
| 36 | − *args++ = regs->er4; | |
| 37 | − break; | |
| 38 | − case 4: | |
| 39 | − *args++ = regs->er5; | |
| 40 | − break; | |
| 41 | − case 5: | |
| 42 | − *args++ = regs->er6; | |
| 43 | − break; | |
| 44 | − } | |
| 45 | − i++; | |
| 46 | − n--; | |
| 47 | − } | |
| 22 | + *args++ = regs->er1; | |
| 23 | + *args++ = regs->er2; | |
| 24 | + *args++ = regs->er3; | |
| 25 | + *args++ = regs->er4; | |
| 26 | + *args++ = regs->er5; | |
| 27 | + *args = regs->er6; | |
| 48 | 28 | } |
| 49 | 29 | |
| 50 | 30 | |
| @@ -37,10 +37,8 @@ static inline long syscall_get_nr(struct task_struct *task, · 36 unmodified lines | ||
| 37 | 37 | |
| 38 | 38 | static inline void syscall_get_arguments(struct task_struct *task, |
| 39 | 39 | struct pt_regs *regs, |
| 40 | − unsigned int i, unsigned int n, | |
| 41 | 40 | unsigned long *args) |
| 42 | 41 | { |
| 43 | − BUG_ON(i + n > 6); | |
| 44 | − memcpy(args, &(®s->r00)[i], n * sizeof(args[0])); | |
| 42 | + memcpy(args, &(®s->r00)[0], 6 * sizeof(args[0])); | |
| 45 | 43 | } |
| 46 | 44 | #endif |
| @@ -59,26 +59,19 @@ static inline void syscall_set_return_value(struct task_struct *task, · 58 unmodified lines | ||
| 59 | 59 | } |
| 60 | 60 | |
| 61 | 61 | extern void ia64_syscall_get_set_arguments(struct task_struct *task, |
| 62 | − struct pt_regs *regs, unsigned int i, unsigned int n, | |
| 63 | − unsigned long *args, int rw); | |
| 62 | + struct pt_regs *regs, unsigned long *args, int rw); | |
| 64 | 63 | static inline void syscall_get_arguments(struct task_struct *task, |
| 65 | 64 | struct pt_regs *regs, |
| 66 | − unsigned int i, unsigned int n, | |
| 67 | 65 | unsigned long *args) |
| 68 | 66 | { |
| 69 | − BUG_ON(i + n > 6); | |
| 70 | − | |
| 71 | − ia64_syscall_get_set_arguments(task, regs, i, n, args, 0); | |
| 67 | + ia64_syscall_get_set_arguments(task, regs, args, 0); | |
| 72 | 68 | } |
| 73 | 69 | |
| 74 | 70 | static inline void syscall_set_arguments(struct task_struct *task, |
| 75 | 71 | struct pt_regs *regs, |
| 76 | − unsigned int i, unsigned int n, | |
| 77 | 72 | unsigned long *args) |
| 78 | 73 | { |
| 79 | − BUG_ON(i + n > 6); | |
| 80 | − | |
| 81 | − ia64_syscall_get_set_arguments(task, regs, i, n, args, 1); | |
| 74 | + ia64_syscall_get_set_arguments(task, regs, args, 1); | |
| 82 | 75 | } |
| 83 | 76 | |
| 84 | 77 | static inline int syscall_get_arch(void) |
| @@ -2179,12 +2179,11 @@ static void syscall_get_set_args_cb(struct unw_frame_info *info, void *data) · 2178 unmodified lines | ||
| 2179 | 2179 | } |
| 2180 | 2180 | |
| 2181 | 2181 | void ia64_syscall_get_set_arguments(struct task_struct *task, |
| 2182 | − struct pt_regs *regs, unsigned int i, unsigned int n, | |
| 2183 | − unsigned long *args, int rw) | |
| 2182 | + struct pt_regs *regs, unsigned long *args, int rw) | |
| 2184 | 2183 | { |
| 2185 | 2184 | struct syscall_get_set_args data = { |
| 2186 | − .i = i, | |
| 2187 | − .n = n, | |
| 2185 | + .i = 0, | |
| 2186 | + .n = 6, | |
| 2188 | 2187 | .args = args, |
| 2189 | 2188 | .regs = regs, |
| 2190 | 2189 | .rw = rw, |
| @@ -82,18 +82,22 @@ static inline void microblaze_set_syscall_arg(struct pt_regs *regs, · 81 unmodified lines | ||
| 82 | 82 | |
| 83 | 83 | static inline void syscall_get_arguments(struct task_struct *task, |
| 84 | 84 | struct pt_regs *regs, |
| 85 | − unsigned int i, unsigned int n, | |
| 86 | 85 | unsigned long *args) |
| 87 | 86 | { |
| 87 | + unsigned int i = 0; | |
| 88 | + unsigned int n = 6; | |
| 89 | + | |
| 88 | 90 | while (n--) |
| 89 | 91 | *args++ = microblaze_get_syscall_arg(regs, i++); |
| 90 | 92 | } |
| 91 | 93 | |
| 92 | 94 | static inline void syscall_set_arguments(struct task_struct *task, |
| 93 | 95 | struct pt_regs *regs, |
| 94 | − unsigned int i, unsigned int n, | |
| 95 | 96 | const unsigned long *args) |
| 96 | 97 | { |
| 98 | + unsigned int i = 0; | |
| 99 | + unsigned int n = 6; | |
| 100 | + | |
| 97 | 101 | while (n--) |
| 98 | 102 | microblaze_set_syscall_arg(regs, i++, *args++); |
| 99 | 103 | } |
| @@ -1,6 +1,10 @@ | ||
| 1 | 1 | # require CONFIG_CPU_MIPS32_R2=y |
| 2 | 2 | |
| 3 | 3 | CONFIG_LEGACY_BOARD_OCELOT=y |
| 4 | +CONFIG_FIT_IMAGE_FDT_OCELOT=y | |
| 5 | + | |
| 6 | +CONFIG_BRIDGE=y | |
| 7 | +CONFIG_GENERIC_PHY=y | |
| 4 | 8 | |
| 5 | 9 | CONFIG_MTD=y |
| 6 | 10 | CONFIG_MTD_CMDLINE_PARTS=y |
| @@ -19,6 +23,8 @@ CONFIG_SERIAL_8250_CONSOLE=y · 12 unmodified lines | ||
| 19 | 23 | CONFIG_SERIAL_OF_PLATFORM=y |
| 20 | 24 | |
| 21 | 25 | CONFIG_NETDEVICES=y |
| 26 | +CONFIG_NET_SWITCHDEV=y | |
| 27 | +CONFIG_NET_DSA=y | |
| 22 | 28 | CONFIG_MSCC_OCELOT_SWITCH=y |
| 23 | 29 | CONFIG_MSCC_OCELOT_SWITCH_OCELOT=y |
| 24 | 30 | CONFIG_MDIO_MSCC_MIIM=y |
| @@ -35,6 +41,8 @@ CONFIG_SPI_DESIGNWARE=y · 10 unmodified lines | ||
| 35 | 41 | CONFIG_SPI_DW_MMIO=y |
| 36 | 42 | CONFIG_SPI_SPIDEV=y |
| 37 | 43 | |
| 44 | +CONFIG_PINCTRL_OCELOT=y | |
| 45 | + | |
| 38 | 46 | CONFIG_GPIO_SYSFS=y |
| 39 | 47 | |
| 40 | 48 | CONFIG_POWER_RESET=y |
| @@ -116,9 +116,10 @@ static inline void syscall_set_return_value(struct task_struct *task, · 115 unmodified lines | ||
| 116 | 116 | |
| 117 | 117 | static inline void syscall_get_arguments(struct task_struct *task, |
| 118 | 118 | struct pt_regs *regs, |
| 119 | − unsigned int i, unsigned int n, | |
| 120 | 119 | unsigned long *args) |
| 121 | 120 | { |
| 121 | + unsigned int i = 0; | |
| 122 | + unsigned int n = 6; | |
| 122 | 123 | int ret; |
| 123 | 124 | |
| 124 | 125 | /* O32 ABI syscall() */ |
| @@ -33,6 +33,7 @@ · 32 unmodified lines | ||
| 33 | 33 | #include <asm/processor.h> |
| 34 | 34 | #include <asm/sigcontext.h> |
| 35 | 35 | #include <linux/uaccess.h> |
| 36 | +#include <asm/irq_regs.h> | |
| 36 | 37 | |
| 37 | 38 | static struct hard_trap_info { |
| 38 | 39 | unsigned char tt; /* Trap type code for MIPS R3xxx and R4xxx */ |
| @@ -214,7 +215,7 @@ void kgdb_call_nmi_hook(void *ignored) · 175 unmodified lines | ||
| 214 | 215 | old_fs = get_fs(); |
| 215 | 216 | set_fs(KERNEL_DS); |
| 216 | 217 | |
| 217 | − kgdb_nmicallback(raw_smp_processor_id(), NULL); | |
| 218 | + kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs()); | |
| 218 | 219 | |
| 219 | 220 | set_fs(old_fs); |
| 220 | 221 | } |
| @@ -1419,7 +1419,7 @@ asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall) · 1418 unmodified lines | ||
| 1419 | 1419 | |
| 1420 | 1420 | sd.nr = syscall; |
| 1421 | 1421 | sd.arch = syscall_get_arch(); |
| 1422 | − syscall_get_arguments(current, regs, 0, 6, args); | |
| 1422 | + syscall_get_arguments(current, regs, args); | |
| 1423 | 1423 | for (i = 0; i < 6; i++) |
| 1424 | 1424 | sd.args[i] = args[i]; |
| 1425 | 1425 | sd.instruction_pointer = KSTK_EIP(current); |
| @@ -118,7 +118,6 @@ static void shutdown_bridge_irq(struct irq_data *d) · 117 unmodified lines | ||
| 118 | 118 | { |
| 119 | 119 | struct hub_irq_data *hd = irq_data_get_irq_chip_data(d); |
| 120 | 120 | struct bridge_controller *bc; |
| 121 | − int pin = hd->pin; | |
| 122 | 121 | |
| 123 | 122 | if (!hd) |
| 124 | 123 | return; |
| @@ -126,7 +125,7 @@ static void shutdown_bridge_irq(struct irq_data *d) · 1 unmodified line | ||
| 126 | 125 | disable_hub_irq(d); |
| 127 | 126 | |
| 128 | 127 | bc = hd->bc; |
| 129 | − bridge_clr(bc, b_int_enable, (1 << pin)); | |
| 128 | + bridge_clr(bc, b_int_enable, (1 << hd->pin)); | |
| 130 | 129 | bridge_read(bc, b_wid_tflush); |
| 131 | 130 | } |
| 132 | 131 | |
| @@ -108,81 +108,41 @@ void syscall_set_return_value(struct task_struct *task, struct pt_regs *regs, · 107 unmodified lines | ||
| 108 | 108 | * syscall_get_arguments - extract system call parameter values |
| 109 | 109 | * @task: task of interest, must be blocked |
| 110 | 110 | * @regs: task_pt_regs() of @task |
| 111 | − * @i: argument index [0,5] | |
| 112 | − * @n: number of arguments; n+i must be [1,6]. | |
| 113 | 111 | * @args: array filled with argument values |
| 114 | 112 | * |
| 115 | − * Fetches @n arguments to the system call starting with the @i'th argument | |
| 116 | − * (from 0 through 5). Argument @i is stored in @args[0], and so on. | |
| 117 | − * An arch inline version is probably optimal when @i and @n are constants. | |
| 113 | + * Fetches 6 arguments to the system call (from 0 through 5). The first | |
| 114 | + * argument is stored in @args[0], and so on. | |
| 118 | 115 | * |
| 119 | 116 | * It's only valid to call this when @task is stopped for tracing on |
| 120 | 117 | * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT. |
| 121 | − * It's invalid to call this with @i + @n > 6; we only support system calls | |
| 122 | − * taking up to 6 arguments. | |
| 123 | 118 | */ |
| 124 | 119 | #define SYSCALL_MAX_ARGS 6 |
| 125 | 120 | void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 126 | − unsigned int i, unsigned int n, unsigned long *args) | |
| 121 | + unsigned long *args) | |
| 127 | 122 | { |
| 128 | − if (n == 0) | |
| 129 | − return; | |
| 130 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 131 | − unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i; | |
| 132 | − unsigned int n_bad = n + i - SYSCALL_MAX_ARGS; | |
| 133 | − pr_warning("%s called with max args %d, handling only %d\n", | |
| 134 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 135 | − memset(args_bad, 0, n_bad * sizeof(args[0])); | |
| 136 | − memset(args_bad, 0, n_bad * sizeof(args[0])); | |
| 137 | − } | |
| 138 | − | |
| 139 | − if (i == 0) { | |
| 140 | − args[0] = regs->orig_r0; | |
| 141 | − args++; | |
| 142 | − i++; | |
| 143 | − n--; | |
| 144 | − } | |
| 145 | − | |
| 146 | − memcpy(args, ®s->uregs[0] + i, n * sizeof(args[0])); | |
| 123 | + args[0] = regs->orig_r0; | |
| 124 | + args++; | |
| 125 | + memcpy(args, ®s->uregs[0] + 1, 5 * sizeof(args[0])); | |
| 147 | 126 | } |
| 148 | 127 | |
| 149 | 128 | /** |
| 150 | 129 | * syscall_set_arguments - change system call parameter value |
| 151 | 130 | * @task: task of interest, must be in system call entry tracing |
| 152 | 131 | * @regs: task_pt_regs() of @task |
| 153 | − * @i: argument index [0,5] | |
| 154 | − * @n: number of arguments; n+i must be [1,6]. | |
| 155 | 132 | * @args: array of argument values to store |
| 156 | 133 | * |
| 157 | − * Changes @n arguments to the system call starting with the @i'th argument. | |
| 158 | − * Argument @i gets value @args[0], and so on. | |
| 159 | − * An arch inline version is probably optimal when @i and @n are constants. | |
| 134 | + * Changes 6 arguments to the system call. The first argument gets value | |
| 135 | + * @args[0], and so on. | |
| 160 | 136 | * |
| 161 | 137 | * It's only valid to call this when @task is stopped for tracing on |
| 162 | 138 | * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT. |
| 163 | − * It's invalid to call this with @i + @n > 6; we only support system calls | |
| 164 | − * taking up to 6 arguments. | |
| 165 | 139 | */ |
| 166 | 140 | void syscall_set_arguments(struct task_struct *task, struct pt_regs *regs, |
| 167 | − unsigned int i, unsigned int n, | |
| 168 | 141 | const unsigned long *args) |
| 169 | 142 | { |
| 170 | − if (n == 0) | |
| 171 | − return; | |
| 172 | − | |
| 173 | − if (i + n > SYSCALL_MAX_ARGS) { | |
| 174 | − pr_warn("%s called with max args %d, handling only %d\n", | |
| 175 | − __func__, i + n, SYSCALL_MAX_ARGS); | |
| 176 | − n = SYSCALL_MAX_ARGS - i; | |
| 177 | − } | |
| 178 | − | |
| 179 | − if (i == 0) { | |
| 180 | − regs->orig_r0 = args[0]; | |
| 181 | − args++; | |
| 182 | − i++; | |
| 183 | − n--; | |
| 184 | − } | |
| 143 | + regs->orig_r0 = args[0]; | |
| 144 | + args++; | |
| 185 | 145 | |
| 186 | − memcpy(®s->uregs[0] + i, args, n * sizeof(args[0])); | |
| 146 | + memcpy(®s->uregs[0] + 1, args, 5 * sizeof(args[0])); | |
| 187 | 147 | } |
| 188 | 148 | #endif /* _ASM_NDS32_SYSCALL_H */ |
| @@ -58,81 +58,25 @@ static inline void syscall_set_return_value(struct task_struct *task, · 57 unmodified lines | ||
| 58 | 58 | } |
| 59 | 59 | |
| 60 | 60 | static inline void syscall_get_arguments(struct task_struct *task, |
| 61 | − struct pt_regs *regs, unsigned int i, unsigned int n, | |
| 62 | − unsigned long *args) | |
| 61 | + struct pt_regs *regs, unsigned long *args) | |
| 63 | 62 | { |
| 64 | − BUG_ON(i + n > 6); | |
| 65 | − | |
| 66 | − switch (i) { | |
| 67 | − case 0: | |
| 68 | − if (!n--) | |
| 69 | − break; | |
| 70 | − *args++ = regs->r4; | |
| 71 | − case 1: | |
| 72 | − if (!n--) | |
| 73 | − break; | |
| 74 | − *args++ = regs->r5; | |
| 75 | − case 2: | |
| 76 | − if (!n--) | |
| 77 | − break; | |
| 78 | − *args++ = regs->r6; | |
| 79 | − case 3: | |
| 80 | − if (!n--) | |
| 81 | − break; | |
| 82 | − *args++ = regs->r7; | |
| 83 | − case 4: | |
| 84 | − if (!n--) | |
| 85 | − break; | |
| 86 | − *args++ = regs->r8; | |
| 87 | − case 5: | |
| 88 | − if (!n--) | |
| 89 | − break; | |
| 90 | − *args++ = regs->r9; | |
| 91 | − case 6: | |
| 92 | − if (!n--) | |
| 93 | − break; | |
| 94 | − default: | |
| 95 | − BUG(); | |
| 96 | − } | |
| 63 | + *args++ = regs->r4; | |
| 64 | + *args++ = regs->r5; | |
| 65 | + *args++ = regs->r6; | |
| 66 | + *args++ = regs->r7; | |
| 67 | + *args++ = regs->r8; | |
| 68 | + *args = regs->r9; | |
| 97 | 69 | } |
| 98 | 70 | |
| 99 | 71 | static inline void syscall_set_arguments(struct task_struct *task, |
| 100 | − struct pt_regs *regs, unsigned int i, unsigned int n, | |
| 101 | − const unsigned long *args) | |
| 72 | + struct pt_regs *regs, const unsigned long *args) | |
| 102 | 73 | { |
| 103 | − BUG_ON(i + n > 6); | |
| 104 | − | |
| 105 | − switch (i) { | |
| 106 | − case 0: | |
| 107 | − if (!n--) | |
| 108 | − break; | |
| 109 | − regs->r4 = *args++; | |
| 110 | − case 1: | |
| 111 | − if (!n--) | |
| 112 | − break; | |
| 113 | − regs->r5 = *args++; | |
| 114 | − case 2: | |
| 115 | − if (!n--) | |
| 116 | − break; | |
| 117 | − regs->r6 = *args++; | |
| 118 | − case 3: | |
| 119 | − if (!n--) | |
| 120 | − break; | |
| 121 | − regs->r7 = *args++; | |
| 122 | − case 4: | |
| 123 | − if (!n--) | |
| 124 | − break; | |
| 125 | − regs->r8 = *args++; | |
| 126 | − case 5: | |
| 127 | − if (!n--) | |
| 128 | − break; | |
| 129 | − regs->r9 = *args++; | |
| 130 | − case 6: | |
| 131 | − if (!n) | |
| 132 | − break; | |
| 133 | − default: | |
| 134 | − BUG(); | |
| 135 | − } | |
| 74 | + regs->r4 = *args++; | |
| 75 | + regs->r5 = *args++; | |
| 76 | + regs->r6 = *args++; | |
| 77 | + regs->r7 = *args++; | |
| 78 | + regs->r8 = *args++; | |
| 79 | + regs->r9 = *args; | |
| 136 | 80 | } |
| 137 | 81 | |
| 138 | 82 | #endif |
| @@ -56,20 +56,16 @@ syscall_set_return_value(struct task_struct *task, struct pt_regs *regs, · 55 unmodified lines | ||
| 56 | 56 | |
| 57 | 57 | static inline void |
| 58 | 58 | syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 59 | − unsigned int i, unsigned int n, unsigned long *args) | |
| 59 | + unsigned long *args) | |
| 60 | 60 | { |
| 61 | − BUG_ON(i + n > 6); | |
| 62 | − | |
| 63 | − memcpy(args, ®s->gpr[3 + i], n * sizeof(args[0])); | |
| 61 | + memcpy(args, ®s->gpr[3], 6 * sizeof(args[0])); | |
| 64 | 62 | } |
| 65 | 63 | |
| 66 | 64 | static inline void |
| 67 | 65 | syscall_set_arguments(struct task_struct *task, struct pt_regs *regs, |
| 68 | − unsigned int i, unsigned int n, const unsigned long *args) | |
| 66 | + const unsigned long *args) | |
| 69 | 67 | { |
| 70 | − BUG_ON(i + n > 6); | |
| 71 | − | |
| 72 | − memcpy(®s->gpr[3 + i], args, n * sizeof(args[0])); | |
| 68 | + memcpy(®s->gpr[3], args, 6 * sizeof(args[0])); | |
| 73 | 69 | } |
| 74 | 70 | |
| 75 | 71 | static inline int syscall_get_arch(void) |
| @@ -22,13 +22,14 @@ unsigned long profile_pc(struct pt_regs *); · 21 unmodified lines | ||
| 22 | 22 | |
| 23 | 23 | static inline unsigned long regs_return_value(struct pt_regs *regs) |
| 24 | 24 | { |
| 25 | − return regs->gr[20]; | |
| 25 | + return regs->gr[28]; | |
| 26 | 26 | } |
| 27 | 27 | |
| 28 | 28 | static inline void instruction_pointer_set(struct pt_regs *regs, |
| 29 | 29 | unsigned long val) |
| 30 | 30 | { |
| 31 | − regs->iaoq[0] = val; | |
| 31 | + regs->iaoq[0] = val; | |
| 32 | + regs->iaoq[1] = val + 4; | |
| 32 | 33 | } |
| 33 | 34 | |
| 34 | 35 | /* Query offset/name of register from its name/offset */ |
| @@ -18,29 +18,15 @@ static inline long syscall_get_nr(struct task_struct *tsk, · 17 unmodified lines | ||
| 18 | 18 | } |
| 19 | 19 | |
| 20 | 20 | static inline void syscall_get_arguments(struct task_struct *tsk, |
| 21 | − struct pt_regs *regs, unsigned int i, | |
| 22 | − unsigned int n, unsigned long *args) | |
| 21 | + struct pt_regs *regs, | |
| 22 | + unsigned long *args) | |
| 23 | 23 | { |
| 24 | − BUG_ON(i); | |
| 25 | − | |
| 26 | − switch (n) { | |
| 27 | − case 6: | |
| 28 | − args[5] = regs->gr[21]; | |
| 29 | − case 5: | |
| 30 | − args[4] = regs->gr[22]; | |
| 31 | − case 4: | |
| 32 | − args[3] = regs->gr[23]; | |
| 33 | − case 3: | |
| 34 | − args[2] = regs->gr[24]; | |
| 35 | − case 2: | |
| 36 | − args[1] = regs->gr[25]; | |
| 37 | − case 1: | |
| 38 | − args[0] = regs->gr[26]; | |
| 39 | − case 0: | |
| 40 | − break; | |
| 41 | − default: | |
| 42 | − BUG(); | |
| 43 | − } | |
| 24 | + args[5] = regs->gr[21]; | |
| 25 | + args[4] = regs->gr[22]; | |
| 26 | + args[3] = regs->gr[23]; | |
| 27 | + args[2] = regs->gr[24]; | |
| 28 | + args[1] = regs->gr[25]; | |
| 29 | + args[0] = regs->gr[26]; | |
| 44 | 30 | } |
| 45 | 31 | |
| 46 | 32 | static inline long syscall_get_return_value(struct task_struct *task, |
| @@ -210,12 +210,6 @@ void __cpuidle arch_cpu_idle(void) · 209 unmodified lines | ||
| 210 | 210 | |
| 211 | 211 | static int __init parisc_idle_init(void) |
| 212 | 212 | { |
| 213 | − const char *marker; | |
| 214 | − | |
| 215 | − /* check QEMU/SeaBIOS marker in PAGE0 */ | |
| 216 | − marker = (char *) &PAGE0->pad0; | |
| 217 | − running_on_qemu = (memcmp(marker, "SeaBIOS", 8) == 0); | |
| 218 | − | |
| 219 | 213 | if (!running_on_qemu) |
| 220 | 214 | cpu_idle_poll_ctrl(1); |
| 221 | 215 | |
| @@ -397,6 +397,9 @@ void __init start_parisc(void) · 396 unmodified lines | ||
| 397 | 397 | int ret, cpunum; |
| 398 | 398 | struct pdc_coproc_cfg coproc_cfg; |
| 399 | 399 | |
| 400 | + /* check QEMU/SeaBIOS marker in PAGE0 */ | |
| 401 | + running_on_qemu = (memcmp(&PAGE0->pad0, "SeaBIOS", 8) == 0); | |
| 402 | + | |
| 400 | 403 | cpunum = smp_processor_id(); |
| 401 | 404 | |
| 402 | 405 | init_cpu_topology(); |
| @@ -65,22 +65,20 @@ static inline void syscall_set_return_value(struct task_struct *task, · 64 unmodified lines | ||
| 65 | 65 | |
| 66 | 66 | static inline void syscall_get_arguments(struct task_struct *task, |
| 67 | 67 | struct pt_regs *regs, |
| 68 | − unsigned int i, unsigned int n, | |
| 69 | 68 | unsigned long *args) |
| 70 | 69 | { |
| 71 | 70 | unsigned long val, mask = -1UL; |
| 72 | − | |
| 73 | − BUG_ON(i + n > 6); | |
| 71 | + unsigned int n = 6; | |
| 74 | 72 | |
| 75 | 73 | #ifdef CONFIG_COMPAT |
| 76 | 74 | if (test_tsk_thread_flag(task, TIF_32BIT)) |
| 77 | 75 | mask = 0xffffffff; |
| 78 | 76 | #endif |
| 79 | 77 | while (n--) { |
| 80 | − if (n == 0 && i == 0) | |
| 78 | + if (n == 0) | |
| 81 | 79 | val = regs->orig_gpr3; |
| 82 | 80 | else |
| 83 | − val = regs->gpr[3 + i + n]; | |
| 81 | + val = regs->gpr[3 + n]; | |
| 84 | 82 | |
| 85 | 83 | args[n] = val & mask; |
| 86 | 84 | } |
| @@ -88,15 +86,12 @@ static inline void syscall_get_arguments(struct task_struct *task, · 1 unmodified line | ||
| 88 | 86 | |
| 89 | 87 | static inline void syscall_set_arguments(struct task_struct *task, |
| 90 | 88 | struct pt_regs *regs, |
| 91 | − unsigned int i, unsigned int n, | |
| 92 | 89 | const unsigned long *args) |
| 93 | 90 | { |
| 94 | − BUG_ON(i + n > 6); | |
| 95 | − memcpy(®s->gpr[3 + i], args, n * sizeof(args[0])); | |
| 91 | + memcpy(®s->gpr[3], args, 6 * sizeof(args[0])); | |
| 96 | 92 | |
| 97 | 93 | /* Also copy the first argument into orig_gpr3 */ |
| 98 | − if (i == 0 && n > 0) | |
| 99 | − regs->orig_gpr3 = args[0]; | |
| 94 | + regs->orig_gpr3 = args[0]; | |
| 100 | 95 | } |
| 101 | 96 | |
| 102 | 97 | static inline int syscall_get_arch(void) |
| @@ -22,6 +22,7 @@ · 21 unmodified lines | ||
| 22 | 22 | #include <linux/kvm_host.h> |
| 23 | 23 | #include <linux/init.h> |
| 24 | 24 | #include <linux/export.h> |
| 25 | +#include <linux/kmemleak.h> | |
| 25 | 26 | #include <linux/kvm_para.h> |
| 26 | 27 | #include <linux/slab.h> |
| 27 | 28 | #include <linux/of.h> |
| @@ -712,6 +713,12 @@ static void kvm_use_magic_page(void) · 684 unmodified lines | ||
| 712 | 713 | |
| 713 | 714 | static __init void kvm_free_tmp(void) |
| 714 | 715 | { |
| 716 | + /* | |
| 717 | + * Inform kmemleak about the hole in the .bss section since the | |
| 718 | + * corresponding pages will be unmapped with DEBUG_PAGEALLOC=y. | |
| 719 | + */ | |
| 720 | + kmemleak_free_part(&kvm_tmp[kvm_tmp_index], | |
| 721 | + ARRAY_SIZE(kvm_tmp) - kvm_tmp_index); | |
| 715 | 722 | free_reserved_area(&kvm_tmp[kvm_tmp_index], |
| 716 | 723 | &kvm_tmp[ARRAY_SIZE(kvm_tmp)], -1, NULL); |
| 717 | 724 | } |
| @@ -26,7 +26,7 @@ enum fixed_addresses { · 25 unmodified lines | ||
| 26 | 26 | }; |
| 27 | 27 | |
| 28 | 28 | #define FIXADDR_SIZE (__end_of_fixed_addresses * PAGE_SIZE) |
| 29 | −#define FIXADDR_TOP (PAGE_OFFSET) | |
| 29 | +#define FIXADDR_TOP (VMALLOC_START) | |
| 30 | 30 | #define FIXADDR_START (FIXADDR_TOP - FIXADDR_SIZE) |
| 31 | 31 | |
| 32 | 32 | #define FIXMAP_PAGE_IO PAGE_KERNEL |
| @@ -72,32 +72,20 @@ static inline void syscall_set_return_value(struct task_struct *task, · 71 unmodified lines | ||
| 72 | 72 | |
| 73 | 73 | static inline void syscall_get_arguments(struct task_struct *task, |
| 74 | 74 | struct pt_regs *regs, |
| 75 | − unsigned int i, unsigned int n, | |
| 76 | 75 | unsigned long *args) |
| 77 | 76 | { |
| 78 | − BUG_ON(i + n > 6); | |
| 79 | − if (i == 0) { | |
| 80 | − args[0] = regs->orig_a0; | |
| 81 | − args++; | |
| 82 | − i++; | |
| 83 | − n--; | |
| 84 | − } | |
| 85 | − memcpy(args, ®s->a1 + i * sizeof(regs->a1), n * sizeof(args[0])); | |
| 77 | + args[0] = regs->orig_a0; | |
| 78 | + args++; | |
| 79 | + memcpy(args, ®s->a1, 5 * sizeof(args[0])); | |
| 86 | 80 | } |
| 87 | 81 | |
| 88 | 82 | static inline void syscall_set_arguments(struct task_struct *task, |
| 89 | 83 | struct pt_regs *regs, |
| 90 | − unsigned int i, unsigned int n, | |
| 91 | 84 | const unsigned long *args) |
| 92 | 85 | { |
| 93 | − BUG_ON(i + n > 6); | |
| 94 | − if (i == 0) { | |
| 95 | − regs->orig_a0 = args[0]; | |
| 96 | − args++; | |
| 97 | − i++; | |
| 98 | − n--; | |
| 99 | − } | |
| 100 | − memcpy(®s->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0)); | |
| 86 | + regs->orig_a0 = args[0]; | |
| 87 | + args++; | |
| 88 | + memcpy(®s->a1, args, 5 * sizeof(regs->a1)); | |
| 101 | 89 | } |
| 102 | 90 | |
| 103 | 91 | static inline int syscall_get_arch(void) |
| @@ -300,7 +300,7 @@ do { \ · 299 unmodified lines | ||
| 300 | 300 | " .balign 4\n" \ |
| 301 | 301 | "4:\n" \ |
| 302 | 302 | " li %0, %6\n" \ |
| 303 | − " jump 2b, %1\n" \ | |
| 303 | + " jump 3b, %1\n" \ | |
| 304 | 304 | " .previous\n" \ |
| 305 | 305 | " .section __ex_table,\"a\"\n" \ |
| 306 | 306 | " .balign " RISCV_SZPTR "\n" \ |
| @@ -4,7 +4,6 @@ · 3 unmodified lines | ||
| 4 | 4 | |
| 5 | 5 | ifdef CONFIG_FTRACE |
| 6 | 6 | CFLAGS_REMOVE_ftrace.o = -pg |
| 7 | −CFLAGS_REMOVE_setup.o = -pg | |
| 8 | 7 | endif |
| 9 | 8 | |
| 10 | 9 | extra-y += head.o |
| @@ -29,8 +28,6 @@ obj-y += vdso.o · 18 unmodified lines | ||
| 29 | 28 | obj-y += cacheinfo.o |
| 30 | 29 | obj-y += vdso/ |
| 31 | 30 | |
| 32 | −CFLAGS_setup.o := -mcmodel=medany | |
| 33 | − | |
| 34 | 31 | obj-$(CONFIG_FPU) += fpu.o |
| 35 | 32 | obj-$(CONFIG_SMP) += smpboot.o |
| 36 | 33 | obj-$(CONFIG_SMP) += smp.o |
| @@ -141,7 +141,7 @@ static int apply_r_riscv_hi20_rela(struct module *me, u32 *location, · 140 unmodified lines | ||
| 141 | 141 | { |
| 142 | 142 | s32 hi20; |
| 143 | 143 | |
| 144 | − if (IS_ENABLED(CMODEL_MEDLOW)) { | |
| 144 | + if (IS_ENABLED(CONFIG_CMODEL_MEDLOW)) { | |
| 145 | 145 | pr_err( |
| 146 | 146 | "%s: target %016llx can not be addressed by the 32-bit offset from PC = %p\n", |
| 147 | 147 | me->name, (long long)v, location); |
| @@ -48,14 +48,6 @@ struct screen_info screen_info = { · 47 unmodified lines | ||
| 48 | 48 | }; |
| 49 | 49 | #endif |
| 50 | 50 | |
| 51 | −unsigned long va_pa_offset; | |
| 52 | −EXPORT_SYMBOL(va_pa_offset); | |
| 53 | −unsigned long pfn_base; | |
| 54 | −EXPORT_SYMBOL(pfn_base); | |
| 55 | − | |
| 56 | −unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] __page_aligned_bss; | |
| 57 | −EXPORT_SYMBOL(empty_zero_page); | |
| 58 | − | |
| 59 | 51 | /* The lucky hart to first increment this variable will boot the other cores */ |
| 60 | 52 | atomic_t hart_lottery; |
| 61 | 53 | unsigned long boot_cpu_hartid; |
| @@ -1,3 +1,9 @@ | ||
| 1 | + | |
| 2 | +CFLAGS_init.o := -mcmodel=medany | |
| 3 | +ifdef CONFIG_FTRACE | |
| 4 | +CFLAGS_REMOVE_init.o = -pg | |
| 5 | +endif | |
| 6 | + | |
| 1 | 7 | obj-y += init.o |
| 2 | 8 | obj-y += fault.o |
| 3 | 9 | obj-y += extable.o |
| @@ -25,6 +25,10 @@ · 24 unmodified lines | ||
| 25 | 25 | #include <asm/pgtable.h> |
| 26 | 26 | #include <asm/io.h> |
| 27 | 27 | |
| 28 | +unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] | |
| 29 | + __page_aligned_bss; | |
| 30 | +EXPORT_SYMBOL(empty_zero_page); | |
| 31 | + | |
| 28 | 32 | static void __init zone_sizes_init(void) |
| 29 | 33 | { |
| 30 | 34 | unsigned long max_zone_pfns[MAX_NR_ZONES] = { 0, }; |
| @@ -143,6 +147,11 @@ void __init setup_bootmem(void) · 112 unmodified lines | ||
| 143 | 147 | } |
| 144 | 148 | } |
| 145 | 149 | |
| 150 | +unsigned long va_pa_offset; | |
| 151 | +EXPORT_SYMBOL(va_pa_offset); | |
| 152 | +unsigned long pfn_base; | |
| 153 | +EXPORT_SYMBOL(pfn_base); | |
| 154 | + | |
| 146 | 155 | pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_bss; |
| 147 | 156 | pgd_t trampoline_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE); |
| 148 | 157 | |
| @@ -172,6 +181,25 @@ void __set_fixmap(enum fixed_addresses idx, phys_addr_t phys, pgprot_t prot) · 23 unmodified lines | ||
| 172 | 181 | } |
| 173 | 182 | } |
| 174 | 183 | |
| 184 | +/* | |
| 185 | + * setup_vm() is called from head.S with MMU-off. | |
| 186 | + * | |
| 187 | + * Following requirements should be honoured for setup_vm() to work | |
| 188 | + * correctly: | |
| 189 | + * 1) It should use PC-relative addressing for accessing kernel symbols. | |
| 190 | + * To achieve this we always use GCC cmodel=medany. | |
| 191 | + * 2) The compiler instrumentation for FTRACE will not work for setup_vm() | |
| 192 | + * so disable compiler instrumentation when FTRACE is enabled. | |
| 193 | + * | |
| 194 | + * Currently, the above requirements are honoured by using custom CFLAGS | |
| 195 | + * for init.o in mm/Makefile. | |
| 196 | + */ | |
| 197 | + | |
| 198 | +#ifndef __riscv_cmodel_medany | |
| 199 | +#error "setup_vm() is called from head.S before relocate so it should " | |
| 200 | + "not use absolute addressing." | |
| 201 | +#endif | |
| 202 | + | |
| 175 | 203 | asmlinkage void __init setup_vm(void) |
| 176 | 204 | { |
| 177 | 205 | extern char _start; |
| @@ -56,40 +56,32 @@ static inline void syscall_set_return_value(struct task_struct *task, · 55 unmodified lines | ||
| 56 | 56 | |
| 57 | 57 | static inline void syscall_get_arguments(struct task_struct *task, |
| 58 | 58 | struct pt_regs *regs, |
| 59 | − unsigned int i, unsigned int n, | |
| 60 | 59 | unsigned long *args) |
| 61 | 60 | { |
| 62 | 61 | unsigned long mask = -1UL; |
| 62 | + unsigned int n = 6; | |
| 63 | 63 | |
| 64 | − /* | |
| 65 | − * No arguments for this syscall, there's nothing to do. | |
| 66 | − */ | |
| 67 | − if (!n) | |
| 68 | − return; | |
| 69 | − | |
| 70 | − BUG_ON(i + n > 6); | |
| 71 | 64 | #ifdef CONFIG_COMPAT |
| 72 | 65 | if (test_tsk_thread_flag(task, TIF_31BIT)) |
| 73 | 66 | mask = 0xffffffff; |
| 74 | 67 | #endif |
| 75 | 68 | while (n-- > 0) |
| 76 | − if (i + n > 0) | |
| 77 | − args[n] = regs->gprs[2 + i + n] & mask; | |
| 78 | − if (i == 0) | |
| 79 | − args[0] = regs->orig_gpr2 & mask; | |
| 69 | + if (n > 0) | |
| 70 | + args[n] = regs->gprs[2 + n] & mask; | |
| 71 | + | |
| 72 | + args[0] = regs->orig_gpr2 & mask; | |
| 80 | 73 | } |
| 81 | 74 | |
| 82 | 75 | static inline void syscall_set_arguments(struct task_struct *task, |
| 83 | 76 | struct pt_regs *regs, |
| 84 | − unsigned int i, unsigned int n, | |
| 85 | 77 | const unsigned long *args) |
| 86 | 78 | { |
| 87 | − BUG_ON(i + n > 6); | |
| 79 | + unsigned int n = 6; | |
| 80 | + | |
| 88 | 81 | while (n-- > 0) |
| 89 | − if (i + n > 0) | |
| 90 | − regs->gprs[2 + i + n] = args[n]; | |
| 91 | − if (i == 0) | |
| 92 | − regs->orig_gpr2 = args[0]; | |
| 82 | + if (n > 0) | |
| 83 | + regs->gprs[2 + n] = args[n]; | |
| 84 | + regs->orig_gpr2 = args[0]; | |
| 93 | 85 | } |
| 94 | 86 | |
| 95 | 87 | static inline int syscall_get_arch(void) |
| @@ -164,10 +164,10 @@ static struct sh_machine_vector __initmv sh_of_generic_mv = { · 163 unmodified lines | ||
| 164 | 164 | |
| 165 | 165 | struct sh_clk_ops; |
| 166 | 166 | |
| 167 | −void __init arch_init_clk_ops(struct sh_clk_ops **ops, int idx) | |
| 167 | +void __init __weak arch_init_clk_ops(struct sh_clk_ops **ops, int idx) | |
| 168 | 168 | { |
| 169 | 169 | } |
| 170 | 170 | |
| 171 | −void __init plat_irq_setup(void) | |
| 171 | +void __init __weak plat_irq_setup(void) | |
| 172 | 172 | { |
| 173 | 173 | } |
| @@ -48,51 +48,28 @@ static inline void syscall_set_return_value(struct task_struct *task, · 47 unmodified lines | ||
| 48 | 48 | |
| 49 | 49 | static inline void syscall_get_arguments(struct task_struct *task, |
| 50 | 50 | struct pt_regs *regs, |
| 51 | − unsigned int i, unsigned int n, | |
| 52 | 51 | unsigned long *args) |
| 53 | 52 | { |
| 54 | − /* | |
| 55 | − * Do this simply for now. If we need to start supporting | |
| 56 | − * fetching arguments from arbitrary indices, this will need some | |
| 57 | − * extra logic. Presently there are no in-tree users that depend | |
| 58 | − * on this behaviour. | |
| 59 | − */ | |
| 60 | − BUG_ON(i); | |
| 61 | 53 | |
| 62 | 54 | /* Argument pattern is: R4, R5, R6, R7, R0, R1 */ |
| 63 | − switch (n) { | |
| 64 | − case 6: args[5] = regs->regs[1]; | |
| 65 | − case 5: args[4] = regs->regs[0]; | |
| 66 | − case 4: args[3] = regs->regs[7]; | |
| 67 | − case 3: args[2] = regs->regs[6]; | |
| 68 | − case 2: args[1] = regs->regs[5]; | |
| 69 | − case 1: args[0] = regs->regs[4]; | |
| 70 | − case 0: | |
| 71 | − break; | |
| 72 | − default: | |
| 73 | − BUG(); | |
| 74 | − } | |
| 55 | + args[5] = regs->regs[1]; | |
| 56 | + args[4] = regs->regs[0]; | |
| 57 | + args[3] = regs->regs[7]; | |
| 58 | + args[2] = regs->regs[6]; | |
| 59 | + args[1] = regs->regs[5]; | |
| 60 | + args[0] = regs->regs[4]; | |
| 75 | 61 | } |
| 76 | 62 | |
| 77 | 63 | static inline void syscall_set_arguments(struct task_struct *task, |
| 78 | 64 | struct pt_regs *regs, |
| 79 | − unsigned int i, unsigned int n, | |
| 80 | 65 | const unsigned long *args) |
| 81 | 66 | { |
| 82 | − /* Same note as above applies */ | |
| 83 | − BUG_ON(i); | |
| 84 | − | |
| 85 | − switch (n) { | |
| 86 | − case 6: regs->regs[1] = args[5]; | |
| 87 | − case 5: regs->regs[0] = args[4]; | |
| 88 | − case 4: regs->regs[7] = args[3]; | |
| 89 | − case 3: regs->regs[6] = args[2]; | |
| 90 | − case 2: regs->regs[5] = args[1]; | |
| 91 | − case 1: regs->regs[4] = args[0]; | |
| 92 | − break; | |
| 93 | − default: | |
| 94 | − BUG(); | |
| 95 | − } | |
| 67 | + regs->regs[1] = args[5]; | |
| 68 | + regs->regs[0] = args[4]; | |
| 69 | + regs->regs[7] = args[3]; | |
| 70 | + regs->regs[6] = args[2]; | |
| 71 | + regs->regs[5] = args[1]; | |
| 72 | + regs->regs[4] = args[0]; | |
| 96 | 73 | } |
| 97 | 74 | |
| 98 | 75 | static inline int syscall_get_arch(void) |
| @@ -47,20 +47,16 @@ static inline void syscall_set_return_value(struct task_struct *task, · 46 unmodified lines | ||
| 47 | 47 | |
| 48 | 48 | static inline void syscall_get_arguments(struct task_struct *task, |
| 49 | 49 | struct pt_regs *regs, |
| 50 | − unsigned int i, unsigned int n, | |
| 51 | 50 | unsigned long *args) |
| 52 | 51 | { |
| 53 | − BUG_ON(i + n > 6); | |
| 54 | − memcpy(args, ®s->regs[2 + i], n * sizeof(args[0])); | |
| 52 | + memcpy(args, ®s->regs[2], 6 * sizeof(args[0])); | |
| 55 | 53 | } |
| 56 | 54 | |
| 57 | 55 | static inline void syscall_set_arguments(struct task_struct *task, |
| 58 | 56 | struct pt_regs *regs, |
| 59 | − unsigned int i, unsigned int n, | |
| 60 | 57 | const unsigned long *args) |
| 61 | 58 | { |
| 62 | − BUG_ON(i + n > 6); | |
| 63 | − memcpy(®s->regs[2 + i], args, n * sizeof(args[0])); | |
| 59 | + memcpy(®s->regs[2], args, 6 * sizeof(args[0])); | |
| 64 | 60 | } |
| 65 | 61 | |
| 66 | 62 | static inline int syscall_get_arch(void) |
| @@ -96,11 +96,11 @@ static inline void syscall_set_return_value(struct task_struct *task, · 95 unmodified lines | ||
| 96 | 96 | |
| 97 | 97 | static inline void syscall_get_arguments(struct task_struct *task, |
| 98 | 98 | struct pt_regs *regs, |
| 99 | − unsigned int i, unsigned int n, | |
| 100 | 99 | unsigned long *args) |
| 101 | 100 | { |
| 102 | 101 | int zero_extend = 0; |
| 103 | 102 | unsigned int j; |
| 103 | + unsigned int n = 6; | |
| 104 | 104 | |
| 105 | 105 | #ifdef CONFIG_SPARC64 |
| 106 | 106 | if (test_tsk_thread_flag(task, TIF_32BIT)) |
| @@ -108,7 +108,7 @@ static inline void syscall_get_arguments(struct task_struct *task, · 1 unmodified line | ||
| 108 | 108 | #endif |
| 109 | 109 | |
| 110 | 110 | for (j = 0; j < n; j++) { |
| 111 | − unsigned long val = regs->u_regs[UREG_I0 + i + j]; | |
| 111 | + unsigned long val = regs->u_regs[UREG_I0 + j]; | |
| 112 | 112 | |
| 113 | 113 | if (zero_extend) |
| 114 | 114 | args[j] = (u32) val; |
| @@ -119,13 +119,12 @@ static inline void syscall_get_arguments(struct task_struct *task, · 4 unmodified lines | ||
| 119 | 119 | |
| 120 | 120 | static inline void syscall_set_arguments(struct task_struct *task, |
| 121 | 121 | struct pt_regs *regs, |
| 122 | − unsigned int i, unsigned int n, | |
| 123 | 122 | const unsigned long *args) |
| 124 | 123 | { |
| 125 | − unsigned int j; | |
| 124 | + unsigned int i; | |
| 126 | 125 | |
| 127 | − for (j = 0; j < n; j++) | |
| 128 | − regs->u_regs[UREG_I0 + i + j] = args[j]; | |
| 126 | + for (i = 0; i < 6; i++) | |
| 127 | + regs->u_regs[UREG_I0 + i] = args[i]; | |
| 129 | 128 | } |
| 130 | 129 | |
| 131 | 130 | static inline int syscall_get_arch(void) |
| @@ -53,84 +53,30 @@ static inline void syscall_set_return_value(struct task_struct *task, · 52 unmodified lines | ||
| 53 | 53 | |
| 54 | 54 | static inline void syscall_get_arguments(struct task_struct *task, |
| 55 | 55 | struct pt_regs *regs, |
| 56 | − unsigned int i, unsigned int n, | |
| 57 | 56 | unsigned long *args) |
| 58 | 57 | { |
| 59 | 58 | const struct uml_pt_regs *r = ®s->regs; |
| 60 | 59 | |
| 61 | − switch (i) { | |
| 62 | − case 0: | |
| 63 | − if (!n--) | |
| 64 | − break; | |
| 65 | − *args++ = UPT_SYSCALL_ARG1(r); | |
| 66 | − case 1: | |
| 67 | − if (!n--) | |
| 68 | − break; | |
| 69 | − *args++ = UPT_SYSCALL_ARG2(r); | |
| 70 | − case 2: | |
| 71 | − if (!n--) | |
| 72 | − break; | |
| 73 | − *args++ = UPT_SYSCALL_ARG3(r); | |
| 74 | − case 3: | |
| 75 | − if (!n--) | |
| 76 | − break; | |
| 77 | − *args++ = UPT_SYSCALL_ARG4(r); | |
| 78 | − case 4: | |
| 79 | − if (!n--) | |
| 80 | − break; | |
| 81 | − *args++ = UPT_SYSCALL_ARG5(r); | |
| 82 | − case 5: | |
| 83 | − if (!n--) | |
| 84 | − break; | |
| 85 | − *args++ = UPT_SYSCALL_ARG6(r); | |
| 86 | − case 6: | |
| 87 | − if (!n--) | |
| 88 | − break; | |
| 89 | − default: | |
| 90 | − BUG(); | |
| 91 | − break; | |
| 92 | − } | |
| 60 | + *args++ = UPT_SYSCALL_ARG1(r); | |
| 61 | + *args++ = UPT_SYSCALL_ARG2(r); | |
| 62 | + *args++ = UPT_SYSCALL_ARG3(r); | |
| 63 | + *args++ = UPT_SYSCALL_ARG4(r); | |
| 64 | + *args++ = UPT_SYSCALL_ARG5(r); | |
| 65 | + *args = UPT_SYSCALL_ARG6(r); | |
| 93 | 66 | } |
| 94 | 67 | |
| 95 | 68 | static inline void syscall_set_arguments(struct task_struct *task, |
| 96 | 69 | struct pt_regs *regs, |
| 97 | − unsigned int i, unsigned int n, | |
| 98 | 70 | const unsigned long *args) |
| 99 | 71 | { |
| 100 | 72 | struct uml_pt_regs *r = ®s->regs; |
| 101 | 73 | |
| 102 | − switch (i) { | |
| 103 | − case 0: | |
| 104 | − if (!n--) | |
| 105 | − break; | |
| 106 | − UPT_SYSCALL_ARG1(r) = *args++; | |
| 107 | − case 1: | |
| 108 | − if (!n--) | |
| 109 | − break; | |
| 110 | − UPT_SYSCALL_ARG2(r) = *args++; | |
| 111 | − case 2: | |
| 112 | − if (!n--) | |
| 113 | − break; | |
| 114 | − UPT_SYSCALL_ARG3(r) = *args++; | |
| 115 | − case 3: | |
| 116 | − if (!n--) | |
| 117 | − break; | |
| 118 | − UPT_SYSCALL_ARG4(r) = *args++; | |
| 119 | − case 4: | |
| 120 | − if (!n--) | |
| 121 | − break; | |
| 122 | − UPT_SYSCALL_ARG5(r) = *args++; | |
| 123 | − case 5: | |
| 124 | − if (!n--) | |
| 125 | − break; | |
| 126 | − UPT_SYSCALL_ARG6(r) = *args++; | |
| 127 | − case 6: | |
| 128 | − if (!n--) | |
| 129 | − break; | |
| 130 | − default: | |
| 131 | − BUG(); | |
| 132 | − break; | |
| 133 | − } | |
| 74 | + UPT_SYSCALL_ARG1(r) = *args++; | |
| 75 | + UPT_SYSCALL_ARG2(r) = *args++; | |
| 76 | + UPT_SYSCALL_ARG3(r) = *args++; | |
| 77 | + UPT_SYSCALL_ARG4(r) = *args++; | |
| 78 | + UPT_SYSCALL_ARG5(r) = *args++; | |
| 79 | + UPT_SYSCALL_ARG6(r) = *args; | |
| 134 | 80 | } |
| 135 | 81 | |
| 136 | 82 | /* See arch/x86/um/asm/syscall.h for syscall_get_arch() definition. */ |
| @@ -91,11 +91,9 @@ static inline void syscall_set_return_value(struct task_struct *task, · 90 unmodified lines | ||
| 91 | 91 | |
| 92 | 92 | static inline void syscall_get_arguments(struct task_struct *task, |
| 93 | 93 | struct pt_regs *regs, |
| 94 | − unsigned int i, unsigned int n, | |
| 95 | 94 | unsigned long *args) |
| 96 | 95 | { |
| 97 | − BUG_ON(i + n > 6); | |
| 98 | − memcpy(args, ®s->bx + i, n * sizeof(args[0])); | |
| 96 | + memcpy(args, ®s->bx, 6 * sizeof(args[0])); | |
| 99 | 97 | } |
| 100 | 98 | |
| 101 | 99 | static inline void syscall_set_arguments(struct task_struct *task, |
| @@ -116,124 +114,50 @@ static inline int syscall_get_arch(void) · 14 unmodified lines | ||
| 116 | 114 | |
| 117 | 115 | static inline void syscall_get_arguments(struct task_struct *task, |
| 118 | 116 | struct pt_regs *regs, |
| 119 | − unsigned int i, unsigned int n, | |
| 120 | 117 | unsigned long *args) |
| 121 | 118 | { |
| 122 | 119 | # ifdef CONFIG_IA32_EMULATION |
| 123 | − if (task->thread_info.status & TS_COMPAT) | |
| 124 | − switch (i) { | |
| 125 | − case 0: | |
| 126 | − if (!n--) break; | |
| 127 | − *args++ = regs->bx; | |
| 128 | − case 1: | |
| 129 | − if (!n--) break; | |
| 130 | − *args++ = regs->cx; | |
| 131 | − case 2: | |
| 132 | − if (!n--) break; | |
| 133 | − *args++ = regs->dx; | |
| 134 | − case 3: | |
| 135 | − if (!n--) break; | |
| 136 | − *args++ = regs->si; | |
| 137 | − case 4: | |
| 138 | − if (!n--) break; | |
| 139 | − *args++ = regs->di; | |
| 140 | − case 5: | |
| 141 | − if (!n--) break; | |
| 142 | − *args++ = regs->bp; | |
| 143 | − case 6: | |
| 144 | − if (!n--) break; | |
| 145 | − default: | |
| 146 | − BUG(); | |
| 147 | − break; | |
| 148 | − } | |
| 149 | − else | |
| 120 | + if (task->thread_info.status & TS_COMPAT) { | |
| 121 | + *args++ = regs->bx; | |
| 122 | + *args++ = regs->cx; | |
| 123 | + *args++ = regs->dx; | |
| 124 | + *args++ = regs->si; | |
| 125 | + *args++ = regs->di; | |
| 126 | + *args = regs->bp; | |
| 127 | + } else | |
| 150 | 128 | # endif |
| 151 | − switch (i) { | |
| 152 | − case 0: | |
| 153 | − if (!n--) break; | |
| 154 | − *args++ = regs->di; | |
| 155 | − case 1: | |
| 156 | − if (!n--) break; | |
| 157 | − *args++ = regs->si; | |
| 158 | − case 2: | |
| 159 | − if (!n--) break; | |
| 160 | − *args++ = regs->dx; | |
| 161 | − case 3: | |
| 162 | − if (!n--) break; | |
| 163 | − *args++ = regs->r10; | |
| 164 | − case 4: | |
| 165 | − if (!n--) break; | |
| 166 | − *args++ = regs->r8; | |
| 167 | − case 5: | |
| 168 | − if (!n--) break; | |
| 169 | − *args++ = regs->r9; | |
| 170 | − case 6: | |
| 171 | − if (!n--) break; | |
| 172 | − default: | |
| 173 | − BUG(); | |
| 174 | − break; | |
| 175 | − } | |
| 129 | + { | |
| 130 | + *args++ = regs->di; | |
| 131 | + *args++ = regs->si; | |
| 132 | + *args++ = regs->dx; | |
| 133 | + *args++ = regs->r10; | |
| 134 | + *args++ = regs->r8; | |
| 135 | + *args = regs->r9; | |
| 136 | + } | |
| 176 | 137 | } |
| 177 | 138 | |
| 178 | 139 | static inline void syscall_set_arguments(struct task_struct *task, |
| 179 | 140 | struct pt_regs *regs, |
| 180 | − unsigned int i, unsigned int n, | |
| 181 | 141 | const unsigned long *args) |
| 182 | 142 | { |
| 183 | 143 | # ifdef CONFIG_IA32_EMULATION |
| 184 | − if (task->thread_info.status & TS_COMPAT) | |
| 185 | − switch (i) { | |
| 186 | − case 0: | |
| 187 | − if (!n--) break; | |
| 188 | − regs->bx = *args++; | |
| 189 | − case 1: | |
| 190 | − if (!n--) break; | |
| 191 | − regs->cx = *args++; | |
| 192 | − case 2: | |
| 193 | − if (!n--) break; | |
| 194 | − regs->dx = *args++; | |
| 195 | − case 3: | |
| 196 | − if (!n--) break; | |
| 197 | − regs->si = *args++; | |
| 198 | − case 4: | |
| 199 | − if (!n--) break; | |
| 200 | − regs->di = *args++; | |
| 201 | − case 5: | |
| 202 | − if (!n--) break; | |
| 203 | − regs->bp = *args++; | |
| 204 | − case 6: | |
| 205 | − if (!n--) break; | |
| 206 | − default: | |
| 207 | − BUG(); | |
| 208 | − break; | |
| 209 | − } | |
| 210 | − else | |
| 144 | + if (task->thread_info.status & TS_COMPAT) { | |
| 145 | + regs->bx = *args++; | |
| 146 | + regs->cx = *args++; | |
| 147 | + regs->dx = *args++; | |
| 148 | + regs->si = *args++; | |
| 149 | + regs->di = *args++; | |
| 150 | + regs->bp = *args; | |
| 151 | + } else | |
| 211 | 152 | # endif |
| 212 | − switch (i) { | |
| 213 | − case 0: | |
| 214 | − if (!n--) break; | |
| 215 | − regs->di = *args++; | |
| 216 | − case 1: | |
| 217 | − if (!n--) break; | |
| 218 | − regs->si = *args++; | |
| 219 | − case 2: | |
| 220 | − if (!n--) break; | |
| 221 | − regs->dx = *args++; | |
| 222 | − case 3: | |
| 223 | − if (!n--) break; | |
| 224 | − regs->r10 = *args++; | |
| 225 | − case 4: | |
| 226 | − if (!n--) break; | |
| 227 | − regs->r8 = *args++; | |
| 228 | − case 5: | |
| 229 | − if (!n--) break; | |
| 230 | − regs->r9 = *args++; | |
| 231 | − case 6: | |
| 232 | − if (!n--) break; | |
| 233 | − default: | |
| 234 | − BUG(); | |
| 235 | − break; | |
| 236 | − } | |
| 153 | + { | |
| 154 | + regs->di = *args++; | |
| 155 | + regs->si = *args++; | |
| 156 | + regs->dx = *args++; | |
| 157 | + regs->r10 = *args++; | |
| 158 | + regs->r8 = *args++; | |
| 159 | + regs->r9 = *args; | |
| 160 | + } | |
| 237 | 161 | } |
| 238 | 162 | |
| 239 | 163 | static inline int syscall_get_arch(void) |
| @@ -206,6 +206,9 @@ xen_single_call(unsigned int call, · 205 unmodified lines | ||
| 206 | 206 | __HYPERCALL_DECLS; |
| 207 | 207 | __HYPERCALL_5ARG(a1, a2, a3, a4, a5); |
| 208 | 208 | |
| 209 | + if (call >= PAGE_SIZE / sizeof(hypercall_page[0])) | |
| 210 | + return -EINVAL; | |
| 211 | + | |
| 209 | 212 | asm volatile(CALL_NOSPEC |
| 210 | 213 | : __HYPERCALL_5PARAM |
| 211 | 214 | : [thunk_target] "a" (&hypercall_page[call]) |
| @@ -6422,11 +6422,11 @@ e_free: · 6421 unmodified lines | ||
| 6422 | 6422 | return ret; |
| 6423 | 6423 | } |
| 6424 | 6424 | |
| 6425 | −static int get_num_contig_pages(int idx, struct page **inpages, | |
| 6426 | − unsigned long npages) | |
| 6425 | +static unsigned long get_num_contig_pages(unsigned long idx, | |
| 6426 | + struct page **inpages, unsigned long npages) | |
| 6427 | 6427 | { |
| 6428 | 6428 | unsigned long paddr, next_paddr; |
| 6429 | − int i = idx + 1, pages = 1; | |
| 6429 | + unsigned long i = idx + 1, pages = 1; | |
| 6430 | 6430 | |
| 6431 | 6431 | /* find the number of contiguous pages starting from idx */ |
| 6432 | 6432 | paddr = __sme_page_pa(inpages[idx]); |
| @@ -6445,12 +6445,12 @@ static int get_num_contig_pages(int idx, struct page **inpages, · 12 unmodified lines | ||
| 6445 | 6445 | |
| 6446 | 6446 | static int sev_launch_update_data(struct kvm *kvm, struct kvm_sev_cmd *argp) |
| 6447 | 6447 | { |
| 6448 | − unsigned long vaddr, vaddr_end, next_vaddr, npages, size; | |
| 6448 | + unsigned long vaddr, vaddr_end, next_vaddr, npages, pages, size, i; | |
| 6449 | 6449 | struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info; |
| 6450 | 6450 | struct kvm_sev_launch_update_data params; |
| 6451 | 6451 | struct sev_data_launch_update_data *data; |
| 6452 | 6452 | struct page **inpages; |
| 6453 | − int i, ret, pages; | |
| 6453 | + int ret; | |
| 6454 | 6454 | |
| 6455 | 6455 | if (!sev_guest(kvm)) |
| 6456 | 6456 | return -ENOTTY; |
| @@ -6799,7 +6799,8 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) · 342 unmodified lines | ||
| 6799 | 6799 | struct page **src_p, **dst_p; |
| 6800 | 6800 | struct kvm_sev_dbg debug; |
| 6801 | 6801 | unsigned long n; |
| 6802 | − int ret, size; | |
| 6802 | + unsigned int size; | |
| 6803 | + int ret; | |
| 6803 | 6804 | |
| 6804 | 6805 | if (!sev_guest(kvm)) |
| 6805 | 6806 | return -ENOTTY; |
| @@ -6807,6 +6808,11 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) · 1 unmodified line | ||
| 6807 | 6808 | if (copy_from_user(&debug, (void __user *)(uintptr_t)argp->data, sizeof(debug))) |
| 6808 | 6809 | return -EFAULT; |
| 6809 | 6810 | |
| 6811 | + if (!debug.len || debug.src_uaddr + debug.len < debug.src_uaddr) | |
| 6812 | + return -EINVAL; | |
| 6813 | + if (!debug.dst_uaddr) | |
| 6814 | + return -EINVAL; | |
| 6815 | + | |
| 6810 | 6816 | vaddr = debug.src_uaddr; |
| 6811 | 6817 | size = debug.len; |
| 6812 | 6818 | vaddr_end = vaddr + size; |
| @@ -6857,8 +6863,8 @@ static int sev_dbg_crypt(struct kvm *kvm, struct kvm_sev_cmd *argp, bool dec) · 44 unmodified lines | ||
| 6857 | 6863 | dst_vaddr, |
| 6858 | 6864 | len, &argp->error); |
| 6859 | 6865 | |
| 6860 | − sev_unpin_memory(kvm, src_p, 1); | |
| 6861 | − sev_unpin_memory(kvm, dst_p, 1); | |
| 6866 | + sev_unpin_memory(kvm, src_p, n); | |
| 6867 | + sev_unpin_memory(kvm, dst_p, n); | |
| 6862 | 6868 | |
| 6863 | 6869 | if (ret) |
| 6864 | 6870 | goto err; |
| @@ -500,6 +500,17 @@ static void nested_vmx_disable_intercept_for_msr(unsigned long *msr_bitmap_l1, · 499 unmodified lines | ||
| 500 | 500 | } |
| 501 | 501 | } |
| 502 | 502 | |
| 503 | +static inline void enable_x2apic_msr_intercepts(unsigned long *msr_bitmap) { | |
| 504 | + int msr; | |
| 505 | + | |
| 506 | + for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) { | |
| 507 | + unsigned word = msr / BITS_PER_LONG; | |
| 508 | + | |
| 509 | + msr_bitmap[word] = ~0; | |
| 510 | + msr_bitmap[word + (0x800 / sizeof(long))] = ~0; | |
| 511 | + } | |
| 512 | +} | |
| 513 | + | |
| 503 | 514 | /* |
| 504 | 515 | * Merge L0's and L1's MSR bitmap, return false to indicate that |
| 505 | 516 | * we do not use the hardware. |
| @@ -541,39 +552,44 @@ static inline bool nested_vmx_prepare_msr_bitmap(struct kvm_vcpu *vcpu, · 35 unmodified lines | ||
| 541 | 552 | return false; |
| 542 | 553 | |
| 543 | 554 | msr_bitmap_l1 = (unsigned long *)kmap(page); |
| 544 | − if (nested_cpu_has_apic_reg_virt(vmcs12)) { | |
| 545 | − /* | |
| 546 | − * L0 need not intercept reads for MSRs between 0x800 and 0x8ff, it | |
| 547 | − * just lets the processor take the value from the virtual-APIC page; | |
| 548 | − * take those 256 bits directly from the L1 bitmap. | |
| 549 | − */ | |
| 550 | − for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) { | |
| 551 | − unsigned word = msr / BITS_PER_LONG; | |
| 552 | − msr_bitmap_l0[word] = msr_bitmap_l1[word]; | |
| 553 | − msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0; | |
| 554 | − } | |
| 555 | − } else { | |
| 556 | − for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) { | |
| 557 | − unsigned word = msr / BITS_PER_LONG; | |
| 558 | − msr_bitmap_l0[word] = ~0; | |
| 559 | − msr_bitmap_l0[word + (0x800 / sizeof(long))] = ~0; | |
| 560 | − } | |
| 561 | − } | |
| 562 | 555 | |
| 563 | − nested_vmx_disable_intercept_for_msr( | |
| 564 | − msr_bitmap_l1, msr_bitmap_l0, | |
| 565 | − X2APIC_MSR(APIC_TASKPRI), | |
| 566 | − MSR_TYPE_W); | |
| 556 | + /* | |
| 557 | + * To keep the control flow simple, pay eight 8-byte writes (sixteen | |
| 558 | + * 4-byte writes on 32-bit systems) up front to enable intercepts for | |
| 559 | + * the x2APIC MSR range and selectively disable them below. | |
| 560 | + */ | |
| 561 | + enable_x2apic_msr_intercepts(msr_bitmap_l0); | |
| 562 | + | |
| 563 | + if (nested_cpu_has_virt_x2apic_mode(vmcs12)) { | |
| 564 | + if (nested_cpu_has_apic_reg_virt(vmcs12)) { | |
| 565 | + /* | |
| 566 | + * L0 need not intercept reads for MSRs between 0x800 | |
| 567 | + * and 0x8ff, it just lets the processor take the value | |
| 568 | + * from the virtual-APIC page; take those 256 bits | |
| 569 | + * directly from the L1 bitmap. | |
| 570 | + */ | |
| 571 | + for (msr = 0x800; msr <= 0x8ff; msr += BITS_PER_LONG) { | |
| 572 | + unsigned word = msr / BITS_PER_LONG; | |
| 573 | + | |
| 574 | + msr_bitmap_l0[word] = msr_bitmap_l1[word]; | |
| 575 | + } | |
| 576 | + } | |
| 567 | 577 | |
| 568 | − if (nested_cpu_has_vid(vmcs12)) { | |
| 569 | − nested_vmx_disable_intercept_for_msr( | |
| 570 | − msr_bitmap_l1, msr_bitmap_l0, | |
| 571 | − X2APIC_MSR(APIC_EOI), | |
| 572 | − MSR_TYPE_W); | |
| 573 | 578 | nested_vmx_disable_intercept_for_msr( |
| 574 | 579 | msr_bitmap_l1, msr_bitmap_l0, |
| 575 | − X2APIC_MSR(APIC_SELF_IPI), | |
| 576 | − MSR_TYPE_W); | |
| 580 | + X2APIC_MSR(APIC_TASKPRI), | |
| 581 | + MSR_TYPE_R | MSR_TYPE_W); | |
| 582 | + | |
| 583 | + if (nested_cpu_has_vid(vmcs12)) { | |
| 584 | + nested_vmx_disable_intercept_for_msr( | |
| 585 | + msr_bitmap_l1, msr_bitmap_l0, | |
| 586 | + X2APIC_MSR(APIC_EOI), | |
| 587 | + MSR_TYPE_W); | |
| 588 | + nested_vmx_disable_intercept_for_msr( | |
| 589 | + msr_bitmap_l1, msr_bitmap_l0, | |
| 590 | + X2APIC_MSR(APIC_SELF_IPI), | |
| 591 | + MSR_TYPE_W); | |
| 592 | + } | |
| 577 | 593 | } |
| 578 | 594 | |
| 579 | 595 | if (spec_ctrl) |
| @@ -187,15 +187,18 @@ struct thread_struct { · 186 unmodified lines | ||
| 187 | 187 | |
| 188 | 188 | /* Clearing a0 terminates the backtrace. */ |
| 189 | 189 | #define start_thread(regs, new_pc, new_sp) \ |
| 190 | − memset(regs, 0, sizeof(*regs)); \ | |
| 191 | − regs->pc = new_pc; \ | |
| 192 | − regs->ps = USER_PS_VALUE; \ | |
| 193 | − regs->areg[1] = new_sp; \ | |
| 194 | − regs->areg[0] = 0; \ | |
| 195 | − regs->wmask = 1; \ | |
| 196 | − regs->depc = 0; \ | |
| 197 | − regs->windowbase = 0; \ | |
| 198 | − regs->windowstart = 1; | |
| 190 | + do { \ | |
| 191 | + memset((regs), 0, sizeof(*(regs))); \ | |
| 192 | + (regs)->pc = (new_pc); \ | |
| 193 | + (regs)->ps = USER_PS_VALUE; \ | |
| 194 | + (regs)->areg[1] = (new_sp); \ | |
| 195 | + (regs)->areg[0] = 0; \ | |
| 196 | + (regs)->wmask = 1; \ | |
| 197 | + (regs)->depc = 0; \ | |
| 198 | + (regs)->windowbase = 0; \ | |
| 199 | + (regs)->windowstart = 1; \ | |
| 200 | + (regs)->syscall = NO_SYSCALL; \ | |
| 201 | + } while (0) | |
| 199 | 202 | |
| 200 | 203 | /* Forward declaration */ |
| 201 | 204 | struct task_struct; |
| @@ -59,45 +59,24 @@ static inline void syscall_set_return_value(struct task_struct *task, · 58 unmodified lines | ||
| 59 | 59 | |
| 60 | 60 | static inline void syscall_get_arguments(struct task_struct *task, |
| 61 | 61 | struct pt_regs *regs, |
| 62 | − unsigned int i, unsigned int n, | |
| 63 | 62 | unsigned long *args) |
| 64 | 63 | { |
| 65 | 64 | static const unsigned int reg[] = XTENSA_SYSCALL_ARGUMENT_REGS; |
| 66 | − unsigned int j; | |
| 65 | + unsigned int i; | |
| 67 | 66 | |
| 68 | − if (n == 0) | |
| 69 | − return; | |
| 70 | − | |
| 71 | − WARN_ON_ONCE(i + n > SYSCALL_MAX_ARGS); | |
| 72 | − | |
| 73 | − for (j = 0; j < n; ++j) { | |
| 74 | − if (i + j < SYSCALL_MAX_ARGS) | |
| 75 | − args[j] = regs->areg[reg[i + j]]; | |
| 76 | − else | |
| 77 | − args[j] = 0; | |
| 78 | − } | |
| 67 | + for (i = 0; i < 6; ++i) | |
| 68 | + args[i] = regs->areg[reg[i]]; | |
| 79 | 69 | } |
| 80 | 70 | |
| 81 | 71 | static inline void syscall_set_arguments(struct task_struct *task, |
| 82 | 72 | struct pt_regs *regs, |
| 83 | − unsigned int i, unsigned int n, | |
| 84 | 73 | const unsigned long *args) |
| 85 | 74 | { |
| 86 | 75 | static const unsigned int reg[] = XTENSA_SYSCALL_ARGUMENT_REGS; |
| 87 | − unsigned int j; | |
| 88 | − | |
| 89 | − if (n == 0) | |
| 90 | − return; | |
| 91 | − | |
| 92 | − if (WARN_ON_ONCE(i + n > SYSCALL_MAX_ARGS)) { | |
| 93 | − if (i < SYSCALL_MAX_ARGS) | |
| 94 | − n = SYSCALL_MAX_ARGS - i; | |
| 95 | − else | |
| 96 | − return; | |
| 97 | − } | |
| 76 | + unsigned int i; | |
| 98 | 77 | |
| 99 | − for (j = 0; j < n; ++j) | |
| 100 | − regs->areg[reg[i + j]] = args[j]; | |
| 78 | + for (i = 0; i < 6; ++i) | |
| 79 | + regs->areg[reg[i]] = args[i]; | |
| 101 | 80 | } |
| 102 | 81 | |
| 103 | 82 | asmlinkage long xtensa_rt_sigreturn(struct pt_regs*); |
| @@ -1860,6 +1860,8 @@ ENTRY(system_call) · 1859 unmodified lines | ||
| 1860 | 1860 | l32i a7, a2, PT_SYSCALL |
| 1861 | 1861 | |
| 1862 | 1862 | 1: |
| 1863 | + s32i a7, a1, 4 | |
| 1864 | + | |
| 1863 | 1865 | /* syscall = sys_call_table[syscall_nr] */ |
| 1864 | 1866 | |
| 1865 | 1867 | movi a4, sys_call_table |
| @@ -1893,8 +1895,12 @@ ENTRY(system_call) · 27 unmodified lines | ||
| 1893 | 1895 | retw |
| 1894 | 1896 | |
| 1895 | 1897 | 1: |
| 1898 | + l32i a4, a1, 4 | |
| 1899 | + l32i a3, a2, PT_SYSCALL | |
| 1900 | + s32i a4, a2, PT_SYSCALL | |
| 1896 | 1901 | mov a6, a2 |
| 1897 | 1902 | call4 do_syscall_trace_leave |
| 1903 | + s32i a3, a2, PT_SYSCALL | |
| 1898 | 1904 | retw |
| 1899 | 1905 | |
| 1900 | 1906 | ENDPROC(system_call) |
| @@ -253,10 +253,14 @@ static int return_address_cb(struct stackframe *frame, void *data) · 252 unmodified lines | ||
| 253 | 253 | return 1; |
| 254 | 254 | } |
| 255 | 255 | |
| 256 | +/* | |
| 257 | + * level == 0 is for the return address from the caller of this function, | |
| 258 | + * not from this function itself. | |
| 259 | + */ | |
| 256 | 260 | unsigned long return_address(unsigned level) |
| 257 | 261 | { |
| 258 | 262 | struct return_addr_data r = { |
| 259 | − .skip = level + 1, | |
| 263 | + .skip = level, | |
| 260 | 264 | }; |
| 261 | 265 | walk_stackframe(stack_pointer(NULL), return_address_cb, &r); |
| 262 | 266 | return r.addr; |
| @@ -33,7 +33,7 @@ static void * __init init_pmd(unsigned long vaddr, unsigned long n_pages) · 32 unmodified lines | ||
| 33 | 33 | |
| 34 | 34 | pte = memblock_alloc_low(n_pages * sizeof(pte_t), PAGE_SIZE); |
| 35 | 35 | if (!pte) |
| 36 | − panic("%s: Failed to allocate %zu bytes align=%lx\n", | |
| 36 | + panic("%s: Failed to allocate %lu bytes align=%lx\n", | |
| 37 | 37 | __func__, n_pages * sizeof(pte_t), PAGE_SIZE); |
| 38 | 38 | |
| 39 | 39 | for (i = 0; i < n_pages; ++i) |
| @@ -674,7 +674,7 @@ static bool bfq_symmetric_scenario(struct bfq_data *bfqd) · 673 unmodified lines | ||
| 674 | 674 | * at least two nodes. |
| 675 | 675 | */ |
| 676 | 676 | return !(varied_queue_weights || multiple_classes_busy |
| 677 | −#ifdef BFQ_GROUP_IOSCHED_ENABLED | |
| 677 | +#ifdef CONFIG_BFQ_GROUP_IOSCHED | |
| 678 | 678 | || bfqd->num_groups_with_pending_reqs > 0 |
| 679 | 679 | #endif |
| 680 | 680 | ); |
| @@ -1012,7 +1012,7 @@ static void __bfq_activate_entity(struct bfq_entity *entity, · 1011 unmodified lines | ||
| 1012 | 1012 | entity->on_st = true; |
| 1013 | 1013 | } |
| 1014 | 1014 | |
| 1015 | −#ifdef BFQ_GROUP_IOSCHED_ENABLED | |
| 1015 | +#ifdef CONFIG_BFQ_GROUP_IOSCHED | |
| 1016 | 1016 | if (!bfq_entity_to_bfqq(entity)) { /* bfq_group */ |
| 1017 | 1017 | struct bfq_group *bfqg = |
| 1018 | 1018 | container_of(entity, struct bfq_group, entity); |
| @@ -1245,8 +1245,6 @@ static int blk_cloned_rq_check_limits(struct request_queue *q, · 1244 unmodified lines | ||
| 1245 | 1245 | */ |
| 1246 | 1246 | blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request *rq) |
| 1247 | 1247 | { |
| 1248 | − blk_qc_t unused; | |
| 1249 | − | |
| 1250 | 1248 | if (blk_cloned_rq_check_limits(q, rq)) |
| 1251 | 1249 | return BLK_STS_IOERR; |
| 1252 | 1250 | |
| @@ -1262,7 +1260,7 @@ blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request * · 9 unmodified lines | ||
| 1262 | 1260 | * bypass a potential scheduler on the bottom device for |
| 1263 | 1261 | * insert. |
| 1264 | 1262 | */ |
| 1265 | − return blk_mq_try_issue_directly(rq->mq_hctx, rq, &unused, true, true); | |
| 1263 | + return blk_mq_request_issue_directly(rq, true); | |
| 1266 | 1264 | } |
| 1267 | 1265 | EXPORT_SYMBOL_GPL(blk_insert_cloned_request); |
| 1268 | 1266 | |
| @@ -423,10 +423,12 @@ void blk_mq_sched_insert_requests(struct blk_mq_hw_ctx *hctx, · 422 unmodified lines | ||
| 423 | 423 | * busy in case of 'none' scheduler, and this way may save |
| 424 | 424 | * us one extra enqueue & dequeue to sw queue. |
| 425 | 425 | */ |
| 426 | − if (!hctx->dispatch_busy && !e && !run_queue_async) | |
| 426 | + if (!hctx->dispatch_busy && !e && !run_queue_async) { | |
| 427 | 427 | blk_mq_try_issue_list_directly(hctx, list); |
| 428 | − else | |
| 429 | − blk_mq_insert_requests(hctx, ctx, list); | |
| 428 | + if (list_empty(list)) | |
| 429 | + return; | |
| 430 | + } | |
| 431 | + blk_mq_insert_requests(hctx, ctx, list); | |
| 430 | 432 | } |
| 431 | 433 | |
| 432 | 434 | blk_mq_run_hw_queue(hctx, run_queue_async); |
| @@ -1711,11 +1711,12 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule) · 1710 unmodified lines | ||
| 1711 | 1711 | unsigned int depth; |
| 1712 | 1712 | |
| 1713 | 1713 | list_splice_init(&plug->mq_list, &list); |
| 1714 | − plug->rq_count = 0; | |
| 1715 | 1714 | |
| 1716 | 1715 | if (plug->rq_count > 2 && plug->multiple_queues) |
| 1717 | 1716 | list_sort(NULL, &list, plug_rq_cmp); |
| 1718 | 1717 | |
| 1718 | + plug->rq_count = 0; | |
| 1719 | + | |
| 1719 | 1720 | this_q = NULL; |
| 1720 | 1721 | this_hctx = NULL; |
| 1721 | 1722 | this_ctx = NULL; |
| @@ -1800,74 +1801,76 @@ static blk_status_t __blk_mq_issue_directly(struct blk_mq_hw_ctx *hctx, · 78 unmodified lines | ||
| 1800 | 1801 | return ret; |
| 1801 | 1802 | } |
| 1802 | 1803 | |
| 1803 | −blk_status_t blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, | |
| 1804 | +static blk_status_t __blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, | |
| 1804 | 1805 | struct request *rq, |
| 1805 | 1806 | blk_qc_t *cookie, |
| 1806 | − bool bypass, bool last) | |
| 1807 | + bool bypass_insert, bool last) | |
| 1807 | 1808 | { |
| 1808 | 1809 | struct request_queue *q = rq->q; |
| 1809 | 1810 | bool run_queue = true; |
| 1810 | − blk_status_t ret = BLK_STS_RESOURCE; | |
| 1811 | − int srcu_idx; | |
| 1812 | − bool force = false; | |
| 1813 | 1811 | |
| 1814 | − hctx_lock(hctx, &srcu_idx); | |
| 1815 | 1812 | /* |
| 1816 | − * hctx_lock is needed before checking quiesced flag. | |
| 1813 | + * RCU or SRCU read lock is needed before checking quiesced flag. | |
| 1817 | 1814 | * |
| 1818 | − * When queue is stopped or quiesced, ignore 'bypass', insert | |
| 1819 | − * and return BLK_STS_OK to caller, and avoid driver to try to | |
| 1820 | − * dispatch again. | |
| 1815 | + * When queue is stopped or quiesced, ignore 'bypass_insert' from | |
| 1816 | + * blk_mq_request_issue_directly(), and return BLK_STS_OK to caller, | |
| 1817 | + * and avoid driver to try to dispatch again. | |
| 1821 | 1818 | */ |
| 1822 | − if (unlikely(blk_mq_hctx_stopped(hctx) || blk_queue_quiesced(q))) { | |
| 1819 | + if (blk_mq_hctx_stopped(hctx) || blk_queue_quiesced(q)) { | |
| 1823 | 1820 | run_queue = false; |
| 1824 | − bypass = false; | |
| 1825 | − goto out_unlock; | |
| 1821 | + bypass_insert = false; | |
| 1822 | + goto insert; | |
| 1826 | 1823 | } |
| 1827 | 1824 | |
| 1828 | − if (unlikely(q->elevator && !bypass)) | |
| 1829 | − goto out_unlock; | |
| 1825 | + if (q->elevator && !bypass_insert) | |
| 1826 | + goto insert; | |
| 1830 | 1827 | |
| 1831 | 1828 | if (!blk_mq_get_dispatch_budget(hctx)) |
| 1832 | − goto out_unlock; | |
| 1829 | + goto insert; | |
| 1833 | 1830 | |
| 1834 | 1831 | if (!blk_mq_get_driver_tag(rq)) { |
| 1835 | 1832 | blk_mq_put_dispatch_budget(hctx); |
| 1836 | − goto out_unlock; | |
| 1833 | + goto insert; | |
| 1837 | 1834 | } |
| 1838 | 1835 | |
| 1839 | − /* | |
| 1840 | − * Always add a request that has been through | |
| 1841 | − *.queue_rq() to the hardware dispatch list. | |
| 1842 | − */ | |
| 1843 | − force = true; | |
| 1844 | − ret = __blk_mq_issue_directly(hctx, rq, cookie, last); | |
| 1845 | −out_unlock: | |
| 1836 | + return __blk_mq_issue_directly(hctx, rq, cookie, last); | |
| 1837 | +insert: | |
| 1838 | + if (bypass_insert) | |
| 1839 | + return BLK_STS_RESOURCE; | |
| 1840 | + | |
| 1841 | + blk_mq_request_bypass_insert(rq, run_queue); | |
| 1842 | + return BLK_STS_OK; | |
| 1843 | +} | |
| 1844 | + | |
| 1845 | +static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, | |
| 1846 | + struct request *rq, blk_qc_t *cookie) | |
| 1847 | +{ | |
| 1848 | + blk_status_t ret; | |
| 1849 | + int srcu_idx; | |
| 1850 | + | |
| 1851 | + might_sleep_if(hctx->flags & BLK_MQ_F_BLOCKING); | |
| 1852 | + | |
| 1853 | + hctx_lock(hctx, &srcu_idx); | |
| 1854 | + | |
| 1855 | + ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true); | |
| 1856 | + if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE) | |
| 1857 | + blk_mq_request_bypass_insert(rq, true); | |
| 1858 | + else if (ret != BLK_STS_OK) | |
| 1859 | + blk_mq_end_request(rq, ret); | |
| 1860 | + | |
| 1861 | + hctx_unlock(hctx, srcu_idx); | |
| 1862 | +} | |
| 1863 | + | |
| 1864 | +blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last) | |
| 1865 | +{ | |
| 1866 | + blk_status_t ret; | |
| 1867 | + int srcu_idx; | |
| 1868 | + blk_qc_t unused_cookie; | |
| 1869 | + struct blk_mq_hw_ctx *hctx = rq->mq_hctx; | |
| 1870 | + | |
| 1871 | + hctx_lock(hctx, &srcu_idx); | |
| 1872 | + ret = __blk_mq_try_issue_directly(hctx, rq, &unused_cookie, true, last); | |
| 1846 | 1873 | hctx_unlock(hctx, srcu_idx); |
| 1847 | − switch (ret) { | |
| 1848 | − case BLK_STS_OK: | |
| 1849 | − break; | |
| 1850 | − case BLK_STS_DEV_RESOURCE: | |
| 1851 | − case BLK_STS_RESOURCE: | |
| 1852 | − if (force) { | |
| 1853 | − blk_mq_request_bypass_insert(rq, run_queue); | |
| 1854 | − /* | |
| 1855 | − * We have to return BLK_STS_OK for the DM | |
| 1856 | − * to avoid livelock. Otherwise, we return | |
| 1857 | − * the real result to indicate whether the | |
| 1858 | − * request is direct-issued successfully. | |
| 1859 | − */ | |
| 1860 | − ret = bypass ? BLK_STS_OK : ret; | |
| 1861 | − } else if (!bypass) { | |
| 1862 | − blk_mq_sched_insert_request(rq, false, | |
| 1863 | − run_queue, false); | |
| 1864 | − } | |
| 1865 | − break; | |
| 1866 | − default: | |
| 1867 | − if (!bypass) | |
| 1868 | − blk_mq_end_request(rq, ret); | |
| 1869 | − break; | |
| 1870 | − } | |
| 1871 | 1874 | |
| 1872 | 1875 | return ret; |
| 1873 | 1876 | } |
| @@ -1875,20 +1878,22 @@ out_unlock: · 1 unmodified line | ||
| 1875 | 1878 | void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, |
| 1876 | 1879 | struct list_head *list) |
| 1877 | 1880 | { |
| 1878 | − blk_qc_t unused; | |
| 1879 | − blk_status_t ret = BLK_STS_OK; | |
| 1880 | − | |
| 1881 | 1881 | while (!list_empty(list)) { |
| 1882 | + blk_status_t ret; | |
| 1882 | 1883 | struct request *rq = list_first_entry(list, struct request, |
| 1883 | 1884 | queuelist); |
| 1884 | 1885 | |
| 1885 | 1886 | list_del_init(&rq->queuelist); |
| 1886 | − if (ret == BLK_STS_OK) | |
| 1887 | − ret = blk_mq_try_issue_directly(hctx, rq, &unused, | |
| 1888 | − false, | |
| 1887 | + ret = blk_mq_request_issue_directly(rq, list_empty(list)); | |
| 1888 | + if (ret != BLK_STS_OK) { | |
| 1889 | + if (ret == BLK_STS_RESOURCE || | |
| 1890 | + ret == BLK_STS_DEV_RESOURCE) { | |
| 1891 | + blk_mq_request_bypass_insert(rq, | |
| 1889 | 1892 | list_empty(list)); |
| 1890 | − else | |
| 1891 | − blk_mq_sched_insert_request(rq, false, true, false); | |
| 1893 | + break; | |
| 1894 | + } | |
| 1895 | + blk_mq_end_request(rq, ret); | |
| 1896 | + } | |
| 1892 | 1897 | } |
| 1893 | 1898 | |
| 1894 | 1899 | /* |
| @@ -1896,7 +1901,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, · 1 unmodified line | ||
| 1896 | 1901 | * the driver there was more coming, but that turned out to |
| 1897 | 1902 | * be a lie. |
| 1898 | 1903 | */ |
| 1899 | − if (ret != BLK_STS_OK && hctx->queue->mq_ops->commit_rqs) | |
| 1904 | + if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs) | |
| 1900 | 1905 | hctx->queue->mq_ops->commit_rqs(hctx); |
| 1901 | 1906 | } |
| 1902 | 1907 | |
| @@ -2003,19 +2008,21 @@ static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio) · 100 unmodified lines | ||
| 2003 | 2008 | plug->rq_count--; |
| 2004 | 2009 | } |
| 2005 | 2010 | blk_add_rq_to_plug(plug, rq); |
| 2011 | + trace_block_plug(q); | |
| 2006 | 2012 | |
| 2007 | 2013 | blk_mq_put_ctx(data.ctx); |
| 2008 | 2014 | |
| 2009 | 2015 | if (same_queue_rq) { |
| 2010 | 2016 | data.hctx = same_queue_rq->mq_hctx; |
| 2017 | + trace_block_unplug(q, 1, true); | |
| 2011 | 2018 | blk_mq_try_issue_directly(data.hctx, same_queue_rq, |
| 2012 | − &cookie, false, true); | |
| 2019 | + &cookie); | |
| 2013 | 2020 | } |
| 2014 | 2021 | } else if ((q->nr_hw_queues > 1 && is_sync) || (!q->elevator && |
| 2015 | 2022 | !data.hctx->dispatch_busy)) { |
| 2016 | 2023 | blk_mq_put_ctx(data.ctx); |
| 2017 | 2024 | blk_mq_bio_to_request(rq, bio); |
| 2018 | − blk_mq_try_issue_directly(data.hctx, rq, &cookie, false, true); | |
| 2025 | + blk_mq_try_issue_directly(data.hctx, rq, &cookie); | |
| 2019 | 2026 | } else { |
| 2020 | 2027 | blk_mq_put_ctx(data.ctx); |
| 2021 | 2028 | blk_mq_bio_to_request(rq, bio); |
| @@ -2332,7 +2339,7 @@ static int blk_mq_init_hctx(struct request_queue *q, · 310 unmodified lines | ||
| 2332 | 2339 | return 0; |
| 2333 | 2340 | |
| 2334 | 2341 | free_fq: |
| 2335 | − kfree(hctx->fq); | |
| 2342 | + blk_free_flush_queue(hctx->fq); | |
| 2336 | 2343 | exit_hctx: |
| 2337 | 2344 | if (set->ops->exit_hctx) |
| 2338 | 2345 | set->ops->exit_hctx(hctx, hctx_idx); |
| @@ -70,10 +70,8 @@ void blk_mq_request_bypass_insert(struct request *rq, bool run_queue); · 69 unmodified lines | ||
| 70 | 70 | void blk_mq_insert_requests(struct blk_mq_hw_ctx *hctx, struct blk_mq_ctx *ctx, |
| 71 | 71 | struct list_head *list); |
| 72 | 72 | |
| 73 | −blk_status_t blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, | |
| 74 | − struct request *rq, | |
| 75 | − blk_qc_t *cookie, | |
| 76 | − bool bypass, bool last); | |
| 73 | +/* Used by blk_insert_cloned_request() to issue request directly */ | |
| 74 | +blk_status_t blk_mq_request_issue_directly(struct request *rq, bool last); | |
| 77 | 75 | void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, |
| 78 | 76 | struct list_head *list); |
| 79 | 77 | |
| @@ -81,8 +81,12 @@ acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info) · 80 unmodified lines | ||
| 81 | 81 | |
| 82 | 82 | ACPI_FUNCTION_TRACE(ev_enable_gpe); |
| 83 | 83 | |
| 84 | − /* Enable the requested GPE */ | |
| 84 | + /* Clear the GPE status */ | |
| 85 | + status = acpi_hw_clear_gpe(gpe_event_info); | |
| 86 | + if (ACPI_FAILURE(status)) | |
| 87 | + return_ACPI_STATUS(status); | |
| 85 | 88 | |
| 89 | + /* Enable the requested GPE */ | |
| 86 | 90 | status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE); |
| 87 | 91 | return_ACPI_STATUS(status); |
| 88 | 92 | } |
| @@ -1748,6 +1748,11 @@ static int __init null_init(void) · 1747 unmodified lines | ||
| 1748 | 1748 | return -EINVAL; |
| 1749 | 1749 | } |
| 1750 | 1750 | |
| 1751 | + if (g_home_node != NUMA_NO_NODE && g_home_node >= nr_online_nodes) { | |
| 1752 | + pr_err("null_blk: invalid home_node value\n"); | |
| 1753 | + g_home_node = NUMA_NO_NODE; | |
| 1754 | + } | |
| 1755 | + | |
| 1751 | 1756 | if (g_queue_mode == NULL_Q_RQ) { |
| 1752 | 1757 | pr_err("null_blk: legacy IO path no longer available\n"); |
| 1753 | 1758 | return -EINVAL; |
| @@ -314,6 +314,7 @@ static void pcd_init_units(void) · 313 unmodified lines | ||
| 314 | 314 | disk->queue = blk_mq_init_sq_queue(&cd->tag_set, &pcd_mq_ops, |
| 315 | 315 | 1, BLK_MQ_F_SHOULD_MERGE); |
| 316 | 316 | if (IS_ERR(disk->queue)) { |
| 317 | + put_disk(disk); | |
| 317 | 318 | disk->queue = NULL; |
| 318 | 319 | continue; |
| 319 | 320 | } |
| @@ -750,6 +751,8 @@ static int pcd_detect(void) · 430 unmodified lines | ||
| 750 | 751 | |
| 751 | 752 | printk("%s: No CD-ROM drive found\n", name); |
| 752 | 753 | for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { |
| 754 | + if (!cd->disk) | |
| 755 | + continue; | |
| 753 | 756 | blk_cleanup_queue(cd->disk->queue); |
| 754 | 757 | cd->disk->queue = NULL; |
| 755 | 758 | blk_mq_free_tag_set(&cd->tag_set); |
| @@ -1010,8 +1013,14 @@ static int __init pcd_init(void) · 254 unmodified lines | ||
| 1010 | 1013 | pcd_probe_capabilities(); |
| 1011 | 1014 | |
| 1012 | 1015 | if (register_blkdev(major, name)) { |
| 1013 | − for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) | |
| 1016 | + for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { | |
| 1017 | + if (!cd->disk) | |
| 1018 | + continue; | |
| 1019 | + | |
| 1020 | + blk_cleanup_queue(cd->disk->queue); | |
| 1021 | + blk_mq_free_tag_set(&cd->tag_set); | |
| 1014 | 1022 | put_disk(cd->disk); |
| 1023 | + } | |
| 1015 | 1024 | return -EBUSY; |
| 1016 | 1025 | } |
| 1017 | 1026 | |
| @@ -1032,6 +1041,9 @@ static void __exit pcd_exit(void) · 14 unmodified lines | ||
| 1032 | 1041 | int unit; |
| 1033 | 1042 | |
| 1034 | 1043 | for (unit = 0, cd = pcd; unit < PCD_UNITS; unit++, cd++) { |
| 1044 | + if (!cd->disk) | |
| 1045 | + continue; | |
| 1046 | + | |
| 1035 | 1047 | if (cd->present) { |
| 1036 | 1048 | del_gendisk(cd->disk); |
| 1037 | 1049 | pi_release(cd->pi); |
| @@ -762,6 +762,8 @@ static int pf_detect(void) · 761 unmodified lines | ||
| 762 | 762 | |
| 763 | 763 | printk("%s: No ATAPI disk detected\n", name); |
| 764 | 764 | for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) { |
| 765 | + if (!pf->disk) | |
| 766 | + continue; | |
| 765 | 767 | blk_cleanup_queue(pf->disk->queue); |
| 766 | 768 | pf->disk->queue = NULL; |
| 767 | 769 | blk_mq_free_tag_set(&pf->tag_set); |
| @@ -1029,8 +1031,13 @@ static int __init pf_init(void) · 261 unmodified lines | ||
| 1029 | 1031 | pf_busy = 0; |
| 1030 | 1032 | |
| 1031 | 1033 | if (register_blkdev(major, name)) { |
| 1032 | − for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) | |
| 1034 | + for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) { | |
| 1035 | + if (!pf->disk) | |
| 1036 | + continue; | |
| 1037 | + blk_cleanup_queue(pf->disk->queue); | |
| 1038 | + blk_mq_free_tag_set(&pf->tag_set); | |
| 1033 | 1039 | put_disk(pf->disk); |
| 1040 | + } | |
| 1034 | 1041 | return -EBUSY; |
| 1035 | 1042 | } |
| 1036 | 1043 | |
| @@ -1051,6 +1058,9 @@ static void __exit pf_exit(void) · 14 unmodified lines | ||
| 1051 | 1058 | int unit; |
| 1052 | 1059 | unregister_blkdev(major, name); |
| 1053 | 1060 | for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) { |
| 1061 | + if (!pf->disk) | |
| 1062 | + continue; | |
| 1063 | + | |
| 1054 | 1064 | if (pf->present) |
| 1055 | 1065 | del_gendisk(pf->disk); |
| 1056 | 1066 | |
| @@ -1090,6 +1090,8 @@ static int ace_setup(struct ace_device *ace) · 1089 unmodified lines | ||
| 1090 | 1090 | return 0; |
| 1091 | 1091 | |
| 1092 | 1092 | err_read: |
| 1093 | + /* prevent double queue cleanup */ | |
| 1094 | + ace->gd->queue = NULL; | |
| 1093 | 1095 | put_disk(ace->gd); |
| 1094 | 1096 | err_alloc_disk: |
| 1095 | 1097 | blk_cleanup_queue(ace->queue); |
| @@ -2942,6 +2942,7 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) · 2941 unmodified lines | ||
| 2942 | 2942 | return 0; |
| 2943 | 2943 | } |
| 2944 | 2944 | |
| 2945 | + irq_set_status_flags(irq, IRQ_NOAUTOEN); | |
| 2945 | 2946 | ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler, |
| 2946 | 2947 | 0, "OOB Wake-on-BT", data); |
| 2947 | 2948 | if (ret) { |
| @@ -2956,7 +2957,6 @@ static int btusb_config_oob_wake(struct hci_dev *hdev) · 8 unmodified lines | ||
| 2956 | 2957 | } |
| 2957 | 2958 | |
| 2958 | 2959 | data->oob_wake_irq = irq; |
| 2959 | − disable_irq(irq); | |
| 2960 | 2960 | bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq); |
| 2961 | 2961 | return 0; |
| 2962 | 2962 | } |
| @@ -348,7 +348,7 @@ config XILINX_HWICAP · 347 unmodified lines | ||
| 348 | 348 | |
| 349 | 349 | config R3964 |
| 350 | 350 | tristate "Siemens R3964 line discipline" |
| 351 | − depends on TTY | |
| 351 | + depends on TTY && BROKEN | |
| 352 | 352 | ---help--- |
| 353 | 353 | This driver allows synchronous communication with devices using the |
| 354 | 354 | Siemens R3964 packet protocol. Unless you are dealing with special |
| @@ -37,8 +37,8 @@ · 36 unmodified lines | ||
| 37 | 37 | * |
| 38 | 38 | * Returns size of the event. If it is an invalid event, returns 0. |
| 39 | 39 | */ |
| 40 | −static int calc_tpm2_event_size(struct tcg_pcr_event2_head *event, | |
| 41 | − struct tcg_pcr_event *event_header) | |
| 40 | +static size_t calc_tpm2_event_size(struct tcg_pcr_event2_head *event, | |
| 41 | + struct tcg_pcr_event *event_header) | |
| 42 | 42 | { |
| 43 | 43 | struct tcg_efi_specid_event_head *efispecid; |
| 44 | 44 | struct tcg_event_field *event_field; |
| @@ -233,12 +233,19 @@ __poll_t tpm_common_poll(struct file *file, poll_table *wait) · 232 unmodified lines | ||
| 233 | 233 | __poll_t mask = 0; |
| 234 | 234 | |
| 235 | 235 | poll_wait(file, &priv->async_wait, wait); |
| 236 | + mutex_lock(&priv->buffer_mutex); | |
| 236 | 237 | |
| 237 | − if (!priv->response_read || priv->response_length) | |
| 238 | + /* | |
| 239 | + * The response_length indicates if there is still response | |
| 240 | + * (or part of it) to be consumed. Partial reads decrease it | |
| 241 | + * by the number of bytes read, and write resets it the zero. | |
| 242 | + */ | |
| 243 | + if (priv->response_length) | |
| 238 | 244 | mask = EPOLLIN | EPOLLRDNORM; |
| 239 | 245 | else |
| 240 | 246 | mask = EPOLLOUT | EPOLLWRNORM; |
| 241 | 247 | |
| 248 | + mutex_unlock(&priv->buffer_mutex); | |
| 242 | 249 | return mask; |
| 243 | 250 | } |
| 244 | 251 | |
| @@ -402,15 +402,13 @@ int tpm_pm_suspend(struct device *dev) · 401 unmodified lines | ||
| 402 | 402 | if (chip->flags & TPM_CHIP_FLAG_ALWAYS_POWERED) |
| 403 | 403 | return 0; |
| 404 | 404 | |
| 405 | − if (chip->flags & TPM_CHIP_FLAG_TPM2) { | |
| 406 | − mutex_lock(&chip->tpm_mutex); | |
| 407 | − if (!tpm_chip_start(chip)) { | |
| 405 | + if (!tpm_chip_start(chip)) { | |
| 406 | + if (chip->flags & TPM_CHIP_FLAG_TPM2) | |
| 408 | 407 | tpm2_shutdown(chip, TPM2_SU_STATE); |
| 409 | − tpm_chip_stop(chip); | |
| 410 | − } | |
| 411 | − mutex_unlock(&chip->tpm_mutex); | |
| 412 | − } else { | |
| 413 | − rc = tpm1_pm_suspend(chip, tpm_suspend_pcr); | |
| 408 | + else | |
| 409 | + rc = tpm1_pm_suspend(chip, tpm_suspend_pcr); | |
| 410 | + | |
| 411 | + tpm_chip_stop(chip); | |
| 414 | 412 | } |
| 415 | 413 | |
| 416 | 414 | return rc; |
| @@ -2596,6 +2596,9 @@ static int __init intel_pstate_init(void) · 2595 unmodified lines | ||
| 2596 | 2596 | const struct x86_cpu_id *id; |
| 2597 | 2597 | int rc; |
| 2598 | 2598 | |
| 2599 | + if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) | |
| 2600 | + return -ENODEV; | |
| 2601 | + | |
| 2599 | 2602 | if (no_load) |
| 2600 | 2603 | return -ENODEV; |
| 2601 | 2604 | |
| @@ -2611,7 +2614,7 @@ static int __init intel_pstate_init(void) · 9 unmodified lines | ||
| 2611 | 2614 | } else { |
| 2612 | 2615 | id = x86_match_cpu(intel_pstate_cpu_ids); |
| 2613 | 2616 | if (!id) { |
| 2614 | − pr_info("CPU ID not supported\n"); | |
| 2617 | + pr_info("CPU model not supported\n"); | |
| 2615 | 2618 | return -ENODEV; |
| 2616 | 2619 | } |
| 2617 | 2620 | |
| @@ -865,19 +865,18 @@ static int ahash_update_ctx(struct ahash_request *req) · 864 unmodified lines | ||
| 865 | 865 | if (ret) |
| 866 | 866 | goto unmap_ctx; |
| 867 | 867 | |
| 868 | − if (mapped_nents) { | |
| 868 | + if (mapped_nents) | |
| 869 | 869 | sg_to_sec4_sg_last(req->src, mapped_nents, |
| 870 | 870 | edesc->sec4_sg + sec4_sg_src_index, |
| 871 | 871 | 0); |
| 872 | − if (*next_buflen) | |
| 873 | − scatterwalk_map_and_copy(next_buf, req->src, | |
| 874 | − to_hash - *buflen, | |
| 875 | − *next_buflen, 0); | |
| 876 | − } else { | |
| 872 | + else | |
| 877 | 873 | sg_to_sec4_set_last(edesc->sec4_sg + sec4_sg_src_index - |
| 878 | 874 | 1); |
| 879 | − } | |
| 880 | 875 | |
| 876 | + if (*next_buflen) | |
| 877 | + scatterwalk_map_and_copy(next_buf, req->src, | |
| 878 | + to_hash - *buflen, | |
| 879 | + *next_buflen, 0); | |
| 881 | 880 | desc = edesc->hw_desc; |
| 882 | 881 | |
| 883 | 882 | edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg, |
| @@ -3625,6 +3625,7 @@ static void amdgpu_device_get_min_pci_speed_width(struct amdgpu_device *adev, · 3624 unmodified lines | ||
| 3625 | 3625 | struct pci_dev *pdev = adev->pdev; |
| 3626 | 3626 | enum pci_bus_speed cur_speed; |
| 3627 | 3627 | enum pcie_link_width cur_width; |
| 3628 | + u32 ret = 1; | |
| 3628 | 3629 | |
| 3629 | 3630 | *speed = PCI_SPEED_UNKNOWN; |
| 3630 | 3631 | *width = PCIE_LNK_WIDTH_UNKNOWN; |
| @@ -3632,6 +3633,10 @@ static void amdgpu_device_get_min_pci_speed_width(struct amdgpu_device *adev, · 1 unmodified line | ||
| 3632 | 3633 | while (pdev) { |
| 3633 | 3634 | cur_speed = pcie_get_speed_cap(pdev); |
| 3634 | 3635 | cur_width = pcie_get_width_cap(pdev); |
| 3636 | + ret = pcie_bandwidth_available(adev->pdev, NULL, | |
| 3637 | + NULL, &cur_width); | |
| 3638 | + if (!ret) | |
| 3639 | + cur_width = PCIE_LNK_WIDTH_RESRV; | |
| 3635 | 3640 | |
| 3636 | 3641 | if (cur_speed != PCI_SPEED_UNKNOWN) { |
| 3637 | 3642 | if (*speed == PCI_SPEED_UNKNOWN) |
| @@ -2405,8 +2405,6 @@ static int gfx_v9_0_rlc_resume(struct amdgpu_device *adev) · 2404 unmodified lines | ||
| 2405 | 2405 | /* disable CG */ |
| 2406 | 2406 | WREG32_SOC15(GC, 0, mmRLC_CGCG_CGLS_CTRL, 0); |
| 2407 | 2407 | |
| 2408 | − adev->gfx.rlc.funcs->reset(adev); | |
| 2409 | − | |
| 2410 | 2408 | gfx_v9_0_init_pg(adev); |
| 2411 | 2409 | |
| 2412 | 2410 | if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP) { |
| @@ -2660,12 +2660,18 @@ void core_link_enable_stream( · 2659 unmodified lines | ||
| 2660 | 2660 | void core_link_disable_stream(struct pipe_ctx *pipe_ctx, int option) |
| 2661 | 2661 | { |
| 2662 | 2662 | struct dc *core_dc = pipe_ctx->stream->ctx->dc; |
| 2663 | + struct dc_stream_state *stream = pipe_ctx->stream; | |
| 2663 | 2664 | |
| 2664 | 2665 | core_dc->hwss.blank_stream(pipe_ctx); |
| 2665 | 2666 | |
| 2666 | 2667 | if (pipe_ctx->stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST) |
| 2667 | 2668 | deallocate_mst_payload(pipe_ctx); |
| 2668 | 2669 | |
| 2670 | + if (dc_is_hdmi_signal(pipe_ctx->stream->signal)) | |
| 2671 | + dal_ddc_service_write_scdc_data( | |
| 2672 | + stream->link->ddc, 0, | |
| 2673 | + stream->timing.flags.LTE_340MCSC_SCRAMBLE); | |
| 2674 | + | |
| 2669 | 2675 | core_dc->hwss.disable_stream(pipe_ctx, option); |
| 2670 | 2676 | |
| 2671 | 2677 | disable_link(pipe_ctx->stream->link, pipe_ctx->stream->signal); |
| @@ -91,6 +91,12 @@ static void vega20_set_default_registry_data(struct pp_hwmgr *hwmgr) · 90 unmodified lines | ||
| 91 | 91 | * MP0CLK DS |
| 92 | 92 | */ |
| 93 | 93 | data->registry_data.disallowed_features = 0xE0041C00; |
| 94 | + /* ECC feature should be disabled on old SMUs */ | |
| 95 | + smum_send_msg_to_smc(hwmgr, PPSMC_MSG_GetSmuVersion); | |
| 96 | + hwmgr->smu_version = smum_get_argument(hwmgr); | |
| 97 | + if (hwmgr->smu_version < 0x282100) | |
| 98 | + data->registry_data.disallowed_features |= FEATURE_ECC_MASK; | |
| 99 | + | |
| 94 | 100 | data->registry_data.od_state_in_dc_support = 0; |
| 95 | 101 | data->registry_data.thermal_support = 1; |
| 96 | 102 | data->registry_data.skip_baco_hardware = 0; |
| @@ -357,6 +363,7 @@ static void vega20_init_dpm_defaults(struct pp_hwmgr *hwmgr) · 260 unmodified lines | ||
| 357 | 363 | data->smu_features[GNLD_DS_MP1CLK].smu_feature_id = FEATURE_DS_MP1CLK_BIT; |
| 358 | 364 | data->smu_features[GNLD_DS_MP0CLK].smu_feature_id = FEATURE_DS_MP0CLK_BIT; |
| 359 | 365 | data->smu_features[GNLD_XGMI].smu_feature_id = FEATURE_XGMI_BIT; |
| 366 | + data->smu_features[GNLD_ECC].smu_feature_id = FEATURE_ECC_BIT; | |
| 360 | 367 | |
| 361 | 368 | for (i = 0; i < GNLD_FEATURES_MAX; i++) { |
| 362 | 369 | data->smu_features[i].smu_feature_bitmap = |
| @@ -3020,7 +3027,8 @@ static int vega20_get_ppfeature_status(struct pp_hwmgr *hwmgr, char *buf) · 2657 unmodified lines | ||
| 3020 | 3027 | "FCLK_DS", |
| 3021 | 3028 | "MP1CLK_DS", |
| 3022 | 3029 | "MP0CLK_DS", |
| 3023 | − "XGMI"}; | |
| 3030 | + "XGMI", | |
| 3031 | + "ECC"}; | |
| 3024 | 3032 | static const char *output_title[] = { |
| 3025 | 3033 | "FEATURES", |
| 3026 | 3034 | "BITMASK", |
| @@ -3462,6 +3470,7 @@ static int vega20_apply_clocks_adjust_rules(struct pp_hwmgr *hwmgr) · 435 unmodified lines | ||
| 3462 | 3470 | struct vega20_single_dpm_table *dpm_table; |
| 3463 | 3471 | bool vblank_too_short = false; |
| 3464 | 3472 | bool disable_mclk_switching; |
| 3473 | + bool disable_fclk_switching; | |
| 3465 | 3474 | uint32_t i, latency; |
| 3466 | 3475 | |
| 3467 | 3476 | disable_mclk_switching = ((1 < hwmgr->display_config->num_display) && |
| @@ -3537,13 +3546,20 @@ static int vega20_apply_clocks_adjust_rules(struct pp_hwmgr *hwmgr) · 69 unmodified lines | ||
| 3537 | 3546 | if (hwmgr->display_config->nb_pstate_switch_disable) |
| 3538 | 3547 | dpm_table->dpm_state.hard_min_level = dpm_table->dpm_levels[dpm_table->count - 1].value; |
| 3539 | 3548 | |
| 3549 | + if ((disable_mclk_switching && | |
| 3550 | + (dpm_table->dpm_state.hard_min_level == dpm_table->dpm_levels[dpm_table->count - 1].value)) || | |
| 3551 | + hwmgr->display_config->min_mem_set_clock / 100 >= dpm_table->dpm_levels[dpm_table->count - 1].value) | |
| 3552 | + disable_fclk_switching = true; | |
| 3553 | + else | |
| 3554 | + disable_fclk_switching = false; | |
| 3555 | + | |
| 3540 | 3556 | /* fclk */ |
| 3541 | 3557 | dpm_table = &(data->dpm_table.fclk_table); |
| 3542 | 3558 | dpm_table->dpm_state.soft_min_level = dpm_table->dpm_levels[0].value; |
| 3543 | 3559 | dpm_table->dpm_state.soft_max_level = VG20_CLOCK_MAX_DEFAULT; |
| 3544 | 3560 | dpm_table->dpm_state.hard_min_level = dpm_table->dpm_levels[0].value; |
| 3545 | 3561 | dpm_table->dpm_state.hard_max_level = VG20_CLOCK_MAX_DEFAULT; |
| 3546 | − if (hwmgr->display_config->nb_pstate_switch_disable) | |
| 3562 | + if (hwmgr->display_config->nb_pstate_switch_disable || disable_fclk_switching) | |
| 3547 | 3563 | dpm_table->dpm_state.soft_min_level = dpm_table->dpm_levels[dpm_table->count - 1].value; |
| 3548 | 3564 | |
| 3549 | 3565 | /* vclk */ |
| @@ -80,6 +80,7 @@ enum { · 79 unmodified lines | ||
| 80 | 80 | GNLD_DS_MP1CLK, |
| 81 | 81 | GNLD_DS_MP0CLK, |
| 82 | 82 | GNLD_XGMI, |
| 83 | + GNLD_ECC, | |
| 83 | 84 | |
| 84 | 85 | GNLD_FEATURES_MAX |
| 85 | 86 | }; |
| @@ -99,7 +99,7 @@ · 98 unmodified lines | ||
| 99 | 99 | #define FEATURE_DS_MP1CLK_BIT 30 |
| 100 | 100 | #define FEATURE_DS_MP0CLK_BIT 31 |
| 101 | 101 | #define FEATURE_XGMI_BIT 32 |
| 102 | −#define FEATURE_SPARE_33_BIT 33 | |
| 102 | +#define FEATURE_ECC_BIT 33 | |
| 103 | 103 | #define FEATURE_SPARE_34_BIT 34 |
| 104 | 104 | #define FEATURE_SPARE_35_BIT 35 |
| 105 | 105 | #define FEATURE_SPARE_36_BIT 36 |
| @@ -165,7 +165,8 @@ · 59 unmodified lines | ||
| 165 | 165 | #define FEATURE_DS_FCLK_MASK (1 << FEATURE_DS_FCLK_BIT ) |
| 166 | 166 | #define FEATURE_DS_MP1CLK_MASK (1 << FEATURE_DS_MP1CLK_BIT ) |
| 167 | 167 | #define FEATURE_DS_MP0CLK_MASK (1 << FEATURE_DS_MP0CLK_BIT ) |
| 168 | −#define FEATURE_XGMI_MASK (1 << FEATURE_XGMI_BIT ) | |
| 168 | +#define FEATURE_XGMI_MASK (1ULL << FEATURE_XGMI_BIT ) | |
| 169 | +#define FEATURE_ECC_MASK (1ULL << FEATURE_ECC_BIT ) | |
| 169 | 170 | |
| 170 | 171 | #define DPM_OVERRIDE_DISABLE_SOCCLK_PID 0x00000001 |
| 171 | 172 | #define DPM_OVERRIDE_DISABLE_UCLK_PID 0x00000002 |
| @@ -448,7 +448,7 @@ void intel_gvt_emulate_vblank(struct intel_gvt *gvt) · 447 unmodified lines | ||
| 448 | 448 | /** |
| 449 | 449 | * intel_vgpu_emulate_hotplug - trigger hotplug event for vGPU |
| 450 | 450 | * @vgpu: a vGPU |
| 451 | − * @conncted: link state | |
| 451 | + * @connected: link state | |
| 452 | 452 | * |
| 453 | 453 | * This function is used to trigger hotplug interrupt for vGPU |
| 454 | 454 | * |
| @@ -238,9 +238,6 @@ static int vgpu_get_plane_info(struct drm_device *dev, · 237 unmodified lines | ||
| 238 | 238 | default: |
| 239 | 239 | gvt_vgpu_err("invalid tiling mode: %x\n", p.tiled); |
| 240 | 240 | } |
| 241 | − | |
| 242 | − info->size = (((p.stride * p.height * p.bpp) / 8) + | |
| 243 | − (PAGE_SIZE - 1)) >> PAGE_SHIFT; | |
| 244 | 241 | } else if (plane_id == DRM_PLANE_TYPE_CURSOR) { |
| 245 | 242 | ret = intel_vgpu_decode_cursor_plane(vgpu, &c); |
| 246 | 243 | if (ret) |
| @@ -262,14 +259,13 @@ static int vgpu_get_plane_info(struct drm_device *dev, · 15 unmodified lines | ||
| 262 | 259 | info->x_hot = UINT_MAX; |
| 263 | 260 | info->y_hot = UINT_MAX; |
| 264 | 261 | } |
| 265 | − | |
| 266 | − info->size = (((info->stride * c.height * c.bpp) / 8) | |
| 267 | − + (PAGE_SIZE - 1)) >> PAGE_SHIFT; | |
| 268 | 262 | } else { |
| 269 | 263 | gvt_vgpu_err("invalid plane id:%d\n", plane_id); |
| 270 | 264 | return -EINVAL; |
| 271 | 265 | } |
| 272 | 266 | |
| 267 | + info->size = (info->stride * info->height + PAGE_SIZE - 1) | |
| 268 | + >> PAGE_SHIFT; | |
| 273 | 269 | if (info->size == 0) { |
| 274 | 270 | gvt_vgpu_err("fb size is zero\n"); |
| 275 | 271 | return -EINVAL; |
| @@ -1946,7 +1946,7 @@ void _intel_vgpu_mm_release(struct kref *mm_ref) · 1945 unmodified lines | ||
| 1946 | 1946 | */ |
| 1947 | 1947 | void intel_vgpu_unpin_mm(struct intel_vgpu_mm *mm) |
| 1948 | 1948 | { |
| 1949 | − atomic_dec(&mm->pincount); | |
| 1949 | + atomic_dec_if_positive(&mm->pincount); | |
| 1950 | 1950 | } |
| 1951 | 1951 | |
| 1952 | 1952 | /** |
| @@ -1486,8 +1486,9 @@ intel_vgpu_create_workload(struct intel_vgpu *vgpu, int ring_id, · 1485 unmodified lines | ||
| 1486 | 1486 | intel_runtime_pm_put_unchecked(dev_priv); |
| 1487 | 1487 | } |
| 1488 | 1488 | |
| 1489 | − if (ret && (vgpu_is_vm_unhealthy(ret))) { | |
| 1490 | − enter_failsafe_mode(vgpu, GVT_FAILSAFE_GUEST_ERR); | |
| 1489 | + if (ret) { | |
| 1490 | + if (vgpu_is_vm_unhealthy(ret)) | |
| 1491 | + enter_failsafe_mode(vgpu, GVT_FAILSAFE_GUEST_ERR); | |
| 1491 | 1492 | intel_vgpu_destroy_workload(workload); |
| 1492 | 1493 | return ERR_PTR(ret); |
| 1493 | 1494 | } |
| @@ -4830,7 +4830,10 @@ static int i915_dsc_fec_support_show(struct seq_file *m, void *data) · 4829 unmodified lines | ||
| 4830 | 4830 | ret = drm_modeset_lock(&dev->mode_config.connection_mutex, |
| 4831 | 4831 | &ctx); |
| 4832 | 4832 | if (ret) { |
| 4833 | − ret = -EINTR; | |
| 4833 | + if (ret == -EDEADLK && !drm_modeset_backoff(&ctx)) { | |
| 4834 | + try_again = true; | |
| 4835 | + continue; | |
| 4836 | + } | |
| 4834 | 4837 | break; |
| 4835 | 4838 | } |
| 4836 | 4839 | crtc = connector->state->crtc; |
| @@ -150,6 +150,7 @@ config HID_ASUS · 149 unmodified lines | ||
| 150 | 150 | tristate "Asus" |
| 151 | 151 | depends on LEDS_CLASS |
| 152 | 152 | depends on ASUS_WMI || ASUS_WMI=n |
| 153 | + select POWER_SUPPLY | |
| 153 | 154 | ---help--- |
| 154 | 155 | Support for Asus notebook built-in keyboard and touchpad via i2c, and |
| 155 | 156 | the Asus Republic of Gamers laptop keyboard special keys. |
| @@ -1301,10 +1301,10 @@ static u32 __extract(u8 *report, unsigned offset, int n) · 1300 unmodified lines | ||
| 1301 | 1301 | u32 hid_field_extract(const struct hid_device *hid, u8 *report, |
| 1302 | 1302 | unsigned offset, unsigned n) |
| 1303 | 1303 | { |
| 1304 | − if (n > 32) { | |
| 1305 | − hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n", | |
| 1304 | + if (n > 256) { | |
| 1305 | + hid_warn(hid, "hid_field_extract() called with n (%d) > 256! (%s)\n", | |
| 1306 | 1306 | n, current->comm); |
| 1307 | − n = 32; | |
| 1307 | + n = 256; | |
| 1308 | 1308 | } |
| 1309 | 1309 | |
| 1310 | 1310 | return __extract(report, offset, n); |
| @@ -1060,10 +1060,15 @@ static int hid_debug_rdesc_show(struct seq_file *f, void *p) · 1059 unmodified lines | ||
| 1060 | 1060 | seq_printf(f, "\n\n"); |
| 1061 | 1061 | |
| 1062 | 1062 | /* dump parsed data and input mappings */ |
| 1063 | + if (down_interruptible(&hdev->driver_input_lock)) | |
| 1064 | + return 0; | |
| 1065 | + | |
| 1063 | 1066 | hid_dump_device(hdev, f); |
| 1064 | 1067 | seq_printf(f, "\n"); |
| 1065 | 1068 | hid_dump_input_mapping(hdev, f); |
| 1066 | 1069 | |
| 1070 | + up(&hdev->driver_input_lock); | |
| 1071 | + | |
| 1067 | 1072 | return 0; |
| 1068 | 1073 | } |
| 1069 | 1074 | |
| @@ -1083,6 +1083,7 @@ · 1082 unmodified lines | ||
| 1083 | 1083 | #define USB_DEVICE_ID_SYNAPTICS_HD 0x0ac3 |
| 1084 | 1084 | #define USB_DEVICE_ID_SYNAPTICS_QUAD_HD 0x1ac3 |
| 1085 | 1085 | #define USB_DEVICE_ID_SYNAPTICS_TP_V103 0x5710 |
| 1086 | +#define I2C_DEVICE_ID_SYNAPTICS_7E7E 0x7e7e | |
| 1086 | 1087 | |
| 1087 | 1088 | #define USB_VENDOR_ID_TEXAS_INSTRUMENTS 0x2047 |
| 1088 | 1089 | #define USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA 0x0855 |
| @@ -998,6 +998,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel · 997 unmodified lines | ||
| 998 | 998 | case 0x1b8: map_key_clear(KEY_VIDEO); break; |
| 999 | 999 | case 0x1bc: map_key_clear(KEY_MESSENGER); break; |
| 1000 | 1000 | case 0x1bd: map_key_clear(KEY_INFO); break; |
| 1001 | + case 0x1cb: map_key_clear(KEY_ASSISTANT); break; | |
| 1001 | 1002 | case 0x201: map_key_clear(KEY_NEW); break; |
| 1002 | 1003 | case 0x202: map_key_clear(KEY_OPEN); break; |
| 1003 | 1004 | case 0x203: map_key_clear(KEY_CLOSE); break; |
| @@ -2111,6 +2111,13 @@ static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index) · 2110 unmodified lines | ||
| 2111 | 2111 | kfree(data); |
| 2112 | 2112 | return -ENOMEM; |
| 2113 | 2113 | } |
| 2114 | + data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue"); | |
| 2115 | + if (!data->wq) { | |
| 2116 | + kfree(data->effect_ids); | |
| 2117 | + kfree(data); | |
| 2118 | + return -ENOMEM; | |
| 2119 | + } | |
| 2120 | + | |
| 2114 | 2121 | data->hidpp = hidpp; |
| 2115 | 2122 | data->feature_index = feature_index; |
| 2116 | 2123 | data->version = version; |
| @@ -2155,7 +2162,6 @@ static int hidpp_ff_init(struct hidpp_device *hidpp, u8 feature_index) · 38 unmodified lines | ||
| 2155 | 2162 | /* ignore boost value at response.fap.params[2] */ |
| 2156 | 2163 | |
| 2157 | 2164 | /* init the hardware command queue */ |
| 2158 | − data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue"); | |
| 2159 | 2165 | atomic_set(&data->workqueue_size, 0); |
| 2160 | 2166 | |
| 2161 | 2167 | /* initialize with zero autocenter to get wheel in usable state */ |
| @@ -2608,8 +2614,9 @@ static int m560_raw_event(struct hid_device *hdev, u8 *data, int size) · 446 unmodified lines | ||
| 2608 | 2614 | input_report_rel(mydata->input, REL_Y, v); |
| 2609 | 2615 | |
| 2610 | 2616 | v = hid_snto32(data[6], 8); |
| 2611 | − hidpp_scroll_counter_handle_scroll( | |
| 2612 | − &hidpp->vertical_wheel_counter, v); | |
| 2617 | + if (v != 0) | |
| 2618 | + hidpp_scroll_counter_handle_scroll( | |
| 2619 | + &hidpp->vertical_wheel_counter, v); | |
| 2613 | 2620 | |
| 2614 | 2621 | input_sync(mydata->input); |
| 2615 | 2622 | } |
| @@ -715,7 +715,6 @@ static const struct hid_device_id hid_ignore_list[] = { · 714 unmodified lines | ||
| 715 | 715 | { HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) }, |
| 716 | 716 | { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) }, |
| 717 | 717 | { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) }, |
| 718 | − { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0400) }, | |
| 719 | 718 | { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) }, |
| 720 | 719 | { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) }, |
| 721 | 720 | { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) }, |
| @@ -855,7 +854,7 @@ static const struct hid_device_id hid_ignore_list[] = { · 133 unmodified lines | ||
| 855 | 854 | { } |
| 856 | 855 | }; |
| 857 | 856 | |
| 858 | −/** | |
| 857 | +/* | |
| 859 | 858 | * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer |
| 860 | 859 | * |
| 861 | 860 | * There are composite devices for which we want to ignore only a certain |
| @@ -996,6 +995,10 @@ bool hid_ignore(struct hid_device *hdev) · 134 unmodified lines | ||
| 996 | 995 | if (hdev->product == 0x0401 && |
| 997 | 996 | strncmp(hdev->name, "ELAN0800", 8) != 0) |
| 998 | 997 | return true; |
| 998 | + /* Same with product id 0x0400 */ | |
| 999 | + if (hdev->product == 0x0400 && | |
| 1000 | + strncmp(hdev->name, "QTEC0001", 8) != 0) | |
| 1001 | + return true; | |
| 999 | 1002 | break; |
| 1000 | 1003 | } |
| 1001 | 1004 | |
| @@ -1042,7 +1045,7 @@ static struct hid_device_id *hid_exists_dquirk(const struct hid_device *hdev) · 40 unmodified lines | ||
| 1042 | 1045 | } |
| 1043 | 1046 | |
| 1044 | 1047 | if (bl_entry != NULL) |
| 1045 | − dbg_hid("Found dynamic quirk 0x%lx for HID device 0x%hx:0x%hx\n", | |
| 1048 | + dbg_hid("Found dynamic quirk 0x%lx for HID device 0x%04x:0x%04x\n", | |
| 1046 | 1049 | bl_entry->driver_data, bl_entry->vendor, |
| 1047 | 1050 | bl_entry->product); |
| 1048 | 1051 | |
| @@ -1209,7 +1212,7 @@ static unsigned long hid_gets_squirk(const struct hid_device *hdev) · 160 unmodified lines | ||
| 1209 | 1212 | quirks |= bl_entry->driver_data; |
| 1210 | 1213 | |
| 1211 | 1214 | if (quirks) |
| 1212 | − dbg_hid("Found squirk 0x%lx for HID device 0x%hx:0x%hx\n", | |
| 1215 | + dbg_hid("Found squirk 0x%lx for HID device 0x%04x:0x%04x\n", | |
| 1213 | 1216 | quirks, hdev->vendor, hdev->product); |
| 1214 | 1217 | return quirks; |
| 1215 | 1218 | } |
| @@ -499,6 +499,7 @@ static void steam_battery_unregister(struct steam_device *steam) · 498 unmodified lines | ||
| 499 | 499 | static int steam_register(struct steam_device *steam) |
| 500 | 500 | { |
| 501 | 501 | int ret; |
| 502 | + bool client_opened; | |
| 502 | 503 | |
| 503 | 504 | /* |
| 504 | 505 | * This function can be called several times in a row with the |
| @@ -511,9 +512,11 @@ static int steam_register(struct steam_device *steam) · 6 unmodified lines | ||
| 511 | 512 | * Unlikely, but getting the serial could fail, and it is not so |
| 512 | 513 | * important, so make up a serial number and go on. |
| 513 | 514 | */ |
| 515 | + mutex_lock(&steam->mutex); | |
| 514 | 516 | if (steam_get_serial(steam) < 0) |
| 515 | 517 | strlcpy(steam->serial_no, "XXXXXXXXXX", |
| 516 | 518 | sizeof(steam->serial_no)); |
| 519 | + mutex_unlock(&steam->mutex); | |
| 517 | 520 | |
| 518 | 521 | hid_info(steam->hdev, "Steam Controller '%s' connected", |
| 519 | 522 | steam->serial_no); |
| @@ -528,13 +531,15 @@ static int steam_register(struct steam_device *steam) · 8 unmodified lines | ||
| 528 | 531 | } |
| 529 | 532 | |
| 530 | 533 | mutex_lock(&steam->mutex); |
| 531 | − if (!steam->client_opened) { | |
| 534 | + client_opened = steam->client_opened; | |
| 535 | + if (!client_opened) | |
| 532 | 536 | steam_set_lizard_mode(steam, lizard_mode); |
| 537 | + mutex_unlock(&steam->mutex); | |
| 538 | + | |
| 539 | + if (!client_opened) | |
| 533 | 540 | ret = steam_input_register(steam); |
| 534 | − } else { | |
| 541 | + else | |
| 535 | 542 | ret = 0; |
| 536 | − } | |
| 537 | − mutex_unlock(&steam->mutex); | |
| 538 | 543 | |
| 539 | 544 | return ret; |
| 540 | 545 | } |
| @@ -630,14 +635,21 @@ static void steam_client_ll_close(struct hid_device *hdev) · 89 unmodified lines | ||
| 630 | 635 | { |
| 631 | 636 | struct steam_device *steam = hdev->driver_data; |
| 632 | 637 | |
| 638 | + unsigned long flags; | |
| 639 | + bool connected; | |
| 640 | + | |
| 641 | + spin_lock_irqsave(&steam->lock, flags); | |
| 642 | + connected = steam->connected; | |
| 643 | + spin_unlock_irqrestore(&steam->lock, flags); | |
| 644 | + | |
| 633 | 645 | mutex_lock(&steam->mutex); |
| 634 | 646 | steam->client_opened = false; |
| 647 | + if (connected) | |
| 648 | + steam_set_lizard_mode(steam, lizard_mode); | |
| 635 | 649 | mutex_unlock(&steam->mutex); |
| 636 | 650 | |
| 637 | − if (steam->connected) { | |
| 638 | − steam_set_lizard_mode(steam, lizard_mode); | |
| 651 | + if (connected) | |
| 639 | 652 | steam_input_register(steam); |
| 640 | − } | |
| 641 | 653 | } |
| 642 | 654 | |
| 643 | 655 | static int steam_client_ll_raw_request(struct hid_device *hdev, |
| @@ -735,10 +735,6 @@ static int uclogic_params_huion_init(struct uclogic_params *params, · 734 unmodified lines | ||
| 735 | 735 | goto cleanup; |
| 736 | 736 | } |
| 737 | 737 | rc = usb_string(udev, 201, ver_ptr, ver_len); |
| 738 | − if (ver_ptr == NULL) { | |
| 739 | − rc = -ENOMEM; | |
| 740 | − goto cleanup; | |
| 741 | − } | |
| 742 | 738 | if (rc == -EPIPE) { |
| 743 | 739 | *ver_ptr = '\0'; |
| 744 | 740 | } else if (rc < 0) { |
| @@ -184,6 +184,8 @@ static const struct i2c_hid_quirks { · 183 unmodified lines | ||
| 184 | 184 | I2C_HID_QUIRK_NO_RUNTIME_PM }, |
| 185 | 185 | { USB_VENDOR_ID_ELAN, HID_ANY_ID, |
| 186 | 186 | I2C_HID_QUIRK_BOGUS_IRQ }, |
| 187 | + { USB_VENDOR_ID_SYNAPTICS, I2C_DEVICE_ID_SYNAPTICS_7E7E, | |
| 188 | + I2C_HID_QUIRK_NO_RUNTIME_PM }, | |
| 187 | 189 | { 0, 0 } |
| 188 | 190 | }; |
| 189 | 191 | |
| @@ -1759,6 +1759,7 @@ config SENSORS_VT8231 · 1758 unmodified lines | ||
| 1759 | 1759 | config SENSORS_W83773G |
| 1760 | 1760 | tristate "Nuvoton W83773G" |
| 1761 | 1761 | depends on I2C |
| 1762 | + select REGMAP_I2C | |
| 1762 | 1763 | help |
| 1763 | 1764 | If you say yes here you get support for the Nuvoton W83773G hardware |
| 1764 | 1765 | monitoring chip. |
| @@ -640,7 +640,7 @@ static const struct hwmon_channel_info ntc_chip = { · 639 unmodified lines | ||
| 640 | 640 | }; |
| 641 | 641 | |
| 642 | 642 | static const u32 ntc_temp_config[] = { |
| 643 | − HWMON_T_INPUT, HWMON_T_TYPE, | |
| 643 | + HWMON_T_INPUT | HWMON_T_TYPE, | |
| 644 | 644 | 0 |
| 645 | 645 | }; |
| 646 | 646 | |
| @@ -890,6 +890,8 @@ static int occ_setup_sensor_attrs(struct occ *occ) · 889 unmodified lines | ||
| 890 | 890 | s++; |
| 891 | 891 | } |
| 892 | 892 | } |
| 893 | + | |
| 894 | + s = (sensors->power.num_sensors * 4) + 1; | |
| 893 | 895 | } else { |
| 894 | 896 | for (i = 0; i < sensors->power.num_sensors; ++i) { |
| 895 | 897 | s = i + 1; |
| @@ -918,11 +920,11 @@ static int occ_setup_sensor_attrs(struct occ *occ) · 22 unmodified lines | ||
| 918 | 920 | show_power, NULL, 3, i); |
| 919 | 921 | attr++; |
| 920 | 922 | } |
| 921 | − } | |
| 922 | 923 | |
| 923 | − if (sensors->caps.num_sensors >= 1) { | |
| 924 | 924 | s = sensors->power.num_sensors + 1; |
| 925 | + } | |
| 925 | 926 | |
| 927 | + if (sensors->caps.num_sensors >= 1) { | |
| 926 | 928 | snprintf(attr->name, sizeof(attr->name), "power%d_label", s); |
| 927 | 929 | attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL, |
| 928 | 930 | 0, 0); |
| @@ -1169,11 +1169,13 @@ static int i2c_imx_probe(struct platform_device *pdev) · 1168 unmodified lines | ||
| 1169 | 1169 | /* Init DMA config if supported */ |
| 1170 | 1170 | ret = i2c_imx_dma_request(i2c_imx, phy_addr); |
| 1171 | 1171 | if (ret < 0) |
| 1172 | − goto clk_notifier_unregister; | |
| 1172 | + goto del_adapter; | |
| 1173 | 1173 | |
| 1174 | 1174 | dev_info(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n"); |
| 1175 | 1175 | return 0; /* Return OK */ |
| 1176 | 1176 | |
| 1177 | +del_adapter: | |
| 1178 | + i2c_del_adapter(&i2c_imx->adapter); | |
| 1177 | 1179 | clk_notifier_unregister: |
| 1178 | 1180 | clk_notifier_unregister(i2c_imx->clk, &i2c_imx->clk_change_nb); |
| 1179 | 1181 | rpm_disable: |
| @@ -115,6 +115,7 @@ struct mapped_device { · 114 unmodified lines | ||
| 115 | 115 | struct srcu_struct io_barrier; |
| 116 | 116 | }; |
| 117 | 117 | |
| 118 | +void disable_discard(struct mapped_device *md); | |
| 118 | 119 | void disable_write_same(struct mapped_device *md); |
| 119 | 120 | void disable_write_zeroes(struct mapped_device *md); |
| 120 | 121 | |
| @@ -36,7 +36,7 @@ struct dm_device { · 35 unmodified lines | ||
| 36 | 36 | struct list_head list; |
| 37 | 37 | }; |
| 38 | 38 | |
| 39 | −const char *dm_allowed_targets[] __initconst = { | |
| 39 | +const char * const dm_allowed_targets[] __initconst = { | |
| 40 | 40 | "crypt", |
| 41 | 41 | "delay", |
| 42 | 42 | "linear", |
| @@ -913,7 +913,7 @@ static void copy_from_journal(struct dm_integrity_c *ic, unsigned section, unsig · 912 unmodified lines | ||
| 913 | 913 | static bool ranges_overlap(struct dm_integrity_range *range1, struct dm_integrity_range *range2) |
| 914 | 914 | { |
| 915 | 915 | return range1->logical_sector < range2->logical_sector + range2->n_sectors && |
| 916 | − range2->logical_sector + range2->n_sectors > range2->logical_sector; | |
| 916 | + range1->logical_sector + range1->n_sectors > range2->logical_sector; | |
| 917 | 917 | } |
| 918 | 918 | |
| 919 | 919 | static bool add_new_range(struct dm_integrity_c *ic, struct dm_integrity_range *new_range, bool check_waiting) |
| @@ -959,8 +959,6 @@ static void remove_range_unlocked(struct dm_integrity_c *ic, struct dm_integrity · 39 unmodified lines | ||
| 959 | 959 | struct dm_integrity_range *last_range = |
| 960 | 960 | list_first_entry(&ic->wait_list, struct dm_integrity_range, wait_entry); |
| 961 | 961 | struct task_struct *last_range_task; |
| 962 | − if (!ranges_overlap(range, last_range)) | |
| 963 | − break; | |
| 964 | 962 | last_range_task = last_range->task; |
| 965 | 963 | list_del(&last_range->wait_entry); |
| 966 | 964 | if (!add_new_range(ic, last_range, false)) { |
| @@ -3185,7 +3183,7 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned argc, char **argv) · 2218 unmodified lines | ||
| 3185 | 3183 | journal_watermark = val; |
| 3186 | 3184 | else if (sscanf(opt_string, "commit_time:%u%c", &val, &dummy) == 1) |
| 3187 | 3185 | sync_msec = val; |
| 3188 | − else if (!memcmp(opt_string, "meta_device:", strlen("meta_device:"))) { | |
| 3186 | + else if (!strncmp(opt_string, "meta_device:", strlen("meta_device:"))) { | |
| 3189 | 3187 | if (ic->meta_dev) { |
| 3190 | 3188 | dm_put_device(ti, ic->meta_dev); |
| 3191 | 3189 | ic->meta_dev = NULL; |
| @@ -3204,17 +3202,17 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned argc, char **argv) · 12 unmodified lines | ||
| 3204 | 3202 | goto bad; |
| 3205 | 3203 | } |
| 3206 | 3204 | ic->sectors_per_block = val >> SECTOR_SHIFT; |
| 3207 | − } else if (!memcmp(opt_string, "internal_hash:", strlen("internal_hash:"))) { | |
| 3205 | + } else if (!strncmp(opt_string, "internal_hash:", strlen("internal_hash:"))) { | |
| 3208 | 3206 | r = get_alg_and_key(opt_string, &ic->internal_hash_alg, &ti->error, |
| 3209 | 3207 | "Invalid internal_hash argument"); |
| 3210 | 3208 | if (r) |
| 3211 | 3209 | goto bad; |
| 3212 | − } else if (!memcmp(opt_string, "journal_crypt:", strlen("journal_crypt:"))) { | |
| 3210 | + } else if (!strncmp(opt_string, "journal_crypt:", strlen("journal_crypt:"))) { | |
| 3213 | 3211 | r = get_alg_and_key(opt_string, &ic->journal_crypt_alg, &ti->error, |
| 3214 | 3212 | "Invalid journal_crypt argument"); |
| 3215 | 3213 | if (r) |
| 3216 | 3214 | goto bad; |
| 3217 | − } else if (!memcmp(opt_string, "journal_mac:", strlen("journal_mac:"))) { | |
| 3215 | + } else if (!strncmp(opt_string, "journal_mac:", strlen("journal_mac:"))) { | |
| 3218 | 3216 | r = get_alg_and_key(opt_string, &ic->journal_mac_alg, &ti->error, |
| 3219 | 3217 | "Invalid journal_mac argument"); |
| 3220 | 3218 | if (r) |
| @@ -3616,7 +3614,7 @@ static struct target_type integrity_target = { · 395 unmodified lines | ||
| 3616 | 3614 | .io_hints = dm_integrity_io_hints, |
| 3617 | 3615 | }; |
| 3618 | 3616 | |
| 3619 | −int __init dm_integrity_init(void) | |
| 3617 | +static int __init dm_integrity_init(void) | |
| 3620 | 3618 | { |
| 3621 | 3619 | int r; |
| 3622 | 3620 | |
| @@ -3635,7 +3633,7 @@ int __init dm_integrity_init(void) · 12 unmodified lines | ||
| 3635 | 3633 | return r; |
| 3636 | 3634 | } |
| 3637 | 3635 | |
| 3638 | −void dm_integrity_exit(void) | |
| 3636 | +static void __exit dm_integrity_exit(void) | |
| 3639 | 3637 | { |
| 3640 | 3638 | dm_unregister_target(&integrity_target); |
| 3641 | 3639 | kmem_cache_destroy(journal_io_cache); |
| @@ -222,11 +222,14 @@ static void dm_done(struct request *clone, blk_status_t error, bool mapped) · 221 unmodified lines | ||
| 222 | 222 | } |
| 223 | 223 | |
| 224 | 224 | if (unlikely(error == BLK_STS_TARGET)) { |
| 225 | − if (req_op(clone) == REQ_OP_WRITE_SAME && | |
| 226 | − !clone->q->limits.max_write_same_sectors) | |
| 225 | + if (req_op(clone) == REQ_OP_DISCARD && | |
| 226 | + !clone->q->limits.max_discard_sectors) | |
| 227 | + disable_discard(tio->md); | |
| 228 | + else if (req_op(clone) == REQ_OP_WRITE_SAME && | |
| 229 | + !clone->q->limits.max_write_same_sectors) | |
| 227 | 230 | disable_write_same(tio->md); |
| 228 | − if (req_op(clone) == REQ_OP_WRITE_ZEROES && | |
| 229 | − !clone->q->limits.max_write_zeroes_sectors) | |
| 231 | + else if (req_op(clone) == REQ_OP_WRITE_ZEROES && | |
| 232 | + !clone->q->limits.max_write_zeroes_sectors) | |
| 230 | 233 | disable_write_zeroes(tio->md); |
| 231 | 234 | } |
| 232 | 235 | |
| @@ -1844,6 +1844,36 @@ static bool dm_table_supports_secure_erase(struct dm_table *t) · 1843 unmodified lines | ||
| 1844 | 1844 | return true; |
| 1845 | 1845 | } |
| 1846 | 1846 | |
| 1847 | +static int device_requires_stable_pages(struct dm_target *ti, | |
| 1848 | + struct dm_dev *dev, sector_t start, | |
| 1849 | + sector_t len, void *data) | |
| 1850 | +{ | |
| 1851 | + struct request_queue *q = bdev_get_queue(dev->bdev); | |
| 1852 | + | |
| 1853 | + return q && bdi_cap_stable_pages_required(q->backing_dev_info); | |
| 1854 | +} | |
| 1855 | + | |
| 1856 | +/* | |
| 1857 | + * If any underlying device requires stable pages, a table must require | |
| 1858 | + * them as well. Only targets that support iterate_devices are considered: | |
| 1859 | + * don't want error, zero, etc to require stable pages. | |
| 1860 | + */ | |
| 1861 | +static bool dm_table_requires_stable_pages(struct dm_table *t) | |
| 1862 | +{ | |
| 1863 | + struct dm_target *ti; | |
| 1864 | + unsigned i; | |
| 1865 | + | |
| 1866 | + for (i = 0; i < dm_table_get_num_targets(t); i++) { | |
| 1867 | + ti = dm_table_get_target(t, i); | |
| 1868 | + | |
| 1869 | + if (ti->type->iterate_devices && | |
| 1870 | + ti->type->iterate_devices(ti, device_requires_stable_pages, NULL)) | |
| 1871 | + return true; | |
| 1872 | + } | |
| 1873 | + | |
| 1874 | + return false; | |
| 1875 | +} | |
| 1876 | + | |
| 1847 | 1877 | void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, |
| 1848 | 1878 | struct queue_limits *limits) |
| 1849 | 1879 | { |
| @@ -1896,6 +1926,15 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, · 46 unmodified lines | ||
| 1896 | 1926 | |
| 1897 | 1927 | dm_table_verify_integrity(t); |
| 1898 | 1928 | |
| 1929 | + /* | |
| 1930 | + * Some devices don't use blk_integrity but still want stable pages | |
| 1931 | + * because they do their own checksumming. | |
| 1932 | + */ | |
| 1933 | + if (dm_table_requires_stable_pages(t)) | |
| 1934 | + q->backing_dev_info->capabilities |= BDI_CAP_STABLE_WRITES; | |
| 1935 | + else | |
| 1936 | + q->backing_dev_info->capabilities &= ~BDI_CAP_STABLE_WRITES; | |
| 1937 | + | |
| 1899 | 1938 | /* |
| 1900 | 1939 | * Determine whether or not this queue's I/O timings contribute |
| 1901 | 1940 | * to the entropy pool, Only request-based targets use this. |
| @@ -945,6 +945,15 @@ static void dec_pending(struct dm_io *io, blk_status_t error) · 944 unmodified lines | ||
| 945 | 945 | } |
| 946 | 946 | } |
| 947 | 947 | |
| 948 | +void disable_discard(struct mapped_device *md) | |
| 949 | +{ | |
| 950 | + struct queue_limits *limits = dm_get_queue_limits(md); | |
| 951 | + | |
| 952 | + /* device doesn't really support DISCARD, disable it */ | |
| 953 | + limits->max_discard_sectors = 0; | |
| 954 | + blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue); | |
| 955 | +} | |
| 956 | + | |
| 948 | 957 | void disable_write_same(struct mapped_device *md) |
| 949 | 958 | { |
| 950 | 959 | struct queue_limits *limits = dm_get_queue_limits(md); |
| @@ -970,11 +979,14 @@ static void clone_endio(struct bio *bio) · 19 unmodified lines | ||
| 970 | 979 | dm_endio_fn endio = tio->ti->type->end_io; |
| 971 | 980 | |
| 972 | 981 | if (unlikely(error == BLK_STS_TARGET) && md->type != DM_TYPE_NVME_BIO_BASED) { |
| 973 | − if (bio_op(bio) == REQ_OP_WRITE_SAME && | |
| 974 | − !bio->bi_disk->queue->limits.max_write_same_sectors) | |
| 982 | + if (bio_op(bio) == REQ_OP_DISCARD && | |
| 983 | + !bio->bi_disk->queue->limits.max_discard_sectors) | |
| 984 | + disable_discard(md); | |
| 985 | + else if (bio_op(bio) == REQ_OP_WRITE_SAME && | |
| 986 | + !bio->bi_disk->queue->limits.max_write_same_sectors) | |
| 975 | 987 | disable_write_same(md); |
| 976 | − if (bio_op(bio) == REQ_OP_WRITE_ZEROES && | |
| 977 | − !bio->bi_disk->queue->limits.max_write_zeroes_sectors) | |
| 988 | + else if (bio_op(bio) == REQ_OP_WRITE_ZEROES && | |
| 989 | + !bio->bi_disk->queue->limits.max_write_zeroes_sectors) | |
| 978 | 990 | disable_write_zeroes(md); |
| 979 | 991 | } |
| 980 | 992 | |
| @@ -1042,15 +1054,7 @@ int dm_set_target_max_io_len(struct dm_target *ti, sector_t len) · 61 unmodified lines | ||
| 1042 | 1054 | return -EINVAL; |
| 1043 | 1055 | } |
| 1044 | 1056 | |
| 1045 | − /* | |
| 1046 | − * BIO based queue uses its own splitting. When multipage bvecs | |
| 1047 | − * is switched on, size of the incoming bio may be too big to | |
| 1048 | − * be handled in some targets, such as crypt. | |
| 1049 | − * | |
| 1050 | − * When these targets are ready for the big bio, we can remove | |
| 1051 | − * the limit. | |
| 1052 | − */ | |
| 1053 | − ti->max_io_len = min_t(uint32_t, len, BIO_MAX_PAGES * PAGE_SIZE); | |
| 1057 | + ti->max_io_len = (uint32_t) len; | |
| 1054 | 1058 | |
| 1055 | 1059 | return 0; |
| 1056 | 1060 | } |
| @@ -1246,7 +1246,7 @@ config MFD_STA2X11 · 1245 unmodified lines | ||
| 1246 | 1246 | |
| 1247 | 1247 | config MFD_SUN6I_PRCM |
| 1248 | 1248 | bool "Allwinner A31 PRCM controller" |
| 1249 | − depends on ARCH_SUNXI | |
| 1249 | + depends on ARCH_SUNXI || COMPILE_TEST | |
| 1250 | 1250 | select MFD_CORE |
| 1251 | 1251 | help |
| 1252 | 1252 | Support for the PRCM (Power/Reset/Clock Management) unit available |
| @@ -53,67 +53,67 @@ static const struct sprd_pmic_data sc2731_data = { · 52 unmodified lines | ||
| 53 | 53 | static const struct mfd_cell sprd_pmic_devs[] = { |
| 54 | 54 | { |
| 55 | 55 | .name = "sc27xx-wdt", |
| 56 | − .of_compatible = "sprd,sc27xx-wdt", | |
| 56 | + .of_compatible = "sprd,sc2731-wdt", | |
| 57 | 57 | }, { |
| 58 | 58 | .name = "sc27xx-rtc", |
| 59 | − .of_compatible = "sprd,sc27xx-rtc", | |
| 59 | + .of_compatible = "sprd,sc2731-rtc", | |
| 60 | 60 | }, { |
| 61 | 61 | .name = "sc27xx-charger", |
| 62 | − .of_compatible = "sprd,sc27xx-charger", | |
| 62 | + .of_compatible = "sprd,sc2731-charger", | |
| 63 | 63 | }, { |
| 64 | 64 | .name = "sc27xx-chg-timer", |
| 65 | − .of_compatible = "sprd,sc27xx-chg-timer", | |
| 65 | + .of_compatible = "sprd,sc2731-chg-timer", | |
| 66 | 66 | }, { |
| 67 | 67 | .name = "sc27xx-fast-chg", |
| 68 | − .of_compatible = "sprd,sc27xx-fast-chg", | |
| 68 | + .of_compatible = "sprd,sc2731-fast-chg", | |
| 69 | 69 | }, { |
| 70 | 70 | .name = "sc27xx-chg-wdt", |
| 71 | − .of_compatible = "sprd,sc27xx-chg-wdt", | |
| 71 | + .of_compatible = "sprd,sc2731-chg-wdt", | |
| 72 | 72 | }, { |
| 73 | 73 | .name = "sc27xx-typec", |
| 74 | − .of_compatible = "sprd,sc27xx-typec", | |
| 74 | + .of_compatible = "sprd,sc2731-typec", | |
| 75 | 75 | }, { |
| 76 | 76 | .name = "sc27xx-flash", |
| 77 | − .of_compatible = "sprd,sc27xx-flash", | |
| 77 | + .of_compatible = "sprd,sc2731-flash", | |
| 78 | 78 | }, { |
| 79 | 79 | .name = "sc27xx-eic", |
| 80 | − .of_compatible = "sprd,sc27xx-eic", | |
| 80 | + .of_compatible = "sprd,sc2731-eic", | |
| 81 | 81 | }, { |
| 82 | 82 | .name = "sc27xx-efuse", |
| 83 | − .of_compatible = "sprd,sc27xx-efuse", | |
| 83 | + .of_compatible = "sprd,sc2731-efuse", | |
| 84 | 84 | }, { |
| 85 | 85 | .name = "sc27xx-thermal", |
| 86 | − .of_compatible = "sprd,sc27xx-thermal", | |
| 86 | + .of_compatible = "sprd,sc2731-thermal", | |
| 87 | 87 | }, { |
| 88 | 88 | .name = "sc27xx-adc", |
| 89 | − .of_compatible = "sprd,sc27xx-adc", | |
| 89 | + .of_compatible = "sprd,sc2731-adc", | |
| 90 | 90 | }, { |
| 91 | 91 | .name = "sc27xx-audio-codec", |
| 92 | − .of_compatible = "sprd,sc27xx-audio-codec", | |
| 92 | + .of_compatible = "sprd,sc2731-audio-codec", | |
| 93 | 93 | }, { |
| 94 | 94 | .name = "sc27xx-regulator", |
| 95 | − .of_compatible = "sprd,sc27xx-regulator", | |
| 95 | + .of_compatible = "sprd,sc2731-regulator", | |
| 96 | 96 | }, { |
| 97 | 97 | .name = "sc27xx-vibrator", |
| 98 | − .of_compatible = "sprd,sc27xx-vibrator", | |
| 98 | + .of_compatible = "sprd,sc2731-vibrator", | |
| 99 | 99 | }, { |
| 100 | 100 | .name = "sc27xx-keypad-led", |
| 101 | − .of_compatible = "sprd,sc27xx-keypad-led", | |
| 101 | + .of_compatible = "sprd,sc2731-keypad-led", | |
| 102 | 102 | }, { |
| 103 | 103 | .name = "sc27xx-bltc", |
| 104 | − .of_compatible = "sprd,sc27xx-bltc", | |
| 104 | + .of_compatible = "sprd,sc2731-bltc", | |
| 105 | 105 | }, { |
| 106 | 106 | .name = "sc27xx-fgu", |
| 107 | − .of_compatible = "sprd,sc27xx-fgu", | |
| 107 | + .of_compatible = "sprd,sc2731-fgu", | |
| 108 | 108 | }, { |
| 109 | 109 | .name = "sc27xx-7sreset", |
| 110 | − .of_compatible = "sprd,sc27xx-7sreset", | |
| 110 | + .of_compatible = "sprd,sc2731-7sreset", | |
| 111 | 111 | }, { |
| 112 | 112 | .name = "sc27xx-poweroff", |
| 113 | − .of_compatible = "sprd,sc27xx-poweroff", | |
| 113 | + .of_compatible = "sprd,sc2731-poweroff", | |
| 114 | 114 | }, { |
| 115 | 115 | .name = "sc27xx-syscon", |
| 116 | − .of_compatible = "sprd,sc27xx-syscon", | |
| 116 | + .of_compatible = "sprd,sc2731-syscon", | |
| 117 | 117 | }, |
| 118 | 118 | }; |
| 119 | 119 | |
| @@ -1245,6 +1245,28 @@ free: · 1244 unmodified lines | ||
| 1245 | 1245 | return status; |
| 1246 | 1246 | } |
| 1247 | 1247 | |
| 1248 | +static int __maybe_unused twl_suspend(struct device *dev) | |
| 1249 | +{ | |
| 1250 | + struct i2c_client *client = to_i2c_client(dev); | |
| 1251 | + | |
| 1252 | + if (client->irq) | |
| 1253 | + disable_irq(client->irq); | |
| 1254 | + | |
| 1255 | + return 0; | |
| 1256 | +} | |
| 1257 | + | |
| 1258 | +static int __maybe_unused twl_resume(struct device *dev) | |
| 1259 | +{ | |
| 1260 | + struct i2c_client *client = to_i2c_client(dev); | |
| 1261 | + | |
| 1262 | + if (client->irq) | |
| 1263 | + enable_irq(client->irq); | |
| 1264 | + | |
| 1265 | + return 0; | |
| 1266 | +} | |
| 1267 | + | |
| 1268 | +static SIMPLE_DEV_PM_OPS(twl_dev_pm_ops, twl_suspend, twl_resume); | |
| 1269 | + | |
| 1248 | 1270 | static const struct i2c_device_id twl_ids[] = { |
| 1249 | 1271 | { "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */ |
| 1250 | 1272 | { "twl5030", 0 }, /* T2 updated */ |
| @@ -1262,6 +1284,7 @@ static const struct i2c_device_id twl_ids[] = { · 11 unmodified lines | ||
| 1262 | 1284 | /* One Client Driver , 4 Clients */ |
| 1263 | 1285 | static struct i2c_driver twl_driver = { |
| 1264 | 1286 | .driver.name = DRIVER_NAME, |
| 1287 | + .driver.pm = &twl_dev_pm_ops, | |
| 1265 | 1288 | .id_table = twl_ids, |
| 1266 | 1289 | .probe = twl_probe, |
| 1267 | 1290 | .remove = twl_remove, |
| @@ -1876,7 +1876,11 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip, · 1875 unmodified lines | ||
| 1876 | 1876 | continue; |
| 1877 | 1877 | } |
| 1878 | 1878 | |
| 1879 | − if (time_after(jiffies, timeo) && !chip_ready(map, adr)) | |
| 1879 | + /* | |
| 1880 | + * We check "time_after" and "!chip_good" before checking "chip_good" to avoid | |
| 1881 | + * the failure due to scheduling. | |
| 1882 | + */ | |
| 1883 | + if (time_after(jiffies, timeo) && !chip_good(map, adr, datum)) | |
| 1880 | 1884 | break; |
| 1881 | 1885 | |
| 1882 | 1886 | if (chip_good(map, adr, datum)) { |
| @@ -55,7 +55,9 @@ static SLAVE_ATTR_RO(link_failure_count); · 54 unmodified lines | ||
| 55 | 55 | |
| 56 | 56 | static ssize_t perm_hwaddr_show(struct slave *slave, char *buf) |
| 57 | 57 | { |
| 58 | − return sprintf(buf, "%pM\n", slave->perm_hwaddr); | |
| 58 | + return sprintf(buf, "%*phC\n", | |
| 59 | + slave->dev->addr_len, | |
| 60 | + slave->perm_hwaddr); | |
| 59 | 61 | } |
| 60 | 62 | static SLAVE_ATTR_RO(perm_hwaddr); |
| 61 | 63 | |
| @@ -427,18 +427,22 @@ int mv88e6390x_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 426 unmodified lines | ||
| 427 | 427 | return 0; |
| 428 | 428 | |
| 429 | 429 | lane = mv88e6390x_serdes_get_lane(chip, port); |
| 430 | − if (lane < 0) | |
| 430 | + if (lane < 0 && lane != -ENODEV) | |
| 431 | 431 | return lane; |
| 432 | 432 | |
| 433 | − if (chip->ports[port].serdes_irq) { | |
| 434 | − err = mv88e6390_serdes_irq_disable(chip, port, lane); | |
| 433 | + if (lane >= 0) { | |
| 434 | + if (chip->ports[port].serdes_irq) { | |
| 435 | + err = mv88e6390_serdes_irq_disable(chip, port, lane); | |
| 436 | + if (err) | |
| 437 | + return err; | |
| 438 | + } | |
| 439 | + | |
| 440 | + err = mv88e6390x_serdes_power(chip, port, false); | |
| 435 | 441 | if (err) |
| 436 | 442 | return err; |
| 437 | 443 | } |
| 438 | 444 | |
| 439 | − err = mv88e6390x_serdes_power(chip, port, false); | |
| 440 | − if (err) | |
| 441 | − return err; | |
| 445 | + chip->ports[port].cmode = 0; | |
| 442 | 446 | |
| 443 | 447 | if (cmode) { |
| 444 | 448 | err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_STS, ®); |
| @@ -452,6 +456,12 @@ int mv88e6390x_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 7 unmodified lines | ||
| 452 | 456 | if (err) |
| 453 | 457 | return err; |
| 454 | 458 | |
| 459 | + chip->ports[port].cmode = cmode; | |
| 460 | + | |
| 461 | + lane = mv88e6390x_serdes_get_lane(chip, port); | |
| 462 | + if (lane < 0) | |
| 463 | + return lane; | |
| 464 | + | |
| 455 | 465 | err = mv88e6390x_serdes_power(chip, port, true); |
| 456 | 466 | if (err) |
| 457 | 467 | return err; |
| @@ -463,8 +473,6 @@ int mv88e6390x_port_set_cmode(struct mv88e6xxx_chip *chip, int port, · 5 unmodified lines | ||
| 463 | 473 | } |
| 464 | 474 | } |
| 465 | 475 | |
| 466 | − chip->ports[port].cmode = cmode; | |
| 467 | − | |
| 468 | 476 | return 0; |
| 469 | 477 | } |
| 470 | 478 | |
| @@ -1133,6 +1133,8 @@ static void bnxt_tpa_start(struct bnxt *bp, struct bnxt_rx_ring_info *rxr, · 1132 unmodified lines | ||
| 1133 | 1133 | tpa_info = &rxr->rx_tpa[agg_id]; |
| 1134 | 1134 | |
| 1135 | 1135 | if (unlikely(cons != rxr->rx_next_cons)) { |
| 1136 | + netdev_warn(bp->dev, "TPA cons %x != expected cons %x\n", | |
| 1137 | + cons, rxr->rx_next_cons); | |
| 1136 | 1138 | bnxt_sched_reset(bp, rxr); |
| 1137 | 1139 | return; |
| 1138 | 1140 | } |
| @@ -1585,15 +1587,17 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_cp_ring_info *cpr, · 446 unmodified lines | ||
| 1585 | 1587 | } |
| 1586 | 1588 | |
| 1587 | 1589 | cons = rxcmp->rx_cmp_opaque; |
| 1588 | − rx_buf = &rxr->rx_buf_ring[cons]; | |
| 1589 | − data = rx_buf->data; | |
| 1590 | − data_ptr = rx_buf->data_ptr; | |
| 1591 | 1590 | if (unlikely(cons != rxr->rx_next_cons)) { |
| 1592 | 1591 | int rc1 = bnxt_discard_rx(bp, cpr, raw_cons, rxcmp); |
| 1593 | 1592 | |
| 1593 | + netdev_warn(bp->dev, "RX cons %x != expected cons %x\n", | |
| 1594 | + cons, rxr->rx_next_cons); | |
| 1594 | 1595 | bnxt_sched_reset(bp, rxr); |
| 1595 | 1596 | return rc1; |
| 1596 | 1597 | } |
| 1598 | + rx_buf = &rxr->rx_buf_ring[cons]; | |
| 1599 | + data = rx_buf->data; | |
| 1600 | + data_ptr = rx_buf->data_ptr; | |
| 1597 | 1601 | prefetch(data_ptr); |
| 1598 | 1602 | |
| 1599 | 1603 | misc = le32_to_cpu(rxcmp->rx_cmp_misc_v1); |
| @@ -1610,11 +1614,17 @@ static int bnxt_rx_pkt(struct bnxt *bp, struct bnxt_cp_ring_info *cpr, · 10 unmodified lines | ||
| 1610 | 1614 | |
| 1611 | 1615 | rx_buf->data = NULL; |
| 1612 | 1616 | if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) { |
| 1617 | + u32 rx_err = le32_to_cpu(rxcmp1->rx_cmp_cfa_code_errors_v2); | |
| 1618 | + | |
| 1613 | 1619 | bnxt_reuse_rx_data(rxr, cons, data); |
| 1614 | 1620 | if (agg_bufs) |
| 1615 | 1621 | bnxt_reuse_rx_agg_bufs(cpr, cp_cons, agg_bufs); |
| 1616 | 1622 | |
| 1617 | 1623 | rc = -EIO; |
| 1624 | + if (rx_err & RX_CMPL_ERRORS_BUFFER_ERROR_MASK) { | |
| 1625 | + netdev_warn(bp->dev, "RX buffer error %x\n", rx_err); | |
| 1626 | + bnxt_sched_reset(bp, rxr); | |
| 1627 | + } | |
| 1618 | 1628 | goto next_rx; |
| 1619 | 1629 | } |
| 1620 | 1630 | |
| @@ -4283,7 +4283,7 @@ static void tg3_power_down(struct tg3 *tp) · 4282 unmodified lines | ||
| 4283 | 4283 | pci_set_power_state(tp->pdev, PCI_D3hot); |
| 4284 | 4284 | } |
| 4285 | 4285 | |
| 4286 | −static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u16 *speed, u8 *duplex) | |
| 4286 | +static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u32 *speed, u8 *duplex) | |
| 4287 | 4287 | { |
| 4288 | 4288 | switch (val & MII_TG3_AUX_STAT_SPDMASK) { |
| 4289 | 4289 | case MII_TG3_AUX_STAT_10HALF: |
| @@ -4787,7 +4787,7 @@ static int tg3_setup_copper_phy(struct tg3 *tp, bool force_reset) · 497 unmodified lines | ||
| 4787 | 4787 | bool current_link_up; |
| 4788 | 4788 | u32 bmsr, val; |
| 4789 | 4789 | u32 lcl_adv, rmt_adv; |
| 4790 | − u16 current_speed; | |
| 4790 | + u32 current_speed; | |
| 4791 | 4791 | u8 current_duplex; |
| 4792 | 4792 | int i, err; |
| 4793 | 4793 | |
| @@ -5719,7 +5719,7 @@ out: · 925 unmodified lines | ||
| 5719 | 5719 | static int tg3_setup_fiber_phy(struct tg3 *tp, bool force_reset) |
| 5720 | 5720 | { |
| 5721 | 5721 | u32 orig_pause_cfg; |
| 5722 | − u16 orig_active_speed; | |
| 5722 | + u32 orig_active_speed; | |
| 5723 | 5723 | u8 orig_active_duplex; |
| 5724 | 5724 | u32 mac_status; |
| 5725 | 5725 | bool current_link_up; |
| @@ -5823,7 +5823,7 @@ static int tg3_setup_fiber_mii_phy(struct tg3 *tp, bool force_reset) · 97 unmodified lines | ||
| 5823 | 5823 | { |
| 5824 | 5824 | int err = 0; |
| 5825 | 5825 | u32 bmsr, bmcr; |
| 5826 | − u16 current_speed = SPEED_UNKNOWN; | |
| 5826 | + u32 current_speed = SPEED_UNKNOWN; | |
| 5827 | 5827 | u8 current_duplex = DUPLEX_UNKNOWN; |
| 5828 | 5828 | bool current_link_up = false; |
| 5829 | 5829 | u32 local_adv, remote_adv, sgsr; |
| @@ -2873,7 +2873,7 @@ struct tg3_tx_ring_info { · 2872 unmodified lines | ||
| 2873 | 2873 | struct tg3_link_config { |
| 2874 | 2874 | /* Describes what we're trying to get. */ |
| 2875 | 2875 | u32 advertising; |
| 2876 | − u16 speed; | |
| 2876 | + u32 speed; | |
| 2877 | 2877 | u8 duplex; |
| 2878 | 2878 | u8 autoneg; |
| 2879 | 2879 | u8 flowctrl; |
| @@ -2882,7 +2882,7 @@ struct tg3_link_config { · 2 unmodified lines | ||
| 2882 | 2882 | u8 active_flowctrl; |
| 2883 | 2883 | |
| 2884 | 2884 | u8 active_duplex; |
| 2885 | − u16 active_speed; | |
| 2885 | + u32 active_speed; | |
| 2886 | 2886 | u32 rmt_adv; |
| 2887 | 2887 | }; |
| 2888 | 2888 | |
| @@ -898,7 +898,9 @@ static void macb_tx_interrupt(struct macb_queue *queue) · 897 unmodified lines | ||
| 898 | 898 | |
| 899 | 899 | /* First, update TX stats if needed */ |
| 900 | 900 | if (skb) { |
| 901 | − if (gem_ptp_do_txstamp(queue, skb, desc) == 0) { | |
| 901 | + if (unlikely(skb_shinfo(skb)->tx_flags & | |
| 902 | + SKBTX_HW_TSTAMP) && | |
| 903 | + gem_ptp_do_txstamp(queue, skb, desc) == 0) { | |
| 902 | 904 | /* skb now belongs to timestamp buffer |
| 903 | 905 | * and will be removed later |
| 904 | 906 | */ |
| @@ -1328,10 +1328,11 @@ int nicvf_stop(struct net_device *netdev) · 1327 unmodified lines | ||
| 1328 | 1328 | struct nicvf_cq_poll *cq_poll = NULL; |
| 1329 | 1329 | union nic_mbx mbx = {}; |
| 1330 | 1330 | |
| 1331 | − cancel_delayed_work_sync(&nic->link_change_work); | |
| 1332 | − | |
| 1333 | 1331 | /* wait till all queued set_rx_mode tasks completes */ |
| 1334 | − drain_workqueue(nic->nicvf_rx_mode_wq); | |
| 1332 | + if (nic->nicvf_rx_mode_wq) { | |
| 1333 | + cancel_delayed_work_sync(&nic->link_change_work); | |
| 1334 | + drain_workqueue(nic->nicvf_rx_mode_wq); | |
| 1335 | + } | |
| 1335 | 1336 | |
| 1336 | 1337 | mbx.msg.msg = NIC_MBOX_MSG_SHUTDOWN; |
| 1337 | 1338 | nicvf_send_msg_to_pf(nic, &mbx); |
| @@ -1452,7 +1453,8 @@ int nicvf_open(struct net_device *netdev) · 114 unmodified lines | ||
| 1452 | 1453 | struct nicvf_cq_poll *cq_poll = NULL; |
| 1453 | 1454 | |
| 1454 | 1455 | /* wait till all queued set_rx_mode tasks completes if any */ |
| 1455 | − drain_workqueue(nic->nicvf_rx_mode_wq); | |
| 1456 | + if (nic->nicvf_rx_mode_wq) | |
| 1457 | + drain_workqueue(nic->nicvf_rx_mode_wq); | |
| 1456 | 1458 | |
| 1457 | 1459 | netif_carrier_off(netdev); |
| 1458 | 1460 | |
| @@ -1550,10 +1552,12 @@ int nicvf_open(struct net_device *netdev) · 91 unmodified lines | ||
| 1550 | 1552 | /* Send VF config done msg to PF */ |
| 1551 | 1553 | nicvf_send_cfg_done(nic); |
| 1552 | 1554 | |
| 1553 | − INIT_DELAYED_WORK(&nic->link_change_work, | |
| 1554 | − nicvf_link_status_check_task); | |
| 1555 | − queue_delayed_work(nic->nicvf_rx_mode_wq, | |
| 1556 | − &nic->link_change_work, 0); | |
| 1555 | + if (nic->nicvf_rx_mode_wq) { | |
| 1556 | + INIT_DELAYED_WORK(&nic->link_change_work, | |
| 1557 | + nicvf_link_status_check_task); | |
| 1558 | + queue_delayed_work(nic->nicvf_rx_mode_wq, | |
| 1559 | + &nic->link_change_work, 0); | |
| 1560 | + } | |
| 1557 | 1561 | |
| 1558 | 1562 | return 0; |
| 1559 | 1563 | cleanup: |
| @@ -105,20 +105,19 @@ static inline struct pgcache *nicvf_alloc_page(struct nicvf *nic, · 104 unmodified lines | ||
| 105 | 105 | /* Check if page can be recycled */ |
| 106 | 106 | if (page) { |
| 107 | 107 | ref_count = page_ref_count(page); |
| 108 | − /* Check if this page has been used once i.e 'put_page' | |
| 109 | − * called after packet transmission i.e internal ref_count | |
| 110 | − * and page's ref_count are equal i.e page can be recycled. | |
| 108 | + /* This page can be recycled if internal ref_count and page's | |
| 109 | + * ref_count are equal, indicating that the page has been used | |
| 110 | + * once for packet transmission. For non-XDP mode, internal | |
| 111 | + * ref_count is always '1'. | |
| 111 | 112 | */ |
| 112 | − if (rbdr->is_xdp && (ref_count == pgcache->ref_count)) | |
| 113 | − pgcache->ref_count--; | |
| 114 | − else | |
| 115 | − page = NULL; | |
| 116 | − | |
| 117 | − /* In non-XDP mode, page's ref_count needs to be '1' for it | |
| 118 | − * to be recycled. | |
| 119 | − */ | |
| 120 | − if (!rbdr->is_xdp && (ref_count != 1)) | |
| 113 | + if (rbdr->is_xdp) { | |
| 114 | + if (ref_count == pgcache->ref_count) | |
| 115 | + pgcache->ref_count--; | |
| 116 | + else | |
| 117 | + page = NULL; | |
| 118 | + } else if (ref_count != 1) { | |
| 121 | 119 | page = NULL; |
| 120 | + } | |
| 122 | 121 | } |
| 123 | 122 | |
| 124 | 123 | if (!page) { |
| @@ -365,11 +364,10 @@ static void nicvf_free_rbdr(struct nicvf *nic, struct rbdr *rbdr) · 240 unmodified lines | ||
| 365 | 364 | while (head < rbdr->pgcnt) { |
| 366 | 365 | pgcache = &rbdr->pgcache[head]; |
| 367 | 366 | if (pgcache->page && page_ref_count(pgcache->page) != 0) { |
| 368 | − if (!rbdr->is_xdp) { | |
| 369 | − put_page(pgcache->page); | |
| 370 | − continue; | |
| 367 | + if (rbdr->is_xdp) { | |
| 368 | + page_ref_sub(pgcache->page, | |
| 369 | + pgcache->ref_count - 1); | |
| 371 | 370 | } |
| 372 | − page_ref_sub(pgcache->page, pgcache->ref_count - 1); | |
| 373 | 371 | put_page(pgcache->page); |
| 374 | 372 | } |
| 375 | 373 | head++; |
| @@ -354,7 +354,10 @@ static struct cxgbi_ppm_pool *ppm_alloc_cpu_pool(unsigned int *total, · 353 unmodified lines | ||
| 354 | 354 | ppmax = max; |
| 355 | 355 | |
| 356 | 356 | /* pool size must be multiple of unsigned long */ |
| 357 | − bmap = BITS_TO_LONGS(ppmax); | |
| 357 | + bmap = ppmax / BITS_PER_TYPE(unsigned long); | |
| 358 | + if (!bmap) | |
| 359 | + return NULL; | |
| 360 | + | |
| 358 | 361 | ppmax = (bmap * sizeof(unsigned long)) << 3; |
| 359 | 362 | |
| 360 | 363 | alloc_sz = sizeof(*pools) + sizeof(unsigned long) * bmap; |
| @@ -402,6 +405,10 @@ int cxgbi_ppm_init(void **ppm_pp, struct net_device *ndev, · 41 unmodified lines | ||
| 402 | 405 | if (reserve_factor) { |
| 403 | 406 | ppmax_pool = ppmax / reserve_factor; |
| 404 | 407 | pool = ppm_alloc_cpu_pool(&ppmax_pool, &pool_index_max); |
| 408 | + if (!pool) { | |
| 409 | + ppmax_pool = 0; | |
| 410 | + reserve_factor = 0; | |
| 411 | + } | |
| 405 | 412 | |
| 406 | 413 | pr_debug("%s: ppmax %u, cpu total %u, per cpu %u.\n", |
| 407 | 414 | ndev->name, ppmax, ppmax_pool, pool_index_max); |
| @@ -150,7 +150,6 @@ out_buffer_fail: · 149 unmodified lines | ||
| 150 | 150 | /* free desc along with its attached buffer */ |
| 151 | 151 | static void hnae_free_desc(struct hnae_ring *ring) |
| 152 | 152 | { |
| 153 | − hnae_free_buffers(ring); | |
| 154 | 153 | dma_unmap_single(ring_to_dev(ring), ring->desc_dma_addr, |
| 155 | 154 | ring->desc_num * sizeof(ring->desc[0]), |
| 156 | 155 | ring_to_dma_dir(ring)); |
| @@ -183,6 +182,9 @@ static int hnae_alloc_desc(struct hnae_ring *ring) · 26 unmodified lines | ||
| 183 | 182 | /* fini ring, also free the buffer for the ring */ |
| 184 | 183 | static void hnae_fini_ring(struct hnae_ring *ring) |
| 185 | 184 | { |
| 185 | + if (is_rx_ring(ring)) | |
| 186 | + hnae_free_buffers(ring); | |
| 187 | + | |
| 186 | 188 | hnae_free_desc(ring); |
| 187 | 189 | kfree(ring->desc_cb); |
| 188 | 190 | ring->desc_cb = NULL; |
| @@ -357,7 +357,7 @@ struct hnae_buf_ops { · 356 unmodified lines | ||
| 357 | 357 | }; |
| 358 | 358 | |
| 359 | 359 | struct hnae_queue { |
| 360 | − void __iomem *io_base; | |
| 360 | + u8 __iomem *io_base; | |
| 361 | 361 | phys_addr_t phy_base; |
| 362 | 362 | struct hnae_ae_dev *dev; /* the device who use this queue */ |
| 363 | 363 | struct hnae_ring rx_ring ____cacheline_internodealigned_in_smp; |
| @@ -370,7 +370,7 @@ int hns_mac_clr_multicast(struct hns_mac_cb *mac_cb, int vfn) · 369 unmodified lines | ||
| 370 | 370 | static void hns_mac_param_get(struct mac_params *param, |
| 371 | 371 | struct hns_mac_cb *mac_cb) |
| 372 | 372 | { |
| 373 | − param->vaddr = (void *)mac_cb->vaddr; | |
| 373 | + param->vaddr = mac_cb->vaddr; | |
| 374 | 374 | param->mac_mode = hns_get_enet_interface(mac_cb); |
| 375 | 375 | ether_addr_copy(param->addr, mac_cb->addr_entry_idx[0].addr); |
| 376 | 376 | param->mac_id = mac_cb->mac_id; |
| @@ -187,7 +187,7 @@ struct mac_statistics { · 186 unmodified lines | ||
| 187 | 187 | /*mac para struct ,mac get param from nic or dsaf when initialize*/ |
| 188 | 188 | struct mac_params { |
| 189 | 189 | char addr[ETH_ALEN]; |
| 190 | − void *vaddr; /*virtual address*/ | |
| 190 | + u8 __iomem *vaddr; /*virtual address*/ | |
| 191 | 191 | struct device *dev; |
| 192 | 192 | u8 mac_id; |
| 193 | 193 | /**< Ethernet operation mode (MAC-PHY interface and speed) */ |
| @@ -402,7 +402,7 @@ struct mac_driver { · 208 unmodified lines | ||
| 402 | 402 | enum mac_mode mac_mode; |
| 403 | 403 | u8 mac_id; |
| 404 | 404 | struct hns_mac_cb *mac_cb; |
| 405 | − void __iomem *io_base; | |
| 405 | + u8 __iomem *io_base; | |
| 406 | 406 | unsigned int mac_en_flg;/*you'd better don't enable mac twice*/ |
| 407 | 407 | unsigned int virt_dev_num; |
| 408 | 408 | struct device *dev; |
| @@ -1602,8 +1602,6 @@ static void hns_dsaf_set_mac_key( · 1601 unmodified lines | ||
| 1602 | 1602 | DSAF_TBL_TCAM_KEY_VLAN_S, vlan_id); |
| 1603 | 1603 | dsaf_set_field(mac_key->low.bits.port_vlan, DSAF_TBL_TCAM_KEY_PORT_M, |
| 1604 | 1604 | DSAF_TBL_TCAM_KEY_PORT_S, port); |
| 1605 | − | |
| 1606 | − mac_key->low.bits.port_vlan = le16_to_cpu(mac_key->low.bits.port_vlan); | |
| 1607 | 1605 | } |
| 1608 | 1606 | |
| 1609 | 1607 | /** |
| @@ -1663,8 +1661,8 @@ int hns_dsaf_set_mac_uc_entry( · 53 unmodified lines | ||
| 1663 | 1661 | /* default config dvc to 0 */ |
| 1664 | 1662 | mac_data.tbl_ucast_dvc = 0; |
| 1665 | 1663 | mac_data.tbl_ucast_out_port = mac_entry->port_num; |
| 1666 | − tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val); | |
| 1667 | − tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val); | |
| 1664 | + tcam_data.tbl_tcam_data_high = mac_key.high.val; | |
| 1665 | + tcam_data.tbl_tcam_data_low = mac_key.low.val; | |
| 1668 | 1666 | |
| 1669 | 1667 | hns_dsaf_tcam_uc_cfg(dsaf_dev, entry_index, &tcam_data, &mac_data); |
| 1670 | 1668 | |
| @@ -1786,9 +1784,6 @@ int hns_dsaf_add_mac_mc_port(struct dsaf_device *dsaf_dev, · 115 unmodified lines | ||
| 1786 | 1784 | 0xff, |
| 1787 | 1785 | mc_mask); |
| 1788 | 1786 | |
| 1789 | − mask_key.high.val = le32_to_cpu(mask_key.high.val); | |
| 1790 | − mask_key.low.val = le32_to_cpu(mask_key.low.val); | |
| 1791 | − | |
| 1792 | 1787 | pmask_key = (struct dsaf_tbl_tcam_data *)(&mask_key); |
| 1793 | 1788 | } |
| 1794 | 1789 | |
| @@ -1840,8 +1835,8 @@ int hns_dsaf_add_mac_mc_port(struct dsaf_device *dsaf_dev, · 45 unmodified lines | ||
| 1840 | 1835 | dsaf_dev->ae_dev.name, mac_key.high.val, |
| 1841 | 1836 | mac_key.low.val, entry_index); |
| 1842 | 1837 | |
| 1843 | − tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val); | |
| 1844 | − tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val); | |
| 1838 | + tcam_data.tbl_tcam_data_high = mac_key.high.val; | |
| 1839 | + tcam_data.tbl_tcam_data_low = mac_key.low.val; | |
| 1845 | 1840 | |
| 1846 | 1841 | /* config mc entry with mask */ |
| 1847 | 1842 | hns_dsaf_tcam_mc_cfg(dsaf_dev, entry_index, &tcam_data, |
| @@ -1956,9 +1951,6 @@ int hns_dsaf_del_mac_mc_port(struct dsaf_device *dsaf_dev, · 108 unmodified lines | ||
| 1956 | 1951 | /* config key mask */ |
| 1957 | 1952 | hns_dsaf_set_mac_key(dsaf_dev, &mask_key, 0x00, 0xff, mc_mask); |
| 1958 | 1953 | |
| 1959 | − mask_key.high.val = le32_to_cpu(mask_key.high.val); | |
| 1960 | − mask_key.low.val = le32_to_cpu(mask_key.low.val); | |
| 1961 | − | |
| 1962 | 1954 | pmask_key = (struct dsaf_tbl_tcam_data *)(&mask_key); |
| 1963 | 1955 | } |
| 1964 | 1956 | |
| @@ -2012,8 +2004,8 @@ int hns_dsaf_del_mac_mc_port(struct dsaf_device *dsaf_dev, · 47 unmodified lines | ||
| 2012 | 2004 | soft_mac_entry += entry_index; |
| 2013 | 2005 | soft_mac_entry->index = DSAF_INVALID_ENTRY_IDX; |
| 2014 | 2006 | } else { /* not zero, just del port, update */ |
| 2015 | − tcam_data.tbl_tcam_data_high = cpu_to_le32(mac_key.high.val); | |
| 2016 | − tcam_data.tbl_tcam_data_low = cpu_to_le32(mac_key.low.val); | |
| 2007 | + tcam_data.tbl_tcam_data_high = mac_key.high.val; | |
| 2008 | + tcam_data.tbl_tcam_data_low = mac_key.low.val; | |
| 2017 | 2009 | |
| 2018 | 2010 | hns_dsaf_tcam_mc_cfg(dsaf_dev, entry_index, |
| 2019 | 2011 | &tcam_data, |
| @@ -2750,6 +2742,17 @@ int hns_dsaf_get_regs_count(void) · 730 unmodified lines | ||
| 2750 | 2742 | return DSAF_DUMP_REGS_NUM; |
| 2751 | 2743 | } |
| 2752 | 2744 | |
| 2745 | +static int hns_dsaf_get_port_id(u8 port) | |
| 2746 | +{ | |
| 2747 | + if (port < DSAF_SERVICE_NW_NUM) | |
| 2748 | + return port; | |
| 2749 | + | |
| 2750 | + if (port >= DSAF_BASE_INNER_PORT_NUM) | |
| 2751 | + return port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM; | |
| 2752 | + | |
| 2753 | + return -EINVAL; | |
| 2754 | +} | |
| 2755 | + | |
| 2753 | 2756 | static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port) |
| 2754 | 2757 | { |
| 2755 | 2758 | struct dsaf_tbl_tcam_ucast_cfg tbl_tcam_ucast = {0, 1, 0, 0, 0x80}; |
| @@ -2815,23 +2818,33 @@ static void set_promisc_tcam_enable(struct dsaf_device *dsaf_dev, u32 port) · 59 unmodified lines | ||
| 2815 | 2818 | memset(&temp_key, 0x0, sizeof(temp_key)); |
| 2816 | 2819 | mask_entry.addr[0] = 0x01; |
| 2817 | 2820 | hns_dsaf_set_mac_key(dsaf_dev, &mask_key, mask_entry.in_vlan_id, |
| 2818 | − port, mask_entry.addr); | |
| 2821 | + 0xf, mask_entry.addr); | |
| 2819 | 2822 | tbl_tcam_mcast.tbl_mcast_item_vld = 1; |
| 2820 | 2823 | tbl_tcam_mcast.tbl_mcast_old_en = 0; |
| 2821 | 2824 | |
| 2822 | − if (port < DSAF_SERVICE_NW_NUM) { | |
| 2823 | − mskid = port; | |
| 2824 | − } else if (port >= DSAF_BASE_INNER_PORT_NUM) { | |
| 2825 | − mskid = port - DSAF_BASE_INNER_PORT_NUM + DSAF_SERVICE_NW_NUM; | |
| 2826 | − } else { | |
| 2825 | + /* set MAC port to handle multicast */ | |
| 2826 | + mskid = hns_dsaf_get_port_id(port); | |
| 2827 | + if (mskid == -EINVAL) { | |
| 2827 | 2828 | dev_err(dsaf_dev->dev, "%s,pnum(%d)error,key(%#x:%#x)\n", |
| 2828 | 2829 | dsaf_dev->ae_dev.name, port, |
| 2829 | 2830 | mask_key.high.val, mask_key.low.val); |
| 2830 | 2831 | return; |
| 2831 | 2832 | } |
| 2833 | + dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32], | |
| 2834 | + mskid % 32, 1); | |
| 2832 | 2835 | |
| 2836 | + /* set pool bit map to handle multicast */ | |
| 2837 | + mskid = hns_dsaf_get_port_id(port_num); | |
| 2838 | + if (mskid == -EINVAL) { | |
| 2839 | + dev_err(dsaf_dev->dev, | |
| 2840 | + "%s, pool bit map pnum(%d)error,key(%#x:%#x)\n", | |
| 2841 | + dsaf_dev->ae_dev.name, port_num, | |
| 2842 | + mask_key.high.val, mask_key.low.val); | |
| 2843 | + return; | |
| 2844 | + } | |
| 2833 | 2845 | dsaf_set_bit(tbl_tcam_mcast.tbl_mcast_port_msk[mskid / 32], |
| 2834 | 2846 | mskid % 32, 1); |
| 2847 | + | |
| 2835 | 2848 | memcpy(&temp_key, &mask_key, sizeof(mask_key)); |
| 2836 | 2849 | hns_dsaf_tcam_mc_cfg_vague(dsaf_dev, entry_index, &tbl_tcam_data_mc, |
| 2837 | 2850 | (struct dsaf_tbl_tcam_data *)(&mask_key), |
| @@ -467,4 +467,6 @@ int hns_dsaf_clr_mac_mc_port(struct dsaf_device *dsaf_dev, · 466 unmodified lines | ||
| 467 | 467 | u8 mac_id, u8 port_num); |
| 468 | 468 | int hns_dsaf_wait_pkt_clean(struct dsaf_device *dsaf_dev, int port); |
| 469 | 469 | |
| 470 | +int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset); | |
| 471 | + | |
| 470 | 472 | #endif /* __HNS_DSAF_MAIN_H__ */ |
| @@ -670,7 +670,7 @@ static int hns_mac_config_sds_loopback(struct hns_mac_cb *mac_cb, bool en) · 669 unmodified lines | ||
| 670 | 670 | dsaf_set_field(origin, 1ull << 10, 10, en); |
| 671 | 671 | dsaf_write_syscon(mac_cb->serdes_ctrl, reg_offset, origin); |
| 672 | 672 | } else { |
| 673 | − u8 *base_addr = (u8 *)mac_cb->serdes_vaddr + | |
| 673 | + u8 __iomem *base_addr = mac_cb->serdes_vaddr + | |
| 674 | 674 | (mac_cb->mac_id <= 3 ? 0x00280000 : 0x00200000); |
| 675 | 675 | dsaf_set_reg_field(base_addr, reg_offset, 1ull << 10, 10, en); |
| 676 | 676 | } |
| @@ -61,7 +61,7 @@ void hns_ppe_set_indir_table(struct hns_ppe_cb *ppe_cb, · 60 unmodified lines | ||
| 61 | 61 | } |
| 62 | 62 | } |
| 63 | 63 | |
| 64 | −static void __iomem * | |
| 64 | +static u8 __iomem * | |
| 65 | 65 | hns_ppe_common_get_ioaddr(struct ppe_common_cb *ppe_common) |
| 66 | 66 | { |
| 67 | 67 | return ppe_common->dsaf_dev->ppe_base + PPE_COMMON_REG_OFFSET; |
| @@ -111,8 +111,8 @@ hns_ppe_common_free_cfg(struct dsaf_device *dsaf_dev, u32 comm_index) · 43 unmodified lines | ||
| 111 | 111 | dsaf_dev->ppe_common[comm_index] = NULL; |
| 112 | 112 | } |
| 113 | 113 | |
| 114 | −static void __iomem *hns_ppe_get_iobase(struct ppe_common_cb *ppe_common, | |
| 115 | − int ppe_idx) | |
| 114 | +static u8 __iomem *hns_ppe_get_iobase(struct ppe_common_cb *ppe_common, | |
| 115 | + int ppe_idx) | |
| 116 | 116 | { |
| 117 | 117 | return ppe_common->dsaf_dev->ppe_base + ppe_idx * PPE_REG_OFFSET; |
| 118 | 118 | } |
| @@ -80,7 +80,7 @@ struct hns_ppe_cb { · 79 unmodified lines | ||
| 80 | 80 | struct hns_ppe_hw_stats hw_stats; |
| 81 | 81 | |
| 82 | 82 | u8 index; /* index in a ppe common device */ |
| 83 | − void __iomem *io_base; | |
| 83 | + u8 __iomem *io_base; | |
| 84 | 84 | int virq; |
| 85 | 85 | u32 rss_indir_table[HNS_PPEV2_RSS_IND_TBL_SIZE]; /*shadow indir tab */ |
| 86 | 86 | u32 rss_key[HNS_PPEV2_RSS_KEY_NUM]; /* rss hash key */ |
| @@ -89,7 +89,7 @@ struct hns_ppe_cb { · 2 unmodified lines | ||
| 89 | 89 | struct ppe_common_cb { |
| 90 | 90 | struct device *dev; |
| 91 | 91 | struct dsaf_device *dsaf_dev; |
| 92 | − void __iomem *io_base; | |
| 92 | + u8 __iomem *io_base; | |
| 93 | 93 | |
| 94 | 94 | enum ppe_common_mode ppe_mode; |
| 95 | 95 | |
| @@ -458,7 +458,7 @@ static void hns_rcb_ring_get_cfg(struct hnae_queue *q, int ring_type) · 457 unmodified lines | ||
| 458 | 458 | mdnum_ppkt = HNS_RCB_RING_MAX_BD_PER_PKT; |
| 459 | 459 | } else { |
| 460 | 460 | ring = &q->tx_ring; |
| 461 | − ring->io_base = (u8 __iomem *)ring_pair_cb->q.io_base + | |
| 461 | + ring->io_base = ring_pair_cb->q.io_base + | |
| 462 | 462 | HNS_RCB_TX_REG_OFFSET; |
| 463 | 463 | irq_idx = HNS_RCB_IRQ_IDX_TX; |
| 464 | 464 | mdnum_ppkt = is_ver1 ? HNS_RCB_RING_MAX_TXBD_PER_PKT : |
| @@ -764,7 +764,7 @@ static int hns_rcb_get_ring_num(struct dsaf_device *dsaf_dev) · 299 unmodified lines | ||
| 764 | 764 | } |
| 765 | 765 | } |
| 766 | 766 | |
| 767 | −static void __iomem *hns_rcb_common_get_vaddr(struct rcb_common_cb *rcb_common) | |
| 767 | +static u8 __iomem *hns_rcb_common_get_vaddr(struct rcb_common_cb *rcb_common) | |
| 768 | 768 | { |
| 769 | 769 | struct dsaf_device *dsaf_dev = rcb_common->dsaf_dev; |
| 770 | 770 | |
| @@ -1018,7 +1018,7 @@ · 1017 unmodified lines | ||
| 1018 | 1018 | #define XGMAC_PAUSE_CTL_RSP_MODE_B 2 |
| 1019 | 1019 | #define XGMAC_PAUSE_CTL_TX_XOFF_B 3 |
| 1020 | 1020 | |
| 1021 | −static inline void dsaf_write_reg(void __iomem *base, u32 reg, u32 value) | |
| 1021 | +static inline void dsaf_write_reg(u8 __iomem *base, u32 reg, u32 value) | |
| 1022 | 1022 | { |
| 1023 | 1023 | writel(value, base + reg); |
| 1024 | 1024 | } |
| @@ -1053,7 +1053,7 @@ static inline int dsaf_read_syscon(struct regmap *base, u32 reg, u32 *val) · 28 unmodified lines | ||
| 1053 | 1053 | #define dsaf_set_bit(origin, shift, val) \ |
| 1054 | 1054 | dsaf_set_field((origin), (1ull << (shift)), (shift), (val)) |
| 1055 | 1055 | |
| 1056 | −static inline void dsaf_set_reg_field(void __iomem *base, u32 reg, u32 mask, | |
| 1056 | +static inline void dsaf_set_reg_field(u8 __iomem *base, u32 reg, u32 mask, | |
| 1057 | 1057 | u32 shift, u32 val) |
| 1058 | 1058 | { |
| 1059 | 1059 | u32 origin = dsaf_read_reg(base, reg); |
| @@ -1073,7 +1073,7 @@ static inline void dsaf_set_reg_field(void __iomem *base, u32 reg, u32 mask, · 13 unmodified lines | ||
| 1073 | 1073 | #define dsaf_get_bit(origin, shift) \ |
| 1074 | 1074 | dsaf_get_field((origin), (1ull << (shift)), (shift)) |
| 1075 | 1075 | |
| 1076 | −static inline u32 dsaf_get_reg_field(void __iomem *base, u32 reg, u32 mask, | |
| 1076 | +static inline u32 dsaf_get_reg_field(u8 __iomem *base, u32 reg, u32 mask, | |
| 1077 | 1077 | u32 shift) |
| 1078 | 1078 | { |
| 1079 | 1079 | u32 origin; |
| @@ -1089,11 +1089,11 @@ static inline u32 dsaf_get_reg_field(void __iomem *base, u32 reg, u32 mask, · 9 unmodified lines | ||
| 1089 | 1089 | dsaf_get_reg_field((dev)->io_base, (reg), (1ull << (bit)), (bit)) |
| 1090 | 1090 | |
| 1091 | 1091 | #define dsaf_write_b(addr, data)\ |
| 1092 | − writeb((data), (__iomem unsigned char *)(addr)) | |
| 1092 | + writeb((data), (__iomem u8 *)(addr)) | |
| 1093 | 1093 | #define dsaf_read_b(addr)\ |
| 1094 | − readb((__iomem unsigned char *)(addr)) | |
| 1094 | + readb((__iomem u8 *)(addr)) | |
| 1095 | 1095 | |
| 1096 | 1096 | #define hns_mac_reg_read64(drv, offset) \ |
| 1097 | − readq((__iomem void *)(((u8 *)(drv)->io_base + 0xc00 + (offset)))) | |
| 1097 | + readq((__iomem void *)(((drv)->io_base + 0xc00 + (offset)))) | |
| 1098 | 1098 | |
| 1099 | 1099 | #endif /* _DSAF_REG_H */ |
| @@ -129,7 +129,7 @@ static void hns_xgmac_lf_rf_control_init(struct mac_driver *mac_drv) · 128 unmodified lines | ||
| 129 | 129 | dsaf_set_bit(val, XGMAC_UNIDIR_EN_B, 0); |
| 130 | 130 | dsaf_set_bit(val, XGMAC_RF_TX_EN_B, 1); |
| 131 | 131 | dsaf_set_field(val, XGMAC_LF_RF_INSERT_M, XGMAC_LF_RF_INSERT_S, 0); |
| 132 | − dsaf_write_reg(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val); | |
| 132 | + dsaf_write_dev(mac_drv, XGMAC_MAC_TX_LF_RF_CONTROL_REG, val); | |
| 133 | 133 | } |
| 134 | 134 | |
| 135 | 135 | /** |
| @@ -29,9 +29,6 @@ · 28 unmodified lines | ||
| 29 | 29 | |
| 30 | 30 | #define SERVICE_TIMER_HZ (1 * HZ) |
| 31 | 31 | |
| 32 | −#define NIC_TX_CLEAN_MAX_NUM 256 | |
| 33 | −#define NIC_RX_CLEAN_MAX_NUM 64 | |
| 34 | − | |
| 35 | 32 | #define RCB_IRQ_NOT_INITED 0 |
| 36 | 33 | #define RCB_IRQ_INITED 1 |
| 37 | 34 | #define HNS_BUFFER_SIZE_2048 2048 |
| @@ -376,8 +373,6 @@ netdev_tx_t hns_nic_net_xmit_hw(struct net_device *ndev, · 338 unmodified lines | ||
| 376 | 373 | wmb(); /* commit all data before submit */ |
| 377 | 374 | assert(skb->queue_mapping < priv->ae_handle->q_num); |
| 378 | 375 | hnae_queue_xmit(priv->ae_handle->qs[skb->queue_mapping], buf_num); |
| 379 | − ring->stats.tx_pkts++; | |
| 380 | − ring->stats.tx_bytes += skb->len; | |
| 381 | 376 | |
| 382 | 377 | return NETDEV_TX_OK; |
| 383 | 378 | |
| @@ -999,6 +994,9 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data, · 615 unmodified lines | ||
| 999 | 994 | /* issue prefetch for next Tx descriptor */ |
| 1000 | 995 | prefetch(&ring->desc_cb[ring->next_to_clean]); |
| 1001 | 996 | } |
| 997 | + /* update tx ring statistics. */ | |
| 998 | + ring->stats.tx_pkts += pkts; | |
| 999 | + ring->stats.tx_bytes += bytes; | |
| 1002 | 1000 | |
| 1003 | 1001 | NETIF_TX_UNLOCK(ring); |
| 1004 | 1002 | |
| @@ -2152,7 +2150,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv) · 1147 unmodified lines | ||
| 2152 | 2150 | hns_nic_tx_fini_pro_v2; |
| 2153 | 2151 | |
| 2154 | 2152 | netif_napi_add(priv->netdev, &rd->napi, |
| 2155 | − hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM); | |
| 2153 | + hns_nic_common_poll, NAPI_POLL_WEIGHT); | |
| 2156 | 2154 | rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; |
| 2157 | 2155 | } |
| 2158 | 2156 | for (i = h->q_num; i < h->q_num * 2; i++) { |
| @@ -2165,7 +2163,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv) · 6 unmodified lines | ||
| 2165 | 2163 | hns_nic_rx_fini_pro_v2; |
| 2166 | 2164 | |
| 2167 | 2165 | netif_napi_add(priv->netdev, &rd->napi, |
| 2168 | − hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM); | |
| 2166 | + hns_nic_common_poll, NAPI_POLL_WEIGHT); | |
| 2169 | 2167 | rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED; |
| 2170 | 2168 | } |
| 2171 | 2169 | |
| @@ -3,7 +3,7 @@ · 2 unmodified lines | ||
| 3 | 3 | # Makefile for the HISILICON network device drivers. |
| 4 | 4 | # |
| 5 | 5 | |
| 6 | −ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3 | |
| 6 | +ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3 | |
| 7 | 7 | |
| 8 | 8 | obj-$(CONFIG_HNS3_HCLGE) += hclge.o |
| 9 | 9 | hclge-objs = hclge_main.o hclge_cmd.o hclge_mdio.o hclge_tm.o hclge_mbx.o hclge_err.o hclge_debugfs.o |
| @@ -3,7 +3,7 @@ · 2 unmodified lines | ||
| 3 | 3 | # Makefile for the HISILICON network device drivers. |
| 4 | 4 | # |
| 5 | 5 | |
| 6 | −ccflags-y := -Idrivers/net/ethernet/hisilicon/hns3 | |
| 6 | +ccflags-y := -I $(srctree)/drivers/net/ethernet/hisilicon/hns3 | |
| 7 | 7 | |
| 8 | 8 | obj-$(CONFIG_HNS3_HCLGEVF) += hclgevf.o |
| 9 | 9 | hclgevf-objs = hclgevf_main.o hclgevf_cmd.o hclgevf_mbx.o |
| @@ -39,7 +39,7 @@ struct hns_mdio_sc_reg { · 38 unmodified lines | ||
| 39 | 39 | }; |
| 40 | 40 | |
| 41 | 41 | struct hns_mdio_device { |
| 42 | − void *vbase; /* mdio reg base address */ | |
| 42 | + u8 __iomem *vbase; /* mdio reg base address */ | |
| 43 | 43 | struct regmap *subctrl_vbase; |
| 44 | 44 | struct hns_mdio_sc_reg sc_reg; |
| 45 | 45 | }; |
| @@ -96,21 +96,17 @@ enum mdio_c45_op_seq { · 50 unmodified lines | ||
| 96 | 96 | #define MDIO_SC_CLK_ST 0x531C |
| 97 | 97 | #define MDIO_SC_RESET_ST 0x5A1C |
| 98 | 98 | |
| 99 | −static void mdio_write_reg(void *base, u32 reg, u32 value) | |
| 99 | +static void mdio_write_reg(u8 __iomem *base, u32 reg, u32 value) | |
| 100 | 100 | { |
| 101 | − u8 __iomem *reg_addr = (u8 __iomem *)base; | |
| 102 | − | |
| 103 | − writel_relaxed(value, reg_addr + reg); | |
| 101 | + writel_relaxed(value, base + reg); | |
| 104 | 102 | } |
| 105 | 103 | |
| 106 | 104 | #define MDIO_WRITE_REG(a, reg, value) \ |
| 107 | 105 | mdio_write_reg((a)->vbase, (reg), (value)) |
| 108 | 106 | |
| 109 | −static u32 mdio_read_reg(void *base, u32 reg) | |
| 107 | +static u32 mdio_read_reg(u8 __iomem *base, u32 reg) | |
| 110 | 108 | { |
| 111 | − u8 __iomem *reg_addr = (u8 __iomem *)base; | |
| 112 | − | |
| 113 | − return readl_relaxed(reg_addr + reg); | |
| 109 | + return readl_relaxed(base + reg); | |
| 114 | 110 | } |
| 115 | 111 | |
| 116 | 112 | #define mdio_set_field(origin, mask, shift, val) \ |
| @@ -121,7 +117,7 @@ static u32 mdio_read_reg(void *base, u32 reg) · 4 unmodified lines | ||
| 121 | 117 | |
| 122 | 118 | #define mdio_get_field(origin, mask, shift) (((origin) >> (shift)) & (mask)) |
| 123 | 119 | |
| 124 | −static void mdio_set_reg_field(void *base, u32 reg, u32 mask, u32 shift, | |
| 120 | +static void mdio_set_reg_field(u8 __iomem *base, u32 reg, u32 mask, u32 shift, | |
| 125 | 121 | u32 val) |
| 126 | 122 | { |
| 127 | 123 | u32 origin = mdio_read_reg(base, reg); |
| @@ -133,7 +129,7 @@ static void mdio_set_reg_field(void *base, u32 reg, u32 mask, u32 shift, · 5 unmodified lines | ||
| 133 | 129 | #define MDIO_SET_REG_FIELD(dev, reg, mask, shift, val) \ |
| 134 | 130 | mdio_set_reg_field((dev)->vbase, (reg), (mask), (shift), (val)) |
| 135 | 131 | |
| 136 | −static u32 mdio_get_reg_field(void *base, u32 reg, u32 mask, u32 shift) | |
| 132 | +static u32 mdio_get_reg_field(u8 __iomem *base, u32 reg, u32 mask, u32 shift) | |
| 137 | 133 | { |
| 138 | 134 | u32 origin; |
| 139 | 135 | |
| @@ -1885,6 +1885,7 @@ static int do_hard_reset(struct ibmvnic_adapter *adapter, · 1884 unmodified lines | ||
| 1885 | 1885 | */ |
| 1886 | 1886 | adapter->state = VNIC_PROBED; |
| 1887 | 1887 | |
| 1888 | + reinit_completion(&adapter->init_done); | |
| 1888 | 1889 | rc = init_crq_queue(adapter); |
| 1889 | 1890 | if (rc) { |
| 1890 | 1891 | netdev_err(adapter->netdev, |
| @@ -4625,7 +4626,7 @@ static int ibmvnic_reset_init(struct ibmvnic_adapter *adapter) · 2734 unmodified lines | ||
| 4625 | 4626 | old_num_rx_queues = adapter->req_rx_queues; |
| 4626 | 4627 | old_num_tx_queues = adapter->req_tx_queues; |
| 4627 | 4628 | |
| 4628 | − init_completion(&adapter->init_done); | |
| 4629 | + reinit_completion(&adapter->init_done); | |
| 4629 | 4630 | adapter->init_done_rc = 0; |
| 4630 | 4631 | ibmvnic_send_crq_init(adapter); |
| 4631 | 4632 | if (!wait_for_completion_timeout(&adapter->init_done, timeout)) { |
| @@ -4680,7 +4681,6 @@ static int ibmvnic_init(struct ibmvnic_adapter *adapter) · 48 unmodified lines | ||
| 4680 | 4681 | |
| 4681 | 4682 | adapter->from_passive_init = false; |
| 4682 | 4683 | |
| 4683 | − init_completion(&adapter->init_done); | |
| 4684 | 4684 | adapter->init_done_rc = 0; |
| 4685 | 4685 | ibmvnic_send_crq_init(adapter); |
| 4686 | 4686 | if (!wait_for_completion_timeout(&adapter->init_done, timeout)) { |
| @@ -4759,6 +4759,7 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id) · 72 unmodified lines | ||
| 4759 | 4759 | INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset); |
| 4760 | 4760 | INIT_LIST_HEAD(&adapter->rwi_list); |
| 4761 | 4761 | spin_lock_init(&adapter->rwi_lock); |
| 4762 | + init_completion(&adapter->init_done); | |
| 4762 | 4763 | adapter->resetting = false; |
| 4763 | 4764 | |
| 4764 | 4765 | adapter->mac_change_pending = false; |
| @@ -41,6 +41,8 @@ static int __init fm10k_init_module(void) · 40 unmodified lines | ||
| 41 | 41 | /* create driver workqueue */ |
| 42 | 42 | fm10k_workqueue = alloc_workqueue("%s", WQ_MEM_RECLAIM, 0, |
| 43 | 43 | fm10k_driver_name); |
| 44 | + if (!fm10k_workqueue) | |
| 45 | + return -ENOMEM; | |
| 44 | 46 | |
| 45 | 47 | fm10k_dbg_init(); |
| 46 | 48 | |
| @@ -790,6 +790,8 @@ struct i40e_vsi { · 789 unmodified lines | ||
| 790 | 790 | |
| 791 | 791 | /* VSI specific handlers */ |
| 792 | 792 | irqreturn_t (*irq_handler)(int irq, void *data); |
| 793 | + | |
| 794 | + unsigned long *af_xdp_zc_qps; /* tracks AF_XDP ZC enabled qps */ | |
| 793 | 795 | } ____cacheline_internodealigned_in_smp; |
| 794 | 796 | |
| 795 | 797 | struct i40e_netdev_priv { |
| @@ -1096,20 +1098,6 @@ static inline bool i40e_enabled_xdp_vsi(struct i40e_vsi *vsi) · 300 unmodified lines | ||
| 1096 | 1098 | return !!vsi->xdp_prog; |
| 1097 | 1099 | } |
| 1098 | 1100 | |
| 1099 | −static inline struct xdp_umem *i40e_xsk_umem(struct i40e_ring *ring) | |
| 1100 | −{ | |
| 1101 | − bool xdp_on = i40e_enabled_xdp_vsi(ring->vsi); | |
| 1102 | − int qid = ring->queue_index; | |
| 1103 | − | |
| 1104 | − if (ring_is_xdp(ring)) | |
| 1105 | − qid -= ring->vsi->alloc_queue_pairs; | |
| 1106 | − | |
| 1107 | − if (!xdp_on) | |
| 1108 | − return NULL; | |
| 1109 | − | |
| 1110 | − return xdp_get_umem_from_qid(ring->vsi->netdev, qid); | |
| 1111 | −} | |
| 1112 | − | |
| 1113 | 1101 | int i40e_create_queue_channel(struct i40e_vsi *vsi, struct i40e_channel *ch); |
| 1114 | 1102 | int i40e_set_bw_limit(struct i40e_vsi *vsi, u16 seid, u64 max_tx_rate); |
| 1115 | 1103 | int i40e_add_del_cloud_filter(struct i40e_vsi *vsi, |
| @@ -2573,8 +2573,7 @@ static int i40e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) · 2572 unmodified lines | ||
| 2573 | 2573 | return -EOPNOTSUPP; |
| 2574 | 2574 | |
| 2575 | 2575 | /* only magic packet is supported */ |
| 2576 | − if (wol->wolopts && (wol->wolopts != WAKE_MAGIC) | |
| 2577 | − | (wol->wolopts != WAKE_FILTER)) | |
| 2576 | + if (wol->wolopts & ~WAKE_MAGIC) | |
| 2578 | 2577 | return -EOPNOTSUPP; |
| 2579 | 2578 | |
| 2580 | 2579 | /* is this a new value? */ |
| @@ -3063,6 +3063,26 @@ static void i40e_config_xps_tx_ring(struct i40e_ring *ring) · 3062 unmodified lines | ||
| 3063 | 3063 | ring->queue_index); |
| 3064 | 3064 | } |
| 3065 | 3065 | |
| 3066 | +/** | |
| 3067 | + * i40e_xsk_umem - Retrieve the AF_XDP ZC if XDP and ZC is enabled | |
| 3068 | + * @ring: The Tx or Rx ring | |
| 3069 | + * | |
| 3070 | + * Returns the UMEM or NULL. | |
| 3071 | + **/ | |
| 3072 | +static struct xdp_umem *i40e_xsk_umem(struct i40e_ring *ring) | |
| 3073 | +{ | |
| 3074 | + bool xdp_on = i40e_enabled_xdp_vsi(ring->vsi); | |
| 3075 | + int qid = ring->queue_index; | |
| 3076 | + | |
| 3077 | + if (ring_is_xdp(ring)) | |
| 3078 | + qid -= ring->vsi->alloc_queue_pairs; | |
| 3079 | + | |
| 3080 | + if (!xdp_on || !test_bit(qid, ring->vsi->af_xdp_zc_qps)) | |
| 3081 | + return NULL; | |
| 3082 | + | |
| 3083 | + return xdp_get_umem_from_qid(ring->vsi->netdev, qid); | |
| 3084 | +} | |
| 3085 | + | |
| 3066 | 3086 | /** |
| 3067 | 3087 | * i40e_configure_tx_ring - Configure a transmit ring context and rest |
| 3068 | 3088 | * @ring: The Tx ring to configure |
| @@ -10064,6 +10084,12 @@ static int i40e_vsi_mem_alloc(struct i40e_pf *pf, enum i40e_vsi_type type) · 6995 unmodified lines | ||
| 10064 | 10084 | hash_init(vsi->mac_filter_hash); |
| 10065 | 10085 | vsi->irqs_ready = false; |
| 10066 | 10086 | |
| 10087 | + if (type == I40E_VSI_MAIN) { | |
| 10088 | + vsi->af_xdp_zc_qps = bitmap_zalloc(pf->num_lan_qps, GFP_KERNEL); | |
| 10089 | + if (!vsi->af_xdp_zc_qps) | |
| 10090 | + goto err_rings; | |
| 10091 | + } | |
| 10092 | + | |
| 10067 | 10093 | ret = i40e_set_num_rings_in_vsi(vsi); |
| 10068 | 10094 | if (ret) |
| 10069 | 10095 | goto err_rings; |
| @@ -10082,6 +10108,7 @@ static int i40e_vsi_mem_alloc(struct i40e_pf *pf, enum i40e_vsi_type type) · 12 unmodified lines | ||
| 10082 | 10108 | goto unlock_pf; |
| 10083 | 10109 | |
| 10084 | 10110 | err_rings: |
| 10111 | + bitmap_free(vsi->af_xdp_zc_qps); | |
| 10085 | 10112 | pf->next_vsi = i - 1; |
| 10086 | 10113 | kfree(vsi); |
| 10087 | 10114 | unlock_pf: |
| @@ -10162,6 +10189,7 @@ static int i40e_vsi_clear(struct i40e_vsi *vsi) · 74 unmodified lines | ||
| 10162 | 10189 | i40e_put_lump(pf->qp_pile, vsi->base_queue, vsi->idx); |
| 10163 | 10190 | i40e_put_lump(pf->irq_pile, vsi->base_vector, vsi->idx); |
| 10164 | 10191 | |
| 10192 | + bitmap_free(vsi->af_xdp_zc_qps); | |
| 10165 | 10193 | i40e_vsi_free_arrays(vsi, true); |
| 10166 | 10194 | i40e_clear_rss_config_user(vsi); |
| 10167 | 10195 | |
| @@ -146,12 +146,13 @@ static int i40e_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb) · 145 unmodified lines | ||
| 146 | 146 | static int i40e_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta) |
| 147 | 147 | { |
| 148 | 148 | struct i40e_pf *pf = container_of(ptp, struct i40e_pf, ptp_caps); |
| 149 | − struct timespec64 now; | |
| 149 | + struct timespec64 now, then; | |
| 150 | 150 | |
| 151 | + then = ns_to_timespec64(delta); | |
| 151 | 152 | mutex_lock(&pf->tmreg_lock); |
| 152 | 153 | |
| 153 | 154 | i40e_ptp_read(pf, &now, NULL); |
| 154 | − timespec64_add_ns(&now, delta); | |
| 155 | + now = timespec64_add(now, then); | |
| 155 | 156 | i40e_ptp_write(pf, (const struct timespec64 *)&now); |
| 156 | 157 | |
| 157 | 158 | mutex_unlock(&pf->tmreg_lock); |
| @@ -102,6 +102,8 @@ static int i40e_xsk_umem_enable(struct i40e_vsi *vsi, struct xdp_umem *umem, · 101 unmodified lines | ||
| 102 | 102 | if (err) |
| 103 | 103 | return err; |
| 104 | 104 | |
| 105 | + set_bit(qid, vsi->af_xdp_zc_qps); | |
| 106 | + | |
| 105 | 107 | if_running = netif_running(vsi->netdev) && i40e_enabled_xdp_vsi(vsi); |
| 106 | 108 | |
| 107 | 109 | if (if_running) { |
| @@ -148,6 +150,7 @@ static int i40e_xsk_umem_disable(struct i40e_vsi *vsi, u16 qid) · 40 unmodified lines | ||
| 148 | 150 | return err; |
| 149 | 151 | } |
| 150 | 152 | |
| 153 | + clear_bit(qid, vsi->af_xdp_zc_qps); | |
| 151 | 154 | i40e_xsk_umem_dma_unmap(vsi, umem); |
| 152 | 155 | |
| 153 | 156 | if (if_running) { |
| @@ -194,6 +194,8 @@ · 193 unmodified lines | ||
| 194 | 194 | /* enable link status from external LINK_0 and LINK_1 pins */ |
| 195 | 195 | #define E1000_CTRL_SWDPIN0 0x00040000 /* SWDPIN 0 value */ |
| 196 | 196 | #define E1000_CTRL_SWDPIN1 0x00080000 /* SWDPIN 1 value */ |
| 197 | +#define E1000_CTRL_ADVD3WUC 0x00100000 /* D3 WUC */ | |
| 198 | +#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 /* PHY PM enable */ | |
| 197 | 199 | #define E1000_CTRL_SDP0_DIR 0x00400000 /* SDP0 Data direction */ |
| 198 | 200 | #define E1000_CTRL_SDP1_DIR 0x00800000 /* SDP1 Data direction */ |
| 199 | 201 | #define E1000_CTRL_RST 0x04000000 /* Global reset */ |
| @@ -8740,9 +8740,7 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, · 8739 unmodified lines | ||
| 8740 | 8740 | struct e1000_hw *hw = &adapter->hw; |
| 8741 | 8741 | u32 ctrl, rctl, status; |
| 8742 | 8742 | u32 wufc = runtime ? E1000_WUFC_LNKC : adapter->wol; |
| 8743 | −#ifdef CONFIG_PM | |
| 8744 | − int retval = 0; | |
| 8745 | −#endif | |
| 8743 | + bool wake; | |
| 8746 | 8744 | |
| 8747 | 8745 | rtnl_lock(); |
| 8748 | 8746 | netif_device_detach(netdev); |
| @@ -8755,14 +8753,6 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, · 6 unmodified lines | ||
| 8755 | 8753 | igb_clear_interrupt_scheme(adapter); |
| 8756 | 8754 | rtnl_unlock(); |
| 8757 | 8755 | |
| 8758 | −#ifdef CONFIG_PM | |
| 8759 | − if (!runtime) { | |
| 8760 | − retval = pci_save_state(pdev); | |
| 8761 | − if (retval) | |
| 8762 | − return retval; | |
| 8763 | − } | |
| 8764 | −#endif | |
| 8765 | − | |
| 8766 | 8756 | status = rd32(E1000_STATUS); |
| 8767 | 8757 | if (status & E1000_STATUS_LU) |
| 8768 | 8758 | wufc &= ~E1000_WUFC_LNKC; |
| @@ -8779,10 +8769,6 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, · 10 unmodified lines | ||
| 8779 | 8769 | } |
| 8780 | 8770 | |
| 8781 | 8771 | ctrl = rd32(E1000_CTRL); |
| 8782 | − /* advertise wake from D3Cold */ | |
| 8783 | − #define E1000_CTRL_ADVD3WUC 0x00100000 | |
| 8784 | − /* phy power management enable */ | |
| 8785 | − #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 | |
| 8786 | 8772 | ctrl |= E1000_CTRL_ADVD3WUC; |
| 8787 | 8773 | wr32(E1000_CTRL, ctrl); |
| 8788 | 8774 | |
| @@ -8796,12 +8782,15 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, · 7 unmodified lines | ||
| 8796 | 8782 | wr32(E1000_WUFC, 0); |
| 8797 | 8783 | } |
| 8798 | 8784 | |
| 8799 | − *enable_wake = wufc || adapter->en_mng_pt; | |
| 8800 | − if (!*enable_wake) | |
| 8785 | + wake = wufc || adapter->en_mng_pt; | |
| 8786 | + if (!wake) | |
| 8801 | 8787 | igb_power_down_link(adapter); |
| 8802 | 8788 | else |
| 8803 | 8789 | igb_power_up_link(adapter); |
| 8804 | 8790 | |
| 8791 | + if (enable_wake) | |
| 8792 | + *enable_wake = wake; | |
| 8793 | + | |
| 8805 | 8794 | /* Release control of h/w to f/w. If f/w is AMT enabled, this |
| 8806 | 8795 | * would have already happened in close and is redundant. |
| 8807 | 8796 | */ |
| @@ -8844,22 +8833,7 @@ static void igb_deliver_wake_packet(struct net_device *netdev) · 36 unmodified lines | ||
| 8844 | 8833 | |
| 8845 | 8834 | static int __maybe_unused igb_suspend(struct device *dev) |
| 8846 | 8835 | { |
| 8847 | − int retval; | |
| 8848 | − bool wake; | |
| 8849 | − struct pci_dev *pdev = to_pci_dev(dev); | |
| 8850 | − | |
| 8851 | − retval = __igb_shutdown(pdev, &wake, 0); | |
| 8852 | − if (retval) | |
| 8853 | − return retval; | |
| 8854 | − | |
| 8855 | − if (wake) { | |
| 8856 | − pci_prepare_to_sleep(pdev); | |
| 8857 | − } else { | |
| 8858 | − pci_wake_from_d3(pdev, false); | |
| 8859 | − pci_set_power_state(pdev, PCI_D3hot); | |
| 8860 | − } | |
| 8861 | − | |
| 8862 | − return 0; | |
| 8836 | + return __igb_shutdown(to_pci_dev(dev), NULL, 0); | |
| 8863 | 8837 | } |
| 8864 | 8838 | |
| 8865 | 8839 | static int __maybe_unused igb_resume(struct device *dev) |
| @@ -8930,22 +8904,7 @@ static int __maybe_unused igb_runtime_idle(struct device *dev) · 64 unmodified lines | ||
| 8930 | 8904 | |
| 8931 | 8905 | static int __maybe_unused igb_runtime_suspend(struct device *dev) |
| 8932 | 8906 | { |
| 8933 | − struct pci_dev *pdev = to_pci_dev(dev); | |
| 8934 | − int retval; | |
| 8935 | − bool wake; | |
| 8936 | − | |
| 8937 | − retval = __igb_shutdown(pdev, &wake, 1); | |
| 8938 | − if (retval) | |
| 8939 | − return retval; | |
| 8940 | − | |
| 8941 | − if (wake) { | |
| 8942 | − pci_prepare_to_sleep(pdev); | |
| 8943 | − } else { | |
| 8944 | − pci_wake_from_d3(pdev, false); | |
| 8945 | − pci_set_power_state(pdev, PCI_D3hot); | |
| 8946 | − } | |
| 8947 | − | |
| 8948 | − return 0; | |
| 8907 | + return __igb_shutdown(to_pci_dev(dev), NULL, 1); | |
| 8949 | 8908 | } |
| 8950 | 8909 | |
| 8951 | 8910 | static int __maybe_unused igb_runtime_resume(struct device *dev) |
| @@ -905,13 +905,12 @@ s32 ixgbe_mii_bus_init(struct ixgbe_hw *hw) · 904 unmodified lines | ||
| 905 | 905 | struct pci_dev *pdev = adapter->pdev; |
| 906 | 906 | struct device *dev = &adapter->netdev->dev; |
| 907 | 907 | struct mii_bus *bus; |
| 908 | + int err = -ENODEV; | |
| 908 | 909 | |
| 909 | − adapter->mii_bus = devm_mdiobus_alloc(dev); | |
| 910 | − if (!adapter->mii_bus) | |
| 910 | + bus = devm_mdiobus_alloc(dev); | |
| 911 | + if (!bus) | |
| 911 | 912 | return -ENOMEM; |
| 912 | 913 | |
| 913 | − bus = adapter->mii_bus; | |
| 914 | − | |
| 915 | 914 | switch (hw->device_id) { |
| 916 | 915 | /* C3000 SoCs */ |
| 917 | 916 | case IXGBE_DEV_ID_X550EM_A_KR: |
| @@ -949,12 +948,15 @@ s32 ixgbe_mii_bus_init(struct ixgbe_hw *hw) · 31 unmodified lines | ||
| 949 | 948 | */ |
| 950 | 949 | hw->phy.mdio.mode_support = MDIO_SUPPORTS_C45 | MDIO_SUPPORTS_C22; |
| 951 | 950 | |
| 952 | − return mdiobus_register(bus); | |
| 951 | + err = mdiobus_register(bus); | |
| 952 | + if (!err) { | |
| 953 | + adapter->mii_bus = bus; | |
| 954 | + return 0; | |
| 955 | + } | |
| 953 | 956 | |
| 954 | 957 | ixgbe_no_mii_bus: |
| 955 | 958 | devm_mdiobus_free(dev, bus); |
| 956 | − adapter->mii_bus = NULL; | |
| 957 | − return -ENODEV; | |
| 959 | + return err; | |
| 958 | 960 | } |
| 959 | 961 | |
| 960 | 962 | /** |
| @@ -96,9 +96,6 @@ int mlx5_port_query_eth_proto(struct mlx5_core_dev *dev, u8 port, bool ext, · 95 unmodified lines | ||
| 96 | 96 | if (!eproto) |
| 97 | 97 | return -EINVAL; |
| 98 | 98 | |
| 99 | − if (ext != MLX5_CAP_PCAM_FEATURE(dev, ptys_extended_ethernet)) | |
| 100 | − return -EOPNOTSUPP; | |
| 101 | − | |
| 102 | 99 | err = mlx5_query_port_ptys(dev, out, sizeof(out), MLX5_PTYS_EN, port); |
| 103 | 100 | if (err) |
| 104 | 101 | return err; |
| @@ -122,7 +122,9 @@ out: · 121 unmodified lines | ||
| 122 | 122 | return err; |
| 123 | 123 | } |
| 124 | 124 | |
| 125 | −/* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B]) */ | |
| 125 | +/* xoff = ((301+2.16 * len [m]) * speed [Gbps] + 2.72 MTU [B]) | |
| 126 | + * minimum speed value is 40Gbps | |
| 127 | + */ | |
| 126 | 128 | static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu) |
| 127 | 129 | { |
| 128 | 130 | u32 speed; |
| @@ -130,10 +132,9 @@ static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu) · 1 unmodified line | ||
| 130 | 132 | int err; |
| 131 | 133 | |
| 132 | 134 | err = mlx5e_port_linkspeed(priv->mdev, &speed); |
| 133 | − if (err) { | |
| 134 | − mlx5_core_warn(priv->mdev, "cannot get port speed\n"); | |
| 135 | − return 0; | |
| 136 | − } | |
| 135 | + if (err) | |
| 136 | + speed = SPEED_40000; | |
| 137 | + speed = max_t(u32, speed, SPEED_40000); | |
| 137 | 138 | |
| 138 | 139 | xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100; |
| 139 | 140 | |
| @@ -142,7 +143,7 @@ static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu) · 2 unmodified lines | ||
| 142 | 143 | } |
| 143 | 144 | |
| 144 | 145 | static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer, |
| 145 | − u32 xoff, unsigned int mtu) | |
| 146 | + u32 xoff, unsigned int max_mtu) | |
| 146 | 147 | { |
| 147 | 148 | int i; |
| 148 | 149 | |
| @@ -154,11 +155,12 @@ static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer, · 5 unmodified lines | ||
| 154 | 155 | } |
| 155 | 156 | |
| 156 | 157 | if (port_buffer->buffer[i].size < |
| 157 | − (xoff + mtu + (1 << MLX5E_BUFFER_CELL_SHIFT))) | |
| 158 | + (xoff + max_mtu + (1 << MLX5E_BUFFER_CELL_SHIFT))) | |
| 158 | 159 | return -ENOMEM; |
| 159 | 160 | |
| 160 | 161 | port_buffer->buffer[i].xoff = port_buffer->buffer[i].size - xoff; |
| 161 | − port_buffer->buffer[i].xon = port_buffer->buffer[i].xoff - mtu; | |
| 162 | + port_buffer->buffer[i].xon = | |
| 163 | + port_buffer->buffer[i].xoff - max_mtu; | |
| 162 | 164 | } |
| 163 | 165 | |
| 164 | 166 | return 0; |
| @@ -166,7 +168,7 @@ static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer, · 1 unmodified line | ||
| 166 | 168 | |
| 167 | 169 | /** |
| 168 | 170 | * update_buffer_lossy() |
| 169 | − * mtu: device's MTU | |
| 171 | + * max_mtu: netdev's max_mtu | |
| 170 | 172 | * pfc_en: <input> current pfc configuration |
| 171 | 173 | * buffer: <input> current prio to buffer mapping |
| 172 | 174 | * xoff: <input> xoff value |
| @@ -183,7 +185,7 @@ static int update_xoff_threshold(struct mlx5e_port_buffer *port_buffer, · 10 unmodified lines | ||
| 183 | 185 | * Return 0 if no error. |
| 184 | 186 | * Set change to true if buffer configuration is modified. |
| 185 | 187 | */ |
| 186 | −static int update_buffer_lossy(unsigned int mtu, | |
| 188 | +static int update_buffer_lossy(unsigned int max_mtu, | |
| 187 | 189 | u8 pfc_en, u8 *buffer, u32 xoff, |
| 188 | 190 | struct mlx5e_port_buffer *port_buffer, |
| 189 | 191 | bool *change) |
| @@ -220,7 +222,7 @@ static int update_buffer_lossy(unsigned int mtu, · 30 unmodified lines | ||
| 220 | 222 | } |
| 221 | 223 | |
| 222 | 224 | if (changed) { |
| 223 | − err = update_xoff_threshold(port_buffer, xoff, mtu); | |
| 225 | + err = update_xoff_threshold(port_buffer, xoff, max_mtu); | |
| 224 | 226 | if (err) |
| 225 | 227 | return err; |
| 226 | 228 | |
| @@ -230,6 +232,7 @@ static int update_buffer_lossy(unsigned int mtu, · 3 unmodified lines | ||
| 230 | 232 | return 0; |
| 231 | 233 | } |
| 232 | 234 | |
| 235 | +#define MINIMUM_MAX_MTU 9216 | |
| 233 | 236 | int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, |
| 234 | 237 | u32 change, unsigned int mtu, |
| 235 | 238 | struct ieee_pfc *pfc, |
| @@ -241,12 +244,14 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 5 unmodified lines | ||
| 241 | 244 | bool update_prio2buffer = false; |
| 242 | 245 | u8 buffer[MLX5E_MAX_PRIORITY]; |
| 243 | 246 | bool update_buffer = false; |
| 247 | + unsigned int max_mtu; | |
| 244 | 248 | u32 total_used = 0; |
| 245 | 249 | u8 curr_pfc_en; |
| 246 | 250 | int err; |
| 247 | 251 | int i; |
| 248 | 252 | |
| 249 | 253 | mlx5e_dbg(HW, priv, "%s: change=%x\n", __func__, change); |
| 254 | + max_mtu = max_t(unsigned int, priv->netdev->max_mtu, MINIMUM_MAX_MTU); | |
| 250 | 255 | |
| 251 | 256 | err = mlx5e_port_query_buffer(priv, &port_buffer); |
| 252 | 257 | if (err) |
| @@ -254,7 +259,7 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 1 unmodified line | ||
| 254 | 259 | |
| 255 | 260 | if (change & MLX5E_PORT_BUFFER_CABLE_LEN) { |
| 256 | 261 | update_buffer = true; |
| 257 | − err = update_xoff_threshold(&port_buffer, xoff, mtu); | |
| 262 | + err = update_xoff_threshold(&port_buffer, xoff, max_mtu); | |
| 258 | 263 | if (err) |
| 259 | 264 | return err; |
| 260 | 265 | } |
| @@ -264,7 +269,7 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 3 unmodified lines | ||
| 264 | 269 | if (err) |
| 265 | 270 | return err; |
| 266 | 271 | |
| 267 | − err = update_buffer_lossy(mtu, pfc->pfc_en, buffer, xoff, | |
| 272 | + err = update_buffer_lossy(max_mtu, pfc->pfc_en, buffer, xoff, | |
| 268 | 273 | &port_buffer, &update_buffer); |
| 269 | 274 | if (err) |
| 270 | 275 | return err; |
| @@ -276,8 +281,8 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 5 unmodified lines | ||
| 276 | 281 | if (err) |
| 277 | 282 | return err; |
| 278 | 283 | |
| 279 | − err = update_buffer_lossy(mtu, curr_pfc_en, prio2buffer, xoff, | |
| 280 | − &port_buffer, &update_buffer); | |
| 284 | + err = update_buffer_lossy(max_mtu, curr_pfc_en, prio2buffer, | |
| 285 | + xoff, &port_buffer, &update_buffer); | |
| 281 | 286 | if (err) |
| 282 | 287 | return err; |
| 283 | 288 | } |
| @@ -301,7 +306,7 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 17 unmodified lines | ||
| 301 | 306 | return -EINVAL; |
| 302 | 307 | |
| 303 | 308 | update_buffer = true; |
| 304 | − err = update_xoff_threshold(&port_buffer, xoff, mtu); | |
| 309 | + err = update_xoff_threshold(&port_buffer, xoff, max_mtu); | |
| 305 | 310 | if (err) |
| 306 | 311 | return err; |
| 307 | 312 | } |
| @@ -309,7 +314,7 @@ int mlx5e_port_manual_buffer_config(struct mlx5e_priv *priv, · 1 unmodified line | ||
| 309 | 314 | /* Need to update buffer configuration if xoff value is changed */ |
| 310 | 315 | if (!update_buffer && xoff != priv->dcbx.xoff) { |
| 311 | 316 | update_buffer = true; |
| 312 | − err = update_xoff_threshold(&port_buffer, xoff, mtu); | |
| 317 | + err = update_xoff_threshold(&port_buffer, xoff, max_mtu); | |
| 313 | 318 | if (err) |
| 314 | 319 | return err; |
| 315 | 320 | } |
| @@ -45,7 +45,9 @@ int mlx5e_create_tir(struct mlx5_core_dev *mdev, · 44 unmodified lines | ||
| 45 | 45 | if (err) |
| 46 | 46 | return err; |
| 47 | 47 | |
| 48 | + mutex_lock(&mdev->mlx5e_res.td.list_lock); | |
| 48 | 49 | list_add(&tir->list, &mdev->mlx5e_res.td.tirs_list); |
| 50 | + mutex_unlock(&mdev->mlx5e_res.td.list_lock); | |
| 49 | 51 | |
| 50 | 52 | return 0; |
| 51 | 53 | } |
| @@ -53,8 +55,10 @@ int mlx5e_create_tir(struct mlx5_core_dev *mdev, · 1 unmodified line | ||
| 53 | 55 | void mlx5e_destroy_tir(struct mlx5_core_dev *mdev, |
| 54 | 56 | struct mlx5e_tir *tir) |
| 55 | 57 | { |
| 58 | + mutex_lock(&mdev->mlx5e_res.td.list_lock); | |
| 56 | 59 | mlx5_core_destroy_tir(mdev, tir->tirn); |
| 57 | 60 | list_del(&tir->list); |
| 61 | + mutex_unlock(&mdev->mlx5e_res.td.list_lock); | |
| 58 | 62 | } |
| 59 | 63 | |
| 60 | 64 | static int mlx5e_create_mkey(struct mlx5_core_dev *mdev, u32 pdn, |
| @@ -114,6 +118,7 @@ int mlx5e_create_mdev_resources(struct mlx5_core_dev *mdev) · 53 unmodified lines | ||
| 114 | 118 | } |
| 115 | 119 | |
| 116 | 120 | INIT_LIST_HEAD(&mdev->mlx5e_res.td.tirs_list); |
| 121 | + mutex_init(&mdev->mlx5e_res.td.list_lock); | |
| 117 | 122 | |
| 118 | 123 | return 0; |
| 119 | 124 | |
| @@ -141,15 +146,17 @@ int mlx5e_refresh_tirs(struct mlx5e_priv *priv, bool enable_uc_lb) · 21 unmodified lines | ||
| 141 | 146 | { |
| 142 | 147 | struct mlx5_core_dev *mdev = priv->mdev; |
| 143 | 148 | struct mlx5e_tir *tir; |
| 144 | − int err = -ENOMEM; | |
| 149 | + int err = 0; | |
| 145 | 150 | u32 tirn = 0; |
| 146 | 151 | int inlen; |
| 147 | 152 | void *in; |
| 148 | 153 | |
| 149 | 154 | inlen = MLX5_ST_SZ_BYTES(modify_tir_in); |
| 150 | 155 | in = kvzalloc(inlen, GFP_KERNEL); |
| 151 | − if (!in) | |
| 156 | + if (!in) { | |
| 157 | + err = -ENOMEM; | |
| 152 | 158 | goto out; |
| 159 | + } | |
| 153 | 160 | |
| 154 | 161 | if (enable_uc_lb) |
| 155 | 162 | MLX5_SET(modify_tir_in, in, ctx.self_lb_block, |
| @@ -157,6 +164,7 @@ int mlx5e_refresh_tirs(struct mlx5e_priv *priv, bool enable_uc_lb) · 1 unmodified line | ||
| 157 | 164 | |
| 158 | 165 | MLX5_SET(modify_tir_in, in, bitmask.self_lb_en, 1); |
| 159 | 166 | |
| 167 | + mutex_lock(&mdev->mlx5e_res.td.list_lock); | |
| 160 | 168 | list_for_each_entry(tir, &mdev->mlx5e_res.td.tirs_list, list) { |
| 161 | 169 | tirn = tir->tirn; |
| 162 | 170 | err = mlx5_core_modify_tir(mdev, tirn, in, inlen); |
| @@ -168,6 +176,7 @@ out: · 5 unmodified lines | ||
| 168 | 176 | kvfree(in); |
| 169 | 177 | if (err) |
| 170 | 178 | netdev_err(priv->netdev, "refresh tir(0x%x) failed, %d\n", tirn, err); |
| 179 | + mutex_unlock(&mdev->mlx5e_res.td.list_lock); | |
| 171 | 180 | |
| 172 | 181 | return err; |
| 173 | 182 | } |
| @@ -603,16 +603,18 @@ static void ptys2ethtool_supported_link(struct mlx5_core_dev *mdev, · 602 unmodified lines | ||
| 603 | 603 | __ETHTOOL_LINK_MODE_MASK_NBITS); |
| 604 | 604 | } |
| 605 | 605 | |
| 606 | −static void ptys2ethtool_adver_link(struct mlx5_core_dev *mdev, | |
| 607 | − unsigned long *advertising_modes, | |
| 608 | − u32 eth_proto_cap) | |
| 606 | +static void ptys2ethtool_adver_link(unsigned long *advertising_modes, | |
| 607 | + u32 eth_proto_cap, bool ext) | |
| 609 | 608 | { |
| 610 | 609 | unsigned long proto_cap = eth_proto_cap; |
| 611 | 610 | struct ptys2ethtool_config *table; |
| 612 | 611 | u32 max_size; |
| 613 | 612 | int proto; |
| 614 | 613 | |
| 615 | − mlx5e_ethtool_get_speed_arr(mdev, &table, &max_size); | |
| 614 | + table = ext ? ptys2ext_ethtool_table : ptys2legacy_ethtool_table; | |
| 615 | + max_size = ext ? ARRAY_SIZE(ptys2ext_ethtool_table) : | |
| 616 | + ARRAY_SIZE(ptys2legacy_ethtool_table); | |
| 617 | + | |
| 616 | 618 | for_each_set_bit(proto, &proto_cap, max_size) |
| 617 | 619 | bitmap_or(advertising_modes, advertising_modes, |
| 618 | 620 | table[proto].advertised, |
| @@ -794,12 +796,12 @@ static void get_supported(struct mlx5_core_dev *mdev, u32 eth_proto_cap, · 175 unmodified lines | ||
| 794 | 796 | ethtool_link_ksettings_add_link_mode(link_ksettings, supported, Pause); |
| 795 | 797 | } |
| 796 | 798 | |
| 797 | −static void get_advertising(struct mlx5_core_dev *mdev, u32 eth_proto_cap, | |
| 798 | − u8 tx_pause, u8 rx_pause, | |
| 799 | − struct ethtool_link_ksettings *link_ksettings) | |
| 799 | +static void get_advertising(u32 eth_proto_cap, u8 tx_pause, u8 rx_pause, | |
| 800 | + struct ethtool_link_ksettings *link_ksettings, | |
| 801 | + bool ext) | |
| 800 | 802 | { |
| 801 | 803 | unsigned long *advertising = link_ksettings->link_modes.advertising; |
| 802 | − ptys2ethtool_adver_link(mdev, advertising, eth_proto_cap); | |
| 804 | + ptys2ethtool_adver_link(advertising, eth_proto_cap, ext); | |
| 803 | 805 | |
| 804 | 806 | if (rx_pause) |
| 805 | 807 | ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Pause); |
| @@ -854,8 +856,9 @@ static void get_lp_advertising(struct mlx5_core_dev *mdev, u32 eth_proto_lp, · 48 unmodified lines | ||
| 854 | 856 | struct ethtool_link_ksettings *link_ksettings) |
| 855 | 857 | { |
| 856 | 858 | unsigned long *lp_advertising = link_ksettings->link_modes.lp_advertising; |
| 859 | + bool ext = MLX5_CAP_PCAM_FEATURE(mdev, ptys_extended_ethernet); | |
| 857 | 860 | |
| 858 | − ptys2ethtool_adver_link(mdev, lp_advertising, eth_proto_lp); | |
| 861 | + ptys2ethtool_adver_link(lp_advertising, eth_proto_lp, ext); | |
| 859 | 862 | } |
| 860 | 863 | |
| 861 | 864 | int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, |
| @@ -872,6 +875,7 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 10 unmodified lines | ||
| 872 | 875 | u8 an_disable_admin; |
| 873 | 876 | u8 an_status; |
| 874 | 877 | u8 connector_type; |
| 878 | + bool admin_ext; | |
| 875 | 879 | bool ext; |
| 876 | 880 | int err; |
| 877 | 881 | |
| @@ -886,6 +890,19 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 8 unmodified lines | ||
| 886 | 890 | eth_proto_capability); |
| 887 | 891 | eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, ext, |
| 888 | 892 | eth_proto_admin); |
| 893 | + /* Fields: eth_proto_admin and ext_eth_proto_admin are | |
| 894 | + * mutually exclusive. Hence try reading legacy advertising | |
| 895 | + * when extended advertising is zero. | |
| 896 | + * admin_ext indicates how eth_proto_admin should be | |
| 897 | + * interpreted | |
| 898 | + */ | |
| 899 | + admin_ext = ext; | |
| 900 | + if (ext && !eth_proto_admin) { | |
| 901 | + eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, false, | |
| 902 | + eth_proto_admin); | |
| 903 | + admin_ext = false; | |
| 904 | + } | |
| 905 | + | |
| 889 | 906 | eth_proto_oper = MLX5_GET_ETH_PROTO(ptys_reg, out, ext, |
| 890 | 907 | eth_proto_oper); |
| 891 | 908 | eth_proto_lp = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise); |
| @@ -899,7 +916,8 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv, · 7 unmodified lines | ||
| 899 | 916 | ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising); |
| 900 | 917 | |
| 901 | 918 | get_supported(mdev, eth_proto_cap, link_ksettings); |
| 902 | − get_advertising(mdev, eth_proto_admin, tx_pause, rx_pause, link_ksettings); | |
| 919 | + get_advertising(eth_proto_admin, tx_pause, rx_pause, link_ksettings, | |
| 920 | + admin_ext); | |
| 903 | 921 | get_speed_duplex(priv->netdev, eth_proto_oper, link_ksettings); |
| 904 | 922 | |
| 905 | 923 | eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap; |
| @@ -997,19 +1015,17 @@ int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv, · 91 unmodified lines | ||
| 997 | 1015 | |
| 998 | 1016 | #define MLX5E_PTYS_EXT ((1ULL << ETHTOOL_LINK_MODE_50000baseKR_Full_BIT) - 1) |
| 999 | 1017 | |
| 1000 | − ext_requested = (link_ksettings->link_modes.advertising[0] > | |
| 1001 | − MLX5E_PTYS_EXT); | |
| 1018 | + ext_requested = !!(link_ksettings->link_modes.advertising[0] > | |
| 1019 | + MLX5E_PTYS_EXT || | |
| 1020 | + link_ksettings->link_modes.advertising[1]); | |
| 1002 | 1021 | ext_supported = MLX5_CAP_PCAM_FEATURE(mdev, ptys_extended_ethernet); |
| 1003 | − | |
| 1004 | − /*when ptys_extended_ethernet is set legacy link modes are deprecated */ | |
| 1005 | − if (ext_requested != ext_supported) | |
| 1006 | − return -EPROTONOSUPPORT; | |
| 1022 | + ext_requested &= ext_supported; | |
| 1007 | 1023 | |
| 1008 | 1024 | speed = link_ksettings->base.speed; |
| 1009 | 1025 | ethtool2ptys_adver_func = ext_requested ? |
| 1010 | 1026 | mlx5e_ethtool2ptys_ext_adver_link : |
| 1011 | 1027 | mlx5e_ethtool2ptys_adver_link; |
| 1012 | − err = mlx5_port_query_eth_proto(mdev, 1, ext_supported, &eproto); | |
| 1028 | + err = mlx5_port_query_eth_proto(mdev, 1, ext_requested, &eproto); | |
| 1013 | 1029 | if (err) { |
| 1014 | 1030 | netdev_err(priv->netdev, "%s: query port eth proto failed: %d\n", |
| 1015 | 1031 | __func__, err); |
| @@ -1037,7 +1053,7 @@ int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv, · 21 unmodified lines | ||
| 1037 | 1053 | if (!an_changes && link_modes == eproto.admin) |
| 1038 | 1054 | goto out; |
| 1039 | 1055 | |
| 1040 | − mlx5_port_set_eth_ptys(mdev, an_disable, link_modes, ext_supported); | |
| 1056 | + mlx5_port_set_eth_ptys(mdev, an_disable, link_modes, ext_requested); | |
| 1041 | 1057 | mlx5_toggle_port_link(mdev); |
| 1042 | 1058 | |
| 1043 | 1059 | out: |
| @@ -2158,6 +2158,52 @@ static bool csum_offload_supported(struct mlx5e_priv *priv, · 2157 unmodified lines | ||
| 2158 | 2158 | return true; |
| 2159 | 2159 | } |
| 2160 | 2160 | |
| 2161 | +struct ip_ttl_word { | |
| 2162 | + __u8 ttl; | |
| 2163 | + __u8 protocol; | |
| 2164 | + __sum16 check; | |
| 2165 | +}; | |
| 2166 | + | |
| 2167 | +struct ipv6_hoplimit_word { | |
| 2168 | + __be16 payload_len; | |
| 2169 | + __u8 nexthdr; | |
| 2170 | + __u8 hop_limit; | |
| 2171 | +}; | |
| 2172 | + | |
| 2173 | +static bool is_action_keys_supported(const struct flow_action_entry *act) | |
| 2174 | +{ | |
| 2175 | + u32 mask, offset; | |
| 2176 | + u8 htype; | |
| 2177 | + | |
| 2178 | + htype = act->mangle.htype; | |
| 2179 | + offset = act->mangle.offset; | |
| 2180 | + mask = ~act->mangle.mask; | |
| 2181 | + /* For IPv4 & IPv6 header check 4 byte word, | |
| 2182 | + * to determine that modified fields | |
| 2183 | + * are NOT ttl & hop_limit only. | |
| 2184 | + */ | |
| 2185 | + if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP4) { | |
| 2186 | + struct ip_ttl_word *ttl_word = | |
| 2187 | + (struct ip_ttl_word *)&mask; | |
| 2188 | + | |
| 2189 | + if (offset != offsetof(struct iphdr, ttl) || | |
| 2190 | + ttl_word->protocol || | |
| 2191 | + ttl_word->check) { | |
| 2192 | + return true; | |
| 2193 | + } | |
| 2194 | + } else if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP6) { | |
| 2195 | + struct ipv6_hoplimit_word *hoplimit_word = | |
| 2196 | + (struct ipv6_hoplimit_word *)&mask; | |
| 2197 | + | |
| 2198 | + if (offset != offsetof(struct ipv6hdr, payload_len) || | |
| 2199 | + hoplimit_word->payload_len || | |
| 2200 | + hoplimit_word->nexthdr) { | |
| 2201 | + return true; | |
| 2202 | + } | |
| 2203 | + } | |
| 2204 | + return false; | |
| 2205 | +} | |
| 2206 | + | |
| 2161 | 2207 | static bool modify_header_match_supported(struct mlx5_flow_spec *spec, |
| 2162 | 2208 | struct flow_action *flow_action, |
| 2163 | 2209 | u32 actions, |
| @@ -2165,9 +2211,9 @@ static bool modify_header_match_supported(struct mlx5_flow_spec *spec, · 1 unmodified line | ||
| 2165 | 2211 | { |
| 2166 | 2212 | const struct flow_action_entry *act; |
| 2167 | 2213 | bool modify_ip_header; |
| 2168 | − u8 htype, ip_proto; | |
| 2169 | 2214 | void *headers_v; |
| 2170 | 2215 | u16 ethertype; |
| 2216 | + u8 ip_proto; | |
| 2171 | 2217 | int i; |
| 2172 | 2218 | |
| 2173 | 2219 | if (actions & MLX5_FLOW_CONTEXT_ACTION_DECAP) |
| @@ -2187,9 +2233,7 @@ static bool modify_header_match_supported(struct mlx5_flow_spec *spec, · 13 unmodified lines | ||
| 2187 | 2233 | act->id != FLOW_ACTION_ADD) |
| 2188 | 2234 | continue; |
| 2189 | 2235 | |
| 2190 | − htype = act->mangle.htype; | |
| 2191 | − if (htype == FLOW_ACT_MANGLE_HDR_TYPE_IP4 || | |
| 2192 | − htype == FLOW_ACT_MANGLE_HDR_TYPE_IP6) { | |
| 2236 | + if (is_action_keys_supported(act)) { | |
| 2193 | 2237 | modify_ip_header = true; |
| 2194 | 2238 | break; |
| 2195 | 2239 | } |
| @@ -2340,15 +2384,22 @@ static int parse_tc_nic_actions(struct mlx5e_priv *priv, · 144 unmodified lines | ||
| 2340 | 2384 | return 0; |
| 2341 | 2385 | } |
| 2342 | 2386 | |
| 2343 | −static inline int cmp_encap_info(struct ip_tunnel_key *a, | |
| 2344 | − struct ip_tunnel_key *b) | |
| 2387 | +struct encap_key { | |
| 2388 | + struct ip_tunnel_key *ip_tun_key; | |
| 2389 | + int tunnel_type; | |
| 2390 | +}; | |
| 2391 | + | |
| 2392 | +static inline int cmp_encap_info(struct encap_key *a, | |
| 2393 | + struct encap_key *b) | |
| 2345 | 2394 | { |
| 2346 | − return memcmp(a, b, sizeof(*a)); | |
| 2395 | + return memcmp(a->ip_tun_key, b->ip_tun_key, sizeof(*a->ip_tun_key)) || | |
| 2396 | + a->tunnel_type != b->tunnel_type; | |
| 2347 | 2397 | } |
| 2348 | 2398 | |
| 2349 | −static inline int hash_encap_info(struct ip_tunnel_key *key) | |
| 2399 | +static inline int hash_encap_info(struct encap_key *key) | |
| 2350 | 2400 | { |
| 2351 | − return jhash(key, sizeof(*key), 0); | |
| 2401 | + return jhash(key->ip_tun_key, sizeof(*key->ip_tun_key), | |
| 2402 | + key->tunnel_type); | |
| 2352 | 2403 | } |
| 2353 | 2404 | |
| 2354 | 2405 | |
| @@ -2379,7 +2430,7 @@ static int mlx5e_attach_encap(struct mlx5e_priv *priv, · 24 unmodified lines | ||
| 2379 | 2430 | struct mlx5_esw_flow_attr *attr = flow->esw_attr; |
| 2380 | 2431 | struct mlx5e_tc_flow_parse_attr *parse_attr; |
| 2381 | 2432 | struct ip_tunnel_info *tun_info; |
| 2382 | − struct ip_tunnel_key *key; | |
| 2433 | + struct encap_key key, e_key; | |
| 2383 | 2434 | struct mlx5e_encap_entry *e; |
| 2384 | 2435 | unsigned short family; |
| 2385 | 2436 | uintptr_t hash_key; |
| @@ -2389,13 +2440,16 @@ static int mlx5e_attach_encap(struct mlx5e_priv *priv, · 3 unmodified lines | ||
| 2389 | 2440 | parse_attr = attr->parse_attr; |
| 2390 | 2441 | tun_info = &parse_attr->tun_info[out_index]; |
| 2391 | 2442 | family = ip_tunnel_info_af(tun_info); |
| 2392 | − key = &tun_info->key; | |
| 2443 | + key.ip_tun_key = &tun_info->key; | |
| 2444 | + key.tunnel_type = mlx5e_tc_tun_get_type(mirred_dev); | |
| 2393 | 2445 | |
| 2394 | − hash_key = hash_encap_info(key); | |
| 2446 | + hash_key = hash_encap_info(&key); | |
| 2395 | 2447 | |
| 2396 | 2448 | hash_for_each_possible_rcu(esw->offloads.encap_tbl, e, |
| 2397 | 2449 | encap_hlist, hash_key) { |
| 2398 | − if (!cmp_encap_info(&e->tun_info.key, key)) { | |
| 2450 | + e_key.ip_tun_key = &e->tun_info.key; | |
| 2451 | + e_key.tunnel_type = e->tunnel_type; | |
| 2452 | + if (!cmp_encap_info(&e_key, &key)) { | |
| 2399 | 2453 | found = true; |
| 2400 | 2454 | break; |
| 2401 | 2455 | } |
| @@ -2657,7 +2711,7 @@ static int parse_tc_fdb_actions(struct mlx5e_priv *priv, · 255 unmodified lines | ||
| 2657 | 2711 | |
| 2658 | 2712 | if (hdrs[TCA_PEDIT_KEY_EX_CMD_SET].pedits || |
| 2659 | 2713 | hdrs[TCA_PEDIT_KEY_EX_CMD_ADD].pedits) { |
| 2660 | − err = alloc_tc_pedit_action(priv, MLX5_FLOW_NAMESPACE_KERNEL, | |
| 2714 | + err = alloc_tc_pedit_action(priv, MLX5_FLOW_NAMESPACE_FDB, | |
| 2661 | 2715 | parse_attr, hdrs, extack); |
| 2662 | 2716 | if (err) |
| 2663 | 2717 | return err; |
| @@ -105,8 +105,7 @@ static int arm_vport_context_events_cmd(struct mlx5_core_dev *dev, u16 vport, · 104 unmodified lines | ||
| 105 | 105 | opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT); |
| 106 | 106 | MLX5_SET(modify_nic_vport_context_in, in, field_select.change_event, 1); |
| 107 | 107 | MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport); |
| 108 | − if (vport) | |
| 109 | − MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1); | |
| 108 | + MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1); | |
| 110 | 109 | nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, |
| 111 | 110 | in, nic_vport_context); |
| 112 | 111 | |
| @@ -134,8 +133,7 @@ static int modify_esw_vport_context_cmd(struct mlx5_core_dev *dev, u16 vport, · 21 unmodified lines | ||
| 134 | 133 | MLX5_SET(modify_esw_vport_context_in, in, opcode, |
| 135 | 134 | MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT); |
| 136 | 135 | MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport); |
| 137 | − if (vport) | |
| 138 | − MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1); | |
| 136 | + MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1); | |
| 139 | 137 | return mlx5_cmd_exec(dev, in, inlen, out, sizeof(out)); |
| 140 | 138 | } |
| 141 | 139 | |
| @@ -431,6 +429,8 @@ static int esw_create_legacy_table(struct mlx5_eswitch *esw) · 289 unmodified lines | ||
| 431 | 429 | { |
| 432 | 430 | int err; |
| 433 | 431 | |
| 432 | + memset(&esw->fdb_table.legacy, 0, sizeof(struct legacy_fdb)); | |
| 433 | + | |
| 434 | 434 | err = esw_create_legacy_vepa_table(esw); |
| 435 | 435 | if (err) |
| 436 | 436 | return err; |
| @@ -2157,6 +2157,7 @@ static int _mlx5_eswitch_set_vepa_locked(struct mlx5_eswitch *esw, · 1720 unmodified lines | ||
| 2157 | 2157 | |
| 2158 | 2158 | /* Star rule to forward all traffic to uplink vport */ |
| 2159 | 2159 | memset(spec, 0, sizeof(*spec)); |
| 2160 | + memset(&dest, 0, sizeof(dest)); | |
| 2160 | 2161 | dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT; |
| 2161 | 2162 | dest.vport.num = MLX5_VPORT_UPLINK; |
| 2162 | 2163 | flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST; |
| @@ -1611,6 +1611,7 @@ static int esw_offloads_steering_init(struct mlx5_eswitch *esw, int nvports) · 1610 unmodified lines | ||
| 1611 | 1611 | { |
| 1612 | 1612 | int err; |
| 1613 | 1613 | |
| 1614 | + memset(&esw->fdb_table.offloads, 0, sizeof(struct offloads_fdb)); | |
| 1614 | 1615 | mutex_init(&esw->fdb_table.offloads.fdb_prio_lock); |
| 1615 | 1616 | |
| 1616 | 1617 | err = esw_create_offloads_fdb_tables(esw, nvports); |
| @@ -217,15 +217,21 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 216 unmodified lines | ||
| 217 | 217 | void *cmd; |
| 218 | 218 | int ret; |
| 219 | 219 | |
| 220 | + rcu_read_lock(); | |
| 221 | + flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle)); | |
| 222 | + rcu_read_unlock(); | |
| 223 | + | |
| 224 | + if (!flow) { | |
| 225 | + WARN_ONCE(1, "Received NULL pointer for handle\n"); | |
| 226 | + return -EINVAL; | |
| 227 | + } | |
| 228 | + | |
| 220 | 229 | buf = kzalloc(size, GFP_ATOMIC); |
| 221 | 230 | if (!buf) |
| 222 | 231 | return -ENOMEM; |
| 223 | 232 | |
| 224 | 233 | cmd = (buf + 1); |
| 225 | 234 | |
| 226 | − rcu_read_lock(); | |
| 227 | − flow = idr_find(&mdev->fpga->tls->rx_idr, ntohl(handle)); | |
| 228 | − rcu_read_unlock(); | |
| 229 | 235 | mlx5_fpga_tls_flow_to_cmd(flow, cmd); |
| 230 | 236 | |
| 231 | 237 | MLX5_SET(tls_cmd, cmd, swid, ntohl(handle)); |
| @@ -238,6 +244,8 @@ int mlx5_fpga_tls_resync_rx(struct mlx5_core_dev *mdev, u32 handle, u32 seq, · 6 unmodified lines | ||
| 238 | 244 | buf->complete = mlx_tls_kfree_complete; |
| 239 | 245 | |
| 240 | 246 | ret = mlx5_fpga_sbu_conn_sendmsg(mdev->fpga->tls->conn, buf); |
| 247 | + if (ret < 0) | |
| 248 | + kfree(buf); | |
| 241 | 249 | |
| 242 | 250 | return ret; |
| 243 | 251 | } |
| @@ -164,26 +164,6 @@ static struct mlx5_profile profile[] = { · 163 unmodified lines | ||
| 164 | 164 | .size = 8, |
| 165 | 165 | .limit = 4 |
| 166 | 166 | }, |
| 167 | − .mr_cache[16] = { | |
| 168 | − .size = 8, | |
| 169 | − .limit = 4 | |
| 170 | − }, | |
| 171 | − .mr_cache[17] = { | |
| 172 | − .size = 8, | |
| 173 | − .limit = 4 | |
| 174 | − }, | |
| 175 | − .mr_cache[18] = { | |
| 176 | − .size = 8, | |
| 177 | − .limit = 4 | |
| 178 | − }, | |
| 179 | − .mr_cache[19] = { | |
| 180 | − .size = 4, | |
| 181 | − .limit = 2 | |
| 182 | − }, | |
| 183 | − .mr_cache[20] = { | |
| 184 | − .size = 4, | |
| 185 | − .limit = 2 | |
| 186 | − }, | |
| 187 | 167 | }, |
| 188 | 168 | }; |
| 189 | 169 | |
| @@ -48,8 +48,7 @@ nfp_fl_push_vlan(struct nfp_fl_push_vlan *push_vlan, · 47 unmodified lines | ||
| 48 | 48 | |
| 49 | 49 | tmp_push_vlan_tci = |
| 50 | 50 | FIELD_PREP(NFP_FL_PUSH_VLAN_PRIO, act->vlan.prio) | |
| 51 | − FIELD_PREP(NFP_FL_PUSH_VLAN_VID, act->vlan.vid) | | |
| 52 | − NFP_FL_PUSH_VLAN_CFI; | |
| 51 | + FIELD_PREP(NFP_FL_PUSH_VLAN_VID, act->vlan.vid); | |
| 53 | 52 | push_vlan->vlan_tci = cpu_to_be16(tmp_push_vlan_tci); |
| 54 | 53 | } |
| 55 | 54 | |
| @@ -26,7 +26,7 @@ · 25 unmodified lines | ||
| 26 | 26 | #define NFP_FLOWER_LAYER2_GENEVE_OP BIT(6) |
| 27 | 27 | |
| 28 | 28 | #define NFP_FLOWER_MASK_VLAN_PRIO GENMASK(15, 13) |
| 29 | −#define NFP_FLOWER_MASK_VLAN_CFI BIT(12) | |
| 29 | +#define NFP_FLOWER_MASK_VLAN_PRESENT BIT(12) | |
| 30 | 30 | #define NFP_FLOWER_MASK_VLAN_VID GENMASK(11, 0) |
| 31 | 31 | |
| 32 | 32 | #define NFP_FLOWER_MASK_MPLS_LB GENMASK(31, 12) |
| @@ -82,7 +82,6 @@ · 49 unmodified lines | ||
| 82 | 82 | #define NFP_FL_OUT_FLAGS_TYPE_IDX GENMASK(2, 0) |
| 83 | 83 | |
| 84 | 84 | #define NFP_FL_PUSH_VLAN_PRIO GENMASK(15, 13) |
| 85 | −#define NFP_FL_PUSH_VLAN_CFI BIT(12) | |
| 86 | 85 | #define NFP_FL_PUSH_VLAN_VID GENMASK(11, 0) |
| 87 | 86 | |
| 88 | 87 | #define IPV6_FLOW_LABEL_MASK cpu_to_be32(0x000fffff) |
| @@ -30,20 +30,19 @@ nfp_flower_compile_meta_tci(struct nfp_flower_meta_tci *ext, · 29 unmodified lines | ||
| 30 | 30 | |
| 31 | 31 | flow_rule_match_vlan(rule, &match); |
| 32 | 32 | /* Populate the tci field. */ |
| 33 | − if (match.key->vlan_id || match.key->vlan_priority) { | |
| 34 | − tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO, | |
| 35 | − match.key->vlan_priority) | | |
| 36 | − FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID, | |
| 37 | − match.key->vlan_id) | | |
| 38 | − NFP_FLOWER_MASK_VLAN_CFI; | |
| 39 | − ext->tci = cpu_to_be16(tmp_tci); | |
| 40 | − tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO, | |
| 41 | − match.mask->vlan_priority) | | |
| 42 | − FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID, | |
| 43 | − match.mask->vlan_id) | | |
| 44 | − NFP_FLOWER_MASK_VLAN_CFI; | |
| 45 | − msk->tci = cpu_to_be16(tmp_tci); | |
| 46 | − } | |
| 33 | + tmp_tci = NFP_FLOWER_MASK_VLAN_PRESENT; | |
| 34 | + tmp_tci |= FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO, | |
| 35 | + match.key->vlan_priority) | | |
| 36 | + FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID, | |
| 37 | + match.key->vlan_id); | |
| 38 | + ext->tci = cpu_to_be16(tmp_tci); | |
| 39 | + | |
| 40 | + tmp_tci = NFP_FLOWER_MASK_VLAN_PRESENT; | |
| 41 | + tmp_tci |= FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO, | |
| 42 | + match.mask->vlan_priority) | | |
| 43 | + FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID, | |
| 44 | + match.mask->vlan_id); | |
| 45 | + msk->tci = cpu_to_be16(tmp_tci); | |
| 47 | 46 | } |
| 48 | 47 | } |
| 49 | 48 | |
| @@ -195,7 +195,7 @@ static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev) · 194 unmodified lines | ||
| 195 | 195 | ret = dev_queue_xmit(skb); |
| 196 | 196 | nfp_repr_inc_tx_stats(netdev, len, ret); |
| 197 | 197 | |
| 198 | − return ret; | |
| 198 | + return NETDEV_TX_OK; | |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | 201 | static int nfp_repr_stop(struct net_device *netdev) |
| @@ -383,7 +383,7 @@ int nfp_repr_init(struct nfp_app *app, struct net_device *netdev, · 181 unmodified lines | ||
| 383 | 383 | netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6); |
| 384 | 384 | netdev->gso_max_segs = NFP_NET_LSO_MAX_SEGS; |
| 385 | 385 | |
| 386 | − netdev->priv_flags |= IFF_NO_QUEUE; | |
| 386 | + netdev->priv_flags |= IFF_NO_QUEUE | IFF_DISABLE_NETPOLL; | |
| 387 | 387 | netdev->features |= NETIF_F_LLTX; |
| 388 | 388 | |
| 389 | 389 | if (nfp_app_has_tc(app)) { |
| @@ -497,7 +497,7 @@ struct qlcnic_hardware_context { · 496 unmodified lines | ||
| 497 | 497 | u16 board_type; |
| 498 | 498 | u16 supported_type; |
| 499 | 499 | |
| 500 | − u16 link_speed; | |
| 500 | + u32 link_speed; | |
| 501 | 501 | u16 link_duplex; |
| 502 | 502 | u16 link_autoneg; |
| 503 | 503 | u16 module_type; |
| @@ -28,6 +28,7 @@ · 27 unmodified lines | ||
| 28 | 28 | #include <linux/pm_runtime.h> |
| 29 | 29 | #include <linux/firmware.h> |
| 30 | 30 | #include <linux/prefetch.h> |
| 31 | +#include <linux/pci-aspm.h> | |
| 31 | 32 | #include <linux/ipv6.h> |
| 32 | 33 | #include <net/ip6_checksum.h> |
| 33 | 34 | |
| @@ -5460,7 +5461,7 @@ static void rtl_hw_start_8168(struct rtl8169_private *tp) · 5426 unmodified lines | ||
| 5460 | 5461 | tp->cp_cmd |= PktCntrDisable | INTT_1; |
| 5461 | 5462 | RTL_W16(tp, CPlusCmd, tp->cp_cmd); |
| 5462 | 5463 | |
| 5463 | − RTL_W16(tp, IntrMitigate, 0x5151); | |
| 5464 | + RTL_W16(tp, IntrMitigate, 0x5100); | |
| 5464 | 5465 | |
| 5465 | 5466 | /* Work around for RxFIFO overflow. */ |
| 5466 | 5467 | if (tp->mac_version == RTL_GIGA_MAC_VER_11) { |
| @@ -7352,6 +7353,11 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) · 1885 unmodified lines | ||
| 7352 | 7353 | if (rc) |
| 7353 | 7354 | return rc; |
| 7354 | 7355 | |
| 7356 | + /* Disable ASPM completely as that cause random device stop working | |
| 7357 | + * problems as well as full system hangs for some PCIe devices users. | |
| 7358 | + */ | |
| 7359 | + pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1); | |
| 7360 | + | |
| 7355 | 7361 | /* enable device (incl. PCI PM wakeup and hotplug setup) */ |
| 7356 | 7362 | rc = pcim_enable_device(pdev); |
| 7357 | 7363 | if (rc < 0) { |
| @@ -29,11 +29,13 @@ · 28 unmodified lines | ||
| 29 | 29 | /* Specific functions used for Ring mode */ |
| 30 | 30 | |
| 31 | 31 | /* Enhanced descriptors */ |
| 32 | −static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end) | |
| 32 | +static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end, | |
| 33 | + int bfsize) | |
| 33 | 34 | { |
| 34 | − p->des1 |= cpu_to_le32((BUF_SIZE_8KiB | |
| 35 | − << ERDES1_BUFFER2_SIZE_SHIFT) | |
| 36 | − & ERDES1_BUFFER2_SIZE_MASK); | |
| 35 | + if (bfsize == BUF_SIZE_16KiB) | |
| 36 | + p->des1 |= cpu_to_le32((BUF_SIZE_8KiB | |
| 37 | + << ERDES1_BUFFER2_SIZE_SHIFT) | |
| 38 | + & ERDES1_BUFFER2_SIZE_MASK); | |
| 37 | 39 | |
| 38 | 40 | if (end) |
| 39 | 41 | p->des1 |= cpu_to_le32(ERDES1_END_RING); |
| @@ -59,11 +61,15 @@ static inline void enh_set_tx_desc_len_on_ring(struct dma_desc *p, int len) · 19 unmodified lines | ||
| 59 | 61 | } |
| 60 | 62 | |
| 61 | 63 | /* Normal descriptors */ |
| 62 | −static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end) | |
| 64 | +static inline void ndesc_rx_set_on_ring(struct dma_desc *p, int end, int bfsize) | |
| 63 | 65 | { |
| 64 | − p->des1 |= cpu_to_le32(((BUF_SIZE_2KiB - 1) | |
| 65 | − << RDES1_BUFFER2_SIZE_SHIFT) | |
| 66 | − & RDES1_BUFFER2_SIZE_MASK); | |
| 66 | + if (bfsize >= BUF_SIZE_2KiB) { | |
| 67 | + int bfsize2; | |
| 68 | + | |
| 69 | + bfsize2 = min(bfsize - BUF_SIZE_2KiB + 1, BUF_SIZE_2KiB - 1); | |
| 70 | + p->des1 |= cpu_to_le32((bfsize2 << RDES1_BUFFER2_SIZE_SHIFT) | |
| 71 | + & RDES1_BUFFER2_SIZE_MASK); | |
| 72 | + } | |
| 67 | 73 | |
| 68 | 74 | if (end) |
| 69 | 75 | p->des1 |= cpu_to_le32(RDES1_END_RING); |
| @@ -296,7 +296,7 @@ exit: · 295 unmodified lines | ||
| 296 | 296 | } |
| 297 | 297 | |
| 298 | 298 | static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic, |
| 299 | − int mode, int end) | |
| 299 | + int mode, int end, int bfsize) | |
| 300 | 300 | { |
| 301 | 301 | dwmac4_set_rx_owner(p, disable_rx_ic); |
| 302 | 302 | } |
| @@ -123,7 +123,7 @@ static int dwxgmac2_get_rx_timestamp_status(void *desc, void *next_desc, · 122 unmodified lines | ||
| 123 | 123 | } |
| 124 | 124 | |
| 125 | 125 | static void dwxgmac2_init_rx_desc(struct dma_desc *p, int disable_rx_ic, |
| 126 | − int mode, int end) | |
| 126 | + int mode, int end, int bfsize) | |
| 127 | 127 | { |
| 128 | 128 | dwxgmac2_set_rx_owner(p, disable_rx_ic); |
| 129 | 129 | } |
| @@ -201,6 +201,11 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, · 200 unmodified lines | ||
| 201 | 201 | if (unlikely(rdes0 & RDES0_OWN)) |
| 202 | 202 | return dma_own; |
| 203 | 203 | |
| 204 | + if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) { | |
| 205 | + stats->rx_length_errors++; | |
| 206 | + return discard_frame; | |
| 207 | + } | |
| 208 | + | |
| 204 | 209 | if (unlikely(rdes0 & RDES0_ERROR_SUMMARY)) { |
| 205 | 210 | if (unlikely(rdes0 & RDES0_DESCRIPTOR_ERROR)) { |
| 206 | 211 | x->rx_desc++; |
| @@ -231,9 +236,10 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, · 24 unmodified lines | ||
| 231 | 236 | * It doesn't match with the information reported into the databook. |
| 232 | 237 | * At any rate, we need to understand if the CSUM hw computation is ok |
| 233 | 238 | * and report this info to the upper layers. */ |
| 234 | − ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR), | |
| 235 | − !!(rdes0 & RDES0_FRAME_TYPE), | |
| 236 | − !!(rdes0 & ERDES0_RX_MAC_ADDR)); | |
| 239 | + if (likely(ret == good_frame)) | |
| 240 | + ret = enh_desc_coe_rdes0(!!(rdes0 & RDES0_IPC_CSUM_ERROR), | |
| 241 | + !!(rdes0 & RDES0_FRAME_TYPE), | |
| 242 | + !!(rdes0 & ERDES0_RX_MAC_ADDR)); | |
| 237 | 243 | |
| 238 | 244 | if (unlikely(rdes0 & RDES0_DRIBBLING)) |
| 239 | 245 | x->dribbling_bit++; |
| @@ -259,15 +265,19 @@ static int enh_desc_get_rx_status(void *data, struct stmmac_extra_stats *x, · 19 unmodified lines | ||
| 259 | 265 | } |
| 260 | 266 | |
| 261 | 267 | static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, |
| 262 | − int mode, int end) | |
| 268 | + int mode, int end, int bfsize) | |
| 263 | 269 | { |
| 270 | + int bfsize1; | |
| 271 | + | |
| 264 | 272 | p->des0 |= cpu_to_le32(RDES0_OWN); |
| 265 | − p->des1 |= cpu_to_le32(BUF_SIZE_8KiB & ERDES1_BUFFER1_SIZE_MASK); | |
| 273 | + | |
| 274 | + bfsize1 = min(bfsize, BUF_SIZE_8KiB); | |
| 275 | + p->des1 |= cpu_to_le32(bfsize1 & ERDES1_BUFFER1_SIZE_MASK); | |
| 266 | 276 | |
| 267 | 277 | if (mode == STMMAC_CHAIN_MODE) |
| 268 | 278 | ehn_desc_rx_set_on_chain(p); |
| 269 | 279 | else |
| 270 | − ehn_desc_rx_set_on_ring(p, end); | |
| 280 | + ehn_desc_rx_set_on_ring(p, end, bfsize); | |
| 271 | 281 | |
| 272 | 282 | if (disable_rx_ic) |
| 273 | 283 | p->des1 |= cpu_to_le32(ERDES1_DISABLE_IC); |
| @@ -33,7 +33,7 @@ struct dma_extended_desc; · 32 unmodified lines | ||
| 33 | 33 | struct stmmac_desc_ops { |
| 34 | 34 | /* DMA RX descriptor ring initialization */ |
| 35 | 35 | void (*init_rx_desc)(struct dma_desc *p, int disable_rx_ic, int mode, |
| 36 | − int end); | |
| 36 | + int end, int bfsize); | |
| 37 | 37 | /* DMA TX descriptor ring initialization */ |
| 38 | 38 | void (*init_tx_desc)(struct dma_desc *p, int mode, int end); |
| 39 | 39 | /* Invoked by the xmit function to prepare the tx descriptor */ |
| @@ -91,8 +91,6 @@ static int ndesc_get_rx_status(void *data, struct stmmac_extra_stats *x, · 90 unmodified lines | ||
| 91 | 91 | return dma_own; |
| 92 | 92 | |
| 93 | 93 | if (unlikely(!(rdes0 & RDES0_LAST_DESCRIPTOR))) { |
| 94 | − pr_warn("%s: Oversized frame spanned multiple buffers\n", | |
| 95 | − __func__); | |
| 96 | 94 | stats->rx_length_errors++; |
| 97 | 95 | return discard_frame; |
| 98 | 96 | } |
| @@ -135,15 +133,19 @@ static int ndesc_get_rx_status(void *data, struct stmmac_extra_stats *x, · 36 unmodified lines | ||
| 135 | 133 | } |
| 136 | 134 | |
| 137 | 135 | static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode, |
| 138 | − int end) | |
| 136 | + int end, int bfsize) | |
| 139 | 137 | { |
| 138 | + int bfsize1; | |
| 139 | + | |
| 140 | 140 | p->des0 |= cpu_to_le32(RDES0_OWN); |
| 141 | − p->des1 |= cpu_to_le32((BUF_SIZE_2KiB - 1) & RDES1_BUFFER1_SIZE_MASK); | |
| 141 | + | |
| 142 | + bfsize1 = min(bfsize, BUF_SIZE_2KiB - 1); | |
| 143 | + p->des1 |= cpu_to_le32(bfsize & RDES1_BUFFER1_SIZE_MASK); | |
| 142 | 144 | |
| 143 | 145 | if (mode == STMMAC_CHAIN_MODE) |
| 144 | 146 | ndesc_rx_set_on_chain(p, end); |
| 145 | 147 | else |
| 146 | − ndesc_rx_set_on_ring(p, end); | |
| 148 | + ndesc_rx_set_on_ring(p, end, bfsize); | |
| 147 | 149 | |
| 148 | 150 | if (disable_rx_ic) |
| 149 | 151 | p->des1 |= cpu_to_le32(RDES1_DISABLE_IC); |
| @@ -1136,11 +1136,13 @@ static void stmmac_clear_rx_descriptors(struct stmmac_priv *priv, u32 queue) · 1135 unmodified lines | ||
| 1136 | 1136 | if (priv->extend_desc) |
| 1137 | 1137 | stmmac_init_rx_desc(priv, &rx_q->dma_erx[i].basic, |
| 1138 | 1138 | priv->use_riwt, priv->mode, |
| 1139 | − (i == DMA_RX_SIZE - 1)); | |
| 1139 | + (i == DMA_RX_SIZE - 1), | |
| 1140 | + priv->dma_buf_sz); | |
| 1140 | 1141 | else |
| 1141 | 1142 | stmmac_init_rx_desc(priv, &rx_q->dma_rx[i], |
| 1142 | 1143 | priv->use_riwt, priv->mode, |
| 1143 | − (i == DMA_RX_SIZE - 1)); | |
| 1144 | + (i == DMA_RX_SIZE - 1), | |
| 1145 | + priv->dma_buf_sz); | |
| 1144 | 1146 | } |
| 1145 | 1147 | |
| 1146 | 1148 | /** |
| @@ -3352,9 +3354,8 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 2205 unmodified lines | ||
| 3352 | 3354 | { |
| 3353 | 3355 | struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue]; |
| 3354 | 3356 | struct stmmac_channel *ch = &priv->channel[queue]; |
| 3355 | − unsigned int entry = rx_q->cur_rx; | |
| 3357 | + unsigned int next_entry = rx_q->cur_rx; | |
| 3356 | 3358 | int coe = priv->hw->rx_csum; |
| 3357 | − unsigned int next_entry; | |
| 3358 | 3359 | unsigned int count = 0; |
| 3359 | 3360 | bool xmac; |
| 3360 | 3361 | |
| @@ -3372,10 +3373,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 11 unmodified lines | ||
| 3372 | 3373 | stmmac_display_ring(priv, rx_head, DMA_RX_SIZE, true); |
| 3373 | 3374 | } |
| 3374 | 3375 | while (count < limit) { |
| 3375 | − int status; | |
| 3376 | + int entry, status; | |
| 3376 | 3377 | struct dma_desc *p; |
| 3377 | 3378 | struct dma_desc *np; |
| 3378 | 3379 | |
| 3380 | + entry = next_entry; | |
| 3381 | + | |
| 3379 | 3382 | if (priv->extend_desc) |
| 3380 | 3383 | p = (struct dma_desc *)(rx_q->dma_erx + entry); |
| 3381 | 3384 | else |
| @@ -3431,11 +3434,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 49 unmodified lines | ||
| 3431 | 3434 | * ignored |
| 3432 | 3435 | */ |
| 3433 | 3436 | if (frame_len > priv->dma_buf_sz) { |
| 3434 | − netdev_err(priv->dev, | |
| 3435 | − "len %d larger than size (%d)\n", | |
| 3436 | − frame_len, priv->dma_buf_sz); | |
| 3437 | + if (net_ratelimit()) | |
| 3438 | + netdev_err(priv->dev, | |
| 3439 | + "len %d larger than size (%d)\n", | |
| 3440 | + frame_len, priv->dma_buf_sz); | |
| 3437 | 3441 | priv->dev->stats.rx_length_errors++; |
| 3438 | − break; | |
| 3442 | + continue; | |
| 3439 | 3443 | } |
| 3440 | 3444 | |
| 3441 | 3445 | /* ACS is set; GMAC core strips PAD/FCS for IEEE 802.3 |
| @@ -3470,7 +3474,7 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 28 unmodified lines | ||
| 3470 | 3474 | dev_warn(priv->device, |
| 3471 | 3475 | "packet dropped\n"); |
| 3472 | 3476 | priv->dev->stats.rx_dropped++; |
| 3473 | − break; | |
| 3477 | + continue; | |
| 3474 | 3478 | } |
| 3475 | 3479 | |
| 3476 | 3480 | dma_sync_single_for_cpu(priv->device, |
| @@ -3490,11 +3494,12 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 13 unmodified lines | ||
| 3490 | 3494 | } else { |
| 3491 | 3495 | skb = rx_q->rx_skbuff[entry]; |
| 3492 | 3496 | if (unlikely(!skb)) { |
| 3493 | − netdev_err(priv->dev, | |
| 3494 | − "%s: Inconsistent Rx chain\n", | |
| 3495 | − priv->dev->name); | |
| 3497 | + if (net_ratelimit()) | |
| 3498 | + netdev_err(priv->dev, | |
| 3499 | + "%s: Inconsistent Rx chain\n", | |
| 3500 | + priv->dev->name); | |
| 3496 | 3501 | priv->dev->stats.rx_dropped++; |
| 3497 | − break; | |
| 3502 | + continue; | |
| 3498 | 3503 | } |
| 3499 | 3504 | prefetch(skb->data - NET_IP_ALIGN); |
| 3500 | 3505 | rx_q->rx_skbuff[entry] = NULL; |
| @@ -3529,7 +3534,6 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) · 28 unmodified lines | ||
| 3529 | 3534 | priv->dev->stats.rx_packets++; |
| 3530 | 3535 | priv->dev->stats.rx_bytes += frame_len; |
| 3531 | 3536 | } |
| 3532 | − entry = next_entry; | |
| 3533 | 3537 | } |
| 3534 | 3538 | |
| 3535 | 3539 | stmmac_rx_refill(priv, queue); |
| @@ -987,6 +987,7 @@ struct netvsc_device { · 986 unmodified lines | ||
| 987 | 987 | |
| 988 | 988 | wait_queue_head_t wait_drain; |
| 989 | 989 | bool destroy; |
| 990 | + bool tx_disable; /* if true, do not wake up queue again */ | |
| 990 | 991 | |
| 991 | 992 | /* Receive buffer allocated by us but manages by NetVSP */ |
| 992 | 993 | void *recv_buf; |
| @@ -110,6 +110,7 @@ static struct netvsc_device *alloc_net_device(void) · 109 unmodified lines | ||
| 110 | 110 | |
| 111 | 111 | init_waitqueue_head(&net_device->wait_drain); |
| 112 | 112 | net_device->destroy = false; |
| 113 | + net_device->tx_disable = false; | |
| 113 | 114 | |
| 114 | 115 | net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT; |
| 115 | 116 | net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT; |
| @@ -719,7 +720,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev, · 603 unmodified lines | ||
| 719 | 720 | } else { |
| 720 | 721 | struct netdev_queue *txq = netdev_get_tx_queue(ndev, q_idx); |
| 721 | 722 | |
| 722 | − if (netif_tx_queue_stopped(txq) && | |
| 723 | + if (netif_tx_queue_stopped(txq) && !net_device->tx_disable && | |
| 723 | 724 | (hv_get_avail_to_write_percent(&channel->outbound) > |
| 724 | 725 | RING_AVAIL_PERCENT_HIWATER || queue_sends < 1)) { |
| 725 | 726 | netif_tx_wake_queue(txq); |
| @@ -874,7 +875,8 @@ static inline int netvsc_send_pkt( · 148 unmodified lines | ||
| 874 | 875 | } else if (ret == -EAGAIN) { |
| 875 | 876 | netif_tx_stop_queue(txq); |
| 876 | 877 | ndev_ctx->eth_stats.stop_queue++; |
| 877 | − if (atomic_read(&nvchan->queue_sends) < 1) { | |
| 878 | + if (atomic_read(&nvchan->queue_sends) < 1 && | |
| 879 | + !net_device->tx_disable) { | |
| 878 | 880 | netif_tx_wake_queue(txq); |
| 879 | 881 | ndev_ctx->eth_stats.wake_queue++; |
| 880 | 882 | ret = -ENOSPC; |
| @@ -109,6 +109,15 @@ static void netvsc_set_rx_mode(struct net_device *net) · 108 unmodified lines | ||
| 109 | 109 | rcu_read_unlock(); |
| 110 | 110 | } |
| 111 | 111 | |
| 112 | +static void netvsc_tx_enable(struct netvsc_device *nvscdev, | |
| 113 | + struct net_device *ndev) | |
| 114 | +{ | |
| 115 | + nvscdev->tx_disable = false; | |
| 116 | + virt_wmb(); /* ensure queue wake up mechanism is on */ | |
| 117 | + | |
| 118 | + netif_tx_wake_all_queues(ndev); | |
| 119 | +} | |
| 120 | + | |
| 112 | 121 | static int netvsc_open(struct net_device *net) |
| 113 | 122 | { |
| 114 | 123 | struct net_device_context *ndev_ctx = netdev_priv(net); |
| @@ -129,7 +138,7 @@ static int netvsc_open(struct net_device *net) · 14 unmodified lines | ||
| 129 | 138 | rdev = nvdev->extension; |
| 130 | 139 | if (!rdev->link_state) { |
| 131 | 140 | netif_carrier_on(net); |
| 132 | − netif_tx_wake_all_queues(net); | |
| 141 | + netvsc_tx_enable(nvdev, net); | |
| 133 | 142 | } |
| 134 | 143 | |
| 135 | 144 | if (vf_netdev) { |
| @@ -184,6 +193,17 @@ static int netvsc_wait_until_empty(struct netvsc_device *nvdev) · 48 unmodified lines | ||
| 184 | 193 | } |
| 185 | 194 | } |
| 186 | 195 | |
| 196 | +static void netvsc_tx_disable(struct netvsc_device *nvscdev, | |
| 197 | + struct net_device *ndev) | |
| 198 | +{ | |
| 199 | + if (nvscdev) { | |
| 200 | + nvscdev->tx_disable = true; | |
| 201 | + virt_wmb(); /* ensure txq will not wake up after stop */ | |
| 202 | + } | |
| 203 | + | |
| 204 | + netif_tx_disable(ndev); | |
| 205 | +} | |
| 206 | + | |
| 187 | 207 | static int netvsc_close(struct net_device *net) |
| 188 | 208 | { |
| 189 | 209 | struct net_device_context *net_device_ctx = netdev_priv(net); |
| @@ -192,7 +212,7 @@ static int netvsc_close(struct net_device *net) · 2 unmodified lines | ||
| 192 | 212 | struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev); |
| 193 | 213 | int ret; |
| 194 | 214 | |
| 195 | − netif_tx_disable(net); | |
| 215 | + netvsc_tx_disable(nvdev, net); | |
| 196 | 216 | |
| 197 | 217 | /* No need to close rndis filter if it is removed already */ |
| 198 | 218 | if (!nvdev) |
| @@ -920,7 +940,7 @@ static int netvsc_detach(struct net_device *ndev, · 721 unmodified lines | ||
| 920 | 940 | |
| 921 | 941 | /* If device was up (receiving) then shutdown */ |
| 922 | 942 | if (netif_running(ndev)) { |
| 923 | − netif_tx_disable(ndev); | |
| 943 | + netvsc_tx_disable(nvdev, ndev); | |
| 924 | 944 | |
| 925 | 945 | ret = rndis_filter_close(nvdev); |
| 926 | 946 | if (ret) { |
| @@ -1908,7 +1928,7 @@ static void netvsc_link_change(struct work_struct *w) · 981 unmodified lines | ||
| 1908 | 1928 | if (rdev->link_state) { |
| 1909 | 1929 | rdev->link_state = false; |
| 1910 | 1930 | netif_carrier_on(net); |
| 1911 | − netif_tx_wake_all_queues(net); | |
| 1931 | + netvsc_tx_enable(net_device, net); | |
| 1912 | 1932 | } else { |
| 1913 | 1933 | notify = true; |
| 1914 | 1934 | } |
| @@ -1918,7 +1938,7 @@ static void netvsc_link_change(struct work_struct *w) · 3 unmodified lines | ||
| 1918 | 1938 | if (!rdev->link_state) { |
| 1919 | 1939 | rdev->link_state = true; |
| 1920 | 1940 | netif_carrier_off(net); |
| 1921 | − netif_tx_stop_all_queues(net); | |
| 1941 | + netvsc_tx_disable(net_device, net); | |
| 1922 | 1942 | } |
| 1923 | 1943 | kfree(event); |
| 1924 | 1944 | break; |
| @@ -1927,7 +1947,7 @@ static void netvsc_link_change(struct work_struct *w) · 2 unmodified lines | ||
| 1927 | 1947 | if (!rdev->link_state) { |
| 1928 | 1948 | rdev->link_state = true; |
| 1929 | 1949 | netif_carrier_off(net); |
| 1930 | − netif_tx_stop_all_queues(net); | |
| 1950 | + netvsc_tx_disable(net_device, net); | |
| 1931 | 1951 | event->event = RNDIS_STATUS_MEDIA_CONNECT; |
| 1932 | 1952 | spin_lock_irqsave(&ndev_ctx->lock, flags); |
| 1933 | 1953 | list_add(&event->list, &ndev_ctx->reconfig_events); |
| @@ -1203,6 +1203,7 @@ static const struct usb_device_id products[] = { · 1202 unmodified lines | ||
| 1203 | 1203 | {QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */ |
| 1204 | 1204 | {QMI_FIXED_INTF(0x2001, 0x7e19, 4)}, /* D-Link DWM-221 B1 */ |
| 1205 | 1205 | {QMI_FIXED_INTF(0x2001, 0x7e35, 4)}, /* D-Link DWM-222 */ |
| 1206 | + {QMI_FIXED_INTF(0x2020, 0x2031, 4)}, /* Olicard 600 */ | |
| 1206 | 1207 | {QMI_FIXED_INTF(0x2020, 0x2033, 4)}, /* BroadMobi BM806U */ |
| 1207 | 1208 | {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */ |
| 1208 | 1209 | {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */ |
| @@ -1273,9 +1273,14 @@ static void vrf_setup(struct net_device *dev) · 1272 unmodified lines | ||
| 1273 | 1273 | |
| 1274 | 1274 | /* default to no qdisc; user can add if desired */ |
| 1275 | 1275 | dev->priv_flags |= IFF_NO_QUEUE; |
| 1276 | + dev->priv_flags |= IFF_NO_RX_HANDLER; | |
| 1276 | 1277 | |
| 1277 | − dev->min_mtu = 0; | |
| 1278 | − dev->max_mtu = 0; | |
| 1278 | + /* VRF devices do not care about MTU, but if the MTU is set | |
| 1279 | + * too low then the ipv4 and ipv6 protocols are disabled | |
| 1280 | + * which breaks networking. | |
| 1281 | + */ | |
| 1282 | + dev->min_mtu = IPV6_MIN_MTU; | |
| 1283 | + dev->max_mtu = ETH_MAX_MTU; | |
| 1279 | 1284 | } |
| 1280 | 1285 | |
| 1281 | 1286 | static int vrf_validate(struct nlattr *tb[], struct nlattr *data[], |
| @@ -157,8 +157,12 @@ · 156 unmodified lines | ||
| 157 | 157 | #define DBG_IRT(x...) |
| 158 | 158 | #endif |
| 159 | 159 | |
| 160 | +#ifdef CONFIG_64BIT | |
| 161 | +#define COMPARE_IRTE_ADDR(irte, hpa) ((irte)->dest_iosapic_addr == (hpa)) | |
| 162 | +#else | |
| 160 | 163 | #define COMPARE_IRTE_ADDR(irte, hpa) \ |
| 161 | − ((irte)->dest_iosapic_addr == F_EXTEND(hpa)) | |
| 164 | + ((irte)->dest_iosapic_addr == ((hpa) | 0xffffffff00000000ULL)) | |
| 165 | +#endif | |
| 162 | 166 | |
| 163 | 167 | #define IOSAPIC_REG_SELECT 0x00 |
| 164 | 168 | #define IOSAPIC_REG_WINDOW 0x10 |
| @@ -130,6 +130,7 @@ static int meson_audio_arb_probe(struct platform_device *pdev) · 129 unmodified lines | ||
| 130 | 130 | arb->rstc.nr_resets = ARRAY_SIZE(axg_audio_arb_reset_bits); |
| 131 | 131 | arb->rstc.ops = &meson_audio_arb_rstc_ops; |
| 132 | 132 | arb->rstc.of_node = dev->of_node; |
| 133 | + arb->rstc.owner = THIS_MODULE; | |
| 133 | 134 | |
| 134 | 135 | /* |
| 135 | 136 | * Enable general : |
| @@ -667,9 +667,9 @@ config RTC_DRV_S5M · 666 unmodified lines | ||
| 667 | 667 | will be called rtc-s5m. |
| 668 | 668 | |
| 669 | 669 | config RTC_DRV_SD3078 |
| 670 | − tristate "ZXW Crystal SD3078" | |
| 670 | + tristate "ZXW Shenzhen whwave SD3078" | |
| 671 | 671 | help |
| 672 | − If you say yes here you get support for the ZXW Crystal | |
| 672 | + If you say yes here you get support for the ZXW Shenzhen whwave | |
| 673 | 673 | SD3078 RTC chips. |
| 674 | 674 | |
| 675 | 675 | This driver can also be built as a module. If so, the module |
| @@ -298,7 +298,7 @@ static int cros_ec_rtc_suspend(struct device *dev) · 297 unmodified lines | ||
| 298 | 298 | struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev); |
| 299 | 299 | |
| 300 | 300 | if (device_may_wakeup(dev)) |
| 301 | − enable_irq_wake(cros_ec_rtc->cros_ec->irq); | |
| 301 | + return enable_irq_wake(cros_ec_rtc->cros_ec->irq); | |
| 302 | 302 | |
| 303 | 303 | return 0; |
| 304 | 304 | } |
| @@ -309,7 +309,7 @@ static int cros_ec_rtc_resume(struct device *dev) · 4 unmodified lines | ||
| 309 | 309 | struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev); |
| 310 | 310 | |
| 311 | 311 | if (device_may_wakeup(dev)) |
| 312 | − disable_irq_wake(cros_ec_rtc->cros_ec->irq); | |
| 312 | + return disable_irq_wake(cros_ec_rtc->cros_ec->irq); | |
| 313 | 313 | |
| 314 | 314 | return 0; |
| 315 | 315 | } |
| @@ -480,6 +480,13 @@ static int da9063_rtc_probe(struct platform_device *pdev) · 479 unmodified lines | ||
| 480 | 480 | da9063_data_to_tm(data, &rtc->alarm_time, rtc); |
| 481 | 481 | rtc->rtc_sync = false; |
| 482 | 482 | |
| 483 | + /* | |
| 484 | + * TODO: some models have alarms on a minute boundary but still support | |
| 485 | + * real hardware interrupts. Add this once the core supports it. | |
| 486 | + */ | |
| 487 | + if (config->rtc_data_start != RTC_SEC) | |
| 488 | + rtc->rtc_dev->uie_unsupported = 1; | |
| 489 | + | |
| 483 | 490 | irq_alarm = platform_get_irq_byname(pdev, "ALARM"); |
| 484 | 491 | ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL, |
| 485 | 492 | da9063_alarm_event, |
| @@ -374,7 +374,7 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm) · 373 unmodified lines | ||
| 374 | 374 | static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off) |
| 375 | 375 | { |
| 376 | 376 | unsigned int byte; |
| 377 | − int value = 0xff; /* return 0xff for ignored values */ | |
| 377 | + int value = -1; /* return -1 for ignored values */ | |
| 378 | 378 | |
| 379 | 379 | byte = readb(rtc->regbase + reg_off); |
| 380 | 380 | if (byte & AR_ENB) { |
| @@ -3878,10 +3878,9 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn, · 3877 unmodified lines | ||
| 3878 | 3878 | * wake up the thread. |
| 3879 | 3879 | */ |
| 3880 | 3880 | spin_lock(&lpfc_cmd->buf_lock); |
| 3881 | − if (unlikely(lpfc_cmd->cur_iocbq.iocb_flag & LPFC_DRIVER_ABORTED)) { | |
| 3882 | − lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED; | |
| 3883 | − if (lpfc_cmd->waitq) | |
| 3884 | − wake_up(lpfc_cmd->waitq); | |
| 3881 | + lpfc_cmd->cur_iocbq.iocb_flag &= ~LPFC_DRIVER_ABORTED; | |
| 3882 | + if (lpfc_cmd->waitq) { | |
| 3883 | + wake_up(lpfc_cmd->waitq); | |
| 3885 | 3884 | lpfc_cmd->waitq = NULL; |
| 3886 | 3885 | } |
| 3887 | 3886 | spin_unlock(&lpfc_cmd->buf_lock); |
| @@ -1392,10 +1392,8 @@ static void qedi_free_nvm_iscsi_cfg(struct qedi_ctx *qedi) · 1391 unmodified lines | ||
| 1392 | 1392 | |
| 1393 | 1393 | static int qedi_alloc_nvm_iscsi_cfg(struct qedi_ctx *qedi) |
| 1394 | 1394 | { |
| 1395 | − struct qedi_nvm_iscsi_image nvm_image; | |
| 1396 | − | |
| 1397 | 1395 | qedi->iscsi_image = dma_alloc_coherent(&qedi->pdev->dev, |
| 1398 | − sizeof(nvm_image), | |
| 1396 | + sizeof(struct qedi_nvm_iscsi_image), | |
| 1399 | 1397 | &qedi->nvm_buf_dma, GFP_KERNEL); |
| 1400 | 1398 | if (!qedi->iscsi_image) { |
| 1401 | 1399 | QEDI_ERR(&qedi->dbg_ctx, "Could not allocate NVM BUF.\n"); |
| @@ -2236,14 +2234,13 @@ static void qedi_boot_release(void *data) · 834 unmodified lines | ||
| 2236 | 2234 | static int qedi_get_boot_info(struct qedi_ctx *qedi) |
| 2237 | 2235 | { |
| 2238 | 2236 | int ret = 1; |
| 2239 | − struct qedi_nvm_iscsi_image nvm_image; | |
| 2240 | 2237 | |
| 2241 | 2238 | QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_INFO, |
| 2242 | 2239 | "Get NVM iSCSI CFG image\n"); |
| 2243 | 2240 | ret = qedi_ops->common->nvm_get_image(qedi->cdev, |
| 2244 | 2241 | QED_NVM_IMAGE_ISCSI_CFG, |
| 2245 | 2242 | (char *)qedi->iscsi_image, |
| 2246 | − sizeof(nvm_image)); | |
| 2243 | + sizeof(struct qedi_nvm_iscsi_image)); | |
| 2247 | 2244 | if (ret) |
| 2248 | 2245 | QEDI_ERR(&qedi->dbg_ctx, |
| 2249 | 2246 | "Could not get NVM image. ret = %d\n", ret); |
| @@ -238,6 +238,7 @@ static struct { · 237 unmodified lines | ||
| 238 | 238 | {"NETAPP", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, |
| 239 | 239 | {"LSI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, |
| 240 | 240 | {"ENGENIO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, |
| 241 | + {"LENOVO", "Universal Xport", "*", BLIST_NO_ULD_ATTACH}, | |
| 241 | 242 | {"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36}, |
| 242 | 243 | {"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN}, |
| 243 | 244 | {"SONY", "TSL", NULL, BLIST_FORCELUN}, /* DDS3 & DDS4 autoloaders */ |
| @@ -75,6 +75,7 @@ static const struct scsi_dh_blist scsi_dh_blist[] = { · 74 unmodified lines | ||
| 75 | 75 | {"NETAPP", "INF-01-00", "rdac", }, |
| 76 | 76 | {"LSI", "INF-01-00", "rdac", }, |
| 77 | 77 | {"ENGENIO", "INF-01-00", "rdac", }, |
| 78 | + {"LENOVO", "DE_Series", "rdac", }, | |
| 78 | 79 | {NULL, NULL, NULL }, |
| 79 | 80 | }; |
| 80 | 81 | |
| @@ -385,7 +385,7 @@ enum storvsc_request_type { · 384 unmodified lines | ||
| 385 | 385 | * This is the end of Protocol specific defines. |
| 386 | 386 | */ |
| 387 | 387 | |
| 388 | −static int storvsc_ringbuffer_size = (256 * PAGE_SIZE); | |
| 388 | +static int storvsc_ringbuffer_size = (128 * 1024); | |
| 389 | 389 | static u32 max_outstanding_req_per_channel; |
| 390 | 390 | |
| 391 | 391 | static int storvsc_vcpus_per_sub_channel = 4; |
| @@ -668,13 +668,22 @@ static void handle_multichannel_storage(struct hv_device *device, int max_chns) · 276 unmodified lines | ||
| 668 | 668 | { |
| 669 | 669 | struct device *dev = &device->device; |
| 670 | 670 | struct storvsc_device *stor_device; |
| 671 | − int num_cpus = num_online_cpus(); | |
| 672 | 671 | int num_sc; |
| 673 | 672 | struct storvsc_cmd_request *request; |
| 674 | 673 | struct vstor_packet *vstor_packet; |
| 675 | 674 | int ret, t; |
| 676 | 675 | |
| 677 | − num_sc = ((max_chns > num_cpus) ? num_cpus : max_chns); | |
| 676 | + /* | |
| 677 | + * If the number of CPUs is artificially restricted, such as | |
| 678 | + * with maxcpus=1 on the kernel boot line, Hyper-V could offer | |
| 679 | + * sub-channels >= the number of CPUs. These sub-channels | |
| 680 | + * should not be created. The primary channel is already created | |
| 681 | + * and assigned to one CPU, so check against # CPUs - 1. | |
| 682 | + */ | |
| 683 | + num_sc = min((int)(num_online_cpus() - 1), max_chns); | |
| 684 | + if (!num_sc) | |
| 685 | + return; | |
| 686 | + | |
| 678 | 687 | stor_device = get_out_stor_device(device); |
| 679 | 688 | if (!stor_device) |
| 680 | 689 | return; |
| @@ -1661,11 +1661,11 @@ static void __init vfio_pci_fill_ids(void) · 1660 unmodified lines | ||
| 1661 | 1661 | rc = pci_add_dynid(&vfio_pci_driver, vendor, device, |
| 1662 | 1662 | subvendor, subdevice, class, class_mask, 0); |
| 1663 | 1663 | if (rc) |
| 1664 | − pr_warn("failed to add dynamic id [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x (%d)\n", | |
| 1664 | + pr_warn("failed to add dynamic id [%04x:%04x[%04x:%04x]] class %#08x/%08x (%d)\n", | |
| 1665 | 1665 | vendor, device, subvendor, subdevice, |
| 1666 | 1666 | class, class_mask, rc); |
| 1667 | 1667 | else |
| 1668 | − pr_info("add [%04hx:%04hx[%04hx:%04hx]] class %#08x/%08x\n", | |
| 1668 | + pr_info("add [%04x:%04x[%04x:%04x]] class %#08x/%08x\n", | |
| 1669 | 1669 | vendor, device, subvendor, subdevice, |
| 1670 | 1670 | class, class_mask); |
| 1671 | 1671 | } |
| @@ -1398,7 +1398,7 @@ unlock_exit: · 1397 unmodified lines | ||
| 1398 | 1398 | mutex_unlock(&container->lock); |
| 1399 | 1399 | } |
| 1400 | 1400 | |
| 1401 | −const struct vfio_iommu_driver_ops tce_iommu_driver_ops = { | |
| 1401 | +static const struct vfio_iommu_driver_ops tce_iommu_driver_ops = { | |
| 1402 | 1402 | .name = "iommu-vfio-powerpc", |
| 1403 | 1403 | .owner = THIS_MODULE, |
| 1404 | 1404 | .open = tce_iommu_open, |
| @@ -58,12 +58,18 @@ module_param_named(disable_hugepages, · 57 unmodified lines | ||
| 58 | 58 | MODULE_PARM_DESC(disable_hugepages, |
| 59 | 59 | "Disable VFIO IOMMU support for IOMMU hugepages."); |
| 60 | 60 | |
| 61 | +static unsigned int dma_entry_limit __read_mostly = U16_MAX; | |
| 62 | +module_param_named(dma_entry_limit, dma_entry_limit, uint, 0644); | |
| 63 | +MODULE_PARM_DESC(dma_entry_limit, | |
| 64 | + "Maximum number of user DMA mappings per container (65535)."); | |
| 65 | + | |
| 61 | 66 | struct vfio_iommu { |
| 62 | 67 | struct list_head domain_list; |
| 63 | 68 | struct vfio_domain *external_domain; /* domain for external user */ |
| 64 | 69 | struct mutex lock; |
| 65 | 70 | struct rb_root dma_list; |
| 66 | 71 | struct blocking_notifier_head notifier; |
| 72 | + unsigned int dma_avail; | |
| 67 | 73 | bool v2; |
| 68 | 74 | bool nesting; |
| 69 | 75 | }; |
| @@ -836,6 +842,7 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *dma) · 766 unmodified lines | ||
| 836 | 842 | vfio_unlink_dma(iommu, dma); |
| 837 | 843 | put_task_struct(dma->task); |
| 838 | 844 | kfree(dma); |
| 845 | + iommu->dma_avail++; | |
| 839 | 846 | } |
| 840 | 847 | |
| 841 | 848 | static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu) |
| @@ -1081,12 +1088,18 @@ static int vfio_dma_do_map(struct vfio_iommu *iommu, · 239 unmodified lines | ||
| 1081 | 1088 | goto out_unlock; |
| 1082 | 1089 | } |
| 1083 | 1090 | |
| 1091 | + if (!iommu->dma_avail) { | |
| 1092 | + ret = -ENOSPC; | |
| 1093 | + goto out_unlock; | |
| 1094 | + } | |
| 1095 | + | |
| 1084 | 1096 | dma = kzalloc(sizeof(*dma), GFP_KERNEL); |
| 1085 | 1097 | if (!dma) { |
| 1086 | 1098 | ret = -ENOMEM; |
| 1087 | 1099 | goto out_unlock; |
| 1088 | 1100 | } |
| 1089 | 1101 | |
| 1102 | + iommu->dma_avail--; | |
| 1090 | 1103 | dma->iova = iova; |
| 1091 | 1104 | dma->vaddr = vaddr; |
| 1092 | 1105 | dma->prot = prot; |
| @@ -1583,6 +1596,7 @@ static void *vfio_iommu_type1_open(unsigned long arg) · 490 unmodified lines | ||
| 1583 | 1596 | |
| 1584 | 1597 | INIT_LIST_HEAD(&iommu->domain_list); |
| 1585 | 1598 | iommu->dma_list = RB_ROOT; |
| 1599 | + iommu->dma_avail = dma_entry_limit; | |
| 1586 | 1600 | mutex_init(&iommu->lock); |
| 1587 | 1601 | BLOCKING_INIT_NOTIFIER_HEAD(&iommu->notifier); |
| 1588 | 1602 | |
| @@ -140,8 +140,7 @@ static int privcmd_buf_mmap(struct file *file, struct vm_area_struct *vma) · 139 unmodified lines | ||
| 140 | 140 | if (!(vma->vm_flags & VM_SHARED)) |
| 141 | 141 | return -EINVAL; |
| 142 | 142 | |
| 143 | − vma_priv = kzalloc(sizeof(*vma_priv) + count * sizeof(void *), | |
| 144 | − GFP_KERNEL); | |
| 143 | + vma_priv = kzalloc(struct_size(vma_priv, pages, count), GFP_KERNEL); | |
| 145 | 144 | if (!vma_priv) |
| 146 | 145 | return -ENOMEM; |
| 147 | 146 | |
| @@ -622,9 +622,7 @@ static int xenbus_file_open(struct inode *inode, struct file *filp) · 621 unmodified lines | ||
| 622 | 622 | if (xen_store_evtchn == 0) |
| 623 | 623 | return -ENOENT; |
| 624 | 624 | |
| 625 | − nonseekable_open(inode, filp); | |
| 626 | − | |
| 627 | − filp->f_mode &= ~FMODE_ATOMIC_POS; /* cdev-style semantics */ | |
| 625 | + stream_open(inode, filp); | |
| 628 | 626 | |
| 629 | 627 | u = kzalloc(sizeof(*u), GFP_KERNEL); |
| 630 | 628 | if (u == NULL) |
| @@ -1034,7 +1034,7 @@ static inline struct aio_kiocb *aio_get_req(struct kioctx *ctx) · 1033 unmodified lines | ||
| 1034 | 1034 | return NULL; |
| 1035 | 1035 | |
| 1036 | 1036 | if (unlikely(!get_reqs_available(ctx))) { |
| 1037 | − kfree(req); | |
| 1037 | + kmem_cache_free(kiocb_cachep, req); | |
| 1038 | 1038 | return NULL; |
| 1039 | 1039 | } |
| 1040 | 1040 | |
| @@ -1794,7 +1794,7 @@ static int __io_submit_one(struct kioctx *ctx, const struct iocb *iocb, · 753 unmodified lines | ||
| 1794 | 1794 | */ |
| 1795 | 1795 | eventfd = eventfd_ctx_fdget(iocb->aio_resfd); |
| 1796 | 1796 | if (IS_ERR(eventfd)) |
| 1797 | − return PTR_ERR(req->ki_eventfd); | |
| 1797 | + return PTR_ERR(eventfd); | |
| 1798 | 1798 | |
| 1799 | 1799 | req->ki_eventfd = eventfd; |
| 1800 | 1800 | } |
| @@ -559,6 +559,8 @@ cifs_show_options(struct seq_file *s, struct dentry *root) · 558 unmodified lines | ||
| 559 | 559 | tcon->ses->server->echo_interval / HZ); |
| 560 | 560 | if (tcon->snapshot_time) |
| 561 | 561 | seq_printf(s, ",snapshot=%llu", tcon->snapshot_time); |
| 562 | + if (tcon->handle_timeout) | |
| 563 | + seq_printf(s, ",handletimeout=%u", tcon->handle_timeout); | |
| 562 | 564 | /* convert actimeo and display it in seconds */ |
| 563 | 565 | seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ); |
| 564 | 566 | |
| @@ -59,6 +59,12 @@ · 58 unmodified lines | ||
| 59 | 59 | */ |
| 60 | 60 | #define CIFS_MAX_ACTIMEO (1 << 30) |
| 61 | 61 | |
| 62 | +/* | |
| 63 | + * Max persistent and resilient handle timeout (milliseconds). | |
| 64 | + * Windows durable max was 960000 (16 minutes) | |
| 65 | + */ | |
| 66 | +#define SMB3_MAX_HANDLE_TIMEOUT 960000 | |
| 67 | + | |
| 62 | 68 | /* |
| 63 | 69 | * MAX_REQ is the maximum number of requests that WE will send |
| 64 | 70 | * on one socket concurrently. |
| @@ -586,6 +592,7 @@ struct smb_vol { · 521 unmodified lines | ||
| 586 | 592 | struct nls_table *local_nls; |
| 587 | 593 | unsigned int echo_interval; /* echo interval in secs */ |
| 588 | 594 | __u64 snapshot_time; /* needed for timewarp tokens */ |
| 595 | + __u32 handle_timeout; /* persistent and durable handle timeout in ms */ | |
| 589 | 596 | unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */ |
| 590 | 597 | }; |
| 591 | 598 | |
| @@ -1058,6 +1065,7 @@ struct cifs_tcon { · 466 unmodified lines | ||
| 1058 | 1065 | __u32 vol_serial_number; |
| 1059 | 1066 | __le64 vol_create_time; |
| 1060 | 1067 | __u64 snapshot_time; /* for timewarp tokens - timestamp of snapshot */ |
| 1068 | + __u32 handle_timeout; /* persistent and durable handle timeout in ms */ | |
| 1061 | 1069 | __u32 ss_flags; /* sector size flags */ |
| 1062 | 1070 | __u32 perf_sector_size; /* best sector size for perf */ |
| 1063 | 1071 | __u32 max_chunks; |
| @@ -103,7 +103,7 @@ enum { · 102 unmodified lines | ||
| 103 | 103 | Opt_cruid, Opt_gid, Opt_file_mode, |
| 104 | 104 | Opt_dirmode, Opt_port, |
| 105 | 105 | Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo, |
| 106 | − Opt_echo_interval, Opt_max_credits, | |
| 106 | + Opt_echo_interval, Opt_max_credits, Opt_handletimeout, | |
| 107 | 107 | Opt_snapshot, |
| 108 | 108 | |
| 109 | 109 | /* Mount options which take string value */ |
| @@ -208,6 +208,7 @@ static const match_table_t cifs_mount_option_tokens = { · 98 unmodified lines | ||
| 208 | 208 | { Opt_rsize, "rsize=%s" }, |
| 209 | 209 | { Opt_wsize, "wsize=%s" }, |
| 210 | 210 | { Opt_actimeo, "actimeo=%s" }, |
| 211 | + { Opt_handletimeout, "handletimeout=%s" }, | |
| 211 | 212 | { Opt_echo_interval, "echo_interval=%s" }, |
| 212 | 213 | { Opt_max_credits, "max_credits=%s" }, |
| 213 | 214 | { Opt_snapshot, "snapshot=%s" }, |
| @@ -1619,6 +1620,9 @@ cifs_parse_mount_options(const char *mountdata, const char *devname, · 1405 unmodified lines | ||
| 1619 | 1620 | |
| 1620 | 1621 | vol->actimeo = CIFS_DEF_ACTIMEO; |
| 1621 | 1622 | |
| 1623 | + /* Most clients set timeout to 0, allows server to use its default */ | |
| 1624 | + vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */ | |
| 1625 | + | |
| 1622 | 1626 | /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */ |
| 1623 | 1627 | vol->ops = &smb30_operations; |
| 1624 | 1628 | vol->vals = &smbdefault_values; |
| @@ -2017,6 +2021,18 @@ cifs_parse_mount_options(const char *mountdata, const char *devname, · 392 unmodified lines | ||
| 2017 | 2021 | goto cifs_parse_mount_err; |
| 2018 | 2022 | } |
| 2019 | 2023 | break; |
| 2024 | + case Opt_handletimeout: | |
| 2025 | + if (get_option_ul(args, &option)) { | |
| 2026 | + cifs_dbg(VFS, "%s: Invalid handletimeout value\n", | |
| 2027 | + __func__); | |
| 2028 | + goto cifs_parse_mount_err; | |
| 2029 | + } | |
| 2030 | + vol->handle_timeout = option; | |
| 2031 | + if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) { | |
| 2032 | + cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n"); | |
| 2033 | + goto cifs_parse_mount_err; | |
| 2034 | + } | |
| 2035 | + break; | |
| 2020 | 2036 | case Opt_echo_interval: |
| 2021 | 2037 | if (get_option_ul(args, &option)) { |
| 2022 | 2038 | cifs_dbg(VFS, "%s: Invalid echo interval value\n", |
| @@ -3183,6 +3199,8 @@ static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info) · 1160 unmodified lines | ||
| 3183 | 3199 | return 0; |
| 3184 | 3200 | if (tcon->snapshot_time != volume_info->snapshot_time) |
| 3185 | 3201 | return 0; |
| 3202 | + if (tcon->handle_timeout != volume_info->handle_timeout) | |
| 3203 | + return 0; | |
| 3186 | 3204 | return 1; |
| 3187 | 3205 | } |
| 3188 | 3206 | |
| @@ -3297,6 +3315,16 @@ cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info) · 108 unmodified lines | ||
| 3297 | 3315 | tcon->snapshot_time = volume_info->snapshot_time; |
| 3298 | 3316 | } |
| 3299 | 3317 | |
| 3318 | + if (volume_info->handle_timeout) { | |
| 3319 | + if (ses->server->vals->protocol_id == 0) { | |
| 3320 | + cifs_dbg(VFS, | |
| 3321 | + "Use SMB2.1 or later for handle timeout option\n"); | |
| 3322 | + rc = -EOPNOTSUPP; | |
| 3323 | + goto out_fail; | |
| 3324 | + } else | |
| 3325 | + tcon->handle_timeout = volume_info->handle_timeout; | |
| 3326 | + } | |
| 3327 | + | |
| 3300 | 3328 | tcon->ses = ses; |
| 3301 | 3329 | if (volume_info->password) { |
| 3302 | 3330 | tcon->password = kstrdup(volume_info->password, GFP_KERNEL); |
| @@ -68,13 +68,15 @@ smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms, · 67 unmodified lines | ||
| 68 | 68 | |
| 69 | 69 | |
| 70 | 70 | if (oparms->tcon->use_resilient) { |
| 71 | − nr_ioctl_req.Timeout = 0; /* use server default (120 seconds) */ | |
| 71 | + /* default timeout is 0, servers pick default (120 seconds) */ | |
| 72 | + nr_ioctl_req.Timeout = | |
| 73 | + cpu_to_le32(oparms->tcon->handle_timeout); | |
| 72 | 74 | nr_ioctl_req.Reserved = 0; |
| 73 | 75 | rc = SMB2_ioctl(xid, oparms->tcon, fid->persistent_fid, |
| 74 | 76 | fid->volatile_fid, FSCTL_LMR_REQUEST_RESILIENCY, |
| 75 | 77 | true /* is_fsctl */, |
| 76 | 78 | (char *)&nr_ioctl_req, sizeof(nr_ioctl_req), |
| 77 | − NULL, NULL /* no return info */); | |
| 79 | + CIFSMaxBufSize, NULL, NULL /* no return info */); | |
| 78 | 80 | if (rc == -EOPNOTSUPP) { |
| 79 | 81 | cifs_dbg(VFS, |
| 80 | 82 | "resiliency not supported by server, disabling\n"); |
| @@ -581,7 +581,7 @@ SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon) · 580 unmodified lines | ||
| 581 | 581 | rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, |
| 582 | 582 | FSCTL_QUERY_NETWORK_INTERFACE_INFO, true /* is_fsctl */, |
| 583 | 583 | NULL /* no data input */, 0 /* no data input */, |
| 584 | − (char **)&out_buf, &ret_data_len); | |
| 584 | + CIFSMaxBufSize, (char **)&out_buf, &ret_data_len); | |
| 585 | 585 | if (rc == -EOPNOTSUPP) { |
| 586 | 586 | cifs_dbg(FYI, |
| 587 | 587 | "server does not support query network interfaces\n"); |
| @@ -717,32 +717,28 @@ int open_shroot(unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *pfid) · 129 unmodified lines | ||
| 717 | 717 | oparms.fid->mid = le64_to_cpu(o_rsp->sync_hdr.MessageId); |
| 718 | 718 | #endif /* CIFS_DEBUG2 */ |
| 719 | 719 | |
| 720 | − if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) | |
| 721 | − oplock = smb2_parse_lease_state(server, o_rsp, | |
| 722 | − &oparms.fid->epoch, | |
| 723 | − oparms.fid->lease_key); | |
| 724 | − else | |
| 725 | − goto oshr_exit; | |
| 726 | − | |
| 727 | − | |
| 728 | 720 | memcpy(tcon->crfid.fid, pfid, sizeof(struct cifs_fid)); |
| 729 | 721 | tcon->crfid.tcon = tcon; |
| 730 | 722 | tcon->crfid.is_valid = true; |
| 731 | 723 | kref_init(&tcon->crfid.refcount); |
| 732 | − kref_get(&tcon->crfid.refcount); | |
| 733 | 724 | |
| 725 | + if (o_rsp->OplockLevel == SMB2_OPLOCK_LEVEL_LEASE) { | |
| 726 | + kref_get(&tcon->crfid.refcount); | |
| 727 | + oplock = smb2_parse_lease_state(server, o_rsp, | |
| 728 | + &oparms.fid->epoch, | |
| 729 | + oparms.fid->lease_key); | |
| 730 | + } else | |
| 731 | + goto oshr_exit; | |
| 734 | 732 | |
| 735 | 733 | qi_rsp = (struct smb2_query_info_rsp *)rsp_iov[1].iov_base; |
| 736 | 734 | if (le32_to_cpu(qi_rsp->OutputBufferLength) < sizeof(struct smb2_file_all_info)) |
| 737 | 735 | goto oshr_exit; |
| 738 | − rc = smb2_validate_and_copy_iov( | |
| 736 | + if (!smb2_validate_and_copy_iov( | |
| 739 | 737 | le16_to_cpu(qi_rsp->OutputBufferOffset), |
| 740 | 738 | sizeof(struct smb2_file_all_info), |
| 741 | 739 | &rsp_iov[1], sizeof(struct smb2_file_all_info), |
| 742 | − (char *)&tcon->crfid.file_all_info); | |
| 743 | − if (rc) | |
| 744 | − goto oshr_exit; | |
| 745 | − tcon->crfid.file_all_info_is_valid = 1; | |
| 740 | + (char *)&tcon->crfid.file_all_info)) | |
| 741 | + tcon->crfid.file_all_info_is_valid = 1; | |
| 746 | 742 | |
| 747 | 743 | oshr_exit: |
| 748 | 744 | mutex_unlock(&tcon->crfid.fid_mutex); |
| @@ -1299,7 +1295,7 @@ SMB2_request_res_key(const unsigned int xid, struct cifs_tcon *tcon, · 550 unmodified lines | ||
| 1299 | 1295 | |
| 1300 | 1296 | rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid, |
| 1301 | 1297 | FSCTL_SRV_REQUEST_RESUME_KEY, true /* is_fsctl */, |
| 1302 | − NULL, 0 /* no input */, | |
| 1298 | + NULL, 0 /* no input */, CIFSMaxBufSize, | |
| 1303 | 1299 | (char **)&res_key, &ret_data_len); |
| 1304 | 1300 | |
| 1305 | 1301 | if (rc) { |
| @@ -1404,7 +1400,7 @@ smb2_ioctl_query_info(const unsigned int xid, · 98 unmodified lines | ||
| 1404 | 1400 | rc = SMB2_ioctl_init(tcon, &rqst[1], |
| 1405 | 1401 | COMPOUND_FID, COMPOUND_FID, |
| 1406 | 1402 | qi.info_type, true, NULL, |
| 1407 | − 0); | |
| 1403 | + 0, CIFSMaxBufSize); | |
| 1408 | 1404 | } |
| 1409 | 1405 | } else if (qi.flags == PASSTHRU_QUERY_INFO) { |
| 1410 | 1406 | memset(&qi_iov, 0, sizeof(qi_iov)); |
| @@ -1532,8 +1528,8 @@ smb2_copychunk_range(const unsigned int xid, · 121 unmodified lines | ||
| 1532 | 1528 | rc = SMB2_ioctl(xid, tcon, trgtfile->fid.persistent_fid, |
| 1533 | 1529 | trgtfile->fid.volatile_fid, FSCTL_SRV_COPYCHUNK_WRITE, |
| 1534 | 1530 | true /* is_fsctl */, (char *)pcchunk, |
| 1535 | − sizeof(struct copychunk_ioctl), (char **)&retbuf, | |
| 1536 | − &ret_data_len); | |
| 1531 | + sizeof(struct copychunk_ioctl), CIFSMaxBufSize, | |
| 1532 | + (char **)&retbuf, &ret_data_len); | |
| 1537 | 1533 | if (rc == 0) { |
| 1538 | 1534 | if (ret_data_len != |
| 1539 | 1535 | sizeof(struct copychunk_ioctl_rsp)) { |
| @@ -1693,7 +1689,7 @@ static bool smb2_set_sparse(const unsigned int xid, struct cifs_tcon *tcon, · 153 unmodified lines | ||
| 1693 | 1689 | rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, |
| 1694 | 1690 | cfile->fid.volatile_fid, FSCTL_SET_SPARSE, |
| 1695 | 1691 | true /* is_fctl */, |
| 1696 | − &setsparse, 1, NULL, NULL); | |
| 1692 | + &setsparse, 1, CIFSMaxBufSize, NULL, NULL); | |
| 1697 | 1693 | if (rc) { |
| 1698 | 1694 | tcon->broken_sparse_sup = true; |
| 1699 | 1695 | cifs_dbg(FYI, "set sparse rc = %d\n", rc); |
| @@ -1766,7 +1762,7 @@ smb2_duplicate_extents(const unsigned int xid, · 66 unmodified lines | ||
| 1766 | 1762 | true /* is_fsctl */, |
| 1767 | 1763 | (char *)&dup_ext_buf, |
| 1768 | 1764 | sizeof(struct duplicate_extents_to_file), |
| 1769 | − NULL, | |
| 1765 | + CIFSMaxBufSize, NULL, | |
| 1770 | 1766 | &ret_data_len); |
| 1771 | 1767 | |
| 1772 | 1768 | if (ret_data_len > 0) |
| @@ -1801,7 +1797,7 @@ smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon, · 28 unmodified lines | ||
| 1801 | 1797 | true /* is_fsctl */, |
| 1802 | 1798 | (char *)&integr_info, |
| 1803 | 1799 | sizeof(struct fsctl_set_integrity_information_req), |
| 1804 | − NULL, | |
| 1800 | + CIFSMaxBufSize, NULL, | |
| 1805 | 1801 | &ret_data_len); |
| 1806 | 1802 | |
| 1807 | 1803 | } |
| @@ -1809,6 +1805,8 @@ smb3_set_integrity(const unsigned int xid, struct cifs_tcon *tcon, · 1 unmodified line | ||
| 1809 | 1805 | /* GMT Token is @GMT-YYYY.MM.DD-HH.MM.SS Unicode which is 48 bytes + null */ |
| 1810 | 1806 | #define GMT_TOKEN_SIZE 50 |
| 1811 | 1807 | |
| 1808 | +#define MIN_SNAPSHOT_ARRAY_SIZE 16 /* See MS-SMB2 section 3.3.5.15.1 */ | |
| 1809 | + | |
| 1812 | 1810 | /* |
| 1813 | 1811 | * Input buffer contains (empty) struct smb_snapshot array with size filled in |
| 1814 | 1812 | * For output see struct SRV_SNAPSHOT_ARRAY in MS-SMB2 section 2.2.32.2 |
| @@ -1820,13 +1818,29 @@ smb3_enum_snapshots(const unsigned int xid, struct cifs_tcon *tcon, · 5 unmodified lines | ||
| 1820 | 1818 | char *retbuf = NULL; |
| 1821 | 1819 | unsigned int ret_data_len = 0; |
| 1822 | 1820 | int rc; |
| 1821 | + u32 max_response_size; | |
| 1823 | 1822 | struct smb_snapshot_array snapshot_in; |
| 1824 | 1823 | |
| 1824 | + if (get_user(ret_data_len, (unsigned int __user *)ioc_buf)) | |
| 1825 | + return -EFAULT; | |
| 1826 | + | |
| 1827 | + /* | |
| 1828 | + * Note that for snapshot queries that servers like Azure expect that | |
| 1829 | + * the first query be minimal size (and just used to get the number/size | |
| 1830 | + * of previous versions) so response size must be specified as EXACTLY | |
| 1831 | + * sizeof(struct snapshot_array) which is 16 when rounded up to multiple | |
| 1832 | + * of eight bytes. | |
| 1833 | + */ | |
| 1834 | + if (ret_data_len == 0) | |
| 1835 | + max_response_size = MIN_SNAPSHOT_ARRAY_SIZE; | |
| 1836 | + else | |
| 1837 | + max_response_size = CIFSMaxBufSize; | |
| 1838 | + | |
| 1825 | 1839 | rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, |
| 1826 | 1840 | cfile->fid.volatile_fid, |
| 1827 | 1841 | FSCTL_SRV_ENUMERATE_SNAPSHOTS, |
| 1828 | 1842 | true /* is_fsctl */, |
| 1829 | − NULL, 0 /* no input data */, | |
| 1843 | + NULL, 0 /* no input data */, max_response_size, | |
| 1830 | 1844 | (char **)&retbuf, |
| 1831 | 1845 | &ret_data_len); |
| 1832 | 1846 | cifs_dbg(FYI, "enum snaphots ioctl returned %d and ret buflen is %d\n", |
| @@ -2304,7 +2318,7 @@ smb2_get_dfs_refer(const unsigned int xid, struct cifs_ses *ses, · 471 unmodified lines | ||
| 2304 | 2318 | rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, |
| 2305 | 2319 | FSCTL_DFS_GET_REFERRALS, |
| 2306 | 2320 | true /* is_fsctl */, |
| 2307 | − (char *)dfs_req, dfs_req_size, | |
| 2321 | + (char *)dfs_req, dfs_req_size, CIFSMaxBufSize, | |
| 2308 | 2322 | (char **)&dfs_rsp, &dfs_rsp_size); |
| 2309 | 2323 | } while (rc == -EAGAIN); |
| 2310 | 2324 | |
| @@ -2658,7 +2672,8 @@ static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon, · 347 unmodified lines | ||
| 2658 | 2672 | rc = SMB2_ioctl_init(tcon, &rqst[num++], cfile->fid.persistent_fid, |
| 2659 | 2673 | cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, |
| 2660 | 2674 | true /* is_fctl */, (char *)&fsctl_buf, |
| 2661 | − sizeof(struct file_zero_data_information)); | |
| 2675 | + sizeof(struct file_zero_data_information), | |
| 2676 | + CIFSMaxBufSize); | |
| 2662 | 2677 | if (rc) |
| 2663 | 2678 | goto zero_range_exit; |
| 2664 | 2679 | |
| @@ -2735,7 +2750,8 @@ static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon, · 70 unmodified lines | ||
| 2735 | 2750 | rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, |
| 2736 | 2751 | cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, |
| 2737 | 2752 | true /* is_fctl */, (char *)&fsctl_buf, |
| 2738 | − sizeof(struct file_zero_data_information), NULL, NULL); | |
| 2753 | + sizeof(struct file_zero_data_information), | |
| 2754 | + CIFSMaxBufSize, NULL, NULL); | |
| 2739 | 2755 | free_xid(xid); |
| 2740 | 2756 | return rc; |
| 2741 | 2757 | } |
| @@ -1002,7 +1002,8 @@ int smb3_validate_negotiate(const unsigned int xid, struct cifs_tcon *tcon) · 1001 unmodified lines | ||
| 1002 | 1002 | |
| 1003 | 1003 | rc = SMB2_ioctl(xid, tcon, NO_FILE_ID, NO_FILE_ID, |
| 1004 | 1004 | FSCTL_VALIDATE_NEGOTIATE_INFO, true /* is_fsctl */, |
| 1005 | − (char *)pneg_inbuf, inbuflen, (char **)&pneg_rsp, &rsplen); | |
| 1005 | + (char *)pneg_inbuf, inbuflen, CIFSMaxBufSize, | |
| 1006 | + (char **)&pneg_rsp, &rsplen); | |
| 1006 | 1007 | if (rc == -EOPNOTSUPP) { |
| 1007 | 1008 | /* |
| 1008 | 1009 | * Old Windows versions or Netapp SMB server can return |
| @@ -1858,8 +1859,9 @@ add_lease_context(struct TCP_Server_Info *server, struct kvec *iov, · 849 unmodified lines | ||
| 1858 | 1859 | } |
| 1859 | 1860 | |
| 1860 | 1861 | static struct create_durable_v2 * |
| 1861 | −create_durable_v2_buf(struct cifs_fid *pfid) | |
| 1862 | +create_durable_v2_buf(struct cifs_open_parms *oparms) | |
| 1862 | 1863 | { |
| 1864 | + struct cifs_fid *pfid = oparms->fid; | |
| 1863 | 1865 | struct create_durable_v2 *buf; |
| 1864 | 1866 | |
| 1865 | 1867 | buf = kzalloc(sizeof(struct create_durable_v2), GFP_KERNEL); |
| @@ -1873,7 +1875,14 @@ create_durable_v2_buf(struct cifs_fid *pfid) · 7 unmodified lines | ||
| 1873 | 1875 | (struct create_durable_v2, Name)); |
| 1874 | 1876 | buf->ccontext.NameLength = cpu_to_le16(4); |
| 1875 | 1877 | |
| 1876 | − buf->dcontext.Timeout = 0; /* Should this be configurable by workload */ | |
| 1878 | + /* | |
| 1879 | + * NB: Handle timeout defaults to 0, which allows server to choose | |
| 1880 | + * (most servers default to 120 seconds) and most clients default to 0. | |
| 1881 | + * This can be overridden at mount ("handletimeout=") if the user wants | |
| 1882 | + * a different persistent (or resilient) handle timeout for all opens | |
| 1883 | + * opens on a particular SMB3 mount. | |
| 1884 | + */ | |
| 1885 | + buf->dcontext.Timeout = cpu_to_le32(oparms->tcon->handle_timeout); | |
| 1877 | 1886 | buf->dcontext.Flags = cpu_to_le32(SMB2_DHANDLE_FLAG_PERSISTENT); |
| 1878 | 1887 | generate_random_uuid(buf->dcontext.CreateGuid); |
| 1879 | 1888 | memcpy(pfid->create_guid, buf->dcontext.CreateGuid, 16); |
| @@ -1926,7 +1935,7 @@ add_durable_v2_context(struct kvec *iov, unsigned int *num_iovec, · 46 unmodified lines | ||
| 1926 | 1935 | struct smb2_create_req *req = iov[0].iov_base; |
| 1927 | 1936 | unsigned int num = *num_iovec; |
| 1928 | 1937 | |
| 1929 | − iov[num].iov_base = create_durable_v2_buf(oparms->fid); | |
| 1938 | + iov[num].iov_base = create_durable_v2_buf(oparms); | |
| 1930 | 1939 | if (iov[num].iov_base == NULL) |
| 1931 | 1940 | return -ENOMEM; |
| 1932 | 1941 | iov[num].iov_len = sizeof(struct create_durable_v2); |
| @@ -2478,7 +2487,8 @@ creat_exit: · 545 unmodified lines | ||
| 2478 | 2487 | int |
| 2479 | 2488 | SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst, |
| 2480 | 2489 | u64 persistent_fid, u64 volatile_fid, u32 opcode, |
| 2481 | − bool is_fsctl, char *in_data, u32 indatalen) | |
| 2490 | + bool is_fsctl, char *in_data, u32 indatalen, | |
| 2491 | + __u32 max_response_size) | |
| 2482 | 2492 | { |
| 2483 | 2493 | struct smb2_ioctl_req *req; |
| 2484 | 2494 | struct kvec *iov = rqst->rq_iov; |
| @@ -2520,16 +2530,21 @@ SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst, · 35 unmodified lines | ||
| 2520 | 2530 | req->OutputCount = 0; /* MBZ */ |
| 2521 | 2531 | |
| 2522 | 2532 | /* |
| 2523 | − * Could increase MaxOutputResponse, but that would require more | |
| 2524 | − * than one credit. Windows typically sets this smaller, but for some | |
| 2533 | + * In most cases max_response_size is set to 16K (CIFSMaxBufSize) | |
| 2534 | + * We Could increase default MaxOutputResponse, but that could require | |
| 2535 | + * more credits. Windows typically sets this smaller, but for some | |
| 2525 | 2536 | * ioctls it may be useful to allow server to send more. No point |
| 2526 | 2537 | * limiting what the server can send as long as fits in one credit |
| 2527 | − * Unfortunately - we can not handle more than CIFS_MAX_MSG_SIZE | |
| 2528 | − * (by default, note that it can be overridden to make max larger) | |
| 2529 | − * in responses (except for read responses which can be bigger. | |
| 2530 | − * We may want to bump this limit up | |
| 2538 | + * We can not handle more than CIFS_MAX_BUF_SIZE yet but may want | |
| 2539 | + * to increase this limit up in the future. | |
| 2540 | + * Note that for snapshot queries that servers like Azure expect that | |
| 2541 | + * the first query be minimal size (and just used to get the number/size | |
| 2542 | + * of previous versions) so response size must be specified as EXACTLY | |
| 2543 | + * sizeof(struct snapshot_array) which is 16 when rounded up to multiple | |
| 2544 | + * of eight bytes. Currently that is the only case where we set max | |
| 2545 | + * response size smaller. | |
| 2531 | 2546 | */ |
| 2532 | − req->MaxOutputResponse = cpu_to_le32(CIFSMaxBufSize); | |
| 2547 | + req->MaxOutputResponse = cpu_to_le32(max_response_size); | |
| 2533 | 2548 | |
| 2534 | 2549 | if (is_fsctl) |
| 2535 | 2550 | req->Flags = cpu_to_le32(SMB2_0_IOCTL_IS_FSCTL); |
| @@ -2550,13 +2565,14 @@ SMB2_ioctl_free(struct smb_rqst *rqst) · 14 unmodified lines | ||
| 2550 | 2565 | cifs_small_buf_release(rqst->rq_iov[0].iov_base); /* request */ |
| 2551 | 2566 | } |
| 2552 | 2567 | |
| 2568 | + | |
| 2553 | 2569 | /* |
| 2554 | 2570 | * SMB2 IOCTL is used for both IOCTLs and FSCTLs |
| 2555 | 2571 | */ |
| 2556 | 2572 | int |
| 2557 | 2573 | SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, |
| 2558 | 2574 | u64 volatile_fid, u32 opcode, bool is_fsctl, |
| 2559 | − char *in_data, u32 indatalen, | |
| 2575 | + char *in_data, u32 indatalen, u32 max_out_data_len, | |
| 2560 | 2576 | char **out_data, u32 *plen /* returned data len */) |
| 2561 | 2577 | { |
| 2562 | 2578 | struct smb_rqst rqst; |
| @@ -2593,8 +2609,8 @@ SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, u64 persistent_fid, · 30 unmodified lines | ||
| 2593 | 2609 | rqst.rq_iov = iov; |
| 2594 | 2610 | rqst.rq_nvec = SMB2_IOCTL_IOV_SIZE; |
| 2595 | 2611 | |
| 2596 | − rc = SMB2_ioctl_init(tcon, &rqst, persistent_fid, volatile_fid, | |
| 2597 | − opcode, is_fsctl, in_data, indatalen); | |
| 2612 | + rc = SMB2_ioctl_init(tcon, &rqst, persistent_fid, volatile_fid, opcode, | |
| 2613 | + is_fsctl, in_data, indatalen, max_out_data_len); | |
| 2598 | 2614 | if (rc) |
| 2599 | 2615 | goto ioctl_exit; |
| 2600 | 2616 | |
| @@ -2672,7 +2688,8 @@ SMB2_set_compression(const unsigned int xid, struct cifs_tcon *tcon, · 71 unmodified lines | ||
| 2672 | 2688 | rc = SMB2_ioctl(xid, tcon, persistent_fid, volatile_fid, |
| 2673 | 2689 | FSCTL_SET_COMPRESSION, true /* is_fsctl */, |
| 2674 | 2690 | (char *)&fsctl_input /* data input */, |
| 2675 | − 2 /* in data len */, &ret_data /* out data */, NULL); | |
| 2691 | + 2 /* in data len */, CIFSMaxBufSize /* max out data */, | |
| 2692 | + &ret_data /* out data */, NULL); | |
| 2676 | 2693 | |
| 2677 | 2694 | cifs_dbg(FYI, "set compression rc %d\n", rc); |
| 2678 | 2695 | |
| @@ -142,11 +142,12 @@ extern int SMB2_open_init(struct cifs_tcon *tcon, struct smb_rqst *rqst, · 141 unmodified lines | ||
| 142 | 142 | extern void SMB2_open_free(struct smb_rqst *rqst); |
| 143 | 143 | extern int SMB2_ioctl(const unsigned int xid, struct cifs_tcon *tcon, |
| 144 | 144 | u64 persistent_fid, u64 volatile_fid, u32 opcode, |
| 145 | − bool is_fsctl, char *in_data, u32 indatalen, | |
| 145 | + bool is_fsctl, char *in_data, u32 indatalen, u32 maxoutlen, | |
| 146 | 146 | char **out_data, u32 *plen /* returned data len */); |
| 147 | 147 | extern int SMB2_ioctl_init(struct cifs_tcon *tcon, struct smb_rqst *rqst, |
| 148 | 148 | u64 persistent_fid, u64 volatile_fid, u32 opcode, |
| 149 | − bool is_fsctl, char *in_data, u32 indatalen); | |
| 149 | + bool is_fsctl, char *in_data, u32 indatalen, | |
| 150 | + __u32 max_response_size); | |
| 150 | 151 | extern void SMB2_ioctl_free(struct smb_rqst *rqst); |
| 151 | 152 | extern int SMB2_close(const unsigned int xid, struct cifs_tcon *tcon, |
| 152 | 153 | u64 persistent_file_id, u64 volatile_file_id); |
| @@ -755,11 +755,17 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, · 754 unmodified lines | ||
| 755 | 755 | umode_t mode, dev_t dev) |
| 756 | 756 | { |
| 757 | 757 | struct inode *inode; |
| 758 | − struct resv_map *resv_map; | |
| 758 | + struct resv_map *resv_map = NULL; | |
| 759 | 759 | |
| 760 | − resv_map = resv_map_alloc(); | |
| 761 | − if (!resv_map) | |
| 762 | − return NULL; | |
| 760 | + /* | |
| 761 | + * Reserve maps are only needed for inodes that can have associated | |
| 762 | + * page allocations. | |
| 763 | + */ | |
| 764 | + if (S_ISREG(mode) || S_ISLNK(mode)) { | |
| 765 | + resv_map = resv_map_alloc(); | |
| 766 | + if (!resv_map) | |
| 767 | + return NULL; | |
| 768 | + } | |
| 763 | 769 | |
| 764 | 770 | inode = new_inode(sb); |
| 765 | 771 | if (inode) { |
| @@ -794,8 +800,10 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb, · 28 unmodified lines | ||
| 794 | 800 | break; |
| 795 | 801 | } |
| 796 | 802 | lockdep_annotate_inode_mutex_key(inode); |
| 797 | − } else | |
| 798 | − kref_put(&resv_map->refs, resv_map_release); | |
| 803 | + } else { | |
| 804 | + if (resv_map) | |
| 805 | + kref_put(&resv_map->refs, resv_map_release); | |
| 806 | + } | |
| 799 | 807 | |
| 800 | 808 | return inode; |
| 801 | 809 | } |
| @@ -2215,6 +2215,7 @@ static int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg, · 2214 unmodified lines | ||
| 2215 | 2215 | fput(ctx->user_files[i]); |
| 2216 | 2216 | |
| 2217 | 2217 | kfree(ctx->user_files); |
| 2218 | + ctx->user_files = NULL; | |
| 2218 | 2219 | ctx->nr_user_files = 0; |
| 2219 | 2220 | return ret; |
| 2220 | 2221 | } |
| @@ -1215,3 +1215,21 @@ int nonseekable_open(struct inode *inode, struct file *filp) · 1214 unmodified lines | ||
| 1215 | 1215 | } |
| 1216 | 1216 | |
| 1217 | 1217 | EXPORT_SYMBOL(nonseekable_open); |
| 1218 | + | |
| 1219 | +/* | |
| 1220 | + * stream_open is used by subsystems that want stream-like file descriptors. | |
| 1221 | + * Such file descriptors are not seekable and don't have notion of position | |
| 1222 | + * (file.f_pos is always 0). Contrary to file descriptors of other regular | |
| 1223 | + * files, .read() and .write() can run simultaneously. | |
| 1224 | + * | |
| 1225 | + * stream_open never fails and is marked to return int so that it could be | |
| 1226 | + * directly used as file_operations.open . | |
| 1227 | + */ | |
| 1228 | +int stream_open(struct inode *inode, struct file *filp) | |
| 1229 | +{ | |
| 1230 | + filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE | FMODE_ATOMIC_POS); | |
| 1231 | + filp->f_mode |= FMODE_STREAM; | |
| 1232 | + return 0; | |
| 1233 | +} | |
| 1234 | + | |
| 1235 | +EXPORT_SYMBOL(stream_open); | |
| @@ -616,24 +616,25 @@ static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns, · 615 unmodified lines | ||
| 616 | 616 | static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns, |
| 617 | 617 | struct pid *pid, struct task_struct *task) |
| 618 | 618 | { |
| 619 | − long nr; | |
| 620 | − unsigned long args[6], sp, pc; | |
| 619 | + struct syscall_info info; | |
| 620 | + u64 *args = &info.data.args[0]; | |
| 621 | 621 | int res; |
| 622 | 622 | |
| 623 | 623 | res = lock_trace(task); |
| 624 | 624 | if (res) |
| 625 | 625 | return res; |
| 626 | 626 | |
| 627 | − if (task_current_syscall(task, &nr, args, 6, &sp, &pc)) | |
| 627 | + if (task_current_syscall(task, &info)) | |
| 628 | 628 | seq_puts(m, "running\n"); |
| 629 | − else if (nr < 0) | |
| 630 | − seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc); | |
| 629 | + else if (info.data.nr < 0) | |
| 630 | + seq_printf(m, "%d 0x%llx 0x%llx\n", | |
| 631 | + info.data.nr, info.sp, info.data.instruction_pointer); | |
| 631 | 632 | else |
| 632 | 633 | seq_printf(m, |
| 633 | − "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", | |
| 634 | − nr, | |
| 634 | + "%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n", | |
| 635 | + info.data.nr, | |
| 635 | 636 | args[0], args[1], args[2], args[3], args[4], args[5], |
| 636 | − sp, pc); | |
| 637 | + info.sp, info.data.instruction_pointer); | |
| 637 | 638 | unlock_trace(task); |
| 638 | 639 | |
| 639 | 640 | return 0; |
| @@ -560,12 +560,13 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_ · 559 unmodified lines | ||
| 560 | 560 | |
| 561 | 561 | static inline loff_t file_pos_read(struct file *file) |
| 562 | 562 | { |
| 563 | − return file->f_pos; | |
| 563 | + return file->f_mode & FMODE_STREAM ? 0 : file->f_pos; | |
| 564 | 564 | } |
| 565 | 565 | |
| 566 | 566 | static inline void file_pos_write(struct file *file, loff_t pos) |
| 567 | 567 | { |
| 568 | − file->f_pos = pos; | |
| 568 | + if ((file->f_mode & FMODE_STREAM) == 0) | |
| 569 | + file->f_pos = pos; | |
| 569 | 570 | } |
| 570 | 571 | |
| 571 | 572 | ssize_t ksys_read(unsigned int fd, char __user *buf, size_t count) |
| @@ -105,41 +105,30 @@ void syscall_set_return_value(struct task_struct *task, struct pt_regs *regs, · 104 unmodified lines | ||
| 105 | 105 | * syscall_get_arguments - extract system call parameter values |
| 106 | 106 | * @task: task of interest, must be blocked |
| 107 | 107 | * @regs: task_pt_regs() of @task |
| 108 | − * @i: argument index [0,5] | |
| 109 | − * @n: number of arguments; n+i must be [1,6]. | |
| 110 | 108 | * @args: array filled with argument values |
| 111 | 109 | * |
| 112 | − * Fetches @n arguments to the system call starting with the @i'th argument | |
| 113 | − * (from 0 through 5). Argument @i is stored in @args[0], and so on. | |
| 114 | − * An arch inline version is probably optimal when @i and @n are constants. | |
| 110 | + * Fetches 6 arguments to the system call. First argument is stored in | |
| 111 | +* @args[0], and so on. | |
| 115 | 112 | * |
| 116 | 113 | * It's only valid to call this when @task is stopped for tracing on |
| 117 | 114 | * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT. |
| 118 | − * It's invalid to call this with @i + @n > 6; we only support system calls | |
| 119 | − * taking up to 6 arguments. | |
| 120 | 115 | */ |
| 121 | 116 | void syscall_get_arguments(struct task_struct *task, struct pt_regs *regs, |
| 122 | − unsigned int i, unsigned int n, unsigned long *args); | |
| 117 | + unsigned long *args); | |
| 123 | 118 | |
| 124 | 119 | /** |
| 125 | 120 | * syscall_set_arguments - change system call parameter value |
| 126 | 121 | * @task: task of interest, must be in system call entry tracing |
| 127 | 122 | * @regs: task_pt_regs() of @task |
| 128 | − * @i: argument index [0,5] | |
| 129 | − * @n: number of arguments; n+i must be [1,6]. | |
| 130 | 123 | * @args: array of argument values to store |
| 131 | 124 | * |
| 132 | − * Changes @n arguments to the system call starting with the @i'th argument. | |
| 133 | − * Argument @i gets value @args[0], and so on. | |
| 134 | − * An arch inline version is probably optimal when @i and @n are constants. | |
| 125 | + * Changes 6 arguments to the system call. | |
| 126 | + * The first argument gets value @args[0], and so on. | |
| 135 | 127 | * |
| 136 | 128 | * It's only valid to call this when @task is stopped for tracing on |
| 137 | 129 | * entry to a system call, due to %TIF_SYSCALL_TRACE or %TIF_SYSCALL_AUDIT. |
| 138 | − * It's invalid to call this with @i + @n > 6; we only support system calls | |
| 139 | − * taking up to 6 arguments. | |
| 140 | 130 | */ |
| 141 | 131 | void syscall_set_arguments(struct task_struct *task, struct pt_regs *regs, |
| 142 | − unsigned int i, unsigned int n, | |
| 143 | 132 | const unsigned long *args); |
| 144 | 133 | |
| 145 | 134 | /** |
| @@ -51,7 +51,10 @@ · 50 unmodified lines | ||
| 51 | 51 | #define RESET_SD_EMMC_A 44 |
| 52 | 52 | #define RESET_SD_EMMC_B 45 |
| 53 | 53 | #define RESET_SD_EMMC_C 46 |
| 54 | −/* 47-60 */ | |
| 54 | +/* 47 */ | |
| 55 | +#define RESET_USB_PHY20 48 | |
| 56 | +#define RESET_USB_PHY21 49 | |
| 57 | +/* 50-60 */ | |
| 55 | 58 | #define RESET_AUDIO_CODEC 61 |
| 56 | 59 | /* 62-63 */ |
| 57 | 60 | /* RESET2 */ |
| @@ -38,7 +38,7 @@ enum { · 37 unmodified lines | ||
| 38 | 38 | |
| 39 | 39 | int TSS_authhmac(unsigned char *digest, const unsigned char *key, |
| 40 | 40 | unsigned int keylen, unsigned char *h1, |
| 41 | − unsigned char *h2, unsigned char h3, ...); | |
| 41 | + unsigned char *h2, unsigned int h3, ...); | |
| 42 | 42 | int TSS_checkhmac1(unsigned char *buffer, |
| 43 | 43 | const uint32_t command, |
| 44 | 44 | const unsigned char *ononce, |
| @@ -34,41 +34,41 @@ static inline u32 __bitrev32(u32 x) · 33 unmodified lines | ||
| 34 | 34 | |
| 35 | 35 | #define __constant_bitrev32(x) \ |
| 36 | 36 | ({ \ |
| 37 | − u32 __x = x; \ | |
| 38 | − __x = (__x >> 16) | (__x << 16); \ | |
| 39 | − __x = ((__x & (u32)0xFF00FF00UL) >> 8) | ((__x & (u32)0x00FF00FFUL) << 8); \ | |
| 40 | − __x = ((__x & (u32)0xF0F0F0F0UL) >> 4) | ((__x & (u32)0x0F0F0F0FUL) << 4); \ | |
| 41 | − __x = ((__x & (u32)0xCCCCCCCCUL) >> 2) | ((__x & (u32)0x33333333UL) << 2); \ | |
| 42 | − __x = ((__x & (u32)0xAAAAAAAAUL) >> 1) | ((__x & (u32)0x55555555UL) << 1); \ | |
| 43 | − __x; \ | |
| 37 | + u32 ___x = x; \ | |
| 38 | + ___x = (___x >> 16) | (___x << 16); \ | |
| 39 | + ___x = ((___x & (u32)0xFF00FF00UL) >> 8) | ((___x & (u32)0x00FF00FFUL) << 8); \ | |
| 40 | + ___x = ((___x & (u32)0xF0F0F0F0UL) >> 4) | ((___x & (u32)0x0F0F0F0FUL) << 4); \ | |
| 41 | + ___x = ((___x & (u32)0xCCCCCCCCUL) >> 2) | ((___x & (u32)0x33333333UL) << 2); \ | |
| 42 | + ___x = ((___x & (u32)0xAAAAAAAAUL) >> 1) | ((___x & (u32)0x55555555UL) << 1); \ | |
| 43 | + ___x; \ | |
| 44 | 44 | }) |
| 45 | 45 | |
| 46 | 46 | #define __constant_bitrev16(x) \ |
| 47 | 47 | ({ \ |
| 48 | − u16 __x = x; \ | |
| 49 | − __x = (__x >> 8) | (__x << 8); \ | |
| 50 | − __x = ((__x & (u16)0xF0F0U) >> 4) | ((__x & (u16)0x0F0FU) << 4); \ | |
| 51 | − __x = ((__x & (u16)0xCCCCU) >> 2) | ((__x & (u16)0x3333U) << 2); \ | |
| 52 | − __x = ((__x & (u16)0xAAAAU) >> 1) | ((__x & (u16)0x5555U) << 1); \ | |
| 53 | − __x; \ | |
| 48 | + u16 ___x = x; \ | |
| 49 | + ___x = (___x >> 8) | (___x << 8); \ | |
| 50 | + ___x = ((___x & (u16)0xF0F0U) >> 4) | ((___x & (u16)0x0F0FU) << 4); \ | |
| 51 | + ___x = ((___x & (u16)0xCCCCU) >> 2) | ((___x & (u16)0x3333U) << 2); \ | |
| 52 | + ___x = ((___x & (u16)0xAAAAU) >> 1) | ((___x & (u16)0x5555U) << 1); \ | |
| 53 | + ___x; \ | |
| 54 | 54 | }) |
| 55 | 55 | |
| 56 | 56 | #define __constant_bitrev8x4(x) \ |
| 57 | 57 | ({ \ |
| 58 | − u32 __x = x; \ | |
| 59 | − __x = ((__x & (u32)0xF0F0F0F0UL) >> 4) | ((__x & (u32)0x0F0F0F0FUL) << 4); \ | |
| 60 | − __x = ((__x & (u32)0xCCCCCCCCUL) >> 2) | ((__x & (u32)0x33333333UL) << 2); \ | |
| 61 | − __x = ((__x & (u32)0xAAAAAAAAUL) >> 1) | ((__x & (u32)0x55555555UL) << 1); \ | |
| 62 | − __x; \ | |
| 58 | + u32 ___x = x; \ | |
| 59 | + ___x = ((___x & (u32)0xF0F0F0F0UL) >> 4) | ((___x & (u32)0x0F0F0F0FUL) << 4); \ | |
| 60 | + ___x = ((___x & (u32)0xCCCCCCCCUL) >> 2) | ((___x & (u32)0x33333333UL) << 2); \ | |
| 61 | + ___x = ((___x & (u32)0xAAAAAAAAUL) >> 1) | ((___x & (u32)0x55555555UL) << 1); \ | |
| 62 | + ___x; \ | |
| 63 | 63 | }) |
| 64 | 64 | |
| 65 | 65 | #define __constant_bitrev8(x) \ |
| 66 | 66 | ({ \ |
| 67 | − u8 __x = x; \ | |
| 68 | − __x = (__x >> 4) | (__x << 4); \ | |
| 69 | − __x = ((__x & (u8)0xCCU) >> 2) | ((__x & (u8)0x33U) << 2); \ | |
| 70 | − __x = ((__x & (u8)0xAAU) >> 1) | ((__x & (u8)0x55U) << 1); \ | |
| 71 | − __x; \ | |
| 67 | + u8 ___x = x; \ | |
| 68 | + ___x = (___x >> 4) | (___x << 4); \ | |
| 69 | + ___x = ((___x & (u8)0xCCU) >> 2) | ((___x & (u8)0x33U) << 2); \ | |
| 70 | + ___x = ((___x & (u8)0xAAU) >> 1) | ((___x & (u8)0x55U) << 1); \ | |
| 71 | + ___x; \ | |
| 72 | 72 | }) |
| 73 | 73 | |
| 74 | 74 | #define bitrev32(x) \ |
| @@ -158,6 +158,9 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset, · 157 unmodified lines | ||
| 158 | 158 | #define FMODE_OPENED ((__force fmode_t)0x80000) |
| 159 | 159 | #define FMODE_CREATED ((__force fmode_t)0x100000) |
| 160 | 160 | |
| 161 | +/* File is stream-like */ | |
| 162 | +#define FMODE_STREAM ((__force fmode_t)0x200000) | |
| 163 | + | |
| 161 | 164 | /* File was opened by fanotify and shouldn't generate fanotify events */ |
| 162 | 165 | #define FMODE_NONOTIFY ((__force fmode_t)0x4000000) |
| 163 | 166 | |
| @@ -3074,6 +3077,7 @@ extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t); · 2910 unmodified lines | ||
| 3074 | 3077 | extern loff_t no_seek_end_llseek(struct file *, loff_t, int); |
| 3075 | 3078 | extern int generic_file_open(struct inode * inode, struct file * filp); |
| 3076 | 3079 | extern int nonseekable_open(struct inode * inode, struct file * filp); |
| 3080 | +extern int stream_open(struct inode * inode, struct file * filp); | |
| 3077 | 3081 | |
| 3078 | 3082 | #ifdef CONFIG_BLOCK |
| 3079 | 3083 | typedef void (dio_submit_t)(struct bio *bio, struct inode *inode, |
| @@ -566,7 +566,10 @@ struct mem_cgroup *lock_page_memcg(struct page *page); · 565 unmodified lines | ||
| 566 | 566 | void __unlock_page_memcg(struct mem_cgroup *memcg); |
| 567 | 567 | void unlock_page_memcg(struct page *page); |
| 568 | 568 | |
| 569 | −/* idx can be of type enum memcg_stat_item or node_stat_item */ | |
| 569 | +/* | |
| 570 | + * idx can be of type enum memcg_stat_item or node_stat_item. | |
| 571 | + * Keep in sync with memcg_exact_page_state(). | |
| 572 | + */ | |
| 570 | 573 | static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, |
| 571 | 574 | int idx) |
| 572 | 575 | { |
| @@ -469,7 +469,7 @@ static inline u32 linkmode_adv_to_lcl_adv_t(unsigned long *advertising) · 468 unmodified lines | ||
| 469 | 469 | if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, |
| 470 | 470 | advertising)) |
| 471 | 471 | lcl_adv |= ADVERTISE_PAUSE_CAP; |
| 472 | − if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, | |
| 472 | + if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, | |
| 473 | 473 | advertising)) |
| 474 | 474 | lcl_adv |= ADVERTISE_PAUSE_ASYM; |
| 475 | 475 | |
| @@ -594,6 +594,8 @@ enum mlx5_pagefault_type_flags { · 593 unmodified lines | ||
| 594 | 594 | }; |
| 595 | 595 | |
| 596 | 596 | struct mlx5_td { |
| 597 | + /* protects tirs list changes while tirs refresh */ | |
| 598 | + struct mutex list_lock; | |
| 597 | 599 | struct list_head tirs_list; |
| 598 | 600 | u32 tdn; |
| 599 | 601 | }; |
| @@ -671,7 +671,7 @@ enum vm_fault_reason { · 670 unmodified lines | ||
| 671 | 671 | |
| 672 | 672 | /* Encode hstate index for a hwpoisoned large page */ |
| 673 | 673 | #define VM_FAULT_SET_HINDEX(x) ((__force vm_fault_t)((x) << 16)) |
| 674 | −#define VM_FAULT_GET_HINDEX(x) (((x) >> 16) & 0xf) | |
| 674 | +#define VM_FAULT_GET_HINDEX(x) (((__force unsigned int)(x) >> 16) & 0xf) | |
| 675 | 675 | |
| 676 | 676 | #define VM_FAULT_ERROR (VM_FAULT_OOM | VM_FAULT_SIGBUS | \ |
| 677 | 677 | VM_FAULT_SIGSEGV | VM_FAULT_HWPOISON | \ |
| @@ -9,6 +9,13 @@ · 8 unmodified lines | ||
| 9 | 9 | #include <linux/bug.h> /* For BUG_ON. */ |
| 10 | 10 | #include <linux/pid_namespace.h> /* For task_active_pid_ns. */ |
| 11 | 11 | #include <uapi/linux/ptrace.h> |
| 12 | +#include <linux/seccomp.h> | |
| 13 | + | |
| 14 | +/* Add sp to seccomp_data, as seccomp is user API, we don't want to modify it */ | |
| 15 | +struct syscall_info { | |
| 16 | + __u64 sp; | |
| 17 | + struct seccomp_data data; | |
| 18 | +}; | |
| 12 | 19 | |
| 13 | 20 | extern int ptrace_access_vm(struct task_struct *tsk, unsigned long addr, |
| 14 | 21 | void *buf, int len, unsigned int gup_flags); |
| @@ -407,9 +414,7 @@ static inline void user_single_step_report(struct pt_regs *regs) · 392 unmodified lines | ||
| 407 | 414 | #define current_user_stack_pointer() user_stack_pointer(current_pt_regs()) |
| 408 | 415 | #endif |
| 409 | 416 | |
| 410 | −extern int task_current_syscall(struct task_struct *target, long *callno, | |
| 411 | − unsigned long args[6], unsigned int maxargs, | |
| 412 | − unsigned long *sp, unsigned long *pc); | |
| 417 | +extern int task_current_syscall(struct task_struct *target, struct syscall_info *info); | |
| 413 | 418 | |
| 414 | 419 | extern void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact); |
| 415 | 420 | #endif |
| @@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t); · 149 unmodified lines | ||
| 150 | 150 | #ifndef __HAVE_ARCH_MEMCMP |
| 151 | 151 | extern int memcmp(const void *,const void *,__kernel_size_t); |
| 152 | 152 | #endif |
| 153 | +#ifndef __HAVE_ARCH_BCMP | |
| 154 | +extern int bcmp(const void *,const void *,__kernel_size_t); | |
| 155 | +#endif | |
| 153 | 156 | #ifndef __HAVE_ARCH_MEMCHR |
| 154 | 157 | extern void * memchr(const void *,int,__kernel_size_t); |
| 155 | 158 | #endif |
| @@ -677,7 +677,7 @@ int ip_options_get_from_user(struct net *net, struct ip_options_rcu **optp, · 676 unmodified lines | ||
| 677 | 677 | unsigned char __user *data, int optlen); |
| 678 | 678 | void ip_options_undo(struct ip_options *opt); |
| 679 | 679 | void ip_forward_options(struct sk_buff *skb); |
| 680 | −int ip_options_rcv_srr(struct sk_buff *skb); | |
| 680 | +int ip_options_rcv_srr(struct sk_buff *skb, struct net_device *dev); | |
| 681 | 681 | |
| 682 | 682 | /* |
| 683 | 683 | * Functions provided by ip_sockglue.c |
| @@ -59,6 +59,7 @@ struct net { · 58 unmodified lines | ||
| 59 | 59 | */ |
| 60 | 60 | spinlock_t rules_mod_lock; |
| 61 | 61 | |
| 62 | + u32 hash_mix; | |
| 62 | 63 | atomic64_t cookie_gen; |
| 63 | 64 | |
| 64 | 65 | struct list_head list; /* list of network namespaces */ |
| @@ -2,16 +2,10 @@ · 1 unmodified line | ||
| 2 | 2 | #ifndef __NET_NS_HASH_H__ |
| 3 | 3 | #define __NET_NS_HASH_H__ |
| 4 | 4 | |
| 5 | −#include <asm/cache.h> | |
| 6 | − | |
| 7 | −struct net; | |
| 5 | +#include <net/net_namespace.h> | |
| 8 | 6 | |
| 9 | 7 | static inline u32 net_hash_mix(const struct net *net) |
| 10 | 8 | { |
| 11 | −#ifdef CONFIG_NET_NS | |
| 12 | − return (u32)(((unsigned long)net) >> ilog2(sizeof(*net))); | |
| 13 | −#else | |
| 14 | − return 0; | |
| 15 | −#endif | |
| 9 | + return net->hash_mix; | |
| 16 | 10 | } |
| 17 | 11 | #endif |
| @@ -166,7 +166,7 @@ struct nci_conn_info { · 165 unmodified lines | ||
| 166 | 166 | * According to specification 102 622 chapter 4.4 Pipes, |
| 167 | 167 | * the pipe identifier is 7 bits long. |
| 168 | 168 | */ |
| 169 | −#define NCI_HCI_MAX_PIPES 127 | |
| 169 | +#define NCI_HCI_MAX_PIPES 128 | |
| 170 | 170 | |
| 171 | 171 | struct nci_hci_gate { |
| 172 | 172 | u8 gate; |
| @@ -923,6 +923,41 @@ static inline void qdisc_qstats_overlimit(struct Qdisc *sch) · 922 unmodified lines | ||
| 923 | 923 | sch->qstats.overlimits++; |
| 924 | 924 | } |
| 925 | 925 | |
| 926 | +static inline int qdisc_qstats_copy(struct gnet_dump *d, struct Qdisc *sch) | |
| 927 | +{ | |
| 928 | + __u32 qlen = qdisc_qlen_sum(sch); | |
| 929 | + | |
| 930 | + return gnet_stats_copy_queue(d, sch->cpu_qstats, &sch->qstats, qlen); | |
| 931 | +} | |
| 932 | + | |
| 933 | +static inline void qdisc_qstats_qlen_backlog(struct Qdisc *sch, __u32 *qlen, | |
| 934 | + __u32 *backlog) | |
| 935 | +{ | |
| 936 | + struct gnet_stats_queue qstats = { 0 }; | |
| 937 | + __u32 len = qdisc_qlen_sum(sch); | |
| 938 | + | |
| 939 | + __gnet_stats_copy_queue(&qstats, sch->cpu_qstats, &sch->qstats, len); | |
| 940 | + *qlen = qstats.qlen; | |
| 941 | + *backlog = qstats.backlog; | |
| 942 | +} | |
| 943 | + | |
| 944 | +static inline void qdisc_tree_flush_backlog(struct Qdisc *sch) | |
| 945 | +{ | |
| 946 | + __u32 qlen, backlog; | |
| 947 | + | |
| 948 | + qdisc_qstats_qlen_backlog(sch, &qlen, &backlog); | |
| 949 | + qdisc_tree_reduce_backlog(sch, qlen, backlog); | |
| 950 | +} | |
| 951 | + | |
| 952 | +static inline void qdisc_purge_queue(struct Qdisc *sch) | |
| 953 | +{ | |
| 954 | + __u32 qlen, backlog; | |
| 955 | + | |
| 956 | + qdisc_qstats_qlen_backlog(sch, &qlen, &backlog); | |
| 957 | + qdisc_reset(sch); | |
| 958 | + qdisc_tree_reduce_backlog(sch, qlen, backlog); | |
| 959 | +} | |
| 960 | + | |
| 926 | 961 | static inline void qdisc_skb_head_init(struct qdisc_skb_head *qh) |
| 927 | 962 | { |
| 928 | 963 | qh->head = NULL; |
| @@ -1106,13 +1141,8 @@ static inline struct Qdisc *qdisc_replace(struct Qdisc *sch, struct Qdisc *new, · 177 unmodified lines | ||
| 1106 | 1141 | sch_tree_lock(sch); |
| 1107 | 1142 | old = *pold; |
| 1108 | 1143 | *pold = new; |
| 1109 | − if (old != NULL) { | |
| 1110 | − unsigned int qlen = old->q.qlen; | |
| 1111 | − unsigned int backlog = old->qstats.backlog; | |
| 1112 | − | |
| 1113 | − qdisc_reset(old); | |
| 1114 | − qdisc_tree_reduce_backlog(old, qlen, backlog); | |
| 1115 | − } | |
| 1144 | + if (old != NULL) | |
| 1145 | + qdisc_tree_flush_backlog(old); | |
| 1116 | 1146 | sch_tree_unlock(sch); |
| 1117 | 1147 | |
| 1118 | 1148 | return old; |
| @@ -28,7 +28,7 @@ TRACE_EVENT_FN(sys_enter, · 27 unmodified lines | ||
| 28 | 28 | |
| 29 | 29 | TP_fast_assign( |
| 30 | 30 | __entry->id = id; |
| 31 | − syscall_get_arguments(current, regs, 0, 6, __entry->args); | |
| 31 | + syscall_get_arguments(current, regs, __entry->args); | |
| 32 | 32 | ), |
| 33 | 33 | |
| 34 | 34 | TP_printk("NR %ld (%lx, %lx, %lx, %lx, %lx, %lx)", |
| @@ -1591,7 +1591,7 @@ enum ethtool_link_mode_bit_indices { · 1590 unmodified lines | ||
| 1591 | 1591 | |
| 1592 | 1592 | static inline int ethtool_validate_speed(__u32 speed) |
| 1593 | 1593 | { |
| 1594 | − return speed <= INT_MAX || speed == SPEED_UNKNOWN; | |
| 1594 | + return speed <= INT_MAX || speed == (__u32)SPEED_UNKNOWN; | |
| 1595 | 1595 | } |
| 1596 | 1596 | |
| 1597 | 1597 | /* Duplex, half or full. */ |
| @@ -162,10 +162,14 @@ static void cpu_map_kthread_stop(struct work_struct *work) · 161 unmodified lines | ||
| 162 | 162 | static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, |
| 163 | 163 | struct xdp_frame *xdpf) |
| 164 | 164 | { |
| 165 | + unsigned int hard_start_headroom; | |
| 165 | 166 | unsigned int frame_size; |
| 166 | 167 | void *pkt_data_start; |
| 167 | 168 | struct sk_buff *skb; |
| 168 | 169 | |
| 170 | + /* Part of headroom was reserved to xdpf */ | |
| 171 | + hard_start_headroom = sizeof(struct xdp_frame) + xdpf->headroom; | |
| 172 | + | |
| 169 | 173 | /* build_skb need to place skb_shared_info after SKB end, and |
| 170 | 174 | * also want to know the memory "truesize". Thus, need to |
| 171 | 175 | * know the memory frame size backing xdp_buff. |
| @@ -183,15 +187,15 @@ static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, · 11 unmodified lines | ||
| 183 | 187 | * is not at a fixed memory location, with mixed length |
| 184 | 188 | * packets, which is bad for cache-line hotness. |
| 185 | 189 | */ |
| 186 | − frame_size = SKB_DATA_ALIGN(xdpf->len + xdpf->headroom) + | |
| 190 | + frame_size = SKB_DATA_ALIGN(xdpf->len + hard_start_headroom) + | |
| 187 | 191 | SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); |
| 188 | 192 | |
| 189 | − pkt_data_start = xdpf->data - xdpf->headroom; | |
| 193 | + pkt_data_start = xdpf->data - hard_start_headroom; | |
| 190 | 194 | skb = build_skb(pkt_data_start, frame_size); |
| 191 | 195 | if (!skb) |
| 192 | 196 | return NULL; |
| 193 | 197 | |
| 194 | − skb_reserve(skb, xdpf->headroom); | |
| 198 | + skb_reserve(skb, hard_start_headroom); | |
| 195 | 199 | __skb_put(skb, xdpf->len); |
| 196 | 200 | if (xdpf->metasize) |
| 197 | 201 | skb_metadata_set(skb, xdpf->metasize); |
| @@ -205,6 +209,9 @@ static struct sk_buff *cpu_map_build_skb(struct bpf_cpu_map_entry *rcpu, · 7 unmodified lines | ||
| 205 | 209 | * - RX ring dev queue index (skb_record_rx_queue) |
| 206 | 210 | */ |
| 207 | 211 | |
| 212 | + /* Allow SKB to reuse area used by xdp_frame */ | |
| 213 | + xdp_scrub_frame(xdpf); | |
| 214 | + | |
| 208 | 215 | return skb; |
| 209 | 216 | } |
| 210 | 217 | |
| @@ -554,19 +554,6 @@ struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type typ · 553 unmodified lines | ||
| 554 | 554 | } |
| 555 | 555 | EXPORT_SYMBOL(bpf_prog_get_type_path); |
| 556 | 556 | |
| 557 | −static void bpf_evict_inode(struct inode *inode) | |
| 558 | −{ | |
| 559 | − enum bpf_type type; | |
| 560 | − | |
| 561 | − truncate_inode_pages_final(&inode->i_data); | |
| 562 | − clear_inode(inode); | |
| 563 | − | |
| 564 | − if (S_ISLNK(inode->i_mode)) | |
| 565 | − kfree(inode->i_link); | |
| 566 | − if (!bpf_inode_type(inode, &type)) | |
| 567 | − bpf_any_put(inode->i_private, type); | |
| 568 | −} | |
| 569 | − | |
| 570 | 557 | /* |
| 571 | 558 | * Display the mount options in /proc/mounts. |
| 572 | 559 | */ |
| @@ -579,11 +566,28 @@ static int bpf_show_options(struct seq_file *m, struct dentry *root) · 6 unmodified lines | ||
| 579 | 566 | return 0; |
| 580 | 567 | } |
| 581 | 568 | |
| 569 | +static void bpf_destroy_inode_deferred(struct rcu_head *head) | |
| 570 | +{ | |
| 571 | + struct inode *inode = container_of(head, struct inode, i_rcu); | |
| 572 | + enum bpf_type type; | |
| 573 | + | |
| 574 | + if (S_ISLNK(inode->i_mode)) | |
| 575 | + kfree(inode->i_link); | |
| 576 | + if (!bpf_inode_type(inode, &type)) | |
| 577 | + bpf_any_put(inode->i_private, type); | |
| 578 | + free_inode_nonrcu(inode); | |
| 579 | +} | |
| 580 | + | |
| 581 | +static void bpf_destroy_inode(struct inode *inode) | |
| 582 | +{ | |
| 583 | + call_rcu(&inode->i_rcu, bpf_destroy_inode_deferred); | |
| 584 | +} | |
| 585 | + | |
| 582 | 586 | static const struct super_operations bpf_super_ops = { |
| 583 | 587 | .statfs = simple_statfs, |
| 584 | 588 | .drop_inode = generic_delete_inode, |
| 585 | 589 | .show_options = bpf_show_options, |
| 586 | − .evict_inode = bpf_evict_inode, | |
| 590 | + .destroy_inode = bpf_destroy_inode, | |
| 587 | 591 | }; |
| 588 | 592 | |
| 589 | 593 | enum { |
| @@ -1897,8 +1897,9 @@ continue_func: · 1896 unmodified lines | ||
| 1897 | 1897 | } |
| 1898 | 1898 | frame++; |
| 1899 | 1899 | if (frame >= MAX_CALL_FRAMES) { |
| 1900 | − WARN_ONCE(1, "verifier bug. Call stack is too deep\n"); | |
| 1901 | − return -EFAULT; | |
| 1900 | + verbose(env, "the call stack of %d frames is too deep !\n", | |
| 1901 | + frame); | |
| 1902 | + return -E2BIG; | |
| 1902 | 1903 | } |
| 1903 | 1904 | goto process_func; |
| 1904 | 1905 | } |
| @@ -149,7 +149,7 @@ static void populate_seccomp_data(struct seccomp_data *sd) · 148 unmodified lines | ||
| 149 | 149 | |
| 150 | 150 | sd->nr = syscall_get_nr(task, regs); |
| 151 | 151 | sd->arch = syscall_get_arch(); |
| 152 | − syscall_get_arguments(task, regs, 0, 6, args); | |
| 152 | + syscall_get_arguments(task, regs, args); | |
| 153 | 153 | sd->args[0] = args[0]; |
| 154 | 154 | sd->args[1] = args[1]; |
| 155 | 155 | sd->args[2] = args[2]; |
| @@ -3605,16 +3605,11 @@ SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig, · 3604 unmodified lines | ||
| 3605 | 3605 | if (unlikely(sig != kinfo.si_signo)) |
| 3606 | 3606 | goto err; |
| 3607 | 3607 | |
| 3608 | + /* Only allow sending arbitrary signals to yourself. */ | |
| 3609 | + ret = -EPERM; | |
| 3608 | 3610 | if ((task_pid(current) != pid) && |
| 3609 | − (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL)) { | |
| 3610 | − /* Only allow sending arbitrary signals to yourself. */ | |
| 3611 | − ret = -EPERM; | |
| 3612 | − if (kinfo.si_code != SI_USER) | |
| 3613 | − goto err; | |
| 3614 | − | |
| 3615 | − /* Turn this into a regular kill signal. */ | |
| 3616 | − prepare_kill_siginfo(sig, &kinfo); | |
| 3617 | − } | |
| 3611 | + (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL)) | |
| 3612 | + goto err; | |
| 3618 | 3613 | } else { |
| 3619 | 3614 | prepare_kill_siginfo(sig, &kinfo); |
| 3620 | 3615 | } |
| @@ -128,6 +128,7 @@ static int zero; · 127 unmodified lines | ||
| 128 | 128 | static int __maybe_unused one = 1; |
| 129 | 129 | static int __maybe_unused two = 2; |
| 130 | 130 | static int __maybe_unused four = 4; |
| 131 | +static unsigned long zero_ul; | |
| 131 | 132 | static unsigned long one_ul = 1; |
| 132 | 133 | static unsigned long long_max = LONG_MAX; |
| 133 | 134 | static int one_hundred = 100; |
| @@ -1750,7 +1751,7 @@ static struct ctl_table fs_table[] = { · 1616 unmodified lines | ||
| 1750 | 1751 | .maxlen = sizeof(files_stat.max_files), |
| 1751 | 1752 | .mode = 0644, |
| 1752 | 1753 | .proc_handler = proc_doulongvec_minmax, |
| 1753 | − .extra1 = &zero, | |
| 1754 | + .extra1 = &zero_ul, | |
| 1754 | 1755 | .extra2 = &long_max, |
| 1755 | 1756 | }, |
| 1756 | 1757 | { |
| @@ -314,6 +314,7 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id) · 313 unmodified lines | ||
| 314 | 314 | struct ring_buffer_event *event; |
| 315 | 315 | struct ring_buffer *buffer; |
| 316 | 316 | unsigned long irq_flags; |
| 317 | + unsigned long args[6]; | |
| 317 | 318 | int pc; |
| 318 | 319 | int syscall_nr; |
| 319 | 320 | int size; |
| @@ -347,7 +348,8 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id) · 27 unmodified lines | ||
| 347 | 348 | |
| 348 | 349 | entry = ring_buffer_event_data(event); |
| 349 | 350 | entry->nr = syscall_nr; |
| 350 | − syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args); | |
| 351 | + syscall_get_arguments(current, regs, args); | |
| 352 | + memcpy(entry->args, args, sizeof(unsigned long) * sys_data->nb_args); | |
| 351 | 353 | |
| 352 | 354 | event_trigger_unlock_commit(trace_file, buffer, event, entry, |
| 353 | 355 | irq_flags, pc); |
| @@ -583,6 +585,7 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id) · 229 unmodified lines | ||
| 583 | 585 | struct syscall_metadata *sys_data; |
| 584 | 586 | struct syscall_trace_enter *rec; |
| 585 | 587 | struct hlist_head *head; |
| 588 | + unsigned long args[6]; | |
| 586 | 589 | bool valid_prog_array; |
| 587 | 590 | int syscall_nr; |
| 588 | 591 | int rctx; |
| @@ -613,8 +616,8 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id) · 24 unmodified lines | ||
| 613 | 616 | return; |
| 614 | 617 | |
| 615 | 618 | rec->nr = syscall_nr; |
| 616 | − syscall_get_arguments(current, regs, 0, sys_data->nb_args, | |
| 617 | − (unsigned long *)&rec->args); | |
| 619 | + syscall_get_arguments(current, regs, args); | |
| 620 | + memcpy(&rec->args, args, sizeof(unsigned long) * sys_data->nb_args); | |
| 618 | 621 | |
| 619 | 622 | if ((valid_prog_array && |
| 620 | 623 | !perf_call_bpf_enter(sys_data->enter_event, regs, sys_data, rec)) || |
| @@ -1528,6 +1528,7 @@ EXPORT_SYMBOL(csum_and_copy_to_iter); · 1527 unmodified lines | ||
| 1528 | 1528 | size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp, |
| 1529 | 1529 | struct iov_iter *i) |
| 1530 | 1530 | { |
| 1531 | +#ifdef CONFIG_CRYPTO | |
| 1531 | 1532 | struct ahash_request *hash = hashp; |
| 1532 | 1533 | struct scatterlist sg; |
| 1533 | 1534 | size_t copied; |
| @@ -1537,6 +1538,9 @@ size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp, · 3 unmodified lines | ||
| 1537 | 1538 | ahash_request_set_crypt(hash, &sg, NULL, copied); |
| 1538 | 1539 | crypto_ahash_update(hash); |
| 1539 | 1540 | return copied; |
| 1541 | +#else | |
| 1542 | + return 0; | |
| 1543 | +#endif | |
| 1540 | 1544 | } |
| 1541 | 1545 | EXPORT_SYMBOL(hash_and_copy_to_iter); |
| 1542 | 1546 | |
| @@ -291,13 +291,14 @@ int lzogeneric1x_1_compress(const unsigned char *in, size_t in_len, · 290 unmodified lines | ||
| 291 | 291 | { |
| 292 | 292 | const unsigned char *ip = in; |
| 293 | 293 | unsigned char *op = out; |
| 294 | + unsigned char *data_start; | |
| 294 | 295 | size_t l = in_len; |
| 295 | 296 | size_t t = 0; |
| 296 | 297 | signed char state_offset = -2; |
| 297 | 298 | unsigned int m4_max_offset; |
| 298 | 299 | |
| 299 | − // LZO v0 will never write 17 as first byte, | |
| 300 | − // so this is used to version the bitstream | |
| 300 | + // LZO v0 will never write 17 as first byte (except for zero-length | |
| 301 | + // input), so this is used to version the bitstream | |
| 301 | 302 | if (bitstream_version > 0) { |
| 302 | 303 | *op++ = 17; |
| 303 | 304 | *op++ = bitstream_version; |
| @@ -306,6 +307,8 @@ int lzogeneric1x_1_compress(const unsigned char *in, size_t in_len, · 2 unmodified lines | ||
| 306 | 307 | m4_max_offset = M4_MAX_OFFSET_V0; |
| 307 | 308 | } |
| 308 | 309 | |
| 310 | + data_start = op; | |
| 311 | + | |
| 309 | 312 | while (l > 20) { |
| 310 | 313 | size_t ll = l <= (m4_max_offset + 1) ? l : (m4_max_offset + 1); |
| 311 | 314 | uintptr_t ll_end = (uintptr_t) ip + ll; |
| @@ -324,7 +327,7 @@ int lzogeneric1x_1_compress(const unsigned char *in, size_t in_len, · 12 unmodified lines | ||
| 324 | 327 | if (t > 0) { |
| 325 | 328 | const unsigned char *ii = in + in_len - t; |
| 326 | 329 | |
| 327 | − if (op == out && t <= 238) { | |
| 330 | + if (op == data_start && t <= 238) { | |
| 328 | 331 | *op++ = (17 + t); |
| 329 | 332 | } else if (t <= 3) { |
| 330 | 333 | op[state_offset] |= t; |
| @@ -54,11 +54,9 @@ int lzo1x_decompress_safe(const unsigned char *in, size_t in_len, · 53 unmodified lines | ||
| 54 | 54 | if (unlikely(in_len < 3)) |
| 55 | 55 | goto input_overrun; |
| 56 | 56 | |
| 57 | − if (likely(*ip == 17)) { | |
| 57 | + if (likely(in_len >= 5) && likely(*ip == 17)) { | |
| 58 | 58 | bitstream_version = ip[1]; |
| 59 | 59 | ip += 2; |
| 60 | − if (unlikely(in_len < 5)) | |
| 61 | − goto input_overrun; | |
| 62 | 60 | } else { |
| 63 | 61 | bitstream_version = 0; |
| 64 | 62 | } |
| @@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count) · 865 unmodified lines | ||
| 866 | 866 | EXPORT_SYMBOL(memcmp); |
| 867 | 867 | #endif |
| 868 | 868 | |
| 869 | +#ifndef __HAVE_ARCH_BCMP | |
| 870 | +/** | |
| 871 | + * bcmp - returns 0 if and only if the buffers have identical contents. | |
| 872 | + * @a: pointer to first buffer. | |
| 873 | + * @b: pointer to second buffer. | |
| 874 | + * @len: size of buffers. | |
| 875 | + * | |
| 876 | + * The sign or magnitude of a non-zero return value has no particular | |
| 877 | + * meaning, and architectures may implement their own more efficient bcmp(). So | |
| 878 | + * while this particular implementation is a simple (tail) call to memcmp, do | |
| 879 | + * not rely on anything but whether the return value is zero or non-zero. | |
| 880 | + */ | |
| 881 | +#undef bcmp | |
| 882 | +int bcmp(const void *a, const void *b, size_t len) | |
| 883 | +{ | |
| 884 | + return memcmp(a, b, len); | |
| 885 | +} | |
| 886 | +EXPORT_SYMBOL(bcmp); | |
| 887 | +#endif | |
| 888 | + | |
| 869 | 889 | #ifndef __HAVE_ARCH_MEMSCAN |
| 870 | 890 | /** |
| 871 | 891 | * memscan - Find a character in an area of memory. |
| @@ -5,16 +5,14 @@ · 4 unmodified lines | ||
| 5 | 5 | #include <linux/export.h> |
| 6 | 6 | #include <asm/syscall.h> |
| 7 | 7 | |
| 8 | −static int collect_syscall(struct task_struct *target, long *callno, | |
| 9 | − unsigned long args[6], unsigned int maxargs, | |
| 10 | − unsigned long *sp, unsigned long *pc) | |
| 8 | +static int collect_syscall(struct task_struct *target, struct syscall_info *info) | |
| 11 | 9 | { |
| 12 | 10 | struct pt_regs *regs; |
| 13 | 11 | |
| 14 | 12 | if (!try_get_task_stack(target)) { |
| 15 | 13 | /* Task has no stack, so the task isn't in a syscall. */ |
| 16 | − *sp = *pc = 0; | |
| 17 | − *callno = -1; | |
| 14 | + memset(info, 0, sizeof(*info)); | |
| 15 | + info->data.nr = -1; | |
| 18 | 16 | return 0; |
| 19 | 17 | } |
| 20 | 18 | |
| @@ -24,12 +22,13 @@ static int collect_syscall(struct task_struct *target, long *callno, · 3 unmodified lines | ||
| 24 | 22 | return -EAGAIN; |
| 25 | 23 | } |
| 26 | 24 | |
| 27 | − *sp = user_stack_pointer(regs); | |
| 28 | − *pc = instruction_pointer(regs); | |
| 25 | + info->sp = user_stack_pointer(regs); | |
| 26 | + info->data.instruction_pointer = instruction_pointer(regs); | |
| 29 | 27 | |
| 30 | − *callno = syscall_get_nr(target, regs); | |
| 31 | − if (*callno != -1L && maxargs > 0) | |
| 32 | − syscall_get_arguments(target, regs, 0, maxargs, args); | |
| 28 | + info->data.nr = syscall_get_nr(target, regs); | |
| 29 | + if (info->data.nr != -1L) | |
| 30 | + syscall_get_arguments(target, regs, | |
| 31 | + (unsigned long *)&info->data.args[0]); | |
| 33 | 32 | |
| 34 | 33 | put_task_stack(target); |
| 35 | 34 | return 0; |
| @@ -38,41 +37,35 @@ static int collect_syscall(struct task_struct *target, long *callno, · 2 unmodified lines | ||
| 38 | 37 | /** |
| 39 | 38 | * task_current_syscall - Discover what a blocked task is doing. |
| 40 | 39 | * @target: thread to examine |
| 41 | − * @callno: filled with system call number or -1 | |
| 42 | − * @args: filled with @maxargs system call arguments | |
| 43 | − * @maxargs: number of elements in @args to fill | |
| 44 | − * @sp: filled with user stack pointer | |
| 45 | − * @pc: filled with user PC | |
| 40 | + * @info: structure with the following fields: | |
| 41 | + * .sp - filled with user stack pointer | |
| 42 | + * .data.nr - filled with system call number or -1 | |
| 43 | + * .data.args - filled with @maxargs system call arguments | |
| 44 | + * .data.instruction_pointer - filled with user PC | |
| 46 | 45 | * |
| 47 | − * If @target is blocked in a system call, returns zero with *@callno | |
| 48 | − * set to the the call's number and @args filled in with its arguments. | |
| 49 | − * Registers not used for system call arguments may not be available and | |
| 50 | − * it is not kosher to use &struct user_regset calls while the system | |
| 46 | + * If @target is blocked in a system call, returns zero with @info.data.nr | |
| 47 | + * set to the the call's number and @info.data.args filled in with its | |
| 48 | + * arguments. Registers not used for system call arguments may not be available | |
| 49 | + * and it is not kosher to use &struct user_regset calls while the system | |
| 51 | 50 | * call is still in progress. Note we may get this result if @target |
| 52 | 51 | * has finished its system call but not yet returned to user mode, such |
| 53 | 52 | * as when it's stopped for signal handling or syscall exit tracing. |
| 54 | 53 | * |
| 55 | 54 | * If @target is blocked in the kernel during a fault or exception, |
| 56 | − * returns zero with *@callno set to -1 and does not fill in @args. | |
| 57 | − * If so, it's now safe to examine @target using &struct user_regset | |
| 58 | − * get() calls as long as we're sure @target won't return to user mode. | |
| 55 | + * returns zero with *@info.data.nr set to -1 and does not fill in | |
| 56 | + * @info.data.args. If so, it's now safe to examine @target using | |
| 57 | + * &struct user_regset get() calls as long as we're sure @target won't return | |
| 58 | + * to user mode. | |
| 59 | 59 | * |
| 60 | 60 | * Returns -%EAGAIN if @target does not remain blocked. |
| 61 | − * | |
| 62 | − * Returns -%EINVAL if @maxargs is too large (maximum is six). | |
| 63 | 61 | */ |
| 64 | −int task_current_syscall(struct task_struct *target, long *callno, | |
| 65 | − unsigned long args[6], unsigned int maxargs, | |
| 66 | − unsigned long *sp, unsigned long *pc) | |
| 62 | +int task_current_syscall(struct task_struct *target, struct syscall_info *info) | |
| 67 | 63 | { |
| 68 | 64 | long state; |
| 69 | 65 | unsigned long ncsw; |
| 70 | 66 | |
| 71 | − if (unlikely(maxargs > 6)) | |
| 72 | − return -EINVAL; | |
| 73 | − | |
| 74 | 67 | if (target == current) |
| 75 | − return collect_syscall(target, callno, args, maxargs, sp, pc); | |
| 68 | + return collect_syscall(target, info); | |
| 76 | 69 | |
| 77 | 70 | state = target->state; |
| 78 | 71 | if (unlikely(!state)) |
| @@ -80,7 +73,7 @@ int task_current_syscall(struct task_struct *target, long *callno, · 1 unmodified line | ||
| 80 | 73 | |
| 81 | 74 | ncsw = wait_task_inactive(target, state); |
| 82 | 75 | if (unlikely(!ncsw) || |
| 83 | − unlikely(collect_syscall(target, callno, args, maxargs, sp, pc)) || | |
| 76 | + unlikely(collect_syscall(target, info)) || | |
| 84 | 77 | unlikely(wait_task_inactive(target, state) != ncsw)) |
| 85 | 78 | return -EAGAIN; |
| 86 | 79 | |
| @@ -242,6 +242,7 @@ __reset_isolation_pfn(struct zone *zone, unsigned long pfn, bool check_source, · 241 unmodified lines | ||
| 242 | 242 | bool check_target) |
| 243 | 243 | { |
| 244 | 244 | struct page *page = pfn_to_online_page(pfn); |
| 245 | + struct page *block_page; | |
| 245 | 246 | struct page *end_page; |
| 246 | 247 | unsigned long block_pfn; |
| 247 | 248 | |
| @@ -267,20 +268,26 @@ __reset_isolation_pfn(struct zone *zone, unsigned long pfn, bool check_source, · 19 unmodified lines | ||
| 267 | 268 | get_pageblock_migratetype(page) != MIGRATE_MOVABLE) |
| 268 | 269 | return false; |
| 269 | 270 | |
| 271 | + /* Ensure the start of the pageblock or zone is online and valid */ | |
| 272 | + block_pfn = pageblock_start_pfn(pfn); | |
| 273 | + block_page = pfn_to_online_page(max(block_pfn, zone->zone_start_pfn)); | |
| 274 | + if (block_page) { | |
| 275 | + page = block_page; | |
| 276 | + pfn = block_pfn; | |
| 277 | + } | |
| 278 | + | |
| 279 | + /* Ensure the end of the pageblock or zone is online and valid */ | |
| 280 | + block_pfn += pageblock_nr_pages; | |
| 281 | + block_pfn = min(block_pfn, zone_end_pfn(zone) - 1); | |
| 282 | + end_page = pfn_to_online_page(block_pfn); | |
| 283 | + if (!end_page) | |
| 284 | + return false; | |
| 285 | + | |
| 270 | 286 | /* |
| 271 | 287 | * Only clear the hint if a sample indicates there is either a |
| 272 | 288 | * free page or an LRU page in the block. One or other condition |
| 273 | 289 | * is necessary for the block to be a migration source/target. |
| 274 | 290 | */ |
| 275 | − block_pfn = pageblock_start_pfn(pfn); | |
| 276 | − pfn = max(block_pfn, zone->zone_start_pfn); | |
| 277 | − page = pfn_to_page(pfn); | |
| 278 | − if (zone != page_zone(page)) | |
| 279 | − return false; | |
| 280 | − pfn = block_pfn + pageblock_nr_pages; | |
| 281 | − pfn = min(pfn, zone_end_pfn(zone)); | |
| 282 | − end_page = pfn_to_page(pfn); | |
| 283 | − | |
| 284 | 291 | do { |
| 285 | 292 | if (pfn_valid_within(pfn)) { |
| 286 | 293 | if (check_source && PageLRU(page)) { |
| @@ -309,7 +316,7 @@ __reset_isolation_pfn(struct zone *zone, unsigned long pfn, bool check_source, · 22 unmodified lines | ||
| 309 | 316 | static void __reset_isolation_suitable(struct zone *zone) |
| 310 | 317 | { |
| 311 | 318 | unsigned long migrate_pfn = zone->zone_start_pfn; |
| 312 | − unsigned long free_pfn = zone_end_pfn(zone); | |
| 319 | + unsigned long free_pfn = zone_end_pfn(zone) - 1; | |
| 313 | 320 | unsigned long reset_migrate = free_pfn; |
| 314 | 321 | unsigned long reset_free = migrate_pfn; |
| 315 | 322 | bool source_set = false; |
| @@ -1363,7 +1370,7 @@ fast_isolate_freepages(struct compact_control *cc) · 1047 unmodified lines | ||
| 1363 | 1370 | count_compact_events(COMPACTISOLATED, nr_isolated); |
| 1364 | 1371 | } else { |
| 1365 | 1372 | /* If isolation fails, abort the search */ |
| 1366 | − order = -1; | |
| 1373 | + order = cc->search_order + 1; | |
| 1367 | 1374 | page = NULL; |
| 1368 | 1375 | } |
| 1369 | 1376 | } |
| @@ -755,6 +755,21 @@ static void insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr, · 754 unmodified lines | ||
| 755 | 755 | spinlock_t *ptl; |
| 756 | 756 | |
| 757 | 757 | ptl = pmd_lock(mm, pmd); |
| 758 | + if (!pmd_none(*pmd)) { | |
| 759 | + if (write) { | |
| 760 | + if (pmd_pfn(*pmd) != pfn_t_to_pfn(pfn)) { | |
| 761 | + WARN_ON_ONCE(!is_huge_zero_pmd(*pmd)); | |
| 762 | + goto out_unlock; | |
| 763 | + } | |
| 764 | + entry = pmd_mkyoung(*pmd); | |
| 765 | + entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma); | |
| 766 | + if (pmdp_set_access_flags(vma, addr, pmd, entry, 1)) | |
| 767 | + update_mmu_cache_pmd(vma, addr, pmd); | |
| 768 | + } | |
| 769 | + | |
| 770 | + goto out_unlock; | |
| 771 | + } | |
| 772 | + | |
| 758 | 773 | entry = pmd_mkhuge(pfn_t_pmd(pfn, prot)); |
| 759 | 774 | if (pfn_t_devmap(pfn)) |
| 760 | 775 | entry = pmd_mkdevmap(entry); |
| @@ -766,11 +781,16 @@ static void insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr, · 5 unmodified lines | ||
| 766 | 781 | if (pgtable) { |
| 767 | 782 | pgtable_trans_huge_deposit(mm, pmd, pgtable); |
| 768 | 783 | mm_inc_nr_ptes(mm); |
| 784 | + pgtable = NULL; | |
| 769 | 785 | } |
| 770 | 786 | |
| 771 | 787 | set_pmd_at(mm, addr, pmd, entry); |
| 772 | 788 | update_mmu_cache_pmd(vma, addr, pmd); |
| 789 | + | |
| 790 | +out_unlock: | |
| 773 | 791 | spin_unlock(ptl); |
| 792 | + if (pgtable) | |
| 793 | + pte_free(mm, pgtable); | |
| 774 | 794 | } |
| 775 | 795 | |
| 776 | 796 | vm_fault_t vmf_insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr, |
| @@ -821,6 +841,20 @@ static void insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr, · 44 unmodified lines | ||
| 821 | 841 | spinlock_t *ptl; |
| 822 | 842 | |
| 823 | 843 | ptl = pud_lock(mm, pud); |
| 844 | + if (!pud_none(*pud)) { | |
| 845 | + if (write) { | |
| 846 | + if (pud_pfn(*pud) != pfn_t_to_pfn(pfn)) { | |
| 847 | + WARN_ON_ONCE(!is_huge_zero_pud(*pud)); | |
| 848 | + goto out_unlock; | |
| 849 | + } | |
| 850 | + entry = pud_mkyoung(*pud); | |
| 851 | + entry = maybe_pud_mkwrite(pud_mkdirty(entry), vma); | |
| 852 | + if (pudp_set_access_flags(vma, addr, pud, entry, 1)) | |
| 853 | + update_mmu_cache_pud(vma, addr, pud); | |
| 854 | + } | |
| 855 | + goto out_unlock; | |
| 856 | + } | |
| 857 | + | |
| 824 | 858 | entry = pud_mkhuge(pfn_t_pud(pfn, prot)); |
| 825 | 859 | if (pfn_t_devmap(pfn)) |
| 826 | 860 | entry = pud_mkdevmap(entry); |
| @@ -830,6 +864,8 @@ static void insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr, · 3 unmodified lines | ||
| 830 | 864 | } |
| 831 | 865 | set_pud_at(mm, addr, pud, entry); |
| 832 | 866 | update_mmu_cache_pud(vma, addr, pud); |
| 867 | + | |
| 868 | +out_unlock: | |
| 833 | 869 | spin_unlock(ptl); |
| 834 | 870 | } |
| 835 | 871 | |
| @@ -1529,11 +1529,6 @@ static void kmemleak_scan(void) · 1528 unmodified lines | ||
| 1529 | 1529 | } |
| 1530 | 1530 | rcu_read_unlock(); |
| 1531 | 1531 | |
| 1532 | − /* data/bss scanning */ | |
| 1533 | − scan_large_block(_sdata, _edata); | |
| 1534 | − scan_large_block(__bss_start, __bss_stop); | |
| 1535 | − scan_large_block(__start_ro_after_init, __end_ro_after_init); | |
| 1536 | − | |
| 1537 | 1532 | #ifdef CONFIG_SMP |
| 1538 | 1533 | /* per-cpu sections scanning */ |
| 1539 | 1534 | for_each_possible_cpu(i) |
| @@ -2071,6 +2066,17 @@ void __init kmemleak_init(void) · 531 unmodified lines | ||
| 2071 | 2066 | } |
| 2072 | 2067 | local_irq_restore(flags); |
| 2073 | 2068 | |
| 2069 | + /* register the data/bss sections */ | |
| 2070 | + create_object((unsigned long)_sdata, _edata - _sdata, | |
| 2071 | + KMEMLEAK_GREY, GFP_ATOMIC); | |
| 2072 | + create_object((unsigned long)__bss_start, __bss_stop - __bss_start, | |
| 2073 | + KMEMLEAK_GREY, GFP_ATOMIC); | |
| 2074 | + /* only register .data..ro_after_init if not within .data */ | |
| 2075 | + if (__start_ro_after_init < _sdata || __end_ro_after_init > _edata) | |
| 2076 | + create_object((unsigned long)__start_ro_after_init, | |
| 2077 | + __end_ro_after_init - __start_ro_after_init, | |
| 2078 | + KMEMLEAK_GREY, GFP_ATOMIC); | |
| 2079 | + | |
| 2074 | 2080 | /* |
| 2075 | 2081 | * This is the point where tracking allocations is safe. Automatic |
| 2076 | 2082 | * scanning is started during the late initcall. Add the early logged |
| @@ -3882,6 +3882,22 @@ struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb) · 3881 unmodified lines | ||
| 3882 | 3882 | return &memcg->cgwb_domain; |
| 3883 | 3883 | } |
| 3884 | 3884 | |
| 3885 | +/* | |
| 3886 | + * idx can be of type enum memcg_stat_item or node_stat_item. | |
| 3887 | + * Keep in sync with memcg_exact_page(). | |
| 3888 | + */ | |
| 3889 | +static unsigned long memcg_exact_page_state(struct mem_cgroup *memcg, int idx) | |
| 3890 | +{ | |
| 3891 | + long x = atomic_long_read(&memcg->stat[idx]); | |
| 3892 | + int cpu; | |
| 3893 | + | |
| 3894 | + for_each_online_cpu(cpu) | |
| 3895 | + x += per_cpu_ptr(memcg->stat_cpu, cpu)->count[idx]; | |
| 3896 | + if (x < 0) | |
| 3897 | + x = 0; | |
| 3898 | + return x; | |
| 3899 | +} | |
| 3900 | + | |
| 3885 | 3901 | /** |
| 3886 | 3902 | * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg |
| 3887 | 3903 | * @wb: bdi_writeback in question |
| @@ -3907,10 +3923,10 @@ void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages, · 19 unmodified lines | ||
| 3907 | 3923 | struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css); |
| 3908 | 3924 | struct mem_cgroup *parent; |
| 3909 | 3925 | |
| 3910 | − *pdirty = memcg_page_state(memcg, NR_FILE_DIRTY); | |
| 3926 | + *pdirty = memcg_exact_page_state(memcg, NR_FILE_DIRTY); | |
| 3911 | 3927 | |
| 3912 | 3928 | /* this should eventually include NR_UNSTABLE_NFS */ |
| 3913 | − *pwriteback = memcg_page_state(memcg, NR_WRITEBACK); | |
| 3929 | + *pwriteback = memcg_exact_page_state(memcg, NR_WRITEBACK); | |
| 3914 | 3930 | *pfilepages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) | |
| 3915 | 3931 | (1 << LRU_ACTIVE_FILE)); |
| 3916 | 3932 | *pheadroom = PAGE_COUNTER_MAX; |
| @@ -4308,7 +4308,8 @@ static void show_symbol(struct seq_file *m, unsigned long address) · 4307 unmodified lines | ||
| 4308 | 4308 | |
| 4309 | 4309 | static int leaks_show(struct seq_file *m, void *p) |
| 4310 | 4310 | { |
| 4311 | − struct kmem_cache *cachep = list_entry(p, struct kmem_cache, list); | |
| 4311 | + struct kmem_cache *cachep = list_entry(p, struct kmem_cache, | |
| 4312 | + root_caches_node); | |
| 4312 | 4313 | struct page *page; |
| 4313 | 4314 | struct kmem_cache_node *n; |
| 4314 | 4315 | const char *name; |
| @@ -204,7 +204,7 @@ EXPORT_SYMBOL(vmemdup_user); · 203 unmodified lines | ||
| 204 | 204 | * @s: The string to duplicate |
| 205 | 205 | * @n: Maximum number of bytes to copy, including the trailing NUL. |
| 206 | 206 | * |
| 207 | − * Return: newly allocated copy of @s or %NULL in case of error | |
| 207 | + * Return: newly allocated copy of @s or an ERR_PTR() in case of error | |
| 208 | 208 | */ |
| 209 | 209 | char *strndup_user(const char __user *s, long n) |
| 210 | 210 | { |
| @@ -443,27 +443,29 @@ static int vlan_dev_fcoe_disable(struct net_device *dev) · 442 unmodified lines | ||
| 443 | 443 | return rc; |
| 444 | 444 | } |
| 445 | 445 | |
| 446 | −static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type) | |
| 446 | +static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid, | |
| 447 | + struct scatterlist *sgl, unsigned int sgc) | |
| 447 | 448 | { |
| 448 | 449 | struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; |
| 449 | 450 | const struct net_device_ops *ops = real_dev->netdev_ops; |
| 450 | − int rc = -EINVAL; | |
| 451 | + int rc = 0; | |
| 452 | + | |
| 453 | + if (ops->ndo_fcoe_ddp_target) | |
| 454 | + rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc); | |
| 451 | 455 | |
| 452 | − if (ops->ndo_fcoe_get_wwn) | |
| 453 | − rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type); | |
| 454 | 456 | return rc; |
| 455 | 457 | } |
| 458 | +#endif | |
| 456 | 459 | |
| 457 | −static int vlan_dev_fcoe_ddp_target(struct net_device *dev, u16 xid, | |
| 458 | − struct scatterlist *sgl, unsigned int sgc) | |
| 460 | +#ifdef NETDEV_FCOE_WWNN | |
| 461 | +static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type) | |
| 459 | 462 | { |
| 460 | 463 | struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; |
| 461 | 464 | const struct net_device_ops *ops = real_dev->netdev_ops; |
| 462 | − int rc = 0; | |
| 463 | − | |
| 464 | − if (ops->ndo_fcoe_ddp_target) | |
| 465 | − rc = ops->ndo_fcoe_ddp_target(real_dev, xid, sgl, sgc); | |
| 465 | + int rc = -EINVAL; | |
| 466 | 466 | |
| 467 | + if (ops->ndo_fcoe_get_wwn) | |
| 468 | + rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type); | |
| 467 | 469 | return rc; |
| 468 | 470 | } |
| 469 | 471 | #endif |
| @@ -794,9 +796,11 @@ static const struct net_device_ops vlan_netdev_ops = { · 324 unmodified lines | ||
| 794 | 796 | .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, |
| 795 | 797 | .ndo_fcoe_enable = vlan_dev_fcoe_enable, |
| 796 | 798 | .ndo_fcoe_disable = vlan_dev_fcoe_disable, |
| 797 | − .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, | |
| 798 | 799 | .ndo_fcoe_ddp_target = vlan_dev_fcoe_ddp_target, |
| 799 | 800 | #endif |
| 801 | +#ifdef NETDEV_FCOE_WWNN | |
| 802 | + .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, | |
| 803 | +#endif | |
| 800 | 804 | #ifdef CONFIG_NET_POLL_CONTROLLER |
| 801 | 805 | .ndo_poll_controller = vlan_dev_poll_controller, |
| 802 | 806 | .ndo_netpoll_setup = vlan_dev_netpoll_setup, |
| @@ -104,8 +104,10 @@ static u32 batadv_v_elp_get_throughput(struct batadv_hardif_neigh_node *neigh) · 103 unmodified lines | ||
| 104 | 104 | |
| 105 | 105 | ret = cfg80211_get_station(real_netdev, neigh->addr, &sinfo); |
| 106 | 106 | |
| 107 | − /* free the TID stats immediately */ | |
| 108 | − cfg80211_sinfo_release_content(&sinfo); | |
| 107 | + if (!ret) { | |
| 108 | + /* free the TID stats immediately */ | |
| 109 | + cfg80211_sinfo_release_content(&sinfo); | |
| 110 | + } | |
| 109 | 111 | |
| 110 | 112 | dev_put(real_netdev); |
| 111 | 113 | if (ret == -ENOENT) { |
| @@ -803,6 +803,8 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv, · 802 unmodified lines | ||
| 803 | 803 | const u8 *mac, const unsigned short vid) |
| 804 | 804 | { |
| 805 | 805 | struct batadv_bla_claim search_claim, *claim; |
| 806 | + struct batadv_bla_claim *claim_removed_entry; | |
| 807 | + struct hlist_node *claim_removed_node; | |
| 806 | 808 | |
| 807 | 809 | ether_addr_copy(search_claim.addr, mac); |
| 808 | 810 | search_claim.vid = vid; |
| @@ -813,10 +815,18 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv, · 4 unmodified lines | ||
| 813 | 815 | batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__, |
| 814 | 816 | mac, batadv_print_vid(vid)); |
| 815 | 817 | |
| 816 | − batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim, | |
| 817 | − batadv_choose_claim, claim); | |
| 818 | − batadv_claim_put(claim); /* reference from the hash is gone */ | |
| 818 | + claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash, | |
| 819 | + batadv_compare_claim, | |
| 820 | + batadv_choose_claim, claim); | |
| 821 | + if (!claim_removed_node) | |
| 822 | + goto free_claim; | |
| 819 | 823 | |
| 824 | + /* reference from the hash is gone */ | |
| 825 | + claim_removed_entry = hlist_entry(claim_removed_node, | |
| 826 | + struct batadv_bla_claim, hash_entry); | |
| 827 | + batadv_claim_put(claim_removed_entry); | |
| 828 | + | |
| 829 | +free_claim: | |
| 820 | 830 | /* don't need the reference from hash_find() anymore */ |
| 821 | 831 | batadv_claim_put(claim); |
| 822 | 832 | } |
| @@ -1116,9 +1116,9 @@ static ssize_t batadv_store_throughput_override(struct kobject *kobj, · 1115 unmodified lines | ||
| 1116 | 1116 | struct attribute *attr, |
| 1117 | 1117 | char *buff, size_t count) |
| 1118 | 1118 | { |
| 1119 | − struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); | |
| 1120 | 1119 | struct net_device *net_dev = batadv_kobj_to_netdev(kobj); |
| 1121 | 1120 | struct batadv_hard_iface *hard_iface; |
| 1121 | + struct batadv_priv *bat_priv; | |
| 1122 | 1122 | u32 tp_override; |
| 1123 | 1123 | u32 old_tp_override; |
| 1124 | 1124 | bool ret; |
| @@ -1147,7 +1147,10 @@ static ssize_t batadv_store_throughput_override(struct kobject *kobj, · 22 unmodified lines | ||
| 1147 | 1147 | |
| 1148 | 1148 | atomic_set(&hard_iface->bat_v.throughput_override, tp_override); |
| 1149 | 1149 | |
| 1150 | − batadv_netlink_notify_hardif(bat_priv, hard_iface); | |
| 1150 | + if (hard_iface->soft_iface) { | |
| 1151 | + bat_priv = netdev_priv(hard_iface->soft_iface); | |
| 1152 | + batadv_netlink_notify_hardif(bat_priv, hard_iface); | |
| 1153 | + } | |
| 1151 | 1154 | |
| 1152 | 1155 | out: |
| 1153 | 1156 | batadv_hardif_put(hard_iface); |
| @@ -616,14 +616,26 @@ static void batadv_tt_global_free(struct batadv_priv *bat_priv, · 615 unmodified lines | ||
| 616 | 616 | struct batadv_tt_global_entry *tt_global, |
| 617 | 617 | const char *message) |
| 618 | 618 | { |
| 619 | + struct batadv_tt_global_entry *tt_removed_entry; | |
| 620 | + struct hlist_node *tt_removed_node; | |
| 621 | + | |
| 619 | 622 | batadv_dbg(BATADV_DBG_TT, bat_priv, |
| 620 | 623 | "Deleting global tt entry %pM (vid: %d): %s\n", |
| 621 | 624 | tt_global->common.addr, |
| 622 | 625 | batadv_print_vid(tt_global->common.vid), message); |
| 623 | 626 | |
| 624 | − batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt, | |
| 625 | − batadv_choose_tt, &tt_global->common); | |
| 626 | − batadv_tt_global_entry_put(tt_global); | |
| 627 | + tt_removed_node = batadv_hash_remove(bat_priv->tt.global_hash, | |
| 628 | + batadv_compare_tt, | |
| 629 | + batadv_choose_tt, | |
| 630 | + &tt_global->common); | |
| 631 | + if (!tt_removed_node) | |
| 632 | + return; | |
| 633 | + | |
| 634 | + /* drop reference of remove hash entry */ | |
| 635 | + tt_removed_entry = hlist_entry(tt_removed_node, | |
| 636 | + struct batadv_tt_global_entry, | |
| 637 | + common.hash_entry); | |
| 638 | + batadv_tt_global_entry_put(tt_removed_entry); | |
| 627 | 639 | } |
| 628 | 640 | |
| 629 | 641 | /** |
| @@ -1337,9 +1349,10 @@ u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, · 707 unmodified lines | ||
| 1337 | 1349 | unsigned short vid, const char *message, |
| 1338 | 1350 | bool roaming) |
| 1339 | 1351 | { |
| 1352 | + struct batadv_tt_local_entry *tt_removed_entry; | |
| 1340 | 1353 | struct batadv_tt_local_entry *tt_local_entry; |
| 1341 | 1354 | u16 flags, curr_flags = BATADV_NO_FLAGS; |
| 1342 | − void *tt_entry_exists; | |
| 1355 | + struct hlist_node *tt_removed_node; | |
| 1343 | 1356 | |
| 1344 | 1357 | tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); |
| 1345 | 1358 | if (!tt_local_entry) |
| @@ -1368,15 +1381,18 @@ u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, · 22 unmodified lines | ||
| 1368 | 1381 | */ |
| 1369 | 1382 | batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL); |
| 1370 | 1383 | |
| 1371 | − tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash, | |
| 1384 | + tt_removed_node = batadv_hash_remove(bat_priv->tt.local_hash, | |
| 1372 | 1385 | batadv_compare_tt, |
| 1373 | 1386 | batadv_choose_tt, |
| 1374 | 1387 | &tt_local_entry->common); |
| 1375 | − if (!tt_entry_exists) | |
| 1388 | + if (!tt_removed_node) | |
| 1376 | 1389 | goto out; |
| 1377 | 1390 | |
| 1378 | − /* extra call to free the local tt entry */ | |
| 1379 | − batadv_tt_local_entry_put(tt_local_entry); | |
| 1391 | + /* drop reference of remove hash entry */ | |
| 1392 | + tt_removed_entry = hlist_entry(tt_removed_node, | |
| 1393 | + struct batadv_tt_local_entry, | |
| 1394 | + common.hash_entry); | |
| 1395 | + batadv_tt_local_entry_put(tt_removed_entry); | |
| 1380 | 1396 | |
| 1381 | 1397 | out: |
| 1382 | 1398 | if (tt_local_entry) |
| @@ -601,6 +601,7 @@ static int br_ip4_multicast_add_group(struct net_bridge *br, · 600 unmodified lines | ||
| 601 | 601 | if (ipv4_is_local_multicast(group)) |
| 602 | 602 | return 0; |
| 603 | 603 | |
| 604 | + memset(&br_group, 0, sizeof(br_group)); | |
| 604 | 605 | br_group.u.ip4 = group; |
| 605 | 606 | br_group.proto = htons(ETH_P_IP); |
| 606 | 607 | br_group.vid = vid; |
| @@ -1497,6 +1498,7 @@ static void br_ip4_multicast_leave_group(struct net_bridge *br, · 890 unmodified lines | ||
| 1497 | 1498 | |
| 1498 | 1499 | own_query = port ? &port->ip4_own_query : &br->ip4_own_query; |
| 1499 | 1500 | |
| 1501 | + memset(&br_group, 0, sizeof(br_group)); | |
| 1500 | 1502 | br_group.u.ip4 = group; |
| 1501 | 1503 | br_group.proto = htons(ETH_P_IP); |
| 1502 | 1504 | br_group.vid = vid; |
| @@ -1520,6 +1522,7 @@ static void br_ip6_multicast_leave_group(struct net_bridge *br, · 17 unmodified lines | ||
| 1520 | 1522 | |
| 1521 | 1523 | own_query = port ? &port->ip6_own_query : &br->ip6_own_query; |
| 1522 | 1524 | |
| 1525 | + memset(&br_group, 0, sizeof(br_group)); | |
| 1523 | 1526 | br_group.u.ip6 = *group; |
| 1524 | 1527 | br_group.proto = htons(ETH_P_IPV6); |
| 1525 | 1528 | br_group.vid = vid; |
| @@ -279,7 +279,7 @@ struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned int flags, · 278 unmodified lines | ||
| 279 | 279 | break; |
| 280 | 280 | |
| 281 | 281 | sk_busy_loop(sk, flags & MSG_DONTWAIT); |
| 282 | − } while (!skb_queue_empty(&sk->sk_receive_queue)); | |
| 282 | + } while (sk->sk_receive_queue.prev != *last); | |
| 283 | 283 | |
| 284 | 284 | error = -EAGAIN; |
| 285 | 285 | |
| @@ -5014,8 +5014,10 @@ static inline void __netif_receive_skb_list_ptype(struct list_head *head, · 5013 unmodified lines | ||
| 5014 | 5014 | if (pt_prev->list_func != NULL) |
| 5015 | 5015 | pt_prev->list_func(head, pt_prev, orig_dev); |
| 5016 | 5016 | else |
| 5017 | − list_for_each_entry_safe(skb, next, head, list) | |
| 5017 | + list_for_each_entry_safe(skb, next, head, list) { | |
| 5018 | + skb_list_del_init(skb); | |
| 5018 | 5019 | pt_prev->func(skb, skb->dev, pt_prev, orig_dev); |
| 5020 | + } | |
| 5019 | 5021 | } |
| 5020 | 5022 | |
| 5021 | 5023 | static void __netif_receive_skb_list_core(struct list_head *head, bool pfmemalloc) |
| @@ -1797,11 +1797,16 @@ static int ethtool_get_strings(struct net_device *dev, void __user *useraddr) · 1796 unmodified lines | ||
| 1797 | 1797 | WARN_ON_ONCE(!ret); |
| 1798 | 1798 | |
| 1799 | 1799 | gstrings.len = ret; |
| 1800 | − data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN)); | |
| 1801 | − if (gstrings.len && !data) | |
| 1802 | − return -ENOMEM; | |
| 1803 | 1800 | |
| 1804 | − __ethtool_get_strings(dev, gstrings.string_set, data); | |
| 1801 | + if (gstrings.len) { | |
| 1802 | + data = vzalloc(array_size(gstrings.len, ETH_GSTRING_LEN)); | |
| 1803 | + if (!data) | |
| 1804 | + return -ENOMEM; | |
| 1805 | + | |
| 1806 | + __ethtool_get_strings(dev, gstrings.string_set, data); | |
| 1807 | + } else { | |
| 1808 | + data = NULL; | |
| 1809 | + } | |
| 1805 | 1810 | |
| 1806 | 1811 | ret = -EFAULT; |
| 1807 | 1812 | if (copy_to_user(useraddr, &gstrings, sizeof(gstrings))) |
| @@ -1897,11 +1902,15 @@ static int ethtool_get_stats(struct net_device *dev, void __user *useraddr) · 89 unmodified lines | ||
| 1897 | 1902 | return -EFAULT; |
| 1898 | 1903 | |
| 1899 | 1904 | stats.n_stats = n_stats; |
| 1900 | − data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 1901 | − if (n_stats && !data) | |
| 1902 | − return -ENOMEM; | |
| 1903 | 1905 | |
| 1904 | − ops->get_ethtool_stats(dev, &stats, data); | |
| 1906 | + if (n_stats) { | |
| 1907 | + data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 1908 | + if (!data) | |
| 1909 | + return -ENOMEM; | |
| 1910 | + ops->get_ethtool_stats(dev, &stats, data); | |
| 1911 | + } else { | |
| 1912 | + data = NULL; | |
| 1913 | + } | |
| 1905 | 1914 | |
| 1906 | 1915 | ret = -EFAULT; |
| 1907 | 1916 | if (copy_to_user(useraddr, &stats, sizeof(stats))) |
| @@ -1941,16 +1950,21 @@ static int ethtool_get_phy_stats(struct net_device *dev, void __user *useraddr) · 33 unmodified lines | ||
| 1941 | 1950 | return -EFAULT; |
| 1942 | 1951 | |
| 1943 | 1952 | stats.n_stats = n_stats; |
| 1944 | − data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 1945 | − if (n_stats && !data) | |
| 1946 | − return -ENOMEM; | |
| 1947 | 1953 | |
| 1948 | − if (dev->phydev && !ops->get_ethtool_phy_stats) { | |
| 1949 | − ret = phy_ethtool_get_stats(dev->phydev, &stats, data); | |
| 1950 | − if (ret < 0) | |
| 1951 | − return ret; | |
| 1954 | + if (n_stats) { | |
| 1955 | + data = vzalloc(array_size(n_stats, sizeof(u64))); | |
| 1956 | + if (!data) | |
| 1957 | + return -ENOMEM; | |
| 1958 | + | |
| 1959 | + if (dev->phydev && !ops->get_ethtool_phy_stats) { | |
| 1960 | + ret = phy_ethtool_get_stats(dev->phydev, &stats, data); | |
| 1961 | + if (ret < 0) | |
| 1962 | + goto out; | |
| 1963 | + } else { | |
| 1964 | + ops->get_ethtool_phy_stats(dev, &stats, data); | |
| 1965 | + } | |
| 1952 | 1966 | } else { |
| 1953 | − ops->get_ethtool_phy_stats(dev, &stats, data); | |
| 1967 | + data = NULL; | |
| 1954 | 1968 | } |
| 1955 | 1969 | |
| 1956 | 1970 | ret = -EFAULT; |
| @@ -6613,14 +6613,8 @@ static bool flow_dissector_is_valid_access(int off, int size, · 6612 unmodified lines | ||
| 6613 | 6613 | const struct bpf_prog *prog, |
| 6614 | 6614 | struct bpf_insn_access_aux *info) |
| 6615 | 6615 | { |
| 6616 | − if (type == BPF_WRITE) { | |
| 6617 | − switch (off) { | |
| 6618 | − case bpf_ctx_range_till(struct __sk_buff, cb[0], cb[4]): | |
| 6619 | − break; | |
| 6620 | − default: | |
| 6621 | − return false; | |
| 6622 | − } | |
| 6623 | − } | |
| 6616 | + if (type == BPF_WRITE) | |
| 6617 | + return false; | |
| 6624 | 6618 | |
| 6625 | 6619 | switch (off) { |
| 6626 | 6620 | case bpf_ctx_range(struct __sk_buff, data): |
| @@ -6632,11 +6626,7 @@ static bool flow_dissector_is_valid_access(int off, int size, · 5 unmodified lines | ||
| 6632 | 6626 | case bpf_ctx_range_ptr(struct __sk_buff, flow_keys): |
| 6633 | 6627 | info->reg_type = PTR_TO_FLOW_KEYS; |
| 6634 | 6628 | break; |
| 6635 | − case bpf_ctx_range(struct __sk_buff, tc_classid): | |
| 6636 | − case bpf_ctx_range(struct __sk_buff, data_meta): | |
| 6637 | − case bpf_ctx_range_till(struct __sk_buff, family, local_port): | |
| 6638 | − case bpf_ctx_range(struct __sk_buff, tstamp): | |
| 6639 | − case bpf_ctx_range(struct __sk_buff, wire_len): | |
| 6629 | + default: | |
| 6640 | 6630 | return false; |
| 6641 | 6631 | } |
| 6642 | 6632 | |
| @@ -707,6 +707,7 @@ bool __skb_flow_bpf_dissect(struct bpf_prog *prog, · 706 unmodified lines | ||
| 707 | 707 | /* Pass parameters to the BPF program */ |
| 708 | 708 | memset(flow_keys, 0, sizeof(*flow_keys)); |
| 709 | 709 | cb->qdisc_cb.flow_keys = flow_keys; |
| 710 | + flow_keys->n_proto = skb->protocol; | |
| 710 | 711 | flow_keys->nhoff = skb_network_offset(skb); |
| 711 | 712 | flow_keys->thoff = flow_keys->nhoff; |
| 712 | 713 | |
| @@ -716,7 +717,8 @@ bool __skb_flow_bpf_dissect(struct bpf_prog *prog, · 3 unmodified lines | ||
| 716 | 717 | /* Restore state */ |
| 717 | 718 | memcpy(cb, &cb_saved, sizeof(cb_saved)); |
| 718 | 719 | |
| 719 | − flow_keys->nhoff = clamp_t(u16, flow_keys->nhoff, 0, skb->len); | |
| 720 | + flow_keys->nhoff = clamp_t(u16, flow_keys->nhoff, | |
| 721 | + skb_network_offset(skb), skb->len); | |
| 720 | 722 | flow_keys->thoff = clamp_t(u16, flow_keys->thoff, |
| 721 | 723 | flow_keys->nhoff, skb->len); |
| 722 | 724 | |
| @@ -304,6 +304,7 @@ static __net_init int setup_net(struct net *net, struct user_namespace *user_ns) · 303 unmodified lines | ||
| 304 | 304 | |
| 305 | 305 | refcount_set(&net->count, 1); |
| 306 | 306 | refcount_set(&net->passive, 1); |
| 307 | + get_random_bytes(&net->hash_mix, sizeof(u32)); | |
| 307 | 308 | net->dev_base_seq = 1; |
| 308 | 309 | net->user_ns = user_ns; |
| 309 | 310 | idr_init(&net->netns_ids); |
| @@ -3801,7 +3801,7 @@ int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb) · 3800 unmodified lines | ||
| 3801 | 3801 | unsigned int delta_truesize; |
| 3802 | 3802 | struct sk_buff *lp; |
| 3803 | 3803 | |
| 3804 | − if (unlikely(p->len + len >= 65536)) | |
| 3804 | + if (unlikely(p->len + len >= 65536 || NAPI_GRO_CB(skb)->flush)) | |
| 3805 | 3805 | return -E2BIG; |
| 3806 | 3806 | |
| 3807 | 3807 | lp = NAPI_GRO_CB(p)->last; |
| @@ -738,7 +738,12 @@ static int __feat_register_sp(struct list_head *fn, u8 feat, u8 is_local, · 737 unmodified lines | ||
| 738 | 738 | if (dccp_feat_clone_sp_val(&fval, sp_val, sp_len)) |
| 739 | 739 | return -ENOMEM; |
| 740 | 740 | |
| 741 | − return dccp_feat_push_change(fn, feat, is_local, mandatory, &fval); | |
| 741 | + if (dccp_feat_push_change(fn, feat, is_local, mandatory, &fval)) { | |
| 742 | + kfree(fval.sp.vec); | |
| 743 | + return -ENOMEM; | |
| 744 | + } | |
| 745 | + | |
| 746 | + return 0; | |
| 742 | 747 | } |
| 743 | 748 | |
| 744 | 749 | /** |
| @@ -98,8 +98,18 @@ static struct sk_buff *qca_tag_rcv(struct sk_buff *skb, struct net_device *dev, · 97 unmodified lines | ||
| 98 | 98 | return skb; |
| 99 | 99 | } |
| 100 | 100 | |
| 101 | +static int qca_tag_flow_dissect(const struct sk_buff *skb, __be16 *proto, | |
| 102 | + int *offset) | |
| 103 | +{ | |
| 104 | + *offset = QCA_HDR_LEN; | |
| 105 | + *proto = ((__be16 *)skb->data)[0]; | |
| 106 | + | |
| 107 | + return 0; | |
| 108 | +} | |
| 109 | + | |
| 101 | 110 | const struct dsa_device_ops qca_netdev_ops = { |
| 102 | 111 | .xmit = qca_tag_xmit, |
| 103 | 112 | .rcv = qca_tag_rcv, |
| 113 | + .flow_dissect = qca_tag_flow_dissect, | |
| 104 | 114 | .overhead = QCA_HDR_LEN, |
| 105 | 115 | }; |
| @@ -259,7 +259,6 @@ static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, · 258 unmodified lines | ||
| 259 | 259 | struct net *net = dev_net(skb->dev); |
| 260 | 260 | struct metadata_dst *tun_dst = NULL; |
| 261 | 261 | struct erspan_base_hdr *ershdr; |
| 262 | − struct erspan_metadata *pkt_md; | |
| 263 | 262 | struct ip_tunnel_net *itn; |
| 264 | 263 | struct ip_tunnel *tunnel; |
| 265 | 264 | const struct iphdr *iph; |
| @@ -282,9 +281,6 @@ static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, · 16 unmodified lines | ||
| 282 | 281 | if (unlikely(!pskb_may_pull(skb, len))) |
| 283 | 282 | return PACKET_REJECT; |
| 284 | 283 | |
| 285 | − ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len); | |
| 286 | − pkt_md = (struct erspan_metadata *)(ershdr + 1); | |
| 287 | − | |
| 288 | 284 | if (__iptunnel_pull_header(skb, |
| 289 | 285 | len, |
| 290 | 286 | htons(ETH_P_TEB), |
| @@ -292,8 +288,9 @@ static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, · 1 unmodified line | ||
| 292 | 288 | goto drop; |
| 293 | 289 | |
| 294 | 290 | if (tunnel->collect_md) { |
| 291 | + struct erspan_metadata *pkt_md, *md; | |
| 295 | 292 | struct ip_tunnel_info *info; |
| 296 | − struct erspan_metadata *md; | |
| 293 | + unsigned char *gh; | |
| 297 | 294 | __be64 tun_id; |
| 298 | 295 | __be16 flags; |
| 299 | 296 | |
| @@ -306,6 +303,14 @@ static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, · 6 unmodified lines | ||
| 306 | 303 | if (!tun_dst) |
| 307 | 304 | return PACKET_REJECT; |
| 308 | 305 | |
| 306 | + /* skb can be uncloned in __iptunnel_pull_header, so | |
| 307 | + * old pkt_md is no longer valid and we need to reset | |
| 308 | + * it | |
| 309 | + */ | |
| 310 | + gh = skb_network_header(skb) + | |
| 311 | + skb_network_header_len(skb); | |
| 312 | + pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len + | |
| 313 | + sizeof(*ershdr)); | |
| 309 | 314 | md = ip_tunnel_info_opts(&tun_dst->u.tun_info); |
| 310 | 315 | md->version = ver; |
| 311 | 316 | md2 = &md->u.md2; |
| @@ -257,11 +257,10 @@ int ip_local_deliver(struct sk_buff *skb) · 256 unmodified lines | ||
| 257 | 257 | ip_local_deliver_finish); |
| 258 | 258 | } |
| 259 | 259 | |
| 260 | −static inline bool ip_rcv_options(struct sk_buff *skb) | |
| 260 | +static inline bool ip_rcv_options(struct sk_buff *skb, struct net_device *dev) | |
| 261 | 261 | { |
| 262 | 262 | struct ip_options *opt; |
| 263 | 263 | const struct iphdr *iph; |
| 264 | − struct net_device *dev = skb->dev; | |
| 265 | 264 | |
| 266 | 265 | /* It looks as overkill, because not all |
| 267 | 266 | IP options require packet mangling. |
| @@ -297,7 +296,7 @@ static inline bool ip_rcv_options(struct sk_buff *skb) · 29 unmodified lines | ||
| 297 | 296 | } |
| 298 | 297 | } |
| 299 | 298 | |
| 300 | − if (ip_options_rcv_srr(skb)) | |
| 299 | + if (ip_options_rcv_srr(skb, dev)) | |
| 301 | 300 | goto drop; |
| 302 | 301 | } |
| 303 | 302 | |
| @@ -353,7 +352,7 @@ static int ip_rcv_finish_core(struct net *net, struct sock *sk, · 49 unmodified lines | ||
| 353 | 352 | } |
| 354 | 353 | #endif |
| 355 | 354 | |
| 356 | − if (iph->ihl > 5 && ip_rcv_options(skb)) | |
| 355 | + if (iph->ihl > 5 && ip_rcv_options(skb, dev)) | |
| 357 | 356 | goto drop; |
| 358 | 357 | |
| 359 | 358 | rt = skb_rtable(skb); |
| @@ -612,7 +612,7 @@ void ip_forward_options(struct sk_buff *skb) · 611 unmodified lines | ||
| 612 | 612 | } |
| 613 | 613 | } |
| 614 | 614 | |
| 615 | −int ip_options_rcv_srr(struct sk_buff *skb) | |
| 615 | +int ip_options_rcv_srr(struct sk_buff *skb, struct net_device *dev) | |
| 616 | 616 | { |
| 617 | 617 | struct ip_options *opt = &(IPCB(skb)->opt); |
| 618 | 618 | int srrspace, srrptr; |
| @@ -647,7 +647,7 @@ int ip_options_rcv_srr(struct sk_buff *skb) · 28 unmodified lines | ||
| 647 | 647 | |
| 648 | 648 | orefdst = skb->_skb_refdst; |
| 649 | 649 | skb_dst_set(skb, NULL); |
| 650 | − err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev); | |
| 650 | + err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, dev); | |
| 651 | 651 | rt2 = skb_rtable(skb); |
| 652 | 652 | if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) { |
| 653 | 653 | skb_dst_drop(skb); |
| @@ -67,11 +67,6 @@ static unsigned int dctcp_alpha_on_init __read_mostly = DCTCP_MAX_ALPHA; · 66 unmodified lines | ||
| 67 | 67 | module_param(dctcp_alpha_on_init, uint, 0644); |
| 68 | 68 | MODULE_PARM_DESC(dctcp_alpha_on_init, "parameter for initial alpha value"); |
| 69 | 69 | |
| 70 | −static unsigned int dctcp_clamp_alpha_on_loss __read_mostly; | |
| 71 | −module_param(dctcp_clamp_alpha_on_loss, uint, 0644); | |
| 72 | −MODULE_PARM_DESC(dctcp_clamp_alpha_on_loss, | |
| 73 | − "parameter for clamping alpha on loss"); | |
| 74 | − | |
| 75 | 70 | static struct tcp_congestion_ops dctcp_reno; |
| 76 | 71 | |
| 77 | 72 | static void dctcp_reset(const struct tcp_sock *tp, struct dctcp *ca) |
| @@ -164,21 +159,23 @@ static void dctcp_update_alpha(struct sock *sk, u32 flags) · 86 unmodified lines | ||
| 164 | 159 | } |
| 165 | 160 | } |
| 166 | 161 | |
| 167 | −static void dctcp_state(struct sock *sk, u8 new_state) | |
| 162 | +static void dctcp_react_to_loss(struct sock *sk) | |
| 168 | 163 | { |
| 169 | − if (dctcp_clamp_alpha_on_loss && new_state == TCP_CA_Loss) { | |
| 170 | − struct dctcp *ca = inet_csk_ca(sk); | |
| 164 | + struct dctcp *ca = inet_csk_ca(sk); | |
| 165 | + struct tcp_sock *tp = tcp_sk(sk); | |
| 171 | 166 | |
| 172 | − /* If this extension is enabled, we clamp dctcp_alpha to | |
| 173 | − * max on packet loss; the motivation is that dctcp_alpha | |
| 174 | − * is an indicator to the extend of congestion and packet | |
| 175 | − * loss is an indicator of extreme congestion; setting | |
| 176 | − * this in practice turned out to be beneficial, and | |
| 177 | − * effectively assumes total congestion which reduces the | |
| 178 | − * window by half. | |
| 179 | − */ | |
| 180 | − ca->dctcp_alpha = DCTCP_MAX_ALPHA; | |
| 181 | − } | |
| 167 | + ca->loss_cwnd = tp->snd_cwnd; | |
| 168 | + tp->snd_ssthresh = max(tp->snd_cwnd >> 1U, 2U); | |
| 169 | +} | |
| 170 | + | |
| 171 | +static void dctcp_state(struct sock *sk, u8 new_state) | |
| 172 | +{ | |
| 173 | + if (new_state == TCP_CA_Recovery && | |
| 174 | + new_state != inet_csk(sk)->icsk_ca_state) | |
| 175 | + dctcp_react_to_loss(sk); | |
| 176 | + /* We handle RTO in dctcp_cwnd_event to ensure that we perform only | |
| 177 | + * one loss-adjustment per RTT. | |
| 178 | + */ | |
| 182 | 179 | } |
| 183 | 180 | |
| 184 | 181 | static void dctcp_cwnd_event(struct sock *sk, enum tcp_ca_event ev) |
| @@ -190,6 +187,9 @@ static void dctcp_cwnd_event(struct sock *sk, enum tcp_ca_event ev) · 5 unmodified lines | ||
| 190 | 187 | case CA_EVENT_ECN_NO_CE: |
| 191 | 188 | dctcp_ece_ack_update(sk, ev, &ca->prior_rcv_nxt, &ca->ce_state); |
| 192 | 189 | break; |
| 190 | + case CA_EVENT_LOSS: | |
| 191 | + dctcp_react_to_loss(sk); | |
| 192 | + break; | |
| 193 | 193 | default: |
| 194 | 194 | /* Don't care for the rest. */ |
| 195 | 195 | break; |
| @@ -2578,7 +2578,8 @@ static void __net_exit tcp_sk_exit(struct net *net) · 2577 unmodified lines | ||
| 2578 | 2578 | { |
| 2579 | 2579 | int cpu; |
| 2580 | 2580 | |
| 2581 | − module_put(net->ipv4.tcp_congestion_control->owner); | |
| 2581 | + if (net->ipv4.tcp_congestion_control) | |
| 2582 | + module_put(net->ipv4.tcp_congestion_control->owner); | |
| 2582 | 2583 | |
| 2583 | 2584 | for_each_possible_cpu(cpu) |
| 2584 | 2585 | inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.tcp_sk, cpu)); |
| @@ -417,6 +417,7 @@ int ila_xlat_nl_cmd_flush(struct sk_buff *skb, struct genl_info *info) · 416 unmodified lines | ||
| 417 | 417 | |
| 418 | 418 | done: |
| 419 | 419 | rhashtable_walk_stop(&iter); |
| 420 | + rhashtable_walk_exit(&iter); | |
| 420 | 421 | return ret; |
| 421 | 422 | } |
| 422 | 423 | |
| @@ -525,10 +525,10 @@ static int ip6gre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi) · 524 unmodified lines | ||
| 525 | 525 | } |
| 526 | 526 | |
| 527 | 527 | static int ip6erspan_rcv(struct sk_buff *skb, |
| 528 | − struct tnl_ptk_info *tpi) | |
| 528 | + struct tnl_ptk_info *tpi, | |
| 529 | + int gre_hdr_len) | |
| 529 | 530 | { |
| 530 | 531 | struct erspan_base_hdr *ershdr; |
| 531 | − struct erspan_metadata *pkt_md; | |
| 532 | 532 | const struct ipv6hdr *ipv6h; |
| 533 | 533 | struct erspan_md2 *md2; |
| 534 | 534 | struct ip6_tnl *tunnel; |
| @@ -547,18 +547,16 @@ static int ip6erspan_rcv(struct sk_buff *skb, · 12 unmodified lines | ||
| 547 | 547 | if (unlikely(!pskb_may_pull(skb, len))) |
| 548 | 548 | return PACKET_REJECT; |
| 549 | 549 | |
| 550 | − ershdr = (struct erspan_base_hdr *)skb->data; | |
| 551 | − pkt_md = (struct erspan_metadata *)(ershdr + 1); | |
| 552 | − | |
| 553 | 550 | if (__iptunnel_pull_header(skb, len, |
| 554 | 551 | htons(ETH_P_TEB), |
| 555 | 552 | false, false) < 0) |
| 556 | 553 | return PACKET_REJECT; |
| 557 | 554 | |
| 558 | 555 | if (tunnel->parms.collect_md) { |
| 556 | + struct erspan_metadata *pkt_md, *md; | |
| 559 | 557 | struct metadata_dst *tun_dst; |
| 560 | 558 | struct ip_tunnel_info *info; |
| 561 | − struct erspan_metadata *md; | |
| 559 | + unsigned char *gh; | |
| 562 | 560 | __be64 tun_id; |
| 563 | 561 | __be16 flags; |
| 564 | 562 | |
| @@ -571,6 +569,14 @@ static int ip6erspan_rcv(struct sk_buff *skb, · 6 unmodified lines | ||
| 571 | 569 | if (!tun_dst) |
| 572 | 570 | return PACKET_REJECT; |
| 573 | 571 | |
| 572 | + /* skb can be uncloned in __iptunnel_pull_header, so | |
| 573 | + * old pkt_md is no longer valid and we need to reset | |
| 574 | + * it | |
| 575 | + */ | |
| 576 | + gh = skb_network_header(skb) + | |
| 577 | + skb_network_header_len(skb); | |
| 578 | + pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len + | |
| 579 | + sizeof(*ershdr)); | |
| 574 | 580 | info = &tun_dst->u.tun_info; |
| 575 | 581 | md = ip_tunnel_info_opts(info); |
| 576 | 582 | md->version = ver; |
| @@ -607,7 +613,7 @@ static int gre_rcv(struct sk_buff *skb) · 30 unmodified lines | ||
| 607 | 613 | |
| 608 | 614 | if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) || |
| 609 | 615 | tpi.proto == htons(ETH_P_ERSPAN2))) { |
| 610 | − if (ip6erspan_rcv(skb, &tpi) == PACKET_RCVD) | |
| 616 | + if (ip6erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD) | |
| 611 | 617 | return 0; |
| 612 | 618 | goto out; |
| 613 | 619 | } |
| @@ -601,7 +601,7 @@ int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, · 600 unmodified lines | ||
| 601 | 601 | inet6_sk(skb->sk) : NULL; |
| 602 | 602 | struct ipv6hdr *tmp_hdr; |
| 603 | 603 | struct frag_hdr *fh; |
| 604 | − unsigned int mtu, hlen, left, len; | |
| 604 | + unsigned int mtu, hlen, left, len, nexthdr_offset; | |
| 605 | 605 | int hroom, troom; |
| 606 | 606 | __be32 frag_id; |
| 607 | 607 | int ptr, offset = 0, err = 0; |
| @@ -612,6 +612,7 @@ int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, · 4 unmodified lines | ||
| 612 | 612 | goto fail; |
| 613 | 613 | hlen = err; |
| 614 | 614 | nexthdr = *prevhdr; |
| 615 | + nexthdr_offset = prevhdr - skb_network_header(skb); | |
| 615 | 616 | |
| 616 | 617 | mtu = ip6_skb_dst_mtu(skb); |
| 617 | 618 | |
| @@ -646,6 +647,7 @@ int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, · 28 unmodified lines | ||
| 646 | 647 | (err = skb_checksum_help(skb))) |
| 647 | 648 | goto fail; |
| 648 | 649 | |
| 650 | + prevhdr = skb_network_header(skb) + nexthdr_offset; | |
| 649 | 651 | hroom = LL_RESERVED_SPACE(rt->dst.dev); |
| 650 | 652 | if (skb_has_frag_list(skb)) { |
| 651 | 653 | unsigned int first_len = skb_pagelen(skb); |
| @@ -627,7 +627,7 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, · 626 unmodified lines | ||
| 627 | 627 | rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL, |
| 628 | 628 | eiph->daddr, eiph->saddr, 0, 0, |
| 629 | 629 | IPPROTO_IPIP, RT_TOS(eiph->tos), 0); |
| 630 | − if (IS_ERR(rt) || rt->dst.dev->type != ARPHRD_TUNNEL) { | |
| 630 | + if (IS_ERR(rt) || rt->dst.dev->type != ARPHRD_TUNNEL6) { | |
| 631 | 631 | if (!IS_ERR(rt)) |
| 632 | 632 | ip_rt_put(rt); |
| 633 | 633 | goto out; |
| @@ -636,7 +636,7 @@ ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, · 2 unmodified lines | ||
| 636 | 636 | } else { |
| 637 | 637 | if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, |
| 638 | 638 | skb2->dev) || |
| 639 | − skb_dst(skb2)->dev->type != ARPHRD_TUNNEL) | |
| 639 | + skb_dst(skb2)->dev->type != ARPHRD_TUNNEL6) | |
| 640 | 640 | goto out; |
| 641 | 641 | } |
| 642 | 642 | |
| @@ -669,6 +669,10 @@ static int ipip6_rcv(struct sk_buff *skb) · 668 unmodified lines | ||
| 669 | 669 | !net_eq(tunnel->net, dev_net(tunnel->dev)))) |
| 670 | 670 | goto out; |
| 671 | 671 | |
| 672 | + /* skb can be uncloned in iptunnel_pull_header, so | |
| 673 | + * old iph is no longer valid | |
| 674 | + */ | |
| 675 | + iph = (const struct iphdr *)skb_mac_header(skb); | |
| 672 | 676 | err = IP_ECN_decapsulate(iph, skb); |
| 673 | 677 | if (unlikely(err)) { |
| 674 | 678 | if (log_ecn_error) |
| @@ -2054,14 +2054,14 @@ static int __init kcm_init(void) · 2053 unmodified lines | ||
| 2054 | 2054 | if (err) |
| 2055 | 2055 | goto fail; |
| 2056 | 2056 | |
| 2057 | − err = sock_register(&kcm_family_ops); | |
| 2058 | − if (err) | |
| 2059 | − goto sock_register_fail; | |
| 2060 | − | |
| 2061 | 2057 | err = register_pernet_device(&kcm_net_ops); |
| 2062 | 2058 | if (err) |
| 2063 | 2059 | goto net_ops_fail; |
| 2064 | 2060 | |
| 2061 | + err = sock_register(&kcm_family_ops); | |
| 2062 | + if (err) | |
| 2063 | + goto sock_register_fail; | |
| 2064 | + | |
| 2065 | 2065 | err = kcm_proc_init(); |
| 2066 | 2066 | if (err) |
| 2067 | 2067 | goto proc_init_fail; |
| @@ -2069,12 +2069,12 @@ static int __init kcm_init(void) · 1 unmodified line | ||
| 2069 | 2069 | return 0; |
| 2070 | 2070 | |
| 2071 | 2071 | proc_init_fail: |
| 2072 | − unregister_pernet_device(&kcm_net_ops); | |
| 2073 | − | |
| 2074 | −net_ops_fail: | |
| 2075 | 2072 | sock_unregister(PF_KCM); |
| 2076 | 2073 | |
| 2077 | 2074 | sock_register_fail: |
| 2075 | + unregister_pernet_device(&kcm_net_ops); | |
| 2076 | + | |
| 2077 | +net_ops_fail: | |
| 2078 | 2078 | proto_unregister(&kcm_proto); |
| 2079 | 2079 | |
| 2080 | 2080 | fail: |
| @@ -2090,8 +2090,8 @@ fail: · 9 unmodified lines | ||
| 2090 | 2090 | static void __exit kcm_exit(void) |
| 2091 | 2091 | { |
| 2092 | 2092 | kcm_proc_exit(); |
| 2093 | − unregister_pernet_device(&kcm_net_ops); | |
| 2094 | 2093 | sock_unregister(PF_KCM); |
| 2094 | + unregister_pernet_device(&kcm_net_ops); | |
| 2095 | 2095 | proto_unregister(&kcm_proto); |
| 2096 | 2096 | destroy_workqueue(kcm_wq); |
| 2097 | 2097 | |
| @@ -312,6 +312,10 @@ static void nci_hci_cmd_received(struct nci_dev *ndev, u8 pipe, · 311 unmodified lines | ||
| 312 | 312 | create_info = (struct nci_hci_create_pipe_resp *)skb->data; |
| 313 | 313 | dest_gate = create_info->dest_gate; |
| 314 | 314 | new_pipe = create_info->pipe; |
| 315 | + if (new_pipe >= NCI_HCI_MAX_PIPES) { | |
| 316 | + status = NCI_HCI_ANY_E_NOK; | |
| 317 | + goto exit; | |
| 318 | + } | |
| 315 | 319 | |
| 316 | 320 | /* Save the new created pipe and bind with local gate, |
| 317 | 321 | * the description for skb->data[3] is destination gate id |
| @@ -336,6 +340,10 @@ static void nci_hci_cmd_received(struct nci_dev *ndev, u8 pipe, · 18 unmodified lines | ||
| 336 | 340 | goto exit; |
| 337 | 341 | } |
| 338 | 342 | delete_info = (struct nci_hci_delete_pipe_noti *)skb->data; |
| 343 | + if (delete_info->pipe >= NCI_HCI_MAX_PIPES) { | |
| 344 | + status = NCI_HCI_ANY_E_NOK; | |
| 345 | + goto exit; | |
| 346 | + } | |
| 339 | 347 | |
| 340 | 348 | ndev->hci_dev->pipes[delete_info->pipe].gate = |
| 341 | 349 | NCI_HCI_INVALID_GATE; |
| @@ -2306,14 +2306,14 @@ static struct nlattr *reserve_sfa_size(struct sw_flow_actions **sfa, · 2305 unmodified lines | ||
| 2306 | 2306 | |
| 2307 | 2307 | struct sw_flow_actions *acts; |
| 2308 | 2308 | int new_acts_size; |
| 2309 | − int req_size = NLA_ALIGN(attr_len); | |
| 2309 | + size_t req_size = NLA_ALIGN(attr_len); | |
| 2310 | 2310 | int next_offset = offsetof(struct sw_flow_actions, actions) + |
| 2311 | 2311 | (*sfa)->actions_len; |
| 2312 | 2312 | |
| 2313 | 2313 | if (req_size <= (ksize(*sfa) - next_offset)) |
| 2314 | 2314 | goto out; |
| 2315 | 2315 | |
| 2316 | − new_acts_size = ksize(*sfa) * 2; | |
| 2316 | + new_acts_size = max(next_offset + req_size, ksize(*sfa) * 2); | |
| 2317 | 2317 | |
| 2318 | 2318 | if (new_acts_size > MAX_ACTIONS_BUFSIZE) { |
| 2319 | 2319 | if ((MAX_ACTIONS_BUFSIZE - next_offset) < req_size) { |
| @@ -608,7 +608,7 @@ static void rds_tcp_kill_sock(struct net *net) · 607 unmodified lines | ||
| 608 | 608 | list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) { |
| 609 | 609 | struct net *c_net = read_pnet(&tc->t_cpath->cp_conn->c_net); |
| 610 | 610 | |
| 611 | − if (net != c_net || !tc->t_sock) | |
| 611 | + if (net != c_net) | |
| 612 | 612 | continue; |
| 613 | 613 | if (!list_has_conn(&tmp_list, tc->t_cpath->cp_conn)) { |
| 614 | 614 | list_move_tail(&tc->t_tcp_node, &tmp_list); |
| @@ -45,8 +45,8 @@ static int tcf_sample_init(struct net *net, struct nlattr *nla, · 44 unmodified lines | ||
| 45 | 45 | struct nlattr *tb[TCA_SAMPLE_MAX + 1]; |
| 46 | 46 | struct psample_group *psample_group; |
| 47 | 47 | struct tcf_chain *goto_ch = NULL; |
| 48 | + u32 psample_group_num, rate; | |
| 48 | 49 | struct tc_sample *parm; |
| 49 | − u32 psample_group_num; | |
| 50 | 50 | struct tcf_sample *s; |
| 51 | 51 | bool exists = false; |
| 52 | 52 | int ret, err; |
| @@ -85,6 +85,12 @@ static int tcf_sample_init(struct net *net, struct nlattr *nla, · 32 unmodified lines | ||
| 85 | 85 | if (err < 0) |
| 86 | 86 | goto release_idr; |
| 87 | 87 | |
| 88 | + rate = nla_get_u32(tb[TCA_SAMPLE_RATE]); | |
| 89 | + if (!rate) { | |
| 90 | + NL_SET_ERR_MSG(extack, "invalid sample rate"); | |
| 91 | + err = -EINVAL; | |
| 92 | + goto put_chain; | |
| 93 | + } | |
| 88 | 94 | psample_group_num = nla_get_u32(tb[TCA_SAMPLE_PSAMPLE_GROUP]); |
| 89 | 95 | psample_group = psample_group_get(net, psample_group_num); |
| 90 | 96 | if (!psample_group) { |
| @@ -96,7 +102,7 @@ static int tcf_sample_init(struct net *net, struct nlattr *nla, · 5 unmodified lines | ||
| 96 | 102 | |
| 97 | 103 | spin_lock_bh(&s->tcf_lock); |
| 98 | 104 | goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch); |
| 99 | − s->rate = nla_get_u32(tb[TCA_SAMPLE_RATE]); | |
| 105 | + s->rate = rate; | |
| 100 | 106 | s->psample_group_num = psample_group_num; |
| 101 | 107 | RCU_INIT_POINTER(s->psample_group, psample_group); |
| 102 | 108 | |
| @@ -130,6 +130,11 @@ static void mall_destroy(struct tcf_proto *tp, bool rtnl_held, · 129 unmodified lines | ||
| 130 | 130 | |
| 131 | 131 | static void *mall_get(struct tcf_proto *tp, u32 handle) |
| 132 | 132 | { |
| 133 | + struct cls_mall_head *head = rtnl_dereference(tp->root); | |
| 134 | + | |
| 135 | + if (head && head->handle == handle) | |
| 136 | + return head; | |
| 137 | + | |
| 133 | 138 | return NULL; |
| 134 | 139 | } |
| 135 | 140 | |
| @@ -1517,16 +1517,27 @@ static unsigned int cake_drop(struct Qdisc *sch, struct sk_buff **to_free) · 1516 unmodified lines | ||
| 1517 | 1517 | |
| 1518 | 1518 | static u8 cake_handle_diffserv(struct sk_buff *skb, u16 wash) |
| 1519 | 1519 | { |
| 1520 | + int wlen = skb_network_offset(skb); | |
| 1520 | 1521 | u8 dscp; |
| 1521 | 1522 | |
| 1522 | − switch (skb->protocol) { | |
| 1523 | + switch (tc_skb_protocol(skb)) { | |
| 1523 | 1524 | case htons(ETH_P_IP): |
| 1525 | + wlen += sizeof(struct iphdr); | |
| 1526 | + if (!pskb_may_pull(skb, wlen) || | |
| 1527 | + skb_try_make_writable(skb, wlen)) | |
| 1528 | + return 0; | |
| 1529 | + | |
| 1524 | 1530 | dscp = ipv4_get_dsfield(ip_hdr(skb)) >> 2; |
| 1525 | 1531 | if (wash && dscp) |
| 1526 | 1532 | ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, 0); |
| 1527 | 1533 | return dscp; |
| 1528 | 1534 | |
| 1529 | 1535 | case htons(ETH_P_IPV6): |
| 1536 | + wlen += sizeof(struct ipv6hdr); | |
| 1537 | + if (!pskb_may_pull(skb, wlen) || | |
| 1538 | + skb_try_make_writable(skb, wlen)) | |
| 1539 | + return 0; | |
| 1540 | + | |
| 1530 | 1541 | dscp = ipv6_get_dsfield(ipv6_hdr(skb)) >> 2; |
| 1531 | 1542 | if (wash && dscp) |
| 1532 | 1543 | ipv6_change_dsfield(ipv6_hdr(skb), INET_ECN_MASK, 0); |
| @@ -1358,9 +1358,11 @@ cbq_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 1357 unmodified lines | ||
| 1358 | 1358 | { |
| 1359 | 1359 | struct cbq_sched_data *q = qdisc_priv(sch); |
| 1360 | 1360 | struct cbq_class *cl = (struct cbq_class *)arg; |
| 1361 | + __u32 qlen; | |
| 1361 | 1362 | |
| 1362 | 1363 | cl->xstats.avgidle = cl->avgidle; |
| 1363 | 1364 | cl->xstats.undertime = 0; |
| 1365 | + qdisc_qstats_qlen_backlog(cl->q, &qlen, &cl->qstats.backlog); | |
| 1364 | 1366 | |
| 1365 | 1367 | if (cl->undertime != PSCHED_PASTPERFECT) |
| 1366 | 1368 | cl->xstats.undertime = cl->undertime - q->now; |
| @@ -1368,7 +1370,7 @@ cbq_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 1 unmodified line | ||
| 1368 | 1370 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 1369 | 1371 | d, NULL, &cl->bstats) < 0 || |
| 1370 | 1372 | gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 || |
| 1371 | − gnet_stats_copy_queue(d, NULL, &cl->qstats, cl->q->q.qlen) < 0) | |
| 1373 | + gnet_stats_copy_queue(d, NULL, &cl->qstats, qlen) < 0) | |
| 1372 | 1374 | return -1; |
| 1373 | 1375 | |
| 1374 | 1376 | return gnet_stats_copy_app(d, &cl->xstats, sizeof(cl->xstats)); |
| @@ -1665,17 +1667,13 @@ static int cbq_delete(struct Qdisc *sch, unsigned long arg) · 290 unmodified lines | ||
| 1665 | 1667 | { |
| 1666 | 1668 | struct cbq_sched_data *q = qdisc_priv(sch); |
| 1667 | 1669 | struct cbq_class *cl = (struct cbq_class *)arg; |
| 1668 | − unsigned int qlen, backlog; | |
| 1669 | 1670 | |
| 1670 | 1671 | if (cl->filters || cl->children || cl == &q->link) |
| 1671 | 1672 | return -EBUSY; |
| 1672 | 1673 | |
| 1673 | 1674 | sch_tree_lock(sch); |
| 1674 | 1675 | |
| 1675 | − qlen = cl->q->q.qlen; | |
| 1676 | − backlog = cl->q->qstats.backlog; | |
| 1677 | − qdisc_reset(cl->q); | |
| 1678 | − qdisc_tree_reduce_backlog(cl->q, qlen, backlog); | |
| 1676 | + qdisc_purge_queue(cl->q); | |
| 1679 | 1677 | |
| 1680 | 1678 | if (cl->next_alive) |
| 1681 | 1679 | cbq_deactivate_class(cl); |
| @@ -50,15 +50,6 @@ static struct drr_class *drr_find_class(struct Qdisc *sch, u32 classid) · 49 unmodified lines | ||
| 50 | 50 | return container_of(clc, struct drr_class, common); |
| 51 | 51 | } |
| 52 | 52 | |
| 53 | −static void drr_purge_queue(struct drr_class *cl) | |
| 54 | −{ | |
| 55 | − unsigned int len = cl->qdisc->q.qlen; | |
| 56 | − unsigned int backlog = cl->qdisc->qstats.backlog; | |
| 57 | − | |
| 58 | − qdisc_reset(cl->qdisc); | |
| 59 | − qdisc_tree_reduce_backlog(cl->qdisc, len, backlog); | |
| 60 | −} | |
| 61 | − | |
| 62 | 53 | static const struct nla_policy drr_policy[TCA_DRR_MAX + 1] = { |
| 63 | 54 | [TCA_DRR_QUANTUM] = { .type = NLA_U32 }, |
| 64 | 55 | }; |
| @@ -167,7 +158,7 @@ static int drr_delete_class(struct Qdisc *sch, unsigned long arg) · 102 unmodified lines | ||
| 167 | 158 | |
| 168 | 159 | sch_tree_lock(sch); |
| 169 | 160 | |
| 170 | − drr_purge_queue(cl); | |
| 161 | + qdisc_purge_queue(cl->qdisc); | |
| 171 | 162 | qdisc_class_hash_remove(&q->clhash, &cl->common); |
| 172 | 163 | |
| 173 | 164 | sch_tree_unlock(sch); |
| @@ -269,7 +260,8 @@ static int drr_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 95 unmodified lines | ||
| 269 | 260 | struct gnet_dump *d) |
| 270 | 261 | { |
| 271 | 262 | struct drr_class *cl = (struct drr_class *)arg; |
| 272 | − __u32 qlen = cl->qdisc->q.qlen; | |
| 263 | + __u32 qlen = qdisc_qlen_sum(cl->qdisc); | |
| 264 | + struct Qdisc *cl_q = cl->qdisc; | |
| 273 | 265 | struct tc_drr_stats xstats; |
| 274 | 266 | |
| 275 | 267 | memset(&xstats, 0, sizeof(xstats)); |
| @@ -279,7 +271,7 @@ static int drr_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 3 unmodified lines | ||
| 279 | 271 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 280 | 272 | d, NULL, &cl->bstats) < 0 || |
| 281 | 273 | gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 || |
| 282 | − gnet_stats_copy_queue(d, NULL, &cl->qdisc->qstats, qlen) < 0) | |
| 274 | + gnet_stats_copy_queue(d, cl_q->cpu_qstats, &cl_q->qstats, qlen) < 0) | |
| 283 | 275 | return -1; |
| 284 | 276 | |
| 285 | 277 | return gnet_stats_copy_app(d, &xstats, sizeof(xstats)); |
| @@ -844,16 +844,6 @@ qdisc_peek_len(struct Qdisc *sch) · 843 unmodified lines | ||
| 844 | 844 | return len; |
| 845 | 845 | } |
| 846 | 846 | |
| 847 | −static void | |
| 848 | −hfsc_purge_queue(struct Qdisc *sch, struct hfsc_class *cl) | |
| 849 | −{ | |
| 850 | − unsigned int len = cl->qdisc->q.qlen; | |
| 851 | − unsigned int backlog = cl->qdisc->qstats.backlog; | |
| 852 | − | |
| 853 | − qdisc_reset(cl->qdisc); | |
| 854 | − qdisc_tree_reduce_backlog(cl->qdisc, len, backlog); | |
| 855 | −} | |
| 856 | − | |
| 857 | 847 | static void |
| 858 | 848 | hfsc_adjust_levels(struct hfsc_class *cl) |
| 859 | 849 | { |
| @@ -1076,7 +1066,7 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid, · 216 unmodified lines | ||
| 1076 | 1066 | qdisc_class_hash_insert(&q->clhash, &cl->cl_common); |
| 1077 | 1067 | list_add_tail(&cl->siblings, &parent->children); |
| 1078 | 1068 | if (parent->level == 0) |
| 1079 | − hfsc_purge_queue(sch, parent); | |
| 1069 | + qdisc_purge_queue(parent->qdisc); | |
| 1080 | 1070 | hfsc_adjust_levels(parent); |
| 1081 | 1071 | sch_tree_unlock(sch); |
| 1082 | 1072 | |
| @@ -1112,7 +1102,7 @@ hfsc_delete_class(struct Qdisc *sch, unsigned long arg) · 29 unmodified lines | ||
| 1112 | 1102 | list_del(&cl->siblings); |
| 1113 | 1103 | hfsc_adjust_levels(cl->cl_parent); |
| 1114 | 1104 | |
| 1115 | − hfsc_purge_queue(sch, cl); | |
| 1105 | + qdisc_purge_queue(cl->qdisc); | |
| 1116 | 1106 | qdisc_class_hash_remove(&q->clhash, &cl->cl_common); |
| 1117 | 1107 | |
| 1118 | 1108 | sch_tree_unlock(sch); |
| @@ -1328,8 +1318,9 @@ hfsc_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 209 unmodified lines | ||
| 1328 | 1318 | { |
| 1329 | 1319 | struct hfsc_class *cl = (struct hfsc_class *)arg; |
| 1330 | 1320 | struct tc_hfsc_stats xstats; |
| 1321 | + __u32 qlen; | |
| 1331 | 1322 | |
| 1332 | − cl->qstats.backlog = cl->qdisc->qstats.backlog; | |
| 1323 | + qdisc_qstats_qlen_backlog(cl->qdisc, &qlen, &cl->qstats.backlog); | |
| 1333 | 1324 | xstats.level = cl->level; |
| 1334 | 1325 | xstats.period = cl->cl_vtperiod; |
| 1335 | 1326 | xstats.work = cl->cl_total; |
| @@ -1337,7 +1328,7 @@ hfsc_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 1 unmodified line | ||
| 1337 | 1328 | |
| 1338 | 1329 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), d, NULL, &cl->bstats) < 0 || |
| 1339 | 1330 | gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 || |
| 1340 | − gnet_stats_copy_queue(d, NULL, &cl->qstats, cl->qdisc->q.qlen) < 0) | |
| 1331 | + gnet_stats_copy_queue(d, NULL, &cl->qstats, qlen) < 0) | |
| 1341 | 1332 | return -1; |
| 1342 | 1333 | |
| 1343 | 1334 | return gnet_stats_copy_app(d, &xstats, sizeof(xstats)); |
| @@ -1127,10 +1127,9 @@ htb_dump_class_stats(struct Qdisc *sch, unsigned long arg, struct gnet_dump *d) · 1126 unmodified lines | ||
| 1127 | 1127 | }; |
| 1128 | 1128 | __u32 qlen = 0; |
| 1129 | 1129 | |
| 1130 | − if (!cl->level && cl->leaf.q) { | |
| 1131 | − qlen = cl->leaf.q->q.qlen; | |
| 1132 | − qs.backlog = cl->leaf.q->qstats.backlog; | |
| 1133 | − } | |
| 1130 | + if (!cl->level && cl->leaf.q) | |
| 1131 | + qdisc_qstats_qlen_backlog(cl->leaf.q, &qlen, &qs.backlog); | |
| 1132 | + | |
| 1134 | 1133 | cl->xstats.tokens = clamp_t(s64, PSCHED_NS2TICKS(cl->tokens), |
| 1135 | 1134 | INT_MIN, INT_MAX); |
| 1136 | 1135 | cl->xstats.ctokens = clamp_t(s64, PSCHED_NS2TICKS(cl->ctokens), |
| @@ -1270,13 +1269,8 @@ static int htb_delete(struct Qdisc *sch, unsigned long arg) · 133 unmodified lines | ||
| 1270 | 1269 | |
| 1271 | 1270 | sch_tree_lock(sch); |
| 1272 | 1271 | |
| 1273 | − if (!cl->level) { | |
| 1274 | − unsigned int qlen = cl->leaf.q->q.qlen; | |
| 1275 | − unsigned int backlog = cl->leaf.q->qstats.backlog; | |
| 1276 | − | |
| 1277 | − qdisc_reset(cl->leaf.q); | |
| 1278 | − qdisc_tree_reduce_backlog(cl->leaf.q, qlen, backlog); | |
| 1279 | − } | |
| 1272 | + if (!cl->level) | |
| 1273 | + qdisc_purge_queue(cl->leaf.q); | |
| 1280 | 1274 | |
| 1281 | 1275 | /* delete from hash and active; remainder in destroy_class */ |
| 1282 | 1276 | qdisc_class_hash_remove(&q->clhash, &cl->common); |
| @@ -1404,12 +1398,8 @@ static int htb_change_class(struct Qdisc *sch, u32 classid, · 121 unmodified lines | ||
| 1404 | 1398 | classid, NULL); |
| 1405 | 1399 | sch_tree_lock(sch); |
| 1406 | 1400 | if (parent && !parent->level) { |
| 1407 | − unsigned int qlen = parent->leaf.q->q.qlen; | |
| 1408 | − unsigned int backlog = parent->leaf.q->qstats.backlog; | |
| 1409 | − | |
| 1410 | 1401 | /* turn parent into inner node */ |
| 1411 | − qdisc_reset(parent->leaf.q); | |
| 1412 | − qdisc_tree_reduce_backlog(parent->leaf.q, qlen, backlog); | |
| 1402 | + qdisc_purge_queue(parent->leaf.q); | |
| 1413 | 1403 | qdisc_put(parent->leaf.q); |
| 1414 | 1404 | if (parent->prio_activity) |
| 1415 | 1405 | htb_deactivate(q, parent); |
| @@ -249,7 +249,7 @@ static int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl, · 248 unmodified lines | ||
| 249 | 249 | |
| 250 | 250 | sch = dev_queue->qdisc_sleeping; |
| 251 | 251 | if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || |
| 252 | − gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) | |
| 252 | + qdisc_qstats_copy(d, sch) < 0) | |
| 253 | 253 | return -1; |
| 254 | 254 | return 0; |
| 255 | 255 | } |
| @@ -561,8 +561,7 @@ static int mqprio_dump_class_stats(struct Qdisc *sch, unsigned long cl, · 560 unmodified lines | ||
| 561 | 561 | sch = dev_queue->qdisc_sleeping; |
| 562 | 562 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 563 | 563 | d, NULL, &sch->bstats) < 0 || |
| 564 | − gnet_stats_copy_queue(d, NULL, | |
| 565 | − &sch->qstats, sch->q.qlen) < 0) | |
| 564 | + qdisc_qstats_copy(d, sch) < 0) | |
| 566 | 565 | return -1; |
| 567 | 566 | } |
| 568 | 567 | return 0; |
| @@ -201,9 +201,9 @@ static int multiq_tune(struct Qdisc *sch, struct nlattr *opt, · 200 unmodified lines | ||
| 201 | 201 | for (i = q->bands; i < q->max_bands; i++) { |
| 202 | 202 | if (q->queues[i] != &noop_qdisc) { |
| 203 | 203 | struct Qdisc *child = q->queues[i]; |
| 204 | + | |
| 204 | 205 | q->queues[i] = &noop_qdisc; |
| 205 | − qdisc_tree_reduce_backlog(child, child->q.qlen, | |
| 206 | − child->qstats.backlog); | |
| 206 | + qdisc_tree_flush_backlog(child); | |
| 207 | 207 | qdisc_put(child); |
| 208 | 208 | } |
| 209 | 209 | } |
| @@ -225,9 +225,7 @@ static int multiq_tune(struct Qdisc *sch, struct nlattr *opt, · 15 unmodified lines | ||
| 225 | 225 | qdisc_hash_add(child, true); |
| 226 | 226 | |
| 227 | 227 | if (old != &noop_qdisc) { |
| 228 | − qdisc_tree_reduce_backlog(old, | |
| 229 | − old->q.qlen, | |
| 230 | − old->qstats.backlog); | |
| 228 | + qdisc_tree_flush_backlog(old); | |
| 231 | 229 | qdisc_put(old); |
| 232 | 230 | } |
| 233 | 231 | sch_tree_unlock(sch); |
| @@ -344,7 +342,7 @@ static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl, · 110 unmodified lines | ||
| 344 | 342 | cl_q = q->queues[cl - 1]; |
| 345 | 343 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 346 | 344 | d, NULL, &cl_q->bstats) < 0 || |
| 347 | − gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0) | |
| 345 | + qdisc_qstats_copy(d, cl_q) < 0) | |
| 348 | 346 | return -1; |
| 349 | 347 | |
| 350 | 348 | return 0; |
| @@ -216,12 +216,8 @@ static int prio_tune(struct Qdisc *sch, struct nlattr *opt, · 215 unmodified lines | ||
| 216 | 216 | q->bands = qopt->bands; |
| 217 | 217 | memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1); |
| 218 | 218 | |
| 219 | − for (i = q->bands; i < oldbands; i++) { | |
| 220 | − struct Qdisc *child = q->queues[i]; | |
| 221 | − | |
| 222 | − qdisc_tree_reduce_backlog(child, child->q.qlen, | |
| 223 | − child->qstats.backlog); | |
| 224 | − } | |
| 219 | + for (i = q->bands; i < oldbands; i++) | |
| 220 | + qdisc_tree_flush_backlog(q->queues[i]); | |
| 225 | 221 | |
| 226 | 222 | for (i = oldbands; i < q->bands; i++) { |
| 227 | 223 | q->queues[i] = queues[i]; |
| @@ -365,7 +361,7 @@ static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl, · 137 unmodified lines | ||
| 365 | 361 | cl_q = q->queues[cl - 1]; |
| 366 | 362 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 367 | 363 | d, NULL, &cl_q->bstats) < 0 || |
| 368 | − gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0) | |
| 364 | + qdisc_qstats_copy(d, cl_q) < 0) | |
| 369 | 365 | return -1; |
| 370 | 366 | |
| 371 | 367 | return 0; |
| @@ -217,15 +217,6 @@ static struct qfq_class *qfq_find_class(struct Qdisc *sch, u32 classid) · 216 unmodified lines | ||
| 217 | 217 | return container_of(clc, struct qfq_class, common); |
| 218 | 218 | } |
| 219 | 219 | |
| 220 | −static void qfq_purge_queue(struct qfq_class *cl) | |
| 221 | −{ | |
| 222 | − unsigned int len = cl->qdisc->q.qlen; | |
| 223 | − unsigned int backlog = cl->qdisc->qstats.backlog; | |
| 224 | − | |
| 225 | − qdisc_reset(cl->qdisc); | |
| 226 | − qdisc_tree_reduce_backlog(cl->qdisc, len, backlog); | |
| 227 | −} | |
| 228 | − | |
| 229 | 220 | static const struct nla_policy qfq_policy[TCA_QFQ_MAX + 1] = { |
| 230 | 221 | [TCA_QFQ_WEIGHT] = { .type = NLA_U32 }, |
| 231 | 222 | [TCA_QFQ_LMAX] = { .type = NLA_U32 }, |
| @@ -551,7 +542,7 @@ static int qfq_delete_class(struct Qdisc *sch, unsigned long arg) · 319 unmodified lines | ||
| 551 | 542 | |
| 552 | 543 | sch_tree_lock(sch); |
| 553 | 544 | |
| 554 | − qfq_purge_queue(cl); | |
| 545 | + qdisc_purge_queue(cl->qdisc); | |
| 555 | 546 | qdisc_class_hash_remove(&q->clhash, &cl->common); |
| 556 | 547 | |
| 557 | 548 | sch_tree_unlock(sch); |
| @@ -655,8 +646,7 @@ static int qfq_dump_class_stats(struct Qdisc *sch, unsigned long arg, · 97 unmodified lines | ||
| 655 | 646 | if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch), |
| 656 | 647 | d, NULL, &cl->bstats) < 0 || |
| 657 | 648 | gnet_stats_copy_rate_est(d, &cl->rate_est) < 0 || |
| 658 | − gnet_stats_copy_queue(d, NULL, | |
| 659 | − &cl->qdisc->qstats, cl->qdisc->q.qlen) < 0) | |
| 649 | + qdisc_qstats_copy(d, cl->qdisc) < 0) | |
| 660 | 650 | return -1; |
| 661 | 651 | |
| 662 | 652 | return gnet_stats_copy_app(d, &xstats, sizeof(xstats)); |
| @@ -233,8 +233,7 @@ static int red_change(struct Qdisc *sch, struct nlattr *opt, · 232 unmodified lines | ||
| 233 | 233 | q->flags = ctl->flags; |
| 234 | 234 | q->limit = ctl->limit; |
| 235 | 235 | if (child) { |
| 236 | − qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen, | |
| 237 | − q->qdisc->qstats.backlog); | |
| 236 | + qdisc_tree_flush_backlog(q->qdisc); | |
| 238 | 237 | old_child = q->qdisc; |
| 239 | 238 | q->qdisc = child; |
| 240 | 239 | } |
| @@ -521,8 +521,7 @@ static int sfb_change(struct Qdisc *sch, struct nlattr *opt, · 520 unmodified lines | ||
| 521 | 521 | qdisc_hash_add(child, true); |
| 522 | 522 | sch_tree_lock(sch); |
| 523 | 523 | |
| 524 | − qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen, | |
| 525 | − q->qdisc->qstats.backlog); | |
| 524 | + qdisc_tree_flush_backlog(q->qdisc); | |
| 526 | 525 | qdisc_put(q->qdisc); |
| 527 | 526 | q->qdisc = child; |
| 528 | 527 | |
| @@ -895,7 +895,7 @@ static int taprio_dump_class_stats(struct Qdisc *sch, unsigned long cl, · 894 unmodified lines | ||
| 895 | 895 | |
| 896 | 896 | sch = dev_queue->qdisc_sleeping; |
| 897 | 897 | if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || |
| 898 | − gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) | |
| 898 | + qdisc_qstats_copy(d, sch) < 0) | |
| 899 | 899 | return -1; |
| 900 | 900 | return 0; |
| 901 | 901 | } |
| @@ -391,8 +391,7 @@ static int tbf_change(struct Qdisc *sch, struct nlattr *opt, · 390 unmodified lines | ||
| 391 | 391 | |
| 392 | 392 | sch_tree_lock(sch); |
| 393 | 393 | if (child) { |
| 394 | − qdisc_tree_reduce_backlog(q->qdisc, q->qdisc->q.qlen, | |
| 395 | − q->qdisc->qstats.backlog); | |
| 394 | + qdisc_tree_flush_backlog(q->qdisc); | |
| 396 | 395 | qdisc_put(q->qdisc); |
| 397 | 396 | q->qdisc = child; |
| 398 | 397 | } |
| @@ -600,6 +600,7 @@ out: · 599 unmodified lines | ||
| 600 | 600 | static int sctp_v4_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr) |
| 601 | 601 | { |
| 602 | 602 | /* No address mapping for V4 sockets */ |
| 603 | + memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero)); | |
| 603 | 604 | return sizeof(struct sockaddr_in); |
| 604 | 605 | } |
| 605 | 606 | |
| @@ -267,8 +267,14 @@ static int tipc_nl_compat_dumpit(struct tipc_nl_compat_cmd_dump *cmd, · 266 unmodified lines | ||
| 267 | 267 | if (msg->rep_type) |
| 268 | 268 | tipc_tlv_init(msg->rep, msg->rep_type); |
| 269 | 269 | |
| 270 | − if (cmd->header) | |
| 271 | − (*cmd->header)(msg); | |
| 270 | + if (cmd->header) { | |
| 271 | + err = (*cmd->header)(msg); | |
| 272 | + if (err) { | |
| 273 | + kfree_skb(msg->rep); | |
| 274 | + msg->rep = NULL; | |
| 275 | + return err; | |
| 276 | + } | |
| 277 | + } | |
| 272 | 278 | |
| 273 | 279 | arg = nlmsg_new(0, GFP_KERNEL); |
| 274 | 280 | if (!arg) { |
| @@ -397,7 +403,12 @@ static int tipc_nl_compat_bearer_enable(struct tipc_nl_compat_cmd_doit *cmd, · 122 unmodified lines | ||
| 397 | 403 | if (!bearer) |
| 398 | 404 | return -EMSGSIZE; |
| 399 | 405 | |
| 400 | − len = min_t(int, TLV_GET_DATA_LEN(msg->req), TIPC_MAX_BEARER_NAME); | |
| 406 | + len = TLV_GET_DATA_LEN(msg->req); | |
| 407 | + len -= offsetof(struct tipc_bearer_config, name); | |
| 408 | + if (len <= 0) | |
| 409 | + return -EINVAL; | |
| 410 | + | |
| 411 | + len = min_t(int, len, TIPC_MAX_BEARER_NAME); | |
| 401 | 412 | if (!string_is_valid(b->name, len)) |
| 402 | 413 | return -EINVAL; |
| 403 | 414 | |
| @@ -766,7 +777,12 @@ static int tipc_nl_compat_link_set(struct tipc_nl_compat_cmd_doit *cmd, · 362 unmodified lines | ||
| 766 | 777 | |
| 767 | 778 | lc = (struct tipc_link_config *)TLV_DATA(msg->req); |
| 768 | 779 | |
| 769 | − len = min_t(int, TLV_GET_DATA_LEN(msg->req), TIPC_MAX_LINK_NAME); | |
| 780 | + len = TLV_GET_DATA_LEN(msg->req); | |
| 781 | + len -= offsetof(struct tipc_link_config, name); | |
| 782 | + if (len <= 0) | |
| 783 | + return -EINVAL; | |
| 784 | + | |
| 785 | + len = min_t(int, len, TIPC_MAX_LINK_NAME); | |
| 770 | 786 | if (!string_is_valid(lc->name, len)) |
| 771 | 787 | return -EINVAL; |
| 772 | 788 | |
| @@ -1484,6 +1484,8 @@ static int decrypt_skb_update(struct sock *sk, struct sk_buff *skb, · 1483 unmodified lines | ||
| 1484 | 1484 | |
| 1485 | 1485 | return err; |
| 1486 | 1486 | } |
| 1487 | + } else { | |
| 1488 | + *zc = false; | |
| 1487 | 1489 | } |
| 1488 | 1490 | |
| 1489 | 1491 | rxm->full_len -= padding_length(ctx, tls_ctx, skb); |
| @@ -0,0 +1,363 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | +// Author: Kirill Smelkov (kirr@nexedi.com) | |
| 3 | +// | |
| 4 | +// Search for stream-like files that are using nonseekable_open and convert | |
| 5 | +// them to stream_open. A stream-like file is a file that does not use ppos in | |
| 6 | +// its read and write. Rationale for the conversion is to avoid deadlock in | |
| 7 | +// between read and write. | |
| 8 | + | |
| 9 | +virtual report | |
| 10 | +virtual patch | |
| 11 | +virtual explain // explain decisions in the patch (SPFLAGS="-D explain") | |
| 12 | + | |
| 13 | +// stream-like reader & writer - ones that do not depend on f_pos. | |
| 14 | +@ stream_reader @ | |
| 15 | +identifier readstream, ppos; | |
| 16 | +identifier f, buf, len; | |
| 17 | +type loff_t; | |
| 18 | +@@ | |
| 19 | + ssize_t readstream(struct file *f, char *buf, size_t len, loff_t *ppos) | |
| 20 | + { | |
| 21 | + ... when != ppos | |
| 22 | + } | |
| 23 | + | |
| 24 | +@ stream_writer @ | |
| 25 | +identifier writestream, ppos; | |
| 26 | +identifier f, buf, len; | |
| 27 | +type loff_t; | |
| 28 | +@@ | |
| 29 | + ssize_t writestream(struct file *f, const char *buf, size_t len, loff_t *ppos) | |
| 30 | + { | |
| 31 | + ... when != ppos | |
| 32 | + } | |
| 33 | + | |
| 34 | + | |
| 35 | +// a function that blocks | |
| 36 | +@ blocks @ | |
| 37 | +identifier block_f; | |
| 38 | +identifier wait_event =~ "^wait_event_.*"; | |
| 39 | +@@ | |
| 40 | + block_f(...) { | |
| 41 | + ... when exists | |
| 42 | + wait_event(...) | |
| 43 | + ... when exists | |
| 44 | + } | |
| 45 | + | |
| 46 | +// stream_reader that can block inside. | |
| 47 | +// | |
| 48 | +// XXX wait_* can be called not directly from current function (e.g. func -> f -> g -> wait()) | |
| 49 | +// XXX currently reader_blocks supports only direct and 1-level indirect cases. | |
| 50 | +@ reader_blocks_direct @ | |
| 51 | +identifier stream_reader.readstream; | |
| 52 | +identifier wait_event =~ "^wait_event_.*"; | |
| 53 | +@@ | |
| 54 | + readstream(...) | |
| 55 | + { | |
| 56 | + ... when exists | |
| 57 | + wait_event(...) | |
| 58 | + ... when exists | |
| 59 | + } | |
| 60 | + | |
| 61 | +@ reader_blocks_1 @ | |
| 62 | +identifier stream_reader.readstream; | |
| 63 | +identifier blocks.block_f; | |
| 64 | +@@ | |
| 65 | + readstream(...) | |
| 66 | + { | |
| 67 | + ... when exists | |
| 68 | + block_f(...) | |
| 69 | + ... when exists | |
| 70 | + } | |
| 71 | + | |
| 72 | +@ reader_blocks depends on reader_blocks_direct || reader_blocks_1 @ | |
| 73 | +identifier stream_reader.readstream; | |
| 74 | +@@ | |
| 75 | + readstream(...) { | |
| 76 | + ... | |
| 77 | + } | |
| 78 | + | |
| 79 | + | |
| 80 | +// file_operations + whether they have _any_ .read, .write, .llseek ... at all. | |
| 81 | +// | |
| 82 | +// XXX add support for file_operations xxx[N] = ... (sound/core/pcm_native.c) | |
| 83 | +@ fops0 @ | |
| 84 | +identifier fops; | |
| 85 | +@@ | |
| 86 | + struct file_operations fops = { | |
| 87 | + ... | |
| 88 | + }; | |
| 89 | + | |
| 90 | +@ has_read @ | |
| 91 | +identifier fops0.fops; | |
| 92 | +identifier read_f; | |
| 93 | +@@ | |
| 94 | + struct file_operations fops = { | |
| 95 | + .read = read_f, | |
| 96 | + }; | |
| 97 | + | |
| 98 | +@ has_read_iter @ | |
| 99 | +identifier fops0.fops; | |
| 100 | +identifier read_iter_f; | |
| 101 | +@@ | |
| 102 | + struct file_operations fops = { | |
| 103 | + .read_iter = read_iter_f, | |
| 104 | + }; | |
| 105 | + | |
| 106 | +@ has_write @ | |
| 107 | +identifier fops0.fops; | |
| 108 | +identifier write_f; | |
| 109 | +@@ | |
| 110 | + struct file_operations fops = { | |
| 111 | + .write = write_f, | |
| 112 | + }; | |
| 113 | + | |
| 114 | +@ has_write_iter @ | |
| 115 | +identifier fops0.fops; | |
| 116 | +identifier write_iter_f; | |
| 117 | +@@ | |
| 118 | + struct file_operations fops = { | |
| 119 | + .write_iter = write_iter_f, | |
| 120 | + }; | |
| 121 | + | |
| 122 | +@ has_llseek @ | |
| 123 | +identifier fops0.fops; | |
| 124 | +identifier llseek_f; | |
| 125 | +@@ | |
| 126 | + struct file_operations fops = { | |
| 127 | + .llseek = llseek_f, | |
| 128 | + }; | |
| 129 | + | |
| 130 | +@ has_no_llseek @ | |
| 131 | +identifier fops0.fops; | |
| 132 | +@@ | |
| 133 | + struct file_operations fops = { | |
| 134 | + .llseek = no_llseek, | |
| 135 | + }; | |
| 136 | + | |
| 137 | +@ has_mmap @ | |
| 138 | +identifier fops0.fops; | |
| 139 | +identifier mmap_f; | |
| 140 | +@@ | |
| 141 | + struct file_operations fops = { | |
| 142 | + .mmap = mmap_f, | |
| 143 | + }; | |
| 144 | + | |
| 145 | +@ has_copy_file_range @ | |
| 146 | +identifier fops0.fops; | |
| 147 | +identifier copy_file_range_f; | |
| 148 | +@@ | |
| 149 | + struct file_operations fops = { | |
| 150 | + .copy_file_range = copy_file_range_f, | |
| 151 | + }; | |
| 152 | + | |
| 153 | +@ has_remap_file_range @ | |
| 154 | +identifier fops0.fops; | |
| 155 | +identifier remap_file_range_f; | |
| 156 | +@@ | |
| 157 | + struct file_operations fops = { | |
| 158 | + .remap_file_range = remap_file_range_f, | |
| 159 | + }; | |
| 160 | + | |
| 161 | +@ has_splice_read @ | |
| 162 | +identifier fops0.fops; | |
| 163 | +identifier splice_read_f; | |
| 164 | +@@ | |
| 165 | + struct file_operations fops = { | |
| 166 | + .splice_read = splice_read_f, | |
| 167 | + }; | |
| 168 | + | |
| 169 | +@ has_splice_write @ | |
| 170 | +identifier fops0.fops; | |
| 171 | +identifier splice_write_f; | |
| 172 | +@@ | |
| 173 | + struct file_operations fops = { | |
| 174 | + .splice_write = splice_write_f, | |
| 175 | + }; | |
| 176 | + | |
| 177 | + | |
| 178 | +// file_operations that is candidate for stream_open conversion - it does not | |
| 179 | +// use mmap and other methods that assume @offset access to file. | |
| 180 | +// | |
| 181 | +// XXX for simplicity require no .{read/write}_iter and no .splice_{read/write} for now. | |
| 182 | +// XXX maybe_steam.fops cannot be used in other rules - it gives "bad rule maybe_stream or bad variable fops". | |
| 183 | +@ maybe_stream depends on (!has_llseek || has_no_llseek) && !has_mmap && !has_copy_file_range && !has_remap_file_range && !has_read_iter && !has_write_iter && !has_splice_read && !has_splice_write @ | |
| 184 | +identifier fops0.fops; | |
| 185 | +@@ | |
| 186 | + struct file_operations fops = { | |
| 187 | + }; | |
| 188 | + | |
| 189 | + | |
| 190 | +// ---- conversions ---- | |
| 191 | + | |
| 192 | +// XXX .open = nonseekable_open -> .open = stream_open | |
| 193 | +// XXX .open = func -> openfunc -> nonseekable_open | |
| 194 | + | |
| 195 | +// read & write | |
| 196 | +// | |
| 197 | +// if both are used in the same file_operations together with an opener - | |
| 198 | +// under that conditions we can use stream_open instead of nonseekable_open. | |
| 199 | +@ fops_rw depends on maybe_stream @ | |
| 200 | +identifier fops0.fops, openfunc; | |
| 201 | +identifier stream_reader.readstream; | |
| 202 | +identifier stream_writer.writestream; | |
| 203 | +@@ | |
| 204 | + struct file_operations fops = { | |
| 205 | + .open = openfunc, | |
| 206 | + .read = readstream, | |
| 207 | + .write = writestream, | |
| 208 | + }; | |
| 209 | + | |
| 210 | +@ report_rw depends on report @ | |
| 211 | +identifier fops_rw.openfunc; | |
| 212 | +position p1; | |
| 213 | +@@ | |
| 214 | + openfunc(...) { | |
| 215 | + <... | |
| 216 | + nonseekable_open@p1 | |
| 217 | + ...> | |
| 218 | + } | |
| 219 | + | |
| 220 | +@ script:python depends on report && reader_blocks @ | |
| 221 | +fops << fops0.fops; | |
| 222 | +p << report_rw.p1; | |
| 223 | +@@ | |
| 224 | +coccilib.report.print_report(p[0], | |
| 225 | + "ERROR: %s: .read() can deadlock .write(); change nonseekable_open -> stream_open to fix." % (fops,)) | |
| 226 | + | |
| 227 | +@ script:python depends on report && !reader_blocks @ | |
| 228 | +fops << fops0.fops; | |
| 229 | +p << report_rw.p1; | |
| 230 | +@@ | |
| 231 | +coccilib.report.print_report(p[0], | |
| 232 | + "WARNING: %s: .read() and .write() have stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) | |
| 233 | + | |
| 234 | + | |
| 235 | +@ explain_rw_deadlocked depends on explain && reader_blocks @ | |
| 236 | +identifier fops_rw.openfunc; | |
| 237 | +@@ | |
| 238 | + openfunc(...) { | |
| 239 | + <... | |
| 240 | +- nonseekable_open | |
| 241 | ++ nonseekable_open /* read & write (was deadlock) */ | |
| 242 | + ...> | |
| 243 | + } | |
| 244 | + | |
| 245 | + | |
| 246 | +@ explain_rw_nodeadlock depends on explain && !reader_blocks @ | |
| 247 | +identifier fops_rw.openfunc; | |
| 248 | +@@ | |
| 249 | + openfunc(...) { | |
| 250 | + <... | |
| 251 | +- nonseekable_open | |
| 252 | ++ nonseekable_open /* read & write (no direct deadlock) */ | |
| 253 | + ...> | |
| 254 | + } | |
| 255 | + | |
| 256 | +@ patch_rw depends on patch @ | |
| 257 | +identifier fops_rw.openfunc; | |
| 258 | +@@ | |
| 259 | + openfunc(...) { | |
| 260 | + <... | |
| 261 | +- nonseekable_open | |
| 262 | ++ stream_open | |
| 263 | + ...> | |
| 264 | + } | |
| 265 | + | |
| 266 | + | |
| 267 | +// read, but not write | |
| 268 | +@ fops_r depends on maybe_stream && !has_write @ | |
| 269 | +identifier fops0.fops, openfunc; | |
| 270 | +identifier stream_reader.readstream; | |
| 271 | +@@ | |
| 272 | + struct file_operations fops = { | |
| 273 | + .open = openfunc, | |
| 274 | + .read = readstream, | |
| 275 | + }; | |
| 276 | + | |
| 277 | +@ report_r depends on report @ | |
| 278 | +identifier fops_r.openfunc; | |
| 279 | +position p1; | |
| 280 | +@@ | |
| 281 | + openfunc(...) { | |
| 282 | + <... | |
| 283 | + nonseekable_open@p1 | |
| 284 | + ...> | |
| 285 | + } | |
| 286 | + | |
| 287 | +@ script:python depends on report @ | |
| 288 | +fops << fops0.fops; | |
| 289 | +p << report_r.p1; | |
| 290 | +@@ | |
| 291 | +coccilib.report.print_report(p[0], | |
| 292 | + "WARNING: %s: .read() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) | |
| 293 | + | |
| 294 | +@ explain_r depends on explain @ | |
| 295 | +identifier fops_r.openfunc; | |
| 296 | +@@ | |
| 297 | + openfunc(...) { | |
| 298 | + <... | |
| 299 | +- nonseekable_open | |
| 300 | ++ nonseekable_open /* read only */ | |
| 301 | + ...> | |
| 302 | + } | |
| 303 | + | |
| 304 | +@ patch_r depends on patch @ | |
| 305 | +identifier fops_r.openfunc; | |
| 306 | +@@ | |
| 307 | + openfunc(...) { | |
| 308 | + <... | |
| 309 | +- nonseekable_open | |
| 310 | ++ stream_open | |
| 311 | + ...> | |
| 312 | + } | |
| 313 | + | |
| 314 | + | |
| 315 | +// write, but not read | |
| 316 | +@ fops_w depends on maybe_stream && !has_read @ | |
| 317 | +identifier fops0.fops, openfunc; | |
| 318 | +identifier stream_writer.writestream; | |
| 319 | +@@ | |
| 320 | + struct file_operations fops = { | |
| 321 | + .open = openfunc, | |
| 322 | + .write = writestream, | |
| 323 | + }; | |
| 324 | + | |
| 325 | +@ report_w depends on report @ | |
| 326 | +identifier fops_w.openfunc; | |
| 327 | +position p1; | |
| 328 | +@@ | |
| 329 | + openfunc(...) { | |
| 330 | + <... | |
| 331 | + nonseekable_open@p1 | |
| 332 | + ...> | |
| 333 | + } | |
| 334 | + | |
| 335 | +@ script:python depends on report @ | |
| 336 | +fops << fops0.fops; | |
| 337 | +p << report_w.p1; | |
| 338 | +@@ | |
| 339 | +coccilib.report.print_report(p[0], | |
| 340 | + "WARNING: %s: .write() has stream semantic; safe to change nonseekable_open -> stream_open." % (fops,)) | |
| 341 | + | |
| 342 | +@ explain_w depends on explain @ | |
| 343 | +identifier fops_w.openfunc; | |
| 344 | +@@ | |
| 345 | + openfunc(...) { | |
| 346 | + <... | |
| 347 | +- nonseekable_open | |
| 348 | ++ nonseekable_open /* write only */ | |
| 349 | + ...> | |
| 350 | + } | |
| 351 | + | |
| 352 | +@ patch_w depends on patch @ | |
| 353 | +identifier fops_w.openfunc; | |
| 354 | +@@ | |
| 355 | + openfunc(...) { | |
| 356 | + <... | |
| 357 | +- nonseekable_open | |
| 358 | ++ stream_open | |
| 359 | + ...> | |
| 360 | + } | |
| 361 | + | |
| 362 | + | |
| 363 | +// no read, no write - don't change anything | |
| @@ -125,7 +125,7 @@ out: · 124 unmodified lines | ||
| 125 | 125 | */ |
| 126 | 126 | int TSS_authhmac(unsigned char *digest, const unsigned char *key, |
| 127 | 127 | unsigned int keylen, unsigned char *h1, |
| 128 | − unsigned char *h2, unsigned char h3, ...) | |
| 128 | + unsigned char *h2, unsigned int h3, ...) | |
| 129 | 129 | { |
| 130 | 130 | unsigned char paramdigest[SHA1_DIGEST_SIZE]; |
| 131 | 131 | struct sdesc *sdesc; |
| @@ -135,13 +135,16 @@ int TSS_authhmac(unsigned char *digest, const unsigned char *key, · 3 unmodified lines | ||
| 135 | 135 | int ret; |
| 136 | 136 | va_list argp; |
| 137 | 137 | |
| 138 | + if (!chip) | |
| 139 | + return -ENODEV; | |
| 140 | + | |
| 138 | 141 | sdesc = init_sdesc(hashalg); |
| 139 | 142 | if (IS_ERR(sdesc)) { |
| 140 | 143 | pr_info("trusted_key: can't alloc %s\n", hash_alg); |
| 141 | 144 | return PTR_ERR(sdesc); |
| 142 | 145 | } |
| 143 | 146 | |
| 144 | − c = h3; | |
| 147 | + c = !!h3; | |
| 145 | 148 | ret = crypto_shash_init(&sdesc->shash); |
| 146 | 149 | if (ret < 0) |
| 147 | 150 | goto out; |
| @@ -196,6 +199,9 @@ int TSS_checkhmac1(unsigned char *buffer, · 48 unmodified lines | ||
| 196 | 199 | va_list argp; |
| 197 | 200 | int ret; |
| 198 | 201 | |
| 202 | + if (!chip) | |
| 203 | + return -ENODEV; | |
| 204 | + | |
| 199 | 205 | bufsize = LOAD32(buffer, TPM_SIZE_OFFSET); |
| 200 | 206 | tag = LOAD16(buffer, 0); |
| 201 | 207 | ordinal = command; |
| @@ -363,6 +369,9 @@ int trusted_tpm_send(unsigned char *cmd, size_t buflen) · 161 unmodified lines | ||
| 363 | 369 | { |
| 364 | 370 | int rc; |
| 365 | 371 | |
| 372 | + if (!chip) | |
| 373 | + return -ENODEV; | |
| 374 | + | |
| 366 | 375 | dump_tpm_buf(cmd); |
| 367 | 376 | rc = tpm_send(chip, cmd, buflen); |
| 368 | 377 | dump_tpm_buf(cmd); |
| @@ -429,6 +438,9 @@ int oiap(struct tpm_buf *tb, uint32_t *handle, unsigned char *nonce) · 60 unmodified lines | ||
| 429 | 438 | { |
| 430 | 439 | int ret; |
| 431 | 440 | |
| 441 | + if (!chip) | |
| 442 | + return -ENODEV; | |
| 443 | + | |
| 432 | 444 | INIT_BUF(tb); |
| 433 | 445 | store16(tb, TPM_TAG_RQU_COMMAND); |
| 434 | 446 | store32(tb, TPM_OIAP_SIZE); |
| @@ -1245,9 +1257,13 @@ static int __init init_trusted(void) · 810 unmodified lines | ||
| 1245 | 1257 | { |
| 1246 | 1258 | int ret; |
| 1247 | 1259 | |
| 1260 | + /* encrypted_keys.ko depends on successful load of this module even if | |
| 1261 | + * TPM is not used. | |
| 1262 | + */ | |
| 1248 | 1263 | chip = tpm_default_chip(); |
| 1249 | 1264 | if (!chip) |
| 1250 | − return -ENOENT; | |
| 1265 | + return 0; | |
| 1266 | + | |
| 1251 | 1267 | ret = init_digests(); |
| 1252 | 1268 | if (ret < 0) |
| 1253 | 1269 | goto err_put; |
| @@ -1269,10 +1285,12 @@ err_put: · 15 unmodified lines | ||
| 1269 | 1285 | |
| 1270 | 1286 | static void __exit cleanup_trusted(void) |
| 1271 | 1287 | { |
| 1272 | − put_device(&chip->dev); | |
| 1273 | − kfree(digests); | |
| 1274 | − trusted_shash_release(); | |
| 1275 | − unregister_key_type(&key_type_trusted); | |
| 1288 | + if (chip) { | |
| 1289 | + put_device(&chip->dev); | |
| 1290 | + kfree(digests); | |
| 1291 | + trusted_shash_release(); | |
| 1292 | + unregister_key_type(&key_type_trusted); | |
| 1293 | + } | |
| 1276 | 1294 | } |
| 1277 | 1295 | |
| 1278 | 1296 | late_initcall(init_trusted); |
| @@ -177,7 +177,7 @@ $(OUTPUT)libbpf.so: $(OUTPUT)libbpf.so.$(LIBBPF_VERSION) · 176 unmodified lines | ||
| 177 | 177 | |
| 178 | 178 | $(OUTPUT)libbpf.so.$(LIBBPF_VERSION): $(BPF_IN) |
| 179 | 179 | $(QUIET_LINK)$(CC) --shared -Wl,-soname,libbpf.so.$(VERSION) \ |
| 180 | − -Wl,--version-script=$(VERSION_SCRIPT) $^ -o $@ | |
| 180 | + -Wl,--version-script=$(VERSION_SCRIPT) $^ -lelf -o $@ | |
| 181 | 181 | @ln -sf $(@F) $(OUTPUT)libbpf.so |
| 182 | 182 | @ln -sf $(@F) $(OUTPUT)libbpf.so.$(VERSION) |
| 183 | 183 | |
| @@ -220,8 +220,9 @@ install_lib: all_cmd · 36 unmodified lines | ||
| 220 | 220 | install_headers: |
| 221 | 221 | $(call QUIET_INSTALL, headers) \ |
| 222 | 222 | $(call do_install,bpf.h,$(prefix)/include/bpf,644); \ |
| 223 | − $(call do_install,libbpf.h,$(prefix)/include/bpf,644); | |
| 224 | − $(call do_install,btf.h,$(prefix)/include/bpf,644); | |
| 223 | + $(call do_install,libbpf.h,$(prefix)/include/bpf,644); \ | |
| 224 | + $(call do_install,btf.h,$(prefix)/include/bpf,644); \ | |
| 225 | + $(call do_install,xsk.h,$(prefix)/include/bpf,644); | |
| 225 | 226 | |
| 226 | 227 | install: install_lib |
| 227 | 228 | |
| @@ -2107,6 +2107,9 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, · 2106 unmodified lines | ||
| 2107 | 2107 | return fwd_kind == real_kind; |
| 2108 | 2108 | } |
| 2109 | 2109 | |
| 2110 | + if (cand_kind != canon_kind) | |
| 2111 | + return 0; | |
| 2112 | + | |
| 2110 | 2113 | switch (cand_kind) { |
| 2111 | 2114 | case BTF_KIND_INT: |
| 2112 | 2115 | return btf_equal_int(cand_type, canon_type); |
| @@ -44,6 +44,7 @@ · 43 unmodified lines | ||
| 44 | 44 | #include <cpuid.h> |
| 45 | 45 | #include <linux/capability.h> |
| 46 | 46 | #include <errno.h> |
| 47 | +#include <math.h> | |
| 47 | 48 | |
| 48 | 49 | char *proc_stat = "/proc/stat"; |
| 49 | 50 | FILE *outf; |
| @@ -63,7 +64,6 @@ unsigned int dump_only; · 13 unmodified lines | ||
| 63 | 64 | unsigned int do_snb_cstates; |
| 64 | 65 | unsigned int do_knl_cstates; |
| 65 | 66 | unsigned int do_slm_cstates; |
| 66 | −unsigned int do_cnl_cstates; | |
| 67 | 67 | unsigned int use_c1_residency_msr; |
| 68 | 68 | unsigned int has_aperf; |
| 69 | 69 | unsigned int has_epb; |
| @@ -141,9 +141,21 @@ unsigned int first_counter_read = 1; · 71 unmodified lines | ||
| 141 | 141 | |
| 142 | 142 | #define RAPL_CORES_ENERGY_STATUS (1 << 9) |
| 143 | 143 | /* 0x639 MSR_PP0_ENERGY_STATUS */ |
| 144 | +#define RAPL_PER_CORE_ENERGY (1 << 10) | |
| 145 | + /* Indicates cores energy collection is per-core, | |
| 146 | + * not per-package. */ | |
| 147 | +#define RAPL_AMD_F17H (1 << 11) | |
| 148 | + /* 0xc0010299 MSR_RAPL_PWR_UNIT */ | |
| 149 | + /* 0xc001029a MSR_CORE_ENERGY_STAT */ | |
| 150 | + /* 0xc001029b MSR_PKG_ENERGY_STAT */ | |
| 144 | 151 | #define RAPL_CORES (RAPL_CORES_ENERGY_STATUS | RAPL_CORES_POWER_LIMIT) |
| 145 | 152 | #define TJMAX_DEFAULT 100 |
| 146 | 153 | |
| 154 | +/* MSRs that are not yet in the kernel-provided header. */ | |
| 155 | +#define MSR_RAPL_PWR_UNIT 0xc0010299 | |
| 156 | +#define MSR_CORE_ENERGY_STAT 0xc001029a | |
| 157 | +#define MSR_PKG_ENERGY_STAT 0xc001029b | |
| 158 | + | |
| 147 | 159 | #define MAX(a, b) ((a) > (b) ? (a) : (b)) |
| 148 | 160 | |
| 149 | 161 | /* |
| @@ -187,6 +199,7 @@ struct core_data { · 37 unmodified lines | ||
| 187 | 199 | unsigned long long c7; |
| 188 | 200 | unsigned long long mc6_us; /* duplicate as per-core for now, even though per module */ |
| 189 | 201 | unsigned int core_temp_c; |
| 202 | + unsigned int core_energy; /* MSR_CORE_ENERGY_STAT */ | |
| 190 | 203 | unsigned int core_id; |
| 191 | 204 | unsigned long long counter[MAX_ADDED_COUNTERS]; |
| 192 | 205 | } *core_even, *core_odd; |
| @@ -273,6 +286,7 @@ struct system_summary { · 80 unmodified lines | ||
| 273 | 286 | |
| 274 | 287 | struct cpu_topology { |
| 275 | 288 | int physical_package_id; |
| 289 | + int die_id; | |
| 276 | 290 | int logical_cpu_id; |
| 277 | 291 | int physical_node_id; |
| 278 | 292 | int logical_node_id; /* 0-based count within the package */ |
| @@ -283,6 +297,7 @@ struct cpu_topology { · 4 unmodified lines | ||
| 283 | 297 | |
| 284 | 298 | struct topo_params { |
| 285 | 299 | int num_packages; |
| 300 | + int num_die; | |
| 286 | 301 | int num_cpus; |
| 287 | 302 | int num_cores; |
| 288 | 303 | int max_cpu_num; |
| @@ -314,9 +329,8 @@ int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg · 25 unmodified lines | ||
| 314 | 329 | int retval, pkg_no, core_no, thread_no, node_no; |
| 315 | 330 | |
| 316 | 331 | for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) { |
| 317 | − for (core_no = 0; core_no < topo.cores_per_node; ++core_no) { | |
| 318 | − for (node_no = 0; node_no < topo.nodes_per_pkg; | |
| 319 | − node_no++) { | |
| 332 | + for (node_no = 0; node_no < topo.nodes_per_pkg; node_no++) { | |
| 333 | + for (core_no = 0; core_no < topo.cores_per_node; ++core_no) { | |
| 320 | 334 | for (thread_no = 0; thread_no < |
| 321 | 335 | topo.threads_per_core; ++thread_no) { |
| 322 | 336 | struct thread_data *t; |
| @@ -442,6 +456,7 @@ struct msr_counter bic[] = { · 119 unmodified lines | ||
| 442 | 456 | { 0x0, "CPU" }, |
| 443 | 457 | { 0x0, "APIC" }, |
| 444 | 458 | { 0x0, "X2APIC" }, |
| 459 | + { 0x0, "Die" }, | |
| 445 | 460 | }; |
| 446 | 461 | |
| 447 | 462 | #define MAX_BIC (sizeof(bic) / sizeof(struct msr_counter)) |
| @@ -495,6 +510,7 @@ struct msr_counter bic[] = { · 47 unmodified lines | ||
| 495 | 510 | #define BIC_CPU (1ULL << 47) |
| 496 | 511 | #define BIC_APIC (1ULL << 48) |
| 497 | 512 | #define BIC_X2APIC (1ULL << 49) |
| 513 | +#define BIC_Die (1ULL << 50) | |
| 498 | 514 | |
| 499 | 515 | #define BIC_DISABLED_BY_DEFAULT (BIC_USEC | BIC_TOD | BIC_APIC | BIC_X2APIC) |
| 500 | 516 | |
| @@ -621,6 +637,8 @@ void print_header(char *delim) · 120 unmodified lines | ||
| 621 | 637 | outp += sprintf(outp, "%sTime_Of_Day_Seconds", (printed++ ? delim : "")); |
| 622 | 638 | if (DO_BIC(BIC_Package)) |
| 623 | 639 | outp += sprintf(outp, "%sPackage", (printed++ ? delim : "")); |
| 640 | + if (DO_BIC(BIC_Die)) | |
| 641 | + outp += sprintf(outp, "%sDie", (printed++ ? delim : "")); | |
| 624 | 642 | if (DO_BIC(BIC_Node)) |
| 625 | 643 | outp += sprintf(outp, "%sNode", (printed++ ? delim : "")); |
| 626 | 644 | if (DO_BIC(BIC_Core)) |
| @@ -667,7 +685,7 @@ void print_header(char *delim) · 40 unmodified lines | ||
| 667 | 685 | |
| 668 | 686 | if (DO_BIC(BIC_CPU_c1)) |
| 669 | 687 | outp += sprintf(outp, "%sCPU%%c1", (printed++ ? delim : "")); |
| 670 | − if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates && !do_cnl_cstates) | |
| 688 | + if (DO_BIC(BIC_CPU_c3)) | |
| 671 | 689 | outp += sprintf(outp, "%sCPU%%c3", (printed++ ? delim : "")); |
| 672 | 690 | if (DO_BIC(BIC_CPU_c6)) |
| 673 | 691 | outp += sprintf(outp, "%sCPU%%c6", (printed++ ? delim : "")); |
| @@ -680,6 +698,14 @@ void print_header(char *delim) · 6 unmodified lines | ||
| 680 | 698 | if (DO_BIC(BIC_CoreTmp)) |
| 681 | 699 | outp += sprintf(outp, "%sCoreTmp", (printed++ ? delim : "")); |
| 682 | 700 | |
| 701 | + if (do_rapl && !rapl_joules) { | |
| 702 | + if (DO_BIC(BIC_CorWatt) && (do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 703 | + outp += sprintf(outp, "%sCorWatt", (printed++ ? delim : "")); | |
| 704 | + } else if (do_rapl && rapl_joules) { | |
| 705 | + if (DO_BIC(BIC_Cor_J) && (do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 706 | + outp += sprintf(outp, "%sCor_J", (printed++ ? delim : "")); | |
| 707 | + } | |
| 708 | + | |
| 683 | 709 | for (mp = sys.cp; mp; mp = mp->next) { |
| 684 | 710 | if (mp->format == FORMAT_RAW) { |
| 685 | 711 | if (mp->width == 64) |
| @@ -734,7 +760,7 @@ void print_header(char *delim) · 48 unmodified lines | ||
| 734 | 760 | if (do_rapl && !rapl_joules) { |
| 735 | 761 | if (DO_BIC(BIC_PkgWatt)) |
| 736 | 762 | outp += sprintf(outp, "%sPkgWatt", (printed++ ? delim : "")); |
| 737 | − if (DO_BIC(BIC_CorWatt)) | |
| 763 | + if (DO_BIC(BIC_CorWatt) && !(do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 738 | 764 | outp += sprintf(outp, "%sCorWatt", (printed++ ? delim : "")); |
| 739 | 765 | if (DO_BIC(BIC_GFXWatt)) |
| 740 | 766 | outp += sprintf(outp, "%sGFXWatt", (printed++ ? delim : "")); |
| @@ -747,7 +773,7 @@ void print_header(char *delim) · 6 unmodified lines | ||
| 747 | 773 | } else if (do_rapl && rapl_joules) { |
| 748 | 774 | if (DO_BIC(BIC_Pkg_J)) |
| 749 | 775 | outp += sprintf(outp, "%sPkg_J", (printed++ ? delim : "")); |
| 750 | − if (DO_BIC(BIC_Cor_J)) | |
| 776 | + if (DO_BIC(BIC_Cor_J) && !(do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 751 | 777 | outp += sprintf(outp, "%sCor_J", (printed++ ? delim : "")); |
| 752 | 778 | if (DO_BIC(BIC_GFX_J)) |
| 753 | 779 | outp += sprintf(outp, "%sGFX_J", (printed++ ? delim : "")); |
| @@ -808,6 +834,7 @@ int dump_counters(struct thread_data *t, struct core_data *c, · 54 unmodified lines | ||
| 808 | 834 | outp += sprintf(outp, "c6: %016llX\n", c->c6); |
| 809 | 835 | outp += sprintf(outp, "c7: %016llX\n", c->c7); |
| 810 | 836 | outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c); |
| 837 | + outp += sprintf(outp, "Joules: %0X\n", c->core_energy); | |
| 811 | 838 | |
| 812 | 839 | for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) { |
| 813 | 840 | outp += sprintf(outp, "cADDED [%d] msr0x%x: %08llX\n", |
| @@ -904,6 +931,8 @@ int format_counters(struct thread_data *t, struct core_data *c, · 90 unmodified lines | ||
| 904 | 931 | if (t == &average.threads) { |
| 905 | 932 | if (DO_BIC(BIC_Package)) |
| 906 | 933 | outp += sprintf(outp, "%s-", (printed++ ? delim : "")); |
| 934 | + if (DO_BIC(BIC_Die)) | |
| 935 | + outp += sprintf(outp, "%s-", (printed++ ? delim : "")); | |
| 907 | 936 | if (DO_BIC(BIC_Node)) |
| 908 | 937 | outp += sprintf(outp, "%s-", (printed++ ? delim : "")); |
| 909 | 938 | if (DO_BIC(BIC_Core)) |
| @@ -921,6 +950,12 @@ int format_counters(struct thread_data *t, struct core_data *c, · 11 unmodified lines | ||
| 921 | 950 | else |
| 922 | 951 | outp += sprintf(outp, "%s-", (printed++ ? delim : "")); |
| 923 | 952 | } |
| 953 | + if (DO_BIC(BIC_Die)) { | |
| 954 | + if (c) | |
| 955 | + outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), cpus[t->cpu_id].die_id); | |
| 956 | + else | |
| 957 | + outp += sprintf(outp, "%s-", (printed++ ? delim : "")); | |
| 958 | + } | |
| 924 | 959 | if (DO_BIC(BIC_Node)) { |
| 925 | 960 | if (t) |
| 926 | 961 | outp += sprintf(outp, "%s%d", |
| @@ -1003,7 +1038,7 @@ int format_counters(struct thread_data *t, struct core_data *c, · 76 unmodified lines | ||
| 1003 | 1038 | if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE)) |
| 1004 | 1039 | goto done; |
| 1005 | 1040 | |
| 1006 | − if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates && !do_cnl_cstates) | |
| 1041 | + if (DO_BIC(BIC_CPU_c3)) | |
| 1007 | 1042 | outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c3/tsc); |
| 1008 | 1043 | if (DO_BIC(BIC_CPU_c6)) |
| 1009 | 1044 | outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c6/tsc); |
| @@ -1033,6 +1068,20 @@ int format_counters(struct thread_data *t, struct core_data *c, · 23 unmodified lines | ||
| 1033 | 1068 | } |
| 1034 | 1069 | } |
| 1035 | 1070 | |
| 1071 | + /* | |
| 1072 | + * If measurement interval exceeds minimum RAPL Joule Counter range, | |
| 1073 | + * indicate that results are suspect by printing "**" in fraction place. | |
| 1074 | + */ | |
| 1075 | + if (interval_float < rapl_joule_counter_range) | |
| 1076 | + fmt8 = "%s%.2f"; | |
| 1077 | + else | |
| 1078 | + fmt8 = "%6.0f**"; | |
| 1079 | + | |
| 1080 | + if (DO_BIC(BIC_CorWatt) && (do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 1081 | + outp += sprintf(outp, fmt8, (printed++ ? delim : ""), c->core_energy * rapl_energy_units / interval_float); | |
| 1082 | + if (DO_BIC(BIC_Cor_J) && (do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 1083 | + outp += sprintf(outp, fmt8, (printed++ ? delim : ""), c->core_energy * rapl_energy_units); | |
| 1084 | + | |
| 1036 | 1085 | /* print per-package data only for 1st core in package */ |
| 1037 | 1086 | if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) |
| 1038 | 1087 | goto done; |
| @@ -1085,18 +1134,9 @@ int format_counters(struct thread_data *t, struct core_data *c, · 46 unmodified lines | ||
| 1085 | 1134 | if (DO_BIC(BIC_SYS_LPI)) |
| 1086 | 1135 | outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->sys_lpi / 1000000.0 / interval_float); |
| 1087 | 1136 | |
| 1088 | − /* | |
| 1089 | − * If measurement interval exceeds minimum RAPL Joule Counter range, | |
| 1090 | − * indicate that results are suspect by printing "**" in fraction place. | |
| 1091 | − */ | |
| 1092 | − if (interval_float < rapl_joule_counter_range) | |
| 1093 | − fmt8 = "%s%.2f"; | |
| 1094 | − else | |
| 1095 | − fmt8 = "%6.0f**"; | |
| 1096 | − | |
| 1097 | 1137 | if (DO_BIC(BIC_PkgWatt)) |
| 1098 | 1138 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_pkg * rapl_energy_units / interval_float); |
| 1099 | − if (DO_BIC(BIC_CorWatt)) | |
| 1139 | + if (DO_BIC(BIC_CorWatt) && !(do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 1100 | 1140 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_cores * rapl_energy_units / interval_float); |
| 1101 | 1141 | if (DO_BIC(BIC_GFXWatt)) |
| 1102 | 1142 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_gfx * rapl_energy_units / interval_float); |
| @@ -1104,7 +1144,7 @@ int format_counters(struct thread_data *t, struct core_data *c, · 1 unmodified line | ||
| 1104 | 1144 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_dram * rapl_dram_energy_units / interval_float); |
| 1105 | 1145 | if (DO_BIC(BIC_Pkg_J)) |
| 1106 | 1146 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_pkg * rapl_energy_units); |
| 1107 | − if (DO_BIC(BIC_Cor_J)) | |
| 1147 | + if (DO_BIC(BIC_Cor_J) && !(do_rapl & RAPL_PER_CORE_ENERGY)) | |
| 1108 | 1148 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_cores * rapl_energy_units); |
| 1109 | 1149 | if (DO_BIC(BIC_GFX_J)) |
| 1110 | 1150 | outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_gfx * rapl_energy_units); |
| @@ -1249,6 +1289,8 @@ delta_core(struct core_data *new, struct core_data *old) · 138 unmodified lines | ||
| 1249 | 1289 | old->core_temp_c = new->core_temp_c; |
| 1250 | 1290 | old->mc6_us = new->mc6_us - old->mc6_us; |
| 1251 | 1291 | |
| 1292 | + DELTA_WRAP32(new->core_energy, old->core_energy); | |
| 1293 | + | |
| 1252 | 1294 | for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) { |
| 1253 | 1295 | if (mp->format == FORMAT_RAW) |
| 1254 | 1296 | old->counter[i] = new->counter[i]; |
| @@ -1391,6 +1433,7 @@ void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data · 136 unmodified lines | ||
| 1391 | 1433 | c->c7 = 0; |
| 1392 | 1434 | c->mc6_us = 0; |
| 1393 | 1435 | c->core_temp_c = 0; |
| 1436 | + c->core_energy = 0; | |
| 1394 | 1437 | |
| 1395 | 1438 | p->pkg_wtd_core_c0 = 0; |
| 1396 | 1439 | p->pkg_any_core_c0 = 0; |
| @@ -1473,6 +1516,8 @@ int sum_counters(struct thread_data *t, struct core_data *c, · 76 unmodified lines | ||
| 1473 | 1516 | |
| 1474 | 1517 | average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c); |
| 1475 | 1518 | |
| 1519 | + average.cores.core_energy += c->core_energy; | |
| 1520 | + | |
| 1476 | 1521 | for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) { |
| 1477 | 1522 | if (mp->format == FORMAT_RAW) |
| 1478 | 1523 | continue; |
| @@ -1818,7 +1863,7 @@ retry: · 339 unmodified lines | ||
| 1818 | 1863 | if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE)) |
| 1819 | 1864 | goto done; |
| 1820 | 1865 | |
| 1821 | − if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates && !do_cnl_cstates) { | |
| 1866 | + if (DO_BIC(BIC_CPU_c3)) { | |
| 1822 | 1867 | if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3)) |
| 1823 | 1868 | return -6; |
| 1824 | 1869 | } |
| @@ -1845,6 +1890,12 @@ retry: · 20 unmodified lines | ||
| 1845 | 1890 | c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F); |
| 1846 | 1891 | } |
| 1847 | 1892 | |
| 1893 | + if (do_rapl & RAPL_AMD_F17H) { | |
| 1894 | + if (get_msr(cpu, MSR_CORE_ENERGY_STAT, &msr)) | |
| 1895 | + return -14; | |
| 1896 | + c->core_energy = msr & 0xFFFFFFFF; | |
| 1897 | + } | |
| 1898 | + | |
| 1848 | 1899 | for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) { |
| 1849 | 1900 | if (get_mp(cpu, mp, &c->counter[i])) |
| 1850 | 1901 | return -10; |
| @@ -1934,6 +1985,11 @@ retry: · 83 unmodified lines | ||
| 1934 | 1985 | return -16; |
| 1935 | 1986 | p->rapl_dram_perf_status = msr & 0xFFFFFFFF; |
| 1936 | 1987 | } |
| 1988 | + if (do_rapl & RAPL_AMD_F17H) { | |
| 1989 | + if (get_msr(cpu, MSR_PKG_ENERGY_STAT, &msr)) | |
| 1990 | + return -13; | |
| 1991 | + p->energy_pkg = msr & 0xFFFFFFFF; | |
| 1992 | + } | |
| 1937 | 1993 | if (DO_BIC(BIC_PkgTmp)) { |
| 1938 | 1994 | if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr)) |
| 1939 | 1995 | return -17; |
| @@ -2456,6 +2512,8 @@ void free_all_buffers(void) · 516 unmodified lines | ||
| 2456 | 2512 | |
| 2457 | 2513 | /* |
| 2458 | 2514 | * Parse a file containing a single int. |
| 2515 | + * Return 0 if file can not be opened | |
| 2516 | + * Exit if file can be opened, but can not be parsed | |
| 2459 | 2517 | */ |
| 2460 | 2518 | int parse_int_file(const char *fmt, ...) |
| 2461 | 2519 | { |
| @@ -2467,7 +2525,9 @@ int parse_int_file(const char *fmt, ...) · 5 unmodified lines | ||
| 2467 | 2525 | va_start(args, fmt); |
| 2468 | 2526 | vsnprintf(path, sizeof(path), fmt, args); |
| 2469 | 2527 | va_end(args); |
| 2470 | − filep = fopen_or_die(path, "r"); | |
| 2528 | + filep = fopen(path, "r"); | |
| 2529 | + if (!filep) | |
| 2530 | + return 0; | |
| 2471 | 2531 | if (fscanf(filep, "%d", &value) != 1) |
| 2472 | 2532 | err(1, "%s: failed to parse number from file", path); |
| 2473 | 2533 | fclose(filep); |
| @@ -2488,6 +2548,11 @@ int get_physical_package_id(int cpu) · 14 unmodified lines | ||
| 2488 | 2548 | return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu); |
| 2489 | 2549 | } |
| 2490 | 2550 | |
| 2551 | +int get_die_id(int cpu) | |
| 2552 | +{ | |
| 2553 | + return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/die_id", cpu); | |
| 2554 | +} | |
| 2555 | + | |
| 2491 | 2556 | int get_core_id(int cpu) |
| 2492 | 2557 | { |
| 2493 | 2558 | return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu); |
| @@ -2578,7 +2643,8 @@ int get_thread_siblings(struct cpu_topology *thiscpu) · 84 unmodified lines | ||
| 2578 | 2643 | filep = fopen_or_die(path, "r"); |
| 2579 | 2644 | do { |
| 2580 | 2645 | offset -= BITMASK_SIZE; |
| 2581 | − fscanf(filep, "%lx%c", &map, &character); | |
| 2646 | + if (fscanf(filep, "%lx%c", &map, &character) != 2) | |
| 2647 | + err(1, "%s: failed to parse file", path); | |
| 2582 | 2648 | for (shift = 0; shift < BITMASK_SIZE; shift++) { |
| 2583 | 2649 | if ((map >> shift) & 0x1) { |
| 2584 | 2650 | so = shift + offset; |
| @@ -2855,8 +2921,11 @@ int snapshot_cpu_lpi_us(void) · 270 unmodified lines | ||
| 2855 | 2921 | fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us", "r"); |
| 2856 | 2922 | |
| 2857 | 2923 | retval = fscanf(fp, "%lld", &cpuidle_cur_cpu_lpi_us); |
| 2858 | − if (retval != 1) | |
| 2859 | − err(1, "CPU LPI"); | |
| 2924 | + if (retval != 1) { | |
| 2925 | + fprintf(stderr, "Disabling Low Power Idle CPU output\n"); | |
| 2926 | + BIC_NOT_PRESENT(BIC_CPU_LPI); | |
| 2927 | + return -1; | |
| 2928 | + } | |
| 2860 | 2929 | |
| 2861 | 2930 | fclose(fp); |
| 2862 | 2931 | |
| @@ -2878,9 +2947,11 @@ int snapshot_sys_lpi_us(void) · 15 unmodified lines | ||
| 2878 | 2947 | fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", "r"); |
| 2879 | 2948 | |
| 2880 | 2949 | retval = fscanf(fp, "%lld", &cpuidle_cur_sys_lpi_us); |
| 2881 | − if (retval != 1) | |
| 2882 | − err(1, "SYS LPI"); | |
| 2883 | − | |
| 2950 | + if (retval != 1) { | |
| 2951 | + fprintf(stderr, "Disabling Low Power Idle System output\n"); | |
| 2952 | + BIC_NOT_PRESENT(BIC_SYS_LPI); | |
| 2953 | + return -1; | |
| 2954 | + } | |
| 2884 | 2955 | fclose(fp); |
| 2885 | 2956 | |
| 2886 | 2957 | return 0; |
| @@ -3410,14 +3481,14 @@ dump_sysfs_cstate_config(void) · 523 unmodified lines | ||
| 3410 | 3481 | input = fopen(path, "r"); |
| 3411 | 3482 | if (input == NULL) |
| 3412 | 3483 | continue; |
| 3413 | − fgets(name_buf, sizeof(name_buf), input); | |
| 3484 | + if (!fgets(name_buf, sizeof(name_buf), input)) | |
| 3485 | + err(1, "%s: failed to read file", path); | |
| 3414 | 3486 | |
| 3415 | 3487 | /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */ |
| 3416 | 3488 | sp = strchr(name_buf, '-'); |
| 3417 | 3489 | if (!sp) |
| 3418 | 3490 | sp = strchrnul(name_buf, '\n'); |
| 3419 | 3491 | *sp = '\0'; |
| 3420 | − | |
| 3421 | 3492 | fclose(input); |
| 3422 | 3493 | |
| 3423 | 3494 | sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/desc", |
| @@ -3425,7 +3496,8 @@ dump_sysfs_cstate_config(void) · 1 unmodified line | ||
| 3425 | 3496 | input = fopen(path, "r"); |
| 3426 | 3497 | if (input == NULL) |
| 3427 | 3498 | continue; |
| 3428 | − fgets(desc, sizeof(desc), input); | |
| 3499 | + if (!fgets(desc, sizeof(desc), input)) | |
| 3500 | + err(1, "%s: failed to read file", path); | |
| 3429 | 3501 | |
| 3430 | 3502 | fprintf(outf, "cpu%d: %s: %s", base_cpu, name_buf, desc); |
| 3431 | 3503 | fclose(input); |
| @@ -3444,20 +3516,22 @@ dump_sysfs_pstate_config(void) · 12 unmodified lines | ||
| 3444 | 3516 | base_cpu); |
| 3445 | 3517 | input = fopen(path, "r"); |
| 3446 | 3518 | if (input == NULL) { |
| 3447 | − fprintf(stderr, "NSFOD %s\n", path); | |
| 3519 | + fprintf(outf, "NSFOD %s\n", path); | |
| 3448 | 3520 | return; |
| 3449 | 3521 | } |
| 3450 | − fgets(driver_buf, sizeof(driver_buf), input); | |
| 3522 | + if (!fgets(driver_buf, sizeof(driver_buf), input)) | |
| 3523 | + err(1, "%s: failed to read file", path); | |
| 3451 | 3524 | fclose(input); |
| 3452 | 3525 | |
| 3453 | 3526 | sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_governor", |
| 3454 | 3527 | base_cpu); |
| 3455 | 3528 | input = fopen(path, "r"); |
| 3456 | 3529 | if (input == NULL) { |
| 3457 | − fprintf(stderr, "NSFOD %s\n", path); | |
| 3530 | + fprintf(outf, "NSFOD %s\n", path); | |
| 3458 | 3531 | return; |
| 3459 | 3532 | } |
| 3460 | − fgets(governor_buf, sizeof(governor_buf), input); | |
| 3533 | + if (!fgets(governor_buf, sizeof(governor_buf), input)) | |
| 3534 | + err(1, "%s: failed to read file", path); | |
| 3461 | 3535 | fclose(input); |
| 3462 | 3536 | |
| 3463 | 3537 | fprintf(outf, "cpu%d: cpufreq driver: %s", base_cpu, driver_buf); |
| @@ -3466,7 +3540,8 @@ dump_sysfs_pstate_config(void) · 2 unmodified lines | ||
| 3466 | 3540 | sprintf(path, "/sys/devices/system/cpu/cpufreq/boost"); |
| 3467 | 3541 | input = fopen(path, "r"); |
| 3468 | 3542 | if (input != NULL) { |
| 3469 | − fscanf(input, "%d", &turbo); | |
| 3543 | + if (fscanf(input, "%d", &turbo) != 1) | |
| 3544 | + err(1, "%s: failed to parse number from file", path); | |
| 3470 | 3545 | fprintf(outf, "cpufreq boost: %d\n", turbo); |
| 3471 | 3546 | fclose(input); |
| 3472 | 3547 | } |
| @@ -3474,7 +3549,8 @@ dump_sysfs_pstate_config(void) · 1 unmodified line | ||
| 3474 | 3549 | sprintf(path, "/sys/devices/system/cpu/intel_pstate/no_turbo"); |
| 3475 | 3550 | input = fopen(path, "r"); |
| 3476 | 3551 | if (input != NULL) { |
| 3477 | − fscanf(input, "%d", &turbo); | |
| 3552 | + if (fscanf(input, "%d", &turbo) != 1) | |
| 3553 | + err(1, "%s: failed to parse number from file", path); | |
| 3478 | 3554 | fprintf(outf, "cpufreq intel_pstate no_turbo: %d\n", turbo); |
| 3479 | 3555 | fclose(input); |
| 3480 | 3556 | } |
| @@ -3718,7 +3794,7 @@ int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data · 237 unmodified lines | ||
| 3718 | 3794 | #define RAPL_POWER_GRANULARITY 0x7FFF /* 15 bit power granularity */ |
| 3719 | 3795 | #define RAPL_TIME_GRANULARITY 0x3F /* 6 bit time granularity */ |
| 3720 | 3796 | |
| 3721 | −double get_tdp(unsigned int model) | |
| 3797 | +double get_tdp_intel(unsigned int model) | |
| 3722 | 3798 | { |
| 3723 | 3799 | unsigned long long msr; |
| 3724 | 3800 | |
| @@ -3735,6 +3811,16 @@ double get_tdp(unsigned int model) · 10 unmodified lines | ||
| 3735 | 3811 | } |
| 3736 | 3812 | } |
| 3737 | 3813 | |
| 3814 | +double get_tdp_amd(unsigned int family) | |
| 3815 | +{ | |
| 3816 | + switch (family) { | |
| 3817 | + case 0x17: | |
| 3818 | + default: | |
| 3819 | + /* This is the max stock TDP of HEDT/Server Fam17h chips */ | |
| 3820 | + return 250.0; | |
| 3821 | + } | |
| 3822 | +} | |
| 3823 | + | |
| 3738 | 3824 | /* |
| 3739 | 3825 | * rapl_dram_energy_units_probe() |
| 3740 | 3826 | * Energy units are either hard-coded, or come from RAPL Energy Unit MSR. |
| @@ -3754,21 +3840,12 @@ rapl_dram_energy_units_probe(int model, double rapl_energy_units) · 13 unmodified lines | ||
| 3754 | 3840 | } |
| 3755 | 3841 | } |
| 3756 | 3842 | |
| 3757 | − | |
| 3758 | −/* | |
| 3759 | − * rapl_probe() | |
| 3760 | − * | |
| 3761 | − * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units | |
| 3762 | − */ | |
| 3763 | −void rapl_probe(unsigned int family, unsigned int model) | |
| 3843 | +void rapl_probe_intel(unsigned int family, unsigned int model) | |
| 3764 | 3844 | { |
| 3765 | 3845 | unsigned long long msr; |
| 3766 | 3846 | unsigned int time_unit; |
| 3767 | 3847 | double tdp; |
| 3768 | 3848 | |
| 3769 | − if (!genuine_intel) | |
| 3770 | − return; | |
| 3771 | − | |
| 3772 | 3849 | if (family != 6) |
| 3773 | 3850 | return; |
| 3774 | 3851 | |
| @@ -3892,13 +3969,69 @@ void rapl_probe(unsigned int family, unsigned int model) · 117 unmodified lines | ||
| 3892 | 3969 | |
| 3893 | 3970 | rapl_time_units = 1.0 / (1 << (time_unit)); |
| 3894 | 3971 | |
| 3895 | − tdp = get_tdp(model); | |
| 3972 | + tdp = get_tdp_intel(model); | |
| 3896 | 3973 | |
| 3897 | 3974 | rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp; |
| 3898 | 3975 | if (!quiet) |
| 3899 | 3976 | fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp); |
| 3977 | +} | |
| 3900 | 3978 | |
| 3901 | − return; | |
| 3979 | +void rapl_probe_amd(unsigned int family, unsigned int model) | |
| 3980 | +{ | |
| 3981 | + unsigned long long msr; | |
| 3982 | + unsigned int eax, ebx, ecx, edx; | |
| 3983 | + unsigned int has_rapl = 0; | |
| 3984 | + double tdp; | |
| 3985 | + | |
| 3986 | + if (max_extended_level >= 0x80000007) { | |
| 3987 | + __cpuid(0x80000007, eax, ebx, ecx, edx); | |
| 3988 | + /* RAPL (Fam 17h) */ | |
| 3989 | + has_rapl = edx & (1 << 14); | |
| 3990 | + } | |
| 3991 | + | |
| 3992 | + if (!has_rapl) | |
| 3993 | + return; | |
| 3994 | + | |
| 3995 | + switch (family) { | |
| 3996 | + case 0x17: /* Zen, Zen+ */ | |
| 3997 | + do_rapl = RAPL_AMD_F17H | RAPL_PER_CORE_ENERGY; | |
| 3998 | + if (rapl_joules) { | |
| 3999 | + BIC_PRESENT(BIC_Pkg_J); | |
| 4000 | + BIC_PRESENT(BIC_Cor_J); | |
| 4001 | + } else { | |
| 4002 | + BIC_PRESENT(BIC_PkgWatt); | |
| 4003 | + BIC_PRESENT(BIC_CorWatt); | |
| 4004 | + } | |
| 4005 | + break; | |
| 4006 | + default: | |
| 4007 | + return; | |
| 4008 | + } | |
| 4009 | + | |
| 4010 | + if (get_msr(base_cpu, MSR_RAPL_PWR_UNIT, &msr)) | |
| 4011 | + return; | |
| 4012 | + | |
| 4013 | + rapl_time_units = ldexp(1.0, -(msr >> 16 & 0xf)); | |
| 4014 | + rapl_energy_units = ldexp(1.0, -(msr >> 8 & 0x1f)); | |
| 4015 | + rapl_power_units = ldexp(1.0, -(msr & 0xf)); | |
| 4016 | + | |
| 4017 | + tdp = get_tdp_amd(model); | |
| 4018 | + | |
| 4019 | + rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp; | |
| 4020 | + if (!quiet) | |
| 4021 | + fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp); | |
| 4022 | +} | |
| 4023 | + | |
| 4024 | +/* | |
| 4025 | + * rapl_probe() | |
| 4026 | + * | |
| 4027 | + * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units | |
| 4028 | + */ | |
| 4029 | +void rapl_probe(unsigned int family, unsigned int model) | |
| 4030 | +{ | |
| 4031 | + if (genuine_intel) | |
| 4032 | + rapl_probe_intel(family, model); | |
| 4033 | + if (authentic_amd) | |
| 4034 | + rapl_probe_amd(family, model); | |
| 3902 | 4035 | } |
| 3903 | 4036 | |
| 3904 | 4037 | void perf_limit_reasons_probe(unsigned int family, unsigned int model) |
| @@ -4003,6 +4136,7 @@ void print_power_limit_msr(int cpu, unsigned long long msr, char *label) · 98 unmodified lines | ||
| 4003 | 4136 | int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p) |
| 4004 | 4137 | { |
| 4005 | 4138 | unsigned long long msr; |
| 4139 | + const char *msr_name; | |
| 4006 | 4140 | int cpu; |
| 4007 | 4141 | |
| 4008 | 4142 | if (!do_rapl) |
| @@ -4018,10 +4152,17 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p) · 9 unmodified lines | ||
| 4018 | 4152 | return -1; |
| 4019 | 4153 | } |
| 4020 | 4154 | |
| 4021 | − if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr)) | |
| 4022 | − return -1; | |
| 4155 | + if (do_rapl & RAPL_AMD_F17H) { | |
| 4156 | + msr_name = "MSR_RAPL_PWR_UNIT"; | |
| 4157 | + if (get_msr(cpu, MSR_RAPL_PWR_UNIT, &msr)) | |
| 4158 | + return -1; | |
| 4159 | + } else { | |
| 4160 | + msr_name = "MSR_RAPL_POWER_UNIT"; | |
| 4161 | + if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr)) | |
| 4162 | + return -1; | |
| 4163 | + } | |
| 4023 | 4164 | |
| 4024 | − fprintf(outf, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx (%f Watts, %f Joules, %f sec.)\n", cpu, msr, | |
| 4165 | + fprintf(outf, "cpu%d: %s: 0x%08llx (%f Watts, %f Joules, %f sec.)\n", cpu, msr_name, msr, | |
| 4025 | 4166 | rapl_power_units, rapl_energy_units, rapl_time_units); |
| 4026 | 4167 | |
| 4027 | 4168 | if (do_rapl & RAPL_PKG_POWER_INFO) { |
| @@ -4451,6 +4592,9 @@ unsigned int intel_model_duplicates(unsigned int model) · 423 unmodified lines | ||
| 4451 | 4592 | case INTEL_FAM6_KABYLAKE_MOBILE: |
| 4452 | 4593 | case INTEL_FAM6_KABYLAKE_DESKTOP: |
| 4453 | 4594 | return INTEL_FAM6_SKYLAKE_MOBILE; |
| 4595 | + | |
| 4596 | + case INTEL_FAM6_ICELAKE_MOBILE: | |
| 4597 | + return INTEL_FAM6_CANNONLAKE_MOBILE; | |
| 4454 | 4598 | } |
| 4455 | 4599 | return model; |
| 4456 | 4600 | } |
| @@ -4702,7 +4846,9 @@ void process_cpuid() · 245 unmodified lines | ||
| 4702 | 4846 | } |
| 4703 | 4847 | do_slm_cstates = is_slm(family, model); |
| 4704 | 4848 | do_knl_cstates = is_knl(family, model); |
| 4705 | − do_cnl_cstates = is_cnl(family, model); | |
| 4849 | + | |
| 4850 | + if (do_slm_cstates || do_knl_cstates || is_cnl(family, model)) | |
| 4851 | + BIC_NOT_PRESENT(BIC_CPU_c3); | |
| 4706 | 4852 | |
| 4707 | 4853 | if (!quiet) |
| 4708 | 4854 | decode_misc_pwr_mgmt_msr(); |
| @@ -4769,6 +4915,7 @@ void topology_probe() · 60 unmodified lines | ||
| 4769 | 4915 | int i; |
| 4770 | 4916 | int max_core_id = 0; |
| 4771 | 4917 | int max_package_id = 0; |
| 4918 | + int max_die_id = 0; | |
| 4772 | 4919 | int max_siblings = 0; |
| 4773 | 4920 | |
| 4774 | 4921 | /* Initialize num_cpus, max_cpu_num */ |
| @@ -4835,6 +4982,11 @@ void topology_probe() · 60 unmodified lines | ||
| 4835 | 4982 | if (cpus[i].physical_package_id > max_package_id) |
| 4836 | 4983 | max_package_id = cpus[i].physical_package_id; |
| 4837 | 4984 | |
| 4985 | + /* get die information */ | |
| 4986 | + cpus[i].die_id = get_die_id(i); | |
| 4987 | + if (cpus[i].die_id > max_die_id) | |
| 4988 | + max_die_id = cpus[i].die_id; | |
| 4989 | + | |
| 4838 | 4990 | /* get numa node information */ |
| 4839 | 4991 | cpus[i].physical_node_id = get_physical_node_id(&cpus[i]); |
| 4840 | 4992 | if (cpus[i].physical_node_id > topo.max_node_num) |
| @@ -4860,6 +5012,13 @@ void topology_probe() · 19 unmodified lines | ||
| 4860 | 5012 | if (!summary_only && topo.cores_per_node > 1) |
| 4861 | 5013 | BIC_PRESENT(BIC_Core); |
| 4862 | 5014 | |
| 5015 | + topo.num_die = max_die_id + 1; | |
| 5016 | + if (debug > 1) | |
| 5017 | + fprintf(outf, "max_die_id %d, sizing for %d die\n", | |
| 5018 | + max_die_id, topo.num_die); | |
| 5019 | + if (!summary_only && topo.num_die > 1) | |
| 5020 | + BIC_PRESENT(BIC_Die); | |
| 5021 | + | |
| 4863 | 5022 | topo.num_packages = max_package_id + 1; |
| 4864 | 5023 | if (debug > 1) |
| 4865 | 5024 | fprintf(outf, "max_package_id %d, sizing for %d packages\n", |
| @@ -4884,8 +5043,8 @@ void topology_probe() · 18 unmodified lines | ||
| 4884 | 5043 | if (cpu_is_not_present(i)) |
| 4885 | 5044 | continue; |
| 4886 | 5045 | fprintf(outf, |
| 4887 | − "cpu %d pkg %d node %d lnode %d core %d thread %d\n", | |
| 4888 | − i, cpus[i].physical_package_id, | |
| 5046 | + "cpu %d pkg %d die %d node %d lnode %d core %d thread %d\n", | |
| 5047 | + i, cpus[i].physical_package_id, cpus[i].die_id, | |
| 4889 | 5048 | cpus[i].physical_node_id, |
| 4890 | 5049 | cpus[i].logical_node_id, |
| 4891 | 5050 | cpus[i].physical_core_id, |
| @@ -5122,7 +5281,7 @@ int get_and_dump_counters(void) · 230 unmodified lines | ||
| 5122 | 5281 | } |
| 5123 | 5282 | |
| 5124 | 5283 | void print_version() { |
| 5125 | − fprintf(outf, "turbostat version 18.07.27" | |
| 5284 | + fprintf(outf, "turbostat version 19.03.20" | |
| 5126 | 5285 | " - Len Brown <lenb@kernel.org>\n"); |
| 5127 | 5286 | } |
| 5128 | 5287 | |
| @@ -5319,7 +5478,8 @@ void probe_sysfs(void) · 190 unmodified lines | ||
| 5319 | 5478 | input = fopen(path, "r"); |
| 5320 | 5479 | if (input == NULL) |
| 5321 | 5480 | continue; |
| 5322 | − fgets(name_buf, sizeof(name_buf), input); | |
| 5481 | + if (!fgets(name_buf, sizeof(name_buf), input)) | |
| 5482 | + err(1, "%s: failed to read file", path); | |
| 5323 | 5483 | |
| 5324 | 5484 | /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */ |
| 5325 | 5485 | sp = strchr(name_buf, '-'); |
| @@ -5346,7 +5506,8 @@ void probe_sysfs(void) · 20 unmodified lines | ||
| 5346 | 5506 | input = fopen(path, "r"); |
| 5347 | 5507 | if (input == NULL) |
| 5348 | 5508 | continue; |
| 5349 | − fgets(name_buf, sizeof(name_buf), input); | |
| 5509 | + if (!fgets(name_buf, sizeof(name_buf), input)) | |
| 5510 | + err(1, "%s: failed to read file", path); | |
| 5350 | 5511 | /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */ |
| 5351 | 5512 | sp = strchr(name_buf, '-'); |
| 5352 | 5513 | if (!sp) |
| @@ -39,6 +39,58 @@ static struct bpf_flow_keys pkt_v6_flow_keys = { · 38 unmodified lines | ||
| 39 | 39 | .n_proto = __bpf_constant_htons(ETH_P_IPV6), |
| 40 | 40 | }; |
| 41 | 41 | |
| 42 | +#define VLAN_HLEN 4 | |
| 43 | + | |
| 44 | +static struct { | |
| 45 | + struct ethhdr eth; | |
| 46 | + __u16 vlan_tci; | |
| 47 | + __u16 vlan_proto; | |
| 48 | + struct iphdr iph; | |
| 49 | + struct tcphdr tcp; | |
| 50 | +} __packed pkt_vlan_v4 = { | |
| 51 | + .eth.h_proto = __bpf_constant_htons(ETH_P_8021Q), | |
| 52 | + .vlan_proto = __bpf_constant_htons(ETH_P_IP), | |
| 53 | + .iph.ihl = 5, | |
| 54 | + .iph.protocol = IPPROTO_TCP, | |
| 55 | + .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), | |
| 56 | + .tcp.urg_ptr = 123, | |
| 57 | + .tcp.doff = 5, | |
| 58 | +}; | |
| 59 | + | |
| 60 | +static struct bpf_flow_keys pkt_vlan_v4_flow_keys = { | |
| 61 | + .nhoff = VLAN_HLEN, | |
| 62 | + .thoff = VLAN_HLEN + sizeof(struct iphdr), | |
| 63 | + .addr_proto = ETH_P_IP, | |
| 64 | + .ip_proto = IPPROTO_TCP, | |
| 65 | + .n_proto = __bpf_constant_htons(ETH_P_IP), | |
| 66 | +}; | |
| 67 | + | |
| 68 | +static struct { | |
| 69 | + struct ethhdr eth; | |
| 70 | + __u16 vlan_tci; | |
| 71 | + __u16 vlan_proto; | |
| 72 | + __u16 vlan_tci2; | |
| 73 | + __u16 vlan_proto2; | |
| 74 | + struct ipv6hdr iph; | |
| 75 | + struct tcphdr tcp; | |
| 76 | +} __packed pkt_vlan_v6 = { | |
| 77 | + .eth.h_proto = __bpf_constant_htons(ETH_P_8021AD), | |
| 78 | + .vlan_proto = __bpf_constant_htons(ETH_P_8021Q), | |
| 79 | + .vlan_proto2 = __bpf_constant_htons(ETH_P_IPV6), | |
| 80 | + .iph.nexthdr = IPPROTO_TCP, | |
| 81 | + .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), | |
| 82 | + .tcp.urg_ptr = 123, | |
| 83 | + .tcp.doff = 5, | |
| 84 | +}; | |
| 85 | + | |
| 86 | +static struct bpf_flow_keys pkt_vlan_v6_flow_keys = { | |
| 87 | + .nhoff = VLAN_HLEN * 2, | |
| 88 | + .thoff = VLAN_HLEN * 2 + sizeof(struct ipv6hdr), | |
| 89 | + .addr_proto = ETH_P_IPV6, | |
| 90 | + .ip_proto = IPPROTO_TCP, | |
| 91 | + .n_proto = __bpf_constant_htons(ETH_P_IPV6), | |
| 92 | +}; | |
| 93 | + | |
| 42 | 94 | void test_flow_dissector(void) |
| 43 | 95 | { |
| 44 | 96 | struct bpf_flow_keys flow_keys; |
| @@ -68,5 +120,21 @@ void test_flow_dissector(void) · 23 unmodified lines | ||
| 68 | 120 | err, errno, retval, duration, size, sizeof(flow_keys)); |
| 69 | 121 | CHECK_FLOW_KEYS("ipv6_flow_keys", flow_keys, pkt_v6_flow_keys); |
| 70 | 122 | |
| 123 | + err = bpf_prog_test_run(prog_fd, 10, &pkt_vlan_v4, sizeof(pkt_vlan_v4), | |
| 124 | + &flow_keys, &size, &retval, &duration); | |
| 125 | + CHECK(size != sizeof(flow_keys) || err || retval != 1, "vlan_ipv4", | |
| 126 | + "err %d errno %d retval %d duration %d size %u/%lu\n", | |
| 127 | + err, errno, retval, duration, size, sizeof(flow_keys)); | |
| 128 | + CHECK_FLOW_KEYS("vlan_ipv4_flow_keys", flow_keys, | |
| 129 | + pkt_vlan_v4_flow_keys); | |
| 130 | + | |
| 131 | + err = bpf_prog_test_run(prog_fd, 10, &pkt_vlan_v6, sizeof(pkt_vlan_v6), | |
| 132 | + &flow_keys, &size, &retval, &duration); | |
| 133 | + CHECK(size != sizeof(flow_keys) || err || retval != 1, "vlan_ipv6", | |
| 134 | + "err %d errno %d retval %d duration %d size %u/%lu\n", | |
| 135 | + err, errno, retval, duration, size, sizeof(flow_keys)); | |
| 136 | + CHECK_FLOW_KEYS("vlan_ipv6_flow_keys", flow_keys, | |
| 137 | + pkt_vlan_v6_flow_keys); | |
| 138 | + | |
| 71 | 139 | bpf_object__close(obj); |
| 72 | 140 | } |
| @@ -92,7 +92,6 @@ static __always_inline int parse_eth_proto(struct __sk_buff *skb, __be16 proto) · 91 unmodified lines | ||
| 92 | 92 | { |
| 93 | 93 | struct bpf_flow_keys *keys = skb->flow_keys; |
| 94 | 94 | |
| 95 | − keys->n_proto = proto; | |
| 96 | 95 | switch (proto) { |
| 97 | 96 | case bpf_htons(ETH_P_IP): |
| 98 | 97 | bpf_tail_call(skb, &jmp_table, IP); |
| @@ -119,10 +118,9 @@ static __always_inline int parse_eth_proto(struct __sk_buff *skb, __be16 proto) · 20 unmodified lines | ||
| 119 | 118 | SEC("flow_dissector") |
| 120 | 119 | int _dissect(struct __sk_buff *skb) |
| 121 | 120 | { |
| 122 | − if (!skb->vlan_present) | |
| 123 | − return parse_eth_proto(skb, skb->protocol); | |
| 124 | − else | |
| 125 | − return parse_eth_proto(skb, skb->vlan_proto); | |
| 121 | + struct bpf_flow_keys *keys = skb->flow_keys; | |
| 122 | + | |
| 123 | + return parse_eth_proto(skb, keys->n_proto); | |
| 126 | 124 | } |
| 127 | 125 | |
| 128 | 126 | /* Parses on IPPROTO_* */ |
| @@ -336,15 +334,9 @@ PROG(VLAN)(struct __sk_buff *skb) · 207 unmodified lines | ||
| 336 | 334 | { |
| 337 | 335 | struct bpf_flow_keys *keys = skb->flow_keys; |
| 338 | 336 | struct vlan_hdr *vlan, _vlan; |
| 339 | − __be16 proto; | |
| 340 | − | |
| 341 | − /* Peek back to see if single or double-tagging */ | |
| 342 | − if (bpf_skb_load_bytes(skb, keys->thoff - sizeof(proto), &proto, | |
| 343 | − sizeof(proto))) | |
| 344 | − return BPF_DROP; | |
| 345 | 337 | |
| 346 | 338 | /* Account for double-tagging */ |
| 347 | − if (proto == bpf_htons(ETH_P_8021AD)) { | |
| 339 | + if (keys->n_proto == bpf_htons(ETH_P_8021AD)) { | |
| 348 | 340 | vlan = bpf_flow_dissect_get_header(skb, sizeof(*vlan), &_vlan); |
| 349 | 341 | if (!vlan) |
| 350 | 342 | return BPF_DROP; |
| @@ -352,6 +344,7 @@ PROG(VLAN)(struct __sk_buff *skb) · 1 unmodified line | ||
| 352 | 344 | if (vlan->h_vlan_encapsulated_proto != bpf_htons(ETH_P_8021Q)) |
| 353 | 345 | return BPF_DROP; |
| 354 | 346 | |
| 347 | + keys->nhoff += sizeof(*vlan); | |
| 355 | 348 | keys->thoff += sizeof(*vlan); |
| 356 | 349 | } |
| 357 | 350 | |
| @@ -359,12 +352,14 @@ PROG(VLAN)(struct __sk_buff *skb) · 1 unmodified line | ||
| 359 | 352 | if (!vlan) |
| 360 | 353 | return BPF_DROP; |
| 361 | 354 | |
| 355 | + keys->nhoff += sizeof(*vlan); | |
| 362 | 356 | keys->thoff += sizeof(*vlan); |
| 363 | 357 | /* Only allow 8021AD + 8021Q double tagging and no triple tagging.*/ |
| 364 | 358 | if (vlan->h_vlan_encapsulated_proto == bpf_htons(ETH_P_8021AD) || |
| 365 | 359 | vlan->h_vlan_encapsulated_proto == bpf_htons(ETH_P_8021Q)) |
| 366 | 360 | return BPF_DROP; |
| 367 | 361 | |
| 362 | + keys->n_proto = vlan->h_vlan_encapsulated_proto; | |
| 368 | 363 | return parse_eth_proto(skb, vlan->h_vlan_encapsulated_proto); |
| 369 | 364 | } |
| 370 | 365 | |
| @@ -5776,6 +5776,53 @@ const struct btf_dedup_test dedup_tests[] = { · 5775 unmodified lines | ||
| 5776 | 5776 | .dedup_table_size = 1, /* force hash collisions */ |
| 5777 | 5777 | }, |
| 5778 | 5778 | }, |
| 5779 | +{ | |
| 5780 | + .descr = "dedup: void equiv check", | |
| 5781 | + /* | |
| 5782 | + * // CU 1: | |
| 5783 | + * struct s { | |
| 5784 | + * struct {} *x; | |
| 5785 | + * }; | |
| 5786 | + * // CU 2: | |
| 5787 | + * struct s { | |
| 5788 | + * int *x; | |
| 5789 | + * }; | |
| 5790 | + */ | |
| 5791 | + .input = { | |
| 5792 | + .raw_types = { | |
| 5793 | + /* CU 1 */ | |
| 5794 | + BTF_STRUCT_ENC(0, 0, 1), /* [1] struct {} */ | |
| 5795 | + BTF_PTR_ENC(1), /* [2] ptr -> [1] */ | |
| 5796 | + BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [3] struct s */ | |
| 5797 | + BTF_MEMBER_ENC(NAME_NTH(2), 2, 0), | |
| 5798 | + /* CU 2 */ | |
| 5799 | + BTF_PTR_ENC(0), /* [4] ptr -> void */ | |
| 5800 | + BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [5] struct s */ | |
| 5801 | + BTF_MEMBER_ENC(NAME_NTH(2), 4, 0), | |
| 5802 | + BTF_END_RAW, | |
| 5803 | + }, | |
| 5804 | + BTF_STR_SEC("\0s\0x"), | |
| 5805 | + }, | |
| 5806 | + .expect = { | |
| 5807 | + .raw_types = { | |
| 5808 | + /* CU 1 */ | |
| 5809 | + BTF_STRUCT_ENC(0, 0, 1), /* [1] struct {} */ | |
| 5810 | + BTF_PTR_ENC(1), /* [2] ptr -> [1] */ | |
| 5811 | + BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [3] struct s */ | |
| 5812 | + BTF_MEMBER_ENC(NAME_NTH(2), 2, 0), | |
| 5813 | + /* CU 2 */ | |
| 5814 | + BTF_PTR_ENC(0), /* [4] ptr -> void */ | |
| 5815 | + BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [5] struct s */ | |
| 5816 | + BTF_MEMBER_ENC(NAME_NTH(2), 4, 0), | |
| 5817 | + BTF_END_RAW, | |
| 5818 | + }, | |
| 5819 | + BTF_STR_SEC("\0s\0x"), | |
| 5820 | + }, | |
| 5821 | + .opts = { | |
| 5822 | + .dont_resolve_fwds = false, | |
| 5823 | + .dedup_table_size = 1, /* force hash collisions */ | |
| 5824 | + }, | |
| 5825 | +}, | |
| 5779 | 5826 | { |
| 5780 | 5827 | .descr = "dedup: all possible kinds (no duplicates)", |
| 5781 | 5828 | .input = { |
| @@ -907,6 +907,44 @@ · 906 unmodified lines | ||
| 907 | 907 | .errstr = "call stack", |
| 908 | 908 | .result = REJECT, |
| 909 | 909 | }, |
| 910 | +{ | |
| 911 | + "calls: stack depth check in dead code", | |
| 912 | + .insns = { | |
| 913 | + /* main */ | |
| 914 | + BPF_MOV64_IMM(BPF_REG_1, 0), | |
| 915 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call A */ | |
| 916 | + BPF_EXIT_INSN(), | |
| 917 | + /* A */ | |
| 918 | + BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1), | |
| 919 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 2), /* call B */ | |
| 920 | + BPF_MOV64_IMM(BPF_REG_0, 0), | |
| 921 | + BPF_EXIT_INSN(), | |
| 922 | + /* B */ | |
| 923 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call C */ | |
| 924 | + BPF_EXIT_INSN(), | |
| 925 | + /* C */ | |
| 926 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call D */ | |
| 927 | + BPF_EXIT_INSN(), | |
| 928 | + /* D */ | |
| 929 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call E */ | |
| 930 | + BPF_EXIT_INSN(), | |
| 931 | + /* E */ | |
| 932 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call F */ | |
| 933 | + BPF_EXIT_INSN(), | |
| 934 | + /* F */ | |
| 935 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call G */ | |
| 936 | + BPF_EXIT_INSN(), | |
| 937 | + /* G */ | |
| 938 | + BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call H */ | |
| 939 | + BPF_EXIT_INSN(), | |
| 940 | + /* H */ | |
| 941 | + BPF_MOV64_IMM(BPF_REG_0, 0), | |
| 942 | + BPF_EXIT_INSN(), | |
| 943 | + }, | |
| 944 | + .prog_type = BPF_PROG_TYPE_XDP, | |
| 945 | + .errstr = "call stack", | |
| 946 | + .result = REJECT, | |
| 947 | +}, | |
| 910 | 948 | { |
| 911 | 949 | "calls: spill into caller stack frame", |
| 912 | 950 | .insns = { |
| @@ -143,6 +143,30 @@ · 142 unmodified lines | ||
| 143 | 143 | "$TC actions flush action sample" |
| 144 | 144 | ] |
| 145 | 145 | }, |
| 146 | + { | |
| 147 | + "id": "7571", | |
| 148 | + "name": "Add sample action with invalid rate", | |
| 149 | + "category": [ | |
| 150 | + "actions", | |
| 151 | + "sample" | |
| 152 | + ], | |
| 153 | + "setup": [ | |
| 154 | + [ | |
| 155 | + "$TC actions flush action sample", | |
| 156 | + 0, | |
| 157 | + 1, | |
| 158 | + 255 | |
| 159 | + ] | |
| 160 | + ], | |
| 161 | + "cmdUnderTest": "$TC actions add action sample rate 0 group 1 index 2", | |
| 162 | + "expExitCode": "255", | |
| 163 | + "verifyCmd": "$TC actions get action sample index 2", | |
| 164 | + "matchPattern": "action order [0-9]+: sample rate 1/0 group 1.*index 2 ref", | |
| 165 | + "matchCount": "0", | |
| 166 | + "teardown": [ | |
| 167 | + "$TC actions flush action sample" | |
| 168 | + ] | |
| 169 | + }, | |
| 146 | 170 | { |
| 147 | 171 | "id": "b6d4", |
| 148 | 172 | "name": "Add sample action with mandatory arguments and invalid control action", |
| @@ -18,6 +18,26 @@ · 17 unmodified lines | ||
| 18 | 18 | "$TC qdisc del dev $DEV1 ingress" |
| 19 | 19 | ] |
| 20 | 20 | }, |
| 21 | + { | |
| 22 | + "id": "2638", | |
| 23 | + "name": "Add matchall and try to get it", | |
| 24 | + "category": [ | |
| 25 | + "filter", | |
| 26 | + "matchall" | |
| 27 | + ], | |
| 28 | + "setup": [ | |
| 29 | + "$TC qdisc add dev $DEV1 clsact", | |
| 30 | + "$TC filter add dev $DEV1 protocol all pref 1 ingress handle 0x1234 matchall action ok" | |
| 31 | + ], | |
| 32 | + "cmdUnderTest": "$TC filter get dev $DEV1 protocol all pref 1 ingress handle 0x1234 matchall", | |
| 33 | + "expExitCode": "0", | |
| 34 | + "verifyCmd": "$TC filter show dev $DEV1 ingress", | |
| 35 | + "matchPattern": "filter protocol all pref 1 matchall chain 0 handle 0x1234", | |
| 36 | + "matchCount": "1", | |
| 37 | + "teardown": [ | |
| 38 | + "$TC qdisc del dev $DEV1 clsact" | |
| 39 | + ] | |
| 40 | + }, | |
| 21 | 41 | { |
| 22 | 42 | "id": "d052", |
| 23 | 43 | "name": "Add 1M filters with the same action", |
| @@ -22,6 +22,7 @@ TPM2_CC_UNSEAL = 0x015E · 21 unmodified lines | ||
| 22 | 22 | TPM2_CC_FLUSH_CONTEXT = 0x0165 |
| 23 | 23 | TPM2_CC_START_AUTH_SESSION = 0x0176 |
| 24 | 24 | TPM2_CC_GET_CAPABILITY = 0x017A |
| 25 | +TPM2_CC_GET_RANDOM = 0x017B | |
| 25 | 26 | TPM2_CC_PCR_READ = 0x017E |
| 26 | 27 | TPM2_CC_POLICY_PCR = 0x017F |
| 27 | 28 | TPM2_CC_PCR_EXTEND = 0x0182 |
| @@ -357,9 +358,9 @@ class Client: · 329 unmodified lines | ||
| 357 | 358 | self.flags = flags |
| 358 | 359 | |
| 359 | 360 | if (self.flags & Client.FLAG_SPACE) == 0: |
| 360 | − self.tpm = open('/dev/tpm0', 'r+b') | |
| 361 | + self.tpm = open('/dev/tpm0', 'r+b', buffering=0) | |
| 361 | 362 | else: |
| 362 | − self.tpm = open('/dev/tpmrm0', 'r+b') | |
| 363 | + self.tpm = open('/dev/tpmrm0', 'r+b', buffering=0) | |
| 363 | 364 | |
| 364 | 365 | def close(self): |
| 365 | 366 | self.tpm.close() |
| @@ -158,6 +158,69 @@ class SmokeTest(unittest.TestCase): · 157 unmodified lines | ||
| 158 | 158 | pass |
| 159 | 159 | self.assertEqual(rejected, True) |
| 160 | 160 | |
| 161 | + def test_read_partial_resp(self): | |
| 162 | + try: | |
| 163 | + fmt = '>HIIH' | |
| 164 | + cmd = struct.pack(fmt, | |
| 165 | + tpm2.TPM2_ST_NO_SESSIONS, | |
| 166 | + struct.calcsize(fmt), | |
| 167 | + tpm2.TPM2_CC_GET_RANDOM, | |
| 168 | + 0x20) | |
| 169 | + self.client.tpm.write(cmd) | |
| 170 | + hdr = self.client.tpm.read(10) | |
| 171 | + sz = struct.unpack('>I', hdr[2:6])[0] | |
| 172 | + rsp = self.client.tpm.read() | |
| 173 | + except: | |
| 174 | + pass | |
| 175 | + self.assertEqual(sz, 10 + 2 + 32) | |
| 176 | + self.assertEqual(len(rsp), 2 + 32) | |
| 177 | + | |
| 178 | + def test_read_partial_overwrite(self): | |
| 179 | + try: | |
| 180 | + fmt = '>HIIH' | |
| 181 | + cmd = struct.pack(fmt, | |
| 182 | + tpm2.TPM2_ST_NO_SESSIONS, | |
| 183 | + struct.calcsize(fmt), | |
| 184 | + tpm2.TPM2_CC_GET_RANDOM, | |
| 185 | + 0x20) | |
| 186 | + self.client.tpm.write(cmd) | |
| 187 | + # Read part of the respone | |
| 188 | + rsp1 = self.client.tpm.read(15) | |
| 189 | + | |
| 190 | + # Send a new cmd | |
| 191 | + self.client.tpm.write(cmd) | |
| 192 | + | |
| 193 | + # Read the whole respone | |
| 194 | + rsp2 = self.client.tpm.read() | |
| 195 | + except: | |
| 196 | + pass | |
| 197 | + self.assertEqual(len(rsp1), 15) | |
| 198 | + self.assertEqual(len(rsp2), 10 + 2 + 32) | |
| 199 | + | |
| 200 | + def test_send_two_cmds(self): | |
| 201 | + rejected = False | |
| 202 | + try: | |
| 203 | + fmt = '>HIIH' | |
| 204 | + cmd = struct.pack(fmt, | |
| 205 | + tpm2.TPM2_ST_NO_SESSIONS, | |
| 206 | + struct.calcsize(fmt), | |
| 207 | + tpm2.TPM2_CC_GET_RANDOM, | |
| 208 | + 0x20) | |
| 209 | + self.client.tpm.write(cmd) | |
| 210 | + | |
| 211 | + # expect the second one to raise -EBUSY error | |
| 212 | + self.client.tpm.write(cmd) | |
| 213 | + rsp = self.client.tpm.read() | |
| 214 | + | |
| 215 | + except IOError, e: | |
| 216 | + # read the response | |
| 217 | + rsp = self.client.tpm.read() | |
| 218 | + rejected = True | |
| 219 | + pass | |
| 220 | + except: | |
| 221 | + pass | |
| 222 | + self.assertEqual(rejected, True) | |
| 223 | + | |
| 161 | 224 | class SpaceTest(unittest.TestCase): |
| 162 | 225 | def setUp(self): |
| 163 | 226 | logging.basicConfig(filename='SpaceTest.log', level=logging.DEBUG) |