Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge remote-tracking branch 'torvalds/master' into perf-tools
To pick up some extra files that need to be sync'ed with the kernel
sources to try and reduce the number of PRs.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
+235
-139
+1
.mailmap
+1
.mailmap
···
327
327
Herbert Xu <herbert@gondor.apana.org.au>
328
328
Huacai Chen <chenhuacai@kernel.org> <chenhc@lemote.com>
329
329
Huacai Chen <chenhuacai@kernel.org> <chenhuacai@loongson.cn>
330
+
Ignat Korchagin <ignat@linux.win> <ignat@cloudflare.com>
330
331
Ike Panhc <ikepanhc@gmail.com> <ike.pan@canonical.com>
331
332
J. Bruce Fields <bfields@fieldses.org> <bfields@redhat.com>
332
333
J. Bruce Fields <bfields@fieldses.org> <bfields@citi.umich.edu>
+2
Documentation/dev-tools/kunit/run_wrapper.rst
+2
Documentation/dev-tools/kunit/run_wrapper.rst
+4
-4
MAINTAINERS
+4
-4
MAINTAINERS
···
4022
4022
ASYMMETRIC KEYS
4023
4023
M: David Howells <dhowells@redhat.com>
4024
4024
M: Lukas Wunner <lukas@wunner.de>
4025
-
M: Ignat Korchagin <ignat@cloudflare.com>
4025
+
M: Ignat Korchagin <ignat@linux.win>
4026
4026
L: keyrings@vger.kernel.org
4027
4027
L: linux-crypto@vger.kernel.org
4028
4028
S: Maintained
···
4035
4035
4036
4036
ASYMMETRIC KEYS - ECDSA
4037
4037
M: Lukas Wunner <lukas@wunner.de>
4038
-
M: Ignat Korchagin <ignat@cloudflare.com>
4038
+
M: Ignat Korchagin <ignat@linux.win>
4039
4039
R: Stefan Berger <stefanb@linux.ibm.com>
4040
4040
L: linux-crypto@vger.kernel.org
4041
4041
S: Maintained
···
4045
4045
4046
4046
ASYMMETRIC KEYS - GOST
4047
4047
M: Lukas Wunner <lukas@wunner.de>
4048
-
M: Ignat Korchagin <ignat@cloudflare.com>
4048
+
M: Ignat Korchagin <ignat@linux.win>
4049
4049
L: linux-crypto@vger.kernel.org
4050
4050
S: Odd fixes
4051
4051
F: crypto/ecrdsa*
4052
4052
4053
4053
ASYMMETRIC KEYS - RSA
4054
4054
M: Lukas Wunner <lukas@wunner.de>
4055
-
M: Ignat Korchagin <ignat@cloudflare.com>
4055
+
M: Ignat Korchagin <ignat@linux.win>
4056
4056
L: linux-crypto@vger.kernel.org
4057
4057
S: Maintained
4058
4058
F: crypto/rsa*
-1
arch/arm/configs/multi_v7_defconfig
-1
arch/arm/configs/multi_v7_defconfig
+8
-8
arch/arm64/boot/dts/renesas/r8a78000.dtsi
+8
-8
arch/arm64/boot/dts/renesas/r8a78000.dtsi
···
698
698
compatible = "renesas,scif-r8a78000",
699
699
"renesas,rcar-gen5-scif", "renesas,scif";
700
700
reg = <0 0xc0700000 0 0x40>;
701
-
interrupts = <GIC_SPI 4074 IRQ_TYPE_LEVEL_HIGH>;
701
+
interrupts = <GIC_ESPI 10 IRQ_TYPE_LEVEL_HIGH>;
702
702
clocks = <&dummy_clk_sgasyncd16>, <&dummy_clk_sgasyncd16>, <&scif_clk>;
703
703
clock-names = "fck", "brg_int", "scif_clk";
704
704
status = "disabled";
···
708
708
compatible = "renesas,scif-r8a78000",
709
709
"renesas,rcar-gen5-scif", "renesas,scif";
710
710
reg = <0 0xc0704000 0 0x40>;
711
-
interrupts = <GIC_SPI 4075 IRQ_TYPE_LEVEL_HIGH>;
711
+
interrupts = <GIC_ESPI 11 IRQ_TYPE_LEVEL_HIGH>;
712
712
clocks = <&dummy_clk_sgasyncd16>, <&dummy_clk_sgasyncd16>, <&scif_clk>;
713
713
clock-names = "fck", "brg_int", "scif_clk";
714
714
status = "disabled";
···
718
718
compatible = "renesas,scif-r8a78000",
719
719
"renesas,rcar-gen5-scif", "renesas,scif";
720
720
reg = <0 0xc0708000 0 0x40>;
721
-
interrupts = <GIC_SPI 4076 IRQ_TYPE_LEVEL_HIGH>;
721
+
interrupts = <GIC_ESPI 12 IRQ_TYPE_LEVEL_HIGH>;
722
722
clocks = <&dummy_clk_sgasyncd16>, <&dummy_clk_sgasyncd16>, <&scif_clk>;
723
723
clock-names = "fck", "brg_int", "scif_clk";
724
724
status = "disabled";
···
728
728
compatible = "renesas,scif-r8a78000",
729
729
"renesas,rcar-gen5-scif", "renesas,scif";
730
730
reg = <0 0xc070c000 0 0x40>;
731
-
interrupts = <GIC_SPI 4077 IRQ_TYPE_LEVEL_HIGH>;
731
+
interrupts = <GIC_ESPI 13 IRQ_TYPE_LEVEL_HIGH>;
732
732
clocks = <&dummy_clk_sgasyncd16>, <&dummy_clk_sgasyncd16>, <&scif_clk>;
733
733
clock-names = "fck", "brg_int", "scif_clk";
734
734
status = "disabled";
···
738
738
compatible = "renesas,hscif-r8a78000",
739
739
"renesas,rcar-gen5-hscif", "renesas,hscif";
740
740
reg = <0 0xc0710000 0 0x60>;
741
-
interrupts = <GIC_SPI 4078 IRQ_TYPE_LEVEL_HIGH>;
741
+
interrupts = <GIC_ESPI 14 IRQ_TYPE_LEVEL_HIGH>;
742
742
clocks = <&dummy_clk_sgasyncd4>, <&dummy_clk_sgasyncd4>, <&scif_clk>;
743
743
clock-names = "fck", "brg_int", "scif_clk";
744
744
status = "disabled";
···
748
748
compatible = "renesas,hscif-r8a78000",
749
749
"renesas,rcar-gen5-hscif", "renesas,hscif";
750
750
reg = <0 0xc0714000 0 0x60>;
751
-
interrupts = <GIC_SPI 4079 IRQ_TYPE_LEVEL_HIGH>;
751
+
interrupts = <GIC_ESPI 15 IRQ_TYPE_LEVEL_HIGH>;
752
752
clocks = <&dummy_clk_sgasyncd4>, <&dummy_clk_sgasyncd4>, <&scif_clk>;
753
753
clock-names = "fck", "brg_int", "scif_clk";
754
754
status = "disabled";
···
758
758
compatible = "renesas,hscif-r8a78000",
759
759
"renesas,rcar-gen5-hscif", "renesas,hscif";
760
760
reg = <0 0xc0718000 0 0x60>;
761
-
interrupts = <GIC_SPI 4080 IRQ_TYPE_LEVEL_HIGH>;
761
+
interrupts = <GIC_ESPI 16 IRQ_TYPE_LEVEL_HIGH>;
762
762
clocks = <&dummy_clk_sgasyncd4>, <&dummy_clk_sgasyncd4>, <&scif_clk>;
763
763
clock-names = "fck", "brg_int", "scif_clk";
764
764
status = "disabled";
···
768
768
compatible = "renesas,hscif-r8a78000",
769
769
"renesas,rcar-gen5-hscif", "renesas,hscif";
770
770
reg = <0 0xc071c000 0 0x60>;
771
-
interrupts = <GIC_SPI 4081 IRQ_TYPE_LEVEL_HIGH>;
771
+
interrupts = <GIC_ESPI 17 IRQ_TYPE_LEVEL_HIGH>;
772
772
clocks = <&dummy_clk_sgasyncd4>, <&dummy_clk_sgasyncd4>, <&scif_clk>;
773
773
clock-names = "fck", "brg_int", "scif_clk";
774
774
status = "disabled";
-30
arch/arm64/boot/dts/renesas/r9a09g057.dtsi
-30
arch/arm64/boot/dts/renesas/r9a09g057.dtsi
···
581
581
status = "disabled";
582
582
};
583
583
584
-
wdt0: watchdog@11c00400 {
585
-
compatible = "renesas,r9a09g057-wdt";
586
-
reg = <0 0x11c00400 0 0x400>;
587
-
clocks = <&cpg CPG_MOD 0x4b>, <&cpg CPG_MOD 0x4c>;
588
-
clock-names = "pclk", "oscclk";
589
-
resets = <&cpg 0x75>;
590
-
power-domains = <&cpg>;
591
-
status = "disabled";
592
-
};
593
-
594
584
wdt1: watchdog@14400000 {
595
585
compatible = "renesas,r9a09g057-wdt";
596
586
reg = <0 0x14400000 0 0x400>;
597
587
clocks = <&cpg CPG_MOD 0x4d>, <&cpg CPG_MOD 0x4e>;
598
588
clock-names = "pclk", "oscclk";
599
589
resets = <&cpg 0x76>;
600
-
power-domains = <&cpg>;
601
-
status = "disabled";
602
-
};
603
-
604
-
wdt2: watchdog@13000000 {
605
-
compatible = "renesas,r9a09g057-wdt";
606
-
reg = <0 0x13000000 0 0x400>;
607
-
clocks = <&cpg CPG_MOD 0x4f>, <&cpg CPG_MOD 0x50>;
608
-
clock-names = "pclk", "oscclk";
609
-
resets = <&cpg 0x77>;
610
-
power-domains = <&cpg>;
611
-
status = "disabled";
612
-
};
613
-
614
-
wdt3: watchdog@13000400 {
615
-
compatible = "renesas,r9a09g057-wdt";
616
-
reg = <0 0x13000400 0 0x400>;
617
-
clocks = <&cpg CPG_MOD 0x51>, <&cpg CPG_MOD 0x52>;
618
-
clock-names = "pclk", "oscclk";
619
-
resets = <&cpg 0x78>;
620
590
power-domains = <&cpg>;
621
591
status = "disabled";
622
592
};
+2
-2
arch/arm64/boot/dts/renesas/r9a09g077.dtsi
+2
-2
arch/arm64/boot/dts/renesas/r9a09g077.dtsi
···
974
974
975
975
cpg: clock-controller@80280000 {
976
976
compatible = "renesas,r9a09g077-cpg-mssr";
977
-
reg = <0 0x80280000 0 0x1000>,
978
-
<0 0x81280000 0 0x9000>;
977
+
reg = <0 0x80280000 0 0x10000>,
978
+
<0 0x81280000 0 0x10000>;
979
979
clocks = <&extal_clk>;
980
980
clock-names = "extal";
981
981
#clock-cells = <2>;
+2
-2
arch/arm64/boot/dts/renesas/r9a09g087.dtsi
+2
-2
arch/arm64/boot/dts/renesas/r9a09g087.dtsi
···
977
977
978
978
cpg: clock-controller@80280000 {
979
979
compatible = "renesas,r9a09g087-cpg-mssr";
980
-
reg = <0 0x80280000 0 0x1000>,
981
-
<0 0x81280000 0 0x9000>;
980
+
reg = <0 0x80280000 0 0x10000>,
981
+
<0 0x81280000 0 0x10000>;
982
982
clocks = <&extal_clk>;
983
983
clock-names = "extal";
984
984
#clock-cells = <2>;
+1
-1
arch/arm64/boot/dts/renesas/rzg3s-smarc-som.dtsi
+1
-1
arch/arm64/boot/dts/renesas/rzg3s-smarc-som.dtsi
+1
arch/arm64/boot/dts/renesas/rzt2h-n2h-evk-common.dtsi
+1
arch/arm64/boot/dts/renesas/rzt2h-n2h-evk-common.dtsi
+1
arch/arm64/boot/dts/renesas/rzv2-evk-cn15-sd.dtso
+1
arch/arm64/boot/dts/renesas/rzv2-evk-cn15-sd.dtso
+3
arch/loongarch/Kconfig
+3
arch/loongarch/Kconfig
+5
arch/loongarch/include/asm/cmpxchg.h
+5
arch/loongarch/include/asm/cmpxchg.h
···
238
238
arch_cmpxchg((ptr), (o), (n)); \
239
239
})
240
240
241
+
#ifdef CONFIG_AS_HAS_SCQ_EXTENSION
242
+
241
243
union __u128_halves {
242
244
u128 full;
243
245
struct {
···
292
290
BUILD_BUG_ON(sizeof(*(ptr)) != 16); \
293
291
__arch_cmpxchg128(ptr, o, n, ""); \
294
292
})
293
+
294
+
#endif /* CONFIG_AS_HAS_SCQ_EXTENSION */
295
+
295
296
#else
296
297
#include <asm-generic/cmpxchg-local.h>
297
298
#define arch_cmpxchg64_local(ptr, o, n) __generic_cmpxchg64_local((ptr), (o), (n))
+12
-2
arch/loongarch/include/asm/uaccess.h
+12
-2
arch/loongarch/include/asm/uaccess.h
···
253
253
\
254
254
__get_kernel_common(*((type *)(dst)), sizeof(type), \
255
255
(__force type *)(src)); \
256
-
if (unlikely(__gu_err)) \
256
+
if (unlikely(__gu_err)) { \
257
+
pr_info("%s: memory access failed, ecode 0x%x\n", \
258
+
__func__, read_csr_excode()); \
259
+
pr_info("%s: the caller is %pS\n", \
260
+
__func__, __builtin_return_address(0)); \
257
261
goto err_label; \
262
+
} \
258
263
} while (0)
259
264
260
265
#define __put_kernel_nofault(dst, src, type, err_label) \
···
269
264
\
270
265
__pu_val = *(__force type *)(src); \
271
266
__put_kernel_common(((type *)(dst)), sizeof(type)); \
272
-
if (unlikely(__pu_err)) \
267
+
if (unlikely(__pu_err)) { \
268
+
pr_info("%s: memory access failed, ecode 0x%x\n", \
269
+
__func__, read_csr_excode()); \
270
+
pr_info("%s: the caller is %pS\n", \
271
+
__func__, __builtin_return_address(0)); \
273
272
goto err_label; \
273
+
} \
274
274
} while (0)
275
275
276
276
extern unsigned long __copy_user(void *to, const void *from, __kernel_size_t n);
+25
-6
arch/loongarch/kernel/inst.c
+25
-6
arch/loongarch/kernel/inst.c
···
246
246
247
247
if (smp_processor_id() == copy->cpu) {
248
248
ret = copy_to_kernel_nofault(copy->dst, copy->src, copy->len);
249
-
if (ret)
249
+
if (ret) {
250
250
pr_err("%s: operation failed\n", __func__);
251
+
return ret;
252
+
}
251
253
}
252
254
253
255
flush_icache_range((unsigned long)copy->dst, (unsigned long)copy->dst + copy->len);
254
256
255
-
return ret;
257
+
return 0;
256
258
}
257
259
258
260
int larch_insn_text_copy(void *dst, void *src, size_t len)
259
261
{
260
262
int ret = 0;
263
+
int err = 0;
261
264
size_t start, end;
262
265
struct insn_copy copy = {
263
266
.dst = dst,
264
267
.src = src,
265
268
.len = len,
266
-
.cpu = smp_processor_id(),
269
+
.cpu = raw_smp_processor_id(),
267
270
};
271
+
272
+
/*
273
+
* Ensure copy.cpu won't be hot removed before stop_machine.
274
+
* If it is removed nobody will really update the text.
275
+
*/
276
+
lockdep_assert_cpus_held();
268
277
269
278
start = round_down((size_t)dst, PAGE_SIZE);
270
279
end = round_up((size_t)dst + len, PAGE_SIZE);
271
280
272
-
set_memory_rw(start, (end - start) / PAGE_SIZE);
273
-
ret = stop_machine(text_copy_cb, ©, cpu_online_mask);
274
-
set_memory_rox(start, (end - start) / PAGE_SIZE);
281
+
err = set_memory_rw(start, (end - start) / PAGE_SIZE);
282
+
if (err) {
283
+
pr_info("%s: set_memory_rw() failed\n", __func__);
284
+
return err;
285
+
}
286
+
287
+
ret = stop_machine_cpuslocked(text_copy_cb, ©, cpu_online_mask);
288
+
289
+
err = set_memory_rox(start, (end - start) / PAGE_SIZE);
290
+
if (err) {
291
+
pr_info("%s: set_memory_rox() failed\n", __func__);
292
+
return err;
293
+
}
275
294
276
295
return ret;
277
296
}
+2
-2
arch/loongarch/kvm/vm.c
+2
-2
arch/loongarch/kvm/vm.c
···
49
49
kvm->arch.kvm_features |= BIT(KVM_LOONGARCH_VM_FEAT_PMU);
50
50
51
51
/* Enable all PV features by default */
52
-
kvm->arch.pv_features = BIT(KVM_FEATURE_IPI);
53
-
kvm->arch.kvm_features = BIT(KVM_LOONGARCH_VM_FEAT_PV_IPI);
52
+
kvm->arch.pv_features |= BIT(KVM_FEATURE_IPI);
53
+
kvm->arch.kvm_features |= BIT(KVM_LOONGARCH_VM_FEAT_PV_IPI);
54
54
if (kvm_pvtime_supported()) {
55
55
kvm->arch.pv_features |= BIT(KVM_FEATURE_PREEMPT);
56
56
kvm->arch.pv_features |= BIT(KVM_FEATURE_STEAL_TIME);
+11
arch/loongarch/net/bpf_jit.c
+11
arch/loongarch/net/bpf_jit.c
···
1379
1379
{
1380
1380
int ret;
1381
1381
1382
+
cpus_read_lock();
1382
1383
mutex_lock(&text_mutex);
1383
1384
ret = larch_insn_text_copy(dst, src, len);
1384
1385
mutex_unlock(&text_mutex);
1386
+
cpus_read_unlock();
1385
1387
1386
1388
return ret ? ERR_PTR(-EINVAL) : dst;
1387
1389
}
···
1431
1429
if (ret)
1432
1430
return ret;
1433
1431
1432
+
cpus_read_lock();
1434
1433
mutex_lock(&text_mutex);
1435
1434
if (memcmp(ip, new_insns, LOONGARCH_LONG_JUMP_NBYTES))
1436
1435
ret = larch_insn_text_copy(ip, new_insns, LOONGARCH_LONG_JUMP_NBYTES);
1437
1436
mutex_unlock(&text_mutex);
1437
+
cpus_read_unlock();
1438
1438
1439
1439
return ret;
1440
1440
}
···
1454
1450
for (i = 0; i < (len / sizeof(u32)); i++)
1455
1451
inst[i] = INSN_BREAK;
1456
1452
1453
+
cpus_read_lock();
1457
1454
mutex_lock(&text_mutex);
1458
1455
if (larch_insn_text_copy(dst, inst, len))
1459
1456
ret = -EINVAL;
1460
1457
mutex_unlock(&text_mutex);
1458
+
cpus_read_unlock();
1461
1459
1462
1460
kvfree(inst);
1463
1461
···
1572
1566
void arch_free_bpf_trampoline(void *image, unsigned int size)
1573
1567
{
1574
1568
bpf_prog_pack_free(image, size);
1569
+
}
1570
+
1571
+
int arch_protect_bpf_trampoline(void *image, unsigned int size)
1572
+
{
1573
+
return 0;
1575
1574
}
1576
1575
1577
1576
/*
+2
arch/riscv/boot/dts/microchip/mpfs.dtsi
+2
arch/riscv/boot/dts/microchip/mpfs.dtsi
···
428
428
clocks = <&clkcfg CLK_CAN0>, <&clkcfg CLK_MSSPLL3>;
429
429
interrupt-parent = <&plic>;
430
430
interrupts = <56>;
431
+
resets = <&mss_top_sysreg CLK_CAN0>;
431
432
status = "disabled";
432
433
};
433
434
···
438
437
clocks = <&clkcfg CLK_CAN1>, <&clkcfg CLK_MSSPLL3>;
439
438
interrupt-parent = <&plic>;
440
439
interrupts = <57>;
440
+
resets = <&mss_top_sysreg CLK_CAN1>;
441
441
status = "disabled";
442
442
};
443
443
+2
-2
drivers/cache/ax45mp_cache.c
+2
-2
drivers/cache/ax45mp_cache.c
···
178
178
179
179
static int __init ax45mp_cache_init(void)
180
180
{
181
-
struct device_node *np;
182
181
struct resource res;
183
182
int ret;
184
183
185
-
np = of_find_matching_node(NULL, ax45mp_cache_ids);
184
+
struct device_node *np __free(device_node) =
185
+
of_find_matching_node(NULL, ax45mp_cache_ids);
186
186
if (!of_device_is_available(np))
187
187
return -ENODEV;
188
188
+2
-2
drivers/cache/starfive_starlink_cache.c
+2
-2
drivers/cache/starfive_starlink_cache.c
···
102
102
103
103
static int __init starlink_cache_init(void)
104
104
{
105
-
struct device_node *np;
106
105
u32 block_size;
107
106
int ret;
108
107
109
-
np = of_find_matching_node(NULL, starlink_cache_ids);
108
+
struct device_node *np __free(device_node) =
109
+
of_find_matching_node(NULL, starlink_cache_ids);
110
110
if (!of_device_is_available(np))
111
111
return -ENODEV;
112
112
+1
-3
drivers/crypto/ccp/sev-dev.c
+1
-3
drivers/crypto/ccp/sev-dev.c
···
2408
2408
* in Firmware state on failure. Use snp_reclaim_pages() to
2409
2409
* transition either case back to Hypervisor-owned state.
2410
2410
*/
2411
-
if (snp_reclaim_pages(__pa(data), 1, true)) {
2412
-
snp_leak_pages(__page_to_pfn(status_page), 1);
2411
+
if (snp_reclaim_pages(__pa(data), 1, true))
2413
2412
return -EFAULT;
2414
-
}
2415
2413
}
2416
2414
2417
2415
if (ret)
+4
-4
drivers/firmware/arm_ffa/driver.c
+4
-4
drivers/firmware/arm_ffa/driver.c
···
205
205
return 0;
206
206
}
207
207
208
-
static int ffa_rxtx_unmap(u16 vm_id)
208
+
static int ffa_rxtx_unmap(void)
209
209
{
210
210
ffa_value_t ret;
211
211
212
212
invoke_ffa_fn((ffa_value_t){
213
-
.a0 = FFA_RXTX_UNMAP, .a1 = PACK_TARGET_INFO(vm_id, 0),
213
+
.a0 = FFA_RXTX_UNMAP,
214
214
}, &ret);
215
215
216
216
if (ret.a0 == FFA_ERROR)
···
2097
2097
2098
2098
pr_err("failed to setup partitions\n");
2099
2099
ffa_notifications_cleanup();
2100
-
ffa_rxtx_unmap(drv_info->vm_id);
2100
+
ffa_rxtx_unmap();
2101
2101
free_pages:
2102
2102
if (drv_info->tx_buffer)
2103
2103
free_pages_exact(drv_info->tx_buffer, rxtx_bufsz);
···
2112
2112
{
2113
2113
ffa_notifications_cleanup();
2114
2114
ffa_partitions_cleanup();
2115
-
ffa_rxtx_unmap(drv_info->vm_id);
2115
+
ffa_rxtx_unmap();
2116
2116
free_pages_exact(drv_info->tx_buffer, drv_info->rxtx_bufsz);
2117
2117
free_pages_exact(drv_info->rx_buffer, drv_info->rxtx_bufsz);
2118
2118
kfree(drv_info);
+2
-2
drivers/firmware/arm_scmi/notify.c
+2
-2
drivers/firmware/arm_scmi/notify.c
···
1066
1066
* since at creation time we usually want to have all setup and ready before
1067
1067
* events really start flowing.
1068
1068
*
1069
-
* Return: A properly refcounted handler on Success, NULL on Failure
1069
+
* Return: A properly refcounted handler on Success, ERR_PTR on Failure
1070
1070
*/
1071
1071
static inline struct scmi_event_handler *
1072
1072
__scmi_event_handler_get_ops(struct scmi_notify_instance *ni,
···
1113
1113
}
1114
1114
mutex_unlock(&ni->pending_mtx);
1115
1115
1116
-
return hndl;
1116
+
return hndl ?: ERR_PTR(-ENODEV);
1117
1117
}
1118
1118
1119
1119
static struct scmi_event_handler *
+2
-2
drivers/firmware/arm_scmi/protocols.h
+2
-2
drivers/firmware/arm_scmi/protocols.h
···
189
189
190
190
/**
191
191
* struct scmi_iterator_state - Iterator current state descriptor
192
-
* @desc_index: Starting index for the current mulit-part request.
192
+
* @desc_index: Starting index for the current multi-part request.
193
193
* @num_returned: Number of returned items in the last multi-part reply.
194
194
* @num_remaining: Number of remaining items in the multi-part message.
195
195
* @max_resources: Maximum acceptable number of items, configured by the caller
196
196
* depending on the underlying resources that it is querying.
197
197
* @loop_idx: The iterator loop index in the current multi-part reply.
198
-
* @rx_len: Size in bytes of the currenly processed message; it can be used by
198
+
* @rx_len: Size in bytes of the currently processed message; it can be used by
199
199
* the user of the iterator to verify a reply size.
200
200
* @priv: Optional pointer to some additional state-related private data setup
201
201
* by the caller during the iterations.
+3
-2
drivers/firmware/arm_scpi.c
+3
-2
drivers/firmware/arm_scpi.c
···
18
18
19
19
#include <linux/bitmap.h>
20
20
#include <linux/bitfield.h>
21
+
#include <linux/cleanup.h>
21
22
#include <linux/device.h>
22
23
#include <linux/err.h>
23
24
#include <linux/export.h>
···
941
940
int idx = scpi_drvinfo->num_chans;
942
941
struct scpi_chan *pchan = scpi_drvinfo->channels + idx;
943
942
struct mbox_client *cl = &pchan->cl;
944
-
struct device_node *shmem = of_parse_phandle(np, "shmem", idx);
943
+
struct device_node *shmem __free(device_node) =
944
+
of_parse_phandle(np, "shmem", idx);
945
945
946
946
if (!of_match_node(shmem_of_match, shmem))
947
947
return -ENXIO;
948
948
949
949
ret = of_address_to_resource(shmem, 0, &res);
950
-
of_node_put(shmem);
951
950
if (ret) {
952
951
dev_err(dev, "failed to get SCPI payload mem resource\n");
953
952
return ret;
+2
drivers/hid/bpf/hid_bpf_dispatch.c
+2
drivers/hid/bpf/hid_bpf_dispatch.c
+3
-2
drivers/hid/hid-appletb-kbd.c
+3
-2
drivers/hid/hid-appletb-kbd.c
···
476
476
return 0;
477
477
}
478
478
479
-
static int appletb_kbd_reset_resume(struct hid_device *hdev)
479
+
static int appletb_kbd_resume(struct hid_device *hdev)
480
480
{
481
481
struct appletb_kbd *kbd = hid_get_drvdata(hdev);
482
482
···
500
500
.event = appletb_kbd_hid_event,
501
501
.input_configured = appletb_kbd_input_configured,
502
502
.suspend = pm_ptr(appletb_kbd_suspend),
503
-
.reset_resume = pm_ptr(appletb_kbd_reset_resume),
503
+
.resume = pm_ptr(appletb_kbd_resume),
504
+
.reset_resume = pm_ptr(appletb_kbd_resume),
504
505
.driver.dev_groups = appletb_kbd_groups,
505
506
};
506
507
module_hid_driver(appletb_kbd_hid_driver);
+3
drivers/hid/hid-asus.c
+3
drivers/hid/hid-asus.c
···
1498
1498
USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY_X),
1499
1499
QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD | QUIRK_ROG_ALLY_XPAD },
1500
1500
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
1501
+
USB_DEVICE_ID_ASUSTEK_XGM_2022),
1502
+
},
1503
+
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
1501
1504
USB_DEVICE_ID_ASUSTEK_XGM_2023),
1502
1505
},
1503
1506
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK,
+4
-3
drivers/hid/hid-core.c
+4
-3
drivers/hid/hid-core.c
···
2057
2057
rsize = max_buffer_size;
2058
2058
2059
2059
if (csize < rsize) {
2060
-
dbg_hid("report %d is too short, (%d < %d)\n", report->id,
2061
-
csize, rsize);
2062
-
memset(cdata + csize, 0, rsize - csize);
2060
+
hid_warn_ratelimited(hid, "Event data for report %d was too short (%d vs %d)\n",
2061
+
report->id, rsize, csize);
2062
+
ret = -EINVAL;
2063
+
goto out;
2063
2064
}
2064
2065
2065
2066
if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
+1
-2
drivers/hid/hid-ids.h
+1
-2
drivers/hid/hid-ids.h
···
229
229
#define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY_X 0x1b4c
230
230
#define USB_DEVICE_ID_ASUSTEK_ROG_CLAYMORE_II_KEYBOARD 0x196b
231
231
#define USB_DEVICE_ID_ASUSTEK_FX503VD_KEYBOARD 0x1869
232
+
#define USB_DEVICE_ID_ASUSTEK_XGM_2022 0x1970
232
233
#define USB_DEVICE_ID_ASUSTEK_XGM_2023 0x1a9a
233
234
234
235
#define USB_VENDOR_ID_ATEN 0x0557
···
455
454
#define USB_DEVICE_ID_TOSHIBA_CLICK_L9W 0x0401
456
455
#define USB_DEVICE_ID_HP_X2 0x074d
457
456
#define USB_DEVICE_ID_HP_X2_10_COVER 0x0755
458
-
#define USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN 0x2544
459
-
#define USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN 0x2706
460
457
#define I2C_DEVICE_ID_CHROMEBOOK_TROGDOR_POMPOM 0x2F81
461
458
462
459
#define USB_VENDOR_ID_ELECOM 0x056e
+11
-7
drivers/hid/hid-input.c
+11
-7
drivers/hid/hid-input.c
···
354
354
#define HID_BATTERY_QUIRK_FEATURE (1 << 1) /* ask for feature report */
355
355
#define HID_BATTERY_QUIRK_IGNORE (1 << 2) /* completely ignore the battery */
356
356
#define HID_BATTERY_QUIRK_AVOID_QUERY (1 << 3) /* do not query the battery */
357
+
#define HID_BATTERY_QUIRK_DYNAMIC (1 << 4) /* report present only after life signs */
357
358
358
359
static const struct hid_device_id hid_battery_quirks[] = {
359
360
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
···
387
386
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
388
387
USB_DEVICE_ID_LOGITECH_DINOVO_EDGE_KBD),
389
388
HID_BATTERY_QUIRK_IGNORE },
390
-
{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN),
391
-
HID_BATTERY_QUIRK_IGNORE },
392
-
{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN),
393
-
HID_BATTERY_QUIRK_IGNORE },
394
389
{ HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_XPPEN_TABLET_DECO_L),
395
390
HID_BATTERY_QUIRK_AVOID_QUERY },
396
391
{ HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_XPPEN_TABLET_DECO_PRO_MW),
···
399
402
* Elan HID touchscreens seem to all report a non present battery,
400
403
* set HID_BATTERY_QUIRK_IGNORE for all Elan I2C and USB HID devices.
401
404
*/
402
-
{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, HID_ANY_ID), HID_BATTERY_QUIRK_IGNORE },
403
-
{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, HID_ANY_ID), HID_BATTERY_QUIRK_IGNORE },
405
+
{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, HID_ANY_ID), HID_BATTERY_QUIRK_DYNAMIC },
406
+
{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, HID_ANY_ID), HID_BATTERY_QUIRK_DYNAMIC },
404
407
{}
405
408
};
406
409
···
457
460
int ret = 0;
458
461
459
462
switch (prop) {
460
-
case POWER_SUPPLY_PROP_PRESENT:
461
463
case POWER_SUPPLY_PROP_ONLINE:
462
464
val->intval = 1;
465
+
break;
466
+
467
+
case POWER_SUPPLY_PROP_PRESENT:
468
+
val->intval = dev->battery_present;
463
469
break;
464
470
465
471
case POWER_SUPPLY_PROP_CAPACITY:
···
577
577
if (quirks & HID_BATTERY_QUIRK_AVOID_QUERY)
578
578
dev->battery_avoid_query = true;
579
579
580
+
dev->battery_present = (quirks & HID_BATTERY_QUIRK_DYNAMIC) ? false : true;
581
+
580
582
dev->battery = power_supply_register(&dev->dev, psy_desc, &psy_cfg);
581
583
if (IS_ERR(dev->battery)) {
582
584
error = PTR_ERR(dev->battery);
···
634
632
return;
635
633
636
634
if (hidinput_update_battery_charge_status(dev, usage, value)) {
635
+
dev->battery_present = true;
637
636
power_supply_changed(dev->battery);
638
637
return;
639
638
}
···
650
647
if (dev->battery_status != HID_BATTERY_REPORTED ||
651
648
capacity != dev->battery_capacity ||
652
649
ktime_after(ktime_get_coarse(), dev->battery_ratelimit_time)) {
650
+
dev->battery_present = true;
653
651
dev->battery_capacity = capacity;
654
652
dev->battery_status = HID_BATTERY_REPORTED;
655
653
dev->battery_ratelimit_time =
+5
-1
drivers/hid/hid-logitech-hidpp.c
+5
-1
drivers/hid/hid-logitech-hidpp.c
···
4487
4487
if (!ret)
4488
4488
ret = hidpp_ff_init(hidpp, &data);
4489
4489
4490
-
if (ret)
4490
+
if (ret) {
4491
4491
hid_warn(hidpp->hid_dev,
4492
4492
"Unable to initialize force feedback support, errno %d\n",
4493
4493
ret);
4494
+
ret = 0;
4495
+
}
4494
4496
}
4495
4497
4496
4498
/*
···
4670
4668
HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb038) },
4671
4669
{ /* Slim Solar+ K980 Keyboard over Bluetooth */
4672
4670
HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb391) },
4671
+
{ /* MX Master 4 mouse over Bluetooth */
4672
+
HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb042) },
4673
4673
{}
4674
4674
};
4675
4675
+7
drivers/hid/hid-multitouch.c
+7
drivers/hid/hid-multitouch.c
···
526
526
dev_warn(&hdev->dev, "failed to fetch feature %d\n",
527
527
report->id);
528
528
} else {
529
+
/* The report ID in the request and the response should match */
530
+
if (report->id != buf[0]) {
531
+
hid_err(hdev, "Returned feature report did not match the request\n");
532
+
goto free;
533
+
}
534
+
529
535
ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
530
536
size, 0);
531
537
if (ret)
532
538
dev_warn(&hdev->dev, "failed to report feature\n");
533
539
}
534
540
541
+
free:
535
542
kfree(buf);
536
543
}
537
544
+1
drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c
+1
drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-hid.c
···
127
127
hid->product = le16_to_cpu(qcdev->dev_desc.product_id);
128
128
snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "quicki2c-hid",
129
129
hid->vendor, hid->product);
130
+
strscpy(hid->phys, dev_name(qcdev->dev), sizeof(hid->phys));
130
131
131
132
ret = hid_add_device(hid);
132
133
if (ret) {
+1
drivers/hid/intel-thc-hid/intel-quickspi/quickspi-hid.c
+1
drivers/hid/intel-thc-hid/intel-quickspi/quickspi-hid.c
···
118
118
hid->product = le16_to_cpu(qsdev->dev_desc.product_id);
119
119
snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "quickspi-hid",
120
120
hid->vendor, hid->product);
121
+
strscpy(hid->phys, dev_name(qsdev->dev), sizeof(hid->phys));
121
122
122
123
ret = hid_add_device(hid);
123
124
if (ret) {
+10
drivers/hid/wacom_wac.c
+10
drivers/hid/wacom_wac.c
···
1208
1208
1209
1209
switch (data[0]) {
1210
1210
case 0x04:
1211
+
if (len < 32) {
1212
+
dev_warn(wacom->pen_input->dev.parent,
1213
+
"Report 0x04 too short: %zu bytes\n", len);
1214
+
break;
1215
+
}
1211
1216
wacom_intuos_bt_process_data(wacom, data + i);
1212
1217
i += 10;
1213
1218
fallthrough;
1214
1219
case 0x03:
1220
+
if (i == 1 && len < 22) {
1221
+
dev_warn(wacom->pen_input->dev.parent,
1222
+
"Report 0x03 too short: %zu bytes\n", len);
1223
+
break;
1224
+
}
1215
1225
wacom_intuos_bt_process_data(wacom, data + i);
1216
1226
i += 10;
1217
1227
wacom_intuos_bt_process_data(wacom, data + i);
+3
-2
drivers/nvdimm/bus.c
+3
-2
drivers/nvdimm/bus.c
···
486
486
static void nd_async_device_register(void *d, async_cookie_t cookie)
487
487
{
488
488
struct device *dev = d;
489
+
struct device *parent = dev->parent;
489
490
490
491
if (device_add(dev) != 0) {
491
492
dev_err(dev, "%s: failed\n", __func__);
492
493
put_device(dev);
493
494
}
494
495
put_device(dev);
495
-
if (dev->parent)
496
-
put_device(dev->parent);
496
+
if (parent)
497
+
put_device(parent);
497
498
}
498
499
499
500
static void nd_async_device_unregister(void *d, async_cookie_t cookie)
+3
drivers/reset/reset-rzg2l-usbphy-ctrl.c
+3
drivers/reset/reset-rzg2l-usbphy-ctrl.c
+22
-2
drivers/soc/fsl/qbman/qman.c
+22
-2
drivers/soc/fsl/qbman/qman.c
···
1827
1827
1828
1828
void qman_destroy_fq(struct qman_fq *fq)
1829
1829
{
1830
+
int leaked;
1831
+
1830
1832
/*
1831
1833
* We don't need to lock the FQ as it is a pre-condition that the FQ be
1832
1834
* quiesced. Instead, run some checks.
···
1836
1834
switch (fq->state) {
1837
1835
case qman_fq_state_parked:
1838
1836
case qman_fq_state_oos:
1839
-
if (fq_isset(fq, QMAN_FQ_FLAG_DYNAMIC_FQID))
1840
-
qman_release_fqid(fq->fqid);
1837
+
/*
1838
+
* There's a race condition here on releasing the fqid,
1839
+
* setting the fq_table to NULL, and freeing the fqid.
1840
+
* To prevent it, this order should be respected:
1841
+
*/
1842
+
if (fq_isset(fq, QMAN_FQ_FLAG_DYNAMIC_FQID)) {
1843
+
leaked = qman_shutdown_fq(fq->fqid);
1844
+
if (leaked)
1845
+
pr_debug("FQID %d leaked\n", fq->fqid);
1846
+
}
1841
1847
1842
1848
DPAA_ASSERT(fq_table[fq->idx]);
1843
1849
fq_table[fq->idx] = NULL;
1850
+
1851
+
if (fq_isset(fq, QMAN_FQ_FLAG_DYNAMIC_FQID) && !leaked) {
1852
+
/*
1853
+
* fq_table[fq->idx] should be set to null before
1854
+
* freeing fq->fqid otherwise it could by allocated by
1855
+
* qman_alloc_fqid() while still being !NULL
1856
+
*/
1857
+
smp_wmb();
1858
+
gen_pool_free(qm_fqalloc, fq->fqid | DPAA_GENALLOC_OFF, 1);
1859
+
}
1844
1860
return;
1845
1861
default:
1846
1862
break;
+2
-2
drivers/soc/fsl/qe/qmc.c
+2
-2
drivers/soc/fsl/qe/qmc.c
···
1790
1790
return -EINVAL;
1791
1791
qmc->dpram_offset = res->start - qe_muram_dma(qe_muram_addr(0));
1792
1792
qmc->dpram = devm_ioremap_resource(qmc->dev, res);
1793
-
if (IS_ERR(qmc->scc_pram))
1794
-
return PTR_ERR(qmc->scc_pram);
1793
+
if (IS_ERR(qmc->dpram))
1794
+
return PTR_ERR(qmc->dpram);
1795
1795
1796
1796
return 0;
1797
1797
}
+9
-4
drivers/soc/microchip/mpfs-sys-controller.c
+9
-4
drivers/soc/microchip/mpfs-sys-controller.c
···
142
142
143
143
sys_controller->flash = of_get_mtd_device_by_node(np);
144
144
of_node_put(np);
145
-
if (IS_ERR(sys_controller->flash))
146
-
return dev_err_probe(dev, PTR_ERR(sys_controller->flash), "Failed to get flash\n");
145
+
if (IS_ERR(sys_controller->flash)) {
146
+
ret = dev_err_probe(dev, PTR_ERR(sys_controller->flash), "Failed to get flash\n");
147
+
goto out_free;
148
+
}
147
149
148
150
no_flash:
149
151
sys_controller->client.dev = dev;
···
157
155
if (IS_ERR(sys_controller->chan)) {
158
156
ret = dev_err_probe(dev, PTR_ERR(sys_controller->chan),
159
157
"Failed to get mbox channel\n");
160
-
kfree(sys_controller);
161
-
return ret;
158
+
goto out_free;
162
159
}
163
160
164
161
init_completion(&sys_controller->c);
···
175
174
dev_info(&pdev->dev, "Registered MPFS system controller\n");
176
175
177
176
return 0;
177
+
178
+
out_free:
179
+
kfree(sys_controller);
180
+
return ret;
178
181
}
179
182
180
183
static void mpfs_sys_controller_remove(struct platform_device *pdev)
+1
drivers/soc/rockchip/grf.c
+1
drivers/soc/rockchip/grf.c
-27
drivers/tee/tee_shm.c
-27
drivers/tee/tee_shm.c
···
23
23
struct page *page;
24
24
};
25
25
26
-
static void shm_put_kernel_pages(struct page **pages, size_t page_count)
27
-
{
28
-
size_t n;
29
-
30
-
for (n = 0; n < page_count; n++)
31
-
put_page(pages[n]);
32
-
}
33
-
34
-
static void shm_get_kernel_pages(struct page **pages, size_t page_count)
35
-
{
36
-
size_t n;
37
-
38
-
for (n = 0; n < page_count; n++)
39
-
get_page(pages[n]);
40
-
}
41
-
42
26
static void release_registered_pages(struct tee_shm *shm)
43
27
{
44
28
if (shm->pages) {
45
29
if (shm->flags & TEE_SHM_USER_MAPPED)
46
30
unpin_user_pages(shm->pages, shm->num_pages);
47
-
else
48
-
shm_put_kernel_pages(shm->pages, shm->num_pages);
49
31
50
32
kfree(shm->pages);
51
33
}
···
459
477
goto err_put_shm_pages;
460
478
}
461
479
462
-
/*
463
-
* iov_iter_extract_kvec_pages does not get reference on the pages,
464
-
* get a reference on them.
465
-
*/
466
-
if (iov_iter_is_kvec(iter))
467
-
shm_get_kernel_pages(shm->pages, num_pages);
468
-
469
480
shm->offset = off;
470
481
shm->size = len;
471
482
shm->num_pages = num_pages;
···
474
499
err_put_shm_pages:
475
500
if (!iov_iter_is_kvec(iter))
476
501
unpin_user_pages(shm->pages, shm->num_pages);
477
-
else
478
-
shm_put_kernel_pages(shm->pages, shm->num_pages);
479
502
err_free_shm_pages:
480
503
kfree(shm->pages);
481
504
err_free_shm:
+1
-1
fs/btrfs/tree-checker.c
+1
-1
fs/btrfs/tree-checker.c
···
1284
1284
}
1285
1285
if (unlikely(btrfs_root_drop_level(&ri) >= BTRFS_MAX_LEVEL)) {
1286
1286
generic_err(leaf, slot,
1287
-
"invalid root level, have %u expect [0, %u]",
1287
+
"invalid root drop_level, have %u expect [0, %u]",
1288
1288
btrfs_root_drop_level(&ri), BTRFS_MAX_LEVEL - 1);
1289
1289
return -EUCLEAN;
1290
1290
}
+6
fs/btrfs/tree-log.c
+6
fs/btrfs/tree-log.c
···
6195
6195
struct btrfs_root *root,
6196
6196
struct btrfs_log_ctx *ctx)
6197
6197
{
6198
+
const bool orig_log_new_dentries = ctx->log_new_dentries;
6198
6199
int ret = 0;
6199
6200
6200
6201
/*
···
6257
6256
* dir index key range logged for the directory. So we
6258
6257
* must make sure the deletion is recorded.
6259
6258
*/
6259
+
ctx->log_new_dentries = false;
6260
6260
ret = btrfs_log_inode(trans, inode, LOG_INODE_ALL, ctx);
6261
+
if (!ret && ctx->log_new_dentries)
6262
+
ret = log_new_dir_dentries(trans, inode, ctx);
6263
+
6261
6264
btrfs_add_delayed_iput(inode);
6262
6265
if (ret)
6263
6266
break;
···
6296
6291
break;
6297
6292
}
6298
6293
6294
+
ctx->log_new_dentries = orig_log_new_dentries;
6299
6295
ctx->logging_conflict_inodes = false;
6300
6296
if (ret)
6301
6297
free_conflicting_inodes(ctx);
+1
-1
fs/btrfs/volumes.c
+1
-1
fs/btrfs/volumes.c
···
3587
3587
3588
3588
/* step one, relocate all the extents inside this chunk */
3589
3589
btrfs_scrub_pause(fs_info);
3590
-
ret = btrfs_relocate_block_group(fs_info, chunk_offset, true);
3590
+
ret = btrfs_relocate_block_group(fs_info, chunk_offset, verbose);
3591
3591
btrfs_scrub_continue(fs_info);
3592
3592
if (ret) {
3593
3593
/*
+4
-2
fs/btrfs/zoned.c
+4
-2
fs/btrfs/zoned.c
···
337
337
if (!btrfs_fs_incompat(fs_info, ZONED))
338
338
return 0;
339
339
340
-
mutex_lock(&fs_devices->device_list_mutex);
340
+
/*
341
+
* No need to take the device_list mutex here, we're still in the mount
342
+
* path and devices cannot be added to or removed from the list yet.
343
+
*/
341
344
list_for_each_entry(device, &fs_devices->devices, dev_list) {
342
345
/* We can skip reading of zone info for missing devices */
343
346
if (!device->bdev)
···
350
347
if (ret)
351
348
break;
352
349
}
353
-
mutex_unlock(&fs_devices->device_list_mutex);
354
350
355
351
return ret;
356
352
}
+3
-1
include/linux/build_bug.h
+3
-1
include/linux/build_bug.h
···
32
32
/**
33
33
* BUILD_BUG_ON_MSG - break compile if a condition is true & emit supplied
34
34
* error message.
35
-
* @condition: the condition which the compiler should know is false.
35
+
* @cond: the condition which the compiler should know is false.
36
+
* @msg: build-time error message
36
37
*
37
38
* See BUILD_BUG_ON for description.
38
39
*/
···
61
60
62
61
/**
63
62
* static_assert - check integer constant expression at build time
63
+
* @expr: expression to be checked
64
64
*
65
65
* static_assert() is a wrapper for the C11 _Static_assert, with a
66
66
* little macro magic to make the message optional (defaulting to the
+1
include/linux/hid.h
+1
include/linux/hid.h
+2
-2
kernel/crash_dump_dm_crypt.c
+2
-2
kernel/crash_dump_dm_crypt.c
···
168
168
169
169
memcpy(dm_key->data, ukp->data, ukp->datalen);
170
170
dm_key->key_size = ukp->datalen;
171
-
kexec_dprintk("Get dm crypt key (size=%u) %s: %8ph\n", dm_key->key_size,
172
-
dm_key->key_desc, dm_key->data);
171
+
kexec_dprintk("Get dm crypt key (size=%u) %s\n", dm_key->key_size,
172
+
dm_key->key_desc);
173
173
174
174
out:
175
175
up_read(&key->sem);
+2
-1
mm/huge_memory.c
+2
-1
mm/huge_memory.c
···
2797
2797
_dst_pmd = pmd_mkwrite(pmd_mkdirty(_dst_pmd), dst_vma);
2798
2798
} else {
2799
2799
src_pmdval = pmdp_huge_clear_flush(src_vma, src_addr, src_pmd);
2800
-
_dst_pmd = folio_mk_pmd(src_folio, dst_vma->vm_page_prot);
2800
+
_dst_pmd = move_soft_dirty_pmd(src_pmdval);
2801
+
_dst_pmd = clear_uffd_wp_pmd(_dst_pmd);
2801
2802
}
2802
2803
set_pmd_at(mm, dst_addr, dst_pmd, _dst_pmd);
2803
2804
+17
-4
mm/rmap.c
+17
-4
mm/rmap.c
···
1955
1955
if (userfaultfd_wp(vma))
1956
1956
return 1;
1957
1957
1958
-
return folio_pte_batch(folio, pvmw->pte, pte, max_nr);
1958
+
/*
1959
+
* If unmap fails, we need to restore the ptes. To avoid accidentally
1960
+
* upgrading write permissions for ptes that were not originally
1961
+
* writable, and to avoid losing the soft-dirty bit, use the
1962
+
* appropriate FPB flags.
1963
+
*/
1964
+
return folio_pte_batch_flags(folio, vma, pvmw->pte, &pte, max_nr,
1965
+
FPB_RESPECT_WRITE | FPB_RESPECT_SOFT_DIRTY);
1959
1966
}
1960
1967
1961
1968
/*
···
2450
2443
__maybe_unused pmd_t pmdval;
2451
2444
2452
2445
if (flags & TTU_SPLIT_HUGE_PMD) {
2446
+
/*
2447
+
* split_huge_pmd_locked() might leave the
2448
+
* folio mapped through PTEs. Retry the walk
2449
+
* so we can detect this scenario and properly
2450
+
* abort the walk.
2451
+
*/
2453
2452
split_huge_pmd_locked(vma, pvmw.address,
2454
2453
pvmw.pmd, true);
2455
-
ret = false;
2456
-
page_vma_mapped_walk_done(&pvmw);
2457
-
break;
2454
+
flags &= ~TTU_SPLIT_HUGE_PMD;
2455
+
page_vma_mapped_walk_restart(&pvmw);
2456
+
continue;
2458
2457
}
2459
2458
#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
2460
2459
pmdval = pmdp_get(pvmw.pmd);
+12
tools/testing/selftests/hid/progs/hid_bpf_helpers.h
+12
tools/testing/selftests/hid/progs/hid_bpf_helpers.h
···
6
6
#define __HID_BPF_HELPERS_H
7
7
8
8
/* "undefine" structs and enums in vmlinux.h, because we "override" them below */
9
+
#define bpf_wq bpf_wq___not_used
9
10
#define hid_bpf_ctx hid_bpf_ctx___not_used
10
11
#define hid_bpf_ops hid_bpf_ops___not_used
12
+
#define hid_device hid_device___not_used
11
13
#define hid_report_type hid_report_type___not_used
12
14
#define hid_class_request hid_class_request___not_used
13
15
#define hid_bpf_attach_flags hid_bpf_attach_flags___not_used
···
29
27
30
28
#include "vmlinux.h"
31
29
30
+
#undef bpf_wq
32
31
#undef hid_bpf_ctx
33
32
#undef hid_bpf_ops
33
+
#undef hid_device
34
34
#undef hid_report_type
35
35
#undef hid_class_request
36
36
#undef hid_bpf_attach_flags
···
57
53
HID_FEATURE_REPORT = 2,
58
54
59
55
HID_REPORT_TYPES,
56
+
};
57
+
58
+
struct hid_device {
59
+
unsigned int id;
60
+
} __attribute__((preserve_access_index));
61
+
62
+
struct bpf_wq {
63
+
__u64 __opaque[2];
60
64
};
61
65
62
66
struct hid_bpf_ctx {