scsi: lpfc: Remove bg debugfs buffers (9db6c14c) · Commits · 戴 / test

drivers/scsi/lpfc/lpfc.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -1038,8 +1038,6 @@ struct lpfc_hba {
		struct dentry *debug_hbqinfo;
		struct dentry *debug_dumpHostSlim;
		struct dentry *debug_dumpHBASlim;
		struct dentry debug_dumpData; / BlockGuard BPL */
		struct dentry debug_dumpDif; / BlockGuard BPL */
		struct dentry debug_InjErrLBA; / LBA to inject errors at */
		struct dentry debug_InjErrNPortID; / NPortID to inject errors at */
		struct dentry debug_InjErrWWPN; / WWPN to inject errors at */

drivers/scsi/lpfc/lpfc_crtn.h

+0 −10

Original line number	Diff line number	Diff line
		@@ -433,16 +433,6 @@ int lpfc_sli4_get_allocated_extnts(struct lpfc_hba *, uint16_t,
		int lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *, uint16_t,
		uint16_t , uint16_t );

		/* externs BlockGuard */
		extern char *_dump_buf_data;
		extern unsigned long _dump_buf_data_order;
		extern char *_dump_buf_dif;
		extern unsigned long _dump_buf_dif_order;
		extern spinlock_t _dump_buf_lock;
		extern int _dump_buf_done;
		extern spinlock_t pgcnt_lock;
		extern unsigned int pgcnt;

		/* Interface exported by fabric iocb scheduler */
		void lpfc_fabric_abort_nport(struct lpfc_nodelist *);
		void lpfc_fabric_abort_hba(struct lpfc_hba *);

drivers/scsi/lpfc/lpfc_debugfs.c

+0 −134

Original line number	Diff line number	Diff line
		@@ -2162,89 +2162,6 @@ out:
		return rc;
		}

		static int
		lpfc_debugfs_dumpData_open(struct inode inode, struct file file)
		{
		struct lpfc_debug *debug;
		int rc = -ENOMEM;

		if (!_dump_buf_data)
		return -EBUSY;

		debug = kmalloc(sizeof(*debug), GFP_KERNEL);
		if (!debug)
		goto out;

		/* Round to page boundary */
		pr_err("9059 BLKGRD: %s: _dump_buf_data=0x%p\n",
		__func__, _dump_buf_data);
		debug->buffer = _dump_buf_data;
		if (!debug->buffer) {
		kfree(debug);
		goto out;
		}

		debug->len = (1 << _dump_buf_data_order) << PAGE_SHIFT;
		file->private_data = debug;

		rc = 0;
		out:
		return rc;
		}

		static int
		lpfc_debugfs_dumpDif_open(struct inode inode, struct file file)
		{
		struct lpfc_debug *debug;
		int rc = -ENOMEM;

		if (!_dump_buf_dif)
		return -EBUSY;

		debug = kmalloc(sizeof(*debug), GFP_KERNEL);
		if (!debug)
		goto out;

		/* Round to page boundary */
		pr_err("9060 BLKGRD: %s: _dump_buf_dif=x%px file=%pD\n",
		__func__, _dump_buf_dif, file);
		debug->buffer = _dump_buf_dif;
		if (!debug->buffer) {
		kfree(debug);
		goto out;
		}

		debug->len = (1 << _dump_buf_dif_order) << PAGE_SHIFT;
		file->private_data = debug;

		rc = 0;
		out:
		return rc;
		}

		static ssize_t
		lpfc_debugfs_dumpDataDif_write(struct file file, const char __user buf,
		size_t nbytes, loff_t *ppos)
		{
		/*
		* The Data/DIF buffers only save one failing IO
		* The write op is used as a reset mechanism after an IO has
		* already been saved to the next one can be saved
		*/
		spin_lock(&_dump_buf_lock);

		memset((void *)_dump_buf_data, 0,
		((1 << PAGE_SHIFT) << _dump_buf_data_order));
		memset((void *)_dump_buf_dif, 0,
		((1 << PAGE_SHIFT) << _dump_buf_dif_order));

		_dump_buf_done = 0;

		spin_unlock(&_dump_buf_lock);

		return nbytes;
		}

		static ssize_t
		lpfc_debugfs_dif_err_read(struct file file, char __user buf,
		size_t nbytes, loff_t *ppos)
		@@ -2457,17 +2374,6 @@ lpfc_debugfs_release(struct inode inode, struct file file)
		return 0;
		}

		static int
		lpfc_debugfs_dumpDataDif_release(struct inode inode, struct file file)
		{
		struct lpfc_debug *debug = file->private_data;

		debug->buffer = NULL;
		kfree(debug);

		return 0;
		}

		/**
		* lpfc_debugfs_multixripools_write - Clear multi-XRI pools statistics
		* @file: The file pointer to read from.
		@@ -5448,26 +5354,6 @@ static const struct file_operations lpfc_debugfs_op_cpucheck = {
		.release = lpfc_debugfs_release,
		};

		#undef lpfc_debugfs_op_dumpData
		static const struct file_operations lpfc_debugfs_op_dumpData = {
		.owner = THIS_MODULE,
		.open = lpfc_debugfs_dumpData_open,
		.llseek = lpfc_debugfs_lseek,
		.read = lpfc_debugfs_read,
		.write = lpfc_debugfs_dumpDataDif_write,
		.release = lpfc_debugfs_dumpDataDif_release,
		};

		#undef lpfc_debugfs_op_dumpDif
		static const struct file_operations lpfc_debugfs_op_dumpDif = {
		.owner = THIS_MODULE,
		.open = lpfc_debugfs_dumpDif_open,
		.llseek = lpfc_debugfs_lseek,
		.read = lpfc_debugfs_read,
		.write = lpfc_debugfs_dumpDataDif_write,
		.release = lpfc_debugfs_dumpDataDif_release,
		};

		#undef lpfc_debugfs_op_dif_err
		static const struct file_operations lpfc_debugfs_op_dif_err = {
		.owner = THIS_MODULE,
		@@ -5864,20 +5750,6 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
		} else
		phba->debug_dumpHostSlim = NULL;

		/* Setup dumpData */
		snprintf(name, sizeof(name), "dumpData");
		phba->debug_dumpData =
		debugfs_create_file(name, S_IFREG\|S_IRUGO\|S_IWUSR,
		phba->hba_debugfs_root,
		phba, &lpfc_debugfs_op_dumpData);

		/* Setup dumpDif */
		snprintf(name, sizeof(name), "dumpDif");
		phba->debug_dumpDif =
		debugfs_create_file(name, S_IFREG\|S_IRUGO\|S_IWUSR,
		phba->hba_debugfs_root,
		phba, &lpfc_debugfs_op_dumpDif);

		/* Setup DIF Error Injections */
		snprintf(name, sizeof(name), "InjErrLBA");
		phba->debug_InjErrLBA =
		@@ -6255,12 +6127,6 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
		debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */
		phba->debug_dumpHostSlim = NULL;

		debugfs_remove(phba->debug_dumpData); /* dumpData */
		phba->debug_dumpData = NULL;

		debugfs_remove(phba->debug_dumpDif); /* dumpDif */
		phba->debug_dumpDif = NULL;

		debugfs_remove(phba->debug_InjErrLBA); /* InjErrLBA */
		phba->debug_InjErrLBA = NULL;

drivers/scsi/lpfc/lpfc_init.c

+0 −70

Original line number	Diff line number	Diff line
		@@ -66,12 +66,6 @@
		#include "lpfc_version.h"
		#include "lpfc_ids.h"

		char *_dump_buf_data;
		unsigned long _dump_buf_data_order;
		char *_dump_buf_dif;
		unsigned long _dump_buf_dif_order;
		spinlock_t _dump_buf_lock;

		/* Used when mapping IRQ vectors in a driver centric manner */
		static uint32_t lpfc_present_cpu;

		@@ -7617,7 +7611,6 @@ lpfc_setup_bg(struct lpfc_hba phba, struct Scsi_Host shost)
		uint32_t old_mask;
		uint32_t old_guard;

		int pagecnt = 10;
		if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
		"1478 Registering BlockGuard with the "
		@@ -7654,56 +7647,6 @@ lpfc_setup_bg(struct lpfc_hba phba, struct Scsi_Host shost)
		"layer, Bad protection parameters: %d %d\n",
		old_mask, old_guard);
		}

		if (!_dump_buf_data) {
		while (pagecnt) {
		spin_lock_init(&_dump_buf_lock);
		_dump_buf_data =
		(char *) __get_free_pages(GFP_KERNEL, pagecnt);
		if (_dump_buf_data) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9043 BLKGRD: allocated %d pages for "
		"_dump_buf_data at x%px\n",
		(1 << pagecnt), _dump_buf_data);
		_dump_buf_data_order = pagecnt;
		memset(_dump_buf_data, 0,
		((1 << PAGE_SHIFT) << pagecnt));
		break;
		} else
		--pagecnt;
		}
		if (!_dump_buf_data_order)
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9044 BLKGRD: ERROR unable to allocate "
		"memory for hexdump\n");
		} else
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9045 BLKGRD: already allocated _dump_buf_data=x%px"
		"\n", _dump_buf_data);
		if (!_dump_buf_dif) {
		while (pagecnt) {
		_dump_buf_dif =
		(char *) __get_free_pages(GFP_KERNEL, pagecnt);
		if (_dump_buf_dif) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9046 BLKGRD: allocated %d pages for "
		"_dump_buf_dif at x%px\n",
		(1 << pagecnt), _dump_buf_dif);
		_dump_buf_dif_order = pagecnt;
		memset(_dump_buf_dif, 0,
		((1 << PAGE_SHIFT) << pagecnt));
		break;
		} else
		--pagecnt;
		}
		if (!_dump_buf_dif_order)
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9047 BLKGRD: ERROR unable to allocate "
		"memory for hexdump\n");
		} else
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9048 BLKGRD: already allocated _dump_buf_dif=x%px\n",
		_dump_buf_dif);
		}

		/**
		@@ -13511,19 +13454,6 @@ lpfc_exit(void)
		pci_unregister_driver(&lpfc_driver);
		fc_release_transport(lpfc_transport_template);
		fc_release_transport(lpfc_vport_transport_template);
		if (_dump_buf_data) {
		printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for "
		"_dump_buf_data at x%px\n",
		(1L << _dump_buf_data_order), _dump_buf_data);
		free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
		}

		if (_dump_buf_dif) {
		printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for "
		"_dump_buf_dif at x%px\n",
		(1L << _dump_buf_dif_order), _dump_buf_dif);
		free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
		}
		idr_destroy(&lpfc_hba_index);
		}

drivers/scsi/lpfc/lpfc_scsi.c

+0 −79

Original line number	Diff line number	Diff line
		@@ -53,8 +53,6 @@
		#define LPFC_RESET_WAIT 2
		#define LPFC_ABORT_WAIT 2

		int _dump_buf_done = 1;

		static char *dif_op_str[] = {
		"PROT_NORMAL",
		"PROT_READ_INSERT",
		@@ -89,63 +87,6 @@ lpfc_release_scsi_buf_s3(struct lpfc_hba phba, struct lpfc_io_buf psb);
		static int
		lpfc_prot_group_type(struct lpfc_hba phba, struct scsi_cmnd sc);

		static void
		lpfc_debug_save_data(struct lpfc_hba phba, struct scsi_cmnd cmnd)
		{
		void src, dst;
		struct scatterlist *sgde = scsi_sglist(cmnd);

		if (!_dump_buf_data) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
		__func__);
		return;
		}


		if (!sgde) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9051 BLKGRD: ERROR: data scatterlist is null\n");
		return;
		}

		dst = (void *) _dump_buf_data;
		while (sgde) {
		src = sg_virt(sgde);
		memcpy(dst, src, sgde->length);
		dst += sgde->length;
		sgde = sg_next(sgde);
		}
		}

		static void
		lpfc_debug_save_dif(struct lpfc_hba phba, struct scsi_cmnd cmnd)
		{
		void src, dst;
		struct scatterlist *sgde = scsi_prot_sglist(cmnd);

		if (!_dump_buf_dif) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
		__func__);
		return;
		}

		if (!sgde) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
		"9053 BLKGRD: ERROR: prot scatterlist is null\n");
		return;
		}

		dst = _dump_buf_dif;
		while (sgde) {
		src = sg_virt(sgde);
		memcpy(dst, src, sgde->length);
		dst += sgde->length;
		sgde = sg_next(sgde);
		}
		}

		static inline unsigned
		lpfc_cmd_blksize(struct scsi_cmnd *sc)
		{
		@@ -2962,26 +2903,6 @@ lpfc_parse_bg_err(struct lpfc_hba phba, struct lpfc_io_buf lpfc_cmd,
		uint32_t bgstat = bgf->bgstat;
		uint64_t failing_sector = 0;

		spin_lock(&_dump_buf_lock);
		if (!_dump_buf_done) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9070 BLKGRD: Saving"
		" Data for %u blocks to debugfs\n",
		(cmd->cmnd[7] << 8 \| cmd->cmnd[8]));
		lpfc_debug_save_data(phba, cmd);

		/* If we have a prot sgl, save the DIF buffer */
		if (lpfc_prot_group_type(phba, cmd) ==
		LPFC_PG_TYPE_DIF_BUF) {
		lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: "
		"Saving DIF for %u blocks to debugfs\n",
		(cmd->cmnd[7] << 8 \| cmd->cmnd[8]));
		lpfc_debug_save_dif(phba, cmd);
		}

		_dump_buf_done = 1;
		}
		spin_unlock(&_dump_buf_lock);

		if (lpfc_bgs_get_invalid_prof(bgstat)) {
		cmd->result = DID_ERROR << 16;
		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP \| LOG_BG,

Admin message