WebSVN – HelenOS – Diff – /branches/dynload/kernel/generic/src/proc/program.c


/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * 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 genericproc
 * @{
 */
 
/**
 * @file
 * @brief   Running userspace programs.
 */
 
#include <main/uinit.h>
#include <proc/thread.h>
#include <proc/task.h>
#include <proc/uarg.h>
#include <mm/as.h>
#include <mm/slab.h>
#include <arch.h>
#include <adt/list.h>
#include <ipc/ipc.h>
#include <ipc/ipcrsc.h>
#include <security/cap.h>
#include <lib/elf.h>
#include <errno.h>
#include <syscall/copy.h>
#include <proc/program.h>
 
#ifndef LOADED_PROG_STACK_PAGES_NO
#define LOADED_PROG_STACK_PAGES_NO 1
#endif
 
/**
 * Points to the binary image used as the program loader. All non-initial
 * tasks are created from this executable image.
 */
void *program_loader = NULL;
 
/** Create a program using an existing address space.
 *
 * @param as        Address space containing a binary program image.
 * @param entry_addr    Program entry-point address in program address space.
 * @param name      Name to set for the program's task.
 * @param p     Buffer for storing program information.
 */
void program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *p)
{
    as_area_t *a;
    uspace_arg_t *kernel_uarg;
 
    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
    kernel_uarg->uspace_entry = (void *) entry_addr;
    kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
    kernel_uarg->uspace_thread_function = NULL;
    kernel_uarg->uspace_thread_arg = NULL;
    kernel_uarg->uspace_uarg = NULL;
   
    p->task = task_create(as, name);
    ASSERT(p->task);
 
    /*
     * Create the data as_area.
     */
    a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
        LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
        AS_AREA_ATTR_NONE, &anon_backend, NULL);
 
    /*
     * Create the main thread.
     */
    p->main_thread = thread_create(uinit, kernel_uarg, p->task,
        THREAD_FLAG_USPACE, "uinit", false);
    ASSERT(p->main_thread);
}
 
/** Parse an executable image in the kernel memory.
 *
 * If the image belongs to a program loader, it is registered as such,
 * (and *task is set to NULL). Otherwise a task is created from the
 * executable image. The task is returned in *task.
 *
 * @param image_addr    Address of an executable program image.
 * @param name      Name to set for the program's task.
 * @param p     Buffer for storing program info. If image_addr
 *          points to a loader image, p->task will be set to
 *          NULL and EOK will be returned.
 *
 * @return EOK on success or negative error code.
 */
int program_create_from_image(void *image_addr, char *name, program_t *p)
{
    as_t *as;
    unsigned int rc;
 
    as = as_create(0);
    ASSERT(as);
 
    rc = elf_load((elf_header_t *) image_addr, as, 0);
    if (rc != EE_OK) {
        as_destroy(as);
        p->task = NULL;
        p->main_thread = NULL;
        if (rc != EE_LOADER)
            return ENOTSUP;
       
        /* Register image as the program loader */
        ASSERT(program_loader == NULL);
        program_loader = image_addr;
        return EOK;
    }
 
    program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);
 
    return EOK;
}
 
/** Create a task from the program loader image.
 *
 * @param p Buffer for storing program info.
 * @param name  Name to set for the program's task.
 *
 * @return EOK on success or negative error code.
 */
int program_create_loader(program_t *p, char *name)
{
    as_t *as;
    unsigned int rc;
    void *loader;
 
    as = as_create(0);
    ASSERT(as);
 
    loader = program_loader;
    if (!loader) return ENOENT;
 
    rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
    if (rc != EE_OK) {
        as_destroy(as);
        return ENOENT;
    }
 
    program_create(as, ((elf_header_t *) program_loader)->e_entry,
        name, p);
 
    return EOK;
}
 
/** Make program ready.
 *
 * Switch program's main thread to the ready state.
 *
 * @param p Program to make ready.
 */
void program_ready(program_t *p)
{
    thread_ready(p->main_thread);
}
 
/** Syscall for creating a new loader instance from userspace.
 *
 * Creates a new task from the program loader image and sets
 * the task name.
 *
 * @param name          Name to set on the new task (typically the same
 *              as the command used to execute it).
 *
 * @return 0 on success or an error code from @ref errno.h.
 */
unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
{
    program_t p;
    int rc;
    char namebuf[TASK_NAME_BUFLEN];
 
    /* Cap length of name and copy it from userspace. */
 
    if (name_len > TASK_NAME_BUFLEN - 1)
        name_len = TASK_NAME_BUFLEN - 1;
 
    rc = copy_from_uspace(namebuf, uspace_name, name_len);
    if (rc != 0)
        return (unative_t) rc;
 
    namebuf[name_len] = '\0';
 
    /* Spawn the new task. */
 
    rc = program_create_loader(&p, namebuf);
    if (rc != 0)
        return rc;
 
    // FIXME: control the capabilities
    cap_set(p.task, cap_get(TASK));
 
    program_ready(&p);
 
    return EOK;
}
 
/** @}
 */
 

Rev 4343	Rev 4344
1	/*	1	/*
2	* Copyright (c) 2001-2004 Jakub Jermar	2	* Copyright (c) 2001-2004 Jakub Jermar
3	* Copyright (c) 2008 Jiri Svoboda	3	* Copyright (c) 2008 Jiri Svoboda
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	/** @addtogroup genericproc	30	/** @addtogroup genericproc
31	* @{	31	* @{
32	*/	32	*/
33		33
34	/**	34	/**
35	* @file	35	* @file
36	* @brief Running userspace programs.	36	* @brief Running userspace programs.
37	*/	37	*/
38		38
39	#include <main/uinit.h>	39	#include <main/uinit.h>
40	#include <proc/thread.h>	40	#include <proc/thread.h>
41	#include <proc/task.h>	41	#include <proc/task.h>
42	#include <proc/uarg.h>	42	#include <proc/uarg.h>
43	#include <mm/as.h>	43	#include <mm/as.h>
44	#include <mm/slab.h>	44	#include <mm/slab.h>
45	#include <arch.h>	45	#include <arch.h>
46	#include <adt/list.h>	46	#include <adt/list.h>
47	#include <ipc/ipc.h>	47	#include <ipc/ipc.h>
48	#include <ipc/ipcrsc.h>	48	#include <ipc/ipcrsc.h>
49	#include <security/cap.h>	49	#include <security/cap.h>
50	#include <lib/elf.h>	50	#include <lib/elf.h>
51	#include <errno.h>	51	#include <errno.h>
52	#include <syscall/copy.h>	52	#include <syscall/copy.h>
53	#include <proc/program.h>	53	#include <proc/program.h>
54		54
55	#ifndef LOADED_PROG_STACK_PAGES_NO	55	#ifndef LOADED_PROG_STACK_PAGES_NO
56	#define LOADED_PROG_STACK_PAGES_NO 1	56	#define LOADED_PROG_STACK_PAGES_NO 1
57	#endif	57	#endif
58		58
59	/**	59	/**
60	* Points to the binary image used as the program loader. All non-initial	60	* Points to the binary image used as the program loader. All non-initial
61	* tasks are created from this executable image.	61	* tasks are created from this executable image.
62	*/	62	*/
63	void *program_loader = NULL;	63	void *program_loader = NULL;
64		64
65	/** Create a program using an existing address space.	65	/** Create a program using an existing address space.
66	*	66	*
67	* @param as Address space containing a binary program image.	67	* @param as Address space containing a binary program image.
68	* @param entry_addr Program entry-point address in program address space.	68	* @param entry_addr Program entry-point address in program address space.
69	* @param name Name to set for the program's task.	69	* @param name Name to set for the program's task.
70	* @param p Buffer for storing program information.	70	* @param p Buffer for storing program information.
71	*/	71	*/
72	void program_create(as_t as, uintptr_t entry_addr, char name, program_t *p)	72	void program_create(as_t as, uintptr_t entry_addr, char name, program_t *p)
73	{	73	{
74	as_area_t *a;	74	as_area_t *a;
75	uspace_arg_t *kernel_uarg;	75	uspace_arg_t *kernel_uarg;
76		76
77	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);	77	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
78	kernel_uarg->uspace_entry = (void *) entry_addr;	78	kernel_uarg->uspace_entry = (void *) entry_addr;
79	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;	79	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
80	kernel_uarg->uspace_thread_function = NULL;	80	kernel_uarg->uspace_thread_function = NULL;
81	kernel_uarg->uspace_thread_arg = NULL;	81	kernel_uarg->uspace_thread_arg = NULL;
82	kernel_uarg->uspace_uarg = NULL;	82	kernel_uarg->uspace_uarg = NULL;
83		83
84	p->task = task_create(as, name);	84	p->task = task_create(as, name);
85	ASSERT(p->task);	85	ASSERT(p->task);
86		86
87	/*	87	/*
88	* Create the data as_area.	88	* Create the data as_area.
89	*/	89	*/
90	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,	90	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,
91	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,	91	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
92	AS_AREA_ATTR_NONE, &anon_backend, NULL);	92	AS_AREA_ATTR_NONE, &anon_backend, NULL);
93		93
94	/*	94	/*
95	* Create the main thread.	95	* Create the main thread.
96	*/	96	*/
97	p->main_thread = thread_create(uinit, kernel_uarg, p->task,	97	p->main_thread = thread_create(uinit, kernel_uarg, p->task,
98	THREAD_FLAG_USPACE, "uinit", false);	98	THREAD_FLAG_USPACE, "uinit", false);
99	ASSERT(p->main_thread);	99	ASSERT(p->main_thread);
100	}	100	}
101		101
102	/** Parse an executable image in the kernel memory.	102	/** Parse an executable image in the kernel memory.
103	*	103	*
104	* If the image belongs to a program loader, it is registered as such,	104	* If the image belongs to a program loader, it is registered as such,
105	* (and *task is set to NULL). Otherwise a task is created from the	105	* (and *task is set to NULL). Otherwise a task is created from the
106	* executable image. The task is returned in *task.	106	* executable image. The task is returned in *task.
107	*	107	*
108	* @param image_addr Address of an executable program image.	108	* @param image_addr Address of an executable program image.
109	* @param name Name to set for the program's task.	109	* @param name Name to set for the program's task.
110	* @param p Buffer for storing program info. If image_addr	110	* @param p Buffer for storing program info. If image_addr
111	* points to a loader image, p->task will be set to	111	* points to a loader image, p->task will be set to
112	* NULL and EOK will be returned.	112	* NULL and EOK will be returned.
113	*	113	*
114	* @return EOK on success or negative error code.	114	* @return EOK on success or negative error code.
115	*/	115	*/
116	int program_create_from_image(void image_addr, char name, program_t *p)	116	int program_create_from_image(void image_addr, char name, program_t *p)
117	{	117	{
118	as_t *as;	118	as_t *as;
119	unsigned int rc;	119	unsigned int rc;
120		120
121	as = as_create(0);	121	as = as_create(0);
122	ASSERT(as);	122	ASSERT(as);
123		123
124	rc = elf_load((elf_header_t *) image_addr, as, 0);	124	rc = elf_load((elf_header_t *) image_addr, as, 0);
125	if (rc != EE_OK) {	125	if (rc != EE_OK) {
126	as_destroy(as);	126	as_destroy(as);
127	p->task = NULL;	127	p->task = NULL;
128	p->main_thread = NULL;	128	p->main_thread = NULL;
129	if (rc != EE_LOADER)	129	if (rc != EE_LOADER)
130	return ENOTSUP;	130	return ENOTSUP;
131		131
132	/* Register image as the program loader */	132	/* Register image as the program loader */
133	ASSERT(program_loader == NULL);	133	ASSERT(program_loader == NULL);
134	program_loader = image_addr;	134	program_loader = image_addr;
135	return EOK;	135	return EOK;
136	}	136	}
137		137
138	program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);	138	program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);
139		139
140	return EOK;	140	return EOK;
141	}	141	}
142		142
143	/** Create a task from the program loader image.	143	/** Create a task from the program loader image.
144	*	144	*
145	* @param p Buffer for storing program info.	145	* @param p Buffer for storing program info.
146	* @param name Name to set for the program's task.	146	* @param name Name to set for the program's task.
147	*	147	*
148	* @return EOK on success or negative error code.	148	* @return EOK on success or negative error code.
149	*/	149	*/
150	int program_create_loader(program_t p, char name)	150	int program_create_loader(program_t p, char name)
151	{	151	{
152	as_t *as;	152	as_t *as;
153	unsigned int rc;	153	unsigned int rc;
154	void *loader;	154	void *loader;
155		155
156	as = as_create(0);	156	as = as_create(0);
157	ASSERT(as);	157	ASSERT(as);
158		158
159	loader = program_loader;	159	loader = program_loader;
160	if (!loader) return ENOENT;	160	if (!loader) return ENOENT;
161		161
162	rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);	162	rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
163	if (rc != EE_OK) {	163	if (rc != EE_OK) {
164	as_destroy(as);	164	as_destroy(as);
165	return ENOENT;	165	return ENOENT;
166	}	166	}
167		167
168	program_create(as, ((elf_header_t *) program_loader)->e_entry,	168	program_create(as, ((elf_header_t *) program_loader)->e_entry,
169	name, p);	169	name, p);
170		170
171	return EOK;	171	return EOK;
172	}	172	}
173		173
174	/** Make program ready.	174	/** Make program ready.
175	*	175	*
176	* Switch program's main thread to the ready state.	176	* Switch program's main thread to the ready state.
177	*	177	*
178	* @param p Program to make ready.	178	* @param p Program to make ready.
179	*/	179	*/
180	void program_ready(program_t *p)	180	void program_ready(program_t *p)
181	{	181	{
182	thread_ready(p->main_thread);	182	thread_ready(p->main_thread);
183	}	183	}
184		184
185	/** Syscall for creating a new loader instance from userspace.	185	/** Syscall for creating a new loader instance from userspace.
186	*	186	*
187	* Creates a new task from the program loader image and sets	187	* Creates a new task from the program loader image and sets
188	* the task name.	188	* the task name.
189	*	189	*
190	* @param name Name to set on the new task (typically the same	190	* @param name Name to set on the new task (typically the same
191	* as the command used to execute it).	191	* as the command used to execute it).
192	*	192	*
193	* @return 0 on success or an error code from @ref errno.h.	193	* @return 0 on success or an error code from @ref errno.h.
194	*/	194	*/
195	unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)	195	unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
196	{	196	{
197	program_t p;	197	program_t p;
198	int rc;	198	int rc;
199	char namebuf[TASK_NAME_BUFLEN];	199	char namebuf[TASK_NAME_BUFLEN];
200		200
201	/* Cap length of name and copy it from userspace. */	201	/* Cap length of name and copy it from userspace. */
202		202
203	if (name_len > THREAD_NAME_BUFLEN - 1)	203	if (name_len > TASK_NAME_BUFLEN - 1)
204	name_len = THREAD_NAME_BUFLEN - 1;	204	name_len = TASK_NAME_BUFLEN - 1;
205		205
206	rc = copy_from_uspace(namebuf, uspace_name, name_len);	206	rc = copy_from_uspace(namebuf, uspace_name, name_len);
207	if (rc != 0)	207	if (rc != 0)
208	return (unative_t) rc;	208	return (unative_t) rc;
209		209
210	namebuf[name_len] = '\0';	210	namebuf[name_len] = '\0';
211		211
212	/* Spawn the new task. */	212	/* Spawn the new task. */
213		213
214	rc = program_create_loader(&p, namebuf);	214	rc = program_create_loader(&p, namebuf);
215	if (rc != 0)	215	if (rc != 0)
216	return rc;	216	return rc;
217		217
218	// FIXME: control the capabilities	218	// FIXME: control the capabilities
219	cap_set(p.task, cap_get(TASK));	219	cap_set(p.task, cap_get(TASK));
220		220
221	program_ready(&p);	221	program_ready(&p);
222		222
223	return EOK;	223	return EOK;
224	}	224	}
225		225
226	/** @}	226	/** @}
227	*/	227	*/
228		228

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/generic/src/proc/program.c – Rev 4343 → 4344