[thirdparty/systemd.git] / udev / lib / libudev-enumerate.c

/*
 * libudev - interface to udev device information
 *
 * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>

#include "libudev.h"
#include "libudev-private.h"

struct udev_enumerate {
	struct udev *udev;
	int refcount;
	struct list_node devices_list;
};

struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	udev_enumerate->refcount++;
	return udev_enumerate;
}

void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return;
	udev_enumerate->refcount--;
	if (udev_enumerate->refcount > 0)
		return;
	list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
	free(udev_enumerate);
}

struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	return udev_enumerate->udev;
}

struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	return list_get_entry(&udev_enumerate->devices_list);
}

static int devices_scan_subsystem(struct udev *udev,
				  const char *basedir, const char *subsystem, const char *subdir,
				  struct list_node *devices_list)
{
	char path[UTIL_PATH_SIZE];
	DIR *dir;
	struct dirent *dent;

	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
	util_strlcat(path, basedir, sizeof(path));
	if (subsystem != NULL) {
		util_strlcat(path, "/", sizeof(path));
		util_strlcat(path, subsystem, sizeof(path));
	}
	if (subdir != NULL)
		util_strlcat(path, subdir, sizeof(path));
	dir = opendir(path);
	if (dir == NULL)
		return -1;
	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
		char syspath[UTIL_PATH_SIZE];
		char filename[UTIL_PATH_SIZE];
		struct stat statbuf;

		if (dent->d_name[0] == '.')
			continue;
		util_strlcpy(syspath, path, sizeof(syspath));
		util_strlcat(syspath, "/", sizeof(syspath));
		util_strlcat(syspath, dent->d_name, sizeof(syspath));
		util_strlcpy(filename, syspath, sizeof(filename));
		util_strlcat(filename, "/uevent", sizeof(filename));
		if (stat(filename, &statbuf) != 0)
			continue;
		util_resolve_sys_link(udev, syspath, sizeof(syspath));
		list_entry_add(udev, devices_list, syspath, NULL, 1, 1);
	}
	closedir(dir);
	return 0;
}

static int devices_scan_subsystems(struct udev *udev,
				   const char *basedir, const char *subdir,
				   struct udev_list_entry *subsystem_include_list,
				   struct udev_list_entry *subsystem_exclude_list,
				   struct list_node *devices_list)
{
	if (subsystem_include_list != NULL) {
		struct udev_list_entry *list_entry;

		/* if list of subsystems to scan is given, just use this list */
		udev_list_entry_foreach(list_entry, subsystem_include_list) {
			if (udev_list_entry_get_by_name(subsystem_exclude_list, udev_list_entry_get_name(list_entry)) != NULL)
					continue;
			devices_scan_subsystem(udev, basedir, udev_list_entry_get_name(list_entry), subdir, devices_list);
		}
	} else {
		char path[UTIL_PATH_SIZE];
		DIR *dir;
		struct dirent *dent;

		/* if no list of subsystems to scan is given, scan all, and possible exclude some subsystems */
		util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
		util_strlcat(path, basedir, sizeof(path));
		dir = opendir(path);
		if (dir == NULL)
			return -1;
		for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
			if (dent->d_name[0] == '.')
				continue;
			if (udev_list_entry_get_by_name(subsystem_exclude_list, dent->d_name) != NULL)
					continue;
			devices_scan_subsystem(udev, basedir, dent->d_name, subdir, devices_list);
		}
		closedir(dir);
	}
	return 0;
}

static int devices_delay(struct udev *udev, const char *syspath)
{
	static const char *delay_device_list[] = {
		"/block/md",
		"/block/dm-",
		NULL
	};
	size_t len;
	int i;

	len = strlen(udev_get_sys_path(udev));

	for (i = 0; delay_device_list[i] != NULL; i++) {
		if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
			info(udev, "delaying: %s\n", syspath);
			return 1;
		}
	}
	return 0;
}

/**
 * udev_enumerate_new:
 * @udev: udev library context
 *
 * Returns: an enumeration context
 **/
struct udev_enumerate *udev_enumerate_new(struct udev *udev)
{
	struct udev_enumerate *udev_enumerate;

	udev_enumerate = malloc(sizeof(struct udev_enumerate));
	if (udev_enumerate == NULL)
		return NULL;
	memset(udev_enumerate, 0x00, (sizeof(struct udev_enumerate)));
	udev_enumerate->refcount = 1;
	udev_enumerate->udev = udev;
	list_init(&udev_enumerate->devices_list);
	return udev_enumerate;
}

/**
 * udev_enumerate_scan_devices:
 * @udev_enumerate: udev enumeration context
 * @subsystem: the list of names of subsystems to look for devices
 *
 * Returns: 0 on success.
 **/
int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate, const char *subsystem, ...)
{
	struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
	va_list vargs;
	const char *arg;
	char base[UTIL_PATH_SIZE];
	struct stat statbuf;
	struct list_node subsystem_include_list;
	struct list_node subsystem_exclude_list;
	struct udev_list_entry *list_entry;

	if (udev_enumerate == NULL)
		return -EINVAL;

	va_start(vargs, subsystem);
	list_init(&subsystem_include_list);
	list_init(&subsystem_exclude_list);
	for (arg = subsystem; arg != NULL; arg = va_arg(vargs, const char *)) {
		if (arg[0] != '!')
			list_entry_add(udev, &subsystem_include_list, arg, NULL, 1, 0);
		else
			list_entry_add(udev, &subsystem_exclude_list, &arg[1], NULL, 1, 0);
	}
	va_end(vargs);

	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	util_strlcat(base, "/subsystem", sizeof(base));
	if (stat(base, &statbuf) == 0) {
		/* we have /subsystem/, forget all the old stuff */
		info(udev, "searching '/subsystem/*/devices/*' dir\n");
		devices_scan_subsystems(udev, "/subsystem", "/devices",
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
	} else {
		info(udev, "searching '/bus/*/devices/*' dir\n");
		devices_scan_subsystems(udev, "/bus", "/devices",
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
		info(udev, "searching '/class/*' dir\n");
		devices_scan_subsystems(udev, "/class", NULL,
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
		/* if block isn't a class, scan /block/ */
		util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
		util_strlcat(base, "/class/block", sizeof(base));
		if (stat(base, &statbuf) != 0) {
			struct udev_list_entry *include_list = list_get_entry(&subsystem_include_list);
			struct udev_list_entry *exclude_list = list_get_entry(&subsystem_exclude_list);
			int include_block = (include_list == NULL || udev_list_entry_get_by_name(include_list, "block") != NULL);
			int exclude_block = (udev_list_entry_get_by_name(exclude_list, "block") != NULL);

			if (include_block && !exclude_block) {
				info(udev, "searching '/block/*' dir\n");
				/* scan disks */
				devices_scan_subsystem(udev, "/block", NULL, NULL, &udev_enumerate->devices_list);
				/* scan partitions */
				info(udev, "searching '/block/*/*' dir\n");
				devices_scan_subsystems(udev, "/block", NULL,
							NULL, NULL,
							&udev_enumerate->devices_list);
			}
		}
	}

	list_cleanup(udev, &subsystem_include_list);
	list_cleanup(udev, &subsystem_exclude_list);

	/* sort delayed devices to the end of the list */
	udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
		if (devices_delay(udev, udev_list_entry_get_name(list_entry)))
			list_entry_move_to_end(list_entry);
	}
	return 0;
}

/**
 * udev_enumerate_scan_subsystems:
 * @udev_enumerate: udev enumeration context
 *
 * Returns: 0 on success.
 **/
int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate)
{
	struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
	char base[UTIL_PATH_SIZE];
	struct stat statbuf;
	const char *subsysdir;

	if (udev_enumerate == NULL)
		return -EINVAL;

	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	util_strlcat(base, "/subsystem", sizeof(base));
	if (stat(base, &statbuf) == 0)
		subsysdir = "/subsystem";
	else
		subsysdir = "/bus";
	info(udev, "searching '%s/*' dir\n", subsysdir);
	devices_scan_subsystem(udev, subsysdir, NULL, NULL, &udev_enumerate->devices_list);
	info(udev, "searching '%s/*/drivers/*' dir\n", subsysdir);
	devices_scan_subsystems(udev, subsysdir, "/drivers",
				NULL, NULL,
				&udev_enumerate->devices_list);
	return 0;
}
Commit	Line	Data
eb1f0e66 KS	1	/*
	2	* libudev - interface to udev device information
	3	*
	4	* Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
eb1f0e66 KS	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <stddef.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25	#include <string.h>
	26	#include <dirent.h>
	27	#include <sys/stat.h>
	28
	29	#include "libudev.h"
	30	#include "libudev-private.h"
eb1f0e66	31
bf7ad0ea KS	32	struct udev_enumerate {
	33	struct udev *udev;
	34	int refcount;
e345e267	35	struct list_node devices_list;
bf7ad0ea KS	36	};
	37
	38	struct udev_enumerate udev_enumerate_ref(struct udev_enumerate udev_enumerate)
	39	{
	40	if (udev_enumerate == NULL)
	41	return NULL;
	42	udev_enumerate->refcount++;
	43	return udev_enumerate;
	44	}
	45
	46	void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
	47	{
	48	if (udev_enumerate == NULL)
	49	return;
	50	udev_enumerate->refcount--;
	51	if (udev_enumerate->refcount > 0)
	52	return;
	53	list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
	54	free(udev_enumerate);
	55	}
	56
bc8184ed KS	57	struct udev udev_enumerate_get_udev(struct udev_enumerate udev_enumerate)
	58	{
	59	if (udev_enumerate == NULL)
	60	return NULL;
	61	return udev_enumerate->udev;
	62	}
	63
0de33a61	64	struct udev_list_entry udev_enumerate_get_list_entry(struct udev_enumerate udev_enumerate)
bf7ad0ea KS	65	{
	66	if (udev_enumerate == NULL)
	67	return NULL;
	68	return list_get_entry(&udev_enumerate->devices_list);
	69	}
	70
eb1f0e66 KS	71	static int devices_scan_subsystem(struct udev *udev,
eb1f0e66 KS	72	const char basedir, const char subsystem, const char *subdir,
bc8184ed	73	struct list_node *devices_list)
eb1f0e66	74	{
3eb46ec6	75	char path[UTIL_PATH_SIZE];
eb1f0e66 KS	76	DIR *dir;
eb1f0e66 KS	77	struct dirent *dent;
eb1f0e66	78
8753fadf	79	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
3eb46ec6	80	util_strlcat(path, basedir, sizeof(path));
6f67f1df KS	81	if (subsystem != NULL) {
	82	util_strlcat(path, "/", sizeof(path));
	83	util_strlcat(path, subsystem, sizeof(path));
	84	}
eb1f0e66	85	if (subdir != NULL)
3eb46ec6	86	util_strlcat(path, subdir, sizeof(path));
eb1f0e66 KS	87	dir = opendir(path);
	88	if (dir == NULL)
	89	return -1;
	90	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
8753fadf	91	char syspath[UTIL_PATH_SIZE];
b03e89cf	92	char filename[UTIL_PATH_SIZE];
6f67f1df	93	struct stat statbuf;
eb1f0e66 KS	94
	95	if (dent->d_name[0] == '.')
	96	continue;
8753fadf KS	97	util_strlcpy(syspath, path, sizeof(syspath));
	98	util_strlcat(syspath, "/", sizeof(syspath));
	99	util_strlcat(syspath, dent->d_name, sizeof(syspath));
b03e89cf KS	100	util_strlcpy(filename, syspath, sizeof(filename));
	101	util_strlcat(filename, "/uevent", sizeof(filename));
	102	if (stat(filename, &statbuf) != 0)
6f67f1df	103	continue;
8753fadf	104	util_resolve_sys_link(udev, syspath, sizeof(syspath));
bc8184ed	105	list_entry_add(udev, devices_list, syspath, NULL, 1, 1);
eb1f0e66 KS	106	}
	107	closedir(dir);
	108	return 0;
	109	}
	110
	111	static int devices_scan_subsystems(struct udev *udev,
bc8184ed KS	112	const char basedir, const char subdir,
	113	struct udev_list_entry *subsystem_include_list,
	114	struct udev_list_entry *subsystem_exclude_list,
	115	struct list_node *devices_list)
eb1f0e66	116	{
bc8184ed KS	117	if (subsystem_include_list != NULL) {
bc8184ed KS	118	struct udev_list_entry *list_entry;
eb1f0e66	119
bc8184ed	120	/* if list of subsystems to scan is given, just use this list */
b03e89cf KS	121	udev_list_entry_foreach(list_entry, subsystem_include_list) {
	122	if (udev_list_entry_get_by_name(subsystem_exclude_list, udev_list_entry_get_name(list_entry)) != NULL)
	123	continue;
bc8184ed	124	devices_scan_subsystem(udev, basedir, udev_list_entry_get_name(list_entry), subdir, devices_list);
b03e89cf	125	}
bc8184ed KS	126	} else {
	127	char path[UTIL_PATH_SIZE];
	128	DIR *dir;
	129	struct dirent *dent;
	130
	131	/* if no list of subsystems to scan is given, scan all, and possible exclude some subsystems */
	132	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
	133	util_strlcat(path, basedir, sizeof(path));
	134	dir = opendir(path);
	135	if (dir == NULL)
	136	return -1;
	137	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	138	if (dent->d_name[0] == '.')
	139	continue;
	140	if (udev_list_entry_get_by_name(subsystem_exclude_list, dent->d_name) != NULL)
	141	continue;
	142	devices_scan_subsystem(udev, basedir, dent->d_name, subdir, devices_list);
	143	}
	144	closedir(dir);
eb1f0e66	145	}
eb1f0e66 KS	146	return 0;
	147	}
	148
8753fadf	149	static int devices_delay(struct udev udev, const char syspath)
eb1f0e66 KS	150	{
	151	static const char *delay_device_list[] = {
	152	"/block/md",
	153	"/block/dm-",
	154	NULL
	155	};
8753fadf	156	size_t len;
eb1f0e66 KS	157	int i;
eb1f0e66 KS	158
8753fadf KS	159	len = strlen(udev_get_sys_path(udev));
8753fadf KS	160
eb1f0e66	161	for (i = 0; delay_device_list[i] != NULL; i++) {
8753fadf KS	162	if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
8753fadf KS	163	info(udev, "delaying: %s\n", syspath);
eb1f0e66 KS	164	return 1;
	165	}
	166	}
	167	return 0;
	168	}
	169
438d4c3c KS	170	/**
	171	* udev_enumerate_new:
	172	* @udev: udev library context
	173	*
	174	* Returns: an enumeration context
	175	**/
	176	struct udev_enumerate udev_enumerate_new(struct udev udev)
6f67f1df KS	177	{
	178	struct udev_enumerate *udev_enumerate;
	179
	180	udev_enumerate = malloc(sizeof(struct udev_enumerate));
	181	if (udev_enumerate == NULL)
	182	return NULL;
	183	memset(udev_enumerate, 0x00, (sizeof(struct udev_enumerate)));
	184	udev_enumerate->refcount = 1;
	185	udev_enumerate->udev = udev;
	186	list_init(&udev_enumerate->devices_list);
	187	return udev_enumerate;
	188	}
	189
eb1f0e66	190	/**
438d4c3c KS	191	* udev_enumerate_scan_devices:
438d4c3c KS	192	* @udev_enumerate: udev enumeration context
bc8184ed	193	* @subsystem: the list of names of subsystems to look for devices
eb1f0e66	194	*
438d4c3c	195	* Returns: 0 on success.
eb1f0e66	196	**/
438d4c3c	197	int udev_enumerate_scan_devices(struct udev_enumerate udev_enumerate, const char subsystem, ...)
eb1f0e66	198	{
438d4c3c	199	struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
bc8184ed KS	200	va_list vargs;
bc8184ed KS	201	const char *arg;
3eb46ec6	202	char base[UTIL_PATH_SIZE];
eb1f0e66	203	struct stat statbuf;
bc8184ed KS	204	struct list_node subsystem_include_list;
bc8184ed KS	205	struct list_node subsystem_exclude_list;
0de33a61	206	struct udev_list_entry *list_entry;
bf7ad0ea	207
bf7ad0ea	208	if (udev_enumerate == NULL)
438d4c3c	209	return -EINVAL;
eb1f0e66	210
bc8184ed KS	211	va_start(vargs, subsystem);
	212	list_init(&subsystem_include_list);
	213	list_init(&subsystem_exclude_list);
	214	for (arg = subsystem; arg != NULL; arg = va_arg(vargs, const char *)) {
	215	if (arg[0] != '!')
	216	list_entry_add(udev, &subsystem_include_list, arg, NULL, 1, 0);
	217	else
	218	list_entry_add(udev, &subsystem_exclude_list, &arg[1], NULL, 1, 0);
	219	}
	220	va_end(vargs);
	221
3eb46ec6 KS	222	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
3eb46ec6 KS	223	util_strlcat(base, "/subsystem", sizeof(base));
eb1f0e66	224	if (stat(base, &statbuf) == 0) {
b03e89cf	225	/* we have /subsystem/, forget all the old stuff */
6f67f1df	226	info(udev, "searching '/subsystem//devices/' dir\n");
bc8184ed KS	227	devices_scan_subsystems(udev, "/subsystem", "/devices",
	228	list_get_entry(&subsystem_include_list),
	229	list_get_entry(&subsystem_exclude_list),
	230	&udev_enumerate->devices_list);
eb1f0e66	231	} else {
6f67f1df	232	info(udev, "searching '/bus//devices/' dir\n");
bc8184ed KS	233	devices_scan_subsystems(udev, "/bus", "/devices",
	234	list_get_entry(&subsystem_include_list),
	235	list_get_entry(&subsystem_exclude_list),
	236	&udev_enumerate->devices_list);
6f67f1df	237	info(udev, "searching '/class/*' dir\n");
bc8184ed KS	238	devices_scan_subsystems(udev, "/class", NULL,
	239	list_get_entry(&subsystem_include_list),
	240	list_get_entry(&subsystem_exclude_list),
	241	&udev_enumerate->devices_list);
b03e89cf KS	242	/* if block isn't a class, scan /block/ */
	243	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	244	util_strlcat(base, "/class/block", sizeof(base));
	245	if (stat(base, &statbuf) != 0) {
	246	struct udev_list_entry *include_list = list_get_entry(&subsystem_include_list);
	247	struct udev_list_entry *exclude_list = list_get_entry(&subsystem_exclude_list);
	248	int include_block = (include_list == NULL \|\| udev_list_entry_get_by_name(include_list, "block") != NULL);
	249	int exclude_block = (udev_list_entry_get_by_name(exclude_list, "block") != NULL);
	250
	251	if (include_block && !exclude_block) {
438d4c3c	252	info(udev, "searching '/block/*' dir\n");
b03e89cf KS	253	/* scan disks */
	254	devices_scan_subsystem(udev, "/block", NULL, NULL, &udev_enumerate->devices_list);
	255	/* scan partitions */
438d4c3c	256	info(udev, "searching '/block//' dir\n");
b03e89cf KS	257	devices_scan_subsystems(udev, "/block", NULL,
	258	NULL, NULL,
	259	&udev_enumerate->devices_list);
	260	}
	261	}
eb1f0e66 KS	262	}
eb1f0e66 KS	263
bc8184ed KS	264	list_cleanup(udev, &subsystem_include_list);
	265	list_cleanup(udev, &subsystem_exclude_list);
	266
bf7ad0ea	267	/* sort delayed devices to the end of the list */
0de33a61 KS	268	udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
	269	if (devices_delay(udev, udev_list_entry_get_name(list_entry)))
	270	list_entry_move_to_end(list_entry);
eb1f0e66	271	}
438d4c3c	272	return 0;
eb1f0e66	273	}
bc8184ed	274
438d4c3c KS	275	/**
	276	* udev_enumerate_scan_subsystems:
	277	* @udev_enumerate: udev enumeration context
	278	*
	279	* Returns: 0 on success.
	280	**/
	281	int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate)
bc8184ed	282	{
438d4c3c	283	struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
6f67f1df KS	284	char base[UTIL_PATH_SIZE];
	285	struct stat statbuf;
	286	const char *subsysdir;
	287
6f67f1df	288	if (udev_enumerate == NULL)
438d4c3c	289	return -EINVAL;
6f67f1df KS	290
	291	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	292	util_strlcat(base, "/subsystem", sizeof(base));
	293	if (stat(base, &statbuf) == 0)
	294	subsysdir = "/subsystem";
	295	else
	296	subsysdir = "/bus";
	297	info(udev, "searching '%s/*' dir\n", subsysdir);
	298	devices_scan_subsystem(udev, subsysdir, NULL, NULL, &udev_enumerate->devices_list);
	299	info(udev, "searching '%s//drivers/' dir\n", subsysdir);
	300	devices_scan_subsystems(udev, subsysdir, "/drivers",
	301	NULL, NULL,
	302	&udev_enumerate->devices_list);
438d4c3c	303	return 0;
bc8184ed	304	}