usr/kinit/kinit.c

#include <sys/mount.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <alloca.h>
#include <limits.h>
#include <ctype.h>
#include <termios.h>

#include "kinit.h"
#include "ipconfig.h"
#include "run-init.h"
#include "resume.h"

const char *progname = "kinit";
int mnt_procfs;
int mnt_sysfs;

#ifdef DEBUG
void dump_args(int argc, char *argv[])
{
	int i;

	printf("  argc == %d\n", argc);

	for (i = 0; i < argc; i++) {
		printf("  argv[%d]: \"%s\"\n", i, argv[i]);
	}

	if (argv[argc] != NULL) {
		printf("  argv[%d]: \"%s\" (SHOULD BE NULL)\n",
			argc, argv[argc]);
	}
}
#endif /* DEBUG */


static int do_ipconfig(int argc, char *argv[])
{
	int i, a = 0;
	char **args = alloca((argc + 3) * sizeof(char *));

	if (!args)
		return -1;

	args[a++] = (char *)"IP-Config";
	args[a++] = (char *)"-i";
	args[a++] = (char *)"Linux kinit";

	dprintf("Running ipconfig\n");

	for (i = 1; i < argc; i++) {
		if (strncmp(argv[i], "ip=", 3) == 0 ||
		    strncmp(argv[i], "nfsaddrs=", 9) == 0) {
			args[a++] = argv[i];
		}
	}

	if (a > 1) {
		args[a] = NULL;
		dump_args(a, args);
		return ipconfig_main(a, args);
	}

	return 0;
}

static int split_cmdline(int cmdcmax, char *cmdv[], char *argv0,
			 char *cmdlines[], char *args[])
{
	int was_space;
	char c, *p;
	int vmax = cmdcmax;
	int v = 1;
	int space;

	if (cmdv)
		cmdv[0] = argv0;

	/* First, add the parsable command lines */

	while (*cmdlines) {
		p = *cmdlines++;
		was_space = 1;
		while (v < vmax) {
			c = *p;
			space = isspace(c);
			if ((space || !c) && !was_space) {
				if (cmdv)
					*p = '\0';
				v++;
			} else if (was_space) {
				if (cmdv)
					cmdv[v] = p;
			}

			if (!c)
				break;

			was_space = space;
			p++;
		}
	}

	/* Second, add the explicit command line arguments */

	while (*args && v < vmax) {
		if (cmdv)
			cmdv[v] = *args;
		v++;
		args++;
	}

	if (cmdv)
		cmdv[v] = NULL;

	return v;
}

static int mount_sys_fs(const char *check, const char *fsname,
			const char *fstype)
{
	struct stat st;

	if (stat(check, &st) == 0) {
		return 0;
	}

	mkdir(fsname, 0555);

	if (mount("none", fsname, fstype, 0, NULL) == -1) {
		fprintf(stderr, "%s: could not mount %s as %s\n",
			progname, fsname, fstype);
		return -1;
	}

	return 1;
}

static void check_path(const char *path)
{
	struct stat st;

	if (stat(path, &st) == -1) {
		if (errno != ENOENT) {
			perror("stat");
			exit(1);
		}
		if (mkdir(path, 0755) == -1) {
			perror("mkdir");
			exit(1);
		}
	} else if (!S_ISDIR(st.st_mode)) {
		fprintf(stderr, "%s: '%s' not a directory\n", progname, path);
		exit(1);
	}
}

static const char *find_init(const char *root, const char *user)
{
	const char *init_paths[] = {
		"/sbin/init", "/bin/init", "/etc/init", "/bin/sh", NULL
	};
	const char **p;
	const char *path;

	if (chdir(root)) {
		perror("chdir");
		exit(1);
	}

	if (user)
		dprintf("Checking for init: %s\n", user);

	if (user && user[0] == '/' && !access(user+1, X_OK)) {
		path = user;
	} else {
		for (p = init_paths; *p; p++) {
			dprintf("Checking for init: %s\n", *p);
			if (!access(*p+1, X_OK))
				break;
		}
		path = *p;
	}
	chdir("/");
	return path;
}

/* This is the argc and argv we pass to init */
const char *init_path;
int init_argc;
char **init_argv;

extern ssize_t readfile(const char *, char **);

int main(int argc, char *argv[])
{
	char **cmdv, **args;
	char *cmdlines[3];
	int i;
	const char *errmsg;
	int ret = 0;
	int cmdc;
	int fd;
	struct timeval now;

	gettimeofday(&now, NULL);
	srand48(now.tv_usec ^ (now.tv_sec << 24));

	/* Default parameters for anything init-like we execute */
	init_argc = argc;
	init_argv = alloca((argc+1)*sizeof(char *));
	memcpy(init_argv, argv, (argc+1)*sizeof(char *));

	if ((fd = open("/dev/console", O_RDWR)) != -1) {
		dup2(fd, STDIN_FILENO);
		dup2(fd, STDOUT_FILENO);
		dup2(fd, STDERR_FILENO);

		if (fd > STDERR_FILENO) {
			close(fd);
		}
	}

	mnt_procfs = mount_sys_fs("/proc/cmdline", "/proc", "proc") >= 0;
	if (!mnt_procfs) {
		ret = 1;
		goto bail;
	}

	mnt_sysfs = mount_sys_fs("/sys/bus", "/sys", "sysfs") >= 0;
	if (!mnt_sysfs) {
		ret = 1;
		goto bail;
	}

	/* Construct the effective kernel command line.  The
	   effective kernel command line consists of /arch.cmd, if
	   it exists, /proc/cmdline, plus any arguments after an --
	   argument on the proper command line, in that order. */

	ret = readfile("/arch.cmd", &cmdlines[0]);
	if (ret < 0)
		cmdlines[0] = "";

	ret = readfile("/proc/cmdline", &cmdlines[1]);
	if (ret < 0) {
		fprintf(stderr, "%s: cannot read /proc/cmdline\n", progname);
		ret = 1;
		goto bail;
	}

	cmdlines[2] = NULL;

	/* Find an -- argument, and if so append to the command line */
	for (i = 1; i < argc; i++) {
		if (!strcmp(argv[i], "--")) {
			i++;
			break;
		}
	}
	args = &argv[i];	/* Points either to first argument past -- or
				   to the final NULL */

	/* Count the number of arguments */
	cmdc = split_cmdline(INT_MAX, NULL, argv[0], cmdlines, args);

	/* Actually generate the cmdline array */
	cmdv = (char **)alloca((cmdc+1)*sizeof(char *));
	if (split_cmdline(cmdc, cmdv, argv[0], cmdlines, args) != cmdc) {
		ret = 1;
		goto bail;
	}

	/* Debugging... */
	dump_args(cmdc, cmdv);

	/* Resume from suspend-to-disk, if appropriate */
	/* If successful, does not return */
	do_resume(cmdc, cmdv);

	/* Initialize networking, if applicable */
	do_ipconfig(cmdc, cmdv);

	check_path("/root");
	do_mounts(cmdc, cmdv);

	if (mnt_procfs) {
		umount2("/proc", 0);
		mnt_procfs = 0;
	}

	if (mnt_sysfs) {
		umount2("/sys", 0);
		mnt_sysfs = 0;
	}

	init_path = find_init("/root", get_arg(cmdc, cmdv, "init="));
	if (!init_path) {
		fprintf(stderr, "%s: init not found!\n", progname);
		ret = 2;
		goto bail;
	}

	init_argv[0] = strrchr(init_path, '/') + 1;

	errmsg = run_init("/root", "/dev/console", init_path, init_argv);

	/* If run_init returned, something went bad */
	fprintf(stderr, "%s: %s: %s\n", progname, errmsg, strerror(errno));
	ret = 2;
	goto bail;

bail:
	if (mnt_procfs)
		umount2("/proc", 0);

	if (mnt_sysfs)
		umount2("/sys", 0);

	/*
	 * If we get here, something bad probably happened, and the kernel
	 * will most likely panic.  Drain console output so the user can
	 * figure out what happened.
	 */
	tcdrain(2);
	tcdrain(1);

	return ret;
}
1	niro	532	#include <sys/mount.h>
2			#include <sys/stat.h>
3			#include <errno.h>
4			#include <fcntl.h>
5			#include <stdio.h>
6			#include <stdlib.h>
7			#include <string.h>
8			#include <alloca.h>
9			#include <limits.h>
10			#include <ctype.h>
11			#include <termios.h>
12
13			#include "kinit.h"
14			#include "ipconfig.h"
15			#include "run-init.h"
16			#include "resume.h"
17
18			const char *progname = "kinit";
19			int mnt_procfs;
20			int mnt_sysfs;
21
22	niro	1122	#ifdef DEBUG
23	niro	532	void dump_args(int argc, char *argv[])
24			{
25			int i;
26
27			printf(" argc == %d\n", argc);
28
29			for (i = 0; i < argc; i++) {
30			printf(" argv[%d]: \"%s\"\n", i, argv[i]);
31			}
32
33			if (argv[argc] != NULL) {
34			printf(" argv[%d]: \"%s\" (SHOULD BE NULL)\n",
35	niro	1122	argc, argv[argc]);
36	niro	532	}
37			}
38	niro	1122	#endif /* DEBUG */
39	niro	532
40
41			static int do_ipconfig(int argc, char *argv[])
42			{
43			int i, a = 0;
44			char *args = alloca((argc + 3) sizeof(char *));
45
46			if (!args)
47			return -1;
48
49			args[a++] = (char *)"IP-Config";
50			args[a++] = (char *)"-i";
51			args[a++] = (char *)"Linux kinit";
52
53	niro	1122	dprintf("Running ipconfig\n");
54	niro	532
55			for (i = 1; i < argc; i++) {
56			if (strncmp(argv[i], "ip=", 3) == 0 \|\|
57			strncmp(argv[i], "nfsaddrs=", 9) == 0) {
58			args[a++] = argv[i];
59			}
60			}
61
62			if (a > 1) {
63			args[a] = NULL;
64			dump_args(a, args);
65			return ipconfig_main(a, args);
66			}
67
68			return 0;
69			}
70
71			static int split_cmdline(int cmdcmax, char cmdv[], char argv0,
72			char cmdlines[], char args[])
73			{
74			int was_space;
75			char c, *p;
76			int vmax = cmdcmax;
77			int v = 1;
78			int space;
79
80			if (cmdv)
81			cmdv[0] = argv0;
82
83			/* First, add the parsable command lines */
84
85			while (*cmdlines) {
86			p = *cmdlines++;
87			was_space = 1;
88			while (v < vmax) {
89			c = *p;
90			space = isspace(c);
91			if ((space \|\| !c) && !was_space) {
92			if (cmdv)
93			*p = '\0';
94			v++;
95			} else if (was_space) {
96			if (cmdv)
97			cmdv[v] = p;
98			}
99
100			if (!c)
101			break;
102
103			was_space = space;
104			p++;
105			}
106			}
107
108			/* Second, add the explicit command line arguments */
109
110			while (*args && v < vmax) {
111			if (cmdv)
112			cmdv[v] = *args;
113			v++;
114			args++;
115			}
116
117			if (cmdv)
118			cmdv[v] = NULL;
119
120			return v;
121			}
122
123			static int mount_sys_fs(const char check, const char fsname,
124			const char *fstype)
125			{
126			struct stat st;
127
128			if (stat(check, &st) == 0) {
129			return 0;
130			}
131
132			mkdir(fsname, 0555);
133
134			if (mount("none", fsname, fstype, 0, NULL) == -1) {
135			fprintf(stderr, "%s: could not mount %s as %s\n",
136			progname, fsname, fstype);
137			return -1;
138			}
139
140			return 1;
141			}
142
143			static void check_path(const char *path)
144			{
145			struct stat st;
146
147			if (stat(path, &st) == -1) {
148			if (errno != ENOENT) {
149			perror("stat");
150			exit(1);
151			}
152			if (mkdir(path, 0755) == -1) {
153			perror("mkdir");
154			exit(1);
155			}
156			} else if (!S_ISDIR(st.st_mode)) {
157			fprintf(stderr, "%s: '%s' not a directory\n", progname, path);
158			exit(1);
159			}
160			}
161
162			static const char find_init(const char root, const char *user)
163			{
164			const char *init_paths[] = {
165			"/sbin/init", "/bin/init", "/etc/init", "/bin/sh", NULL
166			};
167			const char **p;
168			const char *path;
169
170			if (chdir(root)) {
171			perror("chdir");
172			exit(1);
173			}
174
175			if (user)
176	niro	1122	dprintf("Checking for init: %s\n", user);
177	niro	532
178			if (user && user[0] == '/' && !access(user+1, X_OK)) {
179			path = user;
180			} else {
181			for (p = init_paths; *p; p++) {
182	niro	1122	dprintf("Checking for init: %s\n", *p);
183	niro	532	if (!access(*p+1, X_OK))
184			break;
185			}
186			path = *p;
187			}
188			chdir("/");
189			return path;
190			}
191
192			/* This is the argc and argv we pass to init */
193			const char *init_path;
194			int init_argc;
195			char **init_argv;
196
197			extern ssize_t readfile(const char , char *);
198
199			int main(int argc, char *argv[])
200			{
201			char cmdv, args;
202			char *cmdlines[3];
203			int i;
204			const char *errmsg;
205			int ret = 0;
206			int cmdc;
207			int fd;
208			struct timeval now;
209
210			gettimeofday(&now, NULL);
211			srand48(now.tv_usec ^ (now.tv_sec << 24));
212
213			/* Default parameters for anything init-like we execute */
214			init_argc = argc;
215			init_argv = alloca((argc+1)sizeof(char ));
216			memcpy(init_argv, argv, (argc+1)sizeof(char ));
217
218			if ((fd = open("/dev/console", O_RDWR)) != -1) {
219			dup2(fd, STDIN_FILENO);
220			dup2(fd, STDOUT_FILENO);
221			dup2(fd, STDERR_FILENO);
222
223			if (fd > STDERR_FILENO) {
224			close(fd);
225			}
226			}
227
228			mnt_procfs = mount_sys_fs("/proc/cmdline", "/proc", "proc") >= 0;
229			if (!mnt_procfs) {
230			ret = 1;
231			goto bail;
232			}
233
234			mnt_sysfs = mount_sys_fs("/sys/bus", "/sys", "sysfs") >= 0;
235			if (!mnt_sysfs) {
236			ret = 1;
237			goto bail;
238			}
239
240			/* Construct the effective kernel command line. The
241			effective kernel command line consists of /arch.cmd, if
242			it exists, /proc/cmdline, plus any arguments after an --
243			argument on the proper command line, in that order. */
244
245			ret = readfile("/arch.cmd", &cmdlines[0]);
246			if (ret < 0)
247			cmdlines[0] = "";
248
249			ret = readfile("/proc/cmdline", &cmdlines[1]);
250			if (ret < 0) {
251			fprintf(stderr, "%s: cannot read /proc/cmdline\n", progname);
252			ret = 1;
253			goto bail;
254			}
255
256			cmdlines[2] = NULL;
257
258			/* Find an -- argument, and if so append to the command line */
259			for (i = 1; i < argc; i++) {
260			if (!strcmp(argv[i], "--")) {
261			i++;
262			break;
263			}
264			}
265			args = &argv[i]; /* Points either to first argument past -- or
266			to the final NULL */
267
268			/* Count the number of arguments */
269			cmdc = split_cmdline(INT_MAX, NULL, argv[0], cmdlines, args);
270
271			/* Actually generate the cmdline array */
272			cmdv = (char *)alloca((cmdc+1)sizeof(char *));
273			if (split_cmdline(cmdc, cmdv, argv[0], cmdlines, args) != cmdc) {
274			ret = 1;
275			goto bail;
276			}
277
278			/* Debugging... */
279			dump_args(cmdc, cmdv);
280
281			/* Resume from suspend-to-disk, if appropriate */
282			/* If successful, does not return */
283			do_resume(cmdc, cmdv);
284
285			/* Initialize networking, if applicable */
286			do_ipconfig(cmdc, cmdv);
287
288			check_path("/root");
289			do_mounts(cmdc, cmdv);
290
291			if (mnt_procfs) {
292			umount2("/proc", 0);
293			mnt_procfs = 0;
294			}
295
296			if (mnt_sysfs) {
297			umount2("/sys", 0);
298			mnt_sysfs = 0;
299			}
300
301			init_path = find_init("/root", get_arg(cmdc, cmdv, "init="));
302			if (!init_path) {
303			fprintf(stderr, "%s: init not found!\n", progname);
304			ret = 2;
305			goto bail;
306			}
307
308			init_argv[0] = strrchr(init_path, '/') + 1;
309
310			errmsg = run_init("/root", "/dev/console", init_path, init_argv);
311
312			/* If run_init returned, something went bad */
313			fprintf(stderr, "%s: %s: %s\n", progname, errmsg, strerror(errno));
314			ret = 2;
315			goto bail;
316
317			bail:
318			if (mnt_procfs)
319			umount2("/proc", 0);
320
321			if (mnt_sysfs)
322			umount2("/sys", 0);
323
324			/*
325			* If we get here, something bad probably happened, and the kernel
326			* will most likely panic. Drain console output so the user can
327			* figure out what happened.
328			*/
329			tcdrain(2);
330			tcdrain(1);
331
332			return ret;
333			}