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