Loading...
Note: File does not exist in v5.9.
1/*
2 * zfcp device driver
3 *
4 * Userspace interface for accessing the
5 * Access Control Lists / Control File Data Channel;
6 * handling of response code and states for ports and LUNs.
7 *
8 * Copyright IBM Corporation 2008, 2010
9 */
10
11#define KMSG_COMPONENT "zfcp"
12#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
14#include <linux/slab.h>
15#include <linux/types.h>
16#include <linux/miscdevice.h>
17#include <asm/compat.h>
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 */
47struct 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
57static 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
73static 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
89static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
90{
91 char busid[9];
92 struct ccw_device *cdev;
93 struct zfcp_adapter *adapter;
94
95 snprintf(busid, sizeof(busid), "0.0.%04x", devno);
96 cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
97 if (!cdev)
98 return NULL;
99
100 adapter = zfcp_ccw_adapter_by_cdev(cdev);
101
102 put_device(&cdev->dev);
103 return adapter;
104}
105
106static 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
136static 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
158static 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
168static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
169 unsigned long arg)
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
181 if (is_compat_task())
182 data_user = compat_ptr(arg);
183 else
184 data_user = (void __user *)arg;
185
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
193 data = memdup_user(data_user, sizeof(*data_user));
194 if (IS_ERR(data)) {
195 retval = PTR_ERR(data);
196 goto no_mem_sense;
197 }
198
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 }
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:
243 zfcp_ccw_adapter_put(adapter);
244 free_buffer:
245 kfree(data);
246 no_mem_sense:
247 kfree(fsf_cfdc);
248 return retval;
249}
250
251static const struct file_operations zfcp_cfdc_fops = {
252 .open = nonseekable_open,
253 .unlocked_ioctl = zfcp_cfdc_dev_ioctl,
254#ifdef CONFIG_COMPAT
255 .compat_ioctl = zfcp_cfdc_dev_ioctl,
256#endif
257 .llseek = no_llseek,
258};
259
260struct miscdevice zfcp_cfdc_misc = {
261 .minor = MISC_DYNAMIC_MINOR,
262 .name = "zfcp_cfdc",
263 .fops = &zfcp_cfdc_fops,
264};
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 */
273void 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,
291 "cfaac_1");
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,
302 "cfaac_2");
303 }
304}
305
306static 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
320 * @port: The port where the access has been denied
321 * @qual: The FSF status qualifier for the access denied FSF status
322 */
323void 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]);
332 zfcp_erp_set_port_status(port,
333 ZFCP_STATUS_COMMON_ERP_FAILED |
334 ZFCP_STATUS_COMMON_ACCESS_DENIED);
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 */
342void 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]);
353 zfcp_erp_set_lun_status(sdev,
354 ZFCP_STATUS_COMMON_ERP_FAILED |
355 ZFCP_STATUS_COMMON_ACCESS_DENIED);
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 */
366void 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
382 zfcp_erp_set_lun_status(sdev,
383 ZFCP_STATUS_COMMON_ERP_FAILED |
384 ZFCP_STATUS_COMMON_ACCESS_DENIED);
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 */
397int 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);
428 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
429 zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
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);
439 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
440 zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
441 return -EACCES;
442 }
443
444 return 0;
445}