drivers/s390/scsi/zfcp_cfdc.c - android_kernel_htc_msm8960 - Gitiles

 /*
  * zfcp device driver
  *
  * Userspace interface for accessing the
  * Access Control Lists / Control File Data Channel;
  * handling of response code and states for ports and LUNs.
  *
  * Copyright IBM Corporation 2008, 2010
  */

 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/miscdevice.h>
 #include <asm/compat.h>
 #include <asm/ccwdev.h>
 #include "zfcp_def.h"
 #include "zfcp_ext.h"
 #include "zfcp_fsf.h"

 #define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL		0x00010001
 #define ZFCP_CFDC_CMND_DOWNLOAD_FORCE		0x00010101
 #define ZFCP_CFDC_CMND_FULL_ACCESS		0x00000201
 #define ZFCP_CFDC_CMND_RESTRICTED_ACCESS	0x00000401
 #define ZFCP_CFDC_CMND_UPLOAD			0x00010002

 #define ZFCP_CFDC_DOWNLOAD			0x00000001
 #define ZFCP_CFDC_UPLOAD			0x00000002
 #define ZFCP_CFDC_WITH_CONTROL_FILE		0x00010000

 #define ZFCP_CFDC_IOC_MAGIC                     0xDD
 #define ZFCP_CFDC_IOC \
 	_IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_data)

 /**
  * struct zfcp_cfdc_data - data for ioctl cfdc interface
  * @signature: request signature
  * @devno: FCP adapter device number
  * @command: command code
  * @fsf_status: returns status of FSF command to userspace
  * @fsf_status_qual: returned to userspace
  * @payloads: access conflicts list
  * @control_file: access control table
  */
 struct zfcp_cfdc_data {
 	u32 signature;
 	u32 devno;
 	u32 command;
 	u32 fsf_status;
 	u8  fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
 	u8  payloads[256];
 	u8  control_file[0];
 };

 static int zfcp_cfdc_copy_from_user(struct scatterlist *sg,
 				    void __user *user_buffer)
 {
 	unsigned int length;
 	unsigned int size = ZFCP_CFDC_MAX_SIZE;

 	while (size) {
 		length = min((unsigned int)size, sg->length);
 		if (copy_from_user(sg_virt(sg++), user_buffer, length))
 			return -EFAULT;
 		user_buffer += length;
 		size -= length;
 	}
 	return 0;
 }

 static int zfcp_cfdc_copy_to_user(void __user  *user_buffer,
 				  struct scatterlist *sg)
 {
 	unsigned int length;
 	unsigned int size = ZFCP_CFDC_MAX_SIZE;

 	while (size) {
 		length = min((unsigned int) size, sg->length);
 		if (copy_to_user(user_buffer, sg_virt(sg++), length))
 			return -EFAULT;
 		user_buffer += length;
 		size -= length;
 	}
 	return 0;
 }

 static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
 {
 	char busid[9];
 	struct ccw_device *cdev;
 	struct zfcp_adapter *adapter;

 	snprintf(busid, sizeof(busid), "0.0.%04x", devno);
 	cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
 	if (!cdev)
 		return NULL;

 	adapter = zfcp_ccw_adapter_by_cdev(cdev);

 	put_device(&cdev->dev);
 	return adapter;
 }

 static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command)
 {
 	switch (command) {
 	case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL:
 		fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
 		fsf_cfdc->option = FSF_CFDC_OPTION_NORMAL_MODE;
 		break;
 	case ZFCP_CFDC_CMND_DOWNLOAD_FORCE:
 		fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
 		fsf_cfdc->option = FSF_CFDC_OPTION_FORCE;
 		break;
 	case ZFCP_CFDC_CMND_FULL_ACCESS:
 		fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
 		fsf_cfdc->option = FSF_CFDC_OPTION_FULL_ACCESS;
 		break;
 	case ZFCP_CFDC_CMND_RESTRICTED_ACCESS:
 		fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
 		fsf_cfdc->option = FSF_CFDC_OPTION_RESTRICTED_ACCESS;
 		break;
 	case ZFCP_CFDC_CMND_UPLOAD:
 		fsf_cfdc->command = FSF_QTCB_UPLOAD_CONTROL_FILE;
 		fsf_cfdc->option = 0;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static int zfcp_cfdc_sg_setup(int command, struct scatterlist *sg,
 			      u8 __user *control_file)
 {
 	int retval;
 	retval = zfcp_sg_setup_table(sg, ZFCP_CFDC_PAGES);
 	if (retval)
 		return retval;

 	sg[ZFCP_CFDC_PAGES - 1].length = ZFCP_CFDC_MAX_SIZE % PAGE_SIZE;

 	if (command & ZFCP_CFDC_WITH_CONTROL_FILE &&
 	    command & ZFCP_CFDC_DOWNLOAD) {
 		retval = zfcp_cfdc_copy_from_user(sg, control_file);
 		if (retval) {
 			zfcp_sg_free_table(sg, ZFCP_CFDC_PAGES);
 			return -EFAULT;
 		}
 	}

 	return 0;
 }

 static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
 				   struct zfcp_fsf_req *req)
 {
 	data->fsf_status = req->qtcb->header.fsf_status;
 	memcpy(&data->fsf_status_qual, &req->qtcb->header.fsf_status_qual,
 	       sizeof(union fsf_status_qual));
 	memcpy(&data->payloads, &req->qtcb->bottom.support.els,
 	       sizeof(req->qtcb->bottom.support.els));
 }

 static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
 				unsigned long arg)
 {
 	struct zfcp_cfdc_data *data;
 	struct zfcp_cfdc_data __user *data_user;
 	struct zfcp_adapter *adapter;
 	struct zfcp_fsf_req *req;
 	struct zfcp_fsf_cfdc *fsf_cfdc;
 	int retval;

 	if (command != ZFCP_CFDC_IOC)
 		return -ENOTTY;

 	if (is_compat_task())
 		data_user = compat_ptr(arg);
 	else
 		data_user = (void __user *)arg;

 	if (!data_user)
 		return -EINVAL;

 	fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL);
 	if (!fsf_cfdc)
 		return -ENOMEM;

 	data = memdup_user(data_user, sizeof(*data_user));
 	if (IS_ERR(data)) {
 		retval = PTR_ERR(data);
 		goto no_mem_sense;
 	}

 	if (data->signature != 0xCFDCACDF) {
 		retval = -EINVAL;
 		goto free_buffer;
 	}

 	retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command);

 	adapter = zfcp_cfdc_get_adapter(data->devno);
 	if (!adapter) {
 		retval = -ENXIO;
 		goto free_buffer;
 	}

 	retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
 				    data_user->control_file);
 	if (retval)
 		goto adapter_put;
 	req = zfcp_fsf_control_file(adapter, fsf_cfdc);
 	if (IS_ERR(req)) {
 		retval = PTR_ERR(req);
 		goto free_sg;
 	}

 	if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
 		retval = -ENXIO;
 		goto free_fsf;
 	}

 	zfcp_cfdc_req_to_sense(data, req);
 	retval = copy_to_user(data_user, data, sizeof(*data_user));
 	if (retval) {
 		retval = -EFAULT;
 		goto free_fsf;
 	}

 	if (data->command & ZFCP_CFDC_UPLOAD)
 		retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
 						fsf_cfdc->sg);

  free_fsf:
 	zfcp_fsf_req_free(req);
  free_sg:
 	zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
  adapter_put:
 	zfcp_ccw_adapter_put(adapter);
  free_buffer:
 	kfree(data);
  no_mem_sense:
 	kfree(fsf_cfdc);
 	return retval;
 }

 static const struct file_operations zfcp_cfdc_fops = {
 	.open = nonseekable_open,
 	.unlocked_ioctl = zfcp_cfdc_dev_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = zfcp_cfdc_dev_ioctl,
 #endif
 	.llseek = no_llseek,
 };

 struct miscdevice zfcp_cfdc_misc = {
 	.minor = MISC_DYNAMIC_MINOR,
 	.name = "zfcp_cfdc",
 	.fops = &zfcp_cfdc_fops,
 };

 /**
  * zfcp_cfdc_adapter_access_changed - Process change in adapter ACT
  * @adapter: Adapter where the Access Control Table (ACT) changed
  *
  * After a change in the adapter ACT, check if access to any
  * previously denied resources is now possible.
  */
 void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
 {
 	unsigned long flags;
 	struct zfcp_port *port;
 	struct scsi_device *sdev;
 	struct zfcp_scsi_dev *zfcp_sdev;
 	int status;

 	if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
 		return;

 	read_lock_irqsave(&adapter->port_list_lock, flags);
 	list_for_each_entry(port, &adapter->port_list, list) {
 		status = atomic_read(&port->status);
 		if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) ||
 		    (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
 			zfcp_erp_port_reopen(port,
 					     ZFCP_STATUS_COMMON_ERP_FAILED,
 					     "cfaac_1");
 	}
 	read_unlock_irqrestore(&adapter->port_list_lock, flags);

 	shost_for_each_device(sdev, port->adapter->scsi_host) {
 		zfcp_sdev = sdev_to_zfcp(sdev);
 		status = atomic_read(&zfcp_sdev->status);
 		if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) ||
 		    (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
 			zfcp_erp_lun_reopen(sdev,
 					    ZFCP_STATUS_COMMON_ERP_FAILED,
 					    "cfaac_2");
 	}
 }

 static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
 {
 	u16 subtable = table >> 16;
 	u16 rule = table & 0xffff;
 	const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };

 	if (subtable && subtable < ARRAY_SIZE(act_type))
 		dev_warn(&adapter->ccw_device->dev,
 			 "Access denied according to ACT rule type %s, "
 			 "rule %d\n", act_type[subtable], rule);
 }

 /**
  * zfcp_cfdc_port_denied - Process "access denied" for port
  * @port: The port where the access has been denied
  * @qual: The FSF status qualifier for the access denied FSF status
  */
 void zfcp_cfdc_port_denied(struct zfcp_port *port,
 			   union fsf_status_qual *qual)
 {
 	dev_warn(&port->adapter->ccw_device->dev,
 		 "Access denied to port 0x%016Lx\n",
 		 (unsigned long long)port->wwpn);

 	zfcp_act_eval_err(port->adapter, qual->halfword[0]);
 	zfcp_act_eval_err(port->adapter, qual->halfword[1]);
 	zfcp_erp_set_port_status(port,
 				 ZFCP_STATUS_COMMON_ERP_FAILED |
 				 ZFCP_STATUS_COMMON_ACCESS_DENIED);
 }

 /**
  * zfcp_cfdc_lun_denied - Process "access denied" for LUN
  * @sdev: The SCSI device / LUN where the access has been denied
  * @qual: The FSF status qualifier for the access denied FSF status
  */
 void zfcp_cfdc_lun_denied(struct scsi_device *sdev,
 			  union fsf_status_qual *qual)
 {
 	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

 	dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
 		 "Access denied to LUN 0x%016Lx on port 0x%016Lx\n",
 		 zfcp_scsi_dev_lun(sdev),
 		 (unsigned long long)zfcp_sdev->port->wwpn);
 	zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[0]);
 	zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[1]);
 	zfcp_erp_set_lun_status(sdev,
 				ZFCP_STATUS_COMMON_ERP_FAILED |
 				ZFCP_STATUS_COMMON_ACCESS_DENIED);

 	atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
 	atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
 }

 /**
  * zfcp_cfdc_lun_shrng_vltn - Evaluate LUN sharing violation status
  * @sdev: The LUN / SCSI device where sharing violation occurred
  * @qual: The FSF status qualifier from the LUN sharing violation
  */
 void zfcp_cfdc_lun_shrng_vltn(struct scsi_device *sdev,
 			      union fsf_status_qual *qual)
 {
 	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

 	if (qual->word[0])
 		dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
 			 "LUN 0x%Lx on port 0x%Lx is already in "
 			 "use by CSS%d, MIF Image ID %x\n",
 			 zfcp_scsi_dev_lun(sdev),
 			 (unsigned long long)zfcp_sdev->port->wwpn,
 			 qual->fsf_queue_designator.cssid,
 			 qual->fsf_queue_designator.hla);
 	else
 		zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->word[2]);

 	zfcp_erp_set_lun_status(sdev,
 				ZFCP_STATUS_COMMON_ERP_FAILED |
 				ZFCP_STATUS_COMMON_ACCESS_DENIED);
 	atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
 	atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
 }

 /**
  * zfcp_cfdc_open_lun_eval - Eval access ctrl. status for successful "open lun"
  * @sdev: The SCSI device / LUN where to evaluate the status
  * @bottom: The qtcb bottom with the status from the "open lun"
  *
  * Returns: 0 if LUN is usable, -EACCES if the access control table
  *          reports an unsupported configuration.
  */
 int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
 			    struct fsf_qtcb_bottom_support *bottom)
 {
 	int shared, rw;
 	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 	struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;

 	if ((adapter->connection_features & FSF_FEATURE_NPIV_MODE) ||
 	    !(adapter->adapter_features & FSF_FEATURE_LUN_SHARING) ||
 	    zfcp_ccw_priv_sch(adapter))
 		return 0;

 	shared = !(bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE);
 	rw = (bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);

 	if (shared)
 		atomic_set_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);

 	if (!rw) {
 		atomic_set_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
 		dev_info(&adapter->ccw_device->dev, "SCSI device at LUN "
 			 "0x%016Lx on port 0x%016Lx opened read-only\n",
 			 zfcp_scsi_dev_lun(sdev),
 			 (unsigned long long)zfcp_sdev->port->wwpn);
 	}

 	if (!shared && !rw) {
 		dev_err(&adapter->ccw_device->dev, "Exclusive read-only access "
 			"not supported (LUN 0x%016Lx, port 0x%016Lx)\n",
 			zfcp_scsi_dev_lun(sdev),
 			(unsigned long long)zfcp_sdev->port->wwpn);
 		zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
 		zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
 		return -EACCES;
 	}

 	if (shared && rw) {
 		dev_err(&adapter->ccw_device->dev,
 			"Shared read-write access not supported "
 			"(LUN 0x%016Lx, port 0x%016Lx)\n",
 			zfcp_scsi_dev_lun(sdev),
 			(unsigned long long)zfcp_sdev->port->wwpn);
 		zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
 		zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
 		return -EACCES;
 	}

 	return 0;
 }
	/*
	* zfcp device driver
	*
	* Userspace interface for accessing the
	* Access Control Lists / Control File Data Channel;
	* handling of response code and states for ports and LUNs.
	*
	* Copyright IBM Corporation 2008, 2010
	*/

	#define KMSG_COMPONENT "zfcp"
	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

	#include <linux/slab.h>
	#include <linux/types.h>
	#include <linux/miscdevice.h>
	#include <asm/compat.h>
	#include <asm/ccwdev.h>
	#include "zfcp_def.h"
	#include "zfcp_ext.h"
	#include "zfcp_fsf.h"

	#define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL 0x00010001
	#define ZFCP_CFDC_CMND_DOWNLOAD_FORCE 0x00010101
	#define ZFCP_CFDC_CMND_FULL_ACCESS 0x00000201
	#define ZFCP_CFDC_CMND_RESTRICTED_ACCESS 0x00000401
	#define ZFCP_CFDC_CMND_UPLOAD 0x00010002

	#define ZFCP_CFDC_DOWNLOAD 0x00000001
	#define ZFCP_CFDC_UPLOAD 0x00000002
	#define ZFCP_CFDC_WITH_CONTROL_FILE 0x00010000

	#define ZFCP_CFDC_IOC_MAGIC 0xDD
	#define ZFCP_CFDC_IOC \
	_IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_data)

	/**
	* struct zfcp_cfdc_data - data for ioctl cfdc interface
	* @signature: request signature
	* @devno: FCP adapter device number
	* @command: command code
	* @fsf_status: returns status of FSF command to userspace
	* @fsf_status_qual: returned to userspace
	* @payloads: access conflicts list
	* @control_file: access control table
	*/
	struct zfcp_cfdc_data {
	u32 signature;
	u32 devno;
	u32 command;
	u32 fsf_status;
	u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
	u8 payloads[256];
	u8 control_file[0];
	};

	static int zfcp_cfdc_copy_from_user(struct scatterlist *sg,
	void __user *user_buffer)
	{
	unsigned int length;
	unsigned int size = ZFCP_CFDC_MAX_SIZE;

	while (size) {
	length = min((unsigned int)size, sg->length);
	if (copy_from_user(sg_virt(sg++), user_buffer, length))
	return -EFAULT;
	user_buffer += length;
	size -= length;
	}
	return 0;
	}

	static int zfcp_cfdc_copy_to_user(void __user *user_buffer,
	struct scatterlist *sg)
	{
	unsigned int length;
	unsigned int size = ZFCP_CFDC_MAX_SIZE;

	while (size) {
	length = min((unsigned int) size, sg->length);
	if (copy_to_user(user_buffer, sg_virt(sg++), length))
	return -EFAULT;
	user_buffer += length;
	size -= length;
	}
	return 0;
	}

	static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
	{
	char busid[9];
	struct ccw_device *cdev;
	struct zfcp_adapter *adapter;

	snprintf(busid, sizeof(busid), "0.0.%04x", devno);
	cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
	if (!cdev)
	return NULL;

	adapter = zfcp_ccw_adapter_by_cdev(cdev);

	put_device(&cdev->dev);
	return adapter;
	}

	static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command)
	{
	switch (command) {
	case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL:
	fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
	fsf_cfdc->option = FSF_CFDC_OPTION_NORMAL_MODE;
	break;
	case ZFCP_CFDC_CMND_DOWNLOAD_FORCE:
	fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
	fsf_cfdc->option = FSF_CFDC_OPTION_FORCE;
	break;
	case ZFCP_CFDC_CMND_FULL_ACCESS:
	fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
	fsf_cfdc->option = FSF_CFDC_OPTION_FULL_ACCESS;
	break;
	case ZFCP_CFDC_CMND_RESTRICTED_ACCESS:
	fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
	fsf_cfdc->option = FSF_CFDC_OPTION_RESTRICTED_ACCESS;
	break;
	case ZFCP_CFDC_CMND_UPLOAD:
	fsf_cfdc->command = FSF_QTCB_UPLOAD_CONTROL_FILE;
	fsf_cfdc->option = 0;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	static int zfcp_cfdc_sg_setup(int command, struct scatterlist *sg,
	u8 __user *control_file)
	{
	int retval;
	retval = zfcp_sg_setup_table(sg, ZFCP_CFDC_PAGES);
	if (retval)
	return retval;

	sg[ZFCP_CFDC_PAGES - 1].length = ZFCP_CFDC_MAX_SIZE % PAGE_SIZE;

	if (command & ZFCP_CFDC_WITH_CONTROL_FILE &&
	command & ZFCP_CFDC_DOWNLOAD) {
	retval = zfcp_cfdc_copy_from_user(sg, control_file);
	if (retval) {
	zfcp_sg_free_table(sg, ZFCP_CFDC_PAGES);
	return -EFAULT;
	}
	}

	return 0;
	}

	static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
	struct zfcp_fsf_req *req)
	{
	data->fsf_status = req->qtcb->header.fsf_status;
	memcpy(&data->fsf_status_qual, &req->qtcb->header.fsf_status_qual,
	sizeof(union fsf_status_qual));
	memcpy(&data->payloads, &req->qtcb->bottom.support.els,
	sizeof(req->qtcb->bottom.support.els));
	}

	static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
	unsigned long arg)
	{
	struct zfcp_cfdc_data *data;
	struct zfcp_cfdc_data __user *data_user;
	struct zfcp_adapter *adapter;
	struct zfcp_fsf_req *req;
	struct zfcp_fsf_cfdc *fsf_cfdc;
	int retval;

	if (command != ZFCP_CFDC_IOC)
	return -ENOTTY;

	if (is_compat_task())
	data_user = compat_ptr(arg);
	else
	data_user = (void __user *)arg;

	if (!data_user)
	return -EINVAL;

	fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL);
	if (!fsf_cfdc)
	return -ENOMEM;

	data = memdup_user(data_user, sizeof(*data_user));
	if (IS_ERR(data)) {
	retval = PTR_ERR(data);
	goto no_mem_sense;
	}

	if (data->signature != 0xCFDCACDF) {
	retval = -EINVAL;
	goto free_buffer;
	}

	retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command);

	adapter = zfcp_cfdc_get_adapter(data->devno);
	if (!adapter) {
	retval = -ENXIO;
	goto free_buffer;
	}

	retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
	data_user->control_file);
	if (retval)
	goto adapter_put;
	req = zfcp_fsf_control_file(adapter, fsf_cfdc);
	if (IS_ERR(req)) {
	retval = PTR_ERR(req);
	goto free_sg;
	}

	if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
	retval = -ENXIO;
	goto free_fsf;
	}

	zfcp_cfdc_req_to_sense(data, req);
	retval = copy_to_user(data_user, data, sizeof(*data_user));
	if (retval) {
	retval = -EFAULT;
	goto free_fsf;
	}

	if (data->command & ZFCP_CFDC_UPLOAD)
	retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
	fsf_cfdc->sg);

	free_fsf:
	zfcp_fsf_req_free(req);
	free_sg:
	zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
	adapter_put:
	zfcp_ccw_adapter_put(adapter);
	free_buffer:
	kfree(data);
	no_mem_sense:
	kfree(fsf_cfdc);
	return retval;
	}

	static const struct file_operations zfcp_cfdc_fops = {
	.open = nonseekable_open,
	.unlocked_ioctl = zfcp_cfdc_dev_ioctl,
	#ifdef CONFIG_COMPAT
	.compat_ioctl = zfcp_cfdc_dev_ioctl,
	#endif
	.llseek = no_llseek,
	};

	struct miscdevice zfcp_cfdc_misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "zfcp_cfdc",
	.fops = &zfcp_cfdc_fops,
	};

	/**
	* zfcp_cfdc_adapter_access_changed - Process change in adapter ACT
	* @adapter: Adapter where the Access Control Table (ACT) changed
	*
	* After a change in the adapter ACT, check if access to any
	* previously denied resources is now possible.
	*/
	void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
	{
	unsigned long flags;
	struct zfcp_port *port;
	struct scsi_device *sdev;
	struct zfcp_scsi_dev *zfcp_sdev;
	int status;

	if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
	return;

	read_lock_irqsave(&adapter->port_list_lock, flags);
	list_for_each_entry(port, &adapter->port_list, list) {
	status = atomic_read(&port->status);
	if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) \|\|
	(status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
	zfcp_erp_port_reopen(port,
	ZFCP_STATUS_COMMON_ERP_FAILED,
	"cfaac_1");
	}
	read_unlock_irqrestore(&adapter->port_list_lock, flags);

	shost_for_each_device(sdev, port->adapter->scsi_host) {
	zfcp_sdev = sdev_to_zfcp(sdev);
	status = atomic_read(&zfcp_sdev->status);
	if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) \|\|
	(status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
	zfcp_erp_lun_reopen(sdev,
	ZFCP_STATUS_COMMON_ERP_FAILED,
	"cfaac_2");
	}
	}

	static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
	{
	u16 subtable = table >> 16;
	u16 rule = table & 0xffff;
	const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };

	if (subtable && subtable < ARRAY_SIZE(act_type))
	dev_warn(&adapter->ccw_device->dev,
	"Access denied according to ACT rule type %s, "
	"rule %d\n", act_type[subtable], rule);
	}

	/**
	* zfcp_cfdc_port_denied - Process "access denied" for port
	* @port: The port where the access has been denied
	* @qual: The FSF status qualifier for the access denied FSF status
	*/
	void zfcp_cfdc_port_denied(struct zfcp_port *port,
	union fsf_status_qual *qual)
	{
	dev_warn(&port->adapter->ccw_device->dev,
	"Access denied to port 0x%016Lx\n",
	(unsigned long long)port->wwpn);

	zfcp_act_eval_err(port->adapter, qual->halfword[0]);
	zfcp_act_eval_err(port->adapter, qual->halfword[1]);
	zfcp_erp_set_port_status(port,
	ZFCP_STATUS_COMMON_ERP_FAILED \|
	ZFCP_STATUS_COMMON_ACCESS_DENIED);
	}

	/**
	* zfcp_cfdc_lun_denied - Process "access denied" for LUN
	* @sdev: The SCSI device / LUN where the access has been denied
	* @qual: The FSF status qualifier for the access denied FSF status
	*/
	void zfcp_cfdc_lun_denied(struct scsi_device *sdev,
	union fsf_status_qual *qual)
	{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
	"Access denied to LUN 0x%016Lx on port 0x%016Lx\n",
	zfcp_scsi_dev_lun(sdev),
	(unsigned long long)zfcp_sdev->port->wwpn);
	zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[0]);
	zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[1]);
	zfcp_erp_set_lun_status(sdev,
	ZFCP_STATUS_COMMON_ERP_FAILED \|
	ZFCP_STATUS_COMMON_ACCESS_DENIED);

	atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
	atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
	}

	/**
	* zfcp_cfdc_lun_shrng_vltn - Evaluate LUN sharing violation status
	* @sdev: The LUN / SCSI device where sharing violation occurred
	* @qual: The FSF status qualifier from the LUN sharing violation
	*/
	void zfcp_cfdc_lun_shrng_vltn(struct scsi_device *sdev,
	union fsf_status_qual *qual)
	{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	if (qual->word[0])
	dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
	"LUN 0x%Lx on port 0x%Lx is already in "
	"use by CSS%d, MIF Image ID %x\n",
	zfcp_scsi_dev_lun(sdev),
	(unsigned long long)zfcp_sdev->port->wwpn,
	qual->fsf_queue_designator.cssid,
	qual->fsf_queue_designator.hla);
	else
	zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->word[2]);

	zfcp_erp_set_lun_status(sdev,
	ZFCP_STATUS_COMMON_ERP_FAILED \|
	ZFCP_STATUS_COMMON_ACCESS_DENIED);
	atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
	atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
	}

	/**
	* zfcp_cfdc_open_lun_eval - Eval access ctrl. status for successful "open lun"
	* @sdev: The SCSI device / LUN where to evaluate the status
	* @bottom: The qtcb bottom with the status from the "open lun"
	*
	* Returns: 0 if LUN is usable, -EACCES if the access control table
	* reports an unsupported configuration.
	*/
	int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
	struct fsf_qtcb_bottom_support *bottom)
	{
	int shared, rw;
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
	struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;

	if ((adapter->connection_features & FSF_FEATURE_NPIV_MODE) \|\|
	!(adapter->adapter_features & FSF_FEATURE_LUN_SHARING) \|\|
	zfcp_ccw_priv_sch(adapter))
	return 0;

	shared = !(bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE);
	rw = (bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);

	if (shared)
	atomic_set_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);

	if (!rw) {
	atomic_set_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
	dev_info(&adapter->ccw_device->dev, "SCSI device at LUN "
	"0x%016Lx on port 0x%016Lx opened read-only\n",
	zfcp_scsi_dev_lun(sdev),
	(unsigned long long)zfcp_sdev->port->wwpn);
	}

	if (!shared && !rw) {
	dev_err(&adapter->ccw_device->dev, "Exclusive read-only access "
	"not supported (LUN 0x%016Lx, port 0x%016Lx)\n",
	zfcp_scsi_dev_lun(sdev),
	(unsigned long long)zfcp_sdev->port->wwpn);
	zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
	zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
	return -EACCES;
	}

	if (shared && rw) {
	dev_err(&adapter->ccw_device->dev,
	"Shared read-write access not supported "
	"(LUN 0x%016Lx, port 0x%016Lx)\n",
	zfcp_scsi_dev_lun(sdev),
	(unsigned long long)zfcp_sdev->port->wwpn);
	zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
	zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
	return -EACCES;
	}

	return 0;
	}