WebSVN – HelenOS – Diff – /branches/dd/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 <print.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;
        printf("Registered program loader at 0x%" PRIp "\n",
            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) {
        printf("Cannot spawn loader as none was registered\n");
        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 4055	Rev 4296
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 <print.h>	52	#include <print.h>
53	#include <syscall/copy.h>	53	#include <syscall/copy.h>
54	#include <proc/program.h>	54	#include <proc/program.h>
55		55
56	#ifndef LOADED_PROG_STACK_PAGES_NO	56	#ifndef LOADED_PROG_STACK_PAGES_NO
57	#define LOADED_PROG_STACK_PAGES_NO 1	57	#define LOADED_PROG_STACK_PAGES_NO 1
58	#endif	58	#endif
59		59
60	/**	60	/**
61	* Points to the binary image used as the program loader. All non-initial	61	* Points to the binary image used as the program loader. All non-initial
62	* tasks are created from this executable image.	62	* tasks are created from this executable image.
63	*/	63	*/
64	void *program_loader = NULL;	64	void *program_loader = NULL;
65		65
66	/** Create a program using an existing address space.	66	/** Create a program using an existing address space.
67	*	67	*
68	* @param as Address space containing a binary program image.	68	* @param as Address space containing a binary program image.
69	* @param entry_addr Program entry-point address in program address space.	69	* @param entry_addr Program entry-point address in program address space.
70	* @param name Name to set for the program's task.	70	* @param name Name to set for the program's task.
71	* @param p Buffer for storing program information.	71	* @param p Buffer for storing program information.
72	*/	72	*/
73	void program_create(as_t as, uintptr_t entry_addr, char name, program_t *p)	73	void program_create(as_t as, uintptr_t entry_addr, char name, program_t *p)
74	{	74	{
75	as_area_t *a;	75	as_area_t *a;
76	uspace_arg_t *kernel_uarg;	76	uspace_arg_t *kernel_uarg;
77		77
78	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);	78	kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
79	kernel_uarg->uspace_entry = (void *) entry_addr;	79	kernel_uarg->uspace_entry = (void *) entry_addr;
80	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;	80	kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
81	kernel_uarg->uspace_thread_function = NULL;	81	kernel_uarg->uspace_thread_function = NULL;
82	kernel_uarg->uspace_thread_arg = NULL;	82	kernel_uarg->uspace_thread_arg = NULL;
83	kernel_uarg->uspace_uarg = NULL;	83	kernel_uarg->uspace_uarg = NULL;
84		84
85	p->task = task_create(as, name);	85	p->task = task_create(as, name);
86	ASSERT(p->task);	86	ASSERT(p->task);
87		87
88	/*	88	/*
89	* Create the data as_area.	89	* Create the data as_area.
90	*/	90	*/
91	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,	91	a = as_area_create(as, AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE,
92	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,	92	LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
93	AS_AREA_ATTR_NONE, &anon_backend, NULL);	93	AS_AREA_ATTR_NONE, &anon_backend, NULL);
94		94
95	/*	95	/*
96	* Create the main thread.	96	* Create the main thread.
97	*/	97	*/
98	p->main_thread = thread_create(uinit, kernel_uarg, p->task,	98	p->main_thread = thread_create(uinit, kernel_uarg, p->task,
99	THREAD_FLAG_USPACE, "uinit", false);	99	THREAD_FLAG_USPACE, "uinit", false);
100	ASSERT(p->main_thread);	100	ASSERT(p->main_thread);
101	}	101	}
102		102
103	/** Parse an executable image in the kernel memory.	103	/** Parse an executable image in the kernel memory.
104	*	104	*
105	* If the image belongs to a program loader, it is registered as such,	105	* If the image belongs to a program loader, it is registered as such,
106	* (and *task is set to NULL). Otherwise a task is created from the	106	* (and *task is set to NULL). Otherwise a task is created from the
107	* executable image. The task is returned in *task.	107	* executable image. The task is returned in *task.
108	*	108	*
109	* @param image_addr Address of an executable program image.	109	* @param image_addr Address of an executable program image.
110	* @param name Name to set for the program's task.	110	* @param name Name to set for the program's task.
111	* @param p Buffer for storing program info. If image_addr	111	* @param p Buffer for storing program info. If image_addr
112	* points to a loader image, p->task will be set to	112	* points to a loader image, p->task will be set to
113	* NULL and EOK will be returned.	113	* NULL and EOK will be returned.
114	*	114	*
115	* @return EOK on success or negative error code.	115	* @return EOK on success or negative error code.
116	*/	116	*/
117	int program_create_from_image(void image_addr, char name, program_t *p)	117	int program_create_from_image(void image_addr, char name, program_t *p)
118	{	118	{
119	as_t *as;	119	as_t *as;
120	unsigned int rc;	120	unsigned int rc;
121		121
122	as = as_create(0);	122	as = as_create(0);
123	ASSERT(as);	123	ASSERT(as);
124		124
125	rc = elf_load((elf_header_t *) image_addr, as, 0);	125	rc = elf_load((elf_header_t *) image_addr, as, 0);
126	if (rc != EE_OK) {	126	if (rc != EE_OK) {
127	as_destroy(as);	127	as_destroy(as);
128	p->task = NULL;	128	p->task = NULL;
129	p->main_thread = NULL;	129	p->main_thread = NULL;
130	if (rc != EE_LOADER)	130	if (rc != EE_LOADER)
131	return ENOTSUP;	131	return ENOTSUP;
132		132
133	/* Register image as the program loader */	133	/* Register image as the program loader */
134	ASSERT(program_loader == NULL);	134	ASSERT(program_loader == NULL);
135	program_loader = image_addr;	135	program_loader = image_addr;
136	printf("Registered program loader at 0x%" PRIp "\n",	136	printf("Registered program loader at 0x%" PRIp "\n",
137	image_addr);	137	image_addr);
138	return EOK;	138	return EOK;
139	}	139	}
140		140
141	program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);	141	program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);
142		142
143	return EOK;	143	return EOK;
144	}	144	}
145		145
146	/** Create a task from the program loader image.	146	/** Create a task from the program loader image.
147	*	147	*
148	* @param p Buffer for storing program info.	148	* @param p Buffer for storing program info.
149	* @param name Name to set for the program's task.	149	* @param name Name to set for the program's task.
150	*	150	*
151	* @return EOK on success or negative error code.	151	* @return EOK on success or negative error code.
152	*/	152	*/
153	int program_create_loader(program_t p, char name)	153	int program_create_loader(program_t p, char name)
154	{	154	{
155	as_t *as;	155	as_t *as;
156	unsigned int rc;	156	unsigned int rc;
157	void *loader;	157	void *loader;
158		158
159	as = as_create(0);	159	as = as_create(0);
160	ASSERT(as);	160	ASSERT(as);
161		161
162	loader = program_loader;	162	loader = program_loader;
163	if (!loader) {	163	if (!loader) {
164	printf("Cannot spawn loader as none was registered\n");	164	printf("Cannot spawn loader as none was registered\n");
165	return ENOENT;	165	return ENOENT;
166	}	166	}
167		167
168	rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);	168	rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
169	if (rc != EE_OK) {	169	if (rc != EE_OK) {
170	as_destroy(as);	170	as_destroy(as);
171	return ENOENT;	171	return ENOENT;
172	}	172	}
173		173
174	program_create(as, ((elf_header_t *) program_loader)->e_entry,	174	program_create(as, ((elf_header_t *) program_loader)->e_entry,
175	name, p);	175	name, p);
176		176
177	return EOK;	177	return EOK;
178	}	178	}
179		179
180	/** Make program ready.	180	/** Make program ready.
181	*	181	*
182	* Switch program's main thread to the ready state.	182	* Switch program's main thread to the ready state.
183	*	183	*
184	* @param p Program to make ready.	184	* @param p Program to make ready.
185	*/	185	*/
186	void program_ready(program_t *p)	186	void program_ready(program_t *p)
187	{	187	{
188	thread_ready(p->main_thread);	188	thread_ready(p->main_thread);
189	}	189	}
190		190
191	/** Syscall for creating a new loader instance from userspace.	191	/** Syscall for creating a new loader instance from userspace.
192	*	192	*
193	* Creates a new task from the program loader image and sets	193	* Creates a new task from the program loader image and sets
194	* the task name.	194	* the task name.
195	*	195	*
196	* @param name Name to set on the new task (typically the same	196	* @param name Name to set on the new task (typically the same
197	* as the command used to execute it).	197	* as the command used to execute it).
198	*	198	*
199	* @return 0 on success or an error code from @ref errno.h.	199	* @return 0 on success or an error code from @ref errno.h.
200	*/	200	*/
201	unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)	201	unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
202	{	202	{
203	program_t p;	203	program_t p;
204	int rc;	204	int rc;
205	char namebuf[TASK_NAME_BUFLEN];	205	char namebuf[TASK_NAME_BUFLEN];
206		206
207	/* Cap length of name and copy it from userspace. */	207	/* Cap length of name and copy it from userspace. */
208		208
209	if (name_len > TASK_NAME_BUFLEN - 1)	209	if (name_len > TASK_NAME_BUFLEN - 1)
210	name_len = TASK_NAME_BUFLEN - 1;	210	name_len = TASK_NAME_BUFLEN - 1;
211		211
212	rc = copy_from_uspace(namebuf, uspace_name, name_len);	212	rc = copy_from_uspace(namebuf, uspace_name, name_len);
213	if (rc != 0)	213	if (rc != 0)
214	return (unative_t) rc;	214	return (unative_t) rc;
215		215
216	namebuf[name_len] = '\0';	216	namebuf[name_len] = 0;
217		217
218	/* Spawn the new task. */	218	/* Spawn the new task. */
219		219
220	rc = program_create_loader(&p, namebuf);	220	rc = program_create_loader(&p, namebuf);
221	if (rc != 0)	221	if (rc != 0)
222	return rc;	222	return rc;
223		223
224	// FIXME: control the capabilities	224	// FIXME: control the capabilities
225	cap_set(p.task, cap_get(TASK));	225	cap_set(p.task, cap_get(TASK));
226		226
227	program_ready(&p);	227	program_ready(&p);
228		228
229	return EOK;	229	return EOK;
230	}	230	}
231		231
232	/** @}	232	/** @}
233	*/	233	*/
234		234

Subversion Repositories HelenOS

(root)/branches/dd/kernel/generic/src/proc/program.c – Rev 4055 → 4296