Subversion Repositories HelenOS

Rev

Rev 4153 | Rev 4581 | Go to most recent revision | 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
4153 mejdrech 30
 * @brief Loads and runs programs from VFS.
3222 svoboda 31
 * @{
4153 mejdrech 32
 */
3222 svoboda 33
/**
34
 * @file
4153 mejdrech 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>
4153 mejdrech 49
#include <bool.h>
3222 svoboda 50
#include <fcntl.h>
51
#include <sys/types.h>
52
#include <ipc/ipc.h>
4153 mejdrech 53
#include <ipc/services.h>
3222 svoboda 54
#include <ipc/loader.h>
55
#include <loader/pcb.h>
4263 mejdrech 56
#include <console.h>
3222 svoboda 57
#include <errno.h>
58
#include <async.h>
59
#include <as.h>
60
 
61
#include <elf.h>
62
#include <elf_load.h>
63
 
4153 mejdrech 64
#define DPRINTF(...)
3222 svoboda 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
 
4153 mejdrech 79
static elf_info_t prog_info;
80
static elf_info_t interp_info;
81
 
82
static bool is_dyn_linked;
83
 
84
/** Used to limit number of connections to one. */
85
static bool connected;
86
 
87
static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
88
{
89
    ipc_callid_t callid;
90
    task_id_t task_id;
91
    size_t len;
92
 
93
    task_id = task_get_id();
94
 
95
    if (!ipc_data_read_receive(&callid, &len)) {
96
        ipc_answer_0(callid, EINVAL);
97
        ipc_answer_0(rid, EINVAL);
98
        return;
99
    }
100
 
101
    if (len > sizeof(task_id))
102
        len = sizeof(task_id);
103
 
104
    ipc_data_read_finalize(callid, &task_id, len);
105
    ipc_answer_0(rid, EOK);
106
}
107
 
108
 
3222 svoboda 109
/** Receive a call setting pathname of the program to execute.
110
 *
111
 * @param rid
112
 * @param request
113
 */
114
static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
115
{
116
    ipc_callid_t callid;
117
    size_t len;
118
    char *name_buf;
4153 mejdrech 119
 
3222 svoboda 120
    if (!ipc_data_write_receive(&callid, &len)) {
121
        ipc_answer_0(callid, EINVAL);
122
        ipc_answer_0(rid, EINVAL);
123
        return;
124
    }
4153 mejdrech 125
 
3222 svoboda 126
    name_buf = malloc(len + 1);
127
    if (!name_buf) {
128
        ipc_answer_0(callid, ENOMEM);
129
        ipc_answer_0(rid, ENOMEM);
130
        return;
131
    }
4153 mejdrech 132
 
3222 svoboda 133
    ipc_data_write_finalize(callid, name_buf, len);
134
    ipc_answer_0(rid, EOK);
4153 mejdrech 135
 
3222 svoboda 136
    if (pathname != NULL) {
137
        free(pathname);
138
        pathname = NULL;
139
    }
4153 mejdrech 140
 
3222 svoboda 141
    name_buf[len] = '\0';
142
    pathname = name_buf;
143
}
144
 
145
/** Receive a call setting arguments of the program to execute.
146
 *
147
 * @param rid
148
 * @param request
149
 */
150
static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
151
{
152
    ipc_callid_t callid;
153
    size_t buf_len, arg_len;
154
    char *p;
155
    int n;
4153 mejdrech 156
 
3222 svoboda 157
    if (!ipc_data_write_receive(&callid, &buf_len)) {
158
        ipc_answer_0(callid, EINVAL);
159
        ipc_answer_0(rid, EINVAL);
160
        return;
161
    }
4153 mejdrech 162
 
3222 svoboda 163
    if (arg_buf != NULL) {
164
        free(arg_buf);
165
        arg_buf = NULL;
166
    }
4153 mejdrech 167
 
3222 svoboda 168
    if (argv != NULL) {
169
        free(argv);
170
        argv = NULL;
171
    }
4153 mejdrech 172
 
3222 svoboda 173
    arg_buf = malloc(buf_len + 1);
174
    if (!arg_buf) {
175
        ipc_answer_0(callid, ENOMEM);
176
        ipc_answer_0(rid, ENOMEM);
177
        return;
178
    }
4153 mejdrech 179
 
3222 svoboda 180
    ipc_data_write_finalize(callid, arg_buf, buf_len);
4153 mejdrech 181
 
3222 svoboda 182
    arg_buf[buf_len] = '\0';
4153 mejdrech 183
 
3222 svoboda 184
    /*
185
     * Count number of arguments
186
     */
187
    p = arg_buf;
188
    n = 0;
189
    while (p < arg_buf + buf_len) {
190
        arg_len = strlen(p);
191
        p = p + arg_len + 1;
192
        ++n;
193
    }
4153 mejdrech 194
 
3222 svoboda 195
    /* Allocate argv */
196
    argv = malloc((n + 1) * sizeof(char *));
4153 mejdrech 197
 
3222 svoboda 198
    if (argv == NULL) {
199
        free(arg_buf);
200
        ipc_answer_0(rid, ENOMEM);
201
        return;
202
    }
4263 mejdrech 203
 
3222 svoboda 204
    /*
205
     * Fill argv with argument pointers
206
     */
207
    p = arg_buf;
208
    n = 0;
209
    while (p < arg_buf + buf_len) {
210
        argv[n] = p;
4153 mejdrech 211
 
3222 svoboda 212
        arg_len = strlen(p);
213
        p = p + arg_len + 1;
214
        ++n;
215
    }
4153 mejdrech 216
 
3222 svoboda 217
    argc = n;
218
    argv[n] = NULL;
4263 mejdrech 219
 
220
    ipc_answer_0(rid, EOK);
3222 svoboda 221
}
222
 
4153 mejdrech 223
/** Load the previously selected program.
3222 svoboda 224
 *
225
 * @param rid
226
 * @param request
227
 * @return 0 on success, !0 on error.
228
 */
4153 mejdrech 229
static int loader_load(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 230
{
231
    int rc;
4153 mejdrech 232
 
3222 svoboda 233
    rc = elf_load_file(pathname, 0, &prog_info);
234
    if (rc < 0) {
4153 mejdrech 235
        DPRINTF("Failed to load executable '%s'.\n", pathname);
3222 svoboda 236
        ipc_answer_0(rid, EINVAL);
237
        return 1;
238
    }
4153 mejdrech 239
 
3222 svoboda 240
    elf_create_pcb(&prog_info, &pcb);
4153 mejdrech 241
 
3222 svoboda 242
    pcb.argc = argc;
243
    pcb.argv = argv;
4153 mejdrech 244
 
3222 svoboda 245
    if (prog_info.interp == NULL) {
246
        /* Statically linked program */
4153 mejdrech 247
        is_dyn_linked = false;
3222 svoboda 248
        ipc_answer_0(rid, EOK);
249
        return 0;
250
    }
4153 mejdrech 251
 
252
    rc = elf_load_file(prog_info.interp, 0, &interp_info);
3222 svoboda 253
    if (rc < 0) {
4153 mejdrech 254
        DPRINTF("Failed to load interpreter '%s.'\n",
255
            prog_info.interp);
3222 svoboda 256
        ipc_answer_0(rid, EINVAL);
257
        return 1;
258
    }
4153 mejdrech 259
 
260
    is_dyn_linked = true;
261
    ipc_answer_0(rid, EOK);
262
 
263
    return 0;
264
}
3222 svoboda 265
 
266
 
4153 mejdrech 267
/** Run the previously loaded program.
268
 *
269
 * @param rid
270
 * @param request
271
 * @return 0 on success, !0 on error.
272
 */
273
static void loader_run(ipc_callid_t rid, ipc_call_t *request)
274
{
275
    const char *cp;
276
 
277
    /* Set the task name. */
278
    cp = strrchr(pathname, '/');
279
    cp = (cp == NULL) ? pathname : (cp + 1);
280
    task_set_name(cp);
281
 
282
    if (is_dyn_linked == true) {
283
        /* Dynamically linked program */
284
        DPRINTF("Run ELF interpreter.\n");
285
        DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
4263 mejdrech 286
        console_close();
4153 mejdrech 287
 
288
        ipc_answer_0(rid, EOK);
289
        elf_run(&interp_info, &pcb);
290
    } else {
291
        /* Statically linked program */
4263 mejdrech 292
        console_close();
4153 mejdrech 293
        ipc_answer_0(rid, EOK);
294
        elf_run(&prog_info, &pcb);
295
    }
3222 svoboda 296
 
297
    /* Not reached */
298
}
299
 
300
/** Handle loader connection.
301
 *
302
 * Receive and carry out commands (of which the last one should be
303
 * to execute the loaded program).
304
 */
305
static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)
306
{
307
    ipc_callid_t callid;
308
    ipc_call_t call;
309
    int retval;
4153 mejdrech 310
 
311
    /* Already have a connection? */
312
    if (connected) {
313
        ipc_answer_0(iid, ELIMIT);
314
        return;
315
    }
316
 
317
    connected = true;
318
 
319
    /* Accept the connection */
320
    ipc_answer_0(iid, EOK);
321
 
3222 svoboda 322
    /* Ignore parameters, the connection is already open */
4153 mejdrech 323
    (void) iid;
324
    (void) icall;
325
 
3222 svoboda 326
    while (1) {
327
        callid = async_get_call(&call);
4153 mejdrech 328
 
3222 svoboda 329
        switch (IPC_GET_METHOD(call)) {
4153 mejdrech 330
        case IPC_M_PHONE_HUNGUP:
331
            exit(0);
332
        case LOADER_GET_TASKID:
333
            loader_get_taskid(callid, &call);
334
            continue;
3222 svoboda 335
        case LOADER_SET_PATHNAME:
336
            loader_set_pathname(callid, &call);
337
            continue;
338
        case LOADER_SET_ARGS:
339
            loader_set_args(callid, &call);
4153 mejdrech 340
            continue;
341
        case LOADER_LOAD:
342
            loader_load(callid, &call);
343
            continue;
3222 svoboda 344
        case LOADER_RUN:
345
            loader_run(callid, &call);
4153 mejdrech 346
            /* Not reached */
3222 svoboda 347
        default:
348
            retval = ENOENT;
349
            break;
350
        }
351
        if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
352
            IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
4153 mejdrech 353
            DPRINTF("Responding EINVAL to method %d.\n",
3222 svoboda 354
                IPC_GET_METHOD(call));
355
            ipc_answer_0(callid, EINVAL);
356
        }
357
    }
358
}
359
 
360
/** Program loader main function.
361
 */
362
int main(int argc, char *argv[])
363
{
4153 mejdrech 364
    ipcarg_t phonead;
365
 
366
    connected = false;
367
 
368
    /* Set a handler of incomming connections. */
369
    async_set_client_connection(loader_connection);
370
 
371
    /* Register at naming service. */
372
    if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)
373
        return -1;
374
 
3222 svoboda 375
    async_manager();
4153 mejdrech 376
 
377
    /* Never reached */
3222 svoboda 378
    return 0;
379
}
380
 
381
/** @}
382
 */