Exemplo n.º 1
0
/**
 * sysfs_get_class_device: get specific class device using the device's id
 * @cls: sysfs_class to find the device on
 * @name: name of the class device to look for
 *
 * Returns sysfs_class_device * on success and NULL on failure
 */
struct sysfs_class_device *sysfs_get_class_device(struct sysfs_class *cls,
        const char *name)
{
    char path[SYSFS_PATH_MAX];
    struct sysfs_class_device *cdev = NULL;

    if (!cls || !name) {
        errno = EINVAL;
        return NULL;
    }

    if (cls->devices) {
        cdev = (struct sysfs_class_device *)dlist_find_custom
               (cls->devices, (void *)name, cdev_name_equal);
        if (cdev)
            return cdev;
    }

    safestrcpy(path, cls->path);
    safestrcat(path, "/");
    safestrcat(path, name);
    cdev = sysfs_open_class_device_path(path);
    if (!cdev) {
        dprintf("Error opening class device at %s\n", path);
        return NULL;
    }
    if (!cls->devices)
        cls->devices = dlist_new_with_delete
                       (sizeof(struct sysfs_class_device),
                        sysfs_close_cls_dev);

    dlist_unshift_sorted(cls->devices, cdev, sort_list);
    return cdev;
}
Exemplo n.º 2
0
/**
 * Add class devices to list
 */
static void add_cdevs_to_classlist(struct sysfs_class *cls, struct dlist *list)
{
    char path[SYSFS_PATH_MAX], *cdev_name;
    struct sysfs_class_device *cdev = NULL;

    if (cls == NULL || list == NULL)
        return;

    dlist_for_each_data(list, cdev_name, char) {
        if (cls->devices) {
            cdev = (struct sysfs_class_device *)
                   dlist_find_custom(cls->devices,
                                     (void *)cdev_name, cdev_name_equal);
            if (cdev)
                continue;
        }
        safestrcpy(path, cls->path);
        safestrcat(path, "/");
        safestrcat(path, cdev_name);
        cdev = sysfs_open_class_device_path(path);
        if (cdev) {
            if (!cls->devices)
                cls->devices = dlist_new_with_delete
                               (sizeof(struct sysfs_class_device),
                                sysfs_close_cls_dev);
            dlist_unshift_sorted(cls->devices, cdev,
                                 sort_list);
        }
    }
}
Exemplo n.º 3
0
static int refresh_exported_devices(void)
{
	struct sysfs_device	*suinf;  /* sysfs_device of usb_interface */
	struct dlist		*suinf_list;

	struct sysfs_device	*sudev;  /* sysfs_device of usb_device */
	struct dlist		*sudev_list;


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

	suinf_list = sysfs_get_driver_devices(stub_driver->sysfs_driver);
	if (!suinf_list) {
		printf("Bind usbip.ko to a usb device to be exportable!\n");
		goto bye;
	}

	/* collect unique USB devices (not interfaces) */
	dlist_for_each_data(suinf_list, suinf, struct sysfs_device) {

		/* get usb device of this usb interface */
		sudev = sysfs_get_device_parent(suinf);
		if (!sudev) {
			err("get parent dev of %s", suinf->name);
			continue;
		}

		if (check_new(sudev_list, sudev)) {
			dlist_unshift(sudev_list, sudev);
		}
	}
Exemplo n.º 4
0
/**
 * sysfs_get_bus_driver: Get specific driver on bus using driver name
 * @bus: bus to find driver on
 * @drvname: name of driver
 * returns struct sysfs_driver reference or NULL if not found.
 */
struct sysfs_driver *sysfs_get_bus_driver(struct sysfs_bus *bus,
		const char *drvname)
{
	struct sysfs_driver *drv;
	char drvpath[SYSFS_PATH_MAX];

	if (!bus || !drvname) {
		errno = EINVAL;
		return NULL;
	}

	if (bus->drivers) {
		drv = (struct sysfs_driver *)dlist_find_custom
			(bus->drivers, (void *)drvname, name_equal);
		if (drv)
			return drv;
	}
	safestrcpy(drvpath, bus->path);
	safestrcat(drvpath, "/");
	safestrcat(drvpath, SYSFS_DRIVERS_NAME);
	safestrcat(drvpath, "/");
	safestrcat(drvpath, drvname);
	drv = sysfs_open_driver_path(drvpath);
	if (!drv) {
		dprintf("Error opening driver at %s\n", drvpath);
		return NULL;
	}
	if (!bus->drivers)
		bus->drivers = dlist_new_with_delete
				(sizeof(struct sysfs_driver),
				 		sysfs_close_drv);
	dlist_unshift_sorted(bus->drivers, drv, sort_list);
	return drv;
}
Exemplo n.º 5
0
/**
 * add_attribute: open and add attribute at path to given directory
 * @dev: device whose attribute is to be added
 * @path: path to attribute
 * returns pointer to attr added with success and NULL with error.
 */
static struct sysfs_attribute *add_attribute(void *dev, const char *path)
{
	struct sysfs_attribute *attr;

	attr = sysfs_open_attribute(path);
	if (!attr) {
		dprintf("Error opening attribute %s\n",	path);
		return NULL;
	}
	if (attr->method & SYSFS_METHOD_SHOW) {
		if (sysfs_read_attribute(attr)) {
			dprintf("Error reading attribute %s\n",	path);
			sysfs_close_attribute(attr);
			return NULL;
		}
	}

	if (!((struct sysfs_device *)dev)->attrlist) {
		((struct sysfs_device *)dev)->attrlist = dlist_new_with_delete
			(sizeof(struct sysfs_attribute), sysfs_del_attribute);
	}
	dlist_unshift_sorted(((struct sysfs_device *)dev)->attrlist,
			attr, sort_list);

	return attr;
}
Exemplo n.º 6
0
/**
 * sysfs_get_bus_devices: gets all devices for bus
 * @bus: bus to get devices for
 * returns dlist of devices with success and NULL with failure
 */
struct dlist *sysfs_get_bus_devices(struct sysfs_bus *bus)
{
	struct sysfs_device *dev;
	struct dlist *linklist;
	char path[SYSFS_PATH_MAX], devpath[SYSFS_PATH_MAX];
	char target[SYSFS_PATH_MAX];
	char *curlink;

	if (!bus) {
		errno = EINVAL;
		return NULL;
	}
	memset(path, 0, SYSFS_PATH_MAX);
	safestrcpy(path, bus->path);
	safestrcat(path, "/");
	safestrcat(path, SYSFS_DEVICES_NAME);

	linklist = read_dir_links(path);
	if (linklist) {
		dlist_for_each_data(linklist, curlink, char) {
			if (bus->devices) {
				dev = (struct sysfs_device *)
					dlist_find_custom(bus->devices,
					(void *)curlink, name_equal);
				if (dev)
					continue;
			}
			safestrcpy(devpath, path);
			safestrcat(devpath, "/");
			safestrcat(devpath, curlink);
			if (sysfs_get_link(devpath, target, SYSFS_PATH_MAX)) {
				dprintf("Error getting link - %s\n", devpath);
				continue;
			}
			dev = sysfs_open_device_path(target);
			if (!dev) {
				dprintf("Error opening device at %s\n",
								target);
				continue;
			}
			if (!bus->devices)
				bus->devices = dlist_new_with_delete
					(sizeof(struct sysfs_device),
					 		sysfs_close_dev);
			dlist_unshift_sorted(bus->devices, dev, sort_list);
		}
		sysfs_close_list(linklist);
	}
	return (bus->devices);
}
Exemplo n.º 7
0
/**
 * sysfs_get_bus_drivers: gets all drivers for bus
 * @bus: bus to get devices for
 * returns dlist of devices with success and NULL with failure
 */
struct dlist *sysfs_get_bus_drivers(struct sysfs_bus *bus)
{
	struct sysfs_driver *drv;
	struct dlist *dirlist;
	char path[SYSFS_PATH_MAX], drvpath[SYSFS_PATH_MAX];
	char *curdir;

	if (!bus) {
		errno = EINVAL;
		return NULL;
	}
	memset(path, 0, SYSFS_PATH_MAX);
	safestrcpy(path, bus->path);
	safestrcat(path, "/");
	safestrcat(path, SYSFS_DRIVERS_NAME);

	dirlist = read_dir_subdirs(path);
	if (dirlist) {
		dlist_for_each_data(dirlist, curdir, char) {
			if (bus->drivers) {
				drv = (struct sysfs_driver *)
					dlist_find_custom(bus->drivers,
					(void *)curdir, name_equal);
				if (drv)
					continue;
			}
			safestrcpy(drvpath, path);
			safestrcat(drvpath, "/");
			safestrcat(drvpath, curdir);
			drv = sysfs_open_driver_path(drvpath);
			if (!drv) {
				dprintf("Error opening driver at %s\n",
								drvpath);
				continue;
			}
			if (!bus->drivers)
				bus->drivers = dlist_new_with_delete
					(sizeof(struct sysfs_driver),
					 		sysfs_close_drv);
			dlist_unshift_sorted(bus->drivers, drv, sort_list);
		}
		sysfs_close_list(dirlist);
	}
	return (bus->drivers);
}
Exemplo n.º 8
0
int add_subdirectory(struct sysfs_device *dev, char *path)
{
	struct sysfs_device *newdev;

	if (!path)
		return -1;

	newdev = sysfs_open_device_path(path);
	if (newdev == NULL)
		return -1;

	if (dev->children == NULL)
		dev->children = dlist_new_with_delete(
			sizeof(struct sysfs_device), sysfs_close_dev_tree);

	dlist_unshift_sorted(dev->children, newdev, sort_list);
	return 0;
}
Exemplo n.º 9
0
/**
 * read_dir_subdirs: grabs subdirs in a specific directory
 * @sysdir: sysfs directory to read
 * returns list of directory names with success and NULL with error.
 */
struct dlist *read_dir_subdirs(const char *path)
{
	DIR *dir = NULL;
	struct dirent *dirent = NULL;
	char file_path[SYSFS_PATH_MAX], *dir_name;
	struct dlist *dirlist = NULL;

	if (!path) {
		errno = EINVAL;
		return NULL;
	}
	dir = opendir(path);
	if (!dir) {
		dprintf("Error opening directory %s\n", path);
		return NULL;
	}
	while ((dirent = readdir(dir)) != NULL) {
		if (0 == strcmp(dirent->d_name, "."))
			 continue;
		if (0 == strcmp(dirent->d_name, ".."))
			continue;
		memset(file_path, 0, SYSFS_PATH_MAX);
		safestrcpy(file_path, path);
		safestrcat(file_path, "/");
		safestrcat(file_path, dirent->d_name);
		if (!sysfs_path_is_dir(file_path)) {
			if (!dirlist) {
				dirlist = dlist_new_with_delete
					(SYSFS_NAME_LEN, sysfs_del_name);
				if (!dirlist) {
					dprintf("Error creating list\n");
					return NULL;
				}
			}
			dir_name = (char *)calloc(1, SYSFS_NAME_LEN);
			safestrcpymax(dir_name, dirent->d_name, SYSFS_NAME_LEN);
			dlist_unshift_sorted(dirlist, dir_name, sort_char);
		}
	}
	closedir(dir);
	return dirlist;
}
Exemplo n.º 10
0
int usbip_stub_driver_open(void)
{
	int ret;


	stub_driver = (struct usbip_stub_driver *) calloc(1, sizeof(*stub_driver));
	if (!stub_driver) {
		err("alloc stub_driver");
		return -1;
	}

	stub_driver->ndevs = 0;

	stub_driver->edev_list = dlist_new_with_delete(sizeof(struct usbip_exported_device),
			usbip_exported_device_delete);
	if (!stub_driver->edev_list) {
		err("alloc dlist");
		goto err;
	}

	stub_driver->sysfs_driver = open_sysfs_stub_driver();
	if (!stub_driver->sysfs_driver)
		goto err;

	ret = refresh_exported_devices();
	if (ret < 0)
		goto err;

	return 0;


err:
	if (stub_driver->sysfs_driver)
		sysfs_close_driver(stub_driver->sysfs_driver);
	if (stub_driver->edev_list)
		dlist_destroy(stub_driver->edev_list);
	free(stub_driver);

	stub_driver = NULL;
	return -1;
}
Exemplo n.º 11
0
/**
 * get_attributes_list: build a list of attributes for the given path
 * @path: grab attributes at the given path
 * returns dlist of attributes on success and NULL on failure
 */
struct dlist *get_attributes_list(struct dlist *alist, const char *path)
{
	DIR *dir = NULL;
	struct dirent *dirent = NULL;
	char file_path[SYSFS_PATH_MAX];

	if (!path) {
		errno = EINVAL;
		return NULL;
	}

	dir = opendir(path);
	if (!dir) {
		dprintf("Error opening directory %s\n", path);
		return NULL;
	}
	while ((dirent = readdir(dir)) != NULL) {
		if (0 == strcmp(dirent->d_name, "."))
			 continue;
		if (0 == strcmp(dirent->d_name, ".."))
			continue;
		memset(file_path, 0, SYSFS_PATH_MAX);
		safestrcpy(file_path, path);
		safestrcat(file_path, "/");
		safestrcat(file_path, dirent->d_name);
		if (!sysfs_path_is_file(file_path)) {
			if (!alist) {
				alist = dlist_new_with_delete
					(sizeof(struct sysfs_attribute),
							sysfs_del_attribute);
				if (!alist) {
					dprintf("Error creating list\n");
					return NULL;
				}
			}
			add_attribute_to_list(alist, file_path);
		}
	}
	closedir(dir);
	return alist;
}
Exemplo n.º 12
0
/**
 * sysfs_get_driver_devices: gets list of devices that use the driver
 * @drv: sysfs_driver whose device list is needed
 * Returns dlist of struct sysfs_device on success and NULL on failure
 */
struct dlist *sysfs_get_driver_devices(struct sysfs_driver *drv)
{
	char *ln = NULL;
	struct dlist *linklist = NULL;
	struct sysfs_device *dev = NULL;

	if (!drv) {
		errno = EINVAL;
		return NULL;
	}

	linklist = read_dir_links(drv->path);
	if (linklist) {
		dlist_for_each_data(linklist, ln, char) {

			if (!strncmp(ln, SYSFS_MODULE_NAME, strlen(ln)))
				continue;

			dev = sysfs_open_device(drv->bus, ln);
			if (!dev) {
				dprintf("Error opening driver's device\n");
				sysfs_close_list(linklist);
				return NULL;
			}
			if (!drv->devices) {
				drv->devices = dlist_new_with_delete
					(sizeof(struct sysfs_device),
					 sysfs_close_driver_device);
				if (!drv->devices) {
					dprintf("Error creating device list\n");
					sysfs_close_list(linklist);
					return NULL;
				}
			}
			dlist_unshift_sorted(drv->devices, dev, sort_list);
		}
		sysfs_close_list(linklist);
	}
	return drv->devices;
}
Exemplo n.º 13
0
/**
 * sysfs_get_bus_device: Get specific device on bus using device's id
 * @bus: bus to find device on
 * @id: bus_id for device
 * returns struct sysfs_device reference or NULL if not found.
 */
struct sysfs_device *sysfs_get_bus_device(struct sysfs_bus *bus,
		const char *id)
{
	struct sysfs_device *dev = NULL;
	char devpath[SYSFS_PATH_MAX], target[SYSFS_PATH_MAX];

	if (!bus || !id) {
		errno = EINVAL;
		return NULL;
	}

	if (bus->devices) {
		dev = (struct sysfs_device *)dlist_find_custom
			(bus->devices, (void *)id, name_equal);
		if (dev)
			return dev;
	}
	safestrcpy(devpath, bus->path);
	safestrcat(devpath, "/");
	safestrcat(devpath, SYSFS_DEVICES_NAME);
	safestrcat(devpath, "/");
	safestrcat(devpath, id);
	if (sysfs_path_is_link(devpath)) {
		dprintf("No such device %s on bus %s?\n", id, bus->name);
		return NULL;
	}
	if (!sysfs_get_link(devpath, target, SYSFS_PATH_MAX)) {
		dev = sysfs_open_device_path(target);
		if (!dev) {
			dprintf("Error opening device at %s\n", target);
			return NULL;
		}
		if (!bus->devices)
			bus->devices = dlist_new_with_delete
					(sizeof(struct sysfs_device),
					 		sysfs_close_dev);
		dlist_unshift_sorted(bus->devices, dev, sort_list);
	}
	return dev;
}
Exemplo n.º 14
0
int usbip_stub_refresh_device_list(void)
{
	int ret;

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

	stub_driver->ndevs = 0;

	stub_driver->edev_list = dlist_new_with_delete(sizeof(struct usbip_exported_device),
			usbip_exported_device_delete);
	if (!stub_driver->edev_list) {
		err("alloc dlist");
		return -1;
	}

	ret = refresh_exported_devices();
	if (ret < 0)
		return ret;

	return 0;
}
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);
		}
	}