Subversion Repositories HelenOS

Rev

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