staging: usbip: userspace: migrate usbip_host_driver to libudev
authorValentina Manea <valentina.manea.m@gmail.com>
Sat, 8 Mar 2014 12:53:26 +0000 (14:53 +0200)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Sun, 9 Mar 2014 06:46:42 +0000 (22:46 -0800)
This patch modifies usbip_host_driver to use libudev.

Signed-off-by: Valentina Manea <valentina.manea.m@gmail.com>
Reviewed-by: Shuah Khan <shuah.kh@samsung.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/staging/usbip/userspace/libsrc/usbip_common.c
drivers/staging/usbip/userspace/libsrc/usbip_common.h
drivers/staging/usbip/userspace/libsrc/usbip_host_driver.c
drivers/staging/usbip/userspace/libsrc/usbip_host_driver.h
drivers/staging/usbip/userspace/libsrc/vhci_driver.c
drivers/staging/usbip/userspace/src/usbipd.c

index 6620d185d4bf06e55bae6bc1cc197aa8d4e1c743..998c11c6b32398157ac0072b26b1195e70334708 100644 (file)
@@ -2,6 +2,7 @@
  * Copyright (C) 2005-2007 Takahiro Hirofuchi
  */
 
+#include <libudev.h>
 #include "usbip_common.h"
 #include "names.h"
 
@@ -12,6 +13,8 @@ int usbip_use_syslog;
 int usbip_use_stderr;
 int usbip_use_debug;
 
+extern struct udev *udev_context;
+
 struct speed_string {
        int num;
        char *speed;
@@ -111,75 +114,48 @@ void dump_usb_device(struct usbip_usb_device *udev)
 }
 
 
-int read_attr_value(struct sysfs_device *dev, const char *name,
+int read_attr_value(struct udev_device *dev, const char *name,
                    const char *format)
 {
-       char attrpath[SYSFS_PATH_MAX];
-       struct sysfs_attribute *attr;
+       const char *attr;
        int num = 0;
        int ret;
 
-       snprintf(attrpath, sizeof(attrpath), "%s/%s", dev->path, name);
-
-       attr = sysfs_open_attribute(attrpath);
+       attr = udev_device_get_sysattr_value(dev, name);
        if (!attr) {
-               dbg("sysfs_open_attribute failed: %s", attrpath);
-               return 0;
-       }
-
-       ret = sysfs_read_attribute(attr);
-       if (ret < 0) {
-               dbg("sysfs_read_attribute failed");
+               err("udev_device_get_sysattr_value failed");
                goto err;
        }
 
-       ret = sscanf(attr->value, format, &num);
+       ret = sscanf(attr, format, &num);
        if (ret < 1) {
-               dbg("sscanf failed");
+               err("sscanf failed");
                goto err;
        }
 
 err:
-       sysfs_close_attribute(attr);
 
        return num;
 }
 
 
-int read_attr_speed(struct sysfs_device *dev)
+int read_attr_speed(struct udev_device *dev)
 {
-       char attrpath[SYSFS_PATH_MAX];
-       struct sysfs_attribute *attr;
-       char speed[100];
-       int ret;
-
-       snprintf(attrpath, sizeof(attrpath), "%s/%s", dev->path, "speed");
-
-       attr = sysfs_open_attribute(attrpath);
-       if (!attr) {
-               dbg("sysfs_open_attribute failed: %s", attrpath);
-               return 0;
-       }
+       const char *speed;
 
-       ret = sysfs_read_attribute(attr);
-       if (ret < 0) {
-               dbg("sysfs_read_attribute failed");
+       speed = udev_device_get_sysattr_value(dev, "speed");
+       if (!speed) {
+               err("udev_device_get_sysattr_value failed");
                goto err;
        }
 
-       ret = sscanf(attr->value, "%99s\n", speed);
-       if (ret < 1) {
-               dbg("sscanf failed");
-               goto err;
-       }
-err:
-       sysfs_close_attribute(attr);
-
        for (int i = 0; speed_strings[i].speed != NULL; i++) {
                if (!strcmp(speed, speed_strings[i].speed))
                        return speed_strings[i].num;
        }
 
+err:
+
        return USB_SPEED_UNKNOWN;
 }
 
@@ -190,9 +166,10 @@ err:
        } while (0)
 
 
-int read_usb_device(struct sysfs_device *sdev, struct usbip_usb_device *udev)
+int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev)
 {
        uint32_t busnum, devnum;
+       const char *path, *name;
 
        READ_ATTR(udev, uint8_t,  sdev, bDeviceClass,           "%02x\n");
        READ_ATTR(udev, uint8_t,  sdev, bDeviceSubClass,        "%02x\n");
@@ -209,10 +186,13 @@ int read_usb_device(struct sysfs_device *sdev, struct usbip_usb_device *udev)
        READ_ATTR(udev, uint8_t,  sdev, devnum,                 "%d\n");
        udev->speed = read_attr_speed(sdev);
 
-       strncpy(udev->path,  sdev->path,  SYSFS_PATH_MAX);
-       strncpy(udev->busid, sdev->name, SYSFS_BUS_ID_SIZE);
+       path = udev_device_get_syspath(sdev);
+       name = udev_device_get_sysname(sdev);
 
-       sscanf(sdev->name, "%u-%u", &busnum, &devnum);
+       strncpy(udev->path,  path,  SYSFS_PATH_MAX);
+       strncpy(udev->busid, name, SYSFS_BUS_ID_SIZE);
+
+       sscanf(name, "%u-%u", &busnum, &devnum);
        udev->busnum = busnum;
 
        return 0;
@@ -222,13 +202,13 @@ int read_usb_interface(struct usbip_usb_device *udev, int i,
                       struct usbip_usb_interface *uinf)
 {
        char busid[SYSFS_BUS_ID_SIZE];
-       struct sysfs_device *sif;
+       struct udev_device *sif;
 
        sprintf(busid, "%s:%d.%d", udev->busid, udev->bConfigurationValue, i);
 
-       sif = sysfs_open_device("usb", busid);
+       sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
        if (!sif) {
-               dbg("sysfs_open_device(\"usb\", \"%s\") failed", busid);
+               err("udev_device_new_from_subsystem_sysname %s failed", busid);
                return -1;
        }
 
@@ -236,8 +216,6 @@ int read_usb_interface(struct usbip_usb_device *udev, int i,
        READ_ATTR(uinf, uint8_t,  sif, bInterfaceSubClass,      "%02x\n");
        READ_ATTR(uinf, uint8_t,  sif, bInterfaceProtocol,      "%02x\n");
 
-       sysfs_close_device(sif);
-
        return 0;
 }
 
index d313e127d2abbefebad5f215d665dc9a336b2b82..ed9b43bdc500e7d586f42ebdd0bfb3879c3d10b4 100644 (file)
@@ -6,6 +6,7 @@
 #define __USBIP_COMMON_H
 
 #include <sysfs/libsysfs.h>
+#include <libudev.h>
 
 #include <stdint.h>
 #include <stdio.h>
@@ -118,8 +119,8 @@ struct usbip_usb_device {
 
 void dump_usb_interface(struct usbip_usb_interface *);
 void dump_usb_device(struct usbip_usb_device *);
-int read_usb_device(struct sysfs_device *sdev, struct usbip_usb_device *udev);
-int read_attr_value(struct sysfs_device *dev, const char *name,
+int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev);
+int read_attr_value(struct udev_device *dev, const char *name,
                    const char *format);
 int read_usb_interface(struct usbip_usb_device *udev, int i,
                       struct usbip_usb_interface *uinf);
index 35b2f5b0e350f0d2bd17175a0266bff6bbdca31d..c5bf60b135b904973158f74b01fdd953af3fdfdb 100644 (file)
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <fcntl.h>
 
 #include <errno.h>
 #include <unistd.h>
 
+#include <libudev.h>
+
 #include "usbip_common.h"
 #include "usbip_host_driver.h"
+#include "list.h"
+#include "sysfs_utils.h"
 
 #undef  PROGNAME
 #define PROGNAME "libusbip"
 
 struct usbip_host_driver *host_driver;
-
-#define SYSFS_OPEN_RETRIES 100
+struct udev *udev_context;
 
 static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
 {
-       char attrpath[SYSFS_PATH_MAX];
-       struct sysfs_attribute *attr;
+       char status_attr_path[SYSFS_PATH_MAX];
+       int fd;
+       int length;
+       char status;
        int value = 0;
-       int rc;
-       struct stat s;
-       int retries = SYSFS_OPEN_RETRIES;
-
-       /* This access is racy!
-        *
-        * Just after detach, our driver removes the sysfs
-        * files and recreates them.
-        *
-        * We may try and fail to open the usbip_status of
-        * an exported device in the (short) window where
-        * it has been removed and not yet recreated.
-        *
-        * This is a bug in the interface. Nothing we can do
-        * except work around it here by polling for the sysfs
-        * usbip_status to reappear.
-        */
-
-       snprintf(attrpath, SYSFS_PATH_MAX, "%s/usbip_status",
-                udev->path);
-
-       while (retries > 0) {
-               if (stat(attrpath, &s) == 0)
-                       break;
-
-               if (errno != ENOENT) {
-                       dbg("stat failed: %s", attrpath);
-                       return -1;
-               }
-
-               usleep(10000); /* 10ms */
-               retries--;
-       }
 
-       if (retries == 0)
-               dbg("usbip_status not ready after %d retries",
-                   SYSFS_OPEN_RETRIES);
-       else if (retries < SYSFS_OPEN_RETRIES)
-               dbg("warning: usbip_status ready after %d retries",
-                   SYSFS_OPEN_RETRIES - retries);
+       snprintf(status_attr_path, SYSFS_PATH_MAX, "%s/usbip_status",
+                udev->path);
 
-       attr = sysfs_open_attribute(attrpath);
-       if (!attr) {
-               dbg("sysfs_open_attribute failed: %s", attrpath);
+       if ((fd = open(status_attr_path, O_RDONLY)) < 0) {
+               err("error opening attribute %s", status_attr_path);
                return -1;
        }
 
-       rc = sysfs_read_attribute(attr);
-       if (rc) {
-               dbg("sysfs_read_attribute failed: %s", attrpath);
-               sysfs_close_attribute(attr);
+       length = read(fd, &status, 1);
+       if (length < 0) {
+               err("error reading attribute %s", status_attr_path);
+               close(fd);
                return -1;
        }
 
-       value = atoi(attr->value);
-
-       sysfs_close_attribute(attr);
+       value = atoi(&status);
 
        return value;
 }
 
-static struct usbip_exported_device *usbip_exported_device_new(char *sdevpath)
+static
+struct usbip_exported_device *usbip_exported_device_new(const char *sdevpath)
 {
        struct usbip_exported_device *edev = NULL;
        struct usbip_exported_device *edev_old;
        size_t size;
        int i;
 
-       edev = calloc(1, sizeof(*edev));
-       if (!edev) {
-               dbg("calloc failed");
-               return NULL;
-       }
+       edev = calloc(1, sizeof(struct usbip_exported_device));
 
-       edev->sudev = sysfs_open_device_path(sdevpath);
+       edev->sudev = udev_device_new_from_syspath(udev_context, sdevpath);
        if (!edev->sudev) {
-               dbg("sysfs_open_device_path failed: %s", sdevpath);
+               err("udev_device_new_from_syspath: %s", sdevpath);
                goto err;
        }
 
@@ -124,7 +87,7 @@ static struct usbip_exported_device *usbip_exported_device_new(char *sdevpath)
                goto err;
 
        /* reallocate buffer to include usb interface data */
-       size = sizeof(*edev) + edev->udev.bNumInterfaces *
+       size = sizeof(struct usbip_exported_device) + edev->udev.bNumInterfaces *
                sizeof(struct usbip_usb_interface);
 
        edev_old = edev;
@@ -140,149 +103,88 @@ static struct usbip_exported_device *usbip_exported_device_new(char *sdevpath)
 
        return edev;
 err:
-       if (edev && edev->sudev)
-               sysfs_close_device(edev->sudev);
+       if (edev->sudev)
+               udev_device_unref(edev->sudev);
        if (edev)
                free(edev);
 
        return NULL;
 }
 
-static int check_new(struct dlist *dlist, struct sysfs_device *target)
-{
-       struct sysfs_device *dev;
-
-       dlist_for_each_data(dlist, dev, struct sysfs_device) {
-               if (!strncmp(dev->bus_id, target->bus_id, SYSFS_BUS_ID_SIZE))
-                       /* device found and is not new */
-                       return 0;
-       }
-       return 1;
-}
-
-static void delete_nothing(void *unused_data)
-{
-       /*
-        * NOTE: Do not delete anything, but the container will be deleted.
-        */
-       (void) unused_data;
-}
-
 static int refresh_exported_devices(void)
 {
-       /* sysfs_device of usb_device */
-       struct sysfs_device     *sudev;
-       struct dlist            *sudev_list;
-       struct dlist            *sudev_unique_list;
        struct usbip_exported_device *edev;
-
-       sudev_unique_list = dlist_new_with_delete(sizeof(struct sysfs_device),
-                                                 delete_nothing);
-
-       sudev_list = sysfs_get_driver_devices(host_driver->sysfs_driver);
-
-       if (!sudev_list) {
-               /*
-                * Not an error condition. There are simply no devices bound to
-                * the driver yet.
-                */
-               dbg("bind " USBIP_HOST_DRV_NAME ".ko to a usb device to be "
-                   "exportable!");
-               return 0;
-       }
-
-       dlist_for_each_data(sudev_list, sudev, struct sysfs_device)
-               if (check_new(sudev_unique_list, sudev))
-                       dlist_unshift(sudev_unique_list, sudev);
-
-       dlist_for_each_data(sudev_unique_list, sudev, struct sysfs_device) {
-               edev = usbip_exported_device_new(sudev->path);
-
-               if (!edev) {
-                       dbg("usbip_exported_device_new failed");
-                       continue;
+       struct udev_enumerate *enumerate;
+       struct udev_list_entry *devices, *dev_list_entry;
+       struct udev_device *dev;
+       const char *path;
+
+       enumerate = udev_enumerate_new(udev_context);
+       udev_enumerate_add_match_subsystem(enumerate, "usb");
+       udev_enumerate_scan_devices(enumerate);
+
+       devices = udev_enumerate_get_list_entry(enumerate);
+
+       udev_list_entry_foreach(dev_list_entry, devices) {
+               path = udev_list_entry_get_name(dev_list_entry);
+               dev = udev_device_new_from_syspath(udev_context, path);
+
+               /* Check whether device uses usbip-host driver. */
+               if (!strcmp(udev_device_get_driver(dev),
+                           USBIP_HOST_DRV_NAME)) {
+                       edev = usbip_exported_device_new(path);
+                       if (!edev) {
+                               dbg("usbip_exported_device_new failed");
+                               continue;
+                       }
+
+                       list_add(&edev->node, &host_driver->edev_list);
+                       host_driver->ndevs++;
                }
-
-               dlist_unshift(host_driver->edev_list, edev);
-               host_driver->ndevs++;
        }
 
-       dlist_destroy(sudev_unique_list);
-
        return 0;
 }
 
-static struct sysfs_driver *open_sysfs_host_driver(void)
+static void usbip_exported_device_destroy(void)
 {
-       char bus_type[] = "usb";
-       char sysfs_mntpath[SYSFS_PATH_MAX];
-       char host_drv_path[SYSFS_PATH_MAX];
-       struct sysfs_driver *host_drv;
-       int rc;
-
-       rc = sysfs_get_mnt_path(sysfs_mntpath, SYSFS_PATH_MAX);
-       if (rc < 0) {
-               dbg("sysfs_get_mnt_path failed");
-               return NULL;
-       }
-
-       snprintf(host_drv_path, SYSFS_PATH_MAX, "%s/%s/%s/%s/%s",
-                sysfs_mntpath, SYSFS_BUS_NAME, bus_type, SYSFS_DRIVERS_NAME,
-                USBIP_HOST_DRV_NAME);
+       struct list_head *i, *tmp;
+       struct usbip_exported_device *edev;
 
-       host_drv = sysfs_open_driver_path(host_drv_path);
-       if (!host_drv) {
-               dbg("sysfs_open_driver_path failed");
-               return NULL;
+       list_for_each_safe(i, tmp, &host_driver->edev_list) {
+               edev = list_entry(i, struct usbip_exported_device, node);
+               list_del(i);
+               free(edev);
        }
-
-       return host_drv;
-}
-
-static void usbip_exported_device_delete(void *dev)
-{
-       struct usbip_exported_device *edev = dev;
-       sysfs_close_device(edev->sudev);
-       free(dev);
 }
 
 int usbip_host_driver_open(void)
 {
        int rc;
 
-       host_driver = calloc(1, sizeof(*host_driver));
-       if (!host_driver) {
-               dbg("calloc failed");
+       udev_context = udev_new();
+       if (!udev_context) {
+               err("udev_new failed");
                return -1;
        }
 
-       host_driver->ndevs = 0;
-       host_driver->edev_list =
-               dlist_new_with_delete(sizeof(struct usbip_exported_device),
-                                     usbip_exported_device_delete);
-       if (!host_driver->edev_list) {
-               dbg("dlist_new_with_delete failed");
-               goto err_free_host_driver;
-       }
+       host_driver = calloc(1, sizeof(*host_driver));
 
-       host_driver->sysfs_driver = open_sysfs_host_driver();
-       if (!host_driver->sysfs_driver)
-               goto err_destroy_edev_list;
+       host_driver->ndevs = 0;
+       INIT_LIST_HEAD(&host_driver->edev_list);
 
        rc = refresh_exported_devices();
        if (rc < 0)
-               goto err_close_sysfs_driver;
+               goto err_free_host_driver;
 
        return 0;
 
-err_close_sysfs_driver:
-       sysfs_close_driver(host_driver->sysfs_driver);
-err_destroy_edev_list:
-       dlist_destroy(host_driver->edev_list);
 err_free_host_driver:
        free(host_driver);
        host_driver = NULL;
 
+       udev_unref(udev_context);
+
        return -1;
 }
 
@@ -291,30 +193,22 @@ void usbip_host_driver_close(void)
        if (!host_driver)
                return;
 
-       if (host_driver->edev_list)
-               dlist_destroy(host_driver->edev_list);
-       if (host_driver->sysfs_driver)
-               sysfs_close_driver(host_driver->sysfs_driver);
+       usbip_exported_device_destroy();
 
        free(host_driver);
        host_driver = NULL;
+
+       udev_unref(udev_context);
 }
 
 int usbip_host_refresh_device_list(void)
 {
        int rc;
 
-       if (host_driver->edev_list)
-               dlist_destroy(host_driver->edev_list);
+       usbip_exported_device_destroy();
 
        host_driver->ndevs = 0;
-       host_driver->edev_list =
-               dlist_new_with_delete(sizeof(struct usbip_exported_device),
-                                     usbip_exported_device_delete);
-       if (!host_driver->edev_list) {
-               dbg("dlist_new_with_delete failed");
-               return -1;
-       }
+       INIT_LIST_HEAD(&host_driver->edev_list);
 
        rc = refresh_exported_devices();
        if (rc < 0)
@@ -326,8 +220,7 @@ int usbip_host_refresh_device_list(void)
 int usbip_host_export_device(struct usbip_exported_device *edev, int sockfd)
 {
        char attr_name[] = "usbip_sockfd";
-       char attr_path[SYSFS_PATH_MAX];
-       struct sysfs_attribute *attr;
+       char sockfd_attr_path[SYSFS_PATH_MAX];
        char sockfd_buff[30];
        int ret;
 
@@ -347,40 +240,32 @@ int usbip_host_export_device(struct usbip_exported_device *edev, int sockfd)
        }
 
        /* only the first interface is true */
-       snprintf(attr_path, sizeof(attr_path), "%s/%s",
+       snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
                 edev->udev.path, attr_name);
 
-       attr = sysfs_open_attribute(attr_path);
-       if (!attr) {
-               dbg("sysfs_open_attribute failed: %s", attr_path);
-               return -1;
-       }
-
        snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
-       dbg("write: %s", sockfd_buff);
 
-       ret = sysfs_write_attribute(attr, sockfd_buff, strlen(sockfd_buff));
+       ret = write_sysfs_attribute(sockfd_attr_path, sockfd_buff,
+                                   strlen(sockfd_buff));
        if (ret < 0) {
-               dbg("sysfs_write_attribute failed: sockfd %s to %s",
-                   sockfd_buff, attr_path);
-               goto err_write_sockfd;
+               err("write_sysfs_attribute failed: sockfd %s to %s",
+                   sockfd_buff, sockfd_attr_path);
+               return ret;
        }
 
-       dbg("connect: %s", edev->udev.busid);
-
-err_write_sockfd:
-       sysfs_close_attribute(attr);
+       info("connect: %s", edev->udev.busid);
 
        return ret;
 }
 
 struct usbip_exported_device *usbip_host_get_device(int num)
 {
+       struct list_head *i;
        struct usbip_exported_device *edev;
-       struct dlist *dlist = host_driver->edev_list;
        int cnt = 0;
 
-       dlist_for_each_data(dlist, edev, struct usbip_exported_device) {
+       list_for_each(i, &host_driver->edev_list) {
+               edev = list_entry(i, struct usbip_exported_device, node);
                if (num == cnt)
                        return edev;
                else
index 34fd14cbfc49d3def304caae9edde9366c59a689..2a31f855c6168dea6c62ec9a4742e1dd1a8f54b4 100644 (file)
 
 #include <stdint.h>
 #include "usbip_common.h"
+#include "list.h"
 
 struct usbip_host_driver {
        int ndevs;
-       struct sysfs_driver *sysfs_driver;
        /* list of exported device */
-       struct dlist *edev_list;
+       struct list_head edev_list;
 };
 
 struct usbip_exported_device {
-       struct sysfs_device *sudev;
+       struct udev_device *sudev;
        int32_t status;
        struct usbip_usb_device udev;
+       struct list_head node;
        struct usbip_usb_interface uinf[];
 };
 
index d80d37c64cb373c9910d235a5debc81cdc68ec29..acdcb13f7e4e5d8efe9b0322c25fde912ebd2d3a 100644 (file)
@@ -6,24 +6,27 @@
 #include "vhci_driver.h"
 #include <limits.h>
 #include <netdb.h>
+#include <libudev.h>
 
 #undef  PROGNAME
 #define PROGNAME "libusbip"
 
 struct usbip_vhci_driver *vhci_driver;
+struct udev *udev_context;
 
 static struct usbip_imported_device *
 imported_device_init(struct usbip_imported_device *idev, char *busid)
 {
-       struct sysfs_device *sudev;
+       struct udev_device *sudev;
 
-       sudev = sysfs_open_device("usb", busid);
+       sudev = udev_device_new_from_subsystem_sysname(udev_context,
+                                                      "usb", busid);
        if (!sudev) {
-               dbg("sysfs_open_device failed: %s", busid);
+               dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
                goto err;
        }
        read_usb_device(sudev, &idev->udev);
-       sysfs_close_device(sudev);
+       udev_device_unref(sudev);
 
        /* add class devices of this imported device */
        struct usbip_class_device *cdev;
@@ -410,6 +413,12 @@ int usbip_vhci_driver_open(void)
        int ret;
        char hc_busid[SYSFS_BUS_ID_SIZE];
 
+       udev_context = udev_new();
+       if (!udev_context) {
+               err("udev_new failed");
+               return -1;
+       }
+
        vhci_driver = (struct usbip_vhci_driver *) calloc(1, sizeof(*vhci_driver));
        if (!vhci_driver) {
                dbg("calloc failed");
@@ -461,6 +470,9 @@ err:
                free(vhci_driver);
 
        vhci_driver = NULL;
+
+       udev_unref(udev_context);
+
        return -1;
 }
 
@@ -483,6 +495,8 @@ void usbip_vhci_driver_close()
        free(vhci_driver);
 
        vhci_driver = NULL;
+
+       udev_unref(udev_context);
 }
 
 
index 771d6c238297461993876a0cec5b933af72e7507..2cae4ce48d11c1c1ff22c92784246c579cc6591f 100644 (file)
@@ -43,6 +43,7 @@
 #include "usbip_host_driver.h"
 #include "usbip_common.h"
 #include "usbip_network.h"
+#include "list.h"
 
 #undef  PROGNAME
 #define PROGNAME "usbipd"
@@ -93,6 +94,7 @@ static int recv_request_import(int sockfd)
        struct op_common reply;
        struct usbip_exported_device *edev;
        struct usbip_usb_device pdu_udev;
+       struct list_head *i;
        int found = 0;
        int error = 0;
        int rc;
@@ -107,8 +109,8 @@ static int recv_request_import(int sockfd)
        }
        PACK_OP_IMPORT_REQUEST(0, &req);
 
-       dlist_for_each_data(host_driver->edev_list, edev,
-                           struct usbip_exported_device) {
+       list_for_each(i, &host_driver->edev_list) {
+               edev = list_entry(i, struct usbip_exported_device, node);
                if (!strncmp(req.busid, edev->udev.busid, SYSFS_BUS_ID_SIZE)) {
                        info("found requested device: %s", req.busid);
                        found = 1;
@@ -161,12 +163,12 @@ static int send_reply_devlist(int connfd)
        struct usbip_usb_device pdu_udev;
        struct usbip_usb_interface pdu_uinf;
        struct op_devlist_reply reply;
+       struct list_head *j;
        int rc, i;
 
        reply.ndev = 0;
        /* number of exported devices */
-       dlist_for_each_data(host_driver->edev_list, edev,
-                           struct usbip_exported_device) {
+       list_for_each(j, &host_driver->edev_list) {
                reply.ndev += 1;
        }
        info("exportable devices: %d", reply.ndev);
@@ -184,8 +186,8 @@ static int send_reply_devlist(int connfd)
                return -1;
        }
 
-       dlist_for_each_data(host_driver->edev_list, edev,
-                           struct usbip_exported_device) {
+       list_for_each(j, &host_driver->edev_list) {
+               edev = list_entry(j, struct usbip_exported_device, node);
                dump_usb_device(&edev->udev);
                memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
                usbip_net_pack_usb_device(1, &pdu_udev);