ALT-PU-2021-1874-2
Package kernel-image-un-def updated to version 5.10.40-alt1 for branch p9 in task 272594.
Closed vulnerabilities
Modified: 2026-01-20
BDU:2022-04604
Уязвимость функции decode_nfs_fh() ядра операционной системы Linux, позволяющая нарушителю повысить свои привилегии и вызвать аварийное завершение системы
BDU:2025-00799
Уязвимость функции qedf_update_link_speed() компонента drivers/scsi/qedf/qedf_main.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-00800
Уязвимость компонента drivers/uio/uio_hv_generic.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-00810
Уязвимость функции enic_hard_start_xmit() ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-00811
Уязвимость функции i40e_client_subtask() ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-00812
Уязвимость функции hfsplus_file_truncate() компонента fs/hfsplus/extents.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
Modified: 2026-01-20
BDU:2025-00813
Уязвимость ядра операционной системы Linux, связанная с непроверенным индексированием массива, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-00814
Уязвимость функции nbd_disconnect_and_put() компонента /drivers/block/nbd.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-02853
Уязвимость функции nested_get_evmcs_page() модуля arch/x86/kvm/vmx/nested.c подсистемы виртуализации на платформе x86 ядра операционной системы Linux, позволяющая нарушителю оказать воздействие на конфиденциальность, целостность и доступность защищаемой информации.
BDU:2025-02855
Уязвимость функции ucsi_unregister_altmodes() модуля drivers/usb/typec/ucsi/ucsi.c - драйвера поддержки интерфейса системного программного обеспечения разъема USB Type- C ( UCSI) ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
Modified: 2026-02-17
BDU:2025-03846
Уязвимость функции auto_active() модуля drivers/gpu/drm/i915/i915_active.c - драйвера поддержки инфраструктуры прямого рендеринга (DRI) ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
BDU:2025-03848
Уязвимость функции kvm_pv_send_ipi() модуля arch/x86/include/asm/kvm_host.h на платформе x86 ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
BDU:2025-05164
Уязвимость функции mcp251x_stop() модуля drivers/net/can/spi/mcp251x.c - драйвера поддержки сетевых устройств CAN ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
Modified: 2025-08-19
BDU:2025-05173
Уязвимость функции init_dell_smbios_wmi() модуля drivers/platform/x86/dell-smbios-wmi.c - драйвера поддержки устройств X86 ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-05303
Уязвимость функции nvmet_rdma_send_done() модуля drivers/nvme/target/rdma.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-05306
Уязвимость функции f2fs_unlock_rpages() модуля fs/f2fs/compress.c поддержки файловой системы F2FS ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
Modified: 2026-01-20
BDU:2025-05308
Уязвимость функции sctp_sf_do_dupcook_a() модуля net/sctp/sm_statefuns.c реализации протокола SCTP (Stream Control Transmission Protocol) ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-05318
Уязвимость функции nft_rhash_destroy() модуля net/netfilter/nft_set_hash.c компонента netfilter ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-05319
Уязвимость функции f2fs_get_unusable_blocks() модуля fs/f2fs/f2fs.h поддержки файловой системы F2FS ядра операционной системы Linux, позволяющая нарушителю оказать воздействие на целостность защищаемой информации или вызвать отказ в обслуживании
Modified: 2025-08-19
BDU:2025-05320
Уязвимость функции __pipelined_op() модуля ipc/mqueue.c подсистемы межпроцессного взаимодействия IPC ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-05321
Уязвимость функции uclamp_bucket_id() модуля kernel/sched/core.c поддержки системы учета ресурсов ядра операционной системы Linux, позволяющая нарушителю получить доступ к защищаемой информации или вызвать отказ в обслуживании
BDU:2025-05322
Уязвимость функции acpi_device_add() модуля drivers/acpi/scan.c - драйвера поддержки ACPI (расширенный интерфейс конфигурации и питания) ядра операционной системы Linux, позволяющая нарушителю получить доступ к защищаемой информации
BDU:2025-06525
Уязвимость функции dwc3_gadget_exit() модуля drivers/usb/dwc3/gadget.c - драйвера поддержки устройств шины USB ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
BDU:2025-06527
Уязвимость функции shmem_mfill_atomic_pte() модуля mm/shmem.c подсистемы управления памятью ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
BDU:2025-06528
Уязвимость функции do_uaccess_flush_fixups() модуля arch/powerpc/lib/feature-fixups.c поддержки платформы PowerPC ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06530
Уязвимость функции nf_tables_newobj() модуля net/netfilter/nf_tables_api.c компонента netfilter ядра операционной системы Linux, позволяющая нарушителю получить доступ к защищаемой информации или вызвать отказ в обслуживании
BDU:2025-06531
Уязвимость функции local_daif_inherit() модуля arch/arm64/include/asm/daifflags.h поддержки платформы ARM 64-бит ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06533
Уязвимость функции idxd_cmd_exec() модуля drivers/dma/idxd/device.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06534
Уязвимость функции pci_epf_test_bind() модуля drivers/pci/endpoint/functions/pci-epf-test.c - драйвера поддержки утройств PCI ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06535
Уязвимость функции breakpoint_handler() модуля arch/arm/kernel/hw_breakpoint.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06536
Уязвимость функции f2fs_resize_fs() модуля fs/f2fs/gc.c поддержки файловой системы F2FS ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-06539
Уязвимость функции tpm_seal() модуля security/keys/trusted-keys/trusted_tpm1.c ядра операционной системы Linux, позволяющая нарушителю получить доступ к защищаемой информации или вызвать отказ в обслуживании
BDU:2025-07266
Уязвимость функции nvme_loop_create_ctrl() модуля drivers/nvme/target/loop.c ядра операционной системы Linux, позволяющая нарушителю получить доступ к защищаемой информации
BDU:2025-07268
Уязвимость функции ib_uverbs_handler_5() модуля drivers/infiniband/core/uverbs_std_types_device.c - драйвера поддержки InfiniBand ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
Modified: 2025-06-25
BDU:2025-07272
Уязвимость функции nvmet_alloc_ctrl() модуля drivers/nvme/target/core.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-07274
Уязвимость функции rxe_qp_init_req() модуля drivers/infiniband/sw/rxe/rxe_qp.c - драйвера поддержки InfiniBand ядра операционной системы Linux, позволяющая нарушителю оказать воздействие на конфиденциальность, целостность и доступность защищаемой информации
BDU:2025-07276
Уязвимость функции rpcrdma_reply_handler() модуля net/sunrpc/xprtrdma/rpc_rdma.c реализации протокола RPC ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании
BDU:2025-13605
Уязвимость функции __fh_to_dentry() модуля fs/ceph/export.c ядра операционной системы Linux, позволяющая нарушителю вызвать отказ в обслуживании.
Modified: 2024-11-21
CVE-2021-4157
An out of memory bounds write flaw (1 or 2 bytes of memory) in the Linux kernel NFS subsystem was found in the way users use mirroring (replication of files with NFS). A user, having access to the NFS mount, could potentially use this flaw to crash the system or escalate privileges on the system.
- https://bugzilla.redhat.com/show_bug.cgi?id=2034342
- https://lore.kernel.org/lkml/20210517140244.822185482%40linuxfoundation.org/
- https://security.netapp.com/advisory/ntap-20220602-0007/
- https://www.oracle.com/security-alerts/cpujul2022.html
- https://bugzilla.redhat.com/show_bug.cgi?id=2034342
- https://lore.kernel.org/lkml/20210517140244.822185482%40linuxfoundation.org/
- https://security.netapp.com/advisory/ntap-20220602-0007/
- https://www.oracle.com/security-alerts/cpujul2022.html
Modified: 2025-01-10
CVE-2021-46976
In the Linux kernel, the following vulnerability has been resolved: drm/i915: Fix crash in auto_retire The retire logic uses the 2 lower bits of the pointer to the retire function to store flags. However, the auto_retire function is not guaranteed to be aligned to a multiple of 4, which causes crashes as we jump to the wrong address, for example like this: 2021-04-24T18:03:53.804300Z WARNING kernel: [ 516.876901] invalid opcode: 0000 [#1] PREEMPT SMP NOPTI 2021-04-24T18:03:53.804310Z WARNING kernel: [ 516.876906] CPU: 7 PID: 146 Comm: kworker/u16:6 Tainted: G U 5.4.105-13595-g3cd84167b2df #1 2021-04-24T18:03:53.804311Z WARNING kernel: [ 516.876907] Hardware name: Google Volteer2/Volteer2, BIOS Google_Volteer2.13672.76.0 02/22/2021 2021-04-24T18:03:53.804312Z WARNING kernel: [ 516.876911] Workqueue: events_unbound active_work 2021-04-24T18:03:53.804313Z WARNING kernel: [ 516.876914] RIP: 0010:auto_retire+0x1/0x20 2021-04-24T18:03:53.804314Z WARNING kernel: [ 516.876916] Code: e8 01 f2 ff ff eb 02 31 db 48 89 d8 5b 5d c3 0f 1f 44 00 00 55 48 89 e5 f0 ff 87 c8 00 00 00 0f 88 ab 47 4a 00 31 c0 5d c3 0f <1f> 44 00 00 55 48 89 e5 f0 ff 8f c8 00 00 00 0f 88 9a 47 4a 00 74 2021-04-24T18:03:53.804319Z WARNING kernel: [ 516.876918] RSP: 0018:ffff9b4d809fbe38 EFLAGS: 00010286 2021-04-24T18:03:53.804320Z WARNING kernel: [ 516.876919] RAX: 0000000000000007 RBX: ffff927915079600 RCX: 0000000000000007 2021-04-24T18:03:53.804320Z WARNING kernel: [ 516.876921] RDX: ffff9b4d809fbe40 RSI: 0000000000000286 RDI: ffff927915079600 2021-04-24T18:03:53.804321Z WARNING kernel: [ 516.876922] RBP: ffff9b4d809fbe68 R08: 8080808080808080 R09: fefefefefefefeff 2021-04-24T18:03:53.804321Z WARNING kernel: [ 516.876924] R10: 0000000000000010 R11: ffffffff92e44bd8 R12: ffff9279150796a0 2021-04-24T18:03:53.804322Z WARNING kernel: [ 516.876925] R13: ffff92791c368180 R14: ffff927915079640 R15: 000000001c867605 2021-04-24T18:03:53.804323Z WARNING kernel: [ 516.876926] FS: 0000000000000000(0000) GS:ffff92791ffc0000(0000) knlGS:0000000000000000 2021-04-24T18:03:53.804323Z WARNING kernel: [ 516.876928] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 2021-04-24T18:03:53.804324Z WARNING kernel: [ 516.876929] CR2: 0000239514955000 CR3: 00000007f82da001 CR4: 0000000000760ee0 2021-04-24T18:03:53.804325Z WARNING kernel: [ 516.876930] PKRU: 55555554 2021-04-24T18:03:53.804325Z WARNING kernel: [ 516.876931] Call Trace: 2021-04-24T18:03:53.804326Z WARNING kernel: [ 516.876935] __active_retire+0x77/0xcf 2021-04-24T18:03:53.804326Z WARNING kernel: [ 516.876939] process_one_work+0x1da/0x394 2021-04-24T18:03:53.804327Z WARNING kernel: [ 516.876941] worker_thread+0x216/0x375 2021-04-24T18:03:53.804327Z WARNING kernel: [ 516.876944] kthread+0x147/0x156 2021-04-24T18:03:53.804335Z WARNING kernel: [ 516.876946] ? pr_cont_work+0x58/0x58 2021-04-24T18:03:53.804335Z WARNING kernel: [ 516.876948] ? kthread_blkcg+0x2e/0x2e 2021-04-24T18:03:53.804336Z WARNING kernel: [ 516.876950] ret_from_fork+0x1f/0x40 2021-04-24T18:03:53.804336Z WARNING kernel: [ 516.876952] Modules linked in: cdc_mbim cdc_ncm cdc_wdm xt_cgroup rfcomm cmac algif_hash algif_skcipher af_alg xt_MASQUERADE uinput snd_soc_rt5682_sdw snd_soc_rt5682 snd_soc_max98373_sdw snd_soc_max98373 snd_soc_rl6231 regmap_sdw snd_soc_sof_sdw snd_soc_hdac_hdmi snd_soc_dmic snd_hda_codec_hdmi snd_sof_pci snd_sof_intel_hda_common intel_ipu6_psys snd_sof_xtensa_dsp soundwire_intel soundwire_generic_allocation soundwire_cadence snd_sof_intel_hda snd_sof snd_soc_hdac_hda snd_soc_acpi_intel_match snd_soc_acpi snd_hda_ext_core soundwire_bus snd_hda_intel snd_intel_dspcfg snd_hda_codec snd_hwdep snd_hda_core intel_ipu6_isys videobuf2_dma_contig videobuf2_v4l2 videobuf2_common videobuf2_memops mei_hdcp intel_ipu6 ov2740 ov8856 at24 sx9310 dw9768 v4l2_fwnode cros_ec_typec intel_pmc_mux roles acpi_als typec fuse iio_trig_sysfs cros_ec_light_prox cros_ec_lid_angle cros_ec_sensors cros ---truncated---
- https://git.kernel.org/stable/c/402be8a101190969fc7ff122d07e262df86e132b
- https://git.kernel.org/stable/c/608441de3976c526b02af4d7063093c8adf351e3
- https://git.kernel.org/stable/c/805c990a9c54b9451d3daff640b850909c31ab9d
- https://git.kernel.org/stable/c/f7520970d5353cb1fa4d9089a1b23669c5da97fe
- https://git.kernel.org/stable/c/402be8a101190969fc7ff122d07e262df86e132b
- https://git.kernel.org/stable/c/608441de3976c526b02af4d7063093c8adf351e3
- https://git.kernel.org/stable/c/805c990a9c54b9451d3daff640b850909c31ab9d
- https://git.kernel.org/stable/c/f7520970d5353cb1fa4d9089a1b23669c5da97fe
Modified: 2025-01-08
CVE-2021-46977
In the Linux kernel, the following vulnerability has been resolved: KVM: VMX: Disable preemption when probing user return MSRs Disable preemption when probing a user return MSR via RDSMR/WRMSR. If the MSR holds a different value per logical CPU, the WRMSR could corrupt the host's value if KVM is preempted between the RDMSR and WRMSR, and then rescheduled on a different CPU. Opportunistically land the helper in common x86, SVM will use the helper in a future commit.
- https://git.kernel.org/stable/c/31f29749ee970c251b3a7e5b914108425940d089
- https://git.kernel.org/stable/c/5104d7ffcf24749939bea7fdb5378d186473f890
- https://git.kernel.org/stable/c/5adcdeb57007ccf8ab7ac20bf787ffb6fafb1a94
- https://git.kernel.org/stable/c/e3ea1895df719c4ef87862501bb10d95f4177bed
- https://git.kernel.org/stable/c/31f29749ee970c251b3a7e5b914108425940d089
- https://git.kernel.org/stable/c/5104d7ffcf24749939bea7fdb5378d186473f890
- https://git.kernel.org/stable/c/5adcdeb57007ccf8ab7ac20bf787ffb6fafb1a94
- https://git.kernel.org/stable/c/e3ea1895df719c4ef87862501bb10d95f4177bed
Modified: 2025-03-14
CVE-2021-46978
In the Linux kernel, the following vulnerability has been resolved: KVM: nVMX: Always make an attempt to map eVMCS after migration When enlightened VMCS is in use and nested state is migrated with vmx_get_nested_state()/vmx_set_nested_state() KVM can't map evmcs page right away: evmcs gpa is not 'struct kvm_vmx_nested_state_hdr' and we can't read it from VP assist page because userspace may decide to restore HV_X64_MSR_VP_ASSIST_PAGE after restoring nested state (and QEMU, for example, does exactly that). To make sure eVMCS is mapped /vmx_set_nested_state() raises KVM_REQ_GET_NESTED_STATE_PAGES request. Commit f2c7ef3ba955 ("KVM: nSVM: cancel KVM_REQ_GET_NESTED_STATE_PAGES on nested vmexit") added KVM_REQ_GET_NESTED_STATE_PAGES clearing to nested_vmx_vmexit() to make sure MSR permission bitmap is not switched when an immediate exit from L2 to L1 happens right after migration (caused by a pending event, for example). Unfortunately, in the exact same situation we still need to have eVMCS mapped so nested_sync_vmcs12_to_shadow() reflects changes in VMCS12 to eVMCS. As a band-aid, restore nested_get_evmcs_page() when clearing KVM_REQ_GET_NESTED_STATE_PAGES in nested_vmx_vmexit(). The 'fix' is far from being ideal as we can't easily propagate possible failures and even if we could, this is most likely already too late to do so. The whole 'KVM_REQ_GET_NESTED_STATE_PAGES' idea for mapping eVMCS after migration seems to be fragile as we diverge too much from the 'native' path when vmptr loading happens on vmx_set_nested_state().
- https://git.kernel.org/stable/c/200a45649ab7361bc80c70aebf7165b64f9a6c9f
- https://git.kernel.org/stable/c/bd0e8455b85b651a4c77de9616e307129b15aaa7
- https://git.kernel.org/stable/c/c8bf64e3fb77cc19bad146fbe26651985b117194
- https://git.kernel.org/stable/c/f5c7e8425f18fdb9bdb7d13340651d7876890329
- https://git.kernel.org/stable/c/200a45649ab7361bc80c70aebf7165b64f9a6c9f
- https://git.kernel.org/stable/c/bd0e8455b85b651a4c77de9616e307129b15aaa7
- https://git.kernel.org/stable/c/c8bf64e3fb77cc19bad146fbe26651985b117194
- https://git.kernel.org/stable/c/f5c7e8425f18fdb9bdb7d13340651d7876890329
Modified: 2024-12-31
CVE-2021-46980
In the Linux kernel, the following vulnerability has been resolved: usb: typec: ucsi: Retrieve all the PDOs instead of just the first 4 commit 4dbc6a4ef06d ("usb: typec: ucsi: save power data objects in PD mode") introduced retrieval of the PDOs when connected to a PD-capable source. But only the first 4 PDOs are received since that is the maximum number that can be fetched at a time given the MESSAGE_IN length limitation (16 bytes). However, as per the PD spec a connected source may advertise up to a maximum of 7 PDOs. If such a source is connected it's possible the PPM could have negotiated a power contract with one of the PDOs at index greater than 4, and would be reflected in the request data object's (RDO) object position field. This would result in an out-of-bounds access when the rdo_index() is used to index into the src_pdos array in ucsi_psy_get_voltage_now(). With the help of the UBSAN -fsanitize=array-bounds checker enabled this exact issue is revealed when connecting to a PD source adapter that advertise 5 PDOs and the PPM enters a contract having selected the 5th one. [ 151.545106][ T70] Unexpected kernel BRK exception at EL1 [ 151.545112][ T70] Internal error: BRK handler: f2005512 [#1] PREEMPT SMP ... [ 151.545499][ T70] pc : ucsi_psy_get_prop+0x208/0x20c [ 151.545507][ T70] lr : power_supply_show_property+0xc0/0x328 ... [ 151.545542][ T70] Call trace: [ 151.545544][ T70] ucsi_psy_get_prop+0x208/0x20c [ 151.545546][ T70] power_supply_uevent+0x1a4/0x2f0 [ 151.545550][ T70] dev_uevent+0x200/0x384 [ 151.545555][ T70] kobject_uevent_env+0x1d4/0x7e8 [ 151.545557][ T70] power_supply_changed_work+0x174/0x31c [ 151.545562][ T70] process_one_work+0x244/0x6f0 [ 151.545564][ T70] worker_thread+0x3e0/0xa64 We can resolve this by instead retrieving and storing up to the maximum of 7 PDOs in the con->src_pdos array. This would involve two calls to the GET_PDOS command.
- https://git.kernel.org/stable/c/1f4642b72be79757f050924a9b9673b6a02034bc
- https://git.kernel.org/stable/c/5e9c6f58b01e6fdfbc740390c01f542a35c97e57
- https://git.kernel.org/stable/c/a453bfd7ef15fd9d524004d3ca7b05353a302911
- https://git.kernel.org/stable/c/e5366bea0277425e1868ba20eeb27c879d5a6e2d
- https://git.kernel.org/stable/c/1f4642b72be79757f050924a9b9673b6a02034bc
- https://git.kernel.org/stable/c/5e9c6f58b01e6fdfbc740390c01f542a35c97e57
- https://git.kernel.org/stable/c/a453bfd7ef15fd9d524004d3ca7b05353a302911
- https://git.kernel.org/stable/c/e5366bea0277425e1868ba20eeb27c879d5a6e2d
Modified: 2024-12-06
CVE-2021-46981
In the Linux kernel, the following vulnerability has been resolved:
nbd: Fix NULL pointer in flush_workqueue
Open /dev/nbdX first, the config_refs will be 1 and
the pointers in nbd_device are still null. Disconnect
/dev/nbdX, then reference a null recv_workq. The
protection by config_refs in nbd_genl_disconnect is useless.
[ 656.366194] BUG: kernel NULL pointer dereference, address: 0000000000000020
[ 656.368943] #PF: supervisor write access in kernel mode
[ 656.369844] #PF: error_code(0x0002) - not-present page
[ 656.370717] PGD 10cc87067 P4D 10cc87067 PUD 1074b4067 PMD 0
[ 656.371693] Oops: 0002 [#1] SMP
[ 656.372242] CPU: 5 PID: 7977 Comm: nbd-client Not tainted 5.11.0-rc5-00040-g76c057c84d28 #1
[ 656.373661] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ?-20190727_073836-buildvm-ppc64le-16.ppc.fedoraproject.org-3.fc31 04/01/2014
[ 656.375904] RIP: 0010:mutex_lock+0x29/0x60
[ 656.376627] Code: 00 0f 1f 44 00 00 55 48 89 fd 48 83 05 6f d7 fe 08 01 e8 7a c3 ff ff 48 83 05 6a d7 fe 08 01 31 c0 65 48 8b 14 25 00 6d 01 00
- https://git.kernel.org/stable/c/1c4962df938891af9ab4775f5224ef8601764107
- https://git.kernel.org/stable/c/54b78ba7e96e5fe1edb8054e375d31a6c0dc60dc
- https://git.kernel.org/stable/c/79ebe9110fa458d58f1fceb078e2068d7ad37390
- https://git.kernel.org/stable/c/b31d237796fd618379ec8e0f4de3370b5e4aeee7
- https://git.kernel.org/stable/c/cde4b55cfb24522dcbba80bbdb0c082303e76c43
- https://git.kernel.org/stable/c/1c4962df938891af9ab4775f5224ef8601764107
- https://git.kernel.org/stable/c/54b78ba7e96e5fe1edb8054e375d31a6c0dc60dc
- https://git.kernel.org/stable/c/79ebe9110fa458d58f1fceb078e2068d7ad37390
- https://git.kernel.org/stable/c/b31d237796fd618379ec8e0f4de3370b5e4aeee7
- https://git.kernel.org/stable/c/cde4b55cfb24522dcbba80bbdb0c082303e76c43
Modified: 2024-12-31
CVE-2021-46982
In the Linux kernel, the following vulnerability has been resolved: f2fs: compress: fix race condition of overwrite vs truncate pos_fsstress testcase complains a panic as belew: ------------[ cut here ]------------ kernel BUG at fs/f2fs/compress.c:1082! invalid opcode: 0000 [#1] SMP PTI CPU: 4 PID: 2753477 Comm: kworker/u16:2 Tainted: G OE 5.12.0-rc1-custom #1 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.14.0-2 04/01/2014 Workqueue: writeback wb_workfn (flush-252:16) RIP: 0010:prepare_compress_overwrite+0x4c0/0x760 [f2fs] Call Trace: f2fs_prepare_compress_overwrite+0x5f/0x80 [f2fs] f2fs_write_cache_pages+0x468/0x8a0 [f2fs] f2fs_write_data_pages+0x2a4/0x2f0 [f2fs] do_writepages+0x38/0xc0 __writeback_single_inode+0x44/0x2a0 writeback_sb_inodes+0x223/0x4d0 __writeback_inodes_wb+0x56/0xf0 wb_writeback+0x1dd/0x290 wb_workfn+0x309/0x500 process_one_work+0x220/0x3c0 worker_thread+0x53/0x420 kthread+0x12f/0x150 ret_from_fork+0x22/0x30 The root cause is truncate() may race with overwrite as below, so that one reference count left in page can not guarantee the page attaching in mapping tree all the time, after truncation, later find_lock_page() may return NULL pointer. - prepare_compress_overwrite - f2fs_pagecache_get_page - unlock_page - f2fs_setattr - truncate_setsize - truncate_inode_page - delete_from_page_cache - find_lock_page Fix this by avoiding referencing updated page.
- https://git.kernel.org/stable/c/5639b73fd3bc6fc8ca72e3a9ac15aacaabd7ebff
- https://git.kernel.org/stable/c/64acb100fe3beb5d20184d0ae3307235bd3555c4
- https://git.kernel.org/stable/c/936158b15e2648253afb824d252c910c496d34b5
- https://git.kernel.org/stable/c/a949dc5f2c5cfe0c910b664650f45371254c0744
- https://git.kernel.org/stable/c/5639b73fd3bc6fc8ca72e3a9ac15aacaabd7ebff
- https://git.kernel.org/stable/c/64acb100fe3beb5d20184d0ae3307235bd3555c4
- https://git.kernel.org/stable/c/936158b15e2648253afb824d252c910c496d34b5
- https://git.kernel.org/stable/c/a949dc5f2c5cfe0c910b664650f45371254c0744
Modified: 2024-12-06
CVE-2021-46983
In the Linux kernel, the following vulnerability has been resolved: nvmet-rdma: Fix NULL deref when SEND is completed with error When running some traffic and taking down the link on peer, a retry counter exceeded error is received. This leads to nvmet_rdma_error_comp which tried accessing the cq_context to obtain the queue. The cq_context is no longer valid after the fix to use shared CQ mechanism and should be obtained similar to how it is obtained in other functions from the wc->qp. [ 905.786331] nvmet_rdma: SEND for CQE 0x00000000e3337f90 failed with status transport retry counter exceeded (12). [ 905.832048] BUG: unable to handle kernel NULL pointer dereference at 0000000000000048 [ 905.839919] PGD 0 P4D 0 [ 905.842464] Oops: 0000 1 SMP NOPTI [ 905.846144] CPU: 13 PID: 1557 Comm: kworker/13:1H Kdump: loaded Tainted: G OE --------- - - 4.18.0-304.el8.x86_64 #1 [ 905.872135] RIP: 0010:nvmet_rdma_error_comp+0x5/0x1b [nvmet_rdma] [ 905.878259] Code: 19 4f c0 e8 89 b3 a5 f6 e9 5b e0 ff ff 0f b7 75 14 4c 89 ea 48 c7 c7 08 1a 4f c0 e8 71 b3 a5 f6 e9 4b e0 ff ff 0f 1f 44 00 00 <48> 8b 47 48 48 85 c0 74 08 48 89 c7 e9 98 bf 49 00 e9 c3 e3 ff ff [ 905.897135] RSP: 0018:ffffab601c45fe28 EFLAGS: 00010246 [ 905.902387] RAX: 0000000000000065 RBX: ffff9e729ea2f800 RCX: 0000000000000000 [ 905.909558] RDX: 0000000000000000 RSI: ffff9e72df9567c8 RDI: 0000000000000000 [ 905.916731] RBP: ffff9e729ea2b400 R08: 000000000000074d R09: 0000000000000074 [ 905.923903] R10: 0000000000000000 R11: ffffab601c45fcc0 R12: 0000000000000010 [ 905.931074] R13: 0000000000000000 R14: 0000000000000010 R15: ffff9e729ea2f400 [ 905.938247] FS: 0000000000000000(0000) GS:ffff9e72df940000(0000) knlGS:0000000000000000 [ 905.938249] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 905.950067] nvmet_rdma: SEND for CQE 0x00000000c7356cca failed with status transport retry counter exceeded (12). [ 905.961855] CR2: 0000000000000048 CR3: 000000678d010004 CR4: 00000000007706e0 [ 905.961855] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 905.961856] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 905.961857] PKRU: 55555554 [ 906.010315] Call Trace: [ 906.012778] __ib_process_cq+0x89/0x170 [ib_core] [ 906.017509] ib_cq_poll_work+0x26/0x80 [ib_core] [ 906.022152] process_one_work+0x1a7/0x360 [ 906.026182] ? create_worker+0x1a0/0x1a0 [ 906.030123] worker_thread+0x30/0x390 [ 906.033802] ? create_worker+0x1a0/0x1a0 [ 906.037744] kthread+0x116/0x130 [ 906.040988] ? kthread_flush_work_fn+0x10/0x10 [ 906.045456] ret_from_fork+0x1f/0x40
- https://git.kernel.org/stable/c/17fb6dfa5162b89ecfa07df891a53afec321abe8
- https://git.kernel.org/stable/c/5bdb34466ad8370546dfa0497594fb1d6f2fed90
- https://git.kernel.org/stable/c/64f3410c7bfc389b1a58611d0799f4a36ce4b6b5
- https://git.kernel.org/stable/c/8cc365f9559b86802afc0208389f5c8d46b4ad61
- https://git.kernel.org/stable/c/17fb6dfa5162b89ecfa07df891a53afec321abe8
- https://git.kernel.org/stable/c/5bdb34466ad8370546dfa0497594fb1d6f2fed90
- https://git.kernel.org/stable/c/64f3410c7bfc389b1a58611d0799f4a36ce4b6b5
- https://git.kernel.org/stable/c/8cc365f9559b86802afc0208389f5c8d46b4ad61
Modified: 2024-12-06
CVE-2021-46984
In the Linux kernel, the following vulnerability has been resolved: kyber: fix out of bounds access when preempted __blk_mq_sched_bio_merge() gets the ctx and hctx for the current CPU and passes the hctx to ->bio_merge(). kyber_bio_merge() then gets the ctx for the current CPU again and uses that to get the corresponding Kyber context in the passed hctx. However, the thread may be preempted between the two calls to blk_mq_get_ctx(), and the ctx returned the second time may no longer correspond to the passed hctx. This "works" accidentally most of the time, but it can cause us to read garbage if the second ctx came from an hctx with more ctx's than the first one (i.e., if ctx->index_hw[hctx->type] > hctx->nr_ctx). This manifested as this UBSAN array index out of bounds error reported by Jakub: UBSAN: array-index-out-of-bounds in ../kernel/locking/qspinlock.c:130:9 index 13106 is out of range for type 'long unsigned int [128]' Call Trace: dump_stack+0xa4/0xe5 ubsan_epilogue+0x5/0x40 __ubsan_handle_out_of_bounds.cold.13+0x2a/0x34 queued_spin_lock_slowpath+0x476/0x480 do_raw_spin_lock+0x1c2/0x1d0 kyber_bio_merge+0x112/0x180 blk_mq_submit_bio+0x1f5/0x1100 submit_bio_noacct+0x7b0/0x870 submit_bio+0xc2/0x3a0 btrfs_map_bio+0x4f0/0x9d0 btrfs_submit_data_bio+0x24e/0x310 submit_one_bio+0x7f/0xb0 submit_extent_page+0xc4/0x440 __extent_writepage_io+0x2b8/0x5e0 __extent_writepage+0x28d/0x6e0 extent_write_cache_pages+0x4d7/0x7a0 extent_writepages+0xa2/0x110 do_writepages+0x8f/0x180 __writeback_single_inode+0x99/0x7f0 writeback_sb_inodes+0x34e/0x790 __writeback_inodes_wb+0x9e/0x120 wb_writeback+0x4d2/0x660 wb_workfn+0x64d/0xa10 process_one_work+0x53a/0xa80 worker_thread+0x69/0x5b0 kthread+0x20b/0x240 ret_from_fork+0x1f/0x30 Only Kyber uses the hctx, so fix it by passing the request_queue to ->bio_merge() instead. BFQ and mq-deadline just use that, and Kyber can map the queues itself to avoid the mismatch.
- https://git.kernel.org/stable/c/0b6b4b90b74c27bea968c214d820ba4254b903a5
- https://git.kernel.org/stable/c/2ef3c76540c49167a0bc3d5f80d00fd1fc4586df
- https://git.kernel.org/stable/c/54dbe2d2c1fcabf650c7a8b747601da355cd7f9f
- https://git.kernel.org/stable/c/a287cd84e047045f5a4d4da793414e848de627c6
- https://git.kernel.org/stable/c/efed9a3337e341bd0989161b97453b52567bc59d
- https://git.kernel.org/stable/c/0b6b4b90b74c27bea968c214d820ba4254b903a5
- https://git.kernel.org/stable/c/2ef3c76540c49167a0bc3d5f80d00fd1fc4586df
- https://git.kernel.org/stable/c/54dbe2d2c1fcabf650c7a8b747601da355cd7f9f
- https://git.kernel.org/stable/c/a287cd84e047045f5a4d4da793414e848de627c6
- https://git.kernel.org/stable/c/efed9a3337e341bd0989161b97453b52567bc59d
Modified: 2024-12-06
CVE-2021-46985
In the Linux kernel, the following vulnerability has been resolved: ACPI: scan: Fix a memory leak in an error handling path If 'acpi_device_set_name()' fails, we must free 'acpi_device_bus_id->bus_id' or there is a (potential) memory leak.
- https://git.kernel.org/stable/c/0c8bd174f0fc131bc9dfab35cd8784f59045da87
- https://git.kernel.org/stable/c/5ab9857dde7c3ea3faef6b128d718cf8ba98721b
- https://git.kernel.org/stable/c/6901a4f795e0e8d65ae779cb37fc22e0bf294712
- https://git.kernel.org/stable/c/69cc821e89ce572884548ac54c4f80eec7a837a5
- https://git.kernel.org/stable/c/a7e17a8d421ae23c920240625b4413c7b94d94a4
- https://git.kernel.org/stable/c/c5c8f6ffc942cf42f990f22e35bcf4cbe9d8c2fb
- https://git.kernel.org/stable/c/dafd4c0b5e835db020cff11c74b4af9493a58e72
- https://git.kernel.org/stable/c/e2381174daeae0ca35eddffef02dcc8de8c1ef8a
- https://git.kernel.org/stable/c/0c8bd174f0fc131bc9dfab35cd8784f59045da87
- https://git.kernel.org/stable/c/5ab9857dde7c3ea3faef6b128d718cf8ba98721b
- https://git.kernel.org/stable/c/6901a4f795e0e8d65ae779cb37fc22e0bf294712
- https://git.kernel.org/stable/c/69cc821e89ce572884548ac54c4f80eec7a837a5
- https://git.kernel.org/stable/c/a7e17a8d421ae23c920240625b4413c7b94d94a4
- https://git.kernel.org/stable/c/c5c8f6ffc942cf42f990f22e35bcf4cbe9d8c2fb
- https://git.kernel.org/stable/c/dafd4c0b5e835db020cff11c74b4af9493a58e72
- https://git.kernel.org/stable/c/e2381174daeae0ca35eddffef02dcc8de8c1ef8a
Modified: 2024-12-31
CVE-2021-46986
In the Linux kernel, the following vulnerability has been resolved: usb: dwc3: gadget: Free gadget structure only after freeing endpoints As part of commit e81a7018d93a ("usb: dwc3: allocate gadget structure dynamically") the dwc3_gadget_release() was added which will free the dwc->gadget structure upon the device's removal when usb_del_gadget_udc() is called in dwc3_gadget_exit(). However, simply freeing the gadget results a dangling pointer situation: the endpoints created in dwc3_gadget_init_endpoints() have their dep->endpoint.ep_list members chained off the list_head anchored at dwc->gadget->ep_list. Thus when dwc->gadget is freed, the first dwc3_ep in the list now has a dangling prev pointer and likewise for the next pointer of the dwc3_ep at the tail of the list. The dwc3_gadget_free_endpoints() that follows will result in a use-after-free when it calls list_del(). This was caught by enabling KASAN and performing a driver unbind. The recent commit 568262bf5492 ("usb: dwc3: core: Add shutdown callback for dwc3") also exposes this as a panic during shutdown. There are a few possibilities to fix this. One could be to perform a list_del() of the gadget->ep_list itself which removes it from the rest of the dwc3_ep chain. Another approach is what this patch does, by splitting up the usb_del_gadget_udc() call into its separate "del" and "put" components. This allows dwc3_gadget_free_endpoints() to be called before the gadget is finally freed with usb_put_gadget().
- https://git.kernel.org/stable/c/1ea775021282d90e1d08d696b7ab54aa75d688e5
- https://git.kernel.org/stable/c/b4b8e9601d7ee8806d2687f081a42485d27674a1
- https://git.kernel.org/stable/c/bb9c74a5bd1462499fe5ccb1e3c5ac40dcfa9139
- https://git.kernel.org/stable/c/bc0cdd72493236fb72b390ad38ce581e353c143c
- https://git.kernel.org/stable/c/1ea775021282d90e1d08d696b7ab54aa75d688e5
- https://git.kernel.org/stable/c/b4b8e9601d7ee8806d2687f081a42485d27674a1
- https://git.kernel.org/stable/c/bb9c74a5bd1462499fe5ccb1e3c5ac40dcfa9139
- https://git.kernel.org/stable/c/bc0cdd72493236fb72b390ad38ce581e353c143c
Modified: 2024-12-26
CVE-2021-46988
In the Linux kernel, the following vulnerability has been resolved: userfaultfd: release page in error path to avoid BUG_ON Consider the following sequence of events: 1. Userspace issues a UFFD ioctl, which ends up calling into shmem_mfill_atomic_pte(). We successfully account the blocks, we shmem_alloc_page(), but then the copy_from_user() fails. We return -ENOENT. We don't release the page we allocated. 2. Our caller detects this error code, tries the copy_from_user() after dropping the mmap_lock, and retries, calling back into shmem_mfill_atomic_pte(). 3. Meanwhile, let's say another process filled up the tmpfs being used. 4. So shmem_mfill_atomic_pte() fails to account blocks this time, and immediately returns - without releasing the page. This triggers a BUG_ON in our caller, which asserts that the page should always be consumed, unless -ENOENT is returned. To fix this, detect if we have such a "dangling" page when accounting fails, and if so, release it before returning.
- https://git.kernel.org/stable/c/07c9b834c97d0fa3402fb7f3f3b32df370a6ff1f
- https://git.kernel.org/stable/c/140cfd9980124aecb6c03ef2e69c72d0548744de
- https://git.kernel.org/stable/c/2d59a0ed8b26b8f3638d8afc31f839e27759f1f6
- https://git.kernel.org/stable/c/319116227e52d49eee671f0aa278bac89b3c1b69
- https://git.kernel.org/stable/c/7ed9d238c7dbb1fdb63ad96a6184985151b0171c
- https://git.kernel.org/stable/c/ad53127973034c63b5348715a1043d0e80ceb330
- https://git.kernel.org/stable/c/b3f1731c6d7fbc1ebe3ed8eff6d6bec56d76ff43
- https://git.kernel.org/stable/c/07c9b834c97d0fa3402fb7f3f3b32df370a6ff1f
- https://git.kernel.org/stable/c/140cfd9980124aecb6c03ef2e69c72d0548744de
- https://git.kernel.org/stable/c/2d59a0ed8b26b8f3638d8afc31f839e27759f1f6
- https://git.kernel.org/stable/c/319116227e52d49eee671f0aa278bac89b3c1b69
- https://git.kernel.org/stable/c/7ed9d238c7dbb1fdb63ad96a6184985151b0171c
- https://git.kernel.org/stable/c/ad53127973034c63b5348715a1043d0e80ceb330
- https://git.kernel.org/stable/c/b3f1731c6d7fbc1ebe3ed8eff6d6bec56d76ff43
Modified: 2025-03-14
CVE-2021-46989
In the Linux kernel, the following vulnerability has been resolved: hfsplus: prevent corruption in shrinking truncate I believe there are some issues introduced by commit 31651c607151 ("hfsplus: avoid deadlock on file truncation") HFS+ has extent records which always contains 8 extents. In case the first extent record in catalog file gets full, new ones are allocated from extents overflow file. In case shrinking truncate happens to middle of an extent record which locates in extents overflow file, the logic in hfsplus_file_truncate() was changed so that call to hfs_brec_remove() is not guarded any more. Right action would be just freeing the extents that exceed the new size inside extent record by calling hfsplus_free_extents(), and then check if the whole extent record should be removed. However since the guard (blk_cnt > start) is now after the call to hfs_brec_remove(), this has unfortunate effect that the last matching extent record is removed unconditionally. To reproduce this issue, create a file which has at least 10 extents, and then perform shrinking truncate into middle of the last extent record, so that the number of remaining extents is not under or divisible by 8. This causes the last extent record (8 extents) to be removed totally instead of truncating into middle of it. Thus this causes corruption, and lost data. Fix for this is simply checking if the new truncated end is below the start of this extent record, making it safe to remove the full extent record. However call to hfs_brec_remove() can't be moved to it's previous place since we're dropping ->tree_lock and it can cause a race condition and the cached info being invalidated possibly corrupting the node data. Another issue is related to this one. When entering into the block (blk_cnt > start) we are not holding the ->tree_lock. We break out from the loop not holding the lock, but hfs_find_exit() does unlock it. Not sure if it's possible for someone else to take the lock under our feet, but it can cause hard to debug errors and premature unlocking. Even if there's no real risk of it, the locking should still always be kept in balance. Thus taking the lock now just before the check.
- https://git.kernel.org/stable/c/52dde855663e5db824af51db39b5757d2ef3e28a
- https://git.kernel.org/stable/c/97314e45aa1223a42d60256a62c5d9af54baf446
- https://git.kernel.org/stable/c/adbd8a2a8cc05d9e501f93e5c95c59307874cc99
- https://git.kernel.org/stable/c/c3187cf32216313fb316084efac4dab3a8459b1d
- https://git.kernel.org/stable/c/c451a6bafb5f422197d31536f82116aed132b72c
- https://git.kernel.org/stable/c/c477f62db1a0c0ecaa60a29713006ceeeb04b685
- https://git.kernel.org/stable/c/52dde855663e5db824af51db39b5757d2ef3e28a
- https://git.kernel.org/stable/c/97314e45aa1223a42d60256a62c5d9af54baf446
- https://git.kernel.org/stable/c/adbd8a2a8cc05d9e501f93e5c95c59307874cc99
- https://git.kernel.org/stable/c/c3187cf32216313fb316084efac4dab3a8459b1d
- https://git.kernel.org/stable/c/c451a6bafb5f422197d31536f82116aed132b72c
- https://git.kernel.org/stable/c/c477f62db1a0c0ecaa60a29713006ceeeb04b685
Modified: 2024-12-26
CVE-2021-46990
In the Linux kernel, the following vulnerability has been resolved: powerpc/64s: Fix crashes when toggling entry flush barrier The entry flush mitigation can be enabled/disabled at runtime via a debugfs file (entry_flush), which causes the kernel to patch itself to enable/disable the relevant mitigations. However depending on which mitigation we're using, it may not be safe to do that patching while other CPUs are active. For example the following crash: sleeper[15639]: segfault (11) at c000000000004c20 nip c000000000004c20 lr c000000000004c20 Shows that we returned to userspace with a corrupted LR that points into the kernel, due to executing the partially patched call to the fallback entry flush (ie. we missed the LR restore). Fix it by doing the patching under stop machine. The CPUs that aren't doing the patching will be spinning in the core of the stop machine logic. That is currently sufficient for our purposes, because none of the patching we do is to that code or anywhere in the vicinity.
- https://git.kernel.org/stable/c/0b4eb172cc12dc102cd0ad013e53ee4463db9508
- https://git.kernel.org/stable/c/0c25a7bb697f2e6ee65b6d63782f675bf129511a
- https://git.kernel.org/stable/c/2db22ba4e0e103f00e0512e0ecce36ac78c644f8
- https://git.kernel.org/stable/c/5bc00fdda1e934c557351a9c751a205293e68cbf
- https://git.kernel.org/stable/c/8382b15864e5014261b4f36c2aa89723612ee058
- https://git.kernel.org/stable/c/aec86b052df6541cc97c5fca44e5934cbea4963b
- https://git.kernel.org/stable/c/d2e3590ca39ccfd8a5a46d8c7f095cb6c7b9ae92
- https://git.kernel.org/stable/c/dd0d6117052faace5440db20fc37175efe921c7d
- https://git.kernel.org/stable/c/ee4b7aab93c2631c3bb0753023c5dda592bb666b
- https://git.kernel.org/stable/c/0b4eb172cc12dc102cd0ad013e53ee4463db9508
- https://git.kernel.org/stable/c/0c25a7bb697f2e6ee65b6d63782f675bf129511a
- https://git.kernel.org/stable/c/2db22ba4e0e103f00e0512e0ecce36ac78c644f8
- https://git.kernel.org/stable/c/5bc00fdda1e934c557351a9c751a205293e68cbf
- https://git.kernel.org/stable/c/8382b15864e5014261b4f36c2aa89723612ee058
- https://git.kernel.org/stable/c/aec86b052df6541cc97c5fca44e5934cbea4963b
- https://git.kernel.org/stable/c/d2e3590ca39ccfd8a5a46d8c7f095cb6c7b9ae92
- https://git.kernel.org/stable/c/dd0d6117052faace5440db20fc37175efe921c7d
- https://git.kernel.org/stable/c/ee4b7aab93c2631c3bb0753023c5dda592bb666b
Modified: 2024-12-06
CVE-2021-46991
In the Linux kernel, the following vulnerability has been resolved: i40e: Fix use-after-free in i40e_client_subtask() Currently the call to i40e_client_del_instance frees the object pf->cinst, however pf->cinst->lan_info is being accessed after the free. Fix this by adding the missing return. Addresses-Coverity: ("Read from pointer after free")
- https://git.kernel.org/stable/c/1fd5d262e7442192ac7611ff1597a36c5b044323
- https://git.kernel.org/stable/c/38318f23a7ef86a8b1862e5e8078c4de121960c3
- https://git.kernel.org/stable/c/4ebc10aa7cd17fd9857dedac69600465c9dd16d1
- https://git.kernel.org/stable/c/829a713450b8fb127cbabfc1244c1d8179ec5107
- https://git.kernel.org/stable/c/c1322eaeb8af0d8985b5cc5fa759140fa0e57b84
- https://git.kernel.org/stable/c/d718c15a2bf9ae082d5ae4d177fb19ef23cb4132
- https://git.kernel.org/stable/c/1fd5d262e7442192ac7611ff1597a36c5b044323
- https://git.kernel.org/stable/c/38318f23a7ef86a8b1862e5e8078c4de121960c3
- https://git.kernel.org/stable/c/4ebc10aa7cd17fd9857dedac69600465c9dd16d1
- https://git.kernel.org/stable/c/829a713450b8fb127cbabfc1244c1d8179ec5107
- https://git.kernel.org/stable/c/c1322eaeb8af0d8985b5cc5fa759140fa0e57b84
- https://git.kernel.org/stable/c/d718c15a2bf9ae082d5ae4d177fb19ef23cb4132
Modified: 2024-12-24
CVE-2021-46992
In the Linux kernel, the following vulnerability has been resolved: netfilter: nftables: avoid overflows in nft_hash_buckets() Number of buckets being stored in 32bit variables, we have to ensure that no overflows occur in nft_hash_buckets() syzbot injected a size == 0x40000000 and reported: UBSAN: shift-out-of-bounds in ./include/linux/log2.h:57:13 shift exponent 64 is too large for 64-bit type 'long unsigned int' CPU: 1 PID: 29539 Comm: syz-executor.4 Not tainted 5.12.0-rc7-syzkaller #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 Call Trace: __dump_stack lib/dump_stack.c:79 [inline] dump_stack+0x141/0x1d7 lib/dump_stack.c:120 ubsan_epilogue+0xb/0x5a lib/ubsan.c:148 __ubsan_handle_shift_out_of_bounds.cold+0xb1/0x181 lib/ubsan.c:327 __roundup_pow_of_two include/linux/log2.h:57 [inline] nft_hash_buckets net/netfilter/nft_set_hash.c:411 [inline] nft_hash_estimate.cold+0x19/0x1e net/netfilter/nft_set_hash.c:652 nft_select_set_ops net/netfilter/nf_tables_api.c:3586 [inline] nf_tables_newset+0xe62/0x3110 net/netfilter/nf_tables_api.c:4322 nfnetlink_rcv_batch+0xa09/0x24b0 net/netfilter/nfnetlink.c:488 nfnetlink_rcv_skb_batch net/netfilter/nfnetlink.c:612 [inline] nfnetlink_rcv+0x3af/0x420 net/netfilter/nfnetlink.c:630 netlink_unicast_kernel net/netlink/af_netlink.c:1312 [inline] netlink_unicast+0x533/0x7d0 net/netlink/af_netlink.c:1338 netlink_sendmsg+0x856/0xd90 net/netlink/af_netlink.c:1927 sock_sendmsg_nosec net/socket.c:654 [inline] sock_sendmsg+0xcf/0x120 net/socket.c:674 ____sys_sendmsg+0x6e8/0x810 net/socket.c:2350 ___sys_sendmsg+0xf3/0x170 net/socket.c:2404 __sys_sendmsg+0xe5/0x1b0 net/socket.c:2433 do_syscall_64+0x2d/0x70 arch/x86/entry/common.c:46
- https://git.kernel.org/stable/c/1e8ab479cfbe5751efccedb95afb9b112a5ba475
- https://git.kernel.org/stable/c/2824cafc6a93792d9ad85939c499161214d84c4b
- https://git.kernel.org/stable/c/72b49dd116ca00a46a11d5a4d8d7987f05ed9cd7
- https://git.kernel.org/stable/c/a388d10961ff8578b1a6691945d406c0f33aa71b
- https://git.kernel.org/stable/c/a54754ec9891830ba548e2010c889e3c8146e449
- https://git.kernel.org/stable/c/c77e2ef18167ad334e27610ced9a7f6af5ec1787
- https://git.kernel.org/stable/c/efcd730ddd6f25578bd31bfe703e593e2421d708
- https://git.kernel.org/stable/c/1e8ab479cfbe5751efccedb95afb9b112a5ba475
- https://git.kernel.org/stable/c/2824cafc6a93792d9ad85939c499161214d84c4b
- https://git.kernel.org/stable/c/72b49dd116ca00a46a11d5a4d8d7987f05ed9cd7
- https://git.kernel.org/stable/c/a388d10961ff8578b1a6691945d406c0f33aa71b
- https://git.kernel.org/stable/c/a54754ec9891830ba548e2010c889e3c8146e449
- https://git.kernel.org/stable/c/c77e2ef18167ad334e27610ced9a7f6af5ec1787
- https://git.kernel.org/stable/c/efcd730ddd6f25578bd31bfe703e593e2421d708
Modified: 2024-12-24
CVE-2021-46993
In the Linux kernel, the following vulnerability has been resolved: sched: Fix out-of-bound access in uclamp Util-clamp places tasks in different buckets based on their clamp values for performance reasons. However, the size of buckets is currently computed using a rounding division, which can lead to an off-by-one error in some configurations. For instance, with 20 buckets, the bucket size will be 1024/20=51. A task with a clamp of 1024 will be mapped to bucket id 1024/51=20. Sadly, correct indexes are in range [0,19], hence leading to an out of bound memory access. Clamp the bucket id to fix the issue.
- https://git.kernel.org/stable/c/3da3f804b82a0a382d523a21acf4cf3bb35f936d
- https://git.kernel.org/stable/c/42ee47c7e3569d9a0e2cb5053c496d97d380472f
- https://git.kernel.org/stable/c/687f523c134b7f0bd040ee1230f6d17990d54172
- https://git.kernel.org/stable/c/6d2f8909a5fabb73fe2a63918117943986c39b6c
- https://git.kernel.org/stable/c/f7347c85490b92dd144fa1fba9e1eca501656ab3
- https://git.kernel.org/stable/c/3da3f804b82a0a382d523a21acf4cf3bb35f936d
- https://git.kernel.org/stable/c/42ee47c7e3569d9a0e2cb5053c496d97d380472f
- https://git.kernel.org/stable/c/687f523c134b7f0bd040ee1230f6d17990d54172
- https://git.kernel.org/stable/c/6d2f8909a5fabb73fe2a63918117943986c39b6c
- https://git.kernel.org/stable/c/f7347c85490b92dd144fa1fba9e1eca501656ab3
Modified: 2024-12-06
CVE-2021-46994
In the Linux kernel, the following vulnerability has been resolved: can: mcp251x: fix resume from sleep before interface was brought up Since 8ce8c0abcba3 the driver queues work via priv->restart_work when resuming after suspend, even when the interface was not previously enabled. This causes a null dereference error as the workqueue is only allocated and initialized in mcp251x_open(). To fix this we move the workqueue init to mcp251x_can_probe() as there is no reason to do it later and repeat it whenever mcp251x_open() is called. [mkl: fix error handling in mcp251x_stop()]
- https://git.kernel.org/stable/c/03c427147b2d3e503af258711af4fc792b89b0af
- https://git.kernel.org/stable/c/6f8f1c27b577de15f69fefce3c502bb6300d825c
- https://git.kernel.org/stable/c/e1e10a390fd9479209c4d834d916ca5e6d5d396b
- https://git.kernel.org/stable/c/eecb4df8ec9f896b19ee05bfa632ac6c1dcd8f21
- https://git.kernel.org/stable/c/03c427147b2d3e503af258711af4fc792b89b0af
- https://git.kernel.org/stable/c/6f8f1c27b577de15f69fefce3c502bb6300d825c
- https://git.kernel.org/stable/c/e1e10a390fd9479209c4d834d916ca5e6d5d396b
- https://git.kernel.org/stable/c/eecb4df8ec9f896b19ee05bfa632ac6c1dcd8f21
Modified: 2024-12-06
CVE-2021-46996
In the Linux kernel, the following vulnerability has been resolved: netfilter: nftables: Fix a memleak from userdata error path in new objects Release object name if userdata allocation fails.
- https://git.kernel.org/stable/c/2c784a500f5edd337258b0fdb2f31bc9abde1a23
- https://git.kernel.org/stable/c/59fa98bfa1f4013d658d990cac88c87b46ff410c
- https://git.kernel.org/stable/c/85dfd816fabfc16e71786eda0a33a7046688b5b0
- https://git.kernel.org/stable/c/dd3bebf515f336214a91994348a2b86b9a1d3d7f
- https://git.kernel.org/stable/c/2c784a500f5edd337258b0fdb2f31bc9abde1a23
- https://git.kernel.org/stable/c/59fa98bfa1f4013d658d990cac88c87b46ff410c
- https://git.kernel.org/stable/c/85dfd816fabfc16e71786eda0a33a7046688b5b0
- https://git.kernel.org/stable/c/dd3bebf515f336214a91994348a2b86b9a1d3d7f
Modified: 2024-12-24
CVE-2021-46997
In the Linux kernel, the following vulnerability has been resolved: arm64: entry: always set GIC_PRIO_PSR_I_SET during entry Zenghui reports that booting a kernel with "irqchip.gicv3_pseudo_nmi=1" on the command line hits a warning during kernel entry, due to the way we manipulate the PMR. Early in the entry sequence, we call lockdep_hardirqs_off() to inform lockdep that interrupts have been masked (as the HW sets DAIF wqhen entering an exception). Architecturally PMR_EL1 is not affected by exception entry, and we don't set GIC_PRIO_PSR_I_SET in the PMR early in the exception entry sequence, so early in exception entry the PMR can indicate that interrupts are unmasked even though they are masked by DAIF. If DEBUG_LOCKDEP is selected, lockdep_hardirqs_off() will check that interrupts are masked, before we set GIC_PRIO_PSR_I_SET in any of the exception entry paths, and hence lockdep_hardirqs_off() will WARN() that something is amiss. We can avoid this by consistently setting GIC_PRIO_PSR_I_SET during exception entry so that kernel code sees a consistent environment. We must also update local_daif_inherit() to undo this, as currently only touches DAIF. For other paths, local_daif_restore() will update both DAIF and the PMR. With this done, we can remove the existing special cases which set this later in the entry code. We always use (GIC_PRIO_IRQON | GIC_PRIO_PSR_I_SET) for consistency with local_daif_save(), as this will warn if it ever encounters (GIC_PRIO_IRQOFF | GIC_PRIO_PSR_I_SET), and never sets this itself. This matches the gic_prio_kentry_setup that we have to retain for ret_to_user. The original splat from Zenghui's report was: | DEBUG_LOCKS_WARN_ON(!irqs_disabled()) | WARNING: CPU: 3 PID: 125 at kernel/locking/lockdep.c:4258 lockdep_hardirqs_off+0xd4/0xe8 | Modules linked in: | CPU: 3 PID: 125 Comm: modprobe Tainted: G W 5.12.0-rc8+ #463 | Hardware name: QEMU KVM Virtual Machine, BIOS 0.0.0 02/06/2015 | pstate: 604003c5 (nZCv DAIF +PAN -UAO -TCO BTYPE=--) | pc : lockdep_hardirqs_off+0xd4/0xe8 | lr : lockdep_hardirqs_off+0xd4/0xe8 | sp : ffff80002a39bad0 | pmr_save: 000000e0 | x29: ffff80002a39bad0 x28: ffff0000de214bc0 | x27: ffff0000de1c0400 x26: 000000000049b328 | x25: 0000000000406f30 x24: ffff0000de1c00a0 | x23: 0000000020400005 x22: ffff8000105f747c | x21: 0000000096000044 x20: 0000000000498ef9 | x19: ffff80002a39bc88 x18: ffffffffffffffff | x17: 0000000000000000 x16: ffff800011c61eb0 | x15: ffff800011700a88 x14: 0720072007200720 | x13: 0720072007200720 x12: 0720072007200720 | x11: 0720072007200720 x10: 0720072007200720 | x9 : ffff80002a39bad0 x8 : ffff80002a39bad0 | x7 : ffff8000119f0800 x6 : c0000000ffff7fff | x5 : ffff8000119f07a8 x4 : 0000000000000001 | x3 : 9bcdab23f2432800 x2 : ffff800011730538 | x1 : 9bcdab23f2432800 x0 : 0000000000000000 | Call trace: | lockdep_hardirqs_off+0xd4/0xe8 | enter_from_kernel_mode.isra.5+0x7c/0xa8 | el1_abort+0x24/0x100 | el1_sync_handler+0x80/0xd0 | el1_sync+0x6c/0x100 | __arch_clear_user+0xc/0x90 | load_elf_binary+0x9fc/0x1450 | bprm_execve+0x404/0x880 | kernel_execve+0x180/0x188 | call_usermodehelper_exec_async+0xdc/0x158 | ret_from_fork+0x10/0x18
- https://git.kernel.org/stable/c/4d6a38da8e79e94cbd1344aa90876f0f805db705
- https://git.kernel.org/stable/c/51524fa8b5f7b879ba569227738375d283b79382
- https://git.kernel.org/stable/c/d8d52005f57bbb4a4ec02f647e2555d327135c68
- https://git.kernel.org/stable/c/e67a83f078005461b59b4c776e6b5addd11725fa
- https://git.kernel.org/stable/c/4d6a38da8e79e94cbd1344aa90876f0f805db705
- https://git.kernel.org/stable/c/51524fa8b5f7b879ba569227738375d283b79382
- https://git.kernel.org/stable/c/d8d52005f57bbb4a4ec02f647e2555d327135c68
- https://git.kernel.org/stable/c/e67a83f078005461b59b4c776e6b5addd11725fa
Modified: 2024-12-06
CVE-2021-46998
In the Linux kernel, the following vulnerability has been resolved: ethernet:enic: Fix a use after free bug in enic_hard_start_xmit In enic_hard_start_xmit, it calls enic_queue_wq_skb(). Inside enic_queue_wq_skb, if some error happens, the skb will be freed by dev_kfree_skb(skb). But the freed skb is still used in skb_tx_timestamp(skb). My patch makes enic_queue_wq_skb() return error and goto spin_unlock() incase of error. The solution is provided by Govind. See https://lkml.org/lkml/2021/4/30/961.
- https://git.kernel.org/stable/c/25a87b1f566b5eb2af2857a928f0e2310d900976
- https://git.kernel.org/stable/c/643001b47adc844ae33510c4bb93c236667008a3
- https://git.kernel.org/stable/c/6892396ebf04ea2c021d80e10f4075e014cd7cc3
- https://git.kernel.org/stable/c/7afdd6aba95c8a526038e7abe283eeac3e4320f1
- https://git.kernel.org/stable/c/d90529392aaf498dafa95d212295d64b2cea4e24
- https://git.kernel.org/stable/c/f7f6f07774091a6ddd98500b85386c3c6afb30d3
- https://git.kernel.org/stable/c/25a87b1f566b5eb2af2857a928f0e2310d900976
- https://git.kernel.org/stable/c/643001b47adc844ae33510c4bb93c236667008a3
- https://git.kernel.org/stable/c/6892396ebf04ea2c021d80e10f4075e014cd7cc3
- https://git.kernel.org/stable/c/7afdd6aba95c8a526038e7abe283eeac3e4320f1
- https://git.kernel.org/stable/c/d90529392aaf498dafa95d212295d64b2cea4e24
- https://git.kernel.org/stable/c/f7f6f07774091a6ddd98500b85386c3c6afb30d3
Modified: 2025-01-08
CVE-2021-46999
In the Linux kernel, the following vulnerability has been resolved: sctp: do asoc update earlier in sctp_sf_do_dupcook_a There's a panic that occurs in a few of envs, the call trace is as below: [] general protection fault, ... 0x29acd70f1000a: 0000 [#1] SMP PTI [] RIP: 0010:sctp_ulpevent_notify_peer_addr_change+0x4b/0x1fa [sctp] [] sctp_assoc_control_transport+0x1b9/0x210 [sctp] [] sctp_do_8_2_transport_strike.isra.16+0x15c/0x220 [sctp] [] sctp_cmd_interpreter.isra.21+0x1231/0x1a10 [sctp] [] sctp_do_sm+0xc3/0x2a0 [sctp] [] sctp_generate_timeout_event+0x81/0xf0 [sctp] This is caused by a transport use-after-free issue. When processing a duplicate COOKIE-ECHO chunk in sctp_sf_do_dupcook_a(), both COOKIE-ACK and SHUTDOWN chunks are allocated with the transort from the new asoc. However, later in the sideeffect machine, the old asoc is used to send them out and old asoc's shutdown_last_sent_to is set to the transport that SHUTDOWN chunk attached to in sctp_cmd_setup_t2(), which actually belongs to the new asoc. After the new_asoc is freed and the old asoc T2 timeout, the old asoc's shutdown_last_sent_to that is already freed would be accessed in sctp_sf_t2_timer_expire(). Thanks Alexander and Jere for helping dig into this issue. To fix it, this patch is to do the asoc update first, then allocate the COOKIE-ACK and SHUTDOWN chunks with the 'updated' old asoc. This would make more sense, as a chunk from an asoc shouldn't be sent out with another asoc. We had fixed quite a few issues caused by this.
- https://git.kernel.org/stable/c/0bfd913c2121b3d553bfd52810fe6061d542d625
- https://git.kernel.org/stable/c/35b4f24415c854cd718ccdf38dbea6297f010aae
- https://git.kernel.org/stable/c/61b877bad9bb0d82b7d8841be50872557090a704
- https://git.kernel.org/stable/c/b1b31948c0af44628e43353828453461bb74098f
- https://git.kernel.org/stable/c/d624f2991b977821375fbd56c91b0c91d456a697
- https://git.kernel.org/stable/c/f01988ecf3654f805282dce2d3bb9afe68d2691e
- https://git.kernel.org/stable/c/0bfd913c2121b3d553bfd52810fe6061d542d625
- https://git.kernel.org/stable/c/35b4f24415c854cd718ccdf38dbea6297f010aae
- https://git.kernel.org/stable/c/61b877bad9bb0d82b7d8841be50872557090a704
- https://git.kernel.org/stable/c/b1b31948c0af44628e43353828453461bb74098f
- https://git.kernel.org/stable/c/d624f2991b977821375fbd56c91b0c91d456a697
- https://git.kernel.org/stable/c/f01988ecf3654f805282dce2d3bb9afe68d2691e
Modified: 2025-03-14
CVE-2021-47000
In the Linux kernel, the following vulnerability has been resolved: ceph: fix inode leak on getattr error in __fh_to_dentry
- https://git.kernel.org/stable/c/0a219432127d396120fc88cabd82785e0ff72a2f
- https://git.kernel.org/stable/c/1775c7ddacfcea29051c67409087578f8f4d751b
- https://git.kernel.org/stable/c/22fa4c8288f1ec40f6d62d7a32c57ac176f9f0bc
- https://git.kernel.org/stable/c/2ad8af2b70e986284050213230428b823b950a38
- https://git.kernel.org/stable/c/bf45c9fe99aa8003d2703f1bd353f956dea47e40
- https://git.kernel.org/stable/c/0a219432127d396120fc88cabd82785e0ff72a2f
- https://git.kernel.org/stable/c/1775c7ddacfcea29051c67409087578f8f4d751b
- https://git.kernel.org/stable/c/22fa4c8288f1ec40f6d62d7a32c57ac176f9f0bc
- https://git.kernel.org/stable/c/2ad8af2b70e986284050213230428b823b950a38
- https://git.kernel.org/stable/c/bf45c9fe99aa8003d2703f1bd353f956dea47e40
Modified: 2025-04-11
CVE-2021-47001
In the Linux kernel, the following vulnerability has been resolved: xprtrdma: Fix cwnd update ordering After a reconnect, the reply handler is opening the cwnd (and thus enabling more RPC Calls to be sent) /before/ rpcrdma_post_recvs() can post enough Receive WRs to receive their replies. This causes an RNR and the new connection is lost immediately. The race is most clearly exposed when KASAN and disconnect injection are enabled. This slows down rpcrdma_rep_create() enough to allow the send side to post a bunch of RPC Calls before the Receive completion handler can invoke ib_post_recv().
- https://git.kernel.org/stable/c/19b5fa9489b5706bc878c3a522a7f771079e2fa0
- https://git.kernel.org/stable/c/35d8b10a25884050bb3b0149b62c3818ec59f77c
- https://git.kernel.org/stable/c/8834ecb5df22b7ff3c9b0deba7726579bb613f95
- https://git.kernel.org/stable/c/eddae8be7944096419c2ae29477a45f767d0fcd4
- https://git.kernel.org/stable/c/19b5fa9489b5706bc878c3a522a7f771079e2fa0
- https://git.kernel.org/stable/c/35d8b10a25884050bb3b0149b62c3818ec59f77c
- https://git.kernel.org/stable/c/8834ecb5df22b7ff3c9b0deba7726579bb613f95
- https://git.kernel.org/stable/c/eddae8be7944096419c2ae29477a45f767d0fcd4
- https://security.netapp.com/advisory/ntap-20250411-0001/
Modified: 2024-12-09
CVE-2021-47003
In the Linux kernel, the following vulnerability has been resolved: dmaengine: idxd: Fix potential null dereference on pointer status There are calls to idxd_cmd_exec that pass a null status pointer however a recent commit has added an assignment to *status that can end up with a null pointer dereference. The function expects a null status pointer sometimes as there is a later assignment to *status where status is first null checked. Fix the issue by null checking status before making the assignment. Addresses-Coverity: ("Explicit null dereferenced")
- https://git.kernel.org/stable/c/2280b4cc29d8cdd2be3d1b2d1ea4f958e2131c97
- https://git.kernel.org/stable/c/28ac8e03c43dfc6a703aa420d18222540b801120
- https://git.kernel.org/stable/c/5756f757c72501ef1a16f5f63f940623044180e9
- https://git.kernel.org/stable/c/7bc402f843e7817a4a808e7b9ab0bcd7ffd55bfa
- https://git.kernel.org/stable/c/2280b4cc29d8cdd2be3d1b2d1ea4f958e2131c97
- https://git.kernel.org/stable/c/28ac8e03c43dfc6a703aa420d18222540b801120
- https://git.kernel.org/stable/c/5756f757c72501ef1a16f5f63f940623044180e9
- https://git.kernel.org/stable/c/7bc402f843e7817a4a808e7b9ab0bcd7ffd55bfa
Modified: 2025-01-08
CVE-2021-47004
In the Linux kernel, the following vulnerability has been resolved: f2fs: fix to avoid touching checkpointed data in get_victim() In CP disabling mode, there are two issues when using LFS or SSR | AT_SSR mode to select victim: 1. LFS is set to find source section during GC, the victim should have no checkpointed data, since after GC, section could not be set free for reuse. Previously, we only check valid chpt blocks in current segment rather than section, fix it. 2. SSR | AT_SSR are set to find target segment for writes which can be fully filled by checkpointed and newly written blocks, we should never select such segment, otherwise it can cause panic or data corruption during allocation, potential case is described as below: a) target segment has 'n' (n < 512) ckpt valid blocks b) GC migrates 'n' valid blocks to other segment (segment is still in dirty list) c) GC migrates '512 - n' blocks to target segment (segment has 'n' cp_vblocks and '512 - n' vblocks) d) If GC selects target segment via {AT,}SSR allocator, however there is no free space in targe segment.
- https://git.kernel.org/stable/c/105155a8146ddb54c119d8318964eef3859d109d
- https://git.kernel.org/stable/c/1e116f87825f01a6380286472196882746b16f63
- https://git.kernel.org/stable/c/211372b2571520e394b56b431a0705586013b3ff
- https://git.kernel.org/stable/c/61461fc921b756ae16e64243f72af2bfc2e620db
- https://git.kernel.org/stable/c/105155a8146ddb54c119d8318964eef3859d109d
- https://git.kernel.org/stable/c/1e116f87825f01a6380286472196882746b16f63
- https://git.kernel.org/stable/c/211372b2571520e394b56b431a0705586013b3ff
- https://git.kernel.org/stable/c/61461fc921b756ae16e64243f72af2bfc2e620db
Modified: 2024-12-09
CVE-2021-47005
In the Linux kernel, the following vulnerability has been resolved: PCI: endpoint: Fix NULL pointer dereference for ->get_features() get_features ops of pci_epc_ops may return NULL, causing NULL pointer dereference in pci_epf_test_alloc_space function. Let us add a check for pci_epc_feature pointer in pci_epf_test_bind before we access it to avoid any such NULL pointer dereference and return -ENOTSUPP in case pci_epc_feature is not found. When the patch is not applied and EPC features is not implemented in the platform driver, we see the following dump due to kernel NULL pointer dereference. Call trace: pci_epf_test_bind+0xf4/0x388 pci_epf_bind+0x3c/0x80 pci_epc_epf_link+0xa8/0xcc configfs_symlink+0x1a4/0x48c vfs_symlink+0x104/0x184 do_symlinkat+0x80/0xd4 __arm64_sys_symlinkat+0x1c/0x24 el0_svc_common.constprop.3+0xb8/0x170 el0_svc_handler+0x70/0x88 el0_svc+0x8/0x640 Code: d2800581 b9403ab9 f9404ebb 8b394f60 (f9400400) ---[ end trace a438e3c5a24f9df0 ]---
- https://git.kernel.org/stable/c/0169d4f0bee44fdfef908c13ed21fcb326c38695
- https://git.kernel.org/stable/c/6613bc2301ba291a1c5a90e1dc24cf3edf223c03
- https://git.kernel.org/stable/c/679ebad058b8168f10e63876d63b0877fd2fe784
- https://git.kernel.org/stable/c/bbed83d7060e07a5d309104d25a00f0a24441428
- https://git.kernel.org/stable/c/0169d4f0bee44fdfef908c13ed21fcb326c38695
- https://git.kernel.org/stable/c/6613bc2301ba291a1c5a90e1dc24cf3edf223c03
- https://git.kernel.org/stable/c/679ebad058b8168f10e63876d63b0877fd2fe784
- https://git.kernel.org/stable/c/bbed83d7060e07a5d309104d25a00f0a24441428
Modified: 2025-03-19
CVE-2021-47006
In the Linux kernel, the following vulnerability has been resolved: ARM: 9064/1: hw_breakpoint: Do not directly check the event's overflow_handler hook The commit 1879445dfa7b ("perf/core: Set event's default ::overflow_handler()") set a default event->overflow_handler in perf_event_alloc(), and replace the check event->overflow_handler with is_default_overflow_handler(), but one is missing. Currently, the bp->overflow_handler can not be NULL. As a result, enable_single_step() is always not invoked. Comments from Zhen Lei: https://patchwork.kernel.org/project/linux-arm-kernel/patch/20210207105934.2001-1-thunder.leizhen@huawei.com/
- https://git.kernel.org/stable/c/3ed8832aeaa9a37b0fc386bb72ff604352567c80
- https://git.kernel.org/stable/c/555a70f7fff03bd669123487905c47ae27dbdaac
- https://git.kernel.org/stable/c/630146203108bf6b8934eec0dfdb3e46dcb917de
- https://git.kernel.org/stable/c/7eeacc6728c5478e3c01bc82a1f08958eaa12366
- https://git.kernel.org/stable/c/a506bd5756290821a4314f502b4bafc2afcf5260
- https://git.kernel.org/stable/c/a9938d6d78a238d6ab8de57a4d3dcf77adceb9bb
- https://git.kernel.org/stable/c/dabe299425b1a53a69461fed7ac8922ea6733a25
- https://git.kernel.org/stable/c/ed1f67465327cec4457bb988775245b199da86e6
- https://git.kernel.org/stable/c/3ed8832aeaa9a37b0fc386bb72ff604352567c80
- https://git.kernel.org/stable/c/555a70f7fff03bd669123487905c47ae27dbdaac
- https://git.kernel.org/stable/c/630146203108bf6b8934eec0dfdb3e46dcb917de
- https://git.kernel.org/stable/c/7eeacc6728c5478e3c01bc82a1f08958eaa12366
- https://git.kernel.org/stable/c/a506bd5756290821a4314f502b4bafc2afcf5260
- https://git.kernel.org/stable/c/a9938d6d78a238d6ab8de57a4d3dcf77adceb9bb
- https://git.kernel.org/stable/c/dabe299425b1a53a69461fed7ac8922ea6733a25
- https://git.kernel.org/stable/c/ed1f67465327cec4457bb988775245b199da86e6
Modified: 2025-01-08
CVE-2021-47007
In the Linux kernel, the following vulnerability has been resolved: f2fs: fix panic during f2fs_resize_fs() f2fs_resize_fs() hangs in below callstack with testcase: - mkfs 16GB image & mount image - dd 8GB fileA - dd 8GB fileB - sync - rm fileA - sync - resize filesystem to 8GB kernel BUG at segment.c:2484! Call Trace: allocate_segment_by_default+0x92/0xf0 [f2fs] f2fs_allocate_data_block+0x44b/0x7e0 [f2fs] do_write_page+0x5a/0x110 [f2fs] f2fs_outplace_write_data+0x55/0x100 [f2fs] f2fs_do_write_data_page+0x392/0x850 [f2fs] move_data_page+0x233/0x320 [f2fs] do_garbage_collect+0x14d9/0x1660 [f2fs] free_segment_range+0x1f7/0x310 [f2fs] f2fs_resize_fs+0x118/0x330 [f2fs] __f2fs_ioctl+0x487/0x3680 [f2fs] __x64_sys_ioctl+0x8e/0xd0 do_syscall_64+0x33/0x80 entry_SYSCALL_64_after_hwframe+0x44/0xa9 The root cause is we forgot to check that whether we have enough space in resized filesystem to store all valid blocks in before-resizing filesystem, then allocator will run out-of-space during block migration in free_segment_range().
- https://git.kernel.org/stable/c/1c20a4896409f5ca1c770e1880c33d0a28a8b10f
- https://git.kernel.org/stable/c/3ab0598e6d860ef49d029943ba80f627c15c15d6
- https://git.kernel.org/stable/c/822054e5026c43b1dd60cf387dd999e95ee2ecc2
- https://git.kernel.org/stable/c/860afd680d9cc1dabd61cda3cd246f60aa1eb705
- https://git.kernel.org/stable/c/1c20a4896409f5ca1c770e1880c33d0a28a8b10f
- https://git.kernel.org/stable/c/3ab0598e6d860ef49d029943ba80f627c15c15d6
- https://git.kernel.org/stable/c/822054e5026c43b1dd60cf387dd999e95ee2ecc2
- https://git.kernel.org/stable/c/860afd680d9cc1dabd61cda3cd246f60aa1eb705
Modified: 2024-12-09
CVE-2021-47009
In the Linux kernel, the following vulnerability has been resolved: KEYS: trusted: Fix memory leak on object td Two error return paths are neglecting to free allocated object td, causing a memory leak. Fix this by returning via the error return path that securely kfree's td. Fixes clang scan-build warning: security/keys/trusted-keys/trusted_tpm1.c:496:10: warning: Potential memory leak [unix.Malloc]
- https://git.kernel.org/stable/c/1c4031014106aff48e1e686e40101c31eab5d44c
- https://git.kernel.org/stable/c/31c9a4b24d86cbb36ff0d7a085725a3b4f0138c8
- https://git.kernel.org/stable/c/3e24fbd37e72e8a67b74991970fecc82d14f57af
- https://git.kernel.org/stable/c/83a775d5f9bfda95b1c295f95a3a041a40c7f321
- https://git.kernel.org/stable/c/1c4031014106aff48e1e686e40101c31eab5d44c
- https://git.kernel.org/stable/c/31c9a4b24d86cbb36ff0d7a085725a3b4f0138c8
- https://git.kernel.org/stable/c/3e24fbd37e72e8a67b74991970fecc82d14f57af
- https://git.kernel.org/stable/c/83a775d5f9bfda95b1c295f95a3a041a40c7f321
Modified: 2025-01-09
CVE-2021-47069
In the Linux kernel, the following vulnerability has been resolved: ipc/mqueue, msg, sem: avoid relying on a stack reference past its expiry do_mq_timedreceive calls wq_sleep with a stack local address. The sender (do_mq_timedsend) uses this address to later call pipelined_send. This leads to a very hard to trigger race where a do_mq_timedreceive call might return and leave do_mq_timedsend to rely on an invalid address, causing the following crash: RIP: 0010:wake_q_add_safe+0x13/0x60 Call Trace: __x64_sys_mq_timedsend+0x2a9/0x490 do_syscall_64+0x80/0x680 entry_SYSCALL_64_after_hwframe+0x44/0xa9 RIP: 0033:0x7f5928e40343 The race occurs as: 1. do_mq_timedreceive calls wq_sleep with the address of `struct ext_wait_queue` on function stack (aliased as `ewq_addr` here) - it holds a valid `struct ext_wait_queue *` as long as the stack has not been overwritten. 2. `ewq_addr` gets added to info->e_wait_q[RECV].list in wq_add, and do_mq_timedsend receives it via wq_get_first_waiter(info, RECV) to call __pipelined_op. 3. Sender calls __pipelined_op::smp_store_release(&this->state, STATE_READY). Here is where the race window begins. (`this` is `ewq_addr`.) 4. If the receiver wakes up now in do_mq_timedreceive::wq_sleep, it will see `state == STATE_READY` and break. 5. do_mq_timedreceive returns, and `ewq_addr` is no longer guaranteed to be a `struct ext_wait_queue *` since it was on do_mq_timedreceive's stack. (Although the address may not get overwritten until another function happens to touch it, which means it can persist around for an indefinite time.) 6. do_mq_timedsend::__pipelined_op() still believes `ewq_addr` is a `struct ext_wait_queue *`, and uses it to find a task_struct to pass to the wake_q_add_safe call. In the lucky case where nothing has overwritten `ewq_addr` yet, `ewq_addr->task` is the right task_struct. In the unlucky case, __pipelined_op::wake_q_add_safe gets handed a bogus address as the receiver's task_struct causing the crash. do_mq_timedsend::__pipelined_op() should not dereference `this` after setting STATE_READY, as the receiver counterpart is now free to return. Change __pipelined_op to call wake_q_add_safe on the receiver's task_struct returned by get_task_struct, instead of dereferencing `this` which sits on the receiver's stack. As Manfred pointed out, the race potentially also exists in ipc/msg.c::expunge_all and ipc/sem.c::wake_up_sem_queue_prepare. Fix those in the same way.
- https://git.kernel.org/stable/c/4528c0c323085e645b8765913b4a7fd42cf49b65
- https://git.kernel.org/stable/c/807fa14536b26803b858da878b643be72952a097
- https://git.kernel.org/stable/c/a11ddb37bf367e6b5239b95ca759e5389bb46048
- https://git.kernel.org/stable/c/4528c0c323085e645b8765913b4a7fd42cf49b65
- https://git.kernel.org/stable/c/807fa14536b26803b858da878b643be72952a097
- https://git.kernel.org/stable/c/a11ddb37bf367e6b5239b95ca759e5389bb46048
Modified: 2024-12-12
CVE-2021-47071
In the Linux kernel, the following vulnerability has been resolved: uio_hv_generic: Fix a memory leak in error handling paths If 'vmbus_establish_gpadl()' fails, the (recv|send)_gpadl will not be updated and 'hv_uio_cleanup()' in the error handling path will not be able to free the corresponding buffer. In such a case, we need to free the buffer explicitly.
- https://git.kernel.org/stable/c/3ee098f96b8b6c1a98f7f97915f8873164e6af9d
- https://git.kernel.org/stable/c/53486c467e356e06aa37047c984fccd64d78c827
- https://git.kernel.org/stable/c/cdd91637d4ef33e2be19a8e16e72e7d00c996d76
- https://git.kernel.org/stable/c/d84b5e912212b05f6b5bde9f682046accfbe0354
- https://git.kernel.org/stable/c/3ee098f96b8b6c1a98f7f97915f8873164e6af9d
- https://git.kernel.org/stable/c/53486c467e356e06aa37047c984fccd64d78c827
- https://git.kernel.org/stable/c/cdd91637d4ef33e2be19a8e16e72e7d00c996d76
- https://git.kernel.org/stable/c/d84b5e912212b05f6b5bde9f682046accfbe0354
Modified: 2025-01-09
CVE-2021-47073
In the Linux kernel, the following vulnerability has been resolved: platform/x86: dell-smbios-wmi: Fix oops on rmmod dell_smbios init_dell_smbios_wmi() only registers the dell_smbios_wmi_driver on systems where the Dell WMI interface is supported. While exit_dell_smbios_wmi() unregisters it unconditionally, this leads to the following oops: [ 175.722921] ------------[ cut here ]------------ [ 175.722925] Unexpected driver unregister! [ 175.722939] WARNING: CPU: 1 PID: 3630 at drivers/base/driver.c:194 driver_unregister+0x38/0x40 ... [ 175.723089] Call Trace: [ 175.723094] cleanup_module+0x5/0xedd [dell_smbios] ... [ 175.723148] ---[ end trace 064c34e1ad49509d ]--- Make the unregister happen on the same condition the register happens to fix this.
- https://git.kernel.org/stable/c/0cf036a0d325200e6c27b90908e51195bbc557b1
- https://git.kernel.org/stable/c/3a53587423d25c87af4b4126a806a0575104b45e
- https://git.kernel.org/stable/c/6fa78a6b9a3beb676a010dc489c1257f7e432525
- https://git.kernel.org/stable/c/75cfc833da4a2111106d4c134e93e0c7f41e35e7
- https://git.kernel.org/stable/c/8d746ea7c687bab060a2c05a35c449302406cd52
- https://git.kernel.org/stable/c/0cf036a0d325200e6c27b90908e51195bbc557b1
- https://git.kernel.org/stable/c/3a53587423d25c87af4b4126a806a0575104b45e
- https://git.kernel.org/stable/c/6fa78a6b9a3beb676a010dc489c1257f7e432525
- https://git.kernel.org/stable/c/75cfc833da4a2111106d4c134e93e0c7f41e35e7
- https://git.kernel.org/stable/c/8d746ea7c687bab060a2c05a35c449302406cd52
Modified: 2024-12-12
CVE-2021-47074
In the Linux kernel, the following vulnerability has been resolved: nvme-loop: fix memory leak in nvme_loop_create_ctrl() When creating loop ctrl in nvme_loop_create_ctrl(), if nvme_init_ctrl() fails, the loop ctrl should be freed before jumping to the "out" label.
- https://git.kernel.org/stable/c/03504e3b54cc8118cc26c064e60a0b00c2308708
- https://git.kernel.org/stable/c/551ba08d4b7eb26f75758cdb9f15105b276517ad
- https://git.kernel.org/stable/c/9c980795ccd77e8abec33dd6fe28dfe1c4083e65
- https://git.kernel.org/stable/c/03504e3b54cc8118cc26c064e60a0b00c2308708
- https://git.kernel.org/stable/c/551ba08d4b7eb26f75758cdb9f15105b276517ad
- https://git.kernel.org/stable/c/9c980795ccd77e8abec33dd6fe28dfe1c4083e65
Modified: 2025-03-19
CVE-2021-47075
In the Linux kernel, the following vulnerability has been resolved: nvmet: fix memory leak in nvmet_alloc_ctrl() When creating ctrl in nvmet_alloc_ctrl(), if the cntlid_min is larger than cntlid_max of the subsystem, and jumps to the "out_free_changed_ns_list" label, but the ctrl->sqs lack of be freed. Fix this by jumping to the "out_free_sqs" label.
- https://git.kernel.org/stable/c/4720f29acb3fe67aa8aa71e6b675b079d193aaeb
- https://git.kernel.org/stable/c/afb680ed7ecbb7fd66ddb43650e9b533fd8b4b9a
- https://git.kernel.org/stable/c/fec356a61aa3d3a66416b4321f1279e09e0f256f
- https://git.kernel.org/stable/c/4720f29acb3fe67aa8aa71e6b675b079d193aaeb
- https://git.kernel.org/stable/c/afb680ed7ecbb7fd66ddb43650e9b533fd8b4b9a
- https://git.kernel.org/stable/c/fec356a61aa3d3a66416b4321f1279e09e0f256f
Modified: 2024-12-10
CVE-2021-47077
In the Linux kernel, the following vulnerability has been resolved:
scsi: qedf: Add pointer checks in qedf_update_link_speed()
The following trace was observed:
[ 14.042059] Call Trace:
[ 14.042061]
- https://git.kernel.org/stable/c/11014efcec378bb0050a6cf08eaf375e3693400a
- https://git.kernel.org/stable/c/73578af92a0fae6609b955fcc9113e50e413c80f
- https://git.kernel.org/stable/c/a6362a737572f66051deb7637f3f77ddf7a4402f
- https://git.kernel.org/stable/c/11014efcec378bb0050a6cf08eaf375e3693400a
- https://git.kernel.org/stable/c/73578af92a0fae6609b955fcc9113e50e413c80f
- https://git.kernel.org/stable/c/a6362a737572f66051deb7637f3f77ddf7a4402f
Modified: 2025-03-19
CVE-2021-47078
In the Linux kernel, the following vulnerability has been resolved: RDMA/rxe: Clear all QP fields if creation failed rxe_qp_do_cleanup() relies on valid pointer values in QP for the properly created ones, but in case rxe_qp_from_init() failed it was filled with garbage and caused tot the following error. refcount_t: underflow; use-after-free. WARNING: CPU: 1 PID: 12560 at lib/refcount.c:28 refcount_warn_saturate+0x1d1/0x1e0 lib/refcount.c:28 Modules linked in: CPU: 1 PID: 12560 Comm: syz-executor.4 Not tainted 5.12.0-syzkaller #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 RIP: 0010:refcount_warn_saturate+0x1d1/0x1e0 lib/refcount.c:28 Code: e9 db fe ff ff 48 89 df e8 2c c2 ea fd e9 8a fe ff ff e8 72 6a a7 fd 48 c7 c7 e0 b2 c1 89 c6 05 dc 3a e6 09 01 e8 ee 74 fb 04 <0f> 0b e9 af fe ff ff 0f 1f 84 00 00 00 00 00 41 56 41 55 41 54 55 RSP: 0018:ffffc900097ceba8 EFLAGS: 00010286 RAX: 0000000000000000 RBX: 0000000000000000 RCX: 0000000000000000 RDX: 0000000000040000 RSI: ffffffff815bb075 RDI: fffff520012f9d67 RBP: 0000000000000003 R08: 0000000000000000 R09: 0000000000000000 R10: ffffffff815b4eae R11: 0000000000000000 R12: ffff8880322a4800 R13: ffff8880322a4940 R14: ffff888033044e00 R15: 0000000000000000 FS: 00007f6eb2be3700(0000) GS:ffff8880b9d00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007fdbe5d41000 CR3: 000000001d181000 CR4: 00000000001506e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: __refcount_sub_and_test include/linux/refcount.h:283 [inline] __refcount_dec_and_test include/linux/refcount.h:315 [inline] refcount_dec_and_test include/linux/refcount.h:333 [inline] kref_put include/linux/kref.h:64 [inline] rxe_qp_do_cleanup+0x96f/0xaf0 drivers/infiniband/sw/rxe/rxe_qp.c:805 execute_in_process_context+0x37/0x150 kernel/workqueue.c:3327 rxe_elem_release+0x9f/0x180 drivers/infiniband/sw/rxe/rxe_pool.c:391 kref_put include/linux/kref.h:65 [inline] rxe_create_qp+0x2cd/0x310 drivers/infiniband/sw/rxe/rxe_verbs.c:425 _ib_create_qp drivers/infiniband/core/core_priv.h:331 [inline] ib_create_named_qp+0x2ad/0x1370 drivers/infiniband/core/verbs.c:1231 ib_create_qp include/rdma/ib_verbs.h:3644 [inline] create_mad_qp+0x177/0x2d0 drivers/infiniband/core/mad.c:2920 ib_mad_port_open drivers/infiniband/core/mad.c:3001 [inline] ib_mad_init_device+0xd6f/0x1400 drivers/infiniband/core/mad.c:3092 add_client_context+0x405/0x5e0 drivers/infiniband/core/device.c:717 enable_device_and_get+0x1cd/0x3b0 drivers/infiniband/core/device.c:1331 ib_register_device drivers/infiniband/core/device.c:1413 [inline] ib_register_device+0x7c7/0xa50 drivers/infiniband/core/device.c:1365 rxe_register_device+0x3d5/0x4a0 drivers/infiniband/sw/rxe/rxe_verbs.c:1147 rxe_add+0x12fe/0x16d0 drivers/infiniband/sw/rxe/rxe.c:247 rxe_net_add+0x8c/0xe0 drivers/infiniband/sw/rxe/rxe_net.c:503 rxe_newlink drivers/infiniband/sw/rxe/rxe.c:269 [inline] rxe_newlink+0xb7/0xe0 drivers/infiniband/sw/rxe/rxe.c:250 nldev_newlink+0x30e/0x550 drivers/infiniband/core/nldev.c:1555 rdma_nl_rcv_msg+0x36d/0x690 drivers/infiniband/core/netlink.c:195 rdma_nl_rcv_skb drivers/infiniband/core/netlink.c:239 [inline] rdma_nl_rcv+0x2ee/0x430 drivers/infiniband/core/netlink.c:259 netlink_unicast_kernel net/netlink/af_netlink.c:1312 [inline] netlink_unicast+0x533/0x7d0 net/netlink/af_netlink.c:1338 netlink_sendmsg+0x856/0xd90 net/netlink/af_netlink.c:1927 sock_sendmsg_nosec net/socket.c:654 [inline] sock_sendmsg+0xcf/0x120 net/socket.c:674 ____sys_sendmsg+0x6e8/0x810 net/socket.c:2350 ___sys_sendmsg+0xf3/0x170 net/socket.c:2404 __sys_sendmsg+0xe5/0x1b0 net/socket.c:2433 do_syscall_64+0x3a/0xb0 arch/x86/entry/common.c:47 entry_SYSCALL_64_after_hwframe+0 ---truncated---
- https://git.kernel.org/stable/c/03344e843ab6dd3b3f2cadfb65ed910590856c70
- https://git.kernel.org/stable/c/2ee4d79c364914989c80de382c0b1a7259a7e4b3
- https://git.kernel.org/stable/c/67f29896fdc83298eed5a6576ff8f9873f709228
- https://git.kernel.org/stable/c/6a8086a42dfbf548a42bf2ae4faa291645c72c66
- https://git.kernel.org/stable/c/a62225d951d77eb20208fed8fc199e0c9b1df08b
- https://git.kernel.org/stable/c/c65391dd9f0a47617e96e38bd27e277cbe1c40b0
- https://git.kernel.org/stable/c/f3783c415bf6d2ead3d7aa2c38802bbe10723646
- https://git.kernel.org/stable/c/03344e843ab6dd3b3f2cadfb65ed910590856c70
- https://git.kernel.org/stable/c/2ee4d79c364914989c80de382c0b1a7259a7e4b3
- https://git.kernel.org/stable/c/67f29896fdc83298eed5a6576ff8f9873f709228
- https://git.kernel.org/stable/c/6a8086a42dfbf548a42bf2ae4faa291645c72c66
- https://git.kernel.org/stable/c/a62225d951d77eb20208fed8fc199e0c9b1df08b
- https://git.kernel.org/stable/c/c65391dd9f0a47617e96e38bd27e277cbe1c40b0
- https://git.kernel.org/stable/c/f3783c415bf6d2ead3d7aa2c38802bbe10723646
Modified: 2024-12-09
CVE-2021-47080
In the Linux kernel, the following vulnerability has been resolved: RDMA/core: Prevent divide-by-zero error triggered by the user The user_entry_size is supplied by the user and later used as a denominator to calculate number of entries. The zero supplied by the user will trigger the following divide-by-zero error: divide error: 0000 [#1] SMP KASAN PTI CPU: 4 PID: 497 Comm: c_repro Not tainted 5.13.0-rc1+ #281 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 RIP: 0010:ib_uverbs_handler_UVERBS_METHOD_QUERY_GID_TABLE+0x1b1/0x510 Code: 87 59 03 00 00 e8 9f ab 1e ff 48 8d bd a8 00 00 00 e8 d3 70 41 ff 44 0f b7 b5 a8 00 00 00 e8 86 ab 1e ff 31 d2 4c 89 f0 31 ff <49> f7 f5 48 89 d6 48 89 54 24 10 48 89 04 24 e8 1b ad 1e ff 48 8b RSP: 0018:ffff88810416f828 EFLAGS: 00010246 RAX: 0000000000000008 RBX: 1ffff1102082df09 RCX: ffffffff82183f3d RDX: 0000000000000000 RSI: ffff888105f2da00 RDI: 0000000000000000 RBP: ffff88810416fa98 R08: 0000000000000001 R09: ffffed102082df5f R10: ffff88810416faf7 R11: ffffed102082df5e R12: 0000000000000000 R13: 0000000000000000 R14: 0000000000000008 R15: ffff88810416faf0 FS: 00007f5715efa740(0000) GS:ffff88811a700000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000020000840 CR3: 000000010c2e0001 CR4: 0000000000370ea0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: ? ib_uverbs_handler_UVERBS_METHOD_INFO_HANDLES+0x4b0/0x4b0 ib_uverbs_cmd_verbs+0x1546/0x1940 ib_uverbs_ioctl+0x186/0x240 __x64_sys_ioctl+0x38a/0x1220 do_syscall_64+0x3f/0x80 entry_SYSCALL_64_after_hwframe+0x44/0xae
- https://git.kernel.org/stable/c/54d87913f147a983589923c7f651f97de9af5be1
- https://git.kernel.org/stable/c/66ab7fcdac34b890017f04f391507ef5b2b89a13
- https://git.kernel.org/stable/c/e6871b4270c05f8b212e7d98aee82b357972c80a
- https://git.kernel.org/stable/c/54d87913f147a983589923c7f651f97de9af5be1
- https://git.kernel.org/stable/c/66ab7fcdac34b890017f04f391507ef5b2b89a13
- https://git.kernel.org/stable/c/e6871b4270c05f8b212e7d98aee82b357972c80a
