arch/um/os-Linux/umid.c

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