Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 1 | /* |
| 2 | * zfcp device driver |
| 3 | * |
| 4 | * Userspace interface for accessing the |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 5 | * Access Control Lists / Control File Data Channel; |
| 6 | * handling of response code and states for ports and LUNs. |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 7 | * |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 8 | * Copyright IBM Corporation 2008, 2010 |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 9 | */ |
| 10 | |
Christof Schmitt | ecf39d4 | 2008-12-25 13:39:53 +0100 | [diff] [blame] | 11 | #define KMSG_COMPONENT "zfcp" |
| 12 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
| 13 | |
Heiko Carstens | 048cd4e | 2012-02-27 10:01:52 +0100 | [diff] [blame] | 14 | #include <linux/compat.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 16 | #include <linux/types.h> |
| 17 | #include <linux/miscdevice.h> |
Heiko Carstens | 9e2ab1f | 2010-01-13 17:52:38 +0100 | [diff] [blame] | 18 | #include <asm/compat.h> |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 19 | #include <asm/ccwdev.h> |
| 20 | #include "zfcp_def.h" |
| 21 | #include "zfcp_ext.h" |
| 22 | #include "zfcp_fsf.h" |
| 23 | |
| 24 | #define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL 0x00010001 |
| 25 | #define ZFCP_CFDC_CMND_DOWNLOAD_FORCE 0x00010101 |
| 26 | #define ZFCP_CFDC_CMND_FULL_ACCESS 0x00000201 |
| 27 | #define ZFCP_CFDC_CMND_RESTRICTED_ACCESS 0x00000401 |
| 28 | #define ZFCP_CFDC_CMND_UPLOAD 0x00010002 |
| 29 | |
| 30 | #define ZFCP_CFDC_DOWNLOAD 0x00000001 |
| 31 | #define ZFCP_CFDC_UPLOAD 0x00000002 |
| 32 | #define ZFCP_CFDC_WITH_CONTROL_FILE 0x00010000 |
| 33 | |
| 34 | #define ZFCP_CFDC_IOC_MAGIC 0xDD |
| 35 | #define ZFCP_CFDC_IOC \ |
| 36 | _IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_data) |
| 37 | |
| 38 | /** |
| 39 | * struct zfcp_cfdc_data - data for ioctl cfdc interface |
| 40 | * @signature: request signature |
| 41 | * @devno: FCP adapter device number |
| 42 | * @command: command code |
| 43 | * @fsf_status: returns status of FSF command to userspace |
| 44 | * @fsf_status_qual: returned to userspace |
| 45 | * @payloads: access conflicts list |
| 46 | * @control_file: access control table |
| 47 | */ |
| 48 | struct zfcp_cfdc_data { |
| 49 | u32 signature; |
| 50 | u32 devno; |
| 51 | u32 command; |
| 52 | u32 fsf_status; |
| 53 | u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE]; |
| 54 | u8 payloads[256]; |
| 55 | u8 control_file[0]; |
| 56 | }; |
| 57 | |
| 58 | static int zfcp_cfdc_copy_from_user(struct scatterlist *sg, |
| 59 | void __user *user_buffer) |
| 60 | { |
| 61 | unsigned int length; |
| 62 | unsigned int size = ZFCP_CFDC_MAX_SIZE; |
| 63 | |
| 64 | while (size) { |
| 65 | length = min((unsigned int)size, sg->length); |
| 66 | if (copy_from_user(sg_virt(sg++), user_buffer, length)) |
| 67 | return -EFAULT; |
| 68 | user_buffer += length; |
| 69 | size -= length; |
| 70 | } |
| 71 | return 0; |
| 72 | } |
| 73 | |
| 74 | static int zfcp_cfdc_copy_to_user(void __user *user_buffer, |
| 75 | struct scatterlist *sg) |
| 76 | { |
| 77 | unsigned int length; |
| 78 | unsigned int size = ZFCP_CFDC_MAX_SIZE; |
| 79 | |
| 80 | while (size) { |
| 81 | length = min((unsigned int) size, sg->length); |
| 82 | if (copy_to_user(user_buffer, sg_virt(sg++), length)) |
| 83 | return -EFAULT; |
| 84 | user_buffer += length; |
| 85 | size -= length; |
| 86 | } |
| 87 | return 0; |
| 88 | } |
| 89 | |
| 90 | static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno) |
| 91 | { |
Christof Schmitt | b228af0 | 2008-12-19 16:56:55 +0100 | [diff] [blame] | 92 | char busid[9]; |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 93 | struct ccw_device *cdev; |
| 94 | struct zfcp_adapter *adapter; |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 95 | |
Christof Schmitt | b228af0 | 2008-12-19 16:56:55 +0100 | [diff] [blame] | 96 | snprintf(busid, sizeof(busid), "0.0.%04x", devno); |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 97 | cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid); |
| 98 | if (!cdev) |
| 99 | return NULL; |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 100 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 101 | adapter = zfcp_ccw_adapter_by_cdev(cdev); |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 102 | |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 103 | put_device(&cdev->dev); |
Christof Schmitt | c5afd81 | 2009-09-24 10:23:22 +0200 | [diff] [blame] | 104 | return adapter; |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command) |
| 108 | { |
| 109 | switch (command) { |
| 110 | case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL: |
| 111 | fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; |
| 112 | fsf_cfdc->option = FSF_CFDC_OPTION_NORMAL_MODE; |
| 113 | break; |
| 114 | case ZFCP_CFDC_CMND_DOWNLOAD_FORCE: |
| 115 | fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; |
| 116 | fsf_cfdc->option = FSF_CFDC_OPTION_FORCE; |
| 117 | break; |
| 118 | case ZFCP_CFDC_CMND_FULL_ACCESS: |
| 119 | fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; |
| 120 | fsf_cfdc->option = FSF_CFDC_OPTION_FULL_ACCESS; |
| 121 | break; |
| 122 | case ZFCP_CFDC_CMND_RESTRICTED_ACCESS: |
| 123 | fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE; |
| 124 | fsf_cfdc->option = FSF_CFDC_OPTION_RESTRICTED_ACCESS; |
| 125 | break; |
| 126 | case ZFCP_CFDC_CMND_UPLOAD: |
| 127 | fsf_cfdc->command = FSF_QTCB_UPLOAD_CONTROL_FILE; |
| 128 | fsf_cfdc->option = 0; |
| 129 | break; |
| 130 | default: |
| 131 | return -EINVAL; |
| 132 | } |
| 133 | |
| 134 | return 0; |
| 135 | } |
| 136 | |
| 137 | static int zfcp_cfdc_sg_setup(int command, struct scatterlist *sg, |
| 138 | u8 __user *control_file) |
| 139 | { |
| 140 | int retval; |
| 141 | retval = zfcp_sg_setup_table(sg, ZFCP_CFDC_PAGES); |
| 142 | if (retval) |
| 143 | return retval; |
| 144 | |
| 145 | sg[ZFCP_CFDC_PAGES - 1].length = ZFCP_CFDC_MAX_SIZE % PAGE_SIZE; |
| 146 | |
| 147 | if (command & ZFCP_CFDC_WITH_CONTROL_FILE && |
| 148 | command & ZFCP_CFDC_DOWNLOAD) { |
| 149 | retval = zfcp_cfdc_copy_from_user(sg, control_file); |
| 150 | if (retval) { |
| 151 | zfcp_sg_free_table(sg, ZFCP_CFDC_PAGES); |
| 152 | return -EFAULT; |
| 153 | } |
| 154 | } |
| 155 | |
| 156 | return 0; |
| 157 | } |
| 158 | |
| 159 | static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data, |
| 160 | struct zfcp_fsf_req *req) |
| 161 | { |
| 162 | data->fsf_status = req->qtcb->header.fsf_status; |
| 163 | memcpy(&data->fsf_status_qual, &req->qtcb->header.fsf_status_qual, |
| 164 | sizeof(union fsf_status_qual)); |
| 165 | memcpy(&data->payloads, &req->qtcb->bottom.support.els, |
| 166 | sizeof(req->qtcb->bottom.support.els)); |
| 167 | } |
| 168 | |
| 169 | static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command, |
Heiko Carstens | 9e2ab1f | 2010-01-13 17:52:38 +0100 | [diff] [blame] | 170 | unsigned long arg) |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 171 | { |
| 172 | struct zfcp_cfdc_data *data; |
| 173 | struct zfcp_cfdc_data __user *data_user; |
| 174 | struct zfcp_adapter *adapter; |
| 175 | struct zfcp_fsf_req *req; |
| 176 | struct zfcp_fsf_cfdc *fsf_cfdc; |
| 177 | int retval; |
| 178 | |
| 179 | if (command != ZFCP_CFDC_IOC) |
| 180 | return -ENOTTY; |
| 181 | |
Heiko Carstens | 9e2ab1f | 2010-01-13 17:52:38 +0100 | [diff] [blame] | 182 | if (is_compat_task()) |
| 183 | data_user = compat_ptr(arg); |
| 184 | else |
| 185 | data_user = (void __user *)arg; |
| 186 | |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 187 | if (!data_user) |
| 188 | return -EINVAL; |
| 189 | |
| 190 | fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL); |
| 191 | if (!fsf_cfdc) |
| 192 | return -ENOMEM; |
| 193 | |
Christof Schmitt | 674c3a9 | 2010-07-16 15:37:34 +0200 | [diff] [blame] | 194 | data = memdup_user(data_user, sizeof(*data_user)); |
| 195 | if (IS_ERR(data)) { |
| 196 | retval = PTR_ERR(data); |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 197 | goto no_mem_sense; |
| 198 | } |
| 199 | |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 200 | if (data->signature != 0xCFDCACDF) { |
| 201 | retval = -EINVAL; |
| 202 | goto free_buffer; |
| 203 | } |
| 204 | |
| 205 | retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command); |
| 206 | |
| 207 | adapter = zfcp_cfdc_get_adapter(data->devno); |
| 208 | if (!adapter) { |
| 209 | retval = -ENXIO; |
| 210 | goto free_buffer; |
| 211 | } |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 212 | |
| 213 | retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg, |
| 214 | data_user->control_file); |
| 215 | if (retval) |
| 216 | goto adapter_put; |
| 217 | req = zfcp_fsf_control_file(adapter, fsf_cfdc); |
| 218 | if (IS_ERR(req)) { |
| 219 | retval = PTR_ERR(req); |
| 220 | goto free_sg; |
| 221 | } |
| 222 | |
| 223 | if (req->status & ZFCP_STATUS_FSFREQ_ERROR) { |
| 224 | retval = -ENXIO; |
| 225 | goto free_fsf; |
| 226 | } |
| 227 | |
| 228 | zfcp_cfdc_req_to_sense(data, req); |
| 229 | retval = copy_to_user(data_user, data, sizeof(*data_user)); |
| 230 | if (retval) { |
| 231 | retval = -EFAULT; |
| 232 | goto free_fsf; |
| 233 | } |
| 234 | |
| 235 | if (data->command & ZFCP_CFDC_UPLOAD) |
| 236 | retval = zfcp_cfdc_copy_to_user(&data_user->control_file, |
| 237 | fsf_cfdc->sg); |
| 238 | |
| 239 | free_fsf: |
| 240 | zfcp_fsf_req_free(req); |
| 241 | free_sg: |
| 242 | zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES); |
| 243 | adapter_put: |
Swen Schillig | de3dc57 | 2009-11-24 16:54:00 +0100 | [diff] [blame] | 244 | zfcp_ccw_adapter_put(adapter); |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 245 | free_buffer: |
| 246 | kfree(data); |
| 247 | no_mem_sense: |
| 248 | kfree(fsf_cfdc); |
| 249 | return retval; |
| 250 | } |
| 251 | |
| 252 | static const struct file_operations zfcp_cfdc_fops = { |
Martin Schwidefsky | 58ea91c | 2010-05-17 10:00:07 +0200 | [diff] [blame] | 253 | .open = nonseekable_open, |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 254 | .unlocked_ioctl = zfcp_cfdc_dev_ioctl, |
| 255 | #ifdef CONFIG_COMPAT |
Arnd Bergmann | 6038f37 | 2010-08-15 18:52:59 +0200 | [diff] [blame] | 256 | .compat_ioctl = zfcp_cfdc_dev_ioctl, |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 257 | #endif |
Arnd Bergmann | 6038f37 | 2010-08-15 18:52:59 +0200 | [diff] [blame] | 258 | .llseek = no_llseek, |
Christof Schmitt | 45633fd | 2008-06-10 18:20:55 +0200 | [diff] [blame] | 259 | }; |
| 260 | |
| 261 | struct miscdevice zfcp_cfdc_misc = { |
| 262 | .minor = MISC_DYNAMIC_MINOR, |
| 263 | .name = "zfcp_cfdc", |
| 264 | .fops = &zfcp_cfdc_fops, |
| 265 | }; |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 266 | |
| 267 | /** |
| 268 | * zfcp_cfdc_adapter_access_changed - Process change in adapter ACT |
| 269 | * @adapter: Adapter where the Access Control Table (ACT) changed |
| 270 | * |
| 271 | * After a change in the adapter ACT, check if access to any |
| 272 | * previously denied resources is now possible. |
| 273 | */ |
| 274 | void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter) |
| 275 | { |
| 276 | unsigned long flags; |
| 277 | struct zfcp_port *port; |
| 278 | struct scsi_device *sdev; |
| 279 | struct zfcp_scsi_dev *zfcp_sdev; |
| 280 | int status; |
| 281 | |
| 282 | if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) |
| 283 | return; |
| 284 | |
| 285 | read_lock_irqsave(&adapter->port_list_lock, flags); |
| 286 | list_for_each_entry(port, &adapter->port_list, list) { |
| 287 | status = atomic_read(&port->status); |
| 288 | if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) || |
| 289 | (status & ZFCP_STATUS_COMMON_ACCESS_BOXED)) |
| 290 | zfcp_erp_port_reopen(port, |
| 291 | ZFCP_STATUS_COMMON_ERP_FAILED, |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 292 | "cfaac_1"); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 293 | } |
| 294 | read_unlock_irqrestore(&adapter->port_list_lock, flags); |
| 295 | |
| 296 | shost_for_each_device(sdev, port->adapter->scsi_host) { |
| 297 | zfcp_sdev = sdev_to_zfcp(sdev); |
| 298 | status = atomic_read(&zfcp_sdev->status); |
| 299 | if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) || |
| 300 | (status & ZFCP_STATUS_COMMON_ACCESS_BOXED)) |
| 301 | zfcp_erp_lun_reopen(sdev, |
| 302 | ZFCP_STATUS_COMMON_ERP_FAILED, |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 303 | "cfaac_2"); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 304 | } |
| 305 | } |
| 306 | |
| 307 | static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table) |
| 308 | { |
| 309 | u16 subtable = table >> 16; |
| 310 | u16 rule = table & 0xffff; |
| 311 | const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" }; |
| 312 | |
| 313 | if (subtable && subtable < ARRAY_SIZE(act_type)) |
| 314 | dev_warn(&adapter->ccw_device->dev, |
| 315 | "Access denied according to ACT rule type %s, " |
| 316 | "rule %d\n", act_type[subtable], rule); |
| 317 | } |
| 318 | |
| 319 | /** |
| 320 | * zfcp_cfdc_port_denied - Process "access denied" for port |
Uwe Kleine-König | b595076 | 2010-11-01 15:38:34 -0400 | [diff] [blame] | 321 | * @port: The port where the access has been denied |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 322 | * @qual: The FSF status qualifier for the access denied FSF status |
| 323 | */ |
| 324 | void zfcp_cfdc_port_denied(struct zfcp_port *port, |
| 325 | union fsf_status_qual *qual) |
| 326 | { |
| 327 | dev_warn(&port->adapter->ccw_device->dev, |
| 328 | "Access denied to port 0x%016Lx\n", |
| 329 | (unsigned long long)port->wwpn); |
| 330 | |
| 331 | zfcp_act_eval_err(port->adapter, qual->halfword[0]); |
| 332 | zfcp_act_eval_err(port->adapter, qual->halfword[1]); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 333 | zfcp_erp_set_port_status(port, |
| 334 | ZFCP_STATUS_COMMON_ERP_FAILED | |
| 335 | ZFCP_STATUS_COMMON_ACCESS_DENIED); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | /** |
| 339 | * zfcp_cfdc_lun_denied - Process "access denied" for LUN |
| 340 | * @sdev: The SCSI device / LUN where the access has been denied |
| 341 | * @qual: The FSF status qualifier for the access denied FSF status |
| 342 | */ |
| 343 | void zfcp_cfdc_lun_denied(struct scsi_device *sdev, |
| 344 | union fsf_status_qual *qual) |
| 345 | { |
| 346 | struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); |
| 347 | |
| 348 | dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev, |
| 349 | "Access denied to LUN 0x%016Lx on port 0x%016Lx\n", |
| 350 | zfcp_scsi_dev_lun(sdev), |
| 351 | (unsigned long long)zfcp_sdev->port->wwpn); |
| 352 | zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[0]); |
| 353 | zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[1]); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 354 | zfcp_erp_set_lun_status(sdev, |
| 355 | ZFCP_STATUS_COMMON_ERP_FAILED | |
| 356 | ZFCP_STATUS_COMMON_ACCESS_DENIED); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 357 | |
| 358 | atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status); |
| 359 | atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status); |
| 360 | } |
| 361 | |
| 362 | /** |
| 363 | * zfcp_cfdc_lun_shrng_vltn - Evaluate LUN sharing violation status |
| 364 | * @sdev: The LUN / SCSI device where sharing violation occurred |
| 365 | * @qual: The FSF status qualifier from the LUN sharing violation |
| 366 | */ |
| 367 | void zfcp_cfdc_lun_shrng_vltn(struct scsi_device *sdev, |
| 368 | union fsf_status_qual *qual) |
| 369 | { |
| 370 | struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); |
| 371 | |
| 372 | if (qual->word[0]) |
| 373 | dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev, |
| 374 | "LUN 0x%Lx on port 0x%Lx is already in " |
| 375 | "use by CSS%d, MIF Image ID %x\n", |
| 376 | zfcp_scsi_dev_lun(sdev), |
| 377 | (unsigned long long)zfcp_sdev->port->wwpn, |
| 378 | qual->fsf_queue_designator.cssid, |
| 379 | qual->fsf_queue_designator.hla); |
| 380 | else |
| 381 | zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->word[2]); |
| 382 | |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 383 | zfcp_erp_set_lun_status(sdev, |
| 384 | ZFCP_STATUS_COMMON_ERP_FAILED | |
| 385 | ZFCP_STATUS_COMMON_ACCESS_DENIED); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 386 | atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status); |
| 387 | atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status); |
| 388 | } |
| 389 | |
| 390 | /** |
| 391 | * zfcp_cfdc_open_lun_eval - Eval access ctrl. status for successful "open lun" |
| 392 | * @sdev: The SCSI device / LUN where to evaluate the status |
| 393 | * @bottom: The qtcb bottom with the status from the "open lun" |
| 394 | * |
| 395 | * Returns: 0 if LUN is usable, -EACCES if the access control table |
| 396 | * reports an unsupported configuration. |
| 397 | */ |
| 398 | int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev, |
| 399 | struct fsf_qtcb_bottom_support *bottom) |
| 400 | { |
| 401 | int shared, rw; |
| 402 | struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); |
| 403 | struct zfcp_adapter *adapter = zfcp_sdev->port->adapter; |
| 404 | |
| 405 | if ((adapter->connection_features & FSF_FEATURE_NPIV_MODE) || |
| 406 | !(adapter->adapter_features & FSF_FEATURE_LUN_SHARING) || |
| 407 | zfcp_ccw_priv_sch(adapter)) |
| 408 | return 0; |
| 409 | |
| 410 | shared = !(bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE); |
| 411 | rw = (bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER); |
| 412 | |
| 413 | if (shared) |
| 414 | atomic_set_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status); |
| 415 | |
| 416 | if (!rw) { |
| 417 | atomic_set_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status); |
| 418 | dev_info(&adapter->ccw_device->dev, "SCSI device at LUN " |
| 419 | "0x%016Lx on port 0x%016Lx opened read-only\n", |
| 420 | zfcp_scsi_dev_lun(sdev), |
| 421 | (unsigned long long)zfcp_sdev->port->wwpn); |
| 422 | } |
| 423 | |
| 424 | if (!shared && !rw) { |
| 425 | dev_err(&adapter->ccw_device->dev, "Exclusive read-only access " |
| 426 | "not supported (LUN 0x%016Lx, port 0x%016Lx)\n", |
| 427 | zfcp_scsi_dev_lun(sdev), |
| 428 | (unsigned long long)zfcp_sdev->port->wwpn); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 429 | zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED); |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 430 | zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6"); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 431 | return -EACCES; |
| 432 | } |
| 433 | |
| 434 | if (shared && rw) { |
| 435 | dev_err(&adapter->ccw_device->dev, |
| 436 | "Shared read-write access not supported " |
| 437 | "(LUN 0x%016Lx, port 0x%016Lx)\n", |
| 438 | zfcp_scsi_dev_lun(sdev), |
| 439 | (unsigned long long)zfcp_sdev->port->wwpn); |
Swen Schillig | edaed85 | 2010-09-08 14:40:01 +0200 | [diff] [blame] | 440 | zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED); |
Swen Schillig | ea4a3a6 | 2010-12-02 15:16:16 +0100 | [diff] [blame] | 441 | zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8"); |
Christof Schmitt | a1ca483 | 2010-09-08 14:39:59 +0200 | [diff] [blame] | 442 | return -EACCES; |
| 443 | } |
| 444 | |
| 445 | return 0; |
| 446 | } |