Loading...
Note: File does not exist in v3.1.
1/*
2 * Copyright (C) 2003-2008 Takahiro Hirofuchi
3 * Copyright (C) 2015-2016 Nobuo Iwata
4 *
5 * This is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18 * USA.
19 */
20
21#include <linux/kthread.h>
22#include <linux/file.h>
23#include <linux/net.h>
24#include <linux/platform_device.h>
25#include <linux/slab.h>
26
27#include "usbip_common.h"
28#include "vhci.h"
29
30/* TODO: refine locking ?*/
31
32/* Sysfs entry to show port status */
33static ssize_t status_show_vhci(int pdev_nr, char *out)
34{
35 struct platform_device *pdev = *(vhci_pdevs + pdev_nr);
36 struct vhci_hcd *vhci;
37 char *s = out;
38 int i = 0;
39 unsigned long flags;
40
41 if (!pdev || !out) {
42 usbip_dbg_vhci_sysfs("show status error\n");
43 return 0;
44 }
45
46 vhci = hcd_to_vhci(platform_get_drvdata(pdev));
47
48 spin_lock_irqsave(&vhci->lock, flags);
49
50 /*
51 * output example:
52 * port sta spd dev socket local_busid
53 * 0000 004 000 00000000 c5a7bb80 1-2.3
54 * 0001 004 000 00000000 d8cee980 2-3.4
55 *
56 * IP address can be retrieved from a socket pointer address by looking
57 * up /proc/net/{tcp,tcp6}. Also, a userland program may remember a
58 * port number and its peer IP address.
59 */
60 for (i = 0; i < VHCI_HC_PORTS; i++) {
61 struct vhci_device *vdev = &vhci->vdev[i];
62
63 spin_lock(&vdev->ud.lock);
64 out += sprintf(out, "%04u %03u ",
65 (pdev_nr * VHCI_HC_PORTS) + i,
66 vdev->ud.status);
67
68 if (vdev->ud.status == VDEV_ST_USED) {
69 out += sprintf(out, "%03u %08x ",
70 vdev->speed, vdev->devid);
71 out += sprintf(out, "%16p %s",
72 vdev->ud.tcp_socket,
73 dev_name(&vdev->udev->dev));
74
75 } else {
76 out += sprintf(out, "000 00000000 ");
77 out += sprintf(out, "0000000000000000 0-0");
78 }
79
80 out += sprintf(out, "\n");
81 spin_unlock(&vdev->ud.lock);
82 }
83
84 spin_unlock_irqrestore(&vhci->lock, flags);
85
86 return out - s;
87}
88
89static ssize_t status_show_not_ready(int pdev_nr, char *out)
90{
91 char *s = out;
92 int i = 0;
93
94 for (i = 0; i < VHCI_HC_PORTS; i++) {
95 out += sprintf(out, "%04u %03u ",
96 (pdev_nr * VHCI_HC_PORTS) + i,
97 VDEV_ST_NOTASSIGNED);
98 out += sprintf(out, "000 00000000 0000000000000000 0-0");
99 out += sprintf(out, "\n");
100 }
101 return out - s;
102}
103
104static int status_name_to_id(const char *name)
105{
106 char *c;
107 long val;
108 int ret;
109
110 c = strchr(name, '.');
111 if (c == NULL)
112 return 0;
113
114 ret = kstrtol(c+1, 10, &val);
115 if (ret < 0)
116 return ret;
117
118 return val;
119}
120
121static ssize_t status_show(struct device *dev,
122 struct device_attribute *attr, char *out)
123{
124 char *s = out;
125 int pdev_nr;
126
127 out += sprintf(out,
128 "port sta spd dev socket local_busid\n");
129
130 pdev_nr = status_name_to_id(attr->attr.name);
131 if (pdev_nr < 0)
132 out += status_show_not_ready(pdev_nr, out);
133 else
134 out += status_show_vhci(pdev_nr, out);
135
136 return out - s;
137}
138
139static ssize_t nports_show(struct device *dev, struct device_attribute *attr,
140 char *out)
141{
142 char *s = out;
143
144 out += sprintf(out, "%d\n", VHCI_HC_PORTS * vhci_num_controllers);
145 return out - s;
146}
147static DEVICE_ATTR_RO(nports);
148
149/* Sysfs entry to shutdown a virtual connection */
150static int vhci_port_disconnect(struct vhci_hcd *vhci, __u32 rhport)
151{
152 struct vhci_device *vdev = &vhci->vdev[rhport];
153 unsigned long flags;
154
155 usbip_dbg_vhci_sysfs("enter\n");
156
157 /* lock */
158 spin_lock_irqsave(&vhci->lock, flags);
159 spin_lock(&vdev->ud.lock);
160
161 if (vdev->ud.status == VDEV_ST_NULL) {
162 pr_err("not connected %d\n", vdev->ud.status);
163
164 /* unlock */
165 spin_unlock(&vdev->ud.lock);
166 spin_unlock_irqrestore(&vhci->lock, flags);
167
168 return -EINVAL;
169 }
170
171 /* unlock */
172 spin_unlock(&vdev->ud.lock);
173 spin_unlock_irqrestore(&vhci->lock, flags);
174
175 usbip_event_add(&vdev->ud, VDEV_EVENT_DOWN);
176
177 return 0;
178}
179
180static int valid_port(__u32 pdev_nr, __u32 rhport)
181{
182 if (pdev_nr >= vhci_num_controllers) {
183 pr_err("pdev %u\n", pdev_nr);
184 return 0;
185 }
186 if (rhport >= VHCI_HC_PORTS) {
187 pr_err("rhport %u\n", rhport);
188 return 0;
189 }
190 return 1;
191}
192
193static ssize_t store_detach(struct device *dev, struct device_attribute *attr,
194 const char *buf, size_t count)
195{
196 __u32 port = 0, pdev_nr = 0, rhport = 0;
197 struct usb_hcd *hcd;
198 int ret;
199
200 if (kstrtoint(buf, 10, &port) < 0)
201 return -EINVAL;
202
203 pdev_nr = port_to_pdev_nr(port);
204 rhport = port_to_rhport(port);
205
206 if (!valid_port(pdev_nr, rhport))
207 return -EINVAL;
208
209 hcd = platform_get_drvdata(*(vhci_pdevs + pdev_nr));
210 if (hcd == NULL) {
211 dev_err(dev, "port is not ready %u\n", port);
212 return -EAGAIN;
213 }
214
215 ret = vhci_port_disconnect(hcd_to_vhci(hcd), rhport);
216 if (ret < 0)
217 return -EINVAL;
218
219 usbip_dbg_vhci_sysfs("Leave\n");
220
221 return count;
222}
223static DEVICE_ATTR(detach, S_IWUSR, NULL, store_detach);
224
225static int valid_args(__u32 pdev_nr, __u32 rhport, enum usb_device_speed speed)
226{
227 if (!valid_port(pdev_nr, rhport)) {
228 return 0;
229 }
230
231 switch (speed) {
232 case USB_SPEED_LOW:
233 case USB_SPEED_FULL:
234 case USB_SPEED_HIGH:
235 case USB_SPEED_WIRELESS:
236 break;
237 default:
238 pr_err("Failed attach request for unsupported USB speed: %s\n",
239 usb_speed_string(speed));
240 return 0;
241 }
242
243 return 1;
244}
245
246/* Sysfs entry to establish a virtual connection */
247/*
248 * To start a new USB/IP attachment, a userland program needs to setup a TCP
249 * connection and then write its socket descriptor with remote device
250 * information into this sysfs file.
251 *
252 * A remote device is virtually attached to the root-hub port of @rhport with
253 * @speed. @devid is embedded into a request to specify the remote device in a
254 * server host.
255 *
256 * write() returns 0 on success, else negative errno.
257 */
258static ssize_t store_attach(struct device *dev, struct device_attribute *attr,
259 const char *buf, size_t count)
260{
261 struct socket *socket;
262 int sockfd = 0;
263 __u32 port = 0, pdev_nr = 0, rhport = 0, devid = 0, speed = 0;
264 struct usb_hcd *hcd;
265 struct vhci_hcd *vhci;
266 struct vhci_device *vdev;
267 int err;
268 unsigned long flags;
269
270 /*
271 * @rhport: port number of vhci_hcd
272 * @sockfd: socket descriptor of an established TCP connection
273 * @devid: unique device identifier in a remote host
274 * @speed: usb device speed in a remote host
275 */
276 if (sscanf(buf, "%u %u %u %u", &port, &sockfd, &devid, &speed) != 4)
277 return -EINVAL;
278 pdev_nr = port_to_pdev_nr(port);
279 rhport = port_to_rhport(port);
280
281 usbip_dbg_vhci_sysfs("port(%u) pdev(%d) rhport(%u)\n",
282 port, pdev_nr, rhport);
283 usbip_dbg_vhci_sysfs("sockfd(%u) devid(%u) speed(%u)\n",
284 sockfd, devid, speed);
285
286 /* check received parameters */
287 if (!valid_args(pdev_nr, rhport, speed))
288 return -EINVAL;
289
290 hcd = platform_get_drvdata(*(vhci_pdevs + pdev_nr));
291 if (hcd == NULL) {
292 dev_err(dev, "port %d is not ready\n", port);
293 return -EAGAIN;
294 }
295 vhci = hcd_to_vhci(hcd);
296 vdev = &vhci->vdev[rhport];
297
298 /* Extract socket from fd. */
299 socket = sockfd_lookup(sockfd, &err);
300 if (!socket)
301 return -EINVAL;
302
303 /* now need lock until setting vdev status as used */
304
305 /* begin a lock */
306 spin_lock_irqsave(&vhci->lock, flags);
307 spin_lock(&vdev->ud.lock);
308
309 if (vdev->ud.status != VDEV_ST_NULL) {
310 /* end of the lock */
311 spin_unlock(&vdev->ud.lock);
312 spin_unlock_irqrestore(&vhci->lock, flags);
313
314 sockfd_put(socket);
315
316 dev_err(dev, "port %d already used\n", rhport);
317 return -EINVAL;
318 }
319
320 dev_info(dev, "pdev(%u) rhport(%u) sockfd(%d)\n",
321 pdev_nr, rhport, sockfd);
322 dev_info(dev, "devid(%u) speed(%u) speed_str(%s)\n",
323 devid, speed, usb_speed_string(speed));
324
325 vdev->devid = devid;
326 vdev->speed = speed;
327 vdev->ud.tcp_socket = socket;
328 vdev->ud.status = VDEV_ST_NOTASSIGNED;
329
330 spin_unlock(&vdev->ud.lock);
331 spin_unlock_irqrestore(&vhci->lock, flags);
332 /* end the lock */
333
334 vdev->ud.tcp_rx = kthread_get_run(vhci_rx_loop, &vdev->ud, "vhci_rx");
335 vdev->ud.tcp_tx = kthread_get_run(vhci_tx_loop, &vdev->ud, "vhci_tx");
336
337 rh_port_connect(vdev, speed);
338
339 return count;
340}
341static DEVICE_ATTR(attach, S_IWUSR, NULL, store_attach);
342
343#define MAX_STATUS_NAME 16
344
345struct status_attr {
346 struct device_attribute attr;
347 char name[MAX_STATUS_NAME+1];
348};
349
350static struct status_attr *status_attrs;
351
352static void set_status_attr(int id)
353{
354 struct status_attr *status;
355
356 status = status_attrs + id;
357 if (id == 0)
358 strcpy(status->name, "status");
359 else
360 snprintf(status->name, MAX_STATUS_NAME+1, "status.%d", id);
361 status->attr.attr.name = status->name;
362 status->attr.attr.mode = S_IRUGO;
363 status->attr.show = status_show;
364 sysfs_attr_init(&status->attr.attr);
365}
366
367static int init_status_attrs(void)
368{
369 int id;
370
371 status_attrs = kcalloc(vhci_num_controllers, sizeof(struct status_attr),
372 GFP_KERNEL);
373 if (status_attrs == NULL)
374 return -ENOMEM;
375
376 for (id = 0; id < vhci_num_controllers; id++)
377 set_status_attr(id);
378
379 return 0;
380}
381
382static void finish_status_attrs(void)
383{
384 kfree(status_attrs);
385}
386
387struct attribute_group vhci_attr_group = {
388 .attrs = NULL,
389};
390
391int vhci_init_attr_group(void)
392{
393 struct attribute **attrs;
394 int ret, i;
395
396 attrs = kcalloc((vhci_num_controllers + 5), sizeof(struct attribute *),
397 GFP_KERNEL);
398 if (attrs == NULL)
399 return -ENOMEM;
400
401 ret = init_status_attrs();
402 if (ret) {
403 kfree(attrs);
404 return ret;
405 }
406 *attrs = &dev_attr_nports.attr;
407 *(attrs + 1) = &dev_attr_detach.attr;
408 *(attrs + 2) = &dev_attr_attach.attr;
409 *(attrs + 3) = &dev_attr_usbip_debug.attr;
410 for (i = 0; i < vhci_num_controllers; i++)
411 *(attrs + i + 4) = &((status_attrs + i)->attr.attr);
412 vhci_attr_group.attrs = attrs;
413 return 0;
414}
415
416void vhci_finish_attr_group(void)
417{
418 finish_status_attrs();
419 kfree(vhci_attr_group.attrs);
420}