Subversion Repositories HelenOS

Rev

Rev 4420 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4419 trochtova 1
/*
2
 * Copyright (c) 2008 Jiri Svoboda
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup loader
30
 * @brief Loads and runs programs from VFS.
31
 * @{
32
 */
33
/**
34
 * @file
35
 * @brief Loads and runs programs from VFS.
36
 *
37
 * The program loader is a special init binary. Its image is used
38
 * to create a new task upon a @c task_spawn syscall. The syscall
39
 * returns the id of a phone connected to the newly created task.
40
 *
41
 * The caller uses this phone to send the pathname and various other
42
 * information to the loader. This is normally done by the C library
43
 * and completely hidden from applications.
44
 */
45
 
46
#include <stdio.h>
47
#include <stdlib.h>
48
#include <unistd.h>
49
#include <bool.h>
50
#include <fcntl.h>
51
#include <sys/types.h>
52
#include <ipc/ipc.h>
53
#include <ipc/services.h>
54
#include <ipc/loader.h>
55
#include <loader/pcb.h>
56
#include <errno.h>
57
#include <async.h>
4537 trochtova 58
#include <string.h>
4419 trochtova 59
#include <as.h>
60
 
61
#include <elf.h>
62
#include <elf_load.h>
63
 
64
#define DPRINTF(...)
65
 
66
/** Pathname of the file that will be loaded */
67
static char *pathname = NULL;
68
 
69
/** The Program control block */
70
static pcb_t pcb;
71
 
72
/** Number of arguments */
73
static int argc = 0;
74
/** Argument vector */
75
static char **argv = NULL;
76
/** Buffer holding all arguments */
77
static char *arg_buf = NULL;
78
 
4537 trochtova 79
/** Number of preset files */
80
static int filc = 0;
81
/** Preset files vector */
82
static char **filv = NULL;
83
/** Buffer holding all preset files */
84
static fdi_node_t *fil_buf = NULL;
85
 
4419 trochtova 86
static elf_info_t prog_info;
87
static elf_info_t interp_info;
88
 
89
static bool is_dyn_linked;
90
 
91
/** Used to limit number of connections to one. */
92
static bool connected;
93
 
4537 trochtova 94
static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
4419 trochtova 95
{
96
    ipc_callid_t callid;
97
    task_id_t task_id;
98
    size_t len;
99
 
100
    task_id = task_get_id();
101
 
102
    if (!ipc_data_read_receive(&callid, &len)) {
103
        ipc_answer_0(callid, EINVAL);
104
        ipc_answer_0(rid, EINVAL);
105
        return;
106
    }
107
 
108
    if (len > sizeof(task_id))
109
        len = sizeof(task_id);
110
 
111
    ipc_data_read_finalize(callid, &task_id, len);
112
    ipc_answer_0(rid, EOK);
113
}
114
 
115
 
116
/** Receive a call setting pathname of the program to execute.
117
 *
118
 * @param rid
119
 * @param request
120
 */
4537 trochtova 121
static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
4419 trochtova 122
{
123
    ipc_callid_t callid;
124
    size_t len;
125
    char *name_buf;
126
 
127
    if (!ipc_data_write_receive(&callid, &len)) {
128
        ipc_answer_0(callid, EINVAL);
129
        ipc_answer_0(rid, EINVAL);
130
        return;
131
    }
132
 
133
    name_buf = malloc(len + 1);
134
    if (!name_buf) {
135
        ipc_answer_0(callid, ENOMEM);
136
        ipc_answer_0(rid, ENOMEM);
137
        return;
138
    }
139
 
140
    ipc_data_write_finalize(callid, name_buf, len);
141
    ipc_answer_0(rid, EOK);
142
 
143
    if (pathname != NULL) {
144
        free(pathname);
145
        pathname = NULL;
146
    }
147
 
148
    name_buf[len] = '\0';
149
    pathname = name_buf;
150
}
151
 
152
/** Receive a call setting arguments of the program to execute.
153
 *
154
 * @param rid
155
 * @param request
156
 */
4537 trochtova 157
static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
4419 trochtova 158
{
159
    ipc_callid_t callid;
160
    size_t buf_size, arg_size;
161
    char *p;
162
    int n;
163
 
164
    if (!ipc_data_write_receive(&callid, &buf_size)) {
165
        ipc_answer_0(callid, EINVAL);
166
        ipc_answer_0(rid, EINVAL);
167
        return;
168
    }
169
 
170
    if (arg_buf != NULL) {
171
        free(arg_buf);
172
        arg_buf = NULL;
173
    }
174
 
175
    if (argv != NULL) {
176
        free(argv);
177
        argv = NULL;
178
    }
179
 
180
    arg_buf = malloc(buf_size + 1);
181
    if (!arg_buf) {
182
        ipc_answer_0(callid, ENOMEM);
183
        ipc_answer_0(rid, ENOMEM);
184
        return;
185
    }
186
 
187
    ipc_data_write_finalize(callid, arg_buf, buf_size);
188
 
189
    arg_buf[buf_size] = '\0';
190
 
191
    /*
192
     * Count number of arguments
193
     */
194
    p = arg_buf;
195
    n = 0;
196
    while (p < arg_buf + buf_size) {
197
        arg_size = str_size(p);
198
        p = p + arg_size + 1;
199
        ++n;
200
    }
201
 
202
    /* Allocate argv */
203
    argv = malloc((n + 1) * sizeof(char *));
204
 
205
    if (argv == NULL) {
206
        free(arg_buf);
207
        ipc_answer_0(rid, ENOMEM);
208
        return;
209
    }
210
 
211
    /*
212
     * Fill argv with argument pointers
213
     */
214
    p = arg_buf;
215
    n = 0;
216
    while (p < arg_buf + buf_size) {
217
        argv[n] = p;
218
 
219
        arg_size = str_size(p);
220
        p = p + arg_size + 1;
221
        ++n;
222
    }
223
 
224
    argc = n;
225
    argv[n] = NULL;
226
 
227
    ipc_answer_0(rid, EOK);
228
}
229
 
4537 trochtova 230
/** Receive a call setting preset files of the program to execute.
231
 *
232
 * @param rid
233
 * @param request
234
 */
235
static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
236
{
237
    ipc_callid_t callid;
238
    size_t buf_size;
239
    if (!ipc_data_write_receive(&callid, &buf_size)) {
240
        ipc_answer_0(callid, EINVAL);
241
        ipc_answer_0(rid, EINVAL);
242
        return;
243
    }
244
 
245
    if ((buf_size % sizeof(fdi_node_t)) != 0) {
246
        ipc_answer_0(callid, EINVAL);
247
        ipc_answer_0(rid, EINVAL);
248
        return;
249
    }
250
 
251
    if (fil_buf != NULL) {
252
        free(fil_buf);
253
        fil_buf = NULL;
254
    }
255
 
256
    if (filv != NULL) {
257
        free(filv);
258
        filv = NULL;
259
    }
260
 
261
    fil_buf = malloc(buf_size);
262
    if (!fil_buf) {
263
        ipc_answer_0(callid, ENOMEM);
264
        ipc_answer_0(rid, ENOMEM);
265
        return;
266
    }
267
 
268
    ipc_data_write_finalize(callid, fil_buf, buf_size);
269
 
270
    int count = buf_size / sizeof(fdi_node_t);
271
 
272
    /* Allocate filvv */
273
    filv = malloc((count + 1) * sizeof(fdi_node_t *));
274
 
275
    if (filv == NULL) {
276
        free(fil_buf);
277
        ipc_answer_0(rid, ENOMEM);
278
        return;
279
    }
280
 
281
    /*
282
     * Fill filv with argument pointers
283
     */
284
    int i;
285
    for (i = 0; i < count; i++)
286
        filv[i] = &fil_buf[i];
287
 
288
    filc = count;
289
    filv[count] = NULL;
290
 
291
    ipc_answer_0(rid, EOK);
292
}
293
 
4419 trochtova 294
/** Load the previously selected program.
295
 *
296
 * @param rid
297
 * @param request
298
 * @return 0 on success, !0 on error.
299
 */
4537 trochtova 300
static int ldr_load(ipc_callid_t rid, ipc_call_t *request)
4419 trochtova 301
{
302
    int rc;
303
 
304
    rc = elf_load_file(pathname, 0, &prog_info);
4420 trochtova 305
    if (rc != EE_OK) {
4419 trochtova 306
        DPRINTF("Failed to load executable '%s'.\n", pathname);
307
        ipc_answer_0(rid, EINVAL);
308
        return 1;
309
    }
310
 
311
    elf_create_pcb(&prog_info, &pcb);
312
 
313
    pcb.argc = argc;
314
    pcb.argv = argv;
315
 
4537 trochtova 316
    pcb.filc = filc;
317
    pcb.filv = filv;
318
 
4419 trochtova 319
    if (prog_info.interp == NULL) {
320
        /* Statically linked program */
321
        is_dyn_linked = false;
322
        ipc_answer_0(rid, EOK);
323
        return 0;
324
    }
325
 
326
    rc = elf_load_file(prog_info.interp, 0, &interp_info);
4420 trochtova 327
    if (rc != EE_OK) {
4419 trochtova 328
        DPRINTF("Failed to load interpreter '%s.'\n",
329
            prog_info.interp);
330
        ipc_answer_0(rid, EINVAL);
331
        return 1;
332
    }
333
 
334
    is_dyn_linked = true;
335
    ipc_answer_0(rid, EOK);
336
 
337
    return 0;
338
}
339
 
340
 
341
/** Run the previously loaded program.
342
 *
343
 * @param rid
344
 * @param request
345
 * @return 0 on success, !0 on error.
346
 */
4537 trochtova 347
static void ldr_run(ipc_callid_t rid, ipc_call_t *request)
4419 trochtova 348
{
349
    const char *cp;
350
 
351
    /* Set the task name. */
352
    cp = str_rchr(pathname, '/');
353
    cp = (cp == NULL) ? pathname : (cp + 1);
354
    task_set_name(cp);
355
 
356
    if (is_dyn_linked == true) {
357
        /* Dynamically linked program */
358
        DPRINTF("Run ELF interpreter.\n");
359
        DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
360
 
361
        ipc_answer_0(rid, EOK);
362
        elf_run(&interp_info, &pcb);
363
    } else {
364
        /* Statically linked program */
365
        ipc_answer_0(rid, EOK);
366
        elf_run(&prog_info, &pcb);
4537 trochtova 367
    }
368
 
4419 trochtova 369
    /* Not reached */
370
}
371
 
372
/** Handle loader connection.
373
 *
374
 * Receive and carry out commands (of which the last one should be
375
 * to execute the loaded program).
376
 */
4537 trochtova 377
static void ldr_connection(ipc_callid_t iid, ipc_call_t *icall)
4419 trochtova 378
{
379
    ipc_callid_t callid;
380
    ipc_call_t call;
381
    int retval;
382
 
383
    /* Already have a connection? */
384
    if (connected) {
385
        ipc_answer_0(iid, ELIMIT);
386
        return;
387
    }
388
 
389
    connected = true;
390
 
391
    /* Accept the connection */
392
    ipc_answer_0(iid, EOK);
393
 
394
    /* Ignore parameters, the connection is already open */
395
    (void) iid;
396
    (void) icall;
397
 
398
    while (1) {
399
        callid = async_get_call(&call);
400
 
401
        switch (IPC_GET_METHOD(call)) {
402
        case IPC_M_PHONE_HUNGUP:
403
            exit(0);
404
        case LOADER_GET_TASKID:
4537 trochtova 405
            ldr_get_taskid(callid, &call);
4419 trochtova 406
            continue;
407
        case LOADER_SET_PATHNAME:
4537 trochtova 408
            ldr_set_pathname(callid, &call);
4419 trochtova 409
            continue;
410
        case LOADER_SET_ARGS:
4537 trochtova 411
            ldr_set_args(callid, &call);
4419 trochtova 412
            continue;
4537 trochtova 413
        case LOADER_SET_FILES:
414
            ldr_set_files(callid, &call);
415
            continue;
4419 trochtova 416
        case LOADER_LOAD:
4537 trochtova 417
            ldr_load(callid, &call);
4419 trochtova 418
            continue;
419
        case LOADER_RUN:
4537 trochtova 420
            ldr_run(callid, &call);
4419 trochtova 421
            /* Not reached */
422
        default:
423
            retval = ENOENT;
424
            break;
425
        }
426
        if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
427
            IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
428
            DPRINTF("Responding EINVAL to method %d.\n",
429
                IPC_GET_METHOD(call));
430
            ipc_answer_0(callid, EINVAL);
431
        }
432
    }
433
}
434
 
435
/** Program loader main function.
436
 */
437
int main(int argc, char *argv[])
438
{
439
    ipcarg_t phonead;
440
 
441
    connected = false;
442
 
443
    /* Set a handler of incomming connections. */
4537 trochtova 444
    async_set_client_connection(ldr_connection);
4419 trochtova 445
 
446
    /* Register at naming service. */
447
    if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)
448
        return -1;
449
 
450
    async_manager();
451
 
452
    /* Never reached */
453
    return 0;
454
}
455
 
456
/** @}
457
 */