Subversion Repositories HelenOS-historic

Rev

Rev 1024 | Rev 1032 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1024 Rev 1027
Line 29... Line 29...
29 
#include <syscall/syscall.h>
 29 
#include <syscall/syscall.h>
30 
#include <proc/thread.h>
 30 
#include <proc/thread.h>
31 
#include <mm/as.h>
 31 
#include <mm/as.h>
32 
#include <print.h>
 32 
#include <print.h>
33 
#include <putchar.h>
 33 
#include <putchar.h>
34 
#include <ipc/ipc.h>
 - 
 
35 
#include <errno.h>
 34 
#include <errno.h>
36 
#include <proc/task.h>
 35 
#include <proc/task.h>
37 
#include <arch.h>
 36 
#include <arch.h>
38 
#include <debug.h>
 37 
#include <debug.h>
- 
 
 38 
#include <ipc/sysipc.h>
39 
 
 39 
 
40 
static __native sys_ctl(void) {
 40 
static __native sys_ctl(void) {
41 
    printf("Thread finished\n");
 41 
    printf("Thread finished\n");
42 
    thread_exit();
 42 
    thread_exit();
43 
    /* Unreachable */
 43 
    /* Unreachable */
Line 54... Line 54...
54 
        putchar(((char *) buf)[i]);
 54 
        putchar(((char *) buf)[i]);
55 
   
 55 
   
56 
    return count;
 56 
    return count;
57 
}
 57 
}
58 
 
 58 
 
59 
static phone_t * get_phone(__native phoneid)
 - 
 
60 
{
 - 
 
61 
    phone_t *phone;
 - 
 
62 
 
 - 
 
63 
    if (phoneid >= IPC_MAX_PHONES)
 - 
 
64 
        return NULL;
 - 
 
65 
 
 - 
 
66 
    phone = &TASK->phones[phoneid];
 - 
 
67 
    if (!phone->callee)
 - 
 
68 
        return NULL;
 - 
 
69 
    return phone;
 - 
 
70 
}
 - 
 
71 
 
 - 
 
72 
/** Send a call over IPC, wait for reply, return to user
 - 
 
73 
 *
 - 
 
74 
 * @return Call identification, returns -1 on fatal error,
 - 
 
75 
           -2 on 'Too many async request, handle answers first
 - 
 
76 
 */
 - 
 
77 
static __native sys_ipc_call_sync_fast(__native phoneid, __native method,
 - 
 
78 
                       __native arg1, __native *data)
 - 
 
79 
{
 - 
 
80 
    call_t call;
 - 
 
81 
    phone_t *phone;
 - 
 
82 
    /* Special answerbox for synchronous messages */
 - 
 
83 
 
 - 
 
84 
    phone = get_phone(phoneid);
 - 
 
85 
    if (!phone)
 - 
 
86 
        return IPC_CALLRET_FATAL;
 - 
 
87 
 
 - 
 
88 
    ipc_call_init(&call);
 - 
 
89 
    IPC_SET_METHOD(call.data, method);
 - 
 
90 
    IPC_SET_ARG1(call.data, arg1);
 - 
 
91 
   
 - 
 
92 
    ipc_call_sync(phone, &call);
 - 
 
93 
 
 - 
 
94 
    copy_to_uspace(data, &call.data, sizeof(call.data));
 - 
 
95 
 
 - 
 
96 
    return 0;
 - 
 
97 
}
 - 
 
98 
 
 - 
 
99 
/** Synchronous IPC call allowing to send whole message */
 - 
 
100 
static __native sys_ipc_call_sync(__native phoneid, __native *question,
 - 
 
101 
                  __native *reply)
 - 
 
102 
{
 - 
 
103 
    call_t call;
 - 
 
104 
    phone_t *phone;
 - 
 
105 
    /* Special answerbox for synchronous messages */
 - 
 
106 
 
 - 
 
107 
    phone = get_phone(phoneid);
 - 
 
108 
    if (!phone)
 - 
 
109 
        return IPC_CALLRET_FATAL;
 - 
 
110 
 
 - 
 
111 
    ipc_call_init(&call);
 - 
 
112 
    copy_from_uspace(&call.data, question, sizeof(call.data));
 - 
 
113 
   
 - 
 
114 
    ipc_call_sync(phone, &call);
 - 
 
115 
 
 - 
 
116 
    copy_to_uspace(reply, &call.data, sizeof(call.data));
 - 
 
117 
 
 - 
 
118 
    return 0;
 - 
 
119 
}
 - 
 
120 
 
 - 
 
121 
/** Check that the task did not exceed allowed limit
 - 
 
122 
 *
 - 
 
123 
 * @return 0 - Limit OK,   -1 - limit exceeded
 - 
 
124 
 */
 - 
 
125 
static int check_call_limit(void)
 - 
 
126 
{
 - 
 
127 
    if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
 - 
 
128 
        atomic_dec(&TASK->active_calls);
 - 
 
129 
        return -1;
 - 
 
130 
    }
 - 
 
131 
    return 0;
 - 
 
132 
}
 - 
 
133 
 
 - 
 
134 
/** Send an asynchronous call over ipc
 - 
 
135 
 *
 - 
 
136 
 * @return Call identification, returns -1 on fatal error,
 - 
 
137 
           -2 on 'Too many async request, handle answers first
 - 
 
138 
 */
 - 
 
139 
static __native sys_ipc_call_async_fast(__native phoneid, __native method,
 - 
 
140 
                    __native arg1, __native arg2)
 - 
 
141 
{
 - 
 
142 
    call_t *call;
 - 
 
143 
    phone_t *phone;
 - 
 
144 
 
 - 
 
145 
    phone = get_phone(phoneid);
 - 
 
146 
    if (!phone)
 - 
 
147 
        return IPC_CALLRET_FATAL;
 - 
 
148 
 
 - 
 
149 
    if (check_call_limit())
 - 
 
150 
        return IPC_CALLRET_TEMPORARY;
 - 
 
151 
 
 - 
 
152 
    call = ipc_call_alloc();
 - 
 
153 
    IPC_SET_METHOD(call->data, method);
 - 
 
154 
    IPC_SET_ARG1(call->data, arg1);
 - 
 
155 
    IPC_SET_ARG2(call->data, arg2);
 - 
 
156 
 
 - 
 
157 
    ipc_call(phone, call);
 - 
 
158 
 
 - 
 
159 
    return (__native) call;
 - 
 
160 
}
 - 
 
161 
 
 - 
 
162 
/** Synchronous IPC call allowing to send whole message
 - 
 
163 
 *
 - 
 
164 
 * @return The same as sys_ipc_call_async
 - 
 
165 
 */
 - 
 
166 
static __native sys_ipc_call_async(__native phoneid, __native *data)
 - 
 
167 
{
 - 
 
168 
    call_t *call;
 - 
 
169 
    phone_t *phone;
 - 
 
170 
 
 - 
 
171 
    phone = get_phone(phoneid);
 - 
 
172 
    if (!phone)
 - 
 
173 
        return IPC_CALLRET_FATAL;
 - 
 
174 
 
 - 
 
175 
    if (check_call_limit())
 - 
 
176 
        return IPC_CALLRET_TEMPORARY;
 - 
 
177 
 
 - 
 
178 
    call = ipc_call_alloc();
 - 
 
179 
    copy_from_uspace(&call->data, data, sizeof(call->data));
 - 
 
180 
   
 - 
 
181 
    ipc_call(phone, call);
 - 
 
182 
 
 - 
 
183 
    return (__native) call;
 - 
 
184 
}
 - 
 
185 
 
 - 
 
186 
 
 - 
 
187 
/** Send IPC answer */
 - 
 
188 
static __native sys_ipc_answer_fast(__native callid, __native retval,
 - 
 
189 
                    __native arg1, __native arg2)
 - 
 
190 
{
 - 
 
191 
    call_t *call;
 - 
 
192 
 
 - 
 
193 
    /* Check that the user is not sending us answer callid */
 - 
 
194 
    ASSERT(! (callid & 1));
 - 
 
195 
    /* TODO: Check that the callid is in the dispatch table */
 - 
 
196 
    call = (call_t *) callid;
 - 
 
197 
 
 - 
 
198 
    IPC_SET_RETVAL(call->data, retval);
 - 
 
199 
    IPC_SET_ARG1(call->data, arg1);
 - 
 
200 
    IPC_SET_ARG2(call->data, arg2);
 - 
 
201 
 
 - 
 
202 
    ipc_answer(&TASK->answerbox, call);
 - 
 
203 
    return 0;
 - 
 
204 
}
 - 
 
205 
 
 - 
 
206 
/** Send IPC answer */
 - 
 
207 
static __native sys_ipc_answer(__native callid, __native *data)
 - 
 
208 
{
 - 
 
209 
    call_t *call;
 - 
 
210 
 
 - 
 
211 
    /* Check that the user is not sending us answer callid */
 - 
 
212 
    ASSERT(! (callid & 1));
 - 
 
213 
    /* TODO: Check that the callid is in the dispatch table */
 - 
 
214 
    call = (call_t *) callid;
 - 
 
215 
    copy_from_uspace(&call->data, data, sizeof(call->data));
 - 
 
216 
    ipc_answer(&TASK->answerbox, call);
 - 
 
217 
 
 - 
 
218 
    return 0;
 - 
 
219 
}
 - 
 
220 
 
 - 
 
221 
/** Wait for incoming ipc call or answer
 - 
 
222 
 *
 - 
 
223 
 * @param result
 - 
 
224 
 * @param flags
 - 
 
225 
 * @return Callid, if callid & 1, then the call is answer
 - 
 
226 
 */
 - 
 
227 
static __native sys_ipc_wait_for_call(__native *calldata, task_id_t *taskid,
 - 
 
228 
                      __native flags)
 - 
 
229 
{
 - 
 
230 
    call_t *call;
 - 
 
231 
   
 - 
 
232 
    call = ipc_wait_for_call(&TASK->answerbox, flags);
 - 
 
233 
 
 - 
 
234 
    copy_to_uspace(calldata, &call->data, sizeof(call->data));
 - 
 
235 
 
 - 
 
236 
    if (call->flags & IPC_CALL_ANSWERED) {
 - 
 
237 
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
 - 
 
238 
        ipc_call_free(call);
 - 
 
239 
        atomic_dec(&TASK->active_calls);
 - 
 
240 
        return ((__native)call) | IPC_CALLID_ANSWERED;
 - 
 
241 
    }
 - 
 
242 
    copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
 - 
 
243 
    return (__native)call;
 - 
 
244 
}
 - 
 
245 
 
 59 
 
246 
static __native sys_mremap(void *address, size_t size, unsigned long flags)
 60 
static __native sys_mremap(void *address, size_t size, unsigned long flags)
247 
{
 61 
{
248 
    return as_remap(AS, (__address) address, size, 0);
 62 
    return as_remap(AS, (__address) address, size, 0);
249 
}
 63 
}
Line 256... Line 70...
256 
    sys_ipc_call_sync,
 70 
    sys_ipc_call_sync,
257 
    sys_ipc_call_async_fast,
 71 
    sys_ipc_call_async_fast,
258 
    sys_ipc_call_async,
 72 
    sys_ipc_call_async,
259 
    sys_ipc_answer_fast,
 73 
    sys_ipc_answer_fast,
260 
    sys_ipc_answer,
 74 
    sys_ipc_answer,
261 
    sys_ipc_wait_for_call
 75 
    sys_ipc_wait_for_call,
- 
 
 76 
    sys_ipc_connect_to_me
262 
};
 77 
};