Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
2928 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
30
 * @brief	Loads and runs programs from VFS.
31
 * @{
32
 */ 
33
/**
34
 * @file
3101 svoboda 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.
2928 svoboda 44
 */
45
 
46
#include <stdio.h>
3004 svoboda 47
#include <stdlib.h>
2928 svoboda 48
#include <unistd.h>
3474 svoboda 49
#include <bool.h>
2928 svoboda 50
#include <fcntl.h>
51
#include <sys/types.h>
3004 svoboda 52
#include <ipc/ipc.h>
3148 svoboda 53
#include <ipc/loader.h>
3160 svoboda 54
#include <loader/pcb.h>
3004 svoboda 55
#include <errno.h>
3148 svoboda 56
#include <async.h>
2959 svoboda 57
#include <as.h>
2928 svoboda 58
 
2969 svoboda 59
#include <elf.h>
60
#include <elf_load.h>
2928 svoboda 61
 
3101 svoboda 62
/** 
63
 * Bias used for loading the dynamic linker. This will be soon replaced
64
 * by automatic placement.
65
 */
2972 svoboda 66
#define RTLD_BIAS 0x80000
67
 
3101 svoboda 68
/** Pathname of the file that will be loaded */
3004 svoboda 69
static char *pathname = NULL;
70
 
3170 svoboda 71
/** The Program control block */
72
static pcb_t pcb;
73
 
3174 svoboda 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
 
3474 svoboda 81
static elf_info_t prog_info;
82
static elf_info_t interp_info;
83
 
84
static bool is_dyn_linked;
85
 
86
 
87
static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
3448 svoboda 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)) len = sizeof(task_id);
102
 
3535 svoboda 103
	ipc_data_read_finalize(callid, &task_id, len);
3448 svoboda 104
	ipc_answer_0(rid, EOK);
105
}
106
 
107
 
3101 svoboda 108
/** Receive a call setting pathname of the program to execute.
109
 *
110
 * @param rid
111
 * @param request
112
 */
3174 svoboda 113
static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
2928 svoboda 114
{
3148 svoboda 115
	ipc_callid_t callid;
3004 svoboda 116
	size_t len;
117
	char *name_buf;
118
 
119
	if (!ipc_data_write_receive(&callid, &len)) {
120
		ipc_answer_0(callid, EINVAL);
121
		ipc_answer_0(rid, EINVAL);
122
		return;
123
	}
3148 svoboda 124
 
3004 svoboda 125
	name_buf = malloc(len + 1);
126
	if (!name_buf) {
3148 svoboda 127
		ipc_answer_0(callid, ENOMEM);
3004 svoboda 128
		ipc_answer_0(rid, ENOMEM);
129
		return;
130
	}
131
 
3148 svoboda 132
	ipc_data_write_finalize(callid, name_buf, len);
133
	ipc_answer_0(rid, EOK);
3004 svoboda 134
 
135
	if (pathname != NULL) {
136
		free(pathname);
137
		pathname = NULL;
138
	}
139
 
3148 svoboda 140
	name_buf[len] = '\0';
3004 svoboda 141
	pathname = name_buf;
142
}
143
 
3174 svoboda 144
/** Receive a call setting arguments of the program to execute.
145
 *
146
 * @param rid
147
 * @param request
148
 */
149
static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
150
{
151
	ipc_callid_t callid;
152
	size_t buf_len, arg_len;
153
	char *p;
154
	int n;
155
 
156
	if (!ipc_data_write_receive(&callid, &buf_len)) {
157
		ipc_answer_0(callid, EINVAL);
158
		ipc_answer_0(rid, EINVAL);
159
		return;
160
	}
161
 
162
	if (arg_buf != NULL) {
163
		free(arg_buf);
164
		arg_buf = NULL;
165
	}
166
 
167
	if (argv != NULL) {
168
		free(argv);
169
		argv = NULL;
170
	}
171
 
172
	arg_buf = malloc(buf_len + 1);
173
	if (!arg_buf) {
174
		ipc_answer_0(callid, ENOMEM);
175
		ipc_answer_0(rid, ENOMEM);
176
		return;
177
	}
178
 
179
	ipc_data_write_finalize(callid, arg_buf, buf_len);
180
	ipc_answer_0(rid, EOK);
181
 
182
	arg_buf[buf_len] = '\0';
183
 
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
	}
194
 
195
	/* Allocate argv */
196
	argv = malloc((n + 1) * sizeof(char *));
197
 
198
	if (argv == NULL) {
199
		free(arg_buf);
200
		ipc_answer_0(callid, ENOMEM);
201
		ipc_answer_0(rid, ENOMEM);
202
		return;
203
	}
204
 
205
	/*
206
	 * Fill argv with argument pointers
207
	 */
208
	p = arg_buf;
209
	n = 0;
210
	while (p < arg_buf + buf_len) {
211
		argv[n] = p;
212
 
213
		arg_len = strlen(p);
214
		p = p + arg_len + 1;
215
		++n;
216
	}
217
 
218
	argc = n;
219
	argv[n] = NULL;
220
}
221
 
3474 svoboda 222
/** Load the previously selected program.
3101 svoboda 223
 *
224
 * @param rid
225
 * @param request
226
 * @return 0 on success, !0 on error.
227
 */
3474 svoboda 228
static int loader_load(ipc_callid_t rid, ipc_call_t *request)
3004 svoboda 229
{
230
	int rc;
231
 
3155 svoboda 232
//	printf("Load program '%s'\n", pathname);
2928 svoboda 233
 
3004 svoboda 234
	rc = elf_load_file(pathname, 0, &prog_info);
2928 svoboda 235
	if (rc < 0) {
236
		printf("failed to load program\n");
3155 svoboda 237
		ipc_answer_0(rid, EINVAL);
2928 svoboda 238
		return 1;
239
	}
240
 
3155 svoboda 241
//	printf("Create PCB\n");
3170 svoboda 242
	elf_create_pcb(&prog_info, &pcb);
2928 svoboda 243
 
3174 svoboda 244
	pcb.argc = argc;
245
	pcb.argv = argv;
3171 svoboda 246
 
3004 svoboda 247
	if (prog_info.interp == NULL) {
248
		/* Statically linked program */
3155 svoboda 249
//		printf("Run statically linked program\n");
250
//		printf("entry point: 0x%llx\n", prog_info.entry);
3474 svoboda 251
		is_dyn_linked = false;
3155 svoboda 252
		ipc_answer_0(rid, EOK);
3004 svoboda 253
		return 0;
254
	}
2988 svoboda 255
 
3004 svoboda 256
	printf("Load dynamic linker '%s'\n", prog_info.interp);
3400 svoboda 257
	rc = elf_load_file(prog_info.interp, RTLD_BIAS, &interp_info);
2959 svoboda 258
	if (rc < 0) {
259
		printf("failed to load dynamic linker\n");
3155 svoboda 260
		ipc_answer_0(rid, EINVAL);
2959 svoboda 261
		return 1;
262
	}
263
 
2989 svoboda 264
	/*
3004 svoboda 265
	 * Provide dynamic linker with some useful data
2989 svoboda 266
	 */
3170 svoboda 267
	pcb.rtld_dynamic = interp_info.dynamic;
268
	pcb.rtld_bias = RTLD_BIAS;
2989 svoboda 269
 
2959 svoboda 270
	printf("run dynamic linker\n");
3400 svoboda 271
	printf("rtld_dynamic = 0x%lx\n", pcb.rtld_dynamic);
272
	printf("entry point: 0x%lx\n", interp_info.entry);
273
	printf("pcb address: 0x%lx\n", &pcb);
3155 svoboda 274
 
3474 svoboda 275
	is_dyn_linked = true;
3155 svoboda 276
	ipc_answer_0(rid, EOK);
2989 svoboda 277
 
3004 svoboda 278
	return 0;
279
}
280
 
3474 svoboda 281
 
282
/** Run the previously loaded program.
283
 *
284
 * @param rid
285
 * @param request
286
 * @return 0 on success, !0 on error.
287
 */
288
static void loader_run(ipc_callid_t rid, ipc_call_t *request)
289
{
290
	if (is_dyn_linked == true) {
291
		/* Dynamically linked program */
292
		printf("run dynamic linker\n");
293
		printf("entry point: 0x%llx\n", interp_info.entry);
294
		close_console();
295
 
296
		ipc_answer_0(rid, EOK);
297
		elf_run(&interp_info, &pcb);
298
 
299
	} else {
300
		/* Statically linked program */
301
		close_console();
302
		ipc_answer_0(rid, EOK);
303
		elf_run(&prog_info, &pcb);
304
	} 
305
 
306
	/* Not reached */
307
}
308
 
3148 svoboda 309
/** Handle loader connection.
3101 svoboda 310
 *
311
 * Receive and carry out commands (of which the last one should be
312
 * to execute the loaded program).
313
 */
3148 svoboda 314
static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)
3004 svoboda 315
{
316
	ipc_callid_t callid;
317
	ipc_call_t call;
318
	int retval;
319
 
3148 svoboda 320
	/* Ignore parameters, the connection is already open */
321
	(void)iid; (void)icall;
322
 
3004 svoboda 323
	while (1) {
3148 svoboda 324
		callid = async_get_call(&call);
3474 svoboda 325
 
3004 svoboda 326
		switch (IPC_GET_METHOD(call)) {
3448 svoboda 327
		case LOADER_GET_TASKID:
328
			loader_get_taskid(callid, &call);
329
			continue;
3148 svoboda 330
		case LOADER_SET_PATHNAME:
3174 svoboda 331
			loader_set_pathname(callid, &call);
3148 svoboda 332
			continue;
3174 svoboda 333
		case LOADER_SET_ARGS:
334
			loader_set_args(callid, &call);
3474 svoboda 335
			continue;
336
		case LOADER_LOAD:
337
			loader_load(callid, &call);
338
			continue;
3148 svoboda 339
		case LOADER_RUN:
3174 svoboda 340
			loader_run(callid, &call);
3474 svoboda 341
			/* Not reached */
3004 svoboda 342
		default:
343
			retval = ENOENT;
344
			break;
345
		}
3174 svoboda 346
		if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
347
		    IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
348
			printf("responding EINVAL to method %d\n", 
349
			    IPC_GET_METHOD(call));
3004 svoboda 350
			ipc_answer_0(callid, EINVAL);
351
		}
352
	}
3148 svoboda 353
}
3004 svoboda 354
 
3148 svoboda 355
/** Program loader main function.
356
 */
357
int main(int argc, char *argv[])
358
{
359
	ipc_callid_t callid;
360
	ipc_call_t call;
361
	ipcarg_t phone_hash;
362
 
363
	/* The first call only communicates the incoming phone hash */
364
	callid = ipc_wait_for_call(&call);
365
 
366
	if (IPC_GET_METHOD(call) != LOADER_HELLO) {
367
		if (IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP)
368
			ipc_answer_0(callid, EINVAL);
369
		return 1;
370
	}
371
 
372
	ipc_answer_0(callid, EOK);
373
	phone_hash = call.in_phone_hash;
374
 
375
	/* 
3170 svoboda 376
	 * Up until now async must not be used as it couldn't
377
	 * handle incoming requests. (Which means e.g. printf() 
378
	 * cannot be used)
3148 svoboda 379
	 */
380
	async_new_connection(phone_hash, 0, NULL, loader_connection);
381
	async_manager();
382
 
2928 svoboda 383
	/* not reached */
384
	return 0;
385
}
386
 
387
/** @}
388
 */