drivers/usb/usbip/vhci_sysfs.c

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