Automatic merge of /spare/repo/netdev-2.6 branch airo
[linux-2.6] / arch / um / kernel / umid.c
1 /* 
2  * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
3  * Licensed under the GPL
4  */
5
6 #include <stdio.h>
7 #include <unistd.h>
8 #include <errno.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <dirent.h>
12 #include <signal.h>
13 #include <sys/stat.h>
14 #include <sys/param.h>
15 #include "user.h"
16 #include "umid.h"
17 #include "init.h"
18 #include "os.h"
19 #include "user_util.h"
20 #include "choose-mode.h"
21
22 #define UMID_LEN 64
23 #define UML_DIR "~/.uml/"
24
25 /* Changed by set_umid and make_umid, which are run early in boot */
26 static char umid[UMID_LEN] = { 0 };
27
28 /* Changed by set_uml_dir and make_uml_dir, which are run early in boot */
29 static char *uml_dir = UML_DIR;
30
31 /* Changed by set_umid */
32 static int umid_is_random = 1;
33 static int umid_inited = 0;
34
35 static int make_umid(int (*printer)(const char *fmt, ...));
36
37 static int __init set_umid(char *name, int is_random,
38                            int (*printer)(const char *fmt, ...))
39 {
40         if(umid_inited){
41                 (*printer)("Unique machine name can't be set twice\n");
42                 return(-1);
43         }
44
45         if(strlen(name) > UMID_LEN - 1)
46                 (*printer)("Unique machine name is being truncated to %d "
47                            "characters\n", UMID_LEN);
48         strlcpy(umid, name, sizeof(umid));
49
50         umid_is_random = is_random;
51         umid_inited = 1;
52         return 0;
53 }
54
55 static int __init set_umid_arg(char *name, int *add)
56 {
57         *add = 0;
58         return(set_umid(name, 0, printf));
59 }
60
61 __uml_setup("umid=", set_umid_arg,
62 "umid=<name>\n"
63 "    This is used to assign a unique identity to this UML machine and\n"
64 "    is used for naming the pid file and management console socket.\n\n"
65 );
66
67 int __init umid_file_name(char *name, char *buf, int len)
68 {
69         int n;
70
71         if(!umid_inited && make_umid(printk)) return(-1);
72
73         n = strlen(uml_dir) + strlen(umid) + strlen(name) + 1;
74         if(n > len){
75                 printk("umid_file_name : buffer too short\n");
76                 return(-1);
77         }
78
79         sprintf(buf, "%s%s/%s", uml_dir, umid, name);
80         return(0);
81 }
82
83 extern int tracing_pid;
84
85 static int __init create_pid_file(void)
86 {
87         char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
88         char pid[sizeof("nnnnn\0")];
89         int fd, n;
90
91         if(umid_file_name("pid", file, sizeof(file))) return 0;
92
93         fd = os_open_file(file, of_create(of_excl(of_rdwr(OPENFLAGS()))), 
94                           0644);
95         if(fd < 0){
96                 printf("Open of machine pid file \"%s\" failed: %s\n",
97                        file, strerror(-fd));
98                 return 0;
99         }
100
101         sprintf(pid, "%d\n", os_getpid());
102         n = os_write_file(fd, pid, strlen(pid));
103         if(n != strlen(pid))
104                 printf("Write of pid file failed - err = %d\n", -n);
105         os_close_file(fd);
106         return 0;
107 }
108
109 static int actually_do_remove(char *dir)
110 {
111         DIR *directory;
112         struct dirent *ent;
113         int len;
114         char file[256];
115
116         directory = opendir(dir);
117         if(directory == NULL){
118                 printk("actually_do_remove : couldn't open directory '%s', "
119                        "errno = %d\n", dir, errno);
120                 return(1);
121         }
122         while((ent = readdir(directory)) != NULL){
123                 if(!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))
124                         continue;
125                 len = strlen(dir) + sizeof("/") + strlen(ent->d_name) + 1;
126                 if(len > sizeof(file)){
127                         printk("Not deleting '%s' from '%s' - name too long\n",
128                                ent->d_name, dir);
129                         continue;
130                 }
131                 sprintf(file, "%s/%s", dir, ent->d_name);
132                 if(unlink(file) < 0){
133                         printk("actually_do_remove : couldn't remove '%s' "
134                                "from '%s', errno = %d\n", ent->d_name, dir, 
135                                errno);
136                         return(1);
137                 }
138         }
139         if(rmdir(dir) < 0){
140                 printk("actually_do_remove : couldn't rmdir '%s', "
141                        "errno = %d\n", dir, errno);
142                 return(1);
143         }
144         return(0);
145 }
146
147 void remove_umid_dir(void)
148 {
149         char dir[strlen(uml_dir) + UMID_LEN + 1];
150         if(!umid_inited) return;
151
152         sprintf(dir, "%s%s", uml_dir, umid);
153         actually_do_remove(dir);
154 }
155
156 char *get_umid(int only_if_set)
157 {
158         if(only_if_set && umid_is_random) return(NULL);
159         return(umid);
160 }
161
162 int not_dead_yet(char *dir)
163 {
164         char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
165         char pid[sizeof("nnnnn\0")], *end;
166         int dead, fd, p, n;
167
168         sprintf(file, "%s/pid", dir);
169         dead = 0;
170         fd = os_open_file(file, of_read(OPENFLAGS()), 0);
171         if(fd < 0){
172                 if(fd != -ENOENT){
173                         printk("not_dead_yet : couldn't open pid file '%s', "
174                                "err = %d\n", file, -fd);
175                         return(1);
176                 }
177                 dead = 1;
178         }
179         if(fd > 0){
180                 n = os_read_file(fd, pid, sizeof(pid));
181                 if(n < 0){
182                         printk("not_dead_yet : couldn't read pid file '%s', "
183                                "err = %d\n", file, -n);
184                         return(1);
185                 }
186                 p = strtoul(pid, &end, 0);
187                 if(end == pid){
188                         printk("not_dead_yet : couldn't parse pid file '%s', "
189                                "errno = %d\n", file, errno);
190                         dead = 1;
191                 }
192                 if(((kill(p, 0) < 0) && (errno == ESRCH)) ||
193                    (p == CHOOSE_MODE(tracing_pid, os_getpid())))
194                         dead = 1;
195         }
196         if(!dead) return(1);
197         return(actually_do_remove(dir));
198 }
199
200 static int __init set_uml_dir(char *name, int *add)
201 {
202         if((strlen(name) > 0) && (name[strlen(name) - 1] != '/')){
203                 uml_dir = malloc(strlen(name) + 2);
204                 if(uml_dir == NULL){
205                         printf("Failed to malloc uml_dir - error = %d\n",
206                                errno);
207                         uml_dir = name;
208                         /* Return 0 here because do_initcalls doesn't look at
209                          * the return value.
210                          */
211                         return(0);
212                 }
213                 sprintf(uml_dir, "%s/", name);
214         }
215         else uml_dir = name;
216         return(0);
217 }
218
219 static int __init make_uml_dir(void)
220 {
221         char dir[MAXPATHLEN + 1] = { '\0' };
222         int len;
223
224         if(*uml_dir == '~'){
225                 char *home = getenv("HOME");
226
227                 if(home == NULL){
228                         printf("make_uml_dir : no value in environment for "
229                                "$HOME\n");
230                         exit(1);
231                 }
232                 strlcpy(dir, home, sizeof(dir));
233                 uml_dir++;
234         }
235         len = strlen(dir);
236         strncat(dir, uml_dir, sizeof(dir) - len);
237         len = strlen(dir);
238         if((len > 0) && (len < sizeof(dir) - 1) && (dir[len - 1] != '/')){
239                 dir[len] = '/';
240                 dir[len + 1] = '\0';
241         }
242
243         uml_dir = malloc(strlen(dir) + 1);
244         if(uml_dir == NULL){
245                 printf("make_uml_dir : malloc failed, errno = %d\n", errno);
246                 exit(1);
247         }
248         strcpy(uml_dir, dir);
249         
250         if((mkdir(uml_dir, 0777) < 0) && (errno != EEXIST)){
251                 printf("Failed to mkdir %s: %s\n", uml_dir, strerror(errno));
252                 return(-1);
253         }
254         return 0;
255 }
256
257 static int __init make_umid(int (*printer)(const char *fmt, ...))
258 {
259         int fd, err;
260         char tmp[strlen(uml_dir) + UMID_LEN + 1];
261
262         strlcpy(tmp, uml_dir, sizeof(tmp));
263
264         if(!umid_inited){
265                 strcat(tmp, "XXXXXX");
266                 fd = mkstemp(tmp);
267                 if(fd < 0){
268                         (*printer)("make_umid - mkstemp(%s) failed: %s\n",
269                                    tmp,strerror(errno));
270                         return(1);
271                 }
272
273                 os_close_file(fd);
274                 /* There's a nice tiny little race between this unlink and
275                  * the mkdir below.  It'd be nice if there were a mkstemp
276                  * for directories.
277                  */
278                 unlink(tmp);
279                 set_umid(&tmp[strlen(uml_dir)], 1, printer);
280         }
281         
282         sprintf(tmp, "%s%s", uml_dir, umid);
283
284         err = mkdir(tmp, 0777);
285         if(err < 0){
286                 if(errno == EEXIST){
287                         if(not_dead_yet(tmp)){
288                                 (*printer)("umid '%s' is in use\n", umid);
289                                 return(-1);
290                         }
291                         err = mkdir(tmp, 0777);
292                 }
293         }
294         if(err < 0){
295                 (*printer)("Failed to create %s - errno = %d\n", umid, errno);
296                 return(-1);
297         }
298
299         return(0);
300 }
301
302 __uml_setup("uml_dir=", set_uml_dir,
303 "uml_dir=<directory>\n"
304 "    The location to place the pid and umid files.\n\n"
305 );
306
307 static int __init make_umid_setup(void)
308 {
309         /* one function with the ordering we need ... */
310         make_uml_dir();
311         make_umid(printf);
312         return create_pid_file();
313 }
314 __uml_postsetup(make_umid_setup);
315
316 /*
317  * Overrides for Emacs so that we follow Linus's tabbing style.
318  * Emacs will notice this stuff at the end of the file and automatically
319  * adjust the settings for this buffer only.  This must remain at the end
320  * of the file.
321  * ---------------------------------------------------------------------------
322  * Local variables:
323  * c-file-style: "linux"
324  * End:
325  */