CVSS: -EPSS: 0%CPEs: 5EXPL: 0CVE-2024-27035 – f2fs: compress: fix to guarantee persisting compressed blocks by CP
https://notcve.org/view.php?id=CVE-2024-27035
In the Linux kernel, the following vulnerability has been resolved: f2fs: compress: fix to guarantee persisting compressed blocks by CP If data block in compressed cluster is not persisted with metadata during checkpoint, after SPOR, the data may be corrupted, let's guarantee to write compressed page by checkpoint. En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: f2fs: compress: corrección para garantizar la persistencia de los bloques comprimidos por CP. Si el bloque de datos en el clúster comprimido no persiste con los metadatos durante el punto de control, después de SPOR, los datos pueden estar dañados, garanticemos que escribir página comprimida por punto de control. • https://git.kernel.org/stable/c/4c8ff7095bef64fc47e996a938f7d57f9e077da3 https://git.kernel.org/stable/c/e54cce8137258a550b49cae45d09e024821fb28d https://git.kernel.org/stable/c/82704e598d7b33c7e45526e34d3c585426319bed https://git.kernel.org/stable/c/c3311694b9bcced233548574d414c91d39214684 https://git.kernel.org/stable/c/57e8b17d0522c8f4daf0c4d9969b4d7358033532 https://git.kernel.org/stable/c/8a430dd49e9cb021372b0ad91e60aeef9c6ced00 •
CVSS: -EPSS: 0%CPEs: 6EXPL: 0CVE-2024-27034 – f2fs: compress: fix to cover normal cluster write with cp_rwsem
https://notcve.org/view.php?id=CVE-2024-27034
In the Linux kernel, the following vulnerability has been resolved: f2fs: compress: fix to cover normal cluster write with cp_rwsem When we overwrite compressed cluster w/ normal cluster, we should not unlock cp_rwsem during f2fs_write_raw_pages(), otherwise data will be corrupted if partial blocks were persisted before CP & SPOR, due to cluster metadata wasn't updated atomically. En el kernel de Linux, se resolvió la siguiente vulnerabilidad: f2fs: compress: corrección para cubrir la escritura normal del clúster con cp_rwsem Cuando sobrescribimos el clúster comprimido con el clúster normal, no debemos desbloquear cp_rwsem durante f2fs_write_raw_pages(); de lo contrario, los datos se dañarán si Los bloques parciales persistieron antes de CP y SPOR, debido a que los metadatos del clúster no se actualizaron atómicamente. • https://git.kernel.org/stable/c/4c8ff7095bef64fc47e996a938f7d57f9e077da3 https://git.kernel.org/stable/c/7d420eaaa18ec8e2bb4eeab8c65c00492ef6f416 https://git.kernel.org/stable/c/542c8b3c774a480bfd0804291a12f6f2391b0cd1 https://git.kernel.org/stable/c/75abfd61392b1db391bde6d738a30d685b843286 https://git.kernel.org/stable/c/2b1b14d9fc94b8feae20808684c8af28ec80f45b https://git.kernel.org/stable/c/52982edfcefd475cc34af663d5c47c0cddaa5739 https://git.kernel.org/stable/c/fd244524c2cf07b5f4c3fe8abd6a99225c76544b •
CVSS: -EPSS: 0%CPEs: 4EXPL: 0CVE-2024-27033 – f2fs: fix to remove unnecessary f2fs_bug_on() to avoid panic
https://notcve.org/view.php?id=CVE-2024-27033
In the Linux kernel, the following vulnerability has been resolved: f2fs: fix to remove unnecessary f2fs_bug_on() to avoid panic verify_blkaddr() will trigger panic once we inject fault into f2fs_is_valid_blkaddr(), fix to remove this unnecessary f2fs_bug_on(). En el kernel de Linux, se resolvió la siguiente vulnerabilidad: f2fs: solución para eliminar f2fs_bug_on() innecesario para evitar el pánico. verificar_blkaddr() provocará pánico una vez que inyectemos el error en f2fs_is_valid_blkaddr(), solución para eliminar este f2fs_bug_on() innecesario. • https://git.kernel.org/stable/c/18792e64c86dd7e34ba28e4f61faba472b7bf5fc https://git.kernel.org/stable/c/0386408036bfc8b50296d9e544ff91c4d52af2db https://git.kernel.org/stable/c/6633cdc8b2ebefcddcfcdacfd063105e60f39a49 https://git.kernel.org/stable/c/abe98a05e7162f64759bf9111108ebcb11322dec https://git.kernel.org/stable/c/b896e302f79678451a94769ddd9e52e954c64fbb •
CVSS: 6.3EPSS: 0%CPEs: 9EXPL: 0CVE-2024-27032 – f2fs: fix to avoid potential panic during recovery
https://notcve.org/view.php?id=CVE-2024-27032
In the Linux kernel, the following vulnerability has been resolved: f2fs: fix to avoid potential panic during recovery During recovery, if FAULT_BLOCK is on, it is possible that f2fs_reserve_new_block() will return -ENOSPC during recovery, then it may trigger panic. Also, if fault injection rate is 1 and only FAULT_BLOCK fault type is on, it may encounter deadloop in loop of block reservation. Let's change as below to fix these issues: - remove bug_on() to avoid panic. - limit the loop count of block reservation to avoid potential deadloop. En el kernel de Linux, se resolvió la siguiente vulnerabilidad: f2fs: corrección para evitar un posible pánico durante la recuperación. Durante la recuperación, si FAULT_BLOCK está activado, es posible que f2fs_reserve_new_block() devuelva -ENOSPC durante la recuperación, lo que puede provocar pánico. Además, si la tasa de inyección de fallas es 1 y solo el tipo de falla FAULT_BLOCK está activado, es posible que se produzca un bucle muerto en el bucle de reserva de bloque. Cambiemos como se muestra a continuación para solucionar estos problemas: - elimine bug_on() para evitar el pánico. - limitar el número de bucles de reserva de bloques para evitar posibles bucles muertos. • https://git.kernel.org/stable/c/b1020a546779139eec5d930e15ce534c1101b89c https://git.kernel.org/stable/c/2a7b12d4705bc308cf18eae2b69ec8db34881cc3 https://git.kernel.org/stable/c/b29cc6e29b5e6037e1bcd2b2ac67b7d89acd194c https://git.kernel.org/stable/c/956fa1ddc132e028f3b7d4cf17e6bfc8cb36c7fd https://git.kernel.org/stable/c/bc1fb291f36dd1d9d667241d9fe30b835dbb8ee8 https://git.kernel.org/stable/c/9fceaf8182d453639cddb7f4a6877a1e1564de39 https://git.kernel.org/stable/c/80c69f576ff39d6ae8a6e2107da3dc03b533759c https://git.kernel.org/stable/c/b4fb0807a1d60f8642a5fd62bd659cd60 •
CVSS: -EPSS: 0%CPEs: 4EXPL: 0CVE-2024-27031 – NFS: Fix nfs_netfs_issue_read() xarray locking for writeback interrupt
https://notcve.org/view.php?id=CVE-2024-27031
In the Linux kernel, the following vulnerability has been resolved: NFS: Fix nfs_netfs_issue_read() xarray locking for writeback interrupt The loop inside nfs_netfs_issue_read() currently does not disable interrupts while iterating through pages in the xarray to submit for NFS read. This is not safe though since after taking xa_lock, another page in the mapping could be processed for writeback inside an interrupt, and deadlock can occur. The fix is simple and clean if we use xa_for_each_range(), which handles the iteration with RCU while reducing code complexity. The problem is easily reproduced with the following test: mount -o vers=3,fsc 127.0.0.1:/export /mnt/nfs dd if=/dev/zero of=/mnt/nfs/file1.bin bs=4096 count=1 echo 3 > /proc/sys/vm/drop_caches dd if=/mnt/nfs/file1.bin of=/dev/null umount /mnt/nfs On the console with a lockdep-enabled kernel a message similar to the following will be seen: ================================ WARNING: inconsistent lock state 6.7.0-lockdbg+ #10 Not tainted -------------------------------- inconsistent {IN-SOFTIRQ-W} -> {SOFTIRQ-ON-W} usage. test5/1708 [HC0[0]:SC0[0]:HE1:SE1] takes: ffff888127baa598 (&xa->xa_lock#4){+.?.}-{3:3}, at: nfs_netfs_issue_read+0x1b2/0x4b0 [nfs] {IN-SOFTIRQ-W} state was registered at: lock_acquire+0x144/0x380 _raw_spin_lock_irqsave+0x4e/0xa0 __folio_end_writeback+0x17e/0x5c0 folio_end_writeback+0x93/0x1b0 iomap_finish_ioend+0xeb/0x6a0 blk_update_request+0x204/0x7f0 blk_mq_end_request+0x30/0x1c0 blk_complete_reqs+0x7e/0xa0 __do_softirq+0x113/0x544 __irq_exit_rcu+0xfe/0x120 irq_exit_rcu+0xe/0x20 sysvec_call_function_single+0x6f/0x90 asm_sysvec_call_function_single+0x1a/0x20 pv_native_safe_halt+0xf/0x20 default_idle+0x9/0x20 default_idle_call+0x67/0xa0 do_idle+0x2b5/0x300 cpu_startup_entry+0x34/0x40 start_secondary+0x19d/0x1c0 secondary_startup_64_no_verify+0x18f/0x19b irq event stamp: 176891 hardirqs last enabled at (176891): [<ffffffffa67a0be4>] _raw_spin_unlock_irqrestore+0x44/0x60 hardirqs last disabled at (176890): [<ffffffffa67a0899>] _raw_spin_lock_irqsave+0x79/0xa0 softirqs last enabled at (176646): [<ffffffffa515d91e>] __irq_exit_rcu+0xfe/0x120 softirqs last disabled at (176633): [<ffffffffa515d91e>] __irq_exit_rcu+0xfe/0x120 other info that might help us debug this: Possible unsafe locking scenario: CPU0 ---- lock(&xa->xa_lock#4); <Interrupt> lock(&xa->xa_lock#4); *** DEADLOCK *** 2 locks held by test5/1708: #0: ffff888127baa498 (&sb->s_type->i_mutex_key#22){++++}-{4:4}, at: nfs_start_io_read+0x28/0x90 [nfs] #1: ffff888127baa650 (mapping.invalidate_lock#3){.+.+}-{4:4}, at: page_cache_ra_unbounded+0xa4/0x280 stack backtrace: CPU: 6 PID: 1708 Comm: test5 Kdump: loaded Not tainted 6.7.0-lockdbg+ Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.3-1.fc39 04/01/2014 Call Trace: dump_stack_lvl+0x5b/0x90 mark_lock+0xb3f/0xd20 __lock_acquire+0x77b/0x3360 _raw_spin_lock+0x34/0x80 nfs_netfs_issue_read+0x1b2/0x4b0 [nfs] netfs_begin_read+0x77f/0x980 [netfs] nfs_netfs_readahead+0x45/0x60 [nfs] nfs_readahead+0x323/0x5a0 [nfs] read_pages+0xf3/0x5c0 page_cache_ra_unbounded+0x1c8/0x280 filemap_get_pages+0x38c/0xae0 filemap_read+0x206/0x5e0 nfs_file_read+0xb7/0x140 [nfs] vfs_read+0x2a9/0x460 ksys_read+0xb7/0x140 En el kernel de Linux, se ha resuelto la siguiente vulnerabilidad: NFS: corrige el bloqueo de matriz x de nfs_netfs_issue_read() para interrupción de escritura regresiva. El bucle dentro de nfs_netfs_issue_read() actualmente no deshabilita las interrupciones mientras se itera a través de páginas en la matriz x para enviarlas a lectura NFS. • https://git.kernel.org/stable/c/000dbe0bec058cbf2ca9e156e4a5584f5158b0f9 https://git.kernel.org/stable/c/ad27382f8495f8ef6d2c66c413d756bfd13c0598 https://git.kernel.org/stable/c/8df1678c021ffeb20ef8a203bd9413f3ed9b0e9a https://git.kernel.org/stable/c/8a2e5977cecd3cde6a0e3e86b7b914d00240e5dc https://git.kernel.org/stable/c/fd5860ab6341506004219b080aea40213b299d2e •