Subversion Repositories HelenOS

Rev

Rev 3475 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3469 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 libc
30
 * @{
31
 */
32
/** @file
33
 */
34
 
35
#include <ipc/ipc.h>
36
#include <ipc/loader.h>
37
#include <libc.h>
3475 svoboda 38
#include <task.h>
3469 svoboda 39
#include <string.h>
40
#include <stdlib.h>
41
#include <async.h>
42
#include <errno.h>
43
#include <vfs/vfs.h>
44
#include <loader/loader.h>
45
 
46
/** Connect to a new program loader.
47
 *
48
 * Spawns a new program loader task and returns the connection structure.
49
 * @return  Pointer to the loader connection structure (should be
50
 *      de-allocated using free() after use).
51
 */
52
loader_t *loader_spawn(void)
53
{
54
    int phone_id, rc;
55
    loader_t *ldr;
56
 
57
    /*
58
     * Ask kernel to spawn a new loader task.
59
     */
60
    rc = __SYSCALL1(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id);
61
    if (rc != 0)
62
        return NULL;
63
 
64
    /*
65
     * Say hello so that the loader knows the incoming connection's
66
     * phone hash.
67
     */
68
    rc = async_req_0_0(phone_id, LOADER_HELLO);
69
    if (rc != EOK)
70
        return NULL;
71
 
72
    ldr = malloc(sizeof(loader_t));
73
    if (ldr == NULL)
74
        return NULL;
75
 
76
    ldr->phone_id = phone_id;
77
    return ldr;
78
}
79
 
80
/** Get ID of the new task.
81
 *
82
 * Retrieves the ID of the new task from the loader.
83
 *
84
 * @param ldr       Loader connection structure.
85
 * @param task_id   Points to a variable where the ID should be stored.
86
 * @return      Zero on success or negative error code.
87
 */
88
int loader_get_task_id(loader_t *ldr, task_id_t *task_id)
89
{
90
    ipc_call_t answer;
91
    aid_t req;
92
    int rc;
93
    ipcarg_t retval;
94
 
95
    /* Get task ID. */
96
    req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
3475 svoboda 97
    rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
3469 svoboda 98
    if (rc != EOK) {
99
        async_wait_for(req, NULL);
100
        return rc;
101
    }
102
 
103
    async_wait_for(req, &retval);
104
    return (int)retval;
105
}
106
 
107
/** Set pathname of the program to load.
108
 *
109
 * Sets the name of the program file to load. The name can be relative
110
 * to the current working directory (it will be absolutized before
111
 * sending to the loader).
112
 *
113
 * @param ldr       Loader connection structure.
114
 * @param path      Pathname of the program file.
115
 * @return      Zero on success or negative error code.
116
 */
117
int loader_set_pathname(loader_t *ldr, const char *path)
118
{
119
    ipc_call_t answer;
120
    aid_t req;
121
    int rc;
122
    ipcarg_t retval;
123
 
124
    char *pa;
125
    size_t pa_len;
126
 
127
    pa = absolutize(path, &pa_len);
128
    if (!pa)
129
        return 0;
130
 
131
    /* Send program pathname */
132
    req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
133
    rc = ipc_data_write_start(ldr->phone_id, (void *)pa, pa_len);
134
    if (rc != EOK) {
135
        async_wait_for(req, NULL);
136
        return rc;
137
    }
138
 
139
    free(pa);
140
 
141
    async_wait_for(req, &retval);
142
    return (int)retval;
143
}
144
 
145
 
146
/** Set command-line arguments for the program.
147
 *
148
 * Sets the vector of command-line arguments to be passed to the loaded
149
 * program. By convention, the very first argument is typically the same as
150
 * the command used to execute the program.
151
 *
152
 * @param ldr       Loader connection structure.
153
 * @param argv      NULL-terminated array of pointers to arguments.
154
 * @return      Zero on success or negative error code.
155
 */
156
int loader_set_args(loader_t *ldr, char *const argv[])
157
{
158
    aid_t req;
159
    ipc_call_t answer;
160
    ipcarg_t rc;
161
 
162
    char *const *ap;
163
    char *dp;
164
    char *arg_buf;
165
    size_t buffer_size;
166
 
167
    /*
168
     * Serialize the arguments into a single array. First
169
     * compute size of the buffer needed.
170
     */
171
    ap = argv;
172
    buffer_size = 0;
173
    while (*ap != NULL) {
174
        buffer_size += strlen(*ap) + 1;
175
        ++ap;
176
    }
177
 
178
    arg_buf = malloc(buffer_size);
179
    if (arg_buf == NULL) return ENOMEM;
180
 
181
    /* Now fill the buffer with null-terminated argument strings */
182
    ap = argv;
183
    dp = arg_buf;
184
    while (*ap != NULL) {
185
        strcpy(dp, *ap);
186
        dp += strlen(*ap) + 1;
187
 
188
        ++ap;
189
    }
190
 
191
    /* Send serialized arguments to the loader */
192
 
193
    req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
194
    rc = ipc_data_write_start(ldr->phone_id, (void *)arg_buf, buffer_size);
195
    if (rc != EOK) {
196
        async_wait_for(req, NULL);
197
        return rc;
198
    }
199
 
200
    async_wait_for(req, &rc);
201
    if (rc != EOK) return rc;
202
 
203
    /* Free temporary buffer */
204
    free(arg_buf);
205
 
206
    return EOK;
207
}
208
 
3470 svoboda 209
/** Instruct loader to load the program.
210
 *
211
 * If this function succeeds, the program has been successfully loaded
212
 * and is ready to be executed.
213
 *
214
 * @param ldr       Loader connection structure.
215
 * @return      Zero on success or negative error code.
216
 */
217
int loader_load_program(loader_t *ldr)
218
{
219
    int rc;
220
 
221
    rc = async_req_0_0(ldr->phone_id, LOADER_LOAD);
222
    if (rc != EOK)
223
        return rc;
224
 
225
    return EOK;
226
}
227
 
3469 svoboda 228
/** Instruct loader to execute the program.
229
 *
3470 svoboda 230
 * Note that this function blocks until the loader actually replies
231
 * so you cannot expect this function to return if you are debugging
232
 * the task and its thread is stopped.
233
 *
3469 svoboda 234
 * After using this function, no further operations must be performed
235
 * on the loader structure. It should be de-allocated using free().
236
 *
237
 * @param ldr       Loader connection structure.
238
 * @return      Zero on success or negative error code.
239
 */
3470 svoboda 240
int loader_run(loader_t *ldr)
3469 svoboda 241
{
242
    int rc;
243
 
244
    rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
245
    if (rc != EOK)
246
        return rc;
247
 
248
    return EOK;
249
}
250
 
251
/** Cancel the loader session.
252
 *
253
 * Tells the loader not to load any program and terminate.
254
 * After using this function, no further operations must be performed
255
 * on the loader structure. It should be de-allocated using free().
256
 *
257
 * @param ldr       Loader connection structure.
258
 * @return      Zero on success or negative error code.
259
 */
260
void loader_abort(loader_t *ldr)
261
{
262
    ipc_hangup(ldr->phone_id);
263
    ldr->phone_id = 0;
264
}
265
 
266
/** @}
267
 */