1 /*
2 * zfcp device driver
3 *
4 * Userspace interface for accessing the
5 * Access Control Lists / Control File Data Channel
6 *
7 * Copyright IBM Corporation 2008
8 */
9
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13 #include <linux/types.h>
14 #include <linux/miscdevice.h>
15 #include <asm/ccwdev.h>
16 #include "zfcp_def.h"
17 #include "zfcp_ext.h"
18 #include "zfcp_fsf.h"
19
20 #define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL 0x00010001
21 #define ZFCP_CFDC_CMND_DOWNLOAD_FORCE 0x00010101
22 #define ZFCP_CFDC_CMND_FULL_ACCESS 0x00000201
23 #define ZFCP_CFDC_CMND_RESTRICTED_ACCESS 0x00000401
24 #define ZFCP_CFDC_CMND_UPLOAD 0x00010002
25
26 #define ZFCP_CFDC_DOWNLOAD 0x00000001
27 #define ZFCP_CFDC_UPLOAD 0x00000002
28 #define ZFCP_CFDC_WITH_CONTROL_FILE 0x00010000
29
30 #define ZFCP_CFDC_IOC_MAGIC 0xDD
31 #define ZFCP_CFDC_IOC \
32 _IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_data)
33
34 /**
35 * struct zfcp_cfdc_data - data for ioctl cfdc interface
36 * @signature: request signature
37 * @devno: FCP adapter device number
38 * @command: command code
39 * @fsf_status: returns status of FSF command to userspace
40 * @fsf_status_qual: returned to userspace
41 * @payloads: access conflicts list
42 * @control_file: access control table
43 */
44 struct zfcp_cfdc_data {
45 u32 signature;
46 u32 devno;
47 u32 command;
48 u32 fsf_status;
49 u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
50 u8 payloads[256];
51 u8 control_file[0];
52 };
53
zfcp_cfdc_copy_from_user(struct scatterlist * sg,void __user * user_buffer)54 static int zfcp_cfdc_copy_from_user(struct scatterlist *sg,
55 void __user *user_buffer)
56 {
57 unsigned int length;
58 unsigned int size = ZFCP_CFDC_MAX_SIZE;
59
60 while (size) {
61 length = min((unsigned int)size, sg->length);
62 if (copy_from_user(sg_virt(sg++), user_buffer, length))
63 return -EFAULT;
64 user_buffer += length;
65 size -= length;
66 }
67 return 0;
68 }
69
zfcp_cfdc_copy_to_user(void __user * user_buffer,struct scatterlist * sg)70 static int zfcp_cfdc_copy_to_user(void __user *user_buffer,
71 struct scatterlist *sg)
72 {
73 unsigned int length;
74 unsigned int size = ZFCP_CFDC_MAX_SIZE;
75
76 while (size) {
77 length = min((unsigned int) size, sg->length);
78 if (copy_to_user(user_buffer, sg_virt(sg++), length))
79 return -EFAULT;
80 user_buffer += length;
81 size -= length;
82 }
83 return 0;
84 }
85
zfcp_cfdc_get_adapter(u32 devno)86 static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
87 {
88 char busid[9];
89 snprintf(busid, sizeof(busid), "0.0.%04x", devno);
90 return zfcp_get_adapter_by_busid(busid);
91 }
92
zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc * fsf_cfdc,int command)93 static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command)
94 {
95 switch (command) {
96 case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL:
97 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
98 fsf_cfdc->option = FSF_CFDC_OPTION_NORMAL_MODE;
99 break;
100 case ZFCP_CFDC_CMND_DOWNLOAD_FORCE:
101 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
102 fsf_cfdc->option = FSF_CFDC_OPTION_FORCE;
103 break;
104 case ZFCP_CFDC_CMND_FULL_ACCESS:
105 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
106 fsf_cfdc->option = FSF_CFDC_OPTION_FULL_ACCESS;
107 break;
108 case ZFCP_CFDC_CMND_RESTRICTED_ACCESS:
109 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
110 fsf_cfdc->option = FSF_CFDC_OPTION_RESTRICTED_ACCESS;
111 break;
112 case ZFCP_CFDC_CMND_UPLOAD:
113 fsf_cfdc->command = FSF_QTCB_UPLOAD_CONTROL_FILE;
114 fsf_cfdc->option = 0;
115 break;
116 default:
117 return -EINVAL;
118 }
119
120 return 0;
121 }
122
zfcp_cfdc_sg_setup(int command,struct scatterlist * sg,u8 __user * control_file)123 static int zfcp_cfdc_sg_setup(int command, struct scatterlist *sg,
124 u8 __user *control_file)
125 {
126 int retval;
127 retval = zfcp_sg_setup_table(sg, ZFCP_CFDC_PAGES);
128 if (retval)
129 return retval;
130
131 sg[ZFCP_CFDC_PAGES - 1].length = ZFCP_CFDC_MAX_SIZE % PAGE_SIZE;
132
133 if (command & ZFCP_CFDC_WITH_CONTROL_FILE &&
134 command & ZFCP_CFDC_DOWNLOAD) {
135 retval = zfcp_cfdc_copy_from_user(sg, control_file);
136 if (retval) {
137 zfcp_sg_free_table(sg, ZFCP_CFDC_PAGES);
138 return -EFAULT;
139 }
140 }
141
142 return 0;
143 }
144
zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data * data,struct zfcp_fsf_req * req)145 static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
146 struct zfcp_fsf_req *req)
147 {
148 data->fsf_status = req->qtcb->header.fsf_status;
149 memcpy(&data->fsf_status_qual, &req->qtcb->header.fsf_status_qual,
150 sizeof(union fsf_status_qual));
151 memcpy(&data->payloads, &req->qtcb->bottom.support.els,
152 sizeof(req->qtcb->bottom.support.els));
153 }
154
zfcp_cfdc_dev_ioctl(struct file * file,unsigned int command,unsigned long buffer)155 static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
156 unsigned long buffer)
157 {
158 struct zfcp_cfdc_data *data;
159 struct zfcp_cfdc_data __user *data_user;
160 struct zfcp_adapter *adapter;
161 struct zfcp_fsf_req *req;
162 struct zfcp_fsf_cfdc *fsf_cfdc;
163 int retval;
164
165 if (command != ZFCP_CFDC_IOC)
166 return -ENOTTY;
167
168 data_user = (void __user *) buffer;
169 if (!data_user)
170 return -EINVAL;
171
172 fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL);
173 if (!fsf_cfdc)
174 return -ENOMEM;
175
176 data = kmalloc(sizeof(struct zfcp_cfdc_data), GFP_KERNEL);
177 if (!data) {
178 retval = -ENOMEM;
179 goto no_mem_sense;
180 }
181
182 retval = copy_from_user(data, data_user, sizeof(*data));
183 if (retval) {
184 retval = -EFAULT;
185 goto free_buffer;
186 }
187
188 if (data->signature != 0xCFDCACDF) {
189 retval = -EINVAL;
190 goto free_buffer;
191 }
192
193 retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command);
194
195 adapter = zfcp_cfdc_get_adapter(data->devno);
196 if (!adapter) {
197 retval = -ENXIO;
198 goto free_buffer;
199 }
200
201 retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
202 data_user->control_file);
203 if (retval)
204 goto adapter_put;
205 req = zfcp_fsf_control_file(adapter, fsf_cfdc);
206 if (IS_ERR(req)) {
207 retval = PTR_ERR(req);
208 goto free_sg;
209 }
210
211 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
212 retval = -ENXIO;
213 goto free_fsf;
214 }
215
216 zfcp_cfdc_req_to_sense(data, req);
217 retval = copy_to_user(data_user, data, sizeof(*data_user));
218 if (retval) {
219 retval = -EFAULT;
220 goto free_fsf;
221 }
222
223 if (data->command & ZFCP_CFDC_UPLOAD)
224 retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
225 fsf_cfdc->sg);
226
227 free_fsf:
228 zfcp_fsf_req_free(req);
229 free_sg:
230 zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
231 adapter_put:
232 zfcp_adapter_put(adapter);
233 free_buffer:
234 kfree(data);
235 no_mem_sense:
236 kfree(fsf_cfdc);
237 return retval;
238 }
239
240 static const struct file_operations zfcp_cfdc_fops = {
241 .unlocked_ioctl = zfcp_cfdc_dev_ioctl,
242 #ifdef CONFIG_COMPAT
243 .compat_ioctl = zfcp_cfdc_dev_ioctl
244 #endif
245 };
246
247 struct miscdevice zfcp_cfdc_misc = {
248 .minor = MISC_DYNAMIC_MINOR,
249 .name = "zfcp_cfdc",
250 .fops = &zfcp_cfdc_fops,
251 };
252