[PATCH] uml: separate libc-dependent umid code

I reworked Gennady's umid OS abstraction patch because the code shouldn't
be moved entirely to os.  As it turns out, I moved most of it anyway.  This
patch is the minimal one needed to move the code and have it work.
It turns out that the concept of the umid is OS-independent, but
almost everything else about the implementation is OS-dependent.

This is code movement without cleanup - a follow-on patch tidies
everything up without shuffling code around.

Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 292 insertions, 0 deletions

diff --git a/arch/um/os-Linux/umid.c b/arch/um/os-Linux/umid.c
new file mode 100644
index 000000000000..77d69a348cf4
--- /dev/null
+++ b/arch/um/os-Linux/umid.c
@@ -0,0 +1,292 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include "init.h"
+#include "os.h"
+#include "user.h"
+#include "mode.h"
+
+#define UML_DIR "~/.uml/"
+
+#define UMID_LEN 64
+
+/* Changed by set_umid, which is run early in boot */
+char umid[UMID_LEN] = { 0 };
+
+/* Changed by set_uml_dir and make_uml_dir, which are run early in boot */
+static char *uml_dir = UML_DIR;
+
+static int __init make_uml_dir(void)
+{
+        char dir[512] = { '\0' };
+        int len;
+
+        if(*uml_dir == '~'){
+                char *home = getenv("HOME");
+
+                if(home == NULL){
+                        printf("make_uml_dir : no value in environment for "
+                               "$HOME\n");
+                        exit(1);
+                }
+                strlcpy(dir, home, sizeof(dir));
+                uml_dir++;
+        }
+        strlcat(dir, uml_dir, sizeof(dir));
+        len = strlen(dir);
+        if (len > 0 && dir[len - 1] != '/')
+                strlcat(dir, "/", sizeof(dir));
+
+        uml_dir = malloc(strlen(dir) + 1);
+        if (uml_dir == NULL) {
+                printf("make_uml_dir : malloc failed, errno = %d\n", errno);
+                exit(1);
+        }
+        strcpy(uml_dir, dir);
+
+        if((mkdir(uml_dir, 0777) < 0) && (errno != EEXIST)){
+                printf("Failed to mkdir '%s': %s\n", uml_dir, strerror(errno));
+                return(-1);
+        }
+        return 0;
+}
+
+static int actually_do_remove(char *dir)
+{
+        DIR *directory;
+        struct dirent *ent;
+        int len;
+        char file[256];
+
+        directory = opendir(dir);
+        if(directory == NULL){
+                printk("actually_do_remove : couldn't open directory '%s', "
+                       "errno = %d\n", dir, errno);
+                return(1);
+        }
+        while((ent = readdir(directory)) != NULL){
+                if(!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))
+                        continue;
+                len = strlen(dir) + sizeof("/") + strlen(ent->d_name) + 1;
+                if(len > sizeof(file)){
+                        printk("Not deleting '%s' from '%s' - name too long\n",
+                               ent->d_name, dir);
+                        continue;
+                }
+                sprintf(file, "%s/%s", dir, ent->d_name);
+                if(unlink(file) < 0){
+                        printk("actually_do_remove : couldn't remove '%s' "
+                               "from '%s', errno = %d\n", ent->d_name, dir,
+                               errno);
+                        return(1);
+                }
+        }
+        if(rmdir(dir) < 0){
+                printk("actually_do_remove : couldn't rmdir '%s', "
+                       "errno = %d\n", dir, errno);
+                return(1);
+        }
+        return(0);
+}
+
+extern int tracing_pid;
+
+static int not_dead_yet(char *dir)
+{
+        char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
+        char pid[sizeof("nnnnn\0")], *end;
+        int dead, fd, p, n;
+
+        sprintf(file, "%s/pid", dir);
+        dead = 0;
+        fd = os_open_file(file, of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                if(fd != -ENOENT){
+                        printk("not_dead_yet : couldn't open pid file '%s', "
+                               "err = %d\n", file, -fd);
+                        return(1);
+                }
+                dead = 1;
+        }
+        if(fd > 0){
+                n = os_read_file(fd, pid, sizeof(pid));
+                if(n < 0){
+                        printk("not_dead_yet : couldn't read pid file '%s', "
+                               "err = %d\n", file, -n);
+                        return(1);
+                }
+                p = strtoul(pid, &end, 0);
+                if(end == pid){
+                        printk("not_dead_yet : couldn't parse pid file '%s', "
+                               "errno = %d\n", file, errno);
+                        dead = 1;
+                }
+                if(((kill(p, 0) < 0) && (errno == ESRCH)) ||
+                   (p == CHOOSE_MODE(tracing_pid, os_getpid())))
+                        dead = 1;
+        }
+        if(!dead)
+                return(1);
+        return(actually_do_remove(dir));
+}
+
+static void __init create_pid_file(void)
+{
+        char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
+        char pid[sizeof("nnnnn\0")];
+        int fd, n;
+
+        if(umid_file_name("pid", file, sizeof(file)))
+                return;
+
+        fd = os_open_file(file, of_create(of_excl(of_rdwr(OPENFLAGS()))),
+                          0644);
+        if(fd < 0){
+                printf("Open of machine pid file \"%s\" failed: %s\n",
+                       file, strerror(-fd));
+                return;
+        }
+
+        sprintf(pid, "%d\n", os_getpid());
+        n = os_write_file(fd, pid, strlen(pid));
+        if(n != strlen(pid))
+                printf("Write of pid file failed - err = %d\n", -n);
+        os_close_file(fd);
+}
+
+int __init set_umid(char *name, int (*printer)(const char *fmt, ...))
+{
+        if(strlen(name) > UMID_LEN - 1)
+                (*printer)("Unique machine name is being truncated to %d "
+                           "characters\n", UMID_LEN);
+        strlcpy(umid, name, sizeof(umid));
+
+        return 0;
+}
+
+static int umid_setup = 0;
+
+int __init make_umid(int (*printer)(const char *fmt, ...))
+{
+        int fd, err;
+        char tmp[256];
+
+        make_uml_dir();
+
+        if(*umid == '\0'){
+                strlcpy(tmp, uml_dir, sizeof(tmp));
+                strcat(tmp, "XXXXXX");
+                fd = mkstemp(tmp);
+                if(fd < 0){
+                        (*printer)("make_umid - mkstemp(%s) failed: %s\n",
+                                   tmp,strerror(errno));
+                        return(1);
+                }
+
+                os_close_file(fd);
+                /* There's a nice tiny little race between this unlink and
+                 * the mkdir below.  It'd be nice if there were a mkstemp
+                 * for directories.
+                 */
+                unlink(tmp);
+                set_umid(&tmp[strlen(uml_dir)], printer);
+        }
+
+        sprintf(tmp, "%s%s", uml_dir, umid);
+        err = mkdir(tmp, 0777);
+        if(err < 0){
+                if(errno == EEXIST){
+                        if(not_dead_yet(tmp))
+                                return -EEXIST;
+                        err = mkdir(tmp, 0777);
+                }
+        }
+        if(err < 0){
+                (*printer)("Failed to create %s - errno = %d\n", umid, errno);
+                return(-1);
+        }
+
+        umid_setup = 1;
+
+        create_pid_file();
+
+        return 0;
+}
+
+static int __init make_umid_init(void)
+{
+        make_umid(printk);
+
+        return(0);
+}
+
+__initcall(make_umid_init);
+
+int __init umid_file_name(char *name, char *buf, int len)
+{
+        int n, err;
+
+        if(!umid_setup){
+                err = make_umid(printk);
+                if(err)
+                        return err;
+        }
+
+        n = strlen(uml_dir) + strlen(umid) + strlen("/") + strlen(name) + 1;
+        if(n > len){
+                printk("umid_file_name : buffer too short\n");
+                return(-1);
+        }
+
+        sprintf(buf, "%s%s/%s", uml_dir, umid, name);
+        return(0);
+}
+
+extern int umid_is_random;
+
+char *get_umid(int only_if_set)
+{
+        if(only_if_set && umid_is_random)
+                return NULL;
+        return umid;
+}
+
+static int __init set_uml_dir(char *name, int *add)
+{
+        if((strlen(name) > 0) && (name[strlen(name) - 1] != '/')){
+                uml_dir = malloc(strlen(name) + 2);
+                if(uml_dir == NULL){
+                        printf("Failed to malloc uml_dir - error = %d\n",
+                               errno);
+                        uml_dir = name;
+                        /* Return 0 here because do_initcalls doesn't look at
+                         * the return value.
+                         */
+                        return(0);
+                }
+                sprintf(uml_dir, "%s/", name);
+        }
+        else uml_dir = name;
+        return(0);
+}
+
+__uml_setup("uml_dir=", set_uml_dir,
+"uml_dir=<directory>\n"
+"    The location to place the pid and umid files.\n\n"
+);
+
+static void remove_umid_dir(void)
+{
+        char dir[strlen(uml_dir) + UMID_LEN + 1];
+
+        sprintf(dir, "%s%s", uml_dir, umid);
+        actually_do_remove(dir);
+}
+
+__uml_exitcall(remove_umid_dir);