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