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