1
0
kolibrios/programs/develop/libraries/framework/trunk/libIPC/ipc.c
vkos 42f40b69fb 1) First commit of libIPC
2) Kobra (0.1.1) uses libIPC, compilation changed, files with non-kobra functions moved to framework



git-svn-id: svn://kolibrios.org@1286 a494cfbc-eb01-0410-851d-a64ba20cac60
2009-11-25 18:23:48 +00:00

140 lines
3.6 KiB
C

/***************************************************************************************************
* Copyright (C) Vasiliy Kosenko (vkos), 2009 *
* This program is free software: you can redistribute it and/or modify it under the terms of the *
* GNU General Public License as published by the Free Software Foundation, either version 3 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; *
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See *
* the GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License along with this program. *
* If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************************************/
#include <ipc.h>
#include <malloc.h>
#include <kolibri.h>
#include <defs.h>
#include <stdlib.h>
/*
* High level IPC functions
*/
IPCArea *ipc_area = NULL;
int IPCInit(void){
ipc_area = malloc(IPC_BUFFER_SIZE);
if (!ipc_area) {
return IPC_NO_MEMORY;
}
return kolibri_IPC_init(ipc_area, IPC_BUFFER_SIZE);
}
int IPCSend(int tid, void *message, int length){
int err_count = IPC_MAX_ERRORS;
int err;
while (--err_count) {
if (!(err = kolibri_IPC_send(tid, message, length)) || err == IPC_NO_AREA || err == IPC_NO_TID) {
return err;
}
}
return err;
}
bool IPCCheck(void){
return IPCCheckWait(0);
}
bool IPCCheckWait(int time){
int result = false;
int emask = kolibri_event_get_mask();
kolibri_event_set_mask(KOLIBRI_EVENT_IPC_MASK);
result = kolibri_event_wait(time);
kolibri_event_set_mask(emask);
return result;
}
Message *IPCGetNextMessage(void){
return IPCWaitMessage(0);
}
Message *IPCWaitMessage(int time){
if (IPCCheckWait(time)){
Message *msg_ret, *msg = kolibri_IPC_get_next_message();
msg_ret = malloc(sizeof(Message)+msg->length);
if (!msg_ret) {
return NULL;
}
IPCLock();
memcpy(msg_ret, msg, sizeof(Message)+msg->length);
ipc_area->size -= sizeof(Message)+msg->length;
memcpy(msg, msg+sizeof(Message)+msg->length, ipc_area->size);
IPCUnlock();
return msg_ret;
} else {
return NULL;
}
}
/*
* Kolibri IPC functions & data
*/
kolibri_IPC_area_t *kolibri_ipc_area;
int kolibri_IPC_set_area(void *area, int size){
int result;
asm("int $0x40":"=a"(result):"a"(60),"b"(1),"c"(area),"d"(size));
return result;
}
int kolibri_IPC_send(int tid, void *msg, int length){
int result;
asm("movl %5, %%esi\nint $0x40":"=a"(result):"a"(60),"b"(2),"c"(tid),"d"(msg),"g"(length));
return result;
}
void kolibri_IPC_unlock(){
kolibri_ipc_area->lock = 0;
}
void kolibri_IPC_lock(){
kolibri_ipc_area->lock = 1;
}
int kolibri_IPC_init(void *area, int size){
kolibri_ipc_area = (kolibri_IPC_area_t *)area;
kolibri_ipc_area->size = 8;
return kolibri_IPC_set_area(area, size);
}
kolibri_IPC_message_t *kolibri_IPC_get_next_message(){
kolibri_IPC_lock();
return (kolibri_IPC_message_t *)((char *)kolibri_ipc_area+sizeof(kolibri_IPC_area_t));
}
void IPCLock(void){
kolibri_IPC_lock();
}
void IPCUnlock(void){
kolibri_IPC_unlock();
}
// void kolibri_IPC_clear_buff(){
// kolibri_ipc_area->size = 8;
// kolibri_IPC_unlock();
// }