PageRenderTime 180ms CodeModel.GetById 45ms app.highlight 85ms RepoModel.GetById 10ms app.codeStats 0ms

/arch/um/os-Linux/umid.c

https://bitbucket.org/ndreys/linux-sunxi
C | 396 lines | 286 code | 66 blank | 44 comment | 68 complexity | d3a8084a125d5cebc911b46ca049dc5e MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1/*
  2 * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  3 * Licensed under the GPL
  4 */
  5
  6#include <stdio.h>
  7#include <stdlib.h>
  8#include <dirent.h>
  9#include <errno.h>
 10#include <fcntl.h>
 11#include <signal.h>
 12#include <string.h>
 13#include <unistd.h>
 14#include <sys/stat.h>
 15#include "init.h"
 16#include "kern_constants.h"
 17#include "os.h"
 18#include "user.h"
 19
 20#define UML_DIR "~/.uml/"
 21
 22#define UMID_LEN 64
 23
 24/* Changed by set_umid, which is run early in boot */
 25static char umid[UMID_LEN] = { 0 };
 26
 27/* Changed by set_uml_dir and make_uml_dir, which are run early in boot */
 28static char *uml_dir = UML_DIR;
 29
 30static int __init make_uml_dir(void)
 31{
 32	char dir[512] = { '\0' };
 33	int len, err;
 34
 35	if (*uml_dir == '~') {
 36		char *home = getenv("HOME");
 37
 38		err = -ENOENT;
 39		if (home == NULL) {
 40			printk(UM_KERN_ERR "make_uml_dir : no value in "
 41			       "environment for $HOME\n");
 42			goto err;
 43		}
 44		strlcpy(dir, home, sizeof(dir));
 45		uml_dir++;
 46	}
 47	strlcat(dir, uml_dir, sizeof(dir));
 48	len = strlen(dir);
 49	if (len > 0 && dir[len - 1] != '/')
 50		strlcat(dir, "/", sizeof(dir));
 51
 52	err = -ENOMEM;
 53	uml_dir = malloc(strlen(dir) + 1);
 54	if (uml_dir == NULL) {
 55		printf("make_uml_dir : malloc failed, errno = %d\n", errno);
 56		goto err;
 57	}
 58	strcpy(uml_dir, dir);
 59
 60	if ((mkdir(uml_dir, 0777) < 0) && (errno != EEXIST)) {
 61	        printf("Failed to mkdir '%s': %s\n", uml_dir, strerror(errno));
 62		err = -errno;
 63		goto err_free;
 64	}
 65	return 0;
 66
 67err_free:
 68	free(uml_dir);
 69err:
 70	uml_dir = NULL;
 71	return err;
 72}
 73
 74/*
 75 * Unlinks the files contained in @dir and then removes @dir.
 76 * Doesn't handle directory trees, so it's not like rm -rf, but almost such. We
 77 * ignore ENOENT errors for anything (they happen, strangely enough - possibly
 78 * due to races between multiple dying UML threads).
 79 */
 80static int remove_files_and_dir(char *dir)
 81{
 82	DIR *directory;
 83	struct dirent *ent;
 84	int len;
 85	char file[256];
 86	int ret;
 87
 88	directory = opendir(dir);
 89	if (directory == NULL) {
 90		if (errno != ENOENT)
 91			return -errno;
 92		else
 93			return 0;
 94	}
 95
 96	while ((ent = readdir(directory)) != NULL) {
 97		if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))
 98			continue;
 99		len = strlen(dir) + sizeof("/") + strlen(ent->d_name) + 1;
100		if (len > sizeof(file)) {
101			ret = -E2BIG;
102			goto out;
103		}
104
105		sprintf(file, "%s/%s", dir, ent->d_name);
106		if (unlink(file) < 0 && errno != ENOENT) {
107			ret = -errno;
108			goto out;
109		}
110	}
111
112	if (rmdir(dir) < 0 && errno != ENOENT) {
113		ret = -errno;
114		goto out;
115	}
116
117	ret = 0;
118out:
119	closedir(directory);
120	return ret;
121}
122
123/*
124 * This says that there isn't already a user of the specified directory even if
125 * there are errors during the checking.  This is because if these errors
126 * happen, the directory is unusable by the pre-existing UML, so we might as
127 * well take it over.  This could happen either by
128 * 	the existing UML somehow corrupting its umid directory
129 * 	something other than UML sticking stuff in the directory
130 *	this boot racing with a shutdown of the other UML
131 * In any of these cases, the directory isn't useful for anything else.
132 *
133 * Boolean return: 1 if in use, 0 otherwise.
134 */
135static inline int is_umdir_used(char *dir)
136{
137	char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
138	char pid[sizeof("nnnnn\0")], *end;
139	int dead, fd, p, n, err;
140
141	n = snprintf(file, sizeof(file), "%s/pid", dir);
142	if (n >= sizeof(file)) {
143		printk(UM_KERN_ERR "is_umdir_used - pid filename too long\n");
144		err = -E2BIG;
145		goto out;
146	}
147
148	dead = 0;
149	fd = open(file, O_RDONLY);
150	if (fd < 0) {
151		fd = -errno;
152		if (fd != -ENOENT) {
153			printk(UM_KERN_ERR "is_umdir_used : couldn't open pid "
154			       "file '%s', err = %d\n", file, -fd);
155		}
156		goto out;
157	}
158
159	err = 0;
160	n = read(fd, pid, sizeof(pid));
161	if (n < 0) {
162		printk(UM_KERN_ERR "is_umdir_used : couldn't read pid file "
163		       "'%s', err = %d\n", file, errno);
164		goto out_close;
165	} else if (n == 0) {
166		printk(UM_KERN_ERR "is_umdir_used : couldn't read pid file "
167		       "'%s', 0-byte read\n", file);
168		goto out_close;
169	}
170
171	p = strtoul(pid, &end, 0);
172	if (end == pid) {
173		printk(UM_KERN_ERR "is_umdir_used : couldn't parse pid file "
174		       "'%s', errno = %d\n", file, errno);
175		goto out_close;
176	}
177
178	if ((kill(p, 0) == 0) || (errno != ESRCH)) {
179		printk(UM_KERN_ERR "umid \"%s\" is already in use by pid %d\n",
180		       umid, p);
181		return 1;
182	}
183
184out_close:
185	close(fd);
186out:
187	return 0;
188}
189
190/*
191 * Try to remove the directory @dir unless it's in use.
192 * Precondition: @dir exists.
193 * Returns 0 for success, < 0 for failure in removal or if the directory is in
194 * use.
195 */
196static int umdir_take_if_dead(char *dir)
197{
198	int ret;
199	if (is_umdir_used(dir))
200		return -EEXIST;
201
202	ret = remove_files_and_dir(dir);
203	if (ret) {
204		printk(UM_KERN_ERR "is_umdir_used - remove_files_and_dir "
205		       "failed with err = %d\n", ret);
206	}
207	return ret;
208}
209
210static void __init create_pid_file(void)
211{
212	char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
213	char pid[sizeof("nnnnn\0")];
214	int fd, n;
215
216	if (umid_file_name("pid", file, sizeof(file)))
217		return;
218
219	fd = open(file, O_RDWR | O_CREAT | O_EXCL, 0644);
220	if (fd < 0) {
221		printk(UM_KERN_ERR "Open of machine pid file \"%s\" failed: "
222		       "%s\n", file, strerror(errno));
223		return;
224	}
225
226	snprintf(pid, sizeof(pid), "%d\n", getpid());
227	n = write(fd, pid, strlen(pid));
228	if (n != strlen(pid))
229		printk(UM_KERN_ERR "Write of pid file failed - err = %d\n",
230		       errno);
231
232	close(fd);
233}
234
235int __init set_umid(char *name)
236{
237	if (strlen(name) > UMID_LEN - 1)
238		return -E2BIG;
239
240	strlcpy(umid, name, sizeof(umid));
241
242	return 0;
243}
244
245/* Changed in make_umid, which is called during early boot */
246static int umid_setup = 0;
247
248static int __init make_umid(void)
249{
250	int fd, err;
251	char tmp[256];
252
253	if (umid_setup)
254		return 0;
255
256	make_uml_dir();
257
258	if (*umid == '\0') {
259		strlcpy(tmp, uml_dir, sizeof(tmp));
260		strlcat(tmp, "XXXXXX", sizeof(tmp));
261		fd = mkstemp(tmp);
262		if (fd < 0) {
263			printk(UM_KERN_ERR "make_umid - mkstemp(%s) failed: "
264			       "%s\n", tmp, strerror(errno));
265			err = -errno;
266			goto err;
267		}
268
269		close(fd);
270
271		set_umid(&tmp[strlen(uml_dir)]);
272
273		/*
274		 * There's a nice tiny little race between this unlink and
275		 * the mkdir below.  It'd be nice if there were a mkstemp
276		 * for directories.
277		 */
278		if (unlink(tmp)) {
279			err = -errno;
280			goto err;
281		}
282	}
283
284	snprintf(tmp, sizeof(tmp), "%s%s", uml_dir, umid);
285	err = mkdir(tmp, 0777);
286	if (err < 0) {
287		err = -errno;
288		if (err != -EEXIST)
289			goto err;
290
291		if (umdir_take_if_dead(tmp) < 0)
292			goto err;
293
294		err = mkdir(tmp, 0777);
295	}
296	if (err) {
297		err = -errno;
298		printk(UM_KERN_ERR "Failed to create '%s' - err = %d\n", umid,
299		       errno);
300		goto err;
301	}
302
303	umid_setup = 1;
304
305	create_pid_file();
306
307	err = 0;
308 err:
309	return err;
310}
311
312static int __init make_umid_init(void)
313{
314	if (!make_umid())
315		return 0;
316
317	/*
318	 * If initializing with the given umid failed, then try again with
319	 * a random one.
320	 */
321	printk(UM_KERN_ERR "Failed to initialize umid \"%s\", trying with a "
322	       "random umid\n", umid);
323	*umid = '\0';
324	make_umid();
325
326	return 0;
327}
328
329__initcall(make_umid_init);
330
331int __init umid_file_name(char *name, char *buf, int len)
332{
333	int n, err;
334
335	err = make_umid();
336	if (err)
337		return err;
338
339	n = snprintf(buf, len, "%s%s/%s", uml_dir, umid, name);
340	if (n >= len) {
341		printk(UM_KERN_ERR "umid_file_name : buffer too short\n");
342		return -E2BIG;
343	}
344
345	return 0;
346}
347
348char *get_umid(void)
349{
350	return umid;
351}
352
353static int __init set_uml_dir(char *name, int *add)
354{
355	if (*name == '\0') {
356		printf("uml_dir can't be an empty string\n");
357		return 0;
358	}
359
360	if (name[strlen(name) - 1] == '/') {
361		uml_dir = name;
362		return 0;
363	}
364
365	uml_dir = malloc(strlen(name) + 2);
366	if (uml_dir == NULL) {
367		printf("Failed to malloc uml_dir - error = %d\n", errno);
368
369		/*
370		 * Return 0 here because do_initcalls doesn't look at
371		 * the return value.
372		 */
373		return 0;
374	}
375	sprintf(uml_dir, "%s/", name);
376
377	return 0;
378}
379
380__uml_setup("uml_dir=", set_uml_dir,
381"uml_dir=<directory>\n"
382"    The location to place the pid and umid files.\n\n"
383);
384
385static void remove_umid_dir(void)
386{
387	char dir[strlen(uml_dir) + UMID_LEN + 1], err;
388
389	sprintf(dir, "%s%s", uml_dir, umid);
390	err = remove_files_and_dir(dir);
391	if (err)
392		printf("remove_umid_dir - remove_files_and_dir failed with "
393		       "err = %d\n", err);
394}
395
396__uml_exitcall(remove_umid_dir);