Subversion Repositories HelenOS

Rev

Rev 4581 | 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>
4718 mejdrech 55
#include <ipc/ns.h>
56
#include <macros.h>
3222 svoboda 57
#include <loader/pcb.h>
58
#include <errno.h>
59
#include <async.h>
4581 mejdrech 60
#include <string.h>
3222 svoboda 61
#include <as.h>
62
 
63
#include <elf.h>
64
#include <elf_load.h>
65
 
4153 mejdrech 66
#define DPRINTF(...)
3222 svoboda 67
 
68
/** Pathname of the file that will be loaded */
69
static char *pathname = NULL;
70
 
71
/** The Program control block */
72
static pcb_t pcb;
73
 
74
/** Number of arguments */
75
static int argc = 0;
76
/** Argument vector */
77
static char **argv = NULL;
78
/** Buffer holding all arguments */
79
static char *arg_buf = NULL;
80
 
4581 mejdrech 81
/** Number of preset files */
82
static int filc = 0;
83
/** Preset files vector */
84
static fdi_node_t **filv = NULL;
85
/** Buffer holding all preset files */
86
static fdi_node_t *fil_buf = NULL;
87
 
4153 mejdrech 88
static elf_info_t prog_info;
89
static elf_info_t interp_info;
90
 
91
static bool is_dyn_linked;
92
 
93
/** Used to limit number of connections to one. */
94
static bool connected;
95
 
4581 mejdrech 96
static void ldr_get_taskid(ipc_callid_t rid, ipc_call_t *request)
4153 mejdrech 97
{
98
	ipc_callid_t callid;
99
	task_id_t task_id;
100
	size_t len;
101
 
102
	task_id = task_get_id();
103
 
104
	if (!ipc_data_read_receive(&callid, &len)) {
105
		ipc_answer_0(callid, EINVAL);
106
		ipc_answer_0(rid, EINVAL);
107
		return;
108
	}
109
 
110
	if (len > sizeof(task_id))
111
		len = sizeof(task_id);
112
 
113
	ipc_data_read_finalize(callid, &task_id, len);
114
	ipc_answer_0(rid, EOK);
115
}
116
 
117
 
3222 svoboda 118
/** Receive a call setting pathname of the program to execute.
119
 *
120
 * @param rid
121
 * @param request
122
 */
4581 mejdrech 123
static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 124
{
125
	ipc_callid_t callid;
126
	size_t len;
127
	char *name_buf;
4153 mejdrech 128
 
3222 svoboda 129
	if (!ipc_data_write_receive(&callid, &len)) {
130
		ipc_answer_0(callid, EINVAL);
131
		ipc_answer_0(rid, EINVAL);
132
		return;
133
	}
4153 mejdrech 134
 
3222 svoboda 135
	name_buf = malloc(len + 1);
136
	if (!name_buf) {
137
		ipc_answer_0(callid, ENOMEM);
138
		ipc_answer_0(rid, ENOMEM);
139
		return;
140
	}
4153 mejdrech 141
 
3222 svoboda 142
	ipc_data_write_finalize(callid, name_buf, len);
143
	ipc_answer_0(rid, EOK);
4153 mejdrech 144
 
3222 svoboda 145
	if (pathname != NULL) {
146
		free(pathname);
147
		pathname = NULL;
148
	}
4153 mejdrech 149
 
3222 svoboda 150
	name_buf[len] = '\0';
151
	pathname = name_buf;
152
}
153
 
154
/** Receive a call setting arguments of the program to execute.
155
 *
156
 * @param rid
157
 * @param request
158
 */
4581 mejdrech 159
static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 160
{
161
	ipc_callid_t callid;
4327 mejdrech 162
	size_t buf_size, arg_size;
3222 svoboda 163
	char *p;
164
	int n;
4153 mejdrech 165
 
4327 mejdrech 166
	if (!ipc_data_write_receive(&callid, &buf_size)) {
3222 svoboda 167
		ipc_answer_0(callid, EINVAL);
168
		ipc_answer_0(rid, EINVAL);
169
		return;
170
	}
4153 mejdrech 171
 
3222 svoboda 172
	if (arg_buf != NULL) {
173
		free(arg_buf);
174
		arg_buf = NULL;
175
	}
4153 mejdrech 176
 
3222 svoboda 177
	if (argv != NULL) {
178
		free(argv);
179
		argv = NULL;
180
	}
4153 mejdrech 181
 
4327 mejdrech 182
	arg_buf = malloc(buf_size + 1);
3222 svoboda 183
	if (!arg_buf) {
184
		ipc_answer_0(callid, ENOMEM);
185
		ipc_answer_0(rid, ENOMEM);
186
		return;
187
	}
4153 mejdrech 188
 
4327 mejdrech 189
	ipc_data_write_finalize(callid, arg_buf, buf_size);
4153 mejdrech 190
 
4327 mejdrech 191
	arg_buf[buf_size] = '\0';
4153 mejdrech 192
 
3222 svoboda 193
	/*
194
	 * Count number of arguments
195
	 */
196
	p = arg_buf;
197
	n = 0;
4327 mejdrech 198
	while (p < arg_buf + buf_size) {
199
		arg_size = str_size(p);
200
		p = p + arg_size + 1;
3222 svoboda 201
		++n;
202
	}
4153 mejdrech 203
 
3222 svoboda 204
	/* Allocate argv */
205
	argv = malloc((n + 1) * sizeof(char *));
4153 mejdrech 206
 
3222 svoboda 207
	if (argv == NULL) {
208
		free(arg_buf);
209
		ipc_answer_0(rid, ENOMEM);
210
		return;
211
	}
4263 mejdrech 212
 
3222 svoboda 213
	/*
214
	 * Fill argv with argument pointers
215
	 */
216
	p = arg_buf;
217
	n = 0;
4327 mejdrech 218
	while (p < arg_buf + buf_size) {
3222 svoboda 219
		argv[n] = p;
4153 mejdrech 220
 
4327 mejdrech 221
		arg_size = str_size(p);
222
		p = p + arg_size + 1;
3222 svoboda 223
		++n;
224
	}
4153 mejdrech 225
 
3222 svoboda 226
	argc = n;
227
	argv[n] = NULL;
4263 mejdrech 228
 
229
	ipc_answer_0(rid, EOK);
3222 svoboda 230
}
231
 
4581 mejdrech 232
/** Receive a call setting preset files of the program to execute.
233
 *
234
 * @param rid
235
 * @param request
236
 */
237
static void ldr_set_files(ipc_callid_t rid, ipc_call_t *request)
238
{
239
	ipc_callid_t callid;
240
	size_t buf_size;
241
	if (!ipc_data_write_receive(&callid, &buf_size)) {
242
		ipc_answer_0(callid, EINVAL);
243
		ipc_answer_0(rid, EINVAL);
244
		return;
245
	}
246
 
247
	if ((buf_size % sizeof(fdi_node_t)) != 0) {
248
		ipc_answer_0(callid, EINVAL);
249
		ipc_answer_0(rid, EINVAL);
250
		return;
251
	}
252
 
253
	if (fil_buf != NULL) {
254
		free(fil_buf);
255
		fil_buf = NULL;
256
	}
257
 
258
	if (filv != NULL) {
259
		free(filv);
260
		filv = NULL;
261
	}
262
 
263
	fil_buf = malloc(buf_size);
264
	if (!fil_buf) {
265
		ipc_answer_0(callid, ENOMEM);
266
		ipc_answer_0(rid, ENOMEM);
267
		return;
268
	}
269
 
270
	ipc_data_write_finalize(callid, fil_buf, buf_size);
271
 
272
	int count = buf_size / sizeof(fdi_node_t);
273
 
274
	/* Allocate filvv */
275
	filv = malloc((count + 1) * sizeof(fdi_node_t *));
276
 
277
	if (filv == NULL) {
278
		free(fil_buf);
279
		ipc_answer_0(rid, ENOMEM);
280
		return;
281
	}
282
 
283
	/*
284
	 * Fill filv with argument pointers
285
	 */
286
	int i;
287
	for (i = 0; i < count; i++)
288
		filv[i] = &fil_buf[i];
289
 
290
	filc = count;
291
	filv[count] = NULL;
292
 
293
	ipc_answer_0(rid, EOK);
294
}
295
 
4153 mejdrech 296
/** Load the previously selected program.
3222 svoboda 297
 *
298
 * @param rid
299
 * @param request
300
 * @return 0 on success, !0 on error.
301
 */
4581 mejdrech 302
static int ldr_load(ipc_callid_t rid, ipc_call_t *request)
3222 svoboda 303
{
304
	int rc;
4153 mejdrech 305
 
3222 svoboda 306
	rc = elf_load_file(pathname, 0, &prog_info);
4581 mejdrech 307
	if (rc != EE_OK) {
4153 mejdrech 308
		DPRINTF("Failed to load executable '%s'.\n", pathname);
3222 svoboda 309
		ipc_answer_0(rid, EINVAL);
310
		return 1;
311
	}
4153 mejdrech 312
 
3222 svoboda 313
	elf_create_pcb(&prog_info, &pcb);
4153 mejdrech 314
 
3222 svoboda 315
	pcb.argc = argc;
316
	pcb.argv = argv;
4153 mejdrech 317
 
4581 mejdrech 318
	pcb.filc = filc;
319
	pcb.filv = filv;
320
 
3222 svoboda 321
	if (prog_info.interp == NULL) {
322
		/* Statically linked program */
4153 mejdrech 323
		is_dyn_linked = false;
3222 svoboda 324
		ipc_answer_0(rid, EOK);
325
		return 0;
326
	}
4153 mejdrech 327
 
328
	rc = elf_load_file(prog_info.interp, 0, &interp_info);
4581 mejdrech 329
	if (rc != EE_OK) {
4153 mejdrech 330
		DPRINTF("Failed to load interpreter '%s.'\n",
331
		    prog_info.interp);
3222 svoboda 332
		ipc_answer_0(rid, EINVAL);
333
		return 1;
334
	}
4153 mejdrech 335
 
336
	is_dyn_linked = true;
337
	ipc_answer_0(rid, EOK);
338
 
339
	return 0;
340
}
3222 svoboda 341
 
342
 
4153 mejdrech 343
/** Run the previously loaded program.
344
 *
345
 * @param rid
346
 * @param request
347
 * @return 0 on success, !0 on error.
348
 */
4581 mejdrech 349
static void ldr_run(ipc_callid_t rid, ipc_call_t *request)
4153 mejdrech 350
{
351
	const char *cp;
352
 
353
	/* Set the task name. */
4327 mejdrech 354
	cp = str_rchr(pathname, '/');
4153 mejdrech 355
	cp = (cp == NULL) ? pathname : (cp + 1);
356
	task_set_name(cp);
357
 
358
	if (is_dyn_linked == true) {
359
		/* Dynamically linked program */
360
		DPRINTF("Run ELF interpreter.\n");
361
		DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
362
 
363
		ipc_answer_0(rid, EOK);
364
		elf_run(&interp_info, &pcb);
365
	} else {
366
		/* Statically linked program */
367
		ipc_answer_0(rid, EOK);
368
		elf_run(&prog_info, &pcb);
4581 mejdrech 369
	}
370
 
3222 svoboda 371
	/* Not reached */
372
}
373
 
374
/** Handle loader connection.
375
 *
376
 * Receive and carry out commands (of which the last one should be
377
 * to execute the loaded program).
378
 */
4581 mejdrech 379
static void ldr_connection(ipc_callid_t iid, ipc_call_t *icall)
3222 svoboda 380
{
381
	ipc_callid_t callid;
382
	ipc_call_t call;
383
	int retval;
4153 mejdrech 384
 
385
	/* Already have a connection? */
386
	if (connected) {
387
		ipc_answer_0(iid, ELIMIT);
388
		return;
389
	}
390
 
391
	connected = true;
392
 
393
	/* Accept the connection */
394
	ipc_answer_0(iid, EOK);
395
 
3222 svoboda 396
	/* Ignore parameters, the connection is already open */
4153 mejdrech 397
	(void) iid;
398
	(void) icall;
399
 
3222 svoboda 400
	while (1) {
401
		callid = async_get_call(&call);
4153 mejdrech 402
 
3222 svoboda 403
		switch (IPC_GET_METHOD(call)) {
4153 mejdrech 404
		case IPC_M_PHONE_HUNGUP:
405
			exit(0);
406
		case LOADER_GET_TASKID:
4581 mejdrech 407
			ldr_get_taskid(callid, &call);
4153 mejdrech 408
			continue;
3222 svoboda 409
		case LOADER_SET_PATHNAME:
4581 mejdrech 410
			ldr_set_pathname(callid, &call);
3222 svoboda 411
			continue;
412
		case LOADER_SET_ARGS:
4581 mejdrech 413
			ldr_set_args(callid, &call);
4153 mejdrech 414
			continue;
4581 mejdrech 415
		case LOADER_SET_FILES:
416
			ldr_set_files(callid, &call);
417
			continue;
4153 mejdrech 418
		case LOADER_LOAD:
4581 mejdrech 419
			ldr_load(callid, &call);
4153 mejdrech 420
			continue;
3222 svoboda 421
		case LOADER_RUN:
4581 mejdrech 422
			ldr_run(callid, &call);
4153 mejdrech 423
			/* Not reached */
3222 svoboda 424
		default:
425
			retval = ENOENT;
426
			break;
427
		}
428
		if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
429
		    IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
4153 mejdrech 430
			DPRINTF("Responding EINVAL to method %d.\n",
3222 svoboda 431
			    IPC_GET_METHOD(call));
432
			ipc_answer_0(callid, EINVAL);
433
		}
434
	}
435
}
436
 
437
/** Program loader main function.
438
 */
439
int main(int argc, char *argv[])
440
{
4153 mejdrech 441
	ipcarg_t phonead;
4718 mejdrech 442
	task_id_t id;
443
	int rc;
444
 
4153 mejdrech 445
	connected = false;
4718 mejdrech 446
 
447
	/* Introduce this task to the NS (give it our task ID). */
448
	id = task_get_id();
449
	rc = async_req_2_0(PHONE_NS, NS_ID_INTRO, LOWER32(id), UPPER32(id));
450
	if (rc != EOK)
451
		return -1;
452
 
4153 mejdrech 453
	/* Set a handler of incomming connections. */
4581 mejdrech 454
	async_set_client_connection(ldr_connection);
4153 mejdrech 455
 
456
	/* Register at naming service. */
457
	if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0) 
4718 mejdrech 458
		return -2;
459
 
3222 svoboda 460
	async_manager();
4153 mejdrech 461
 
462
	/* Never reached */
3222 svoboda 463
	return 0;
464
}
465
 
466
/** @}
467
 */