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