[rocky8_10] History rebuild for kernel-4.18.0-553.72.1.el8_10

Makefile.rhelver

@@ -12,7 +12,7 @@ RHEL_MINOR = 10
 #
 # Use this spot to avoid future merge conflicts.
 # Do not trim this comment.
-RHEL_RELEASE = 553.69.1
+RHEL_RELEASE = 553.72.1
 
 #
 # ZSTREAM

arch/s390/pci/pci_event.c

@@ -98,6 +98,10 @@ static pci_ers_result_t zpci_event_do_error_state_clear(struct pci_dev *pdev,
 	struct zpci_dev *zdev = to_zpci(pdev);
 	int rc;
 
+	/* The underlying device may have been disabled by the event */
+	if (!zdev_enabled(zdev))
+		return PCI_ERS_RESULT_NEED_RESET;
+
 	pr_info("%s: Unblocking device access for examination\n", pci_name(pdev));
 	rc = zpci_reset_load_store_blocked(zdev);
 	if (rc) {
@@ -253,6 +257,8 @@ static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
 	struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
 	struct pci_dev *pdev = NULL;
 	pci_ers_result_t ers_res;
+	u32 fh = 0;
+	int rc;
 
 	zpci_dbg(3, "err fid:%x, fh:%x, pec:%x\n",
 		 ccdf->fid, ccdf->fh, ccdf->pec);
@@ -261,6 +267,15 @@ static void __zpci_event_error(struct zpci_ccdf_err *ccdf)
 
 	if (zdev) {
 		mutex_lock(&zdev->state_lock);
+		rc = clp_refresh_fh(zdev->fid, &fh);
+		if (rc)
+			goto no_pdev;
+		if (!fh || ccdf->fh != fh) {
+			/* Ignore events with stale handles */
+			zpci_dbg(3, "err fid:%x, fh:%x (stale %x)\n",
+				 ccdf->fid, fh, ccdf->fh);
+			goto no_pdev;
+		}
 		zpci_update_fh(zdev, ccdf->fh);
 		if (zdev->zbus->bus)
 			pdev = pci_get_slot(zdev->zbus->bus, zdev->devfn);

arch/x86/boot/compressed/eboot.c

@@ -10,6 +10,7 @@
 
 #include <linux/efi.h>
 #include <linux/pci.h>
+#include <linux/ctype.h>
 
 #include <asm/efi.h>
 #include <asm/e820/types.h>
@@ -863,6 +864,26 @@ static void error(char *str)
 	efi_printk(sys_table, "\n");
 }
 
+static const char *cmdline_memmap_override;
+
+static efi_status_t parse_options(const char *cmdline)
+{
+	static const char opts[][14] = {
+		"mem=", "memmap=", "efi_fake_mem=", "hugepages="
+	};
+
+	for (int i = 0; i < ARRAY_SIZE(opts); i++) {
+		const char *p = strstr(cmdline, opts[i]);
+
+		if (p == cmdline || (p > cmdline && isspace(p[-1]))) {
+			cmdline_memmap_override = opts[i];
+			break;
+		}
+	}
+
+	return efi_parse_options(cmdline);
+}
+
 static efi_status_t efi_decompress_kernel(unsigned long *kernel_entry)
 {
 	unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
@@ -893,6 +914,10 @@ static efi_status_t efi_decompress_kernel(unsigned long *kernel_entry)
 		if (sys_table->hdr.revision <= EFI_2_00_SYSTEM_TABLE_REVISION &&
 		    !memcmp(efistub_fw_vendor(), ami, sizeof(ami))) {
 			seed[0] = 0;
+		} else if (cmdline_memmap_override) {
+			efi_printk(sys_table,
+				"cmdline memmap override detected on the kernel command line - disabling physical KASLR\n");
+			seed[0] = 0;
 		}
 
 		boot_params_ptr->hdr.loadflags |= KASLR_FLAG;
@@ -942,7 +967,6 @@ void __noreturn efi_main(struct efi_config *c,
 	void *handle;
 	efi_system_table_t *_table;
 	bool is64;
-	unsigned long cmdline_paddr;
 	extern char _bss[], _ebss[];
 
 	/*
@@ -997,9 +1021,22 @@ void __noreturn efi_main(struct efi_config *c,
 	 * case this is the second time we parse the cmdline. This is ok,
 	 * parsing the cmdline multiple times does not have side-effects.
 	 */
-	cmdline_paddr = ((u64)hdr->cmd_line_ptr |
-			 ((u64)boot_params->ext_cmd_line_ptr << 32));
-	efi_parse_options((char *)cmdline_paddr);
+#ifdef CONFIG_CMDLINE_BOOL
+	status = parse_options(CONFIG_CMDLINE);
+	if (status != EFI_SUCCESS) {
+		efi_printk(sys_table, "Failed to parse options\n");
+		goto fail;
+	}
+#endif
+	if (!IS_ENABLED(CONFIG_CMDLINE_OVERRIDE)) {
+		unsigned long cmdline_paddr = ((u64)hdr->cmd_line_ptr |
+					       ((u64)boot_params->ext_cmd_line_ptr << 32));
+		status = parse_options((char *)cmdline_paddr);
+		if (status != EFI_SUCCESS) {
+			efi_printk(sys_table, "Failed to parse options\n");
+			goto fail;
+		}
+	}
 
 	status = efi_decompress_kernel(&kernel_entry);
 	if (status != EFI_SUCCESS) {

block/blk-mq-debugfs.c

@@ -461,7 +461,7 @@ static void blk_mq_debugfs_tags_show(struct seq_file *m,
 	seq_printf(m, "nr_tags=%u\n", tags->nr_tags);
 	seq_printf(m, "nr_reserved_tags=%u\n", tags->nr_reserved_tags);
 	seq_printf(m, "active_queues=%d\n",
-		   atomic_read(&tags->active_queues));
+		   READ_ONCE(tags->active_queues));
 
 	seq_puts(m, "\nbitmap_tags:\n");
 	sbitmap_queue_show(tags->bitmap_tags, m);

block/blk-mq-tag.c

@@ -15,6 +15,21 @@
 #include "blk-mq-sched.h"
 #include "blk-mq-tag.h"
 
+/*
+ * Recalculate wakeup batch when tag is shared by hctx.
+ */
+static void blk_mq_update_wake_batch(struct blk_mq_tags *tags,
+		unsigned int users)
+{
+	if (!users)
+		return;
+
+	sbitmap_queue_recalculate_wake_batch(tags->bitmap_tags,
+			users);
+	sbitmap_queue_recalculate_wake_batch(tags->breserved_tags,
+			users);
+}
+
 /*
  * If a previously inactive queue goes active, bump the active user count.
  * We need to do this before try to allocate driver tag, then even if fail
@@ -23,17 +38,33 @@
  */
 bool __blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
 {
+	unsigned int users;
+	unsigned long flags;
+	struct blk_mq_tags *tags = hctx->tags;
+
 	if (blk_mq_is_sbitmap_shared(hctx->flags)) {
 		struct request_queue *q = hctx->queue;
 		struct blk_mq_tag_set *set = q->tag_set;
 
-		if (!test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags) &&
-		    !test_and_set_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags))
-			atomic_inc(&set->active_queues_shared_sbitmap);
+		if (test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags) ||
+		    test_and_set_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags)) {
+			return true;
+		}
+		spin_lock_irqsave(&set->active_queues_lock, flags);
+		users = set->active_queues_shared_sbitmap + 1;
+		WRITE_ONCE(set->active_queues_shared_sbitmap, users);
+		blk_mq_update_wake_batch(hctx->tags, users);
+		spin_unlock_irqrestore(&set->active_queues_lock, flags);
 	} else {
-		if (!test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state) &&
-		    !test_and_set_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state))
-			atomic_inc(&hctx->tags->active_queues);
+		if (test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state) ||
+		    test_and_set_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state)) {
+			return true;
+		}
+		spin_lock_irqsave(&tags->lock, flags);
+		users = hctx->tags->active_queues + 1;
+		WRITE_ONCE(tags->active_queues, users);
+		blk_mq_update_wake_batch(tags, users);
+		spin_unlock_irqrestore(&tags->lock, flags);
 	}
 
 	return true;
@@ -58,16 +89,25 @@ void __blk_mq_tag_idle(struct blk_mq_hw_ctx *hctx)
 	struct blk_mq_tags *tags = hctx->tags;
 	struct request_queue *q = hctx->queue;
 	struct blk_mq_tag_set *set = q->tag_set;
+	unsigned int users;
 
 	if (blk_mq_is_sbitmap_shared(hctx->flags)) {
 		if (!test_and_clear_bit(QUEUE_FLAG_HCTX_ACTIVE,
 					&q->queue_flags))
 			return;
-		atomic_dec(&set->active_queues_shared_sbitmap);
+		spin_lock_irq(&set->active_queues_lock);
+		users = set->active_queues_shared_sbitmap - 1;
+		WRITE_ONCE(set->active_queues_shared_sbitmap, users);
+		blk_mq_update_wake_batch(tags, users);
+		spin_unlock_irq(&set->active_queues_lock);
 	} else {
 		if (!test_and_clear_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state))
 			return;
-		atomic_dec(&tags->active_queues);
+		spin_lock_irq(&tags->lock);
+		users = tags->active_queues - 1;
+		WRITE_ONCE(tags->active_queues, users);
+		blk_mq_update_wake_batch(tags, users);
+		spin_unlock_irq(&tags->lock);
 	}
 
 	blk_mq_tag_wakeup_all(tags, false);

block/blk-mq-tag.h

@@ -9,7 +9,11 @@ struct blk_mq_tags {
 	unsigned int nr_tags;
 	unsigned int nr_reserved_tags;
 
+#ifdef __GENKSYMS__
 	atomic_t active_queues;
+#else
+	unsigned int active_queues;
+#endif
 
 	struct sbitmap_queue RH_KABI_RENAME(bitmap_tags, __bitmap_tags);
 	struct sbitmap_queue RH_KABI_RENAME(breserved_tags, __breserved_tags);

block/blk-mq.c

@@ -3666,8 +3666,6 @@ int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
 		goto out_free_mq_map;
 
 	if (blk_mq_is_sbitmap_shared(set->flags)) {
-		atomic_set(&set->active_queues_shared_sbitmap, 0);
-
 		if (blk_mq_init_shared_sbitmap(set)) {
 			ret = -ENOMEM;
 			goto out_free_mq_rq_maps;
@@ -3676,6 +3674,7 @@ int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set)
 
 	mutex_init(&set->tag_list_lock);
 	INIT_LIST_HEAD(&set->tag_list);
+	spin_lock_init(&set->active_queues_lock);
 
 	return 0;
 

block/blk-mq.h

@@ -343,11 +343,11 @@ static inline bool hctx_may_queue(struct blk_mq_hw_ctx *hctx,
 
 		if (!test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags))
 			return true;
-		users = atomic_read(&set->active_queues_shared_sbitmap);
+		users = READ_ONCE(set->active_queues_shared_sbitmap);
 	} else {
 		if (!test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state))
 			return true;
-		users = atomic_read(&hctx->tags->active_queues);
+		users = READ_ONCE(hctx->tags->active_queues);
 	}
 
 	if (!users)