drivers/staging/usbip/userspace/libsrc/usbip_host_driver.c - nest-hello/linux-3.10 - Git at Google

 /*
  * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
  *               2005-2007 Takahiro Hirofuchi
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */

 #include <sys/types.h>
 #include <sys/stat.h>

 #include <errno.h>
 #include <unistd.h>

 #include "usbip_common.h"
 #include "usbip_host_driver.h"

 #undef  PROGNAME
 #define PROGNAME "libusbip"

 struct usbip_host_driver *host_driver;

 #define SYSFS_OPEN_RETRIES 100

 /* only the first interface value is true! */
 static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
 {
 	char attrpath[SYSFS_PATH_MAX];
 	struct sysfs_attribute *attr;
 	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/%s:%d.%d/usbip_status",
 		 udev->path, udev->busid, udev->bConfigurationValue, 0);

 	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);

 	attr = sysfs_open_attribute(attrpath);
 	if (!attr) {
 		dbg("sysfs_open_attribute failed: %s", attrpath);
 		return -1;
 	}

 	rc = sysfs_read_attribute(attr);
 	if (rc) {
 		dbg("sysfs_read_attribute failed: %s", attrpath);
 		sysfs_close_attribute(attr);
 		return -1;
 	}

 	value = atoi(attr->value);

 	sysfs_close_attribute(attr);

 	return value;
 }

 static struct usbip_exported_device *usbip_exported_device_new(char *sdevpath)
 {
 	struct usbip_exported_device *edev = NULL;
 	size_t size;
 	int i;

 	edev = calloc(1, sizeof(*edev));
 	if (!edev) {
 		dbg("calloc failed");
 		return NULL;
 	}

 	edev->sudev = sysfs_open_device_path(sdevpath);
 	if (!edev->sudev) {
 		dbg("sysfs_open_device_path failed: %s", sdevpath);
 		goto err;
 	}

 	read_usb_device(edev->sudev, &edev->udev);

 	edev->status = read_attr_usbip_status(&edev->udev);
 	if (edev->status < 0)
 		goto err;

 	/* reallocate buffer to include usb interface data */
 	size = sizeof(*edev) + edev->udev.bNumInterfaces *
 		sizeof(struct usbip_usb_interface);

 	edev = realloc(edev, size);
 	if (!edev) {
 		dbg("realloc failed");
 		goto err;
 	}

 	for (i = 0; i < edev->udev.bNumInterfaces; i++)
 		read_usb_interface(&edev->udev, i, &edev->uinf[i]);

 	return edev;
 err:
 	if (edev && edev->sudev)
 		sysfs_close_device(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_interface */
 	struct sysfs_device	*suintf;
 	struct dlist		*suintf_list;
 	/* sysfs_device of usb_device */
 	struct sysfs_device	*sudev;
 	struct dlist		*sudev_list;
 	struct usbip_exported_device *edev;

 	sudev_list = dlist_new_with_delete(sizeof(struct sysfs_device),
 					   delete_nothing);

 	suintf_list = sysfs_get_driver_devices(host_driver->sysfs_driver);
 	if (!suintf_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;
 	}

 	/* collect unique USB devices (not interfaces) */
 	dlist_for_each_data(suintf_list, suintf, struct sysfs_device) {
 		/* get usb device of this usb interface */
 		sudev = sysfs_get_device_parent(suintf);
 		if (!sudev) {
 			dbg("sysfs_get_device_parent failed: %s", suintf->name);
 			continue;
 		}

 		if (check_new(sudev_list, sudev)) {
 			/* insert item at head of list */
 			dlist_unshift(sudev_list, sudev);
 		}
 	}

 	dlist_for_each_data(sudev_list, sudev, struct sysfs_device) {
 		edev = usbip_exported_device_new(sudev->path);
 		if (!edev) {
 			dbg("usbip_exported_device_new failed");
 			continue;
 		}

 		dlist_unshift(host_driver->edev_list, edev);
 		host_driver->ndevs++;
 	}

 	dlist_destroy(sudev_list);

 	return 0;
 }

 static struct sysfs_driver *open_sysfs_host_driver(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);

 	host_drv = sysfs_open_driver_path(host_drv_path);
 	if (!host_drv) {
 		dbg("sysfs_open_driver_path failed");
 		return NULL;
 	}

 	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");
 		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->sysfs_driver = open_sysfs_host_driver();
 	if (!host_driver->sysfs_driver)
 		goto err_destroy_edev_list;

 	rc = refresh_exported_devices();
 	if (rc < 0)
 		goto err_close_sysfs_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;

 	return -1;
 }

 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);

 	free(host_driver);
 	host_driver = NULL;
 }

 int usbip_host_refresh_device_list(void)
 {
 	int rc;

 	if (host_driver->edev_list)
 		dlist_destroy(host_driver->edev_list);

 	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;
 	}

 	rc = refresh_exported_devices();
 	if (rc < 0)
 		return -1;

 	return 0;
 }

 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_buff[30];
 	int ret;

 	if (edev->status != SDEV_ST_AVAILABLE) {
 		dbg("device not available: %s", edev->udev.busid);
 		switch (edev->status) {
 		case SDEV_ST_ERROR:
 			dbg("status SDEV_ST_ERROR");
 			break;
 		case SDEV_ST_USED:
 			dbg("status SDEV_ST_USED");
 			break;
 		default:
 			dbg("status unknown: 0x%x", edev->status);
 		}
 		return -1;
 	}

 	/* only the first interface is true */
 	snprintf(attr_path, sizeof(attr_path), "%s/%s:%d.%d/%s",
 		 edev->udev.path, edev->udev.busid,
 		 edev->udev.bConfigurationValue, 0, 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));
 	if (ret < 0) {
 		dbg("sysfs_write_attribute failed: sockfd %s to %s",
 		    sockfd_buff, attr_path);
 		goto err_write_sockfd;
 	}

 	dbg("connect: %s", edev->udev.busid);

 err_write_sockfd:
 	sysfs_close_attribute(attr);

 	return ret;
 }

 struct usbip_exported_device *usbip_host_get_device(int num)
 {
 	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) {
 		if (num == cnt)
 			return edev;
 		else
 			cnt++;
 	}

 	return NULL;
 }
	/*
	* Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
	* 2005-2007 Takahiro Hirofuchi
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include <sys/types.h>
	#include <sys/stat.h>

	#include <errno.h>
	#include <unistd.h>

	#include "usbip_common.h"
	#include "usbip_host_driver.h"

	#undef PROGNAME
	#define PROGNAME "libusbip"

	struct usbip_host_driver *host_driver;

	#define SYSFS_OPEN_RETRIES 100

	/* only the first interface value is true! */
	static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
	{
	char attrpath[SYSFS_PATH_MAX];
	struct sysfs_attribute *attr;
	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/%s:%d.%d/usbip_status",
	udev->path, udev->busid, udev->bConfigurationValue, 0);

	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);

	attr = sysfs_open_attribute(attrpath);
	if (!attr) {
	dbg("sysfs_open_attribute failed: %s", attrpath);
	return -1;
	}

	rc = sysfs_read_attribute(attr);
	if (rc) {
	dbg("sysfs_read_attribute failed: %s", attrpath);
	sysfs_close_attribute(attr);
	return -1;
	}

	value = atoi(attr->value);

	sysfs_close_attribute(attr);

	return value;
	}

	static struct usbip_exported_device usbip_exported_device_new(char sdevpath)
	{
	struct usbip_exported_device *edev = NULL;
	size_t size;
	int i;

	edev = calloc(1, sizeof(*edev));
	if (!edev) {
	dbg("calloc failed");
	return NULL;
	}

	edev->sudev = sysfs_open_device_path(sdevpath);
	if (!edev->sudev) {
	dbg("sysfs_open_device_path failed: %s", sdevpath);
	goto err;
	}

	read_usb_device(edev->sudev, &edev->udev);

	edev->status = read_attr_usbip_status(&edev->udev);
	if (edev->status < 0)
	goto err;

	/* reallocate buffer to include usb interface data */
	size = sizeof(edev) + edev->udev.bNumInterfaces
	sizeof(struct usbip_usb_interface);

	edev = realloc(edev, size);
	if (!edev) {
	dbg("realloc failed");
	goto err;
	}

	for (i = 0; i < edev->udev.bNumInterfaces; i++)
	read_usb_interface(&edev->udev, i, &edev->uinf[i]);

	return edev;
	err:
	if (edev && edev->sudev)
	sysfs_close_device(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_interface */
	struct sysfs_device *suintf;
	struct dlist *suintf_list;
	/* sysfs_device of usb_device */
	struct sysfs_device *sudev;
	struct dlist *sudev_list;
	struct usbip_exported_device *edev;

	sudev_list = dlist_new_with_delete(sizeof(struct sysfs_device),
	delete_nothing);

	suintf_list = sysfs_get_driver_devices(host_driver->sysfs_driver);
	if (!suintf_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;
	}

	/* collect unique USB devices (not interfaces) */
	dlist_for_each_data(suintf_list, suintf, struct sysfs_device) {
	/* get usb device of this usb interface */
	sudev = sysfs_get_device_parent(suintf);
	if (!sudev) {
	dbg("sysfs_get_device_parent failed: %s", suintf->name);
	continue;
	}

	if (check_new(sudev_list, sudev)) {
	/* insert item at head of list */
	dlist_unshift(sudev_list, sudev);
	}
	}

	dlist_for_each_data(sudev_list, sudev, struct sysfs_device) {
	edev = usbip_exported_device_new(sudev->path);
	if (!edev) {
	dbg("usbip_exported_device_new failed");
	continue;
	}

	dlist_unshift(host_driver->edev_list, edev);
	host_driver->ndevs++;
	}

	dlist_destroy(sudev_list);

	return 0;
	}

	static struct sysfs_driver *open_sysfs_host_driver(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);

	host_drv = sysfs_open_driver_path(host_drv_path);
	if (!host_drv) {
	dbg("sysfs_open_driver_path failed");
	return NULL;
	}

	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");
	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->sysfs_driver = open_sysfs_host_driver();
	if (!host_driver->sysfs_driver)
	goto err_destroy_edev_list;

	rc = refresh_exported_devices();
	if (rc < 0)
	goto err_close_sysfs_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;

	return -1;
	}

	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);

	free(host_driver);
	host_driver = NULL;
	}

	int usbip_host_refresh_device_list(void)
	{
	int rc;

	if (host_driver->edev_list)
	dlist_destroy(host_driver->edev_list);

	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;
	}

	rc = refresh_exported_devices();
	if (rc < 0)
	return -1;

	return 0;
	}

	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_buff[30];
	int ret;

	if (edev->status != SDEV_ST_AVAILABLE) {
	dbg("device not available: %s", edev->udev.busid);
	switch (edev->status) {
	case SDEV_ST_ERROR:
	dbg("status SDEV_ST_ERROR");
	break;
	case SDEV_ST_USED:
	dbg("status SDEV_ST_USED");
	break;
	default:
	dbg("status unknown: 0x%x", edev->status);
	}
	return -1;
	}

	/* only the first interface is true */
	snprintf(attr_path, sizeof(attr_path), "%s/%s:%d.%d/%s",
	edev->udev.path, edev->udev.busid,
	edev->udev.bConfigurationValue, 0, 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));
	if (ret < 0) {
	dbg("sysfs_write_attribute failed: sockfd %s to %s",
	sockfd_buff, attr_path);
	goto err_write_sockfd;
	}

	dbg("connect: %s", edev->udev.busid);

	err_write_sockfd:
	sysfs_close_attribute(attr);

	return ret;
	}

	struct usbip_exported_device *usbip_host_get_device(int num)
	{
	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) {
	if (num == cnt)
	return edev;
	else
	cnt++;
	}

	return NULL;
	}