From e64bc85ffe2988e2945b508dc5972f9c938ead41 Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Fri, 26 Jan 2024 14:32:57 -0800 Subject: [PATCH] 5.4-stable patches added patches: crypto-api-disallow-identical-driver-names.patch ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch parisc-firmware-fix-f-extend-for-pdc-addresses.patch pm-hibernate-enforce-ordering-during-image-compression-decompression.patch rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch --- ...-api-disallow-identical-driver-names.patch | 29 +++ ...e-last-group-to-be-marked-as-trimmed.patch | 86 ++++++++ ...age-fault-dead-lock-on-mmap-ed-hwrng.patch | 117 ++++++++++ ...mware-fix-f-extend-for-pdc-addresses.patch | 41 ++++ ...ring-image-compression-decompression.patch | 202 ++++++++++++++++++ ...ee-driver_override-when-rpmsg_remove.patch | 55 +++++ queue-5.4/series | 6 + 7 files changed, 536 insertions(+) create mode 100644 queue-5.4/crypto-api-disallow-identical-driver-names.patch create mode 100644 queue-5.4/ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch create mode 100644 queue-5.4/hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch create mode 100644 queue-5.4/parisc-firmware-fix-f-extend-for-pdc-addresses.patch create mode 100644 queue-5.4/pm-hibernate-enforce-ordering-during-image-compression-decompression.patch create mode 100644 queue-5.4/rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch diff --git a/queue-5.4/crypto-api-disallow-identical-driver-names.patch b/queue-5.4/crypto-api-disallow-identical-driver-names.patch new file mode 100644 index 00000000000..22d49eee841 --- /dev/null +++ b/queue-5.4/crypto-api-disallow-identical-driver-names.patch @@ -0,0 +1,29 @@ +From 27016f75f5ed47e2d8e0ca75a8ff1f40bc1a5e27 Mon Sep 17 00:00:00 2001 +From: Herbert Xu +Date: Thu, 7 Dec 2023 18:36:57 +0800 +Subject: crypto: api - Disallow identical driver names + +From: Herbert Xu + +commit 27016f75f5ed47e2d8e0ca75a8ff1f40bc1a5e27 upstream. + +Disallow registration of two algorithms with identical driver names. + +Cc: +Reported-by: Ovidiu Panait +Signed-off-by: Herbert Xu +Signed-off-by: Greg Kroah-Hartman +--- + crypto/algapi.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/crypto/algapi.c ++++ b/crypto/algapi.c +@@ -217,6 +217,7 @@ static struct crypto_larval *__crypto_re + } + + if (!strcmp(q->cra_driver_name, alg->cra_name) || ++ !strcmp(q->cra_driver_name, alg->cra_driver_name) || + !strcmp(q->cra_name, alg->cra_driver_name)) + goto err; + } diff --git a/queue-5.4/ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch b/queue-5.4/ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch new file mode 100644 index 00000000000..ea31eb1b04c --- /dev/null +++ b/queue-5.4/ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch @@ -0,0 +1,86 @@ +From 7c784d624819acbeefb0018bac89e632467cca5a Mon Sep 17 00:00:00 2001 +From: Suraj Jitindar Singh +Date: Wed, 13 Dec 2023 16:16:35 +1100 +Subject: ext4: allow for the last group to be marked as trimmed + +From: Suraj Jitindar Singh + +commit 7c784d624819acbeefb0018bac89e632467cca5a upstream. + +The ext4 filesystem tracks the trim status of blocks at the group +level. When an entire group has been trimmed then it is marked as +such and subsequent trim invocations with the same minimum trim size +will not be attempted on that group unless it is marked as able to be +trimmed again such as when a block is freed. + +Currently the last group can't be marked as trimmed due to incorrect +logic in ext4_last_grp_cluster(). ext4_last_grp_cluster() is supposed +to return the zero based index of the last cluster in a group. This is +then used by ext4_try_to_trim_range() to determine if the trim +operation spans the entire group and as such if the trim status of the +group should be recorded. + +ext4_last_grp_cluster() takes a 0 based group index, thus the valid +values for grp are 0..(ext4_get_groups_count - 1). Any group index +less than (ext4_get_groups_count - 1) is not the last group and must +have EXT4_CLUSTERS_PER_GROUP(sb) clusters. For the last group we need +to calculate the number of clusters based on the number of blocks in +the group. Finally subtract 1 from the number of clusters as zero +based indexing is expected. Rearrange the function slightly to make +it clear what we are calculating and returning. + +Reproducer: +// Create file system where the last group has fewer blocks than +// blocks per group +$ mkfs.ext4 -b 4096 -g 8192 /dev/nvme0n1 8191 +$ mount /dev/nvme0n1 /mnt + +Before Patch: +$ fstrim -v /mnt +/mnt: 25.9 MiB (27156480 bytes) trimmed +// Group not marked as trimmed so second invocation still discards blocks +$ fstrim -v /mnt +/mnt: 25.9 MiB (27156480 bytes) trimmed + +After Patch: +fstrim -v /mnt +/mnt: 25.9 MiB (27156480 bytes) trimmed +// Group marked as trimmed so second invocation DOESN'T discard any blocks +fstrim -v /mnt +/mnt: 0 B (0 bytes) trimmed + +Fixes: 45e4ab320c9b ("ext4: move setting of trimmed bit into ext4_try_to_trim_range()") +Cc: # 4.19+ +Signed-off-by: Suraj Jitindar Singh +Reviewed-by: Jan Kara +Link: https://lore.kernel.org/r/20231213051635.37731-1-surajjs@amazon.com +Signed-off-by: Theodore Ts'o +Signed-off-by: Greg Kroah-Hartman +--- + fs/ext4/mballoc.c | 15 ++++++++++----- + 1 file changed, 10 insertions(+), 5 deletions(-) + +--- a/fs/ext4/mballoc.c ++++ b/fs/ext4/mballoc.c +@@ -5195,11 +5195,16 @@ __acquires(bitlock) + static ext4_grpblk_t ext4_last_grp_cluster(struct super_block *sb, + ext4_group_t grp) + { +- if (grp < ext4_get_groups_count(sb)) +- return EXT4_CLUSTERS_PER_GROUP(sb) - 1; +- return (ext4_blocks_count(EXT4_SB(sb)->s_es) - +- ext4_group_first_block_no(sb, grp) - 1) >> +- EXT4_CLUSTER_BITS(sb); ++ unsigned long nr_clusters_in_group; ++ ++ if (grp < (ext4_get_groups_count(sb) - 1)) ++ nr_clusters_in_group = EXT4_CLUSTERS_PER_GROUP(sb); ++ else ++ nr_clusters_in_group = (ext4_blocks_count(EXT4_SB(sb)->s_es) - ++ ext4_group_first_block_no(sb, grp)) ++ >> EXT4_CLUSTER_BITS(sb); ++ ++ return nr_clusters_in_group - 1; + } + + static bool ext4_trim_interrupted(void) diff --git a/queue-5.4/hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch b/queue-5.4/hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch new file mode 100644 index 00000000000..94434cdaf6b --- /dev/null +++ b/queue-5.4/hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch @@ -0,0 +1,117 @@ +From 78aafb3884f6bc6636efcc1760c891c8500b9922 Mon Sep 17 00:00:00 2001 +From: Herbert Xu +Date: Sat, 2 Dec 2023 09:01:54 +0800 +Subject: hwrng: core - Fix page fault dead lock on mmap-ed hwrng + +From: Herbert Xu + +commit 78aafb3884f6bc6636efcc1760c891c8500b9922 upstream. + +There is a dead-lock in the hwrng device read path. This triggers +when the user reads from /dev/hwrng into memory also mmap-ed from +/dev/hwrng. The resulting page fault triggers a recursive read +which then dead-locks. + +Fix this by using a stack buffer when calling copy_to_user. + +Reported-by: Edward Adam Davis +Reported-by: syzbot+c52ab18308964d248092@syzkaller.appspotmail.com +Fixes: 9996508b3353 ("hwrng: core - Replace u32 in driver API with byte array") +Cc: +Signed-off-by: Herbert Xu +Signed-off-by: Greg Kroah-Hartman +--- + drivers/char/hw_random/core.c | 34 +++++++++++++++++++++------------- + 1 file changed, 21 insertions(+), 13 deletions(-) + +--- a/drivers/char/hw_random/core.c ++++ b/drivers/char/hw_random/core.c +@@ -24,10 +24,13 @@ + #include + #include + #include ++#include + #include + + #define RNG_MODULE_NAME "hw_random" + ++#define RNG_BUFFER_SIZE (SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES) ++ + static struct hwrng *current_rng; + /* the current rng has been explicitly chosen by user via sysfs */ + static int cur_rng_set_by_user; +@@ -59,7 +62,7 @@ static inline int rng_get_data(struct hw + + static size_t rng_buffer_size(void) + { +- return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES; ++ return RNG_BUFFER_SIZE; + } + + static void add_early_randomness(struct hwrng *rng) +@@ -202,6 +205,7 @@ static inline int rng_get_data(struct hw + static ssize_t rng_dev_read(struct file *filp, char __user *buf, + size_t size, loff_t *offp) + { ++ u8 buffer[RNG_BUFFER_SIZE]; + ssize_t ret = 0; + int err = 0; + int bytes_read, len; +@@ -229,34 +233,37 @@ static ssize_t rng_dev_read(struct file + if (bytes_read < 0) { + err = bytes_read; + goto out_unlock_reading; ++ } else if (bytes_read == 0 && ++ (filp->f_flags & O_NONBLOCK)) { ++ err = -EAGAIN; ++ goto out_unlock_reading; + } ++ + data_avail = bytes_read; + } + +- if (!data_avail) { +- if (filp->f_flags & O_NONBLOCK) { +- err = -EAGAIN; +- goto out_unlock_reading; +- } +- } else { +- len = data_avail; ++ len = data_avail; ++ if (len) { + if (len > size) + len = size; + + data_avail -= len; + +- if (copy_to_user(buf + ret, rng_buffer + data_avail, +- len)) { ++ memcpy(buffer, rng_buffer + data_avail, len); ++ } ++ mutex_unlock(&reading_mutex); ++ put_rng(rng); ++ ++ if (len) { ++ if (copy_to_user(buf + ret, buffer, len)) { + err = -EFAULT; +- goto out_unlock_reading; ++ goto out; + } + + size -= len; + ret += len; + } + +- mutex_unlock(&reading_mutex); +- put_rng(rng); + + if (need_resched()) + schedule_timeout_interruptible(1); +@@ -267,6 +274,7 @@ static ssize_t rng_dev_read(struct file + } + } + out: ++ memzero_explicit(buffer, sizeof(buffer)); + return ret ? : err; + + out_unlock_reading: diff --git a/queue-5.4/parisc-firmware-fix-f-extend-for-pdc-addresses.patch b/queue-5.4/parisc-firmware-fix-f-extend-for-pdc-addresses.patch new file mode 100644 index 00000000000..4bd70e207d2 --- /dev/null +++ b/queue-5.4/parisc-firmware-fix-f-extend-for-pdc-addresses.patch @@ -0,0 +1,41 @@ +From 735ae74f73e55c191d48689bd11ff4a06ea0508f Mon Sep 17 00:00:00 2001 +From: Helge Deller +Date: Wed, 3 Jan 2024 21:02:16 +0100 +Subject: parisc/firmware: Fix F-extend for PDC addresses + +From: Helge Deller + +commit 735ae74f73e55c191d48689bd11ff4a06ea0508f upstream. + +When running with narrow firmware (64-bit kernel using a 32-bit +firmware), extend PDC addresses into the 0xfffffff0.00000000 +region instead of the 0xf0f0f0f0.00000000 region. + +This fixes the power button on the C3700 machine in qemu (64-bit CPU +with 32-bit firmware), and my assumption is that the previous code was +really never used (because most 64-bit machines have a 64-bit firmware), +or it just worked on very old machines because they may only decode +40-bit of virtual addresses. + +Cc: stable@vger.kernel.org +Signed-off-by: Helge Deller +Signed-off-by: Greg Kroah-Hartman +--- + arch/parisc/kernel/firmware.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/arch/parisc/kernel/firmware.c ++++ b/arch/parisc/kernel/firmware.c +@@ -122,10 +122,10 @@ static unsigned long f_extend(unsigned l + #ifdef CONFIG_64BIT + if(unlikely(parisc_narrow_firmware)) { + if((address & 0xff000000) == 0xf0000000) +- return 0xf0f0f0f000000000UL | (u32)address; ++ return (0xfffffff0UL << 32) | (u32)address; + + if((address & 0xf0000000) == 0xf0000000) +- return 0xffffffff00000000UL | (u32)address; ++ return (0xffffffffUL << 32) | (u32)address; + } + #endif + return address; diff --git a/queue-5.4/pm-hibernate-enforce-ordering-during-image-compression-decompression.patch b/queue-5.4/pm-hibernate-enforce-ordering-during-image-compression-decompression.patch new file mode 100644 index 00000000000..dc45b4b3294 --- /dev/null +++ b/queue-5.4/pm-hibernate-enforce-ordering-during-image-compression-decompression.patch @@ -0,0 +1,202 @@ +From 71cd7e80cfde548959952eac7063aeaea1f2e1c6 Mon Sep 17 00:00:00 2001 +From: Hongchen Zhang +Date: Thu, 16 Nov 2023 08:56:09 +0800 +Subject: PM: hibernate: Enforce ordering during image compression/decompression + +From: Hongchen Zhang + +commit 71cd7e80cfde548959952eac7063aeaea1f2e1c6 upstream. + +An S4 (suspend to disk) test on the LoongArch 3A6000 platform sometimes +fails with the following error messaged in the dmesg log: + + Invalid LZO compressed length + +That happens because when compressing/decompressing the image, the +synchronization between the control thread and the compress/decompress/crc +thread is based on a relaxed ordering interface, which is unreliable, and the +following situation may occur: + +CPU 0 CPU 1 +save_image_lzo lzo_compress_threadfn + atomic_set(&d->stop, 1); + atomic_read(&data[thr].stop) + data[thr].cmp = data[thr].cmp_len; + WRITE data[thr].cmp_len + +Then CPU0 gets a stale cmp_len and writes it to disk. During resume from S4, +wrong cmp_len is loaded. + +To maintain data consistency between the two threads, use the acquire/release +variants of atomic set and read operations. + +Fixes: 081a9d043c98 ("PM / Hibernate: Improve performance of LZO/plain hibernation, checksum image") +Cc: All applicable +Signed-off-by: Hongchen Zhang +Co-developed-by: Weihao Li +Signed-off-by: Weihao Li +[ rjw: Subject rewrite and changelog edits ] +Signed-off-by: Rafael J. Wysocki +Signed-off-by: Greg Kroah-Hartman +--- + kernel/power/swap.c | 38 +++++++++++++++++++------------------- + 1 file changed, 19 insertions(+), 19 deletions(-) + +--- a/kernel/power/swap.c ++++ b/kernel/power/swap.c +@@ -594,11 +594,11 @@ static int crc32_threadfn(void *data) + unsigned i; + + while (1) { +- wait_event(d->go, atomic_read(&d->ready) || ++ wait_event(d->go, atomic_read_acquire(&d->ready) || + kthread_should_stop()); + if (kthread_should_stop()) { + d->thr = NULL; +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + break; + } +@@ -607,7 +607,7 @@ static int crc32_threadfn(void *data) + for (i = 0; i < d->run_threads; i++) + *d->crc32 = crc32_le(*d->crc32, + d->unc[i], *d->unc_len[i]); +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + } + return 0; +@@ -637,12 +637,12 @@ static int lzo_compress_threadfn(void *d + struct cmp_data *d = data; + + while (1) { +- wait_event(d->go, atomic_read(&d->ready) || ++ wait_event(d->go, atomic_read_acquire(&d->ready) || + kthread_should_stop()); + if (kthread_should_stop()) { + d->thr = NULL; + d->ret = -1; +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + break; + } +@@ -651,7 +651,7 @@ static int lzo_compress_threadfn(void *d + d->ret = lzo1x_1_compress(d->unc, d->unc_len, + d->cmp + LZO_HEADER, &d->cmp_len, + d->wrk); +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + } + return 0; +@@ -789,7 +789,7 @@ static int save_image_lzo(struct swap_ma + + data[thr].unc_len = off; + +- atomic_set(&data[thr].ready, 1); ++ atomic_set_release(&data[thr].ready, 1); + wake_up(&data[thr].go); + } + +@@ -797,12 +797,12 @@ static int save_image_lzo(struct swap_ma + break; + + crc->run_threads = thr; +- atomic_set(&crc->ready, 1); ++ atomic_set_release(&crc->ready, 1); + wake_up(&crc->go); + + for (run_threads = thr, thr = 0; thr < run_threads; thr++) { + wait_event(data[thr].done, +- atomic_read(&data[thr].stop)); ++ atomic_read_acquire(&data[thr].stop)); + atomic_set(&data[thr].stop, 0); + + ret = data[thr].ret; +@@ -841,7 +841,7 @@ static int save_image_lzo(struct swap_ma + } + } + +- wait_event(crc->done, atomic_read(&crc->stop)); ++ wait_event(crc->done, atomic_read_acquire(&crc->stop)); + atomic_set(&crc->stop, 0); + } + +@@ -1121,12 +1121,12 @@ static int lzo_decompress_threadfn(void + struct dec_data *d = data; + + while (1) { +- wait_event(d->go, atomic_read(&d->ready) || ++ wait_event(d->go, atomic_read_acquire(&d->ready) || + kthread_should_stop()); + if (kthread_should_stop()) { + d->thr = NULL; + d->ret = -1; +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + break; + } +@@ -1139,7 +1139,7 @@ static int lzo_decompress_threadfn(void + flush_icache_range((unsigned long)d->unc, + (unsigned long)d->unc + d->unc_len); + +- atomic_set(&d->stop, 1); ++ atomic_set_release(&d->stop, 1); + wake_up(&d->done); + } + return 0; +@@ -1327,7 +1327,7 @@ static int load_image_lzo(struct swap_ma + } + + if (crc->run_threads) { +- wait_event(crc->done, atomic_read(&crc->stop)); ++ wait_event(crc->done, atomic_read_acquire(&crc->stop)); + atomic_set(&crc->stop, 0); + crc->run_threads = 0; + } +@@ -1363,7 +1363,7 @@ static int load_image_lzo(struct swap_ma + pg = 0; + } + +- atomic_set(&data[thr].ready, 1); ++ atomic_set_release(&data[thr].ready, 1); + wake_up(&data[thr].go); + } + +@@ -1382,7 +1382,7 @@ static int load_image_lzo(struct swap_ma + + for (run_threads = thr, thr = 0; thr < run_threads; thr++) { + wait_event(data[thr].done, +- atomic_read(&data[thr].stop)); ++ atomic_read_acquire(&data[thr].stop)); + atomic_set(&data[thr].stop, 0); + + ret = data[thr].ret; +@@ -1413,7 +1413,7 @@ static int load_image_lzo(struct swap_ma + ret = snapshot_write_next(snapshot); + if (ret <= 0) { + crc->run_threads = thr + 1; +- atomic_set(&crc->ready, 1); ++ atomic_set_release(&crc->ready, 1); + wake_up(&crc->go); + goto out_finish; + } +@@ -1421,13 +1421,13 @@ static int load_image_lzo(struct swap_ma + } + + crc->run_threads = thr; +- atomic_set(&crc->ready, 1); ++ atomic_set_release(&crc->ready, 1); + wake_up(&crc->go); + } + + out_finish: + if (crc->run_threads) { +- wait_event(crc->done, atomic_read(&crc->stop)); ++ wait_event(crc->done, atomic_read_acquire(&crc->stop)); + atomic_set(&crc->stop, 0); + } + stop = ktime_get(); diff --git a/queue-5.4/rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch b/queue-5.4/rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch new file mode 100644 index 00000000000..d6598819d47 --- /dev/null +++ b/queue-5.4/rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch @@ -0,0 +1,55 @@ +From d5362c37e1f8a40096452fc201c30e705750e687 Mon Sep 17 00:00:00 2001 +From: Xiaolei Wang +Date: Fri, 15 Dec 2023 10:00:49 +0800 +Subject: rpmsg: virtio: Free driver_override when rpmsg_remove() + +From: Xiaolei Wang + +commit d5362c37e1f8a40096452fc201c30e705750e687 upstream. + +Free driver_override when rpmsg_remove(), otherwise +the following memory leak will occur: + +unreferenced object 0xffff0000d55d7080 (size 128): + comm "kworker/u8:2", pid 56, jiffies 4294893188 (age 214.272s) + hex dump (first 32 bytes): + 72 70 6d 73 67 5f 6e 73 00 00 00 00 00 00 00 00 rpmsg_ns........ + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ + backtrace: + [<000000009c94c9c1>] __kmem_cache_alloc_node+0x1f8/0x320 + [<000000002300d89b>] __kmalloc_node_track_caller+0x44/0x70 + [<00000000228a60c3>] kstrndup+0x4c/0x90 + [<0000000077158695>] driver_set_override+0xd0/0x164 + [<000000003e9c4ea5>] rpmsg_register_device_override+0x98/0x170 + [<000000001c0c89a8>] rpmsg_ns_register_device+0x24/0x30 + [<000000008bbf8fa2>] rpmsg_probe+0x2e0/0x3ec + [<00000000e65a68df>] virtio_dev_probe+0x1c0/0x280 + [<00000000443331cc>] really_probe+0xbc/0x2dc + [<00000000391064b1>] __driver_probe_device+0x78/0xe0 + [<00000000a41c9a5b>] driver_probe_device+0xd8/0x160 + [<000000009c3bd5df>] __device_attach_driver+0xb8/0x140 + [<0000000043cd7614>] bus_for_each_drv+0x7c/0xd4 + [<000000003b929a36>] __device_attach+0x9c/0x19c + [<00000000a94e0ba8>] device_initial_probe+0x14/0x20 + [<000000003c999637>] bus_probe_device+0xa0/0xac + +Signed-off-by: Xiaolei Wang +Fixes: b0b03b811963 ("rpmsg: Release rpmsg devices in backends") +Cc: stable@vger.kernel.org +Link: https://lore.kernel.org/r/20231215020049.78750-1-xiaolei.wang@windriver.com +Signed-off-by: Mathieu Poirier +Signed-off-by: Greg Kroah-Hartman +--- + drivers/rpmsg/virtio_rpmsg_bus.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/drivers/rpmsg/virtio_rpmsg_bus.c ++++ b/drivers/rpmsg/virtio_rpmsg_bus.c +@@ -381,6 +381,7 @@ static void virtio_rpmsg_release_device( + struct rpmsg_device *rpdev = to_rpmsg_device(dev); + struct virtio_rpmsg_channel *vch = to_virtio_rpmsg_channel(rpdev); + ++ kfree(rpdev->driver_override); + kfree(vch); + } + diff --git a/queue-5.4/series b/queue-5.4/series index 0de6d36a023..f84003b4e08 100644 --- a/queue-5.4/series +++ b/queue-5.4/series @@ -6,3 +6,9 @@ units-add-the-hz-macros.patch serial-sc16is7xx-set-safe-default-spi-clock-frequenc.patch spi-introduce-spi_mode_x_mask-macro.patch serial-sc16is7xx-add-check-for-unsupported-spi-modes.patch +ext4-allow-for-the-last-group-to-be-marked-as-trimmed.patch +crypto-api-disallow-identical-driver-names.patch +pm-hibernate-enforce-ordering-during-image-compression-decompression.patch +hwrng-core-fix-page-fault-dead-lock-on-mmap-ed-hwrng.patch +rpmsg-virtio-free-driver_override-when-rpmsg_remove.patch +parisc-firmware-fix-f-extend-for-pdc-addresses.patch -- 2.47.3