source: mainline/uspace/lib/c/generic/loader.c@ cc74cb5

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since cc74cb5 was 09ab0a9a, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix vertical spacing with new Ccheck revision.

  • Property mode set to 100644
File size: 8.7 KB
Line 
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 libc
30 * @{
31 */
32/** @file
33 */
34
35#include <ipc/loader.h>
36#include <ipc/services.h>
37#include <ns.h>
38#include <libc.h>
39#include <task.h>
40#include <str.h>
41#include <stdlib.h>
42#include <async.h>
43#include <errno.h>
44#include <vfs/vfs.h>
45#include <loader/loader.h>
46#include "private/loader.h"
47
48/** Connect to a new program loader.
49 *
50 * Spawns a new program loader task and returns the connection structure.
51 *
52 * @param name Symbolic name to set on the newly created task.
53 *
54 * @return Error code.
55 */
56errno_t loader_spawn(const char *name)
57{
58 return (errno_t) __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
59 (sysarg_t) name, str_size(name));
60}
61
62loader_t *loader_connect(void)
63{
64 loader_t *ldr = malloc(sizeof(loader_t));
65 if (ldr == NULL)
66 return NULL;
67
68 async_sess_t *sess =
69 service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0);
70 if (sess == NULL) {
71 free(ldr);
72 return NULL;
73 }
74
75 ldr->sess = sess;
76 return ldr;
77}
78
79/** Get ID of the new task.
80 *
81 * Retrieves the ID of the new task from the loader.
82 *
83 * @param ldr Loader connection structure.
84 * @param task_id Points to a variable where the ID should be stored.
85 *
86 * @return Zero on success or an error code.
87 *
88 */
89errno_t loader_get_task_id(loader_t *ldr, task_id_t *task_id)
90{
91 /* Get task ID. */
92 async_exch_t *exch = async_exchange_begin(ldr->sess);
93
94 ipc_call_t answer;
95 aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer);
96 errno_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
97
98 async_exchange_end(exch);
99
100 if (rc != EOK) {
101 async_forget(req);
102 return (errno_t) rc;
103 }
104
105 async_wait_for(req, &rc);
106 return (errno_t) rc;
107}
108
109/** Set current working directory for the loaded task.
110 *
111 * Sets the current working directory for the loaded task.
112 *
113 * @param ldr Loader connection structure.
114 *
115 * @return Zero on success or an error code.
116 *
117 */
118errno_t loader_set_cwd(loader_t *ldr)
119{
120 char *cwd = (char *) malloc(MAX_PATH_LEN + 1);
121 if (!cwd)
122 return ENOMEM;
123
124 if (vfs_cwd_get(cwd, MAX_PATH_LEN + 1) != EOK)
125 str_cpy(cwd, MAX_PATH_LEN + 1, "/");
126
127 size_t len = str_length(cwd);
128
129 async_exch_t *exch = async_exchange_begin(ldr->sess);
130
131 ipc_call_t answer;
132 aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer);
133 errno_t rc = async_data_write_start(exch, cwd, len);
134
135 async_exchange_end(exch);
136 free(cwd);
137
138 if (rc != EOK) {
139 async_forget(req);
140 return (errno_t) rc;
141 }
142
143 async_wait_for(req, &rc);
144 return (errno_t) rc;
145}
146
147/** Set the program to load.
148 *
149 * @param ldr Loader connection structure.
150 * @param name Name to set for the spawned program.
151 * @param file Program file.
152 *
153 * @return Zero on success or an error code.
154 *
155 */
156errno_t loader_set_program(loader_t *ldr, const char *name, int file)
157{
158 async_exch_t *exch = async_exchange_begin(ldr->sess);
159
160 ipc_call_t answer;
161 aid_t req = async_send_0(exch, LOADER_SET_PROGRAM, &answer);
162
163 errno_t rc = async_data_write_start(exch, name, str_size(name) + 1);
164 if (rc == EOK) {
165 async_exch_t *vfs_exch = vfs_exchange_begin();
166 rc = vfs_pass_handle(vfs_exch, file, exch);
167 vfs_exchange_end(vfs_exch);
168 }
169
170 async_exchange_end(exch);
171
172 if (rc != EOK) {
173 async_forget(req);
174 return (errno_t) rc;
175 }
176
177 async_wait_for(req, &rc);
178 return (errno_t) rc;
179}
180
181/** Set the program to load by path.
182 *
183 * @param ldr Loader connection structure.
184 * @param path Program path.
185 *
186 * @return Zero on success or an error code.
187 *
188 */
189errno_t loader_set_program_path(loader_t *ldr, const char *path)
190{
191 const char *name = str_rchr(path, '/');
192 if (name == NULL) {
193 name = path;
194 } else {
195 name++;
196 }
197
198 int fd;
199 errno_t rc = vfs_lookup(path, 0, &fd);
200 if (rc != EOK) {
201 return rc;
202 }
203
204 rc = loader_set_program(ldr, name, fd);
205 vfs_put(fd);
206 return rc;
207}
208
209/** Set command-line arguments for the program.
210 *
211 * Sets the vector of command-line arguments to be passed to the loaded
212 * program. By convention, the very first argument is typically the same as
213 * the command used to execute the program.
214 *
215 * @param ldr Loader connection structure.
216 * @param argv NULL-terminated array of pointers to arguments.
217 *
218 * @return Zero on success or an error code.
219 *
220 */
221errno_t loader_set_args(loader_t *ldr, const char *const argv[])
222{
223 /*
224 * Serialize the arguments into a single array. First
225 * compute size of the buffer needed.
226 */
227 const char *const *ap = argv;
228 size_t buffer_size = 0;
229 while (*ap != NULL) {
230 buffer_size += str_size(*ap) + 1;
231 ap++;
232 }
233
234 char *arg_buf = malloc(buffer_size);
235 if (arg_buf == NULL)
236 return ENOMEM;
237
238 /* Now fill the buffer with null-terminated argument strings */
239 ap = argv;
240 char *dp = arg_buf;
241
242 while (*ap != NULL) {
243 str_cpy(dp, buffer_size - (dp - arg_buf), *ap);
244 dp += str_size(*ap) + 1;
245 ap++;
246 }
247
248 /* Send serialized arguments to the loader */
249 async_exch_t *exch = async_exchange_begin(ldr->sess);
250
251 ipc_call_t answer;
252 aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer);
253 errno_t rc = async_data_write_start(exch, (void *) arg_buf,
254 buffer_size);
255
256 async_exchange_end(exch);
257 free(arg_buf);
258
259 if (rc != EOK) {
260 async_forget(req);
261 return (errno_t) rc;
262 }
263
264 async_wait_for(req, &rc);
265 return (errno_t) rc;
266}
267
268/** Add a file to the task's inbox.
269 *
270 * @param ldr Loader connection structure.
271 * @param name Identification of the file.
272 * @param file The file's descriptor.
273 *
274 * @return Zero on success or an error code.
275 *
276 */
277errno_t loader_add_inbox(loader_t *ldr, const char *name, int file)
278{
279 async_exch_t *exch = async_exchange_begin(ldr->sess);
280 async_exch_t *vfs_exch = vfs_exchange_begin();
281
282 aid_t req = async_send_0(exch, LOADER_ADD_INBOX, NULL);
283
284 errno_t rc = async_data_write_start(exch, name, str_size(name) + 1);
285 if (rc == EOK) {
286 rc = vfs_pass_handle(vfs_exch, file, exch);
287 }
288
289 async_exchange_end(vfs_exch);
290 async_exchange_end(exch);
291
292 if (rc == EOK) {
293 async_wait_for(req, &rc);
294 } else {
295 async_forget(req);
296 }
297
298 return (errno_t) rc;
299}
300
301/** Instruct loader to load the program.
302 *
303 * If this function succeeds, the program has been successfully loaded
304 * and is ready to be executed.
305 *
306 * @param ldr Loader connection structure.
307 *
308 * @return Zero on success or an error code.
309 *
310 */
311errno_t loader_load_program(loader_t *ldr)
312{
313 async_exch_t *exch = async_exchange_begin(ldr->sess);
314 errno_t rc = async_req_0_0(exch, LOADER_LOAD);
315 async_exchange_end(exch);
316
317 return rc;
318}
319
320/** Instruct loader to execute the program.
321 *
322 * Note that this function blocks until the loader actually replies
323 * so you cannot expect this function to return if you are debugging
324 * the task and its thread is stopped.
325 *
326 * After using this function, no further operations can be performed
327 * on the loader structure and it is deallocated.
328 *
329 * @param ldr Loader connection structure.
330 *
331 * @return Zero on success or an error code.
332 *
333 */
334errno_t loader_run(loader_t *ldr)
335{
336 async_exch_t *exch = async_exchange_begin(ldr->sess);
337 errno_t rc = async_req_0_0(exch, LOADER_RUN);
338 async_exchange_end(exch);
339
340 if (rc != EOK)
341 return rc;
342
343 async_hangup(ldr->sess);
344 free(ldr);
345
346 return EOK;
347}
348
349/** Cancel the loader session.
350 *
351 * Tell the loader not to load any program and terminate.
352 * After using this function, no further operations can be performed
353 * on the loader structure and it is deallocated.
354 *
355 * @param ldr Loader connection structure.
356 *
357 * @return Zero on success or an error code.
358 *
359 */
360void loader_abort(loader_t *ldr)
361{
362 async_hangup(ldr->sess);
363 free(ldr);
364}
365
366/** @}
367 */
Note: See TracBrowser for help on using the repository browser.