~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/um/os-Linux/umid.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp