1 /* 2 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com> 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 } 224