Merge branch 'fixes' into misc (2441500a) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/scsi/Kconfig

+11 −0

Original line number	Diff line number	Diff line
		@@ -47,6 +47,17 @@ config SCSI_NETLINK
		default n
		depends on NET

		config SCSI_MQ_DEFAULT
		bool "SCSI: use blk-mq I/O path by default"
		depends on SCSI
		---help---
		This option enables the new blk-mq based I/O path for SCSI
		devices by default. With the option the scsi_mod.use_blk_mq
		module/boot option defaults to Y, without it to N, but it can
		still be overridden either way.

		If unsure say N.

		config SCSI_PROC_FS
		bool "legacy /proc/scsi/ support"
		depends on SCSI && PROC_FS

drivers/scsi/aacraid/aachba.c

+32 −38

Original line number	Diff line number	Diff line
		@@ -549,7 +549,9 @@ static void get_container_name_callback(void context, struct fib fibptr)
		if ((le32_to_cpu(get_name_reply->status) == CT_OK)
		&& (get_name_reply->data[0] != '\0')) {
		char *sp = get_name_reply->data;
		sp[sizeof(((struct aac_get_name_resp *)NULL)->data)] = '\0';
		int data_size = FIELD_SIZEOF(struct aac_get_name_resp, data);

		sp[data_size - 1] = '\0';
		while (*sp == ' ')
		++sp;
		if (*sp) {
		@@ -579,21 +581,25 @@ static void get_container_name_callback(void context, struct fib fibptr)
		static int aac_get_container_name(struct scsi_cmnd * scsicmd)
		{
		int status;
		int data_size;
		struct aac_get_name *dinfo;
		struct fib * cmd_fibcontext;
		struct aac_dev * dev;

		dev = (struct aac_dev *)scsicmd->device->host->hostdata;

		data_size = FIELD_SIZEOF(struct aac_get_name_resp, data);

		cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);

		aac_fib_init(cmd_fibcontext);
		dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext);
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		dinfo->command = cpu_to_le32(VM_ContainerConfig);
		dinfo->type = cpu_to_le32(CT_READ_NAME);
		dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
		dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
		dinfo->count = cpu_to_le32(data_size - 1);

		status = aac_fib_send(ContainerCommand,
		cmd_fibcontext,
		@@ -606,10 +612,8 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd)
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status);
		aac_fib_complete(cmd_fibcontext);
		@@ -720,6 +724,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)

		dinfo->count = cpu_to_le32(scmd_id(scsicmd));
		dinfo->type = cpu_to_le32(FT_FILESYS);
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		status = aac_fib_send(ContainerCommand,
		fibptr,
		@@ -731,9 +736,7 @@ static void _aac_probe_container1(void * context, struct fib * fibptr)
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS)
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		else if (status < 0) {
		if (status < 0 && status != -EINPROGRESS) {
		/* Inherit results from VM_NameServe, if any */
		dresp->status = cpu_to_le32(ST_OK);
		_aac_probe_container2(context, fibptr);
		@@ -761,6 +764,7 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
		dinfo->count = cpu_to_le32(scmd_id(scsicmd));
		dinfo->type = cpu_to_le32(FT_FILESYS);
		scsicmd->SCp.ptr = (char *)callback;
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		status = aac_fib_send(ContainerCommand,
		fibptr,
		@@ -772,10 +776,9 @@ static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(stru
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		if (status < 0) {
		scsicmd->SCp.ptr = NULL;
		aac_fib_complete(fibptr);
		@@ -1121,6 +1124,7 @@ static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
		dinfo->command = cpu_to_le32(VM_ContainerConfig);
		dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID);
		dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		status = aac_fib_send(ContainerCommand,
		cmd_fibcontext,
		@@ -1133,10 +1137,8 @@ static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status);
		aac_fib_complete(cmd_fibcontext);
		@@ -2330,16 +2332,14 @@ static int aac_read(struct scsi_cmnd * scsicmd)
		* Alocate and initialize a Fib
		*/
		cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);

		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count);

		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status);
		/*
		@@ -2424,16 +2424,14 @@ static int aac_write(struct scsi_cmnd * scsicmd)
		* Allocate and initialize a Fib then setup a BlockWrite command
		*/
		cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);

		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);

		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status);
		/*
		@@ -2583,6 +2581,7 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd)
		synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd));
		synchronizecmd->count =
		cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		/*
		* Now send the Fib to the adapter
		@@ -2598,10 +2597,8 @@ static int aac_synchronize(struct scsi_cmnd *scsicmd)
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING
		"aac_synchronize: aac_fib_send failed with status: %d.\n", status);
		@@ -2661,6 +2658,7 @@ static int aac_start_stop(struct scsi_cmnd *scsicmd)
		pmcmd->cid = cpu_to_le32(sdev_id(sdev));
		pmcmd->parm = (scsicmd->cmnd[1] & 1) ?
		cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0;
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;

		/*
		* Now send the Fib to the adapter
		@@ -2676,10 +2674,8 @@ static int aac_start_stop(struct scsi_cmnd *scsicmd)
		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		aac_fib_complete(cmd_fibcontext);
		aac_fib_free(cmd_fibcontext);
		@@ -3198,10 +3194,11 @@ static int query_disk(struct aac_dev dev, void __user arg)
		return -EBUSY;
		if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk)))
		return -EFAULT;
		if (qd.cnum == -1)
		if (qd.cnum == -1) {
		if (qd.id < 0 \|\| qd.id >= dev->maximum_num_containers)
		return -EINVAL;
		qd.cnum = qd.id;
		else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1))
		{
		} else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) {
		if (qd.cnum < 0 \|\| qd.cnum >= dev->maximum_num_containers)
		return -EINVAL;
		qd.instance = dev->scsi_host_ptr->host_no;
		@@ -3686,16 +3683,14 @@ static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
		* Allocate and initialize a Fib then setup a BlockWrite command
		*/
		cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);

		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		status = aac_adapter_scsi(cmd_fibcontext, scsicmd);

		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status);
		aac_fib_complete(cmd_fibcontext);
		@@ -3733,15 +3728,14 @@ static int aac_send_hba_fib(struct scsi_cmnd *scsicmd)
		if (!cmd_fibcontext)
		return -1;

		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		status = aac_adapter_hba(cmd_fibcontext, scsicmd);

		/*
		* Check that the command queued to the controller
		*/
		if (status == -EINPROGRESS) {
		scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
		if (status == -EINPROGRESS)
		return 0;
		}

		pr_warn("aac_hba_cmd_req: aac_fib_send failed with status: %d\n",
		status);

drivers/scsi/aacraid/aacraid.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -2275,7 +2275,7 @@ struct aac_get_name_resp {
		__le32 parm3;
		__le32 parm4;
		__le32 parm5;
		u8 data[16];
		u8 data[17];
		};

		#define CT_CID_TO_32BITS_UID 165

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

+15 −53

Original line number	Diff line number	Diff line
		@@ -2624,12 +2624,11 @@ static struct fcoe_transport bnx2fc_transport = {
		};

		/**
		* bnx2fc_percpu_thread_create - Create a receive thread for an
		* online CPU
		* bnx2fc_cpu_online - Create a receive thread for an online CPU
		*
		* @cpu: cpu index for the online cpu
		*/
		static void bnx2fc_percpu_thread_create(unsigned int cpu)
		static int bnx2fc_cpu_online(unsigned int cpu)
		{
		struct bnx2fc_percpu_s *p;
		struct task_struct *thread;
		@@ -2639,15 +2638,17 @@ static void bnx2fc_percpu_thread_create(unsigned int cpu)
		thread = kthread_create_on_node(bnx2fc_percpu_io_thread,
		(void *)p, cpu_to_node(cpu),
		"bnx2fc_thread/%d", cpu);
		if (IS_ERR(thread))
		return PTR_ERR(thread);

		/* bind thread to the cpu */
		if (likely(!IS_ERR(thread))) {
		kthread_bind(thread, cpu);
		p->iothread = thread;
		wake_up_process(thread);
		}
		return 0;
		}

		static void bnx2fc_percpu_thread_destroy(unsigned int cpu)
		static int bnx2fc_cpu_offline(unsigned int cpu)
		{
		struct bnx2fc_percpu_s *p;
		struct task_struct *thread;
		@@ -2661,7 +2662,6 @@ static void bnx2fc_percpu_thread_destroy(unsigned int cpu)
		thread = p->iothread;
		p->iothread = NULL;


		/* Free all work in the list */
		list_for_each_entry_safe(work, tmp, &p->work_list, list) {
		list_del_init(&work->list);
		@@ -2673,20 +2673,6 @@ static void bnx2fc_percpu_thread_destroy(unsigned int cpu)

		if (thread)
		kthread_stop(thread);
		}


		static int bnx2fc_cpu_online(unsigned int cpu)
		{
		printk(PFX "CPU %x online: Create Rx thread\n", cpu);
		bnx2fc_percpu_thread_create(cpu);
		return 0;
		}

		static int bnx2fc_cpu_dead(unsigned int cpu)
		{
		printk(PFX "CPU %x offline: Remove Rx thread\n", cpu);
		bnx2fc_percpu_thread_destroy(cpu);
		return 0;
		}

		@@ -2761,30 +2747,16 @@ static int __init bnx2fc_mod_init(void)
		spin_lock_init(&p->fp_work_lock);
		}

		get_online_cpus();

		for_each_online_cpu(cpu)
		bnx2fc_percpu_thread_create(cpu);

		rc = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
		"scsi/bnx2fc:online",
		bnx2fc_cpu_online, NULL);
		rc = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "scsi/bnx2fc:online",
		bnx2fc_cpu_online, bnx2fc_cpu_offline);
		if (rc < 0)
		goto stop_threads;
		goto stop_thread;
		bnx2fc_online_state = rc;

		cpuhp_setup_state_nocalls(CPUHP_SCSI_BNX2FC_DEAD, "scsi/bnx2fc:dead",
		NULL, bnx2fc_cpu_dead);
		put_online_cpus();

		cnic_register_driver(CNIC_ULP_FCOE, &bnx2fc_cnic_cb);

		return 0;

		stop_threads:
		for_each_online_cpu(cpu)
		bnx2fc_percpu_thread_destroy(cpu);
		put_online_cpus();
		stop_thread:
		kthread_stop(l2_thread);
		free_wq:
		destroy_workqueue(bnx2fc_wq);
		@@ -2803,7 +2775,6 @@ static void __exit bnx2fc_mod_exit(void)
		struct fcoe_percpu_s *bg;
		struct task_struct *l2_thread;
		struct sk_buff *skb;
		unsigned int cpu = 0;

		/*
		* NOTE: Since cnic calls register_driver routine rtnl_lock,
		@@ -2844,16 +2815,7 @@ static void __exit bnx2fc_mod_exit(void)
		if (l2_thread)
		kthread_stop(l2_thread);

		get_online_cpus();
		/* Destroy per cpu threads */
		for_each_online_cpu(cpu) {
		bnx2fc_percpu_thread_destroy(cpu);
		}

		cpuhp_remove_state_nocalls(bnx2fc_online_state);
		cpuhp_remove_state_nocalls(CPUHP_SCSI_BNX2FC_DEAD);

		put_online_cpus();
		cpuhp_remove_state(bnx2fc_online_state);

		destroy_workqueue(bnx2fc_wq);
		/*

drivers/scsi/bnx2fc/bnx2fc_hwi.c

+23 −22

Original line number	Diff line number	Diff line
		@@ -1008,6 +1008,28 @@ static struct bnx2fc_work bnx2fc_alloc_work(struct bnx2fc_rport tgt, u16 wqe)
		return work;
		}

		/* Pending work request completion */
		static void bnx2fc_pending_work(struct bnx2fc_rport *tgt, unsigned int wqe)
		{
		unsigned int cpu = wqe % num_possible_cpus();
		struct bnx2fc_percpu_s *fps;
		struct bnx2fc_work *work;

		fps = &per_cpu(bnx2fc_percpu, cpu);
		spin_lock_bh(&fps->fp_work_lock);
		if (fps->iothread) {
		work = bnx2fc_alloc_work(tgt, wqe);
		if (work) {
		list_add_tail(&work->list, &fps->work_list);
		wake_up_process(fps->iothread);
		spin_unlock_bh(&fps->fp_work_lock);
		return;
		}
		}
		spin_unlock_bh(&fps->fp_work_lock);
		bnx2fc_process_cq_compl(tgt, wqe);
		}

		int bnx2fc_process_new_cqes(struct bnx2fc_rport *tgt)
		{
		struct fcoe_cqe *cq;
		@@ -1042,28 +1064,7 @@ int bnx2fc_process_new_cqes(struct bnx2fc_rport *tgt)
		/* Unsolicited event notification */
		bnx2fc_process_unsol_compl(tgt, wqe);
		} else {
		/* Pending work request completion */
		struct bnx2fc_work *work = NULL;
		struct bnx2fc_percpu_s *fps = NULL;
		unsigned int cpu = wqe % num_possible_cpus();

		fps = &per_cpu(bnx2fc_percpu, cpu);
		spin_lock_bh(&fps->fp_work_lock);
		if (unlikely(!fps->iothread))
		goto unlock;

		work = bnx2fc_alloc_work(tgt, wqe);
		if (work)
		list_add_tail(&work->list,
		&fps->work_list);
		unlock:
		spin_unlock_bh(&fps->fp_work_lock);

		/* Pending work request completion */
		if (fps->iothread && work)
		wake_up_process(fps->iothread);
		else
		bnx2fc_process_cq_compl(tgt, wqe);
		bnx2fc_pending_work(tgt, wqe);
		num_free_sqes++;
		}
		cqe++;