Subversion Repositories HelenOS

Rev

Rev 4547 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3222 svoboda 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
4014 decky 30
 * @brief Loads and runs programs from VFS.
3222 svoboda 31
 * @{
4014 decky 32
 */
3222 svoboda 33
/**
34
 * @file
4014 decky 35
 * @brief Loads and runs programs from VFS.
3222 svoboda 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>
3470 svoboda 49
#include <bool.h>
3222 svoboda 50
#include <fcntl.h>
51
#include <sys/types.h>
52
#include <ipc/ipc.h>
3896 svoboda 53
#include <ipc/services.h>
3222 svoboda 54
#include <ipc/loader.h>
55
#include <loader/pcb.h>
56
#include <errno.h>
57
#include <async.h>
4461 decky 58
#include <string.h>
3222 svoboda 59
#include <as.h>
60
 
61
#include <elf.h>
62
#include <elf_load.h>
63
 
3787 svoboda 64
#define DPRINTF(...)
65
 
3222 svoboda 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
 
4461 decky 79
/** Number of preset files */
80
static int filc = 0;
81
/** Preset files vector */
4547 svoboda 82
static fdi_node_t **filv = NULL;
4461 decky 83
/** Buffer holding all preset files */
4492 jermar 84
static fdi_node_t *fil_buf = NULL;
4461 decky 85
 
3470 svoboda 86
static elf_info_t prog_info;
87
static elf_info_t interp_info;
88
 
89
static bool is_dyn_linked;
90
 
3896 svoboda 91
/** Used to limit number of connections to one. */
92
static bool connected;
3470 svoboda 93
 
4461 decky 94
static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
3447 svoboda 95
{
96
    ipc_callid_t callid;
97
    task_id_t task_id;
98
    size_t len;
4014 decky 99
 
3447 svoboda 100
    task_id = task_get_id();
4014 decky 101
 
3447 svoboda 102
    if (!ipc_data_read_receive(&callid, &len)) {
103
        ipc_answer_0(callid, EINVAL);
104
        ipc_answer_0(rid, EINVAL);
105
        return;
106
    }
4014 decky 107
 
108
    if (len > sizeof(task_id))
109
        len = sizeof(task_id);
110
 
3475 svoboda 111
    ipc_data_read_finalize(callid, &task_id, len);
3447 svoboda 112
    ipc_answer_0(rid, EOK);
113
}
114
 
115
 
3222 svoboda 116
/** Receive a call setting pathname of the program to execute.
117
 *
118
 * @param rid
119
 * @param request
120
 */
4461 decky 121
static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 122
{
123
    ipc_callid_t callid;
124
    size_t len;
125
    char *name_buf;
4014 decky 126
 
3222 svoboda 127
    if (!ipc_data_write_receive(&callid, &len)) {
128
        ipc_answer_0(callid, EINVAL);
129
        ipc_answer_0(rid, EINVAL);
130
        return;
131
    }
4014 decky 132
 
3222 svoboda 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
    }
4014 decky 139
 
3222 svoboda 140
    ipc_data_write_finalize(callid, name_buf, len);
141
    ipc_answer_0(rid, EOK);
4014 decky 142
 
3222 svoboda 143
    if (pathname != NULL) {
144
        free(pathname);
145
        pathname = NULL;
146
    }
4014 decky 147
 
3222 svoboda 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
 */
4461 decky 157
static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 158
{
159
    ipc_callid_t callid;
4264 svoboda 160
    size_t buf_size, arg_size;
3222 svoboda 161
    char *p;
162
    int n;
4014 decky 163
 
4264 svoboda 164
    if (!ipc_data_write_receive(&callid, &buf_size)) {
3222 svoboda 165
        ipc_answer_0(callid, EINVAL);
166
        ipc_answer_0(rid, EINVAL);
167
        return;
168
    }
4014 decky 169
 
3222 svoboda 170
    if (arg_buf != NULL) {
171
        free(arg_buf);
172
        arg_buf = NULL;
173
    }
4014 decky 174
 
3222 svoboda 175
    if (argv != NULL) {
176
        free(argv);
177
        argv = NULL;
178
    }
4014 decky 179
 
4264 svoboda 180
    arg_buf = malloc(buf_size + 1);
3222 svoboda 181
    if (!arg_buf) {
182
        ipc_answer_0(callid, ENOMEM);
183
        ipc_answer_0(rid, ENOMEM);
184
        return;
185
    }
4014 decky 186
 
4264 svoboda 187
    ipc_data_write_finalize(callid, arg_buf, buf_size);
4014 decky 188
 
4264 svoboda 189
    arg_buf[buf_size] = '\0';
4014 decky 190
 
3222 svoboda 191
    /*
192
     * Count number of arguments
193
     */
194
    p = arg_buf;
195
    n = 0;
4264 svoboda 196
    while (p < arg_buf + buf_size) {
197
        arg_size = str_size(p);
198
        p = p + arg_size + 1;
3222 svoboda 199
        ++n;
200
    }
4014 decky 201
 
3222 svoboda 202
    /* Allocate argv */
203
    argv = malloc((n + 1) * sizeof(char *));
4014 decky 204
 
3222 svoboda 205
    if (argv == NULL) {
206
        free(arg_buf);
207
        ipc_answer_0(rid, ENOMEM);
208
        return;
209
    }
4241 svoboda 210
 
3222 svoboda 211
    /*
212
     * Fill argv with argument pointers
213
     */
214
    p = arg_buf;
215
    n = 0;
4264 svoboda 216
    while (p < arg_buf + buf_size) {
3222 svoboda 217
        argv[n] = p;
4014 decky 218
 
4264 svoboda 219
        arg_size = str_size(p);
220
        p = p + arg_size + 1;
3222 svoboda 221
        ++n;
222
    }
4014 decky 223
 
3222 svoboda 224
    argc = n;
225
    argv[n] = NULL;
4241 svoboda 226
 
227
    ipc_answer_0(rid, EOK);
3222 svoboda 228
}
229
 
4461 decky 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
 
4492 jermar 245
    if ((buf_size % sizeof(fdi_node_t)) != 0) {
4461 decky 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
 
4492 jermar 270
    int count = buf_size / sizeof(fdi_node_t);
4461 decky 271
 
272
    /* Allocate filvv */
4492 jermar 273
    filv = malloc((count + 1) * sizeof(fdi_node_t *));
4461 decky 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
 
3470 svoboda 294
/** Load the previously selected program.
3222 svoboda 295
 *
296
 * @param rid
297
 * @param request
298
 * @return 0 on success, !0 on error.
299
 */
4461 decky 300
static int ldr_load(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 301
{
302
    int rc;
4014 decky 303
 
3222 svoboda 304
    rc = elf_load_file(pathname, 0, &prog_info);
4331 svoboda 305
    if (rc != EE_OK) {
3787 svoboda 306
        DPRINTF("Failed to load executable '%s'.\n", pathname);
3222 svoboda 307
        ipc_answer_0(rid, EINVAL);
308
        return 1;
309
    }
4014 decky 310
 
3222 svoboda 311
    elf_create_pcb(&prog_info, &pcb);
4014 decky 312
 
3222 svoboda 313
    pcb.argc = argc;
314
    pcb.argv = argv;
4014 decky 315
 
4461 decky 316
    pcb.filc = filc;
317
    pcb.filv = filv;
318
 
3222 svoboda 319
    if (prog_info.interp == NULL) {
320
        /* Statically linked program */
3470 svoboda 321
        is_dyn_linked = false;
3222 svoboda 322
        ipc_answer_0(rid, EOK);
323
        return 0;
324
    }
4014 decky 325
 
3676 svoboda 326
    rc = elf_load_file(prog_info.interp, 0, &interp_info);
4331 svoboda 327
    if (rc != EE_OK) {
3787 svoboda 328
        DPRINTF("Failed to load interpreter '%s.'\n",
329
            prog_info.interp);
3222 svoboda 330
        ipc_answer_0(rid, EINVAL);
331
        return 1;
332
    }
4014 decky 333
 
3470 svoboda 334
    is_dyn_linked = true;
3222 svoboda 335
    ipc_answer_0(rid, EOK);
4014 decky 336
 
3222 svoboda 337
    return 0;
338
}
339
 
3470 svoboda 340
 
341
/** Run the previously loaded program.
342
 *
343
 * @param rid
344
 * @param request
345
 * @return 0 on success, !0 on error.
346
 */
4461 decky 347
static void ldr_run(ipc_callid_t rid, ipc_call_t *request)
3470 svoboda 348
{
4012 svoboda 349
    const char *cp;
4014 decky 350
 
3983 svoboda 351
    /* Set the task name. */
4265 svoboda 352
    cp = str_rchr(pathname, '/');
4012 svoboda 353
    cp = (cp == NULL) ? pathname : (cp + 1);
354
    task_set_name(cp);
4014 decky 355
 
3470 svoboda 356
    if (is_dyn_linked == true) {
357
        /* Dynamically linked program */
3787 svoboda 358
        DPRINTF("Run ELF interpreter.\n");
359
        DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
4014 decky 360
 
3470 svoboda 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);
4461 decky 367
    }
368
 
3470 svoboda 369
    /* Not reached */
370
}
371
 
3222 svoboda 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
 */
4461 decky 377
static void ldr_connection(ipc_callid_t iid, ipc_call_t *icall)
3222 svoboda 378
{
379
    ipc_callid_t callid;
380
    ipc_call_t call;
381
    int retval;
4014 decky 382
 
3896 svoboda 383
    /* Already have a connection? */
384
    if (connected) {
385
        ipc_answer_0(iid, ELIMIT);
386
        return;
387
    }
4014 decky 388
 
3896 svoboda 389
    connected = true;
390
 
391
    /* Accept the connection */
392
    ipc_answer_0(iid, EOK);
4014 decky 393
 
3222 svoboda 394
    /* Ignore parameters, the connection is already open */
4014 decky 395
    (void) iid;
396
    (void) icall;
397
 
3222 svoboda 398
    while (1) {
399
        callid = async_get_call(&call);
4014 decky 400
 
3222 svoboda 401
        switch (IPC_GET_METHOD(call)) {
3559 svoboda 402
        case IPC_M_PHONE_HUNGUP:
403
            exit(0);
3447 svoboda 404
        case LOADER_GET_TASKID:
4461 decky 405
            ldr_get_taskid(callid, &call);
3447 svoboda 406
            continue;
3222 svoboda 407
        case LOADER_SET_PATHNAME:
4461 decky 408
            ldr_set_pathname(callid, &call);
3222 svoboda 409
            continue;
410
        case LOADER_SET_ARGS:
4461 decky 411
            ldr_set_args(callid, &call);
3470 svoboda 412
            continue;
4461 decky 413
        case LOADER_SET_FILES:
414
            ldr_set_files(callid, &call);
415
            continue;
3470 svoboda 416
        case LOADER_LOAD:
4461 decky 417
            ldr_load(callid, &call);
3470 svoboda 418
            continue;
3222 svoboda 419
        case LOADER_RUN:
4461 decky 420
            ldr_run(callid, &call);
3470 svoboda 421
            /* Not reached */
3222 svoboda 422
        default:
423
            retval = ENOENT;
424
            break;
425
        }
426
        if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
427
            IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
3787 svoboda 428
            DPRINTF("Responding EINVAL to method %d.\n",
3222 svoboda 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
{
3896 svoboda 439
    ipcarg_t phonead;
4014 decky 440
 
3896 svoboda 441
    connected = false;
442
 
443
    /* Set a handler of incomming connections. */
4461 decky 444
    async_set_client_connection(ldr_connection);
4014 decky 445
 
3896 svoboda 446
    /* Register at naming service. */
447
    if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)
448
        return -1;
449
 
3222 svoboda 450
    async_manager();
4014 decky 451
 
3896 svoboda 452
    /* Never reached */
3222 svoboda 453
    return 0;
454
}
455
 
456
/** @}
457
 */