drivers/staging/usbip/userspace/libsrc/usbip_host_driver.c

   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 <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <fcntl.h>
  22
  23 #include <errno.h>
  24 #include <unistd.h>
  25
  26 #include <libudev.h>
  27
  28 #include "usbip_common.h"
  29 #include "usbip_host_driver.h"
  30 #include "list.h"
  31 #include "sysfs_utils.h"
  32
  33 #undef  PROGNAME
  34 #define PROGNAME "libusbip"
  35
  36 struct usbip_host_driver *host_driver;
  37 struct udev *udev_context;
  38
  39 static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
  40 {
  41         char status_attr_path[SYSFS_PATH_MAX];
  42         int fd;
  43         int length;
  44         char status;
  45         int value = 0;
  46
  47         snprintf(status_attr_path, SYSFS_PATH_MAX, "%s/usbip_status",
  48                  udev->path);
  49
  50         if ((fd = open(status_attr_path, O_RDONLY)) < 0) {
  51                 err("error opening attribute %s", status_attr_path);
  52                 return -1;
  53         }
  54
  55         length = read(fd, &status, 1);
  56         if (length < 0) {
  57                 err("error reading attribute %s", status_attr_path);
  58                 close(fd);
  59                 return -1;
  60         }
  61
  62         value = atoi(&status);
  63
  64         return value;
  65 }
  66
  67 static
  68 struct usbip_exported_device *usbip_exported_device_new(const char *sdevpath)
  69 {
  70         struct usbip_exported_device *edev = NULL;
  71         struct usbip_exported_device *edev_old;
  72         size_t size;
  73         int i;
  74
  75         edev = calloc(1, sizeof(struct usbip_exported_device));
  76
  77         edev->sudev = udev_device_new_from_syspath(udev_context, sdevpath);
  78         if (!edev->sudev) {
  79                 err("udev_device_new_from_syspath: %s", sdevpath);
  80                 goto err;
  81         }
  82
  83         read_usb_device(edev->sudev, &edev->udev);
  84
  85         edev->status = read_attr_usbip_status(&edev->udev);
  86         if (edev->status < 0)
  87                 goto err;
  88
  89         /* reallocate buffer to include usb interface data */
  90         size = sizeof(struct usbip_exported_device) + edev->udev.bNumInterfaces *
  91                 sizeof(struct usbip_usb_interface);
  92
  93         edev_old = edev;
  94         edev = realloc(edev, size);
  95         if (!edev) {
  96                 edev = edev_old;
  97                 dbg("realloc failed");
  98                 goto err;
  99         }
 100
 101         for (i = 0; i < edev->udev.bNumInterfaces; i++)
 102                 read_usb_interface(&edev->udev, i, &edev->uinf[i]);
 103
 104         return edev;
 105 err:
 106         if (edev->sudev)
 107                 udev_device_unref(edev->sudev);
 108         if (edev)
 109                 free(edev);
 110
 111         return NULL;
 112 }
 113
 114 static int refresh_exported_devices(void)
 115 {
 116         struct usbip_exported_device *edev;
 117         struct udev_enumerate *enumerate;
 118         struct udev_list_entry *devices, *dev_list_entry;
 119         struct udev_device *dev;
 120         const char *path;
 121
 122         enumerate = udev_enumerate_new(udev_context);
 123         udev_enumerate_add_match_subsystem(enumerate, "usb");
 124         udev_enumerate_scan_devices(enumerate);
 125
 126         devices = udev_enumerate_get_list_entry(enumerate);
 127
 128         udev_list_entry_foreach(dev_list_entry, devices) {
 129                 path = udev_list_entry_get_name(dev_list_entry);
 130                 dev = udev_device_new_from_syspath(udev_context, path);
 131
 132                 /* Check whether device uses usbip-host driver. */
 133                 if (!strcmp(udev_device_get_driver(dev),
 134                             USBIP_HOST_DRV_NAME)) {
 135                         edev = usbip_exported_device_new(path);
 136                         if (!edev) {
 137                                 dbg("usbip_exported_device_new failed");
 138                                 continue;
 139                         }
 140
 141                         list_add(&edev->node, &host_driver->edev_list);
 142                         host_driver->ndevs++;
 143                 }
 144         }
 145
 146         return 0;
 147 }
 148
 149 static void usbip_exported_device_destroy(void)
 150 {
 151         struct list_head *i, *tmp;
 152         struct usbip_exported_device *edev;
 153
 154         list_for_each_safe(i, tmp, &host_driver->edev_list) {
 155                 edev = list_entry(i, struct usbip_exported_device, node);
 156                 list_del(i);
 157                 free(edev);
 158         }
 159 }
 160
 161 int usbip_host_driver_open(void)
 162 {
 163         int rc;
 164
 165         udev_context = udev_new();
 166         if (!udev_context) {
 167                 err("udev_new failed");
 168                 return -1;
 169         }
 170
 171         host_driver = calloc(1, sizeof(*host_driver));
 172
 173         host_driver->ndevs = 0;
 174         INIT_LIST_HEAD(&host_driver->edev_list);
 175
 176         rc = refresh_exported_devices();
 177         if (rc < 0)
 178                 goto err_free_host_driver;
 179
 180         return 0;
 181
 182 err_free_host_driver:
 183         free(host_driver);
 184         host_driver = NULL;
 185
 186         udev_unref(udev_context);
 187
 188         return -1;
 189 }
 190
 191 void usbip_host_driver_close(void)
 192 {
 193         if (!host_driver)
 194                 return;
 195
 196         usbip_exported_device_destroy();
 197
 198         free(host_driver);
 199         host_driver = NULL;
 200
 201         udev_unref(udev_context);
 202 }
 203
 204 int usbip_host_refresh_device_list(void)
 205 {
 206         int rc;
 207
 208         usbip_exported_device_destroy();
 209
 210         host_driver->ndevs = 0;
 211         INIT_LIST_HEAD(&host_driver->edev_list);
 212
 213         rc = refresh_exported_devices();
 214         if (rc < 0)
 215                 return -1;
 216
 217         return 0;
 218 }
 219
 220 int usbip_host_export_device(struct usbip_exported_device *edev, int sockfd)
 221 {
 222         char attr_name[] = "usbip_sockfd";
 223         char sockfd_attr_path[SYSFS_PATH_MAX];
 224         char sockfd_buff[30];
 225         int ret;
 226
 227         if (edev->status != SDEV_ST_AVAILABLE) {
 228                 dbg("device not available: %s", edev->udev.busid);
 229                 switch (edev->status) {
 230                 case SDEV_ST_ERROR:
 231                         dbg("status SDEV_ST_ERROR");
 232                         break;
 233                 case SDEV_ST_USED:
 234                         dbg("status SDEV_ST_USED");
 235                         break;
 236                 default:
 237                         dbg("status unknown: 0x%x", edev->status);
 238                 }
 239                 return -1;
 240         }
 241
 242         /* only the first interface is true */
 243         snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
 244                  edev->udev.path, attr_name);
 245
 246         snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
 247
 248         ret = write_sysfs_attribute(sockfd_attr_path, sockfd_buff,
 249                                     strlen(sockfd_buff));
 250         if (ret < 0) {
 251                 err("write_sysfs_attribute failed: sockfd %s to %s",
 252                     sockfd_buff, sockfd_attr_path);
 253                 return ret;
 254         }
 255
 256         info("connect: %s", edev->udev.busid);
 257
 258         return ret;
 259 }
 260
 261 struct usbip_exported_device *usbip_host_get_device(int num)
 262 {
 263         struct list_head *i;
 264         struct usbip_exported_device *edev;
 265         int cnt = 0;
 266
 267         list_for_each(i, &host_driver->edev_list) {
 268                 edev = list_entry(i, struct usbip_exported_device, node);
 269                 if (num == cnt)
 270                         return edev;
 271                 else
 272                         cnt++;
 273         }
 274
 275         return NULL;
 276 }