WebSVN – HelenOS – Diff – /trunk/uspace/srv/loader/main.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup loader
 * @brief   Loads and runs programs from VFS.
 * @{
 */
/**
 * @file
 * @brief   Loads and runs programs from VFS.
 *
 * The program loader is a special init binary. Its image is used
 * to create a new task upon a @c task_spawn syscall. The syscall
 * returns the id of a phone connected to the newly created task.
 *
 * The caller uses this phone to send the pathname and various other
 * information to the loader. This is normally done by the C library
 * and completely hidden from applications.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <ipc/ipc.h>
#include <ipc/loader.h>
#include <loader/pcb.h>
#include <errno.h>
#include <async.h>
#include <as.h>
 
#include <elf.h>
#include <elf_load.h>
 
/**
 * Bias used for loading the dynamic linker. This will be soon replaced
 * by automatic placement.
 */
#define RTLD_BIAS 0x80000
 
/** Pathname of the file that will be loaded */
static char *pathname = NULL;
 
/** The Program control block */
static pcb_t pcb;
 
/** Number of arguments */
static int argc = 0;
/** Argument vector */
static char **argv = NULL;
/** Buffer holding all arguments */
static char *arg_buf = NULL;
 
static int loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_callid_t callid;
    task_id_t task_id;
    size_t len;
 
    task_id = task_get_id();
 
    if (!ipc_data_read_receive(&callid, &len)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    if (len > sizeof(task_id)) len = sizeof(task_id);
 
    ipc_data_write_finalize(callid, &task_id, len);
    ipc_answer_0(rid, EOK);
}
 
 
/** Receive a call setting pathname of the program to execute.
 *
 * @param rid
 * @param request
 */
static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_callid_t callid;
    size_t len;
    char *name_buf;
 
    if (!ipc_data_write_receive(&callid, &len)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    name_buf = malloc(len + 1);
    if (!name_buf) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    ipc_data_write_finalize(callid, name_buf, len);
    ipc_answer_0(rid, EOK);
 
    if (pathname != NULL) {
        free(pathname);
        pathname = NULL;
    }
 
    name_buf[len] = '\0';
    pathname = name_buf;
}
 
/** Receive a call setting arguments of the program to execute.
 *
 * @param rid
 * @param request
 */
static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
{
    ipc_callid_t callid;
    size_t buf_len, arg_len;
    char *p;
    int n;
 
    if (!ipc_data_write_receive(&callid, &buf_len)) {
        ipc_answer_0(callid, EINVAL);
        ipc_answer_0(rid, EINVAL);
        return;
    }
 
    if (arg_buf != NULL) {
        free(arg_buf);
        arg_buf = NULL;
    }
 
    if (argv != NULL) {
        free(argv);
        argv = NULL;
    }
 
    arg_buf = malloc(buf_len + 1);
    if (!arg_buf) {
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    ipc_data_write_finalize(callid, arg_buf, buf_len);
    ipc_answer_0(rid, EOK);
 
    arg_buf[buf_len] = '\0';
 
    /*
     * Count number of arguments
     */
    p = arg_buf;
    n = 0;
    while (p < arg_buf + buf_len) {
        arg_len = strlen(p);
        p = p + arg_len + 1;
        ++n;
    }
 
    /* Allocate argv */
    argv = malloc((n + 1) * sizeof(char *));
 
    if (argv == NULL) {
        free(arg_buf);
        ipc_answer_0(callid, ENOMEM);
        ipc_answer_0(rid, ENOMEM);
        return;
    }
 
    /*
     * Fill argv with argument pointers
     */
    p = arg_buf;
    n = 0;
    while (p < arg_buf + buf_len) {
        argv[n] = p;
 
        arg_len = strlen(p);
        p = p + arg_len + 1;
        ++n;
    }
 
    argc = n;
    argv[n] = NULL;
}
 
 
/** Load and run the previously selected program.
 *
 * @param rid
 * @param request
 * @return 0 on success, !0 on error.
 */
static int loader_run(ipc_callid_t rid, ipc_call_t *request)
{
    int rc;
 
    elf_info_t prog_info;
    elf_info_t interp_info;
 
//  printf("Load program '%s'\n", pathname);
 
    rc = elf_load_file(pathname, 0, &prog_info);
    if (rc < 0) {
        printf("failed to load program\n");
        ipc_answer_0(rid, EINVAL);
        return 1;
    }
 
//  printf("Create PCB\n");
    elf_create_pcb(&prog_info, &pcb);
 
    pcb.argc = argc;
    pcb.argv = argv;
 
    if (prog_info.interp == NULL) {
        /* Statically linked program */
//      printf("Run statically linked program\n");
//      printf("entry point: 0x%llx\n", prog_info.entry);
        ipc_answer_0(rid, EOK);
        close_console();
        elf_run(&prog_info, &pcb);
        return 0;
    }
 
    printf("Load dynamic linker '%s'\n", prog_info.interp);
    rc = elf_load_file("/rtld.so", RTLD_BIAS, &interp_info);
    if (rc < 0) {
        printf("failed to load dynamic linker\n");
        ipc_answer_0(rid, EINVAL);
        return 1;
    }
 
    /*
     * Provide dynamic linker with some useful data
     */
    pcb.rtld_dynamic = interp_info.dynamic;
    pcb.rtld_bias = RTLD_BIAS;
 
    printf("run dynamic linker\n");
    printf("entry point: 0x%llx\n", interp_info.entry);
    close_console();
 
    ipc_answer_0(rid, EOK);
    elf_run(&interp_info, &pcb);
 
    /* Not reached */
    return 0;
}
 
/** Handle loader connection.
 *
 * Receive and carry out commands (of which the last one should be
 * to execute the loaded program).
 */
static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int retval;
 
    /* Ignore parameters, the connection is already open */
    (void)iid; (void)icall;
 
    while (1) {
        callid = async_get_call(&call);
//      printf("received call from phone %d, method=%d\n",
//          call.in_phone_hash, IPC_GET_METHOD(call));
        switch (IPC_GET_METHOD(call)) {
        case LOADER_GET_TASKID:
            loader_get_taskid(callid, &call);
            continue;
        case LOADER_SET_PATHNAME:
            loader_set_pathname(callid, &call);
            continue;
        case LOADER_SET_ARGS:
            loader_set_args(callid, &call);
        case LOADER_RUN:
            loader_run(callid, &call);
            exit(0);
            continue;
        default:
            retval = ENOENT;
            break;
        }
        if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
            IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
            printf("responding EINVAL to method %d\n",
                IPC_GET_METHOD(call));
            ipc_answer_0(callid, EINVAL);
        }
    }
}
 
/** Program loader main function.
 */
int main(int argc, char *argv[])
{
    ipc_callid_t callid;
    ipc_call_t call;
    ipcarg_t phone_hash;
 
    /* The first call only communicates the incoming phone hash */
    callid = ipc_wait_for_call(&call);
 
    if (IPC_GET_METHOD(call) != LOADER_HELLO) {
        if (IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP)
            ipc_answer_0(callid, EINVAL);
        return 1;
    }
 
    ipc_answer_0(callid, EOK);
    phone_hash = call.in_phone_hash;
 
    /*
     * Up until now async must not be used as it couldn't
     * handle incoming requests. (Which means e.g. printf()
     * cannot be used)
     */
    async_new_connection(phone_hash, 0, NULL, loader_connection);
    async_manager();
 
    /* not reached */
    return 0;
}
 
/** @}
 */
 

Rev 3222	Rev 3447
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup loader	29	/** @addtogroup loader
30	* @brief Loads and runs programs from VFS.	30	* @brief Loads and runs programs from VFS.
31	* @{	31	* @{
32	*/	32	*/
33	/**	33	/**
34	* @file	34	* @file
35	* @brief Loads and runs programs from VFS.	35	* @brief Loads and runs programs from VFS.
36	*	36	*
37	* The program loader is a special init binary. Its image is used	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	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.	39	* returns the id of a phone connected to the newly created task.
40	*	40	*
41	* The caller uses this phone to send the pathname and various other	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	42	* information to the loader. This is normally done by the C library
43	* and completely hidden from applications.	43	* and completely hidden from applications.
44	*/	44	*/
45		45
46	#include <stdio.h>	46	#include <stdio.h>
47	#include <stdlib.h>	47	#include <stdlib.h>
48	#include <unistd.h>	48	#include <unistd.h>
49	#include <fcntl.h>	49	#include <fcntl.h>
50	#include <sys/types.h>	50	#include <sys/types.h>
51	#include <ipc/ipc.h>	51	#include <ipc/ipc.h>
52	#include <ipc/loader.h>	52	#include <ipc/loader.h>
53	#include <loader/pcb.h>	53	#include <loader/pcb.h>
54	#include <errno.h>	54	#include <errno.h>
55	#include <async.h>	55	#include <async.h>
56	#include <as.h>	56	#include <as.h>
57		57
58	#include <elf.h>	58	#include <elf.h>
59	#include <elf_load.h>	59	#include <elf_load.h>
60		60
61	/**	61	/**
62	* Bias used for loading the dynamic linker. This will be soon replaced	62	* Bias used for loading the dynamic linker. This will be soon replaced
63	* by automatic placement.	63	* by automatic placement.
64	*/	64	*/
65	#define RTLD_BIAS 0x80000	65	#define RTLD_BIAS 0x80000
66		66
67	/** Pathname of the file that will be loaded */	67	/** Pathname of the file that will be loaded */
68	static char *pathname = NULL;	68	static char *pathname = NULL;
69		69
70	/** The Program control block */	70	/** The Program control block */
71	static pcb_t pcb;	71	static pcb_t pcb;
72		72
73	/** Number of arguments */	73	/** Number of arguments */
74	static int argc = 0;	74	static int argc = 0;
75	/** Argument vector */	75	/** Argument vector */
76	static char **argv = NULL;	76	static char **argv = NULL;
77	/** Buffer holding all arguments */	77	/** Buffer holding all arguments */
78	static char *arg_buf = NULL;	78	static char *arg_buf = NULL;
79		79
-		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
80	/** Receive a call setting pathname of the program to execute.	101	/** Receive a call setting pathname of the program to execute.
81	*	102	*
82	* @param rid	103	* @param rid
83	* @param request	104	* @param request
84	*/	105	*/
85	static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)	106	static void loader_set_pathname(ipc_callid_t rid, ipc_call_t *request)
86	{	107	{
87	ipc_callid_t callid;	108	ipc_callid_t callid;
88	size_t len;	109	size_t len;
89	char *name_buf;	110	char *name_buf;
90		111
91	if (!ipc_data_write_receive(&callid, &len)) {	112	if (!ipc_data_write_receive(&callid, &len)) {
92	ipc_answer_0(callid, EINVAL);	113	ipc_answer_0(callid, EINVAL);
93	ipc_answer_0(rid, EINVAL);	114	ipc_answer_0(rid, EINVAL);
94	return;	115	return;
95	}	116	}
96		117
97	name_buf = malloc(len + 1);	118	name_buf = malloc(len + 1);
98	if (!name_buf) {	119	if (!name_buf) {
99	ipc_answer_0(callid, ENOMEM);	120	ipc_answer_0(callid, ENOMEM);
100	ipc_answer_0(rid, ENOMEM);	121	ipc_answer_0(rid, ENOMEM);
101	return;	122	return;
102	}	123	}
103		124
104	ipc_data_write_finalize(callid, name_buf, len);	125	ipc_data_write_finalize(callid, name_buf, len);
105	ipc_answer_0(rid, EOK);	126	ipc_answer_0(rid, EOK);
106		127
107	if (pathname != NULL) {	128	if (pathname != NULL) {
108	free(pathname);	129	free(pathname);
109	pathname = NULL;	130	pathname = NULL;
110	}	131	}
111		132
112	name_buf[len] = '\0';	133	name_buf[len] = '\0';
113	pathname = name_buf;	134	pathname = name_buf;
114	}	135	}
115		136
116	/** Receive a call setting arguments of the program to execute.	137	/** Receive a call setting arguments of the program to execute.
117	*	138	*
118	* @param rid	139	* @param rid
119	* @param request	140	* @param request
120	*/	141	*/
121	static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)	142	static void loader_set_args(ipc_callid_t rid, ipc_call_t *request)
122	{	143	{
123	ipc_callid_t callid;	144	ipc_callid_t callid;
124	size_t buf_len, arg_len;	145	size_t buf_len, arg_len;
125	char *p;	146	char *p;
126	int n;	147	int n;
127		148
128	if (!ipc_data_write_receive(&callid, &buf_len)) {	149	if (!ipc_data_write_receive(&callid, &buf_len)) {
129	ipc_answer_0(callid, EINVAL);	150	ipc_answer_0(callid, EINVAL);
130	ipc_answer_0(rid, EINVAL);	151	ipc_answer_0(rid, EINVAL);
131	return;	152	return;
132	}	153	}
133		154
134	if (arg_buf != NULL) {	155	if (arg_buf != NULL) {
135	free(arg_buf);	156	free(arg_buf);
136	arg_buf = NULL;	157	arg_buf = NULL;
137	}	158	}
138		159
139	if (argv != NULL) {	160	if (argv != NULL) {
140	free(argv);	161	free(argv);
141	argv = NULL;	162	argv = NULL;
142	}	163	}
143		164
144	arg_buf = malloc(buf_len + 1);	165	arg_buf = malloc(buf_len + 1);
145	if (!arg_buf) {	166	if (!arg_buf) {
146	ipc_answer_0(callid, ENOMEM);	167	ipc_answer_0(callid, ENOMEM);
147	ipc_answer_0(rid, ENOMEM);	168	ipc_answer_0(rid, ENOMEM);
148	return;	169	return;
149	}	170	}
150		171
151	ipc_data_write_finalize(callid, arg_buf, buf_len);	172	ipc_data_write_finalize(callid, arg_buf, buf_len);
152	ipc_answer_0(rid, EOK);	173	ipc_answer_0(rid, EOK);
153		174
154	arg_buf[buf_len] = '\0';	175	arg_buf[buf_len] = '\0';
155		176
156	/*	177	/*
157	* Count number of arguments	178	* Count number of arguments
158	*/	179	*/
159	p = arg_buf;	180	p = arg_buf;
160	n = 0;	181	n = 0;
161	while (p < arg_buf + buf_len) {	182	while (p < arg_buf + buf_len) {
162	arg_len = strlen(p);	183	arg_len = strlen(p);
163	p = p + arg_len + 1;	184	p = p + arg_len + 1;
164	++n;	185	++n;
165	}	186	}
166		187
167	/* Allocate argv */	188	/* Allocate argv */
168	argv = malloc((n + 1) * sizeof(char *));	189	argv = malloc((n + 1) * sizeof(char *));
169		190
170	if (argv == NULL) {	191	if (argv == NULL) {
171	free(arg_buf);	192	free(arg_buf);
172	ipc_answer_0(callid, ENOMEM);	193	ipc_answer_0(callid, ENOMEM);
173	ipc_answer_0(rid, ENOMEM);	194	ipc_answer_0(rid, ENOMEM);
174	return;	195	return;
175	}	196	}
176		197
177	/*	198	/*
178	* Fill argv with argument pointers	199	* Fill argv with argument pointers
179	*/	200	*/
180	p = arg_buf;	201	p = arg_buf;
181	n = 0;	202	n = 0;
182	while (p < arg_buf + buf_len) {	203	while (p < arg_buf + buf_len) {
183	argv[n] = p;	204	argv[n] = p;
184		205
185	arg_len = strlen(p);	206	arg_len = strlen(p);
186	p = p + arg_len + 1;	207	p = p + arg_len + 1;
187	++n;	208	++n;
188	}	209	}
189		210
190	argc = n;	211	argc = n;
191	argv[n] = NULL;	212	argv[n] = NULL;
192	}	213	}
193		214
194		215
195	/** Load and run the previously selected program.	216	/** Load and run the previously selected program.
196	*	217	*
197	* @param rid	218	* @param rid
198	* @param request	219	* @param request
199	* @return 0 on success, !0 on error.	220	* @return 0 on success, !0 on error.
200	*/	221	*/
201	static int loader_run(ipc_callid_t rid, ipc_call_t *request)	222	static int loader_run(ipc_callid_t rid, ipc_call_t *request)
202	{	223	{
203	int rc;	224	int rc;
204		225
205	elf_info_t prog_info;	226	elf_info_t prog_info;
206	elf_info_t interp_info;	227	elf_info_t interp_info;
207		228
208	// printf("Load program '%s'\n", pathname);	229	// printf("Load program '%s'\n", pathname);
209		230
210	rc = elf_load_file(pathname, 0, &prog_info);	231	rc = elf_load_file(pathname, 0, &prog_info);
211	if (rc < 0) {	232	if (rc < 0) {
212	printf("failed to load program\n");	233	printf("failed to load program\n");
213	ipc_answer_0(rid, EINVAL);	234	ipc_answer_0(rid, EINVAL);
214	return 1;	235	return 1;
215	}	236	}
216		237
217	// printf("Create PCB\n");	238	// printf("Create PCB\n");
218	elf_create_pcb(&prog_info, &pcb);	239	elf_create_pcb(&prog_info, &pcb);
219		240
220	pcb.argc = argc;	241	pcb.argc = argc;
221	pcb.argv = argv;	242	pcb.argv = argv;
222		243
223	if (prog_info.interp == NULL) {	244	if (prog_info.interp == NULL) {
224	/* Statically linked program */	245	/* Statically linked program */
225	// printf("Run statically linked program\n");	246	// printf("Run statically linked program\n");
226	// printf("entry point: 0x%llx\n", prog_info.entry);	247	// printf("entry point: 0x%llx\n", prog_info.entry);
227	ipc_answer_0(rid, EOK);	248	ipc_answer_0(rid, EOK);
228	close_console();	249	close_console();
229	elf_run(&prog_info, &pcb);	250	elf_run(&prog_info, &pcb);
230	return 0;	251	return 0;
231	}	252	}
232		253
233	printf("Load dynamic linker '%s'\n", prog_info.interp);	254	printf("Load dynamic linker '%s'\n", prog_info.interp);
234	rc = elf_load_file("/rtld.so", RTLD_BIAS, &interp_info);	255	rc = elf_load_file("/rtld.so", RTLD_BIAS, &interp_info);
235	if (rc < 0) {	256	if (rc < 0) {
236	printf("failed to load dynamic linker\n");	257	printf("failed to load dynamic linker\n");
237	ipc_answer_0(rid, EINVAL);	258	ipc_answer_0(rid, EINVAL);
238	return 1;	259	return 1;
239	}	260	}
240		261
241	/*	262	/*
242	* Provide dynamic linker with some useful data	263	* Provide dynamic linker with some useful data
243	*/	264	*/
244	pcb.rtld_dynamic = interp_info.dynamic;	265	pcb.rtld_dynamic = interp_info.dynamic;
245	pcb.rtld_bias = RTLD_BIAS;	266	pcb.rtld_bias = RTLD_BIAS;
246		267
247	printf("run dynamic linker\n");	268	printf("run dynamic linker\n");
248	printf("entry point: 0x%llx\n", interp_info.entry);	269	printf("entry point: 0x%llx\n", interp_info.entry);
249	close_console();	270	close_console();
250		271
251	ipc_answer_0(rid, EOK);	272	ipc_answer_0(rid, EOK);
252	elf_run(&interp_info, &pcb);	273	elf_run(&interp_info, &pcb);
253		274
254	/* Not reached */	275	/* Not reached */
255	return 0;	276	return 0;
256	}	277	}
257		278
258	/** Handle loader connection.	279	/** Handle loader connection.
259	*	280	*
260	* Receive and carry out commands (of which the last one should be	281	* Receive and carry out commands (of which the last one should be
261	* to execute the loaded program).	282	* to execute the loaded program).
262	*/	283	*/
263	static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)	284	static void loader_connection(ipc_callid_t iid, ipc_call_t *icall)
264	{	285	{
265	ipc_callid_t callid;	286	ipc_callid_t callid;
266	ipc_call_t call;	287	ipc_call_t call;
267	int retval;	288	int retval;
268		289
269	/* Ignore parameters, the connection is already open */	290	/* Ignore parameters, the connection is already open */
270	(void)iid; (void)icall;	291	(void)iid; (void)icall;
271		292
272	while (1) {	293	while (1) {
273	callid = async_get_call(&call);	294	callid = async_get_call(&call);
274	// printf("received call from phone %d, method=%d\n",	295	// printf("received call from phone %d, method=%d\n",
275	// call.in_phone_hash, IPC_GET_METHOD(call));	296	// call.in_phone_hash, IPC_GET_METHOD(call));
276	switch (IPC_GET_METHOD(call)) {	297	switch (IPC_GET_METHOD(call)) {
-		298	case LOADER_GET_TASKID:
-		299	loader_get_taskid(callid, &call);
-		300	continue;
277	case LOADER_SET_PATHNAME:	301	case LOADER_SET_PATHNAME:
278	loader_set_pathname(callid, &call);	302	loader_set_pathname(callid, &call);
279	continue;	303	continue;
280	case LOADER_SET_ARGS:	304	case LOADER_SET_ARGS:
281	loader_set_args(callid, &call);	305	loader_set_args(callid, &call);
282	case LOADER_RUN:	306	case LOADER_RUN:
283	loader_run(callid, &call);	307	loader_run(callid, &call);
284	exit(0);	308	exit(0);
285	continue;	309	continue;
286	default:	310	default:
287	retval = ENOENT;	311	retval = ENOENT;
288	break;	312	break;
289	}	313	}
290	if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&	314	if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
291	IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {	315	IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
292	printf("responding EINVAL to method %d\n",	316	printf("responding EINVAL to method %d\n",
293	IPC_GET_METHOD(call));	317	IPC_GET_METHOD(call));
294	ipc_answer_0(callid, EINVAL);	318	ipc_answer_0(callid, EINVAL);
295	}	319	}
296	}	320	}
297	}	321	}
298		322
299	/** Program loader main function.	323	/** Program loader main function.
300	*/	324	*/
301	int main(int argc, char *argv[])	325	int main(int argc, char *argv[])
302	{	326	{
303	ipc_callid_t callid;	327	ipc_callid_t callid;
304	ipc_call_t call;	328	ipc_call_t call;
305	ipcarg_t phone_hash;	329	ipcarg_t phone_hash;
306		330
307	/* The first call only communicates the incoming phone hash */	331	/* The first call only communicates the incoming phone hash */
308	callid = ipc_wait_for_call(&call);	332	callid = ipc_wait_for_call(&call);
309		333
310	if (IPC_GET_METHOD(call) != LOADER_HELLO) {	334	if (IPC_GET_METHOD(call) != LOADER_HELLO) {
311	if (IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP)	335	if (IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP)
312	ipc_answer_0(callid, EINVAL);	336	ipc_answer_0(callid, EINVAL);
313	return 1;	337	return 1;
314	}	338	}
315		339
316	ipc_answer_0(callid, EOK);	340	ipc_answer_0(callid, EOK);
317	phone_hash = call.in_phone_hash;	341	phone_hash = call.in_phone_hash;
318		342
319	/*	343	/*
320	* Up until now async must not be used as it couldn't	344	* Up until now async must not be used as it couldn't
321	* handle incoming requests. (Which means e.g. printf()	345	* handle incoming requests. (Which means e.g. printf()
322	* cannot be used)	346	* cannot be used)
323	*/	347	*/
324	async_new_connection(phone_hash, 0, NULL, loader_connection);	348	async_new_connection(phone_hash, 0, NULL, loader_connection);
325	async_manager();	349	async_manager();
326		350
327	/* not reached */	351	/* not reached */
328	return 0;	352	return 0;
329	}	353	}
330		354
331	/** @}	355	/** @}
332	*/	356	*/
333		357

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/loader/main.c – Rev 3222 → 3447