Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
662 decky 1
/*
2
 * Copyright (C) 2005 Martin Decky
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
 
678 decky 29
#include <syscall/syscall.h>
714 decky 30
#include <proc/thread.h>
712 decky 31
#include <print.h>
32
#include <putchar.h>
955 palkovsky 33
#include <ipc/ipc.h>
34
#include <errno.h>
35
#include <proc/task.h>
36
#include <arch.h>
37
#include <debug.h>
662 decky 38
 
955 palkovsky 39
static __native sys_ctl(void) {
714 decky 40
    printf("Thread finished\n");
41
    thread_exit();
42
    /* Unreachable */
662 decky 43
    return 0;
44
}
45
 
955 palkovsky 46
static __native sys_io(int fd, const void * buf, size_t count) {
712 decky 47
 
48
    // TODO: buf sanity checks and a lot of other stuff ...
49
 
50
    size_t i;
51
 
52
    for (i = 0; i < count; i++)
53
        putchar(((char *) buf)[i]);
54
 
714 decky 55
    return count;
662 decky 56
}
57
 
959 palkovsky 58
/** Send a call over IPC, wait for reply, return to user
955 palkovsky 59
 *
60
 * @return Call identification, returns -1 on fatal error,
61
           -2 on 'Too many async request, handle answers first
62
 */
959 palkovsky 63
static __native sys_ipc_call_sync(__native phoneid, __native arg1,
64
                   __native arg2, __native *respdata)
955 palkovsky 65
{
66
    call_t *call;
67
    phone_t *phone;
959 palkovsky 68
    /* Special answerbox for synchronous messages */
955 palkovsky 69
 
70
    if (phoneid >= IPC_MAX_PHONES)
71
        return -ENOENT;
72
 
73
    phone = &TASK->phones[phoneid];
74
    if (!phone->callee)
75
        return -ENOENT;
76
 
959 palkovsky 77
    call = ipc_call_alloc();
78
    call->data[0] = arg1;
79
    call->data[1] = arg2;
80
 
81
    ipc_call_sync(phone, call);
955 palkovsky 82
 
959 palkovsky 83
    copy_to_uspace(respdata, &call->data, sizeof(__native) * IPC_CALL_LEN);
84
 
85
    return 0;
86
}
87
 
88
/** Send an asynchronous call over ipc
89
 *
90
 * @return Call identification, returns -1 on fatal error,
91
           -2 on 'Too many async request, handle answers first
92
 */
93
static __native sys_ipc_call_async(__native phoneid, __native arg1,
94
                   __native arg2)
95
{
96
    call_t *call;
97
    phone_t *phone;
98
 
99
    if (phoneid >= IPC_MAX_PHONES)
100
        return -ENOENT;
101
 
102
    phone = &TASK->phones[phoneid];
103
    if (!phone->callee)
104
        return -ENOENT;
105
 
106
 
955 palkovsky 107
    /* TODO: Check that we did not exceed system imposed maximum
108
     * of asynchrnously sent messages
109
     * - the userspace should be able to handle it correctly
110
     */
111
    call = ipc_call_alloc();
112
    call->data[0] = arg1;
113
    call->data[1] = arg2;
114
    ipc_call(phone, call);
115
 
116
    return (__native) call;
117
}
118
 
119
/** Send IPC answer */
120
static __native sys_ipc_answer(__native callid, __native arg1, __native arg2)
121
{
122
    call_t *call;
123
 
124
    /* Check that the user is not sending us answer callid */
125
    ASSERT(! (callid & 1));
126
    /* TODO: Check that the callid is in the dispatch table */
127
    call = (call_t *) callid;
128
 
129
    call->data[0] = arg1;
130
    call->data[1] = arg2;
131
 
132
    ipc_answer(&TASK->answerbox, call);
133
    return 0;
134
}
135
 
136
/** Wait for incoming ipc call or answer
137
 *
138
 * @param result
139
 * @param flags
140
 * @return Callid, if callid & 1, then the call is answer
141
 */
142
static __native sys_ipc_wait_for_call(__native *calldata, __native flags)
143
{
144
    call_t *call;
145
 
146
    call = ipc_wait_for_call(&TASK->answerbox, flags);
147
    copy_to_uspace(calldata, &call->data, sizeof(__native) * IPC_CALL_LEN);
148
 
149
    if (call->flags & IPC_CALL_ANSWERED)
150
        return ((__native)call) | 1;
151
    return (__native)call;
152
}
153
 
154
 
662 decky 155
syshandler_t syscall_table[SYSCALL_END] = {
156
    sys_ctl,
955 palkovsky 157
    sys_io,
959 palkovsky 158
    sys_ipc_call_sync,
159
    sys_ipc_call_async,
955 palkovsky 160
    sys_ipc_answer,
161
    sys_ipc_wait_for_call
662 decky 162
};