tools/usb/usbip/src/usbip_bind.c

   1 /*
   2  * Copyright (C) 2011 matt mooney <[email protected]>
   3  *               2005-2007 Takahiro Hirofuchi
   4  *
   5  * This program 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 program 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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <libudev.h>
  20
  21 #include <errno.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include <getopt.h>
  27
  28 #include "usbip_common.h"
  29 #include "utils.h"
  30 #include "usbip.h"
  31 #include "sysfs_utils.h"
  32
  33 enum unbind_status {
  34         UNBIND_ST_OK,
  35         UNBIND_ST_USBIP_HOST,
  36         UNBIND_ST_FAILED
  37 };
  38
  39 static const char usbip_bind_usage_string[] =
  40         "usbip bind <args>\n"
  41         "    -b, --busid=<busid>    Bind " USBIP_HOST_DRV_NAME ".ko to device "
  42         "on <busid>\n";
  43
  44 void usbip_bind_usage(void)
  45 {
  46         printf("usage: %s", usbip_bind_usage_string);
  47 }
  48
  49 /* call at unbound state */
  50 static int bind_usbip(char *busid)
  51 {
  52         char attr_name[] = "bind";
  53         char bind_attr_path[SYSFS_PATH_MAX];
  54         int rc = -1;
  55
  56         snprintf(bind_attr_path, sizeof(bind_attr_path), "%s/%s/%s/%s/%s/%s",
  57                  SYSFS_MNT_PATH, SYSFS_BUS_NAME, SYSFS_BUS_TYPE,
  58                  SYSFS_DRIVERS_NAME, USBIP_HOST_DRV_NAME, attr_name);
  59
  60         rc = write_sysfs_attribute(bind_attr_path, busid, strlen(busid));
  61         if (rc < 0) {
  62                 err("error binding device %s to driver: %s", busid,
  63                     strerror(errno));
  64                 return -1;
  65         }
  66
  67         return 0;
  68 }
  69
  70 /* buggy driver may cause dead lock */
  71 static int unbind_other(char *busid)
  72 {
  73         enum unbind_status status = UNBIND_ST_OK;
  74
  75         char attr_name[] = "unbind";
  76         char unbind_attr_path[SYSFS_PATH_MAX];
  77         int rc = -1;
  78
  79         struct udev *udev;
  80         struct udev_device *dev;
  81         const char *driver;
  82         const char *bDevClass;
  83
  84         /* Create libudev context. */
  85         udev = udev_new();
  86
  87         /* Get the device. */
  88         dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid);
  89         if (!dev) {
  90                 dbg("unable to find device with bus ID %s", busid);
  91                 goto err_close_busid_dev;
  92         }
  93
  94         /* Check what kind of device it is. */
  95         bDevClass  = udev_device_get_sysattr_value(dev, "bDeviceClass");
  96         if (!bDevClass) {
  97                 dbg("unable to get bDevClass device attribute");
  98                 goto err_close_busid_dev;
  99         }
 100
 101         if (!strncmp(bDevClass, "09", strlen(bDevClass))) {
 102                 dbg("skip unbinding of hub");
 103                 goto err_close_busid_dev;
 104         }
 105
 106         /* Get the device driver. */
 107         driver = udev_device_get_driver(dev);
 108         if (!driver) {
 109                 /* No driver bound to this device. */
 110                 goto out;
 111         }
 112
 113         if (!strncmp(USBIP_HOST_DRV_NAME, driver,
 114                                 strlen(USBIP_HOST_DRV_NAME))) {
 115                 /* Already bound to usbip-host. */
 116                 status = UNBIND_ST_USBIP_HOST;
 117                 goto out;
 118         }
 119
 120         /* Unbind device from driver. */
 121         snprintf(unbind_attr_path, sizeof(unbind_attr_path), "%s/%s/%s/%s/%s/%s",
 122                  SYSFS_MNT_PATH, SYSFS_BUS_NAME, SYSFS_BUS_TYPE,
 123                  SYSFS_DRIVERS_NAME, driver, attr_name);
 124
 125         rc = write_sysfs_attribute(unbind_attr_path, busid, strlen(busid));
 126         if (rc < 0) {
 127                 err("error unbinding device %s from driver", busid);
 128                 goto err_close_busid_dev;
 129         }
 130
 131         goto out;
 132
 133 err_close_busid_dev:
 134         status = UNBIND_ST_FAILED;
 135 out:
 136         udev_device_unref(dev);
 137         udev_unref(udev);
 138
 139         return status;
 140 }
 141
 142 static int bind_device(char *busid)
 143 {
 144         int rc;
 145         struct udev *udev;
 146         struct udev_device *dev;
 147         const char *devpath;
 148
 149         /* Check whether the device with this bus ID exists. */
 150         udev = udev_new();
 151         dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid);
 152         if (!dev) {
 153                 err("device with the specified bus ID does not exist");
 154                 return -1;
 155         }
 156         devpath = udev_device_get_devpath(dev);
 157         udev_unref(udev);
 158
 159         /* If the device is already attached to vhci_hcd - bail out */
 160         if (strstr(devpath, USBIP_VHCI_DRV_NAME)) {
 161                 err("bind loop detected: device: %s is attached to %s\n",
 162                     devpath, USBIP_VHCI_DRV_NAME);
 163                 return -1;
 164         }
 165
 166         rc = unbind_other(busid);
 167         if (rc == UNBIND_ST_FAILED) {
 168                 err("could not unbind driver from device on busid %s", busid);
 169                 return -1;
 170         } else if (rc == UNBIND_ST_USBIP_HOST) {
 171                 err("device on busid %s is already bound to %s", busid,
 172                     USBIP_HOST_DRV_NAME);
 173                 return -1;
 174         }
 175
 176         rc = modify_match_busid(busid, 1);
 177         if (rc < 0) {
 178                 err("unable to bind device on %s", busid);
 179                 return -1;
 180         }
 181
 182         rc = bind_usbip(busid);
 183         if (rc < 0) {
 184                 err("could not bind device to %s", USBIP_HOST_DRV_NAME);
 185                 modify_match_busid(busid, 0);
 186                 return -1;
 187         }
 188
 189         info("bind device on busid %s: complete", busid);
 190
 191         return 0;
 192 }
 193
 194 int usbip_bind(int argc, char *argv[])
 195 {
 196         static const struct option opts[] = {
 197                 { "busid", required_argument, NULL, 'b' },
 198                 { NULL,    0,                 NULL,  0  }
 199         };
 200
 201         int opt;
 202         int ret = -1;
 203
 204         for (;;) {
 205                 opt = getopt_long(argc, argv, "b:", opts, NULL);
 206
 207                 if (opt == -1)
 208                         break;
 209
 210                 switch (opt) {
 211                 case 'b':
 212                         ret = bind_device(optarg);
 213                         goto out;
 214                 default:
 215                         goto err_out;
 216                 }
 217         }
 218
 219 err_out:
 220         usbip_bind_usage();
 221 out:
 222         return ret;
 223 }