Subversion Repositories HelenOS

Rev

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