Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 1027 → Rev 1026

/kernel/trunk/generic/include/syscall/syscall.h
40,7 → 40,6
SYS_IPC_ANSWER_FAST,
SYS_IPC_ANSWER,
SYS_IPC_WAIT,
SYS_IPC_CONNECT_TO_ME,
SYSCALL_END
} syscall_t;
 
/kernel/trunk/generic/include/ipc/sysipc.h
File deleted
/kernel/trunk/generic/include/ipc/ipc.h
68,37 → 68,6
/* Well known phone descriptors */
#define PHONE_NS 0
 
/* System-specific methods - only through special syscalls
* These methods have special behaviour
*/
#define IPC_M_IAMCONNECTING 0
/** Protocol for CONNECT - TO - ME
*
* Calling process asks the callee to create a callback connection,
* so that it can start initiating new messages.
*
* The protocol for negotiating is as follows:
* - sys_connecttome - sends a message IPC_M_CONNECTTOME
* - sys_wait_for_call - upon receipt tries to allocate new phone
* - if it fails, responds with ELIMIT
* - passes call to userspace. If userspace
* responds with error, phone is deallocated and
* error is sent back to caller. Otherwise
* the call is accepted and the response is sent back.
* - the allocated phoneid is passed to userspace as
* ARG3 of the call.
* - the caller obtains taskid of the called thread
*/
#define IPC_M_CONNECTTOME 1
#define IPC_M_CONNECTMETO 2
 
 
/* Well-known methods */
#define IPC_M_FIRST_USER 512
#define IPC_M_PING 512
/* User methods */
#define FIRST_USER_METHOD 1024
 
#ifdef KERNEL
 
#include <synch/mutex.h>
107,8 → 76,8
 
#define IPC_MAX_PHONES 16
 
 
typedef struct answerbox answerbox_t;
typedef __native ipc_data_t[IPC_CALL_LEN];
 
typedef struct {
link_t list;
115,14 → 84,12
answerbox_t *callerbox;
int flags;
task_t *sender;
ipc_data_t data;
__native data[IPC_CALL_LEN];
} call_t;
 
struct answerbox {
SPINLOCK_DECLARE(lock);
 
task_t *task;
 
mutex_t mutex;
condvar_t cv;
 
/kernel/trunk/generic/include/ipc/ns.h
0,0 → 1,46
/*
* Copyright (C) 2006 Ondrej Palkovsky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
#ifndef __NS_H_
#define __NS_H_
 
/* NameService methods */
 
/** Ping name service */
#define NS_PING 1
 
 
#ifdef KERNEL
 
#include <ipc/ipc.h>
 
extern void ns_start(void);
 
#endif
 
#endif
/kernel/trunk/generic/include/errno.h
33,7 → 33,5
 
#define ENOENT -1 /* No such entry */
#define ENOMEM -2 /* Not enough memory */
#define ELIMIT -3 /* Limit exceeded */
#define EREFUSED -4 /* Connection refused */
 
#endif
/kernel/trunk/generic/src/syscall/syscall.c
31,11 → 31,11
#include <mm/as.h>
#include <print.h>
#include <putchar.h>
#include <ipc/ipc.h>
#include <errno.h>
#include <proc/task.h>
#include <arch.h>
#include <debug.h>
#include <ipc/sysipc.h>
 
static __native sys_ctl(void) {
printf("Thread finished\n");
56,7 → 56,193
return count;
}
 
static phone_t * get_phone(__native phoneid)
{
phone_t *phone;
 
if (phoneid >= IPC_MAX_PHONES)
return NULL;
 
phone = &TASK->phones[phoneid];
if (!phone->callee)
return NULL;
return phone;
}
 
/** Send a call over IPC, wait for reply, return to user
*
* @return Call identification, returns -1 on fatal error,
-2 on 'Too many async request, handle answers first
*/
static __native sys_ipc_call_sync_fast(__native phoneid, __native method,
__native arg1, __native *data)
{
call_t call;
phone_t *phone;
/* Special answerbox for synchronous messages */
 
phone = get_phone(phoneid);
if (!phone)
return IPC_CALLRET_FATAL;
 
ipc_call_init(&call);
IPC_SET_METHOD(call.data, method);
IPC_SET_ARG1(call.data, arg1);
ipc_call_sync(phone, &call);
 
copy_to_uspace(data, &call.data, sizeof(call.data));
 
return 0;
}
 
/** Synchronous IPC call allowing to send whole message */
static __native sys_ipc_call_sync(__native phoneid, __native *question,
__native *reply)
{
call_t call;
phone_t *phone;
/* Special answerbox for synchronous messages */
 
phone = get_phone(phoneid);
if (!phone)
return IPC_CALLRET_FATAL;
 
ipc_call_init(&call);
copy_from_uspace(&call.data, question, sizeof(call.data));
ipc_call_sync(phone, &call);
 
copy_to_uspace(reply, &call.data, sizeof(call.data));
 
return 0;
}
 
/** Check that the task did not exceed allowed limit
*
* @return 0 - Limit OK, -1 - limit exceeded
*/
static int check_call_limit(void)
{
if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
atomic_dec(&TASK->active_calls);
return -1;
}
return 0;
}
 
/** Send an asynchronous call over ipc
*
* @return Call identification, returns -1 on fatal error,
-2 on 'Too many async request, handle answers first
*/
static __native sys_ipc_call_async_fast(__native phoneid, __native method,
__native arg1, __native arg2)
{
call_t *call;
phone_t *phone;
 
phone = get_phone(phoneid);
if (!phone)
return IPC_CALLRET_FATAL;
 
if (check_call_limit())
return IPC_CALLRET_TEMPORARY;
 
call = ipc_call_alloc();
IPC_SET_METHOD(call->data, method);
IPC_SET_ARG1(call->data, arg1);
IPC_SET_ARG2(call->data, arg2);
 
ipc_call(phone, call);
 
return (__native) call;
}
 
/** Synchronous IPC call allowing to send whole message
*
* @return The same as sys_ipc_call_async
*/
static __native sys_ipc_call_async(__native phoneid, __native *data)
{
call_t *call;
phone_t *phone;
 
phone = get_phone(phoneid);
if (!phone)
return IPC_CALLRET_FATAL;
 
if (check_call_limit())
return IPC_CALLRET_TEMPORARY;
 
call = ipc_call_alloc();
copy_from_uspace(&call->data, data, sizeof(call->data));
ipc_call(phone, call);
 
return (__native) call;
}
 
 
/** Send IPC answer */
static __native sys_ipc_answer_fast(__native callid, __native retval,
__native arg1, __native arg2)
{
call_t *call;
 
/* Check that the user is not sending us answer callid */
ASSERT(! (callid & 1));
/* TODO: Check that the callid is in the dispatch table */
call = (call_t *) callid;
 
IPC_SET_RETVAL(call->data, retval);
IPC_SET_ARG1(call->data, arg1);
IPC_SET_ARG2(call->data, arg2);
 
ipc_answer(&TASK->answerbox, call);
return 0;
}
 
/** Send IPC answer */
static __native sys_ipc_answer(__native callid, __native *data)
{
call_t *call;
 
/* Check that the user is not sending us answer callid */
ASSERT(! (callid & 1));
/* TODO: Check that the callid is in the dispatch table */
call = (call_t *) callid;
copy_from_uspace(&call->data, data, sizeof(call->data));
ipc_answer(&TASK->answerbox, call);
 
return 0;
}
 
/** Wait for incoming ipc call or answer
*
* @param result
* @param flags
* @return Callid, if callid & 1, then the call is answer
*/
static __native sys_ipc_wait_for_call(__native *calldata, task_id_t *taskid,
__native flags)
{
call_t *call;
call = ipc_wait_for_call(&TASK->answerbox, flags);
 
copy_to_uspace(calldata, &call->data, sizeof(call->data));
 
if (call->flags & IPC_CALL_ANSWERED) {
ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
ipc_call_free(call);
atomic_dec(&TASK->active_calls);
return ((__native)call) | IPC_CALLID_ANSWERED;
}
copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
return (__native)call;
}
 
static __native sys_mremap(void *address, size_t size, unsigned long flags)
{
return as_remap(AS, (__address) address, size, 0);
72,6 → 258,5
sys_ipc_call_async,
sys_ipc_answer_fast,
sys_ipc_answer,
sys_ipc_wait_for_call,
sys_ipc_connect_to_me
sys_ipc_wait_for_call
};
/kernel/trunk/generic/src/ipc/sysipc.c
File deleted
/kernel/trunk/generic/src/ipc/ipc.c
71,7 → 71,6
{
call->callerbox = &TASK->answerbox;
call->flags = IPC_CALL_STATIC_ALLOC;
call->sender = TASK;
}
 
/** Deallocate call stracuture */
90,7 → 89,6
list_initialize(&box->calls);
list_initialize(&box->dispatched_calls);
list_initialize(&box->answers);
box->task = TASK;
}
 
/** Initialize phone structure and connect phone to naswerbox
/kernel/trunk/generic/src/ipc/ns.c
0,0 → 1,77
/*
* Copyright (C) 2006 Ondrej Palkovsky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
#include <ipc/ipc.h>
#include <ipc/ns.h>
#include <print.h>
#include <proc/thread.h>
#include <arch.h>
#include <panic.h>
 
static answerbox_t ns_answerbox;
 
/** */
static void ns_thread(void *data)
{
call_t *call;
 
printf("Name service started.\n");
while (1) {
call = ipc_wait_for_call(&ns_answerbox, 0);
switch (IPC_GET_METHOD(call->data)) {
case NS_PING:
printf("Ping - %X, %X\n", IPC_GET_ARG1(call->data),
IPC_GET_ARG2(call->data));
IPC_SET_RETVAL(call->data, 0);
IPC_SET_ARG1(call->data, 0xdeaddead);
IPC_SET_ARG2(call->data, 0xdeaddea2);
break;
default:
printf("Unsupported name service call.\n");
IPC_SET_RETVAL(call->data, -1);
}
ipc_answer(&ns_answerbox, call);
}
}
 
/** Name service initialization and start
*
* This must be started before any task that communicates with name service
*/
void ns_start(void)
{
thread_t *t;
 
ipc_answerbox_init(&ns_answerbox);
ipc_phone_0 = &ns_answerbox;
if ((t = thread_create(ns_thread, NULL, TASK, 0)))
thread_ready(t);
else
panic("thread_create/phonecompany");
}
/kernel/trunk/generic/src/main/kinit.c
45,6 → 45,7
#include <console/console.h>
#include <interrupt.h>
#include <console/kconsole.h>
#include <ipc/ns.h>
 
#ifdef CONFIG_SMP
#include <arch/smp/mps.h>
68,7 → 69,6
void kinit(void *arg)
{
thread_t *t;
task_t *utask;
 
interrupts_disable();
 
133,6 → 133,9
 
interrupts_enable();
 
/* Initialize name service */
ns_start();
 
if (config.init_size > 0) {
/*
* Create the first user task.
141,11 → 144,9
if (config.init_addr % FRAME_SIZE)
panic("config.init_addr is not frame aligned");
 
utask = task_run_program((void *)config.init_addr);
if (utask)
ipc_phone_0 = &utask->answerbox;
else
if (!task_run_program((void *)config.init_addr)) {
printf("Userspace not started.\n");
}
}
 
#ifdef CONFIG_TEST
/kernel/trunk/Makefile
135,7 → 135,7
generic/src/synch/waitq.c \
generic/src/smp/ipi.c \
generic/src/ipc/ipc.c \
generic/src/ipc/sysipc.c
generic/src/ipc/ns.c
 
## Test sources
#