[SCSI] zfcp: Reference counting for cfdc requests
[linux-2.6] / 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/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
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
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
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
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
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
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
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         zfcp_adapter_get(adapter);
201
202         retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
203                                     data_user->control_file);
204         if (retval)
205                 goto adapter_put;
206         req = zfcp_fsf_control_file(adapter, fsf_cfdc);
207         if (IS_ERR(req)) {
208                 retval = PTR_ERR(req);
209                 goto free_sg;
210         }
211
212         if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
213                 retval = -ENXIO;
214                 goto free_fsf;
215         }
216
217         zfcp_cfdc_req_to_sense(data, req);
218         retval = copy_to_user(data_user, data, sizeof(*data_user));
219         if (retval) {
220                 retval = -EFAULT;
221                 goto free_fsf;
222         }
223
224         if (data->command & ZFCP_CFDC_UPLOAD)
225                 retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
226                                                 fsf_cfdc->sg);
227
228  free_fsf:
229         zfcp_fsf_req_free(req);
230  free_sg:
231         zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
232  adapter_put:
233         zfcp_adapter_put(adapter);
234  free_buffer:
235         kfree(data);
236  no_mem_sense:
237         kfree(fsf_cfdc);
238         return retval;
239 }
240
241 static const struct file_operations zfcp_cfdc_fops = {
242         .unlocked_ioctl = zfcp_cfdc_dev_ioctl,
243 #ifdef CONFIG_COMPAT
244         .compat_ioctl = zfcp_cfdc_dev_ioctl
245 #endif
246 };
247
248 struct miscdevice zfcp_cfdc_misc = {
249         .minor = MISC_DYNAMIC_MINOR,
250         .name = "zfcp_cfdc",
251         .fops = &zfcp_cfdc_fops,
252 };