/trunk/uspace/app/tester/ipc/send_async.c |
---|
38,6 → 38,7 |
char * test_send_async(bool quiet) |
{ |
int phoneid; |
int res; |
static int msgid = 1; |
char c; |
/trunk/uspace/app/tester/ipc/answer.c |
---|
46,7 → 46,7 |
break; |
} |
if (!cnt) |
return NULL; |
return; |
printf("Choose message:\n"); |
do { |
c = getchar(); |
69,7 → 69,7 |
else if (c == 'e') |
errn = ENOENT; |
printf("Answering %P\n", callids[i]); |
ipc_answer_0(callids[i], errn); |
ipc_answer_fast(callids[i], errn, 0, 0); |
callids[i] = 0; |
return NULL; |
/trunk/uspace/app/tester/ipc/register.c |
---|
29,7 → 29,6 |
#include <stdio.h> |
#include <unistd.h> |
#include <async.h> |
#include <errno.h> |
#include "../tester.h" |
static void client_connection(ipc_callid_t iid, ipc_call_t *icall) |
41,7 → 40,7 |
int i; |
printf("Connected phone: %P, accepting\n", icall->in_phone_hash); |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, 0, 0, 0); |
for (i = 0; i < 1024; i++) |
if (!connections[i]) { |
connections[i] = phonehash; |
56,8 → 55,7 |
retval = 0; |
break; |
default: |
printf("Received message from %P: %X\n", phonehash, |
callid); |
printf("Received message from %P: %X\n", phonehash,callid); |
for (i = 0; i < 1024; i++) |
if (!callids[i]) { |
callids[i] = callid; |
65,7 → 63,7 |
} |
continue; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |
/trunk/uspace/lib/libc/include/ipc/ipc.h |
---|
190,29 → 190,13 |
} |
extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data); |
/* |
* User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow(). |
* They are in the form of ipc_answer_m(), where m is the number of return |
* arguments. The macros decide between the fast and the slow version according |
* to m. |
*/ |
#define ipc_answer_0(callid, retval) \ |
ipc_answer_fast((callid), (retval), 0, 0, 0, 0) |
#define ipc_answer_1(callid, retval, arg1) \ |
ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0) |
#define ipc_answer_2(callid, retval, arg1, arg2) \ |
ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0) |
#define ipc_answer_3(callid, retval, arg1, arg2, arg3) \ |
ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0) |
#define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \ |
ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4)) |
#define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \ |
ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5)) |
#define ipc_answer_fast_0(callid, retval) \ |
ipc_answer_fast((callid), (retval), 0, 0) |
#define ipc_answer_fast_1(callid, retval, arg1) \ |
ipc_answer_fast((callid), (retval), (arg1), 0) |
extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, |
ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4); |
extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, |
ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5); |
ipcarg_t arg1, ipcarg_t arg2); |
extern ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call); |
/* |
* User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow(). |
260,8 → 244,10 |
extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, |
ipcarg_t arg1); |
extern int ipc_data_send(int phoneid, void *src, size_t size); |
extern int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size); |
extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size); |
extern int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst, |
size_t *size); |
extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call, |
void *dst, size_t size); |
#endif |
/trunk/uspace/lib/libc/generic/ipc.c |
---|
375,50 → 375,33 |
/** Answer a received call - fast version. |
* |
* The fast answer makes use of passing retval and first four arguments in |
* registers. If you need to return more, use the ipc_answer_slow() instead. |
* The fast answer makes use of passing retval and first two arguments in |
* registers. If you need to return more, use the ipc_answer() instead. |
* |
* @param callid Hash of the call being answered. |
* @param retval Return value. |
* @param arg1 First return argument. |
* @param arg2 Second return argument. |
* @param arg3 Third return argument. |
* @param arg4 Fourth return argument. |
* |
* @return Zero on success or a value from @ref errno.h on failure. |
*/ |
ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1, |
ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4) |
ipcarg_t arg2) |
{ |
return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3, |
arg4); |
return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2); |
} |
/** Answer a received call - slow full version. |
/** Answer a received call - full version. |
* |
* @param callid Hash of the call being answered. |
* @param retval Return value. |
* @param arg1 First return argument. |
* @param arg2 Second return argument. |
* @param arg3 Third return argument. |
* @param arg4 Fourth return argument. |
* @param arg5 Fifth return argument. |
* @param call Call structure with the answer. |
* Must be already initialized by the responder. |
* |
* @return Zero on success or a value from @ref errno.h on failure. |
*/ |
ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1, |
ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5) |
ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call) |
{ |
ipc_call_t data; |
IPC_SET_RETVAL(data, retval); |
IPC_SET_ARG1(data, arg1); |
IPC_SET_ARG2(data, arg2); |
IPC_SET_ARG3(data, arg3); |
IPC_SET_ARG4(data, arg4); |
IPC_SET_ARG5(data, arg5); |
return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data); |
return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call); |
} |
675,6 → 658,7 |
* |
* @param callid Storage where the hash of the IPC_M_DATA_SEND call will |
* be stored. |
* @param call Storage where the incoming call will be stored. |
* @param dst Storage where the suggested destination address will |
* be stored. May be NULL. |
* @param size Storage where the suggested size will be stored. May be |
682,19 → 666,19 |
* |
* @return Non-zero on success, zero on failure. |
*/ |
int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size) |
int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst, |
size_t *size) |
{ |
ipc_call_t data; |
assert(callid); |
assert(call); |
*callid = async_get_call(&data); |
if (IPC_GET_METHOD(data) != IPC_M_DATA_SEND) |
*callid = async_get_call(call); |
if (IPC_GET_METHOD(*call) != IPC_M_DATA_SEND) |
return 0; |
if (dst) |
*dst = (void *) IPC_GET_ARG1(data); |
*dst = (void *) IPC_GET_ARG1(*call); |
if (size) |
*size = (size_t) IPC_GET_ARG3(data); |
*size = (size_t) IPC_GET_ARG3(*call); |
return 1; |
} |
704,14 → 688,19 |
* so that the user doesn't have to remember the meaning of each IPC argument. |
* |
* @param callid Hash of the IPC_M_DATA_SEND call to answer. |
* @param call Call structure with the request. |
* @param dst Final destination address for the IPC_M_DATA_SEND call. |
* @param size Final size for the IPC_M_DATA_SEND call. |
* |
* @return Zero on success or a value from @ref errno.h on failure. |
*/ |
ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size) |
ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call, void *dst, |
size_t size) |
{ |
return ipc_answer_3(callid, EOK, (ipcarg_t) dst, 0, (ipcarg_t) size); |
IPC_SET_RETVAL(*call, EOK); |
IPC_SET_ARG1(*call, (ipcarg_t) dst); |
IPC_SET_ARG3(*call, (ipcarg_t) size); |
return ipc_answer(callid, call); |
} |
/** @} |
/trunk/uspace/lib/libc/generic/async.c |
---|
75,14 → 75,14 |
* my_client_connection(icallid, *icall) |
* { |
* if (want_refuse) { |
* ipc_answer_0(icallid, ELIMIT); |
* ipc_answer_fast(icallid, ELIMIT, 0, 0); |
* return; |
* } |
* ipc_answer_0(icallid, EOK); |
* ipc_answer_fast(icallid, EOK, 0, 0); |
* |
* callid = async_get_call(&call); |
* handle_call(callid, call); |
* ipc_answer_2(callid, 1, 2, 3); |
* ipc_answer_fast(callid, 1, 2, 3); |
* |
* callid = async_get_call(&call); |
* .... |
395,7 → 395,7 |
*/ |
static void default_client_connection(ipc_callid_t callid, ipc_call_t *call) |
{ |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast(callid, ENOENT, 0, 0); |
} |
/** Default fibril function that gets called to handle interrupt notifications. |
440,11 → 440,11 |
list_remove(&msg->link); |
if (msg->callid == FIBRIL_connection->close_callid) |
close_answered = 1; |
ipc_answer_0(msg->callid, EHANGUP); |
ipc_answer_fast(msg->callid, EHANGUP, 0, 0); |
free(msg); |
} |
if (FIBRIL_connection->close_callid) |
ipc_answer_0(FIBRIL_connection->close_callid, EOK); |
ipc_answer_fast(FIBRIL_connection->close_callid, 0, 0, 0); |
return 0; |
} |
475,7 → 475,7 |
conn = malloc(sizeof(*conn)); |
if (!conn) { |
if (callid) |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_fast(callid, ENOMEM, 0, 0); |
return NULL; |
} |
conn->in_phone_hash = in_phone_hash; |
491,7 → 491,7 |
if (!conn->wdata.fid) { |
free(conn); |
if (callid) |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_fast(callid, ENOMEM, 0, 0); |
return NULL; |
} |
/* Add connection to the connection hash table */ |
536,7 → 536,7 |
return; |
/* Unknown call from unknown phone - hang it up */ |
ipc_answer_0(callid, EHANGUP); |
ipc_answer_fast(callid, EHANGUP, 0, 0); |
} |
/** Fire all timeouts that expired. */ |
/trunk/uspace/srv/console/console.c |
---|
277,7 → 277,8 |
for (j = 0; j < conn->screenbuffer.size_y; j++) |
for (i = 0; i < conn->screenbuffer.size_x; i++) { |
field = get_field_at(&conn->screenbuffer, i, j); |
field = get_field_at(&conn->screenbuffer, i, |
j); |
if (!style_same(*style, field->style)) |
set_style(&field->style); |
style = &field->style; |
348,8 → 349,8 |
/* if client is awaiting key, send it */ |
if (conn->keyrequest_counter > 0) { |
conn->keyrequest_counter--; |
ipc_answer_1(fifo_pop(conn->keyrequests), EOK, |
c); |
ipc_answer_fast(fifo_pop(conn->keyrequests), 0, |
c, 0); |
break; |
} |
360,7 → 361,7 |
default: |
retval = ENOENT; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |
374,7 → 375,7 |
connection_t *conn; |
if ((consnum = find_free_connection()) == -1) { |
ipc_answer_0(iid, ELIMIT); |
ipc_answer_fast(iid, ELIMIT, 0, 0); |
return; |
} |
conn = &connections[consnum]; |
386,7 → 387,7 |
screenbuffer_clear(&conn->screenbuffer); |
/* Accept the connection */ |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, 0, 0, 0); |
while (1) { |
async_serialize_end(); |
402,8 → 403,8 |
/* Answer all pending requests */ |
while (conn->keyrequest_counter > 0) { |
conn->keyrequest_counter--; |
ipc_answer_0(fifo_pop(conn->keyrequests), |
ENOENT); |
ipc_answer_fast(fifo_pop(conn->keyrequests), |
ENOENT, 0, 0); |
break; |
} |
conn->used = 0; |
463,7 → 464,7 |
* No key available and too many |
* requests => fail. |
*/ |
ipc_answer_0(callid, ELIMIT); |
ipc_answer_fast(callid, ELIMIT, 0, 0); |
} |
continue; |
} |
470,7 → 471,7 |
keybuffer_pop(&conn->keybuffer, (int *) &arg1); |
break; |
} |
ipc_answer_2(callid, EOK, arg1, arg2); |
ipc_answer_fast(callid, 0, arg1, arg2); |
} |
} |
/trunk/uspace/srv/fs/fat/fat.c |
---|
93,7 → 93,7 |
* IPC_M_CONNECT_ME_TO calls as opposed to callback connections |
* created by IPC_M_CONNECT_TO_ME. |
*/ |
ipc_answer_0(iid, EOK); |
ipc_answer_fast_0(iid, EOK); |
} |
dprintf("VFS-FAT connection established.\n"); |
104,7 → 104,7 |
callid = async_get_call(&call); |
switch (IPC_GET_METHOD(call)) { |
default: |
ipc_answer_0(callid, ENOTSUP); |
ipc_answer_fast_0(callid, ENOTSUP); |
break; |
} |
} |
/trunk/uspace/srv/vfs/vfs_register.c |
---|
155,13 → 155,13 |
* The first call has to be IPC_M_DATA_SEND in which we receive the |
* VFS info structure from the client FS. |
*/ |
if (!ipc_data_receive(&callid, NULL, &size)) { |
if (!ipc_data_receive(&callid, &call, NULL, &size)) { |
/* |
* The client doesn't obey the same protocol as we do. |
*/ |
dprintf("Receiving of VFS info failed.\n"); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
177,8 → 177,8 |
* the info structure. |
*/ |
dprintf("Received VFS info has bad size.\n"); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
189,19 → 189,19 |
fs_info = (fs_info_t *) malloc(sizeof(fs_info_t)); |
if (!fs_info) { |
dprintf("Could not allocate memory for FS info.\n"); |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(callid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
link_initialize(&fs_info->fs_link); |
rc = ipc_data_deliver(callid, &fs_info->vfs_info, size); |
rc = ipc_data_deliver(callid, &call, &fs_info->vfs_info, size); |
if (rc != EOK) { |
dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n", |
rc); |
free(fs_info); |
ipc_answer_0(callid, rc); |
ipc_answer_0(rid, rc); |
ipc_answer_fast_0(callid, rc); |
ipc_answer_fast_0(rid, rc); |
return; |
} |
209,8 → 209,8 |
if (!vfs_info_sane(&fs_info->vfs_info)) { |
free(fs_info); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
226,8 → 226,8 |
dprintf("FS is already registered.\n"); |
futex_up(&fs_head_futex); |
free(fs_info); |
ipc_answer_0(callid, EEXISTS); |
ipc_answer_0(rid, EEXISTS); |
ipc_answer_fast_0(callid, EEXISTS); |
ipc_answer_fast_0(rid, EEXISTS); |
return; |
} |
248,12 → 248,12 |
list_remove(&fs_info->fs_link); |
futex_up(&fs_head_futex); |
free(fs_info); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
fs_info->phone = IPC_GET_ARG3(call); |
ipc_answer_0(callid, EOK); |
ipc_answer_fast_0(callid, EOK); |
dprintf("Callback connection to FS created.\n"); |
267,8 → 267,8 |
futex_up(&fs_head_futex); |
ipc_hangup(fs_info->phone); |
free(fs_info); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
282,8 → 282,8 |
futex_up(&fs_head_futex); |
ipc_hangup(fs_info->phone); |
free(fs_info); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
290,7 → 290,7 |
/* |
* Commit to read-only sharing the PLB with the client. |
*/ |
ipc_answer_2(callid, EOK, (ipcarg_t) plb, |
ipc_answer_fast(callid, EOK, (ipcarg_t) plb, |
(ipcarg_t) (AS_AREA_READ | AS_AREA_CACHEABLE)); |
dprintf("Sharing PLB.\n"); |
301,7 → 301,7 |
* system a global file system handle. |
*/ |
fs_info->fs_handle = (int) atomic_postinc(&fs_handle_next); |
ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle); |
ipc_answer_fast_1(rid, EOK, (ipcarg_t) fs_info->fs_handle); |
futex_up(&fs_head_futex); |
/trunk/uspace/srv/vfs/vfs_mount.c |
---|
84,10 → 84,11 |
* system and the path of the mountpoint. |
*/ |
ipc_callid_t callid; |
ipc_call_t call; |
size_t size; |
if (!ipc_data_receive(&callid, NULL, &size)) { |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
if (!ipc_data_receive(&callid, &call, NULL, &size)) { |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
98,8 → 99,8 |
*/ |
if ((size < FS_NAME_MAXLEN + 1) || |
(size > FS_NAME_MAXLEN + MAX_PATH_LEN)) { |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
109,8 → 110,8 |
uint8_t *buf; |
buf = malloc(size); |
if (!buf) { |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(callid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
117,7 → 118,7 |
/* |
* Deliver the data. |
*/ |
(void) ipc_data_deliver(callid, buf, size); |
(void) ipc_data_deliver(callid, &call, buf, size); |
char fs_name[FS_NAME_MAXLEN + 1]; |
memcpy(fs_name, buf, FS_NAME_MAXLEN); |
130,7 → 131,7 |
int fs_handle = fs_name_to_handle(fs_name, true); |
if (!fs_handle) { |
free(buf); |
ipc_answer_0(rid, ENOENT); |
ipc_answer_fast_0(rid, ENOENT); |
return; |
} |
145,13 → 146,13 |
rc = lookup_root(fs_handle, dev_handle, &mounted_root); |
if (rc != EOK) { |
free(buf); |
ipc_answer_0(rid, rc); |
ipc_answer_fast_0(rid, rc); |
return; |
} |
vfs_node_t *mr_node = vfs_node_get(&mounted_root); |
if (!mr_node) { |
free(buf); |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
175,7 → 176,7 |
futex_up(&rootfs_futex); |
vfs_node_put(mr_node); /* failed -> drop reference */ |
free(buf); |
ipc_answer_0(rid, rc); |
ipc_answer_fast_0(rid, rc); |
return; |
} |
mp_node = vfs_node_get(&mp); |
184,7 → 185,7 |
futex_up(&rootfs_futex); |
vfs_node_put(mr_node); /* failed -> drop reference */ |
free(buf); |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
/* |
205,7 → 206,7 |
rootfs = mounted_root; |
futex_up(&rootfs_futex); |
free(buf); |
ipc_answer_0(rid, EOK); |
ipc_answer_fast_0(rid, EOK); |
return; |
} else { |
/* |
215,7 → 216,7 |
futex_up(&rootfs_futex); |
free(buf); |
vfs_node_put(mr_node); /* failed -> drop reference */ |
ipc_answer_0(rid, ENOENT); |
ipc_answer_fast_0(rid, ENOENT); |
return; |
} |
} |
253,11 → 254,11 |
} |
if (rc2 == EOK) |
ipc_answer_0(rid, rc1); |
ipc_answer_fast_0(rid, rc1); |
else if (rc1 == EOK) |
ipc_answer_0(rid, rc2); |
ipc_answer_fast_0(rid, rc2); |
else |
ipc_answer_0(rid, rc1); |
ipc_answer_fast_0(rid, rc1); |
} |
/** |
/trunk/uspace/srv/vfs/vfs.c |
---|
59,7 → 59,7 |
* The connection was opened via the IPC_CONNECT_ME_TO call. |
* This call needs to be answered. |
*/ |
ipc_answer_0(iid, EOK); |
ipc_answer_fast_0(iid, EOK); |
/* |
* Here we enter the main connection fibril loop. |
103,7 → 103,7 |
case VFS_UNLINK: |
case VFS_RENAME: |
default: |
ipc_answer_0(callid, ENOTSUP); |
ipc_answer_fast_0(callid, ENOTSUP); |
break; |
} |
} |
/trunk/uspace/srv/vfs/vfs_open.c |
---|
46,7 → 46,7 |
void vfs_open(ipc_callid_t rid, ipc_call_t *request) |
{ |
if (!vfs_files_init()) { |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
60,10 → 60,11 |
size_t size; |
ipc_callid_t callid; |
ipc_call_t call; |
if (!ipc_data_receive(&callid, NULL, &size)) { |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(rid, EINVAL); |
if (!ipc_data_receive(&callid, &call, NULL, &size)) { |
ipc_answer_fast_0(callid, EINVAL); |
ipc_answer_fast_0(rid, EINVAL); |
return; |
} |
76,14 → 77,14 |
char *path = malloc(size); |
if (!path) { |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(rid, ENOMEM); |
ipc_answer_fast_0(callid, ENOMEM); |
ipc_answer_fast_0(rid, ENOMEM); |
return; |
} |
int rc; |
if ((rc = ipc_data_deliver(callid, path, size))) { |
ipc_answer_0(rid, rc); |
if ((rc = ipc_data_deliver(callid, &call, path, size))) { |
ipc_answer_fast_0(rid, rc); |
free(path); |
return; |
} |
102,7 → 103,7 |
rc = vfs_lookup_internal(path, size, &triplet, NULL); |
if (rc) { |
futex_up(&unlink_futex); |
ipc_answer_0(rid, rc); |
ipc_answer_fast_0(rid, rc); |
free(path); |
return; |
} |
122,7 → 123,7 |
int fd = vfs_fd_alloc(); |
if (fd < 0) { |
vfs_node_put(node); |
ipc_answer_0(rid, fd); |
ipc_answer_fast_0(rid, fd); |
return; |
} |
vfs_file_t *file = vfs_file_get(fd); |
141,7 → 142,7 |
/* |
* Success! Return the new file descriptor to the client. |
*/ |
ipc_answer_1(rid, EOK, fd); |
ipc_answer_fast_1(rid, EOK, fd); |
} |
/** |
/trunk/uspace/srv/devmap/devmap.c |
---|
113,7 → 113,7 |
} |
if (item == &devices_list) { |
printf("DEVMAP: no device named %s.\n", name); |
printf("DevMap: no device named %s.\n", name); |
return NULL; |
} |
189,13 → 189,13 |
iid = async_get_call(&icall); |
if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) { |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
if (NULL == |
(driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) { |
ipc_answer_0(iid, ENOMEM); |
ipc_answer_fast(iid, ENOMEM, 0, 0); |
return; |
} |
202,11 → 202,11 |
/* |
* Get driver name |
*/ |
if (!ipc_data_receive(&callid, NULL, &name_size)) { |
printf("Unexpected request.\n"); |
if (!ipc_data_receive(&callid, &call, NULL, &name_size)) { |
printf("Unexpected request: %u.\n", IPC_GET_METHOD(call)); |
free(driver); |
ipc_answer_0(callid, EREFUSED); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, EREFUSED, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
214,8 → 214,8 |
printf("Too logn name: %u: maximum is %u.\n", name_size, |
DEVMAP_NAME_MAXLEN); |
free(driver); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, EINVAL, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
225,8 → 225,8 |
if (NULL == (driver->name = (char *)malloc(name_size + 1))) { |
printf("Cannot allocate space for driver name.\n"); |
free(driver); |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, ENOMEM, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
233,11 → 233,11 |
/* |
* Send confirmation to sender and get data into buffer. |
*/ |
if (EOK != ipc_data_deliver(callid, driver->name, name_size)) { |
if (EOK != ipc_data_deliver(callid, &call, driver->name, name_size)) { |
printf("Cannot read driver name.\n"); |
free(driver->name); |
free(driver); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
250,7 → 250,7 |
/* |
* Initialize list of asociated devices |
*/ |
*/ |
list_initialize(&(driver->devices)); |
/* |
259,19 → 259,19 |
callid = async_get_call(&call); |
if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) { |
printf("DEVMAP: Unexpected method: %u.\n", |
printf("DevMap: Unexpected method: %u.\n", |
IPC_GET_METHOD(call)); |
ipc_answer_0(callid, ENOTSUP); |
ipc_answer_fast(callid, ENOTSUP, 0, 0); |
free(driver->name); |
free(driver); |
ipc_answer_0(iid, ENOTSUP); |
ipc_answer_fast(iid, ENOTSUP, 0, 0); |
return; |
} |
driver->phone = IPC_GET_ARG3(call); |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, EOK, 0, 0); |
list_initialize(&(driver->drivers)); |
287,7 → 287,7 |
list_append(&(driver->drivers), &drivers_list); |
futex_up(&drivers_list_futex); |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, EOK, 0, 0); |
printf("Driver registered.\n"); |
*odriver = driver; |
294,8 → 294,8 |
return; |
} |
/** Unregister device driver, unregister all its devices and free driver |
* structure. |
/** Unregister device driver, unregister all its devices and free driver structure. |
* |
*/ |
static int devmap_driver_unregister(devmap_driver_t *driver) |
{ |
347,15 → 347,16 |
* |
*/ |
static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall, |
devmap_driver_t *driver) |
devmap_driver_t *driver) |
{ |
ipc_callid_t callid; |
ipc_call_t call; |
size_t size; |
devmap_device_t *device; |
if (NULL == driver) { |
printf("Invalid driver registration.\n"); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
363,15 → 364,15 |
if (NULL == |
(device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) { |
printf("Cannot allocate new device.\n"); |
ipc_answer_0(iid, ENOMEM); |
ipc_answer_fast(iid, ENOMEM, 0, 0); |
return; |
} |
/* Get device name */ |
if (!ipc_data_receive(&callid, NULL, &size)) { |
if (!ipc_data_receive(&callid, &call, NULL, &size)) { |
free(device); |
printf("Cannot read device name.\n"); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
378,8 → 379,8 |
if (size > DEVMAP_NAME_MAXLEN) { |
printf("Too long device name: %u.\n", size); |
free(device); |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, EINVAL, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
389,12 → 390,12 |
if (NULL == device->name) { |
printf("Cannot read device name.\n"); |
free(device); |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, ENOMEM, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
ipc_data_deliver(callid, device->name, size); |
ipc_data_deliver(callid, &call, device->name, size); |
device->name[size] = 0; |
list_initialize(&(device->devices)); |
408,7 → 409,7 |
futex_up(&devices_list_futex); |
free(device->name); |
free(device); |
ipc_answer_0(iid, EEXISTS); |
ipc_answer_fast(iid, EEXISTS, 0, 0); |
return; |
} |
418,18 → 419,18 |
device->driver = driver; |
/* Insert device into list of all devices */ |
list_append(&device->devices, &devices_list); |
list_append(&(device->devices), &devices_list); |
/* Insert device into list of devices that belog to one driver */ |
futex_down(&device->driver->devices_futex); |
futex_down(&(device->driver->devices_futex)); |
list_append(&device->driver_devices, &device->driver->devices); |
list_append(&(device->driver_devices), &(device->driver->devices)); |
futex_up(&device->driver->devices_futex); |
futex_up(&(device->driver->devices_futex)); |
futex_up(&devices_list_futex); |
printf("Device '%s' registered.\n", device->name); |
ipc_answer_1(iid, EOK, device->handle); |
ipc_answer_fast(iid, EOK, device->handle, 0); |
return; |
} |
438,7 → 439,7 |
* |
*/ |
static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall, |
devmap_driver_t *driver) |
devmap_driver_t *driver) |
{ |
/* TODO */ |
463,9 → 464,9 |
dev = devmap_device_find_handle(handle); |
if (NULL == dev) { |
printf("DEVMAP: No registered device with handle %d.\n", |
printf("DevMap: No registered device with handle %d.\n", |
handle); |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast(callid, ENOENT, 0, 0); |
return; |
} |
485,6 → 486,7 |
size_t name_size; |
const devmap_device_t *dev; |
ipc_callid_t callid; |
ipc_call_t call; |
ipcarg_t retval; |
492,15 → 494,15 |
* Wait for incoming message with device name (but do not |
* read the name itself until the buffer is allocated). |
*/ |
if (!ipc_data_receive(&callid, NULL, &name_size)) { |
ipc_answer_0(callid, EREFUSED); |
ipc_answer_0(iid, EREFUSED); |
if (!ipc_data_receive(&callid, &call, NULL, &name_size)) { |
ipc_answer_fast(callid, EREFUSED, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
if (name_size > DEVMAP_NAME_MAXLEN) { |
ipc_answer_0(callid, EINVAL); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, EINVAL, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
508,8 → 510,8 |
* Allocate buffer for device name. |
*/ |
if (NULL == (name = (char *)malloc(name_size))) { |
ipc_answer_0(callid, ENOMEM); |
ipc_answer_0(iid, EREFUSED); |
ipc_answer_fast(callid, ENOMEM, 0, 0); |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
516,8 → 518,9 |
/* |
* Send confirmation to sender and get data into buffer. |
*/ |
if (EOK != (retval = ipc_data_deliver(callid, name, name_size))) { |
ipc_answer_0(iid, EREFUSED); |
if (EOK != (retval = ipc_data_deliver(callid, &call, name, |
name_size))) { |
ipc_answer_fast(iid, EREFUSED, 0, 0); |
return; |
} |
530,14 → 533,14 |
* Device was not found. |
*/ |
if (NULL == dev) { |
printf("DEVMAP: device %s has not been registered.\n", name); |
ipc_answer_0(iid, ENOENT); |
printf("DevMap: device %s has not been registered.\n", name); |
ipc_answer_fast(iid, ENOENT, 0, 0); |
return; |
} |
printf("DEVMAP: device %s has handler %d.\n", name, dev->handle); |
printf("DevMap: device %s has handler %d.\n", name, dev->handle); |
ipc_answer_1(iid, EOK, dev->handle); |
ipc_answer_fast(iid, EOK, dev->handle, 0); |
return; |
} |
556,17 → 559,17 |
* Device not found. |
*/ |
if (NULL == device) { |
ipc_answer_0(iid, ENOENT); |
ipc_answer_fast(iid, ENOENT, 0, 0); |
return; |
} |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, EOK, 0, 0); |
name_size = strlen(device->name); |
/* FIXME: |
we have no channel from DEVMAP to client -> |
we have no channel from DevMap to client -> |
sending must be initiated by client |
int rc = ipc_data_send(phone, device->name, name_size); |
591,12 → 594,12 |
bool cont = true; |
devmap_driver_t *driver = NULL; |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, EOK, 0, 0); |
devmap_driver_register(&driver); |
if (NULL == driver) { |
printf("DEVMAP: driver registration failed.\n"); |
printf("DevMap: driver registration failed.\n"); |
return; |
} |
605,16 → 608,16 |
switch (IPC_GET_METHOD(call)) { |
case IPC_M_PHONE_HUNGUP: |
printf("DEVMAP: connection hung up.\n"); |
printf("DevMap: connection hung up.\n"); |
cont = false; |
continue; /* Exit thread */ |
case DEVMAP_DRIVER_UNREGISTER: |
printf("DEVMAP: unregister driver.\n"); |
printf("DevMap: unregister driver.\n"); |
if (NULL == driver) { |
printf("DEVMAP: driver was not registered!\n"); |
ipc_answer_0(callid, ENOENT); |
printf("DevMap: driver was not registered!\n"); |
ipc_answer_fast(callid, ENOENT, 0, 0); |
} else { |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, EOK, 0, 0); |
} |
break; |
case DEVMAP_DEVICE_REGISTER: |
633,15 → 636,15 |
break; |
default: |
if (!(callid & IPC_CALLID_NOTIFICATION)) { |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast(callid, ENOENT, 0, 0); |
} |
} |
} |
if (NULL != driver) { |
/* |
* Unregister the device driver and all its devices. |
*/ |
/* |
* Unregister the device driver and all its devices. |
*/ |
devmap_driver_unregister(driver); |
driver = NULL; |
} |
658,7 → 661,7 |
ipc_call_t call; |
bool cont = true; |
ipc_answer_0(iid, EOK); /* Accept connection */ |
ipc_answer_fast(iid, EOK, 0, 0); /* Accept connection */ |
while (cont) { |
callid = async_get_call(&call); |
665,13 → 668,13 |
switch (IPC_GET_METHOD(call)) { |
case IPC_M_PHONE_HUNGUP: |
printf("DEVMAP: connection hung up.\n"); |
printf("DevMap: connection hung up.\n"); |
cont = false; |
continue; /* Exit thread */ |
case DEVMAP_DEVICE_CONNECT_ME_TO: |
/* Connect client to selected device */ |
printf("DEVMAP: connect to device %d.\n", |
printf("DevMap: connect to device %d.\n", |
IPC_GET_ARG1(call)); |
devmap_forward(callid, &call); |
break; |
686,7 → 689,7 |
break; |
default: |
if (!(callid & IPC_CALLID_NOTIFICATION)) { |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast(callid, ENOENT, 0, 0); |
} |
} |
} |
699,7 → 702,7 |
devmap_connection(ipc_callid_t iid, ipc_call_t *icall) |
{ |
printf("DEVMAP: new connection.\n"); |
printf("DevMap: new connection.\n"); |
/* Select interface */ |
switch ((ipcarg_t)(IPC_GET_ARG1(*icall))) { |
710,14 → 713,14 |
devmap_connection_client(iid, icall); |
break; |
default: |
ipc_answer_0(iid, ENOENT); /* No such interface */ |
printf("DEVMAP: Unknown interface %u.\n", |
ipc_answer_fast(iid, ENOENT, 0, 0); /* No such interface */ |
printf("DevMap: Unknown interface %u.\n", |
(ipcarg_t)(IPC_GET_ARG1(*icall))); |
} |
/* Cleanup */ |
printf("DEVMAP: connection closed.\n"); |
printf("DevMap: connection closed.\n"); |
return; |
} |
728,10 → 731,10 |
{ |
ipcarg_t phonead; |
printf("DEVMAP: HelenOS device mapper.\n"); |
printf("DevMap: HelenOS device mapper.\n"); |
if (devmap_init() != 0) { |
printf("Error while initializing DEVMAP service.\n"); |
printf("Error while initializing DevMap service.\n"); |
return -1; |
} |
/trunk/uspace/srv/ns/ns.c |
---|
92,7 → 92,7 |
if (!*addr) { |
ph_addr = (void *) sysinfo_value(name); |
if (!ph_addr) { |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast_0(callid, ENOENT); |
return; |
} |
*addr = as_get_mappable_page(PAGE_SIZE); |
99,7 → 99,7 |
physmem_map(ph_addr, *addr, 1, |
AS_AREA_READ | AS_AREA_CACHEABLE); |
} |
ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ); |
ipc_answer_fast(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ); |
} |
int main(int argc, char **argv) |
128,7 → 128,7 |
&klogaddr); |
break; |
default: |
ipc_answer_0(callid, ENOENT); |
ipc_answer_fast_0(callid, ENOENT); |
} |
continue; |
case IPC_M_PHONE_HUNGUP: |
153,7 → 153,7 |
break; |
} |
if (!(callid & IPC_CALLID_NOTIFICATION)) { |
ipc_answer_0(callid, retval); |
ipc_answer_fast_0(callid, retval); |
} |
} |
} |
/trunk/uspace/srv/kbd/generic/kbd.c |
---|
68,10 → 68,7 |
kbd_arch_process(&keybuffer, call); |
if (cons_connected && phone2cons != -1) { |
/* |
* recode to ASCII - one interrupt can produce more than one |
* code so result is stored in fifo |
*/ |
/* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */ |
while (!keybuffer_empty(&keybuffer)) { |
if (!keybuffer_pop(&keybuffer, (int *)&chr)) |
break; |
88,11 → 85,11 |
int retval; |
if (cons_connected) { |
ipc_answer_0(iid, ELIMIT); |
ipc_answer_fast(iid, ELIMIT, 0, 0); |
return; |
} |
cons_connected = 1; |
ipc_answer_0(iid, EOK); |
ipc_answer_fast(iid, 0, 0, 0); |
while (1) { |
callid = async_get_call(&call); |
101,7 → 98,7 |
cons_connected = 0; |
ipc_hangup(phone2cons); |
phone2cons = -1; |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, 0,0,0); |
return; |
case IPC_M_CONNECT_TO_ME: |
if (phone2cons != -1) { |
114,7 → 111,7 |
default: |
retval = EINVAL; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |
/trunk/uspace/srv/fb/fb.c |
---|
165,7 → 165,7 |
bgr_byte0888(void *dst, int rgb) |
{ |
*((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 | |
RED(rgb, 8); |
RED(rgb, 8); |
} |
static int |
173,7 → 173,7 |
{ |
int color = *(uint32_t *)(src); |
return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) | |
((color >> 16) & 0xff); |
((color >> 16) & 0xff); |
} |
static void |
208,7 → 208,7 |
{ |
/* 5-bit, 5-bits, 5-bits */ |
*((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 | |
BLUE(rgb, 5); |
BLUE(rgb, 5); |
} |
/** 16-bit depth (5:5:5) */ |
217,7 → 217,7 |
{ |
int color = *(uint16_t *)(src); |
return (((color >> 10) & 0x1f) << (16 + 3)) | |
(((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3); |
(((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3); |
} |
/** 16-bit depth (5:6:5) */ |
226,7 → 226,7 |
{ |
/* 5-bit, 6-bits, 5-bits */ |
*((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 | |
BLUE(rgb, 5); |
BLUE(rgb, 5); |
} |
/** 16-bit depth (5:6:5) */ |
235,7 → 235,7 |
{ |
int color = *(uint16_t *)(src); |
return (((color >> 11) & 0x1f) << (16 + 3)) | |
(((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3); |
(((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3); |
} |
/** Put pixel - 8-bit depth (3:2:3) */ |
251,7 → 251,7 |
{ |
int color = *(uint8_t *)src; |
return (((color >> 5) & 0x7) << (16 + 5)) | |
(((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5); |
(((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5); |
} |
/** Put pixel into viewport |
269,7 → 269,7 |
if (! (vport->paused && vport->dbdata)) |
(*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)], |
COLOR(color)); |
COLOR(color)); |
if (vport->dbdata) { |
int dline = (y + vport->dboffset) % vport->height; |
291,7 → 291,7 |
static inline void |
putpixel_mem(char *mem, unsigned int x, unsigned int y, int color) |
{ |
(*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color)); |
(*screen.rgb2scr)(&mem[POINTPOS(x,y)], COLOR(color)); |
} |
static void |
302,7 → 302,7 |
static void *tmpline; |
if (!tmpline) |
tmpline = malloc(screen.scanline * screen.pixelbytes); |
tmpline = malloc(screen.scanline*screen.pixelbytes); |
/* Clear first line */ |
for (x = 0; x < width; x++) |
315,15 → 315,15 |
/* Copy the rest */ |
for (y = sy;y < sy+height; y++) |
memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline, |
screen.pixelbytes * width); |
screen.pixelbytes * width); |
} |
if (vport->dbdata) { |
for (y = sy; y < sy + height; y++) { |
int rline = (y + vport->dboffset) % vport->height; |
int rpos = (rline * vport->width + sx) * |
screen.pixelbytes; |
screen.pixelbytes; |
memcpy(&vport->dbdata[rpos], tmpline, |
screen.pixelbytes * width); |
screen.pixelbytes * width); |
} |
} |
334,7 → 334,7 |
clear_port(viewport_t *vport) |
{ |
draw_rectangle(vport, 0, 0, vport->width, vport->height, |
vport->style.bg_color); |
vport->style.bg_color); |
} |
/** Scroll unbuffered viewport up/down |
350,18 → 350,19 |
if (lines > 0) { |
for (y = vport->y; y < vport->y+vport->height - lines; y++) |
memcpy(&screen.fbaddress[POINTPOS(vport->x,y)], |
&screen.fbaddress[POINTPOS(vport->x,y + lines)], |
screen.pixelbytes * vport->width); |
&screen.fbaddress[POINTPOS(vport->x,y + lines)], |
screen.pixelbytes * vport->width); |
draw_rectangle(vport, 0, vport->height - lines, vport->width, |
lines, vport->style.bg_color); |
lines, vport->style.bg_color); |
} else if (lines < 0) { |
lines = -lines; |
for (y = vport->y + vport->height-1; y >= vport->y + lines; y--) |
for (y = vport->y + vport->height-1; y >= vport->y + lines; |
y--) |
memcpy(&screen.fbaddress[POINTPOS(vport->x,y)], |
&screen.fbaddress[POINTPOS(vport->x,y - lines)], |
screen.pixelbytes * vport->width); |
&screen.fbaddress[POINTPOS(vport->x,y - lines)], |
screen.pixelbytes * vport->width); |
draw_rectangle(vport, 0, 0, vport->width, lines, |
vport->style.bg_color); |
vport->style.bg_color); |
} |
} |
379,7 → 380,8 |
dsty = vport->y + y; |
memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)], |
&vport->dbdata[srcoff], vport->width * screen.pixelbytes); |
&vport->dbdata[srcoff], |
vport->width*screen.pixelbytes); |
} |
} |
390,13 → 392,14 |
++vport->paused; |
if (lines > 0) { |
draw_rectangle(vport, 0, 0, vport->width, lines, |
vport->style.bg_color); |
vport->style.bg_color); |
vport->dboffset += lines; |
vport->dboffset %= vport->height; |
} else if (lines < 0) { |
lines = -lines; |
draw_rectangle(vport, 0, vport->height-lines, vport->width, |
lines, vport->style.bg_color); |
draw_rectangle(vport, 0, vport->height-lines, |
vport->width, lines, |
vport->style.bg_color); |
if (vport->dboffset < lines) |
vport->dboffset += vport->height; |
438,8 → 441,8 |
* @param transparent If false, print background color |
*/ |
static void |
draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy, |
style_t style, int transparent) |
draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, |
unsigned int sy, style_t style, int transparent) |
{ |
int i; |
unsigned int y; |
449,9 → 452,11 |
glline = fb_font[glyph * FONT_SCANLINES + y]; |
for (i = 0; i < 8; i++) { |
if (glline & (1 << (7 - i))) |
putpixel(vport, sx + i, sy + y, style.fg_color); |
putpixel(vport, sx + i, sy + y, |
style.fg_color); |
else if (!transparent) |
putpixel(vport, sx + i, sy + y, style.bg_color); |
putpixel(vport, sx + i, sy + y, |
style.bg_color); |
} |
} |
} |
466,7 → 471,7 |
for (x = 0; x < COL_WIDTH; x++) |
for (y = 0; y < FONT_SCANLINES; y++) |
invert_pixel(vport, col * COL_WIDTH + x, row * |
FONT_SCANLINES + y); |
FONT_SCANLINES + y); |
} |
/***************************************************************/ |
625,7 → 630,7 |
invert_char(vport, vport->cur_row, vport->cur_col); |
draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style, |
transparent); |
transparent); |
vport->cur_col = col; |
vport->cur_row = row; |
654,13 → 659,13 |
clear_port(vport); |
for (i = 0; i < vport->cols * vport->rows; i++) { |
if (data[i].character == ' ' && style_same(data[i].style, |
vport->style)) |
vport->style)) |
continue; |
col = i % vport->cols; |
row = i / vport->cols; |
draw_glyph(vport, data[i].character, col * COL_WIDTH, row * |
FONT_SCANLINES, data[i].style, style_same(data[i].style, |
vport->style)); |
FONT_SCANLINES, data[i].style, |
style_same(data[i].style,vport->style)); |
} |
cursor_print(vport); |
} |
706,7 → 711,7 |
return ENOMEM; |
ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, |
(putpixel_cb_t)putpixel_pixmap, (void *)pm); |
(putpixel_cb_t)putpixel_pixmap, (void *)pm); |
return pm; |
} |
752,7 → 757,7 |
if (IPC_GET_ARG1(*call) == shm_id) { |
void *dest = as_get_mappable_page(IPC_GET_ARG2(*call)); |
shm_size = IPC_GET_ARG2(*call); |
if (!ipc_answer_1(callid, EOK, (sysarg_t) dest)) |
if (!ipc_answer_fast(callid, 0, (sysarg_t) dest, 0)) |
shm = dest; |
else |
shm_id = 0; |
800,8 → 805,8 |
} |
ppm_draw(shm, shm_size, IPC_GET_ARG1(*call), |
IPC_GET_ARG2(*call), vport->width - x, vport->height - y, |
(putpixel_cb_t)putpixel, vport); |
IPC_GET_ARG2(*call), vport->width - x, |
vport->height - y, (putpixel_cb_t)putpixel, vport); |
break; |
case FB_DRAW_TEXT_DATA: |
if (!interbuffer) { |
809,7 → 814,7 |
break; |
} |
if (intersize < vport->cols * vport->rows * |
sizeof(*interbuffer)) { |
sizeof(*interbuffer)) { |
retval = EINVAL; |
break; |
} |
820,7 → 825,7 |
} |
if (handled) |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
return handled; |
} |
846,9 → 851,9 |
for (y = 0; y < realheight; y++) { |
tmp = (vport->y + y) * screen.scanline + |
vport->x * screen.pixelbytes; |
vport->x * screen.pixelbytes; |
memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp, |
realrowsize); |
realrowsize); |
} |
} |
907,9 → 912,9 |
for (y = 0; y < realheight; y++) { |
tmp = (vport->y + y) * screen.scanline + |
vport->x * screen.pixelbytes; |
vport->x * screen.pixelbytes; |
memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize, |
realrowsize); |
realrowsize); |
} |
return 0; |
} |
928,12 → 933,12 |
for (i = 0; i < MAX_ANIMATIONS; i++) { |
if (!animations[i].animlen || !animations[i].initialized || |
!animations[i].enabled) |
!animations[i].enabled) |
continue; |
draw_pixmap(animations[i].vp, |
animations[i].pixmaps[animations[i].pos]); |
animations[i].pixmaps[animations[i].pos]); |
animations[i].pos = (animations[i].pos + 1) % |
animations[i].animlen; |
animations[i].animlen; |
} |
} |
957,7 → 962,7 |
/* Save image under the cursor */ |
if (pointer_vport == -1) { |
pointer_vport = viewport_create(pointer_x, pointer_y, |
pointer_width, pointer_height); |
pointer_width, pointer_height); |
if (pointer_vport < 0) |
return; |
} else { |
969,7 → 974,7 |
pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]); |
else |
copy_vp_to_pixmap(&viewports[pointer_vport], |
&pixmaps[pointer_pixmap]); |
&pixmaps[pointer_pixmap]); |
/* Draw cursor */ |
for (i = 0; i < pointer_height; i++) |
976,14 → 981,14 |
for (j = 0; j < pointer_width; j++) { |
bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8; |
visibility = pointer_mask_bits[bytepos] & |
(1 << (j % 8)); |
(1 << (j % 8)); |
if (visibility) { |
color = pointer_bits[bytepos] & |
(1 << (j % 8)) ? 0 : 0xffffff; |
color = pointer_bits[bytepos] & (1 << (j % 8)) |
? 0 : 0xffffff; |
if (pointer_x + j < screen.xres && pointer_y + |
i < screen.yres) |
i < screen.yres) |
putpixel(&viewports[0], pointer_x + j, |
pointer_y + i, color); |
pointer_y + i, color); |
} |
} |
pointer_shown = 1; |
1101,7 → 1106,7 |
handled = 0; |
} |
if (handled) |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
return handled; |
} |
1152,7 → 1157,7 |
} |
if (handled) |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
return handled; |
} |
1174,11 → 1179,11 |
viewport_t *vport = &viewports[0]; |
if (client_connected) { |
ipc_answer_0(iid, ELIMIT); |
ipc_answer_fast(iid, ELIMIT, 0,0); |
return; |
} |
client_connected = 1; |
ipc_answer_0(iid, EOK); /* Accept connection */ |
ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */ |
while (1) { |
if (vport->cursor_active || anims_enabled) |
1217,10 → 1222,10 |
retval = EINVAL; |
break; |
} |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, 0, 0, 0); |
draw_char(vport, c, row, col, vport->style, |
IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR); |
IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR); |
continue; /* msg already answered */ |
case FB_CLEAR: |
clear_port(vport); |
1247,7 → 1252,7 |
retval = 0; |
break; |
case FB_GET_CSIZE: |
ipc_answer_2(callid, EOK, vport->rows, vport->cols); |
ipc_answer_fast(callid, 0, vport->rows, vport->cols); |
continue; |
case FB_SCROLL: |
i = IPC_GET_ARG1(call); |
1269,17 → 1274,17 |
retval = EINVAL; |
break; |
} |
if (!viewports[i].initialized ) { |
if (! viewports[i].initialized ) { |
retval = EADDRNOTAVAIL; |
break; |
} |
viewports[i].dboffset = 0; |
if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata) |
viewports[i].dbdata = |
malloc(screen.pixelbytes * |
viewports[i].width * viewports[i].height); |
viewports[i].dbdata = malloc(screen.pixelbytes |
* viewports[i].width * |
viewports[i].height); |
else if (IPC_GET_ARG2(call) == 0 && |
viewports[i].dbdata) { |
viewports[i].dbdata) { |
free(viewports[i].dbdata); |
viewports[i].dbdata = NULL; |
} |
1303,9 → 1308,9 |
break; |
case FB_VIEWPORT_CREATE: |
retval = viewport_create(IPC_GET_ARG1(call) >> 16, |
IPC_GET_ARG1(call) & 0xffff, |
IPC_GET_ARG2(call) >> 16, |
IPC_GET_ARG2(call) & 0xffff); |
IPC_GET_ARG1(call) & 0xffff, |
IPC_GET_ARG2(call) >> 16, |
IPC_GET_ARG2(call) & 0xffff); |
break; |
case FB_VIEWPORT_DELETE: |
i = IPC_GET_ARG1(call); |
1330,7 → 1335,7 |
retval = 0; |
break; |
case FB_GET_RESOLUTION: |
ipc_answer_2(callid, EOK, screen.xres, screen.yres); |
ipc_answer_fast(callid, 0, screen.xres,screen.yres); |
continue; |
case FB_POINTER_MOVE: |
pointer_enabled = 1; |
1340,7 → 1345,7 |
default: |
retval = ENOENT; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid,retval, 0, 0); |
} |
} |
1370,10 → 1375,10 |
fb_addr = as_get_mappable_page(asz); |
physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >> |
PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE); |
PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE); |
if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual, |
fb_invert_colors)) |
fb_invert_colors)) |
return 0; |
return -1; |
/trunk/uspace/srv/fb/main.c |
---|
44,7 → 44,7 |
void *dest; |
dest = as_get_mappable_page(IPC_GET_ARG2(*call)); |
if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) { |
if (ipc_answer_fast(callid, 0, (sysarg_t) dest, 0) == 0) { |
if (*area) |
as_area_destroy(*area); |
*area = dest; |
/trunk/uspace/srv/fb/ega.c |
---|
82,7 → 82,7 |
{ |
int i; |
for (i = 0; i < scr_width * scr_height; i++) { |
for (i = 0; i < scr_width*scr_height; i++) { |
scr_addr[i * 2] = ' '; |
scr_addr[i * 2 + 1] = style; |
} |
125,13 → 125,13 |
int i; |
if (rows > 0) { |
memcpy(scr_addr, ((char *) scr_addr) + rows * scr_width * 2, |
scr_width * scr_height * 2 - rows * scr_width * 2); |
scr_width * scr_height * 2 - rows * scr_width * 2); |
for (i = 0; i < rows * scr_width; i++) |
(((short *) scr_addr) + scr_width * scr_height - rows * |
scr_width)[i] = ((style << 8) + ' '); |
scr_width)[i] = ((style << 8) + ' '); |
} else if (rows < 0) { |
memcpy(((char *)scr_addr) - rows * scr_width * 2, scr_addr, |
scr_width * scr_height * 2 + rows * scr_width * 2); |
scr_width * scr_height * 2 + rows * scr_width * 2); |
for (i = 0; i < -rows * scr_width; i++) |
((short *)scr_addr)[i] = ((style << 8 ) + ' '); |
} |
152,7 → 152,7 |
for (i = 0; i < scr_width * scr_height; i++) { |
scr_addr[i * 2] = data[i].character; |
scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color, |
data[i].style.bg_color); |
data[i].style.bg_color); |
} |
} |
160,7 → 160,7 |
{ |
int i; |
for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++) |
for (i=0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++) |
; |
if (i == MAX_SAVED_SCREENS) |
return EINVAL; |
175,7 → 175,7 |
{ |
if (saved_screens[i].data) |
memcpy(scr_addr, saved_screens[i].data, 2 * scr_width * |
scr_height); |
scr_height); |
else |
return EINVAL; |
return i; |
195,11 → 195,11 |
int i; |
if (client_connected) { |
ipc_answer_0(iid, ELIMIT); |
ipc_answer_fast(iid, ELIMIT, 0,0); |
return; |
} |
client_connected = 1; |
ipc_answer_0(iid, EOK); /* Accept connection */ |
ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */ |
while (1) { |
callid = async_get_call(&call); |
206,15 → 206,15 |
switch (IPC_GET_METHOD(call)) { |
case IPC_M_PHONE_HUNGUP: |
client_connected = 0; |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, 0, 0, 0); |
return; /* Exit thread */ |
case IPC_M_AS_AREA_SEND: |
/* We accept one area for data interchange */ |
intersize = IPC_GET_ARG2(call); |
if (intersize >= scr_width * scr_height * |
sizeof(*interbuf)) { |
receive_comm_area(callid, &call, |
(void *) &interbuf); |
sizeof(*interbuf)) { |
receive_comm_area(callid, &call, (void *) |
&interbuf); |
continue; |
} |
retval = EINVAL; |
228,7 → 228,7 |
retval = 0; |
break; |
case FB_GET_CSIZE: |
ipc_answer_2(callid, EOK, scr_height, scr_width); |
ipc_answer_fast(callid, 0, scr_height, scr_width); |
continue; |
case FB_CLEAR: |
clrscr(); |
300,7 → 300,7 |
default: |
retval = ENOENT; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |
318,7 → 318,7 |
scr_addr = as_get_mappable_page(sz); |
physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >> |
PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE); |
PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE); |
async_set_client_connection(ega_client_connection); |
/trunk/uspace/srv/fb/sysio.c |
---|
117,69 → 117,69 |
int i; |
if (client_connected) { |
ipc_answer_0(iid, ELIMIT); |
ipc_answer_fast(iid, ELIMIT, 0,0); |
return; |
} |
client_connected = 1; |
ipc_answer_0(iid, EOK); /* Accept connection */ |
ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */ |
while (1) { |
callid = async_get_call(&call); |
switch (IPC_GET_METHOD(call)) { |
case IPC_M_PHONE_HUNGUP: |
client_connected = 0; |
ipc_answer_0(callid, EOK); |
return; /* Exit thread */ |
case FB_PUTCHAR: |
c = IPC_GET_ARG1(call); |
newrow = IPC_GET_ARG2(call); |
newcol = IPC_GET_ARG3(call); |
if ((lastcol != newcol) || (lastrow != newrow)) |
case IPC_M_PHONE_HUNGUP: |
client_connected = 0; |
ipc_answer_fast(callid, 0, 0, 0); |
return; /* Exit thread */ |
case FB_PUTCHAR: |
c = IPC_GET_ARG1(call); |
newrow = IPC_GET_ARG2(call); |
newcol = IPC_GET_ARG3(call); |
if ((lastcol != newcol) || (lastrow != newrow)) |
curs_goto(newrow, newcol); |
lastcol = newcol + 1; |
lastrow = newrow; |
sysput(c); |
retval = 0; |
break; |
case FB_CURSOR_GOTO: |
newrow = IPC_GET_ARG1(call); |
newcol = IPC_GET_ARG2(call); |
curs_goto(newrow, newcol); |
lastcol = newcol + 1; |
lastrow = newrow; |
sysput(c); |
retval = 0; |
break; |
case FB_CURSOR_GOTO: |
newrow = IPC_GET_ARG1(call); |
newcol = IPC_GET_ARG2(call); |
curs_goto(newrow, newcol); |
lastrow = newrow; |
lastcol = newcol; |
retval = 0; |
break; |
case FB_GET_CSIZE: |
ipc_answer_2(callid, EOK, HEIGHT, WIDTH); |
continue; |
case FB_CLEAR: |
clrscr(); |
retval = 0; |
break; |
case FB_SET_STYLE: |
fgcolor = IPC_GET_ARG1(call); |
bgcolor = IPC_GET_ARG2(call); |
if (fgcolor < bgcolor) |
set_style(0); |
else |
set_style(7); |
retval = 0; |
break; |
case FB_SCROLL: |
i = IPC_GET_ARG1(call); |
if ((i > HEIGHT) || (i < -HEIGHT)) { |
retval = EINVAL; |
lastrow = newrow; |
lastcol = newcol; |
retval = 0; |
break; |
} |
scroll(i); |
curs_goto(lastrow, lastcol); |
retval = 0; |
break; |
default: |
retval = ENOENT; |
case FB_GET_CSIZE: |
ipc_answer_fast(callid, 0, HEIGHT, WIDTH); |
continue; |
case FB_CLEAR: |
clrscr(); |
retval = 0; |
break; |
case FB_SET_STYLE: |
fgcolor = IPC_GET_ARG1(call); |
bgcolor = IPC_GET_ARG2(call); |
if (fgcolor < bgcolor) |
set_style(0); |
else |
set_style(7); |
retval = 0; |
break; |
case FB_SCROLL: |
i = IPC_GET_ARG1(call); |
if ((i > HEIGHT) || (i < -HEIGHT)) { |
retval = EINVAL; |
break; |
} |
scroll(i); |
curs_goto(lastrow, lastcol); |
retval = 0; |
break; |
default: |
retval = ENOENT; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |
/trunk/uspace/srv/pci/pci.c |
---|
66,17 → 66,17 |
while (1) { |
ipc_call_t call; |
ipc_callid_t callid; |
ipcarg_t retval = ENOTSUP; |
callid = ipc_wait_for_call(&call); |
switch(IPC_GET_METHOD(call)) { |
case IPC_M_CONNECT_ME_TO: |
retval = EOK; |
IPC_SET_RETVAL(call, 0); |
break; |
} |
ipc_answer_0(callid, retval); |
printf("%s: received call from %lX\n", NAME, |
call.in_phone_hash); |
if (! (callid & IPC_CALLID_NOTIFICATION)) { |
ipc_answer(callid, &call); |
} |
printf("%s: received call from %lX\n", NAME, call.in_phone_hash); |
} |
pci_cleanup(pacc); |
/trunk/uspace/srv/rd/rd.c |
---|
90,7 → 90,7 |
* Hang up the phone if we cannot proceed any further. |
* This is the answer to the call that opened the connection. |
*/ |
ipc_answer_0(iid, EHANGUP); |
ipc_answer_fast(iid, EHANGUP, 0, 0); |
return; |
} else { |
/* |
97,7 → 97,7 |
* Answer the first IPC_M_CONNECT_ME_TO call. |
* Return supported block size as ARG1. |
*/ |
ipc_answer_1(iid, EOK, BLOCK_SIZE); |
ipc_answer_fast(iid, EOK, BLOCK_SIZE, 0); |
} |
/* |
110,13 → 110,13 |
* The client sends an as_area that can absorb the whole |
* block. |
*/ |
ipc_answer_1(callid, EOK, (uintptr_t) fs_va); |
ipc_answer_fast(callid, EOK, (uintptr_t) fs_va, 0); |
} else { |
/* |
* The client offered as_area too small. |
* Close the connection. |
*/ |
ipc_answer_0(callid, EHANGUP); |
ipc_answer_fast(callid, EHANGUP, 0, 0); |
return; |
} |
} else { |
125,7 → 125,7 |
* At this point we can't handle protocol variations. |
* Close the connection. |
*/ |
ipc_answer_0(callid, EHANGUP); |
ipc_answer_fast(callid, EHANGUP, 0, 0); |
return; |
} |
137,7 → 137,7 |
* The other side has hung up. |
* Answer the message and exit the fibril. |
*/ |
ipc_answer_0(callid, EOK); |
ipc_answer_fast(callid, EOK, 0, 0); |
return; |
case RD_READ_BLOCK: |
offset = IPC_GET_ARG1(call); |
177,7 → 177,7 |
retval = EINVAL; |
break; |
} |
ipc_answer_0(callid, retval); |
ipc_answer_fast(callid, retval, 0, 0); |
} |
} |