[build] copy qemus from server not for local build
[opensuse:build.git] / initvm.c
1 /*
2  * NAME
3  *      initvm - init for qemu, setup binfmt_misc launch build
4  *      
5  * SYNOPSIS
6  *      initvm
7  *
8  * DESCRIPTION
9  *      This is the kernel init script for virtual machines which will
10  *      be running executables for an embedded (non-native)
11  *      architecture. It registers binfmt_misc handlers for qemu and
12  *      executes the build script, and tests many assumptions.
13  *
14  * FILES
15  *      /.build/qemu-reg
16  *              text file with lines to stuff into the binfmt_misc
17  *              filesystem registration file
18  *      /.build/build
19  *              build script to execute once binfmts are set up
20  *
21  * AUTHOR
22  *      James Perkins <james.perkins@linuxfoundation.org>
23  */
24
25 #include <sys/mount.h>
26 #include <fcntl.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <stdio.h>
31
32 /* to enable debugging, compile with -DDEBUG */
33 #ifdef DEBUG
34 #define DBG(x)          do { x; } while(0)
35 #else
36 #define DBG(x)
37 #endif
38
39 /* function return codes */
40 enum okfail { FAIL=0, OK=1 };
41
42 /* qemu registration fields, see kernel/Documentation/binfmt_misc.txt */
43 enum fields { ignore=0, name, type, offset, magic, mask, interpreter, flags };
44 const char * const fieldnames[] = {
45         "ignore", "name", "type", "offset",
46         "magic", "mask", "interpreter", "flags"
47 };
48 const int n_fields = 8;
49
50 /* files in useful places */
51 #define SYSFS_BINFMT_MISC       "/proc/sys/fs/binfmt_misc"
52 #define SYSFS_BINFMT_MISC_REG   "/proc/sys/fs/binfmt_misc/register"
53 #define SYSFS_BINFMT_MISC_STAT  "/proc/sys/fs/binfmt_misc/status"
54
55 /* /usr/lib/build/x paths are copied to /.build inside a virtual machine */
56 #define BINFMT_REGF_0           "/.build/qemu-reg"
57 #define BINFMT_REGF_1           "/usr/lib/build/qemu-reg"
58 #define BUILD                   "/.build/build"
59
60 /* useful constant arrays */
61 static char *rx_files[] = { "/proc", "/proc/sys", "/proc/sys/fs",
62          SYSFS_BINFMT_MISC, NULL };
63 static char *w_files[] = { SYSFS_BINFMT_MISC_REG, NULL };
64
65 static char* const args[] = { BUILD, NULL };
66
67 /* test access modes for files, return OK or FAIL */
68 enum okfail test_access_files(char *files[], int mode, const char *errstr)
69 {
70         int i;
71
72         for (i = 0; files[i] != NULL; i++) {
73                 if (access(files[i], mode) != 0) {
74                         fprintf(stderr, "%s: %s: fails test\n",
75                                 files[i], errstr);
76                         return FAIL;
77                 }
78         }
79
80         return OK;
81 }
82
83 /* find a string in the given file, return OK or FAIL */
84 enum okfail strfile(const char *filename, const char *string)
85 {
86         char buf[BUFSIZ];
87         FILE *fp;
88         enum okfail found = FAIL;
89
90         fp = fopen(filename, "r");
91         if (fp == NULL)
92         {
93                 perror(filename);
94                 return FAIL;
95         }
96         while (fgets(buf, sizeof(buf), fp) != NULL)
97         {
98                 if (strcmp(buf, string) == 0) {
99                         found = OK;
100                         break;
101                 }
102
103         }
104         (void)fclose(fp);
105
106         return found;
107 }
108
109 /* write the file with given string, return OK or FAIL */
110 enum okfail write_file_string(const char *filename, const char *string)
111 {
112         int fd;
113
114         if ((fd = open(filename, O_WRONLY)) == -1)
115         {
116                 perror(filename);
117                 return FAIL;
118         }
119
120         if (write(fd, string, strlen(string)) == -1)
121         {
122                 perror("write");
123                 fprintf(stderr, "%s: write failed\n", filename);
124                 close(fd);
125                 return FAIL;
126         }
127
128         close(fd);
129         return OK;
130 }
131
132 #ifdef DEBUG
133 /* dump contents of the file to stderr, return OK or FAIL */
134 enum okfail dump_file(char *path)
135 {
136         FILE *fp;
137         char buf[BUFSIZ];
138
139         fp = fopen(path, "r");
140         if (fp == NULL) {
141                 perror(path);
142                 return FAIL;
143         }
144
145         while (fgets(buf, sizeof(buf), fp) != NULL)
146         {
147                 fputs(buf, stderr);
148         }
149
150         fclose(fp);
151         return OK;
152 }
153 #endif /* DEBUG */
154
155 /* parse datafile and register (to regfile) all binary formats found */
156 enum okfail binfmt_register(char *datafile, char *regfile)
157 {
158         char buf[BUFSIZ];
159         FILE *fp;
160         int line;
161
162         fp = fopen(datafile, "r");
163         if (fp == NULL)
164         {
165                 perror(datafile);
166                 return FAIL;
167         }
168
169         for (line = 1; fgets(buf, sizeof(buf), fp) != NULL; line++)
170         {
171                 char tokens[BUFSIZ];
172                 char *s = tokens;
173                 char *f[n_fields];      /* field content pointers */
174                 int n;                  /* current field */
175                 char path[BUFSIZ];
176
177                 if (buf[0] != ':')      /* non-data input line */
178                 {
179                         goto skip;
180                 }
181
182                 /* copy buf and tokenize :-seperated fields into f[] */
183                 strcpy(tokens, buf);
184                 for (n = 0; s != NULL && n < n_fields; n++)
185                 {
186                         f[n] = strsep(&s, ":");
187                 }
188
189 #ifdef DEBUG
190                 int i;
191                 fprintf(stderr, "DEBUG: line %d, fields %d:\n",  line, n);
192                 for (i = name; i < n; i++)
193                 {
194                         fprintf(stderr, " %s %s\n", fieldnames[i], f[i]);
195                 }
196 #endif /* DEBUG */
197
198                 if (n == n_fields && s != NULL)
199                 {
200                         fprintf(stderr, "%s: line %d: extra fields, ignoring."
201                                 " Content: %s", datafile, line, buf);
202                         goto skip;
203                 }
204
205                 if (n < n_fields)
206                 {
207                         fprintf(stderr, "%s: line %d: missing fields, ignoring."
208                                 " Content: %s", datafile, line, buf);
209                         goto skip;
210                 }
211
212
213                 if (access(f[interpreter], X_OK) != 0) {
214                         fprintf(stderr, 
215                                 "%s: line %d: interpreter '%s' not found,"
216                                 " ignoring\n", datafile, line, f[interpreter]);
217                         goto skip;
218                 }
219
220                 if (!write_file_string(regfile, buf)) {
221                         fprintf(stderr, "%s: line %d: write failed."
222                                 " Content: %s\n", datafile, line, buf);
223                         (void)fclose(fp);
224                         return FAIL;
225                 }
226
227                 /* verify registration completed correctly */
228                 snprintf(path, sizeof(path), SYSFS_BINFMT_MISC "/%s", f[name]);
229
230                 if (access(path, R_OK) != 0) {
231                         fprintf(stderr, 
232                                 "%s: line %d: binfmt path not created, content '%s'\n",
233                                 path, line, buf);
234                         (void)fclose(fp);
235                         return FAIL;
236                 }
237
238                 DBG(fprintf(stderr, "dumping: %s\n", path));
239                 DBG(dump_file(path));
240
241 skip:
242                 ;
243         }
244
245
246         (void)fclose(fp);
247
248         return OK;
249 }
250
251 /* set up/verify binfmt FS support, program more binfmts, and launch build */
252 int main(int argc, char* argv[], char* env[])
253 {
254         int retval;
255
256         /* mount proc filesystem if it isn't already */
257         if (mount("proc", "/proc", "proc", MS_MGC_VAL, NULL) == -1) {
258                 if (errno != EBUSY) {
259                         perror("mount: /proc");
260                         exit(1);
261                 }
262         }
263
264         /* try to load binfmt module if present, no big deal if it fails */
265         if ((retval = system("/sbin/modprobe binfmt_misc")) != 0) {
266                 DBG(fprintf(stderr, "modprobe binfmt_misc exit code %d\n",
267                         retval));
268         }
269
270         /* mount binfmt filesystem */
271         if (mount("binfmt_misc", SYSFS_BINFMT_MISC, "binfmt_misc", MS_MGC_VAL,
272                 NULL) == -1) {
273                 if (errno != EBUSY) {
274                         perror("mount: binfmt_misc, " SYSFS_BINFMT_MISC);
275                 }
276         }
277
278         /* verify all paths resulting from this are OK */
279         if (!test_access_files(rx_files, R_OK|X_OK, "read/search")) {
280                 exit(1);
281         }
282         if (!test_access_files(w_files, W_OK, "write")) {
283                 exit(1);
284         }
285
286         if (!strfile("/proc/filesystems", "nodev\tbinfmt_misc\n")) {
287                 fprintf(stderr,
288                         "/proc/filesystems: binfmt_misc support missing\n");
289                 exit(1);
290         }
291
292         if (!strfile(SYSFS_BINFMT_MISC_STAT, "enabled\n")) {
293                 fprintf(stderr,
294                         "%s: binfmt_misc filesystem support not enabled\n",
295                         SYSFS_BINFMT_MISC_STAT);
296                 exit(1);
297         }
298
299         /* setup all done, do the registration */
300         if (!binfmt_register(BINFMT_REGF_0, SYSFS_BINFMT_MISC_REG)) {
301                 fprintf(stderr, "%s: failed. Trying alternate binfmt file\n",
302                         BINFMT_REGF_0);
303                 if (!binfmt_register(BINFMT_REGF_1, SYSFS_BINFMT_MISC_REG)) {
304                         fprintf(stderr, "%s: binfmt registration failed\n",
305                                 BINFMT_REGF_1);
306                         exit(1);
307                 }
308         }
309
310         /* if we are the init process, start build */
311         if (getpid() == 1)
312         {
313                 if (access(BUILD, F_OK) != 0) {
314                         fprintf(stderr, "%s: build executable missing\n",
315                                 BUILD);
316                         exit(1);
317                 }
318                 if (access(BUILD, X_OK) != 0) {
319                         fprintf(stderr, "%s: not executable\n", BUILD);
320                         exit(1);
321                 }
322                 execve(BUILD, args, env);
323                 perror("execve");
324                 exit(1);
325         }
326
327         /* success! */
328         exit(0);
329 }