~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/usb/usbip/libsrc/vhci_driver.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) 2005-2007 Takahiro Hirofuchi
  3  */
  4 
  5 #include "usbip_common.h"
  6 #include "vhci_driver.h"
  7 #include <limits.h>
  8 #include <netdb.h>
  9 #include <libudev.h>
 10 #include "sysfs_utils.h"
 11 
 12 #undef  PROGNAME
 13 #define PROGNAME "libusbip"
 14 
 15 struct usbip_vhci_driver *vhci_driver;
 16 struct udev *udev_context;
 17 
 18 static struct usbip_imported_device *
 19 imported_device_init(struct usbip_imported_device *idev, char *busid)
 20 {
 21         struct udev_device *sudev;
 22 
 23         sudev = udev_device_new_from_subsystem_sysname(udev_context,
 24                                                        "usb", busid);
 25         if (!sudev) {
 26                 dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
 27                 goto err;
 28         }
 29         read_usb_device(sudev, &idev->udev);
 30         udev_device_unref(sudev);
 31 
 32         return idev;
 33 
 34 err:
 35         return NULL;
 36 }
 37 
 38 
 39 
 40 static int parse_status(const char *value)
 41 {
 42         int ret = 0;
 43         char *c;
 44 
 45 
 46         for (int i = 0; i < vhci_driver->nports; i++)
 47                 memset(&vhci_driver->idev[i], 0, sizeof(vhci_driver->idev[i]));
 48 
 49 
 50         /* skip a header line */
 51         c = strchr(value, '\n');
 52         if (!c)
 53                 return -1;
 54         c++;
 55 
 56         while (*c != '\0') {
 57                 int port, status, speed, devid;
 58                 unsigned long socket;
 59                 char lbusid[SYSFS_BUS_ID_SIZE];
 60 
 61                 ret = sscanf(c, "%d %d %d %x %lx %31s\n",
 62                                 &port, &status, &speed,
 63                                 &devid, &socket, lbusid);
 64 
 65                 if (ret < 5) {
 66                         dbg("sscanf failed: %d", ret);
 67                         BUG();
 68                 }
 69 
 70                 dbg("port %d status %d speed %d devid %x",
 71                                 port, status, speed, devid);
 72                 dbg("socket %lx lbusid %s", socket, lbusid);
 73 
 74 
 75                 /* if a device is connected, look at it */
 76                 {
 77                         struct usbip_imported_device *idev = &vhci_driver->idev[port];
 78 
 79                         idev->port      = port;
 80                         idev->status    = status;
 81 
 82                         idev->devid     = devid;
 83 
 84                         idev->busnum    = (devid >> 16);
 85                         idev->devnum    = (devid & 0x0000ffff);
 86 
 87                         if (idev->status != VDEV_ST_NULL
 88                             && idev->status != VDEV_ST_NOTASSIGNED) {
 89                                 idev = imported_device_init(idev, lbusid);
 90                                 if (!idev) {
 91                                         dbg("imported_device_init failed");
 92                                         return -1;
 93                                 }
 94                         }
 95                 }
 96 
 97 
 98                 /* go to the next line */
 99                 c = strchr(c, '\n');
100                 if (!c)
101                         break;
102                 c++;
103         }
104 
105         dbg("exit");
106 
107         return 0;
108 }
109 
110 static int refresh_imported_device_list(void)
111 {
112         const char *attr_status;
113 
114         attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
115                                                "status");
116         if (!attr_status) {
117                 err("udev_device_get_sysattr_value failed");
118                 return -1;
119         }
120 
121         return parse_status(attr_status);
122 }
123 
124 static int get_nports(void)
125 {
126         char *c;
127         int nports = 0;
128         const char *attr_status;
129 
130         attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
131                                                "status");
132         if (!attr_status) {
133                 err("udev_device_get_sysattr_value failed");
134                 return -1;
135         }
136 
137         /* skip a header line */
138         c = strchr(attr_status, '\n');
139         if (!c)
140                 return 0;
141         c++;
142 
143         while (*c != '\0') {
144                 /* go to the next line */
145                 c = strchr(c, '\n');
146                 if (!c)
147                         return nports;
148                 c++;
149                 nports += 1;
150         }
151 
152         return nports;
153 }
154 
155 /*
156  * Read the given port's record.
157  *
158  * To avoid buffer overflow we will read the entire line and
159  * validate each part's size. The initial buffer is padded by 4 to
160  * accommodate the 2 spaces, 1 newline and an additional character
161  * which is needed to properly validate the 3rd part without it being
162  * truncated to an acceptable length.
163  */
164 static int read_record(int rhport, char *host, unsigned long host_len,
165                 char *port, unsigned long port_len, char *busid)
166 {
167         int part;
168         FILE *file;
169         char path[PATH_MAX+1];
170         char *buffer, *start, *end;
171         char delim[] = {' ', ' ', '\n'};
172         int max_len[] = {(int)host_len, (int)port_len, SYSFS_BUS_ID_SIZE};
173         size_t buffer_len = host_len + port_len + SYSFS_BUS_ID_SIZE + 4;
174 
175         buffer = malloc(buffer_len);
176         if (!buffer)
177                 return -1;
178 
179         snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport);
180 
181         file = fopen(path, "r");
182         if (!file) {
183                 err("fopen");
184                 free(buffer);
185                 return -1;
186         }
187 
188         if (fgets(buffer, buffer_len, file) == NULL) {
189                 err("fgets");
190                 free(buffer);
191                 fclose(file);
192                 return -1;
193         }
194         fclose(file);
195 
196         /* validate the length of each of the 3 parts */
197         start = buffer;
198         for (part = 0; part < 3; part++) {
199                 end = strchr(start, delim[part]);
200                 if (end == NULL || (end - start) > max_len[part]) {
201                         free(buffer);
202                         return -1;
203                 }
204                 start = end + 1;
205         }
206 
207         if (sscanf(buffer, "%s %s %s\n", host, port, busid) != 3) {
208                 err("sscanf");
209                 free(buffer);
210                 return -1;
211         }
212 
213         free(buffer);
214 
215         return 0;
216 }
217 
218 /* ---------------------------------------------------------------------- */
219 
220 int usbip_vhci_driver_open(void)
221 {
222         udev_context = udev_new();
223         if (!udev_context) {
224                 err("udev_new failed");
225                 return -1;
226         }
227 
228         vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver));
229 
230         /* will be freed in usbip_driver_close() */
231         vhci_driver->hc_device =
232                 udev_device_new_from_subsystem_sysname(udev_context,
233                                                        USBIP_VHCI_BUS_TYPE,
234                                                        USBIP_VHCI_DRV_NAME);
235         if (!vhci_driver->hc_device) {
236                 err("udev_device_new_from_subsystem_sysname failed");
237                 goto err;
238         }
239 
240         vhci_driver->nports = get_nports();
241 
242         dbg("available ports: %d", vhci_driver->nports);
243 
244         if (refresh_imported_device_list())
245                 goto err;
246 
247         return 0;
248 
249 err:
250         udev_device_unref(vhci_driver->hc_device);
251 
252         if (vhci_driver)
253                 free(vhci_driver);
254 
255         vhci_driver = NULL;
256 
257         udev_unref(udev_context);
258 
259         return -1;
260 }
261 
262 
263 void usbip_vhci_driver_close(void)
264 {
265         if (!vhci_driver)
266                 return;
267 
268         udev_device_unref(vhci_driver->hc_device);
269 
270         free(vhci_driver);
271 
272         vhci_driver = NULL;
273 
274         udev_unref(udev_context);
275 }
276 
277 
278 int usbip_vhci_refresh_device_list(void)
279 {
280 
281         if (refresh_imported_device_list())
282                 goto err;
283 
284         return 0;
285 err:
286         dbg("failed to refresh device list");
287         return -1;
288 }
289 
290 
291 int usbip_vhci_get_free_port(void)
292 {
293         for (int i = 0; i < vhci_driver->nports; i++) {
294                 if (vhci_driver->idev[i].status == VDEV_ST_NULL)
295                         return i;
296         }
297 
298         return -1;
299 }
300 
301 int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid,
302                 uint32_t speed) {
303         char buff[200]; /* what size should be ? */
304         char attach_attr_path[SYSFS_PATH_MAX];
305         char attr_attach[] = "attach";
306         const char *path;
307         int ret;
308 
309         snprintf(buff, sizeof(buff), "%u %d %u %u",
310                         port, sockfd, devid, speed);
311         dbg("writing: %s", buff);
312 
313         path = udev_device_get_syspath(vhci_driver->hc_device);
314         snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s",
315                  path, attr_attach);
316         dbg("attach attribute path: %s", attach_attr_path);
317 
318         ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff));
319         if (ret < 0) {
320                 dbg("write_sysfs_attribute failed");
321                 return -1;
322         }
323 
324         dbg("attached port: %d", port);
325 
326         return 0;
327 }
328 
329 static unsigned long get_devid(uint8_t busnum, uint8_t devnum)
330 {
331         return (busnum << 16) | devnum;
332 }
333 
334 /* will be removed */
335 int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum,
336                 uint8_t devnum, uint32_t speed)
337 {
338         int devid = get_devid(busnum, devnum);
339 
340         return usbip_vhci_attach_device2(port, sockfd, devid, speed);
341 }
342 
343 int usbip_vhci_detach_device(uint8_t port)
344 {
345         char detach_attr_path[SYSFS_PATH_MAX];
346         char attr_detach[] = "detach";
347         char buff[200]; /* what size should be ? */
348         const char *path;
349         int ret;
350 
351         snprintf(buff, sizeof(buff), "%u", port);
352         dbg("writing: %s", buff);
353 
354         path = udev_device_get_syspath(vhci_driver->hc_device);
355         snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s",
356                  path, attr_detach);
357         dbg("detach attribute path: %s", detach_attr_path);
358 
359         ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff));
360         if (ret < 0) {
361                 dbg("write_sysfs_attribute failed");
362                 return -1;
363         }
364 
365         dbg("detached port: %d", port);
366 
367         return 0;
368 }
369 
370 int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev)
371 {
372         char product_name[100];
373         char host[NI_MAXHOST] = "unknown host";
374         char serv[NI_MAXSERV] = "unknown port";
375         char remote_busid[SYSFS_BUS_ID_SIZE];
376         int ret;
377         int read_record_error = 0;
378 
379         if (idev->status == VDEV_ST_NULL || idev->status == VDEV_ST_NOTASSIGNED)
380                 return 0;
381 
382         ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv),
383                           remote_busid);
384         if (ret) {
385                 err("read_record");
386                 read_record_error = 1;
387         }
388 
389         printf("Port %02d: <%s> at %s\n", idev->port,
390                usbip_status_string(idev->status),
391                usbip_speed_string(idev->udev.speed));
392 
393         usbip_names_get_product(product_name, sizeof(product_name),
394                                 idev->udev.idVendor, idev->udev.idProduct);
395 
396         printf("       %s\n",  product_name);
397 
398         if (!read_record_error) {
399                 printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid,
400                        host, serv, remote_busid);
401                 printf("%10s -> remote bus/dev %03d/%03d\n", " ",
402                        idev->busnum, idev->devnum);
403         } else {
404                 printf("%10s -> unknown host, remote port and remote busid\n",
405                        idev->udev.busid);
406                 printf("%10s -> remote bus/dev %03d/%03d\n", " ",
407                        idev->busnum, idev->devnum);
408         }
409 
410         return 0;
411 }
412 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp