[thirdparty/systemd.git] / udevstart.c

/*
 * udevstart.c
 *
 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
 * 
 * Quick and dirty way to populate a /dev with udev if your system
 * does not have access to a shell.  Based originally on a patch to udev 
 * from Harald Hoyer <harald@redhat.com>
 *
 *	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 version 2 of the License.
 * 
 *	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, write to the Free Software Foundation, Inc.,
 *	675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <dirent.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>

#include "logging.h"
#include "udev_lib.h"
#include "list.h"


#ifdef LOG
unsigned char logname[LOGNAME_SIZE];
void log_message(int level, const char *format, ...)
{
	va_list args;

	va_start(args, format);
	vsyslog(level, format, args);
	va_end(args);
}
#endif


#define MAX_PATHLEN		1024
#define SYSBLOCK		"/sys/block"
#define SYSCLASS		"/sys/class"
#define UDEV_BIN		"/sbin/udev"

struct device {
	struct list_head list;
	char path[MAX_PATHLEN];
	char subsys[MAX_PATHLEN];
};

/* sort files in lexical order */
static int device_list_insert(char *path, char *subsystem, struct list_head *device_list)
{
	struct device *loop_device;
	struct device *new_device;

	list_for_each_entry(loop_device, device_list, list) {
		if (strcmp(loop_device->path, path) > 0) {
			break;
		}
	}

	new_device = malloc(sizeof(struct device));
	if (new_device == NULL) {
		dbg("error malloc");
		return -ENOMEM;
	}

	strfieldcpy(new_device->path, path);
	strfieldcpy(new_device->subsys, subsystem);
	list_add_tail(&new_device->list, &loop_device->list);
	return 0;
}

static void udev_exec(const char *path, const char* subsystem)
{
	pid_t pid;
	char action[] = "ACTION=add";
	char devpath[MAX_PATHLEN];
	char nosleep[] = "UDEV_NO_SLEEP=1";
	char *env[] = { action, devpath, nosleep, NULL };

	return;
	strcpy(devpath, "DEVPATH=");
	strfieldcat(devpath, path);

	pid = fork();
	switch (pid) {
	case 0:
		/* child */
		execle(UDEV_BIN, "udev", subsystem, NULL, env);
		dbg("exec of child failed");
		exit(1);
		break;
	case -1:
		dbg("fork of child failed");
		break;
	default:
		wait(NULL);
	}
}

/* list of devices that we should run last due to any one of a number of reasons */
static char *last_list[] = {
	"/block/dm",	/* on here because dm wants to have the block devices around before it */
	NULL,
};

static void exec_list(struct list_head *device_list)
{
	struct device *loop_device;
	struct device *tmp_device;

	/* handle the devices we are allowed to, excluding the "last" type devices */
	list_for_each_entry_safe(loop_device, tmp_device, device_list, list) {
		int found = 0;
		int i;
		for (i=0; last_list[i] != NULL; i++) {
			if (strncmp(loop_device->path, last_list[i], strlen(last_list[i])) == 0) {
				found = 1;
				break;
			}
		}
		if (found)
			continue;

		udev_exec(loop_device->path, loop_device->subsys);
		list_del(&loop_device->list);
		free(loop_device);
	}

	/* handle the rest of the devices left over, if any */
	list_for_each_entry_safe(loop_device, tmp_device, device_list, list) {
		udev_exec(loop_device->path, loop_device->subsys);
		list_del(&loop_device->list);
		free(loop_device);
	}
}

static void udev_scan_block(void)
{
	DIR *dir;
	struct dirent *dent;
	LIST_HEAD(device_list);

	dir = opendir(SYSBLOCK);
	if (dir != NULL) {
		for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
			char dirname[MAX_PATHLEN];
			DIR *dir2;
			struct dirent *dent2;

			if ((strcmp(dent->d_name, ".") == 0) ||
			    (strcmp(dent->d_name, "..") == 0))
				continue;

			snprintf(dirname, MAX_PATHLEN, "/block/%s", dent->d_name);
			dirname[MAX_PATHLEN-1] = '\0';
			device_list_insert(dirname, "block", &device_list);

			snprintf(dirname, MAX_PATHLEN, "%s/%s", SYSBLOCK, dent->d_name);
			dir2 = opendir(dirname);
			if (dir2 != NULL) {
				for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) {
					char dirname2[MAX_PATHLEN];
					DIR *dir3;
					struct dirent *dent3;

					if ((strcmp(dent2->d_name, ".") == 0) ||
					    (strcmp(dent2->d_name, "..") == 0))
						continue;

					snprintf(dirname2, MAX_PATHLEN, "%s/%s", dirname, dent2->d_name);
					dirname2[MAX_PATHLEN-1] = '\0';

					dir3 = opendir(dirname2);
					if (dir3 != NULL) {
						for (dent3 = readdir(dir3); dent3 != NULL; dent3 = readdir(dir3)) {
							char filename[MAX_PATHLEN];

							if (strcmp(dent3->d_name, "dev") == 0) {
								snprintf(filename, MAX_PATHLEN, "/block/%s/%s",
									 dent->d_name, dent2->d_name);
								filename[MAX_PATHLEN-1] = '\0';
								device_list_insert(filename, "block", &device_list);
							}
						}
						closedir(dir3);
					}
				}
				closedir(dir2);
			}
		}
		closedir(dir);
	}

	exec_list(&device_list);
}

static void udev_scan_class(void)
{
	DIR *dir;
	struct dirent *dent;
	LIST_HEAD(device_list);

	dir = opendir(SYSCLASS);
	if (dir != NULL) {
		for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
			char dirname[MAX_PATHLEN];
			DIR *dir2;
			struct dirent *dent2;

			if ((strcmp(dent->d_name, ".") == 0) ||
			    (strcmp(dent->d_name, "..") == 0))
				continue;

			snprintf(dirname, MAX_PATHLEN, "%s/%s", SYSCLASS, dent->d_name);
			dirname[MAX_PATHLEN] = '\0';
			dir2 = opendir(dirname);
			if (dir2 != NULL) {
				for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) {
					char dirname2[MAX_PATHLEN-1];
					DIR *dir3;
					struct dirent *dent3;

					if ((strcmp(dent2->d_name, ".") == 0) ||
					    (strcmp(dent2->d_name, "..") == 0))
						continue;

					snprintf(dirname2, MAX_PATHLEN, "%s/%s", dirname, dent2->d_name);
					dirname2[MAX_PATHLEN-1] = '\0';

					dir3 = opendir(dirname2);
					if (dir3 != NULL) {
						for (dent3 = readdir(dir3); dent3 != NULL; dent3 = readdir(dir3)) {
							char filename[MAX_PATHLEN];

							if (strcmp(dent3->d_name, "dev") == 0) {
								snprintf(filename, MAX_PATHLEN, "/class/%s/%s",
									 dent->d_name, dent2->d_name);
								filename[MAX_PATHLEN-1] = '\0';
								device_list_insert(filename, dent->d_name, &device_list);
							}
						}
						closedir(dir3);
					}
				}
				closedir(dir2);
			}
		}
		closedir(dir);
	}

	exec_list(&device_list);
}

int main(int argc, char *argv[], char *envp[])
{
	init_logging("udevstart");

	udev_scan_class();
	udev_scan_block();

	return 0;
}
Commit	Line	Data
82b9a637 GKH	1	/*
	2	* udevstart.c
	3	*
	4	* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
	5	*
	6	* Quick and dirty way to populate a /dev with udev if your system
	7	* does not have access to a shell. Based originally on a patch to udev
	8	* from Harald Hoyer <harald@redhat.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the
	12	* Free Software Foundation version 2 of the License.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*
	23	*/
	24
	25	#include <stdlib.h>
0e306d08	26	#include <stddef.h>
82b9a637 GKH	27	#include <string.h>
	28	#include <stdio.h>
	29	#include <errno.h>
	30	#include <ctype.h>
82b9a637 GKH	31	#include <dirent.h>
82b9a637 GKH	32	#include <sys/wait.h>
f27125f9	33	#include <sys/types.h>
f27125f9	34	#include <unistd.h>
82b9a637 GKH	35
82b9a637 GKH	36	#include "logging.h"
9b28a52a	37	#include "udev_lib.h"
0e306d08	38	#include "list.h"
82b9a637 GKH	39
	40
	41	#ifdef LOG
d00bd172	42	unsigned char logname[LOGNAME_SIZE];
82b9a637 GKH	43	void log_message(int level, const char *format, ...)
	44	{
	45	va_list args;
	46
	47	va_start(args, format);
	48	vsyslog(level, format, args);
	49	va_end(args);
	50	}
	51	#endif
	52
	53
e4dc0e11 KS	54	#define MAX_PATHLEN 1024
	55	#define SYSBLOCK "/sys/block"
	56	#define SYSCLASS "/sys/class"
	57	#define UDEV_BIN "/sbin/udev"
82b9a637	58
0e306d08 GKH	59	struct device {
	60	struct list_head list;
	61	char path[MAX_PATHLEN];
	62	char subsys[MAX_PATHLEN];
	63	};
	64
	65	/* sort files in lexical order */
	66	static int device_list_insert(char path, char subsystem, struct list_head *device_list)
	67	{
	68	struct device *loop_device;
	69	struct device *new_device;
	70
	71	list_for_each_entry(loop_device, device_list, list) {
	72	if (strcmp(loop_device->path, path) > 0) {
	73	break;
	74	}
	75	}
	76
	77	new_device = malloc(sizeof(struct device));
	78	if (new_device == NULL) {
	79	dbg("error malloc");
	80	return -ENOMEM;
	81	}
	82
	83	strfieldcpy(new_device->path, path);
	84	strfieldcpy(new_device->subsys, subsystem);
	85	list_add_tail(&new_device->list, &loop_device->list);
	86	return 0;
	87	}
	88
e4dc0e11	89	static void udev_exec(const char path, const char subsystem)
82b9a637	90	{
82b9a637	91	pid_t pid;
e4dc0e11 KS	92	char action[] = "ACTION=add";
	93	char devpath[MAX_PATHLEN];
	94	char nosleep[] = "UDEV_NO_SLEEP=1";
	95	char *env[] = { action, devpath, nosleep, NULL };
	96
0e306d08	97	return;
5df33ccd KS	98	strcpy(devpath, "DEVPATH=");
5df33ccd KS	99	strfieldcat(devpath, path);
e4dc0e11	100
82b9a637	101	pid = fork();
e4dc0e11	102	switch (pid) {
82b9a637 GKH	103	case 0:
82b9a637 GKH	104	/* child */
e4dc0e11 KS	105	execle(UDEV_BIN, "udev", subsystem, NULL, env);
e4dc0e11 KS	106	dbg("exec of child failed");
82b9a637	107	exit(1);
e4dc0e11	108	break;
82b9a637	109	case -1:
e4dc0e11 KS	110	dbg("fork of child failed");
e4dc0e11 KS	111	break;
82b9a637	112	default:
e4dc0e11	113	wait(NULL);
82b9a637	114	}
82b9a637 GKH	115	}
82b9a637 GKH	116
0e306d08 GKH	117	/* list of devices that we should run last due to any one of a number of reasons */
	118	static char *last_list[] = {
	119	"/block/dm", /* on here because dm wants to have the block devices around before it */
	120	NULL,
	121	};
	122
	123	static void exec_list(struct list_head *device_list)
	124	{
	125	struct device *loop_device;
	126	struct device *tmp_device;
	127
	128	/* handle the devices we are allowed to, excluding the "last" type devices */
	129	list_for_each_entry_safe(loop_device, tmp_device, device_list, list) {
	130	int found = 0;
	131	int i;
	132	for (i=0; last_list[i] != NULL; i++) {
	133	if (strncmp(loop_device->path, last_list[i], strlen(last_list[i])) == 0) {
	134	found = 1;
	135	break;
	136	}
	137	}
	138	if (found)
	139	continue;
	140
	141	udev_exec(loop_device->path, loop_device->subsys);
	142	list_del(&loop_device->list);
	143	free(loop_device);
	144	}
	145
	146	/* handle the rest of the devices left over, if any */
	147	list_for_each_entry_safe(loop_device, tmp_device, device_list, list) {
	148	udev_exec(loop_device->path, loop_device->subsys);
	149	list_del(&loop_device->list);
	150	free(loop_device);
	151	}
	152	}
	153
	154	static void udev_scan_block(void)
82b9a637	155	{
e4dc0e11 KS	156	DIR *dir;
e4dc0e11 KS	157	struct dirent *dent;
0e306d08	158	LIST_HEAD(device_list);
82b9a637	159
0e306d08	160	dir = opendir(SYSBLOCK);
e4dc0e11 KS	161	if (dir != NULL) {
	162	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	163	char dirname[MAX_PATHLEN];
	164	DIR *dir2;
	165	struct dirent *dent2;
	166
	167	if ((strcmp(dent->d_name, ".") == 0) \|\|
	168	(strcmp(dent->d_name, "..") == 0))
82b9a637 GKH	169	continue;
82b9a637 GKH	170
0e306d08 GKH	171	snprintf(dirname, MAX_PATHLEN, "/block/%s", dent->d_name);
	172	dirname[MAX_PATHLEN-1] = '\0';
	173	device_list_insert(dirname, "block", &device_list);
	174
	175	snprintf(dirname, MAX_PATHLEN, "%s/%s", SYSBLOCK, dent->d_name);
82b9a637	176	dir2 = opendir(dirname);
e4dc0e11 KS	177	if (dir2 != NULL) {
e4dc0e11 KS	178	for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) {
0e306d08	179	char dirname2[MAX_PATHLEN];
e4dc0e11 KS	180	DIR *dir3;
e4dc0e11 KS	181	struct dirent *dent3;
82b9a637 GKH	182
	183	if ((strcmp(dent2->d_name, ".") == 0) \|\|
	184	(strcmp(dent2->d_name, "..") == 0))
	185	continue;
	186
	187	snprintf(dirname2, MAX_PATHLEN, "%s/%s", dirname, dent2->d_name);
e4dc0e11	188	dirname2[MAX_PATHLEN-1] = '\0';
82b9a637 GKH	189
82b9a637 GKH	190	dir3 = opendir(dirname2);
e4dc0e11 KS	191	if (dir3 != NULL) {
e4dc0e11 KS	192	for (dent3 = readdir(dir3); dent3 != NULL; dent3 = readdir(dir3)) {
82b9a637 GKH	193	char filename[MAX_PATHLEN];
	194
	195	if (strcmp(dent3->d_name, "dev") == 0) {
0e306d08	196	snprintf(filename, MAX_PATHLEN, "/block/%s/%s",
e4dc0e11 KS	197	dent->d_name, dent2->d_name);
e4dc0e11 KS	198	filename[MAX_PATHLEN-1] = '\0';
0e306d08	199	device_list_insert(filename, "block", &device_list);
82b9a637 GKH	200	}
82b9a637 GKH	201	}
e13fa599	202	closedir(dir3);
82b9a637 GKH	203	}
82b9a637 GKH	204	}
e13fa599	205	closedir(dir2);
82b9a637 GKH	206	}
82b9a637 GKH	207	}
e13fa599	208	closedir(dir);
82b9a637 GKH	209	}
82b9a637 GKH	210
0e306d08 GKH	211	exec_list(&device_list);
	212	}
	213
	214	static void udev_scan_class(void)
	215	{
	216	DIR *dir;
	217	struct dirent *dent;
	218	LIST_HEAD(device_list);
	219
	220	dir = opendir(SYSCLASS);
e4dc0e11 KS	221	if (dir != NULL) {
	222	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	223	char dirname[MAX_PATHLEN];
	224	DIR *dir2;
	225	struct dirent *dent2;
	226
	227	if ((strcmp(dent->d_name, ".") == 0) \|\|
	228	(strcmp(dent->d_name, "..") == 0))
82b9a637 GKH	229	continue;
82b9a637 GKH	230
0e306d08 GKH	231	snprintf(dirname, MAX_PATHLEN, "%s/%s", SYSCLASS, dent->d_name);
0e306d08 GKH	232	dirname[MAX_PATHLEN] = '\0';
82b9a637	233	dir2 = opendir(dirname);
e4dc0e11 KS	234	if (dir2 != NULL) {
e4dc0e11 KS	235	for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) {
0e306d08	236	char dirname2[MAX_PATHLEN-1];
e4dc0e11 KS	237	DIR *dir3;
e4dc0e11 KS	238	struct dirent *dent3;
82b9a637	239
e4dc0e11 KS	240	if ((strcmp(dent2->d_name, ".") == 0) \|\|
e4dc0e11 KS	241	(strcmp(dent2->d_name, "..") == 0))
82b9a637 GKH	242	continue;
	243
	244	snprintf(dirname2, MAX_PATHLEN, "%s/%s", dirname, dent2->d_name);
e4dc0e11	245	dirname2[MAX_PATHLEN-1] = '\0';
82b9a637 GKH	246
82b9a637 GKH	247	dir3 = opendir(dirname2);
e4dc0e11 KS	248	if (dir3 != NULL) {
	249	for (dent3 = readdir(dir3); dent3 != NULL; dent3 = readdir(dir3)) {
	250	char filename[MAX_PATHLEN];
82b9a637 GKH	251
82b9a637 GKH	252	if (strcmp(dent3->d_name, "dev") == 0) {
0e306d08	253	snprintf(filename, MAX_PATHLEN, "/class/%s/%s",
e4dc0e11 KS	254	dent->d_name, dent2->d_name);
e4dc0e11 KS	255	filename[MAX_PATHLEN-1] = '\0';
0e306d08	256	device_list_insert(filename, dent->d_name, &device_list);
82b9a637 GKH	257	}
82b9a637 GKH	258	}
e13fa599	259	closedir(dir3);
82b9a637 GKH	260	}
82b9a637 GKH	261	}
e13fa599	262	closedir(dir2);
82b9a637 GKH	263	}
82b9a637 GKH	264	}
e13fa599	265	closedir(dir);
82b9a637	266	}
0e306d08 GKH	267
0e306d08 GKH	268	exec_list(&device_list);
82b9a637 GKH	269	}
82b9a637 GKH	270
d00bd172	271	int main(int argc, char argv[], char envp[])
82b9a637 GKH	272	{
	273	init_logging("udevstart");
	274
0e306d08 GKH	275	udev_scan_class();
0e306d08 GKH	276	udev_scan_block();
3f20eac0 MI	277
3f20eac0 MI	278	return 0;
82b9a637	279	}