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 148 /* Check whether the device with this bus ID exists. */ 149 udev = udev_new(); 150 dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid); 151 if (!dev) { 152 err("device with the specified bus ID does not exist"); 153 return -1; 154 } 155 udev_unref(udev); 156 157 rc = unbind_other(busid); 158 if (rc == UNBIND_ST_FAILED) { 159 err("could not unbind driver from device on busid %s", busid); 160 return -1; 161 } else if (rc == UNBIND_ST_USBIP_HOST) { 162 err("device on busid %s is already bound to %s", busid, 163 USBIP_HOST_DRV_NAME); 164 return -1; 165 } 166 167 rc = modify_match_busid(busid, 1); 168 if (rc < 0) { 169 err("unable to bind device on %s", busid); 170 return -1; 171 } 172 173 rc = bind_usbip(busid); 174 if (rc < 0) { 175 err("could not bind device to %s", USBIP_HOST_DRV_NAME); 176 modify_match_busid(busid, 0); 177 return -1; 178 } 179 180 info("bind device on busid %s: complete", busid); 181 182 return 0; 183 } 184 185 int usbip_bind(int argc, char *argv[]) 186 { 187 static const struct option opts[] = { 188 { "busid", required_argument, NULL, 'b' }, 189 { NULL, 0, NULL, 0 } 190 }; 191 192 int opt; 193 int ret = -1; 194 195 for (;;) { 196 opt = getopt_long(argc, argv, "b:", opts, NULL); 197 198 if (opt == -1) 199 break; 200 201 switch (opt) { 202 case 'b': 203 ret = bind_device(optarg); 204 goto out; 205 default: 206 goto err_out; 207 } 208 } 209 210 err_out: 211 usbip_bind_usage(); 212 out: 213 return ret; 214 } 215