michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Rename microkernel struct field 'Args' to 'args'.

Browse source 
Rename field 'Args' of the struct:
- 'k_proc' in the file include/microkernel/base_api.h
- 'k_args' in the file kernel/microkernel/include/micro_private_types.h

Change-Id: I5847a2f1e9c7dd34dea37857b4fadeb37ced489b
Signed-off-by: Yonattan Louise <yonattan.a.louise.mendoza@intel.com>
This commit is contained in:
Yonattan Louise 2015-08-24 10:48:18 -05:00 • committed by Anas Nashif
commit 13d583dc06
23 changed files with 441 additions and 441 deletions
Download patch file Download diff file Expand all files Collapse all files

6
arch/arm/core/task_abort.c
View file

@ -75,10 +75,10 @@ void _TaskAbort(void)
_task_ioctl(_k_current_task->id, taskAbortCode); _task_ioctl(_k_current_task->id, taskAbortCode);
} else { } else {
cmd_packet.Comm = _K_SVC_TASK_OP; cmd_packet.Comm = _K_SVC_TASK_OP;
cmd_packet.Args.g1.task = _k_current_task->id; cmd_packet.args.g1.task = _k_current_task->id;
cmd_packet.Args.g1.opt = taskAbortCode; cmd_packet.args.g1.opt = taskAbortCode;
cmd_packet.alloc = false; cmd_packet.alloc = false;
_k_current_task->Args = &cmd_packet; _k_current_task->args = &cmd_packet;
nano_isr_stack_push(&_k_command_stack, (uint32_t) &cmd_packet); nano_isr_stack_push(&_k_command_stack, (uint32_t) &cmd_packet);
_ScbPendsvSet(); _ScbPendsvSet();
} }

2
include/microkernel/base_api.h
View file

@ -116,7 +116,7 @@ struct k_task {
char *workspace; char *workspace;
int worksize; int worksize;
void (*fn_abort)(void); void (*fn_abort)(void);
struct k_args *Args; struct k_args *args;
}; };
struct _k_mbox_struct { struct _k_mbox_struct {

6
kernel/microkernel/include/micro_private_types.h
View file

@ -50,7 +50,7 @@ struct k_timer {
struct k_timer *prev; struct k_timer *prev;
int32_t duration; int32_t duration;
int32_t period; int32_t period;
struct k_args *Args; struct k_args *args;
}; };
/* Kernel server command codes */ /* Kernel server command codes */
@ -370,7 +370,7 @@ union k_args_args {
* The size of the k_args structure must be equivalent to ... * The size of the k_args structure must be equivalent to ...
* CMD_PKT_SIZE_IN_WORDS * sizeof(uint32_t) * CMD_PKT_SIZE_IN_WORDS * sizeof(uint32_t)
* To this end the entire structure is packed. This ensures that the compiler * To this end the entire structure is packed. This ensures that the compiler
* aligns 'Args' to a 4-byte boundary. If left unpacked, then some compilers * aligns 'args' to a 4-byte boundary. If left unpacked, then some compilers
* may provide an extra 4 bytes of padding to align it to an 8-byte boundary, * may provide an extra 4 bytes of padding to align it to an 8-byte boundary,
* thereby violating the previously stated equivalence. * thereby violating the previously stated equivalence.
*/ */
@ -393,7 +393,7 @@ struct k_args {
struct k_timer *timer; struct k_timer *timer;
int rcode; int rcode;
} Time; } Time;
K_ARGS_ARGS Args; K_ARGS_ARGS args;
} __packed; } __packed;
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */

2
kernel/microkernel/k_command_packet.c
View file

@ -103,6 +103,6 @@ cmdPkt_t *_cmd_pkt_get(
void _k_task_call(struct k_args *cmd_packet) void _k_task_call(struct k_args *cmd_packet)
{ {
cmd_packet->alloc = false; cmd_packet->alloc = false;
_k_current_task->Args = cmd_packet; _k_current_task->args = cmd_packet;
nano_task_stack_push(&_k_command_stack, (uint32_t)cmd_packet); nano_task_stack_push(&_k_command_stack, (uint32_t)cmd_packet);
} }

20
kernel/microkernel/k_event.c
View file

@ -48,11 +48,11 @@ extern struct evstr _k_event_list[];
*/ */
void _k_event_handler_set(struct k_args *A) void _k_event_handler_set(struct k_args *A)
{ {
kevent_t event = A->Args.e1.event; kevent_t event = A->args.e1.event;
struct evstr *E = _k_event_list + event; struct evstr *E = _k_event_list + event;
if (E->func != NULL) { if (E->func != NULL) {
if (likely(A->Args.e1.func == NULL)) { if (likely(A->args.e1.func == NULL)) {
/* uninstall handler */ /* uninstall handler */
E->func = NULL; E->func = NULL;
A->Time.rcode = RC_OK; A->Time.rcode = RC_OK;
@ -62,7 +62,7 @@ void _k_event_handler_set(struct k_args *A)
} }
} else { } else {
/* install handler */ /* install handler */
E->func = A->Args.e1.func; E->func = A->args.e1.func;
E->status = 0; E->status = 0;
A->Time.rcode = RC_OK; A->Time.rcode = RC_OK;
} }
@ -73,8 +73,8 @@ int task_event_handler_set(kevent_t event, kevent_handler_t handler)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_EVENT_HANDLER_SET; A.Comm = _K_SVC_EVENT_HANDLER_SET;
A.Args.e1.event = event; A.args.e1.event = event;
A.Args.e1.func = handler; A.args.e1.func = handler;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }
@ -87,7 +87,7 @@ int task_event_handler_set(kevent_t event, kevent_handler_t handler)
*/ */
void _k_event_test_timeout(struct k_args *A) void _k_event_test_timeout(struct k_args *A)
{ {
kevent_t event = A->Args.e1.event; kevent_t event = A->args.e1.event;
struct evstr *E = _k_event_list + event; struct evstr *E = _k_event_list + event;
FREETIMER(A->Time.timer); FREETIMER(A->Time.timer);
@ -104,7 +104,7 @@ void _k_event_test_timeout(struct k_args *A)
*/ */
void _k_event_test(struct k_args *A) void _k_event_test(struct k_args *A)
{ {
kevent_t event = A->Args.e1.event; kevent_t event = A->args.e1.event;
struct evstr *E = _k_event_list + event; struct evstr *E = _k_event_list + event;
if (E->status) { /* the next event can be received */ if (E->status) { /* the next event can be received */
@ -142,7 +142,7 @@ int _task_event_recv(kevent_t event, int32_t time)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_EVENT_TEST; A.Comm = _K_SVC_EVENT_TEST;
A.Args.e1.event = event; A.args.e1.event = event;
A.Time.ticks = time; A.Time.ticks = time;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
@ -199,7 +199,7 @@ void _k_do_event_signal(kevent_t event)
*/ */
void _k_event_signal(struct k_args *A) void _k_event_signal(struct k_args *A)
{ {
kevent_t event = A->Args.e1.event; kevent_t event = A->args.e1.event;
_k_do_event_signal(event); _k_do_event_signal(event);
A->Time.rcode = RC_OK; A->Time.rcode = RC_OK;
} }
@ -209,7 +209,7 @@ int task_event_send(kevent_t event)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_EVENT_SIGNAL; A.Comm = _K_SVC_EVENT_SIGNAL;
A.Args.e1.event = event; A.args.e1.event = event;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }

28
kernel/microkernel/k_fifo.c
View file

@ -96,16 +96,16 @@ void _k_fifo_enque_request(struct k_args *A)
int Qid, n, w; int Qid, n, w;
char *p, *q; /* Ski char->uint32_t ??? */ char *p, *q; /* Ski char->uint32_t ??? */
Qid = A->Args.q1.queue; Qid = A->args.q1.queue;
Q = (struct _k_fifo_struct *)Qid; Q = (struct _k_fifo_struct *)Qid;
w = OCTET_TO_SIZEOFUNIT(Q->Esize); w = OCTET_TO_SIZEOFUNIT(Q->Esize);
q = A->Args.q1.data; q = A->args.q1.data;
n = Q->Nused; n = Q->Nused;
if (n < Q->Nelms) { if (n < Q->Nelms) {
W = Q->Waiters; W = Q->Waiters;
if (W) { if (W) {
Q->Waiters = W->next; Q->Waiters = W->next;
p = W->Args.q1.data; p = W->args.q1.data;
memcpy(p, q, w); memcpy(p, q, w);
#ifdef CONFIG_SYS_CLOCK_EXISTS #ifdef CONFIG_SYS_CLOCK_EXISTS
@ -168,8 +168,8 @@ int _task_fifo_put(kfifo_t queue, /* FIFO queue */
A.Comm = _K_SVC_FIFO_ENQUE_REQUEST; A.Comm = _K_SVC_FIFO_ENQUE_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.q1.data = (char *)data; A.args.q1.data = (char *)data;
A.Args.q1.queue = queue; A.args.q1.queue = queue;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
@ -228,10 +228,10 @@ void _k_fifo_deque_request(struct k_args *A)
int Qid, n, w; int Qid, n, w;
char *p, *q; /* idem */ char *p, *q; /* idem */
Qid = A->Args.q1.queue; Qid = A->args.q1.queue;
Q = (struct _k_fifo_struct *)Qid; Q = (struct _k_fifo_struct *)Qid;
w = OCTET_TO_SIZEOFUNIT(Q->Esize); w = OCTET_TO_SIZEOFUNIT(Q->Esize);
p = A->Args.q1.data; p = A->args.q1.data;
n = Q->Nused; n = Q->Nused;
if (n) { if (n) {
q = Q->Deqp; q = Q->Deqp;
@ -247,7 +247,7 @@ void _k_fifo_deque_request(struct k_args *A)
if (W) { if (W) {
Q->Waiters = W->next; Q->Waiters = W->next;
p = Q->Enqp; p = Q->Enqp;
q = W->Args.q1.data; q = W->args.q1.data;
w = OCTET_TO_SIZEOFUNIT(Q->Esize); w = OCTET_TO_SIZEOFUNIT(Q->Esize);
memcpy(p, q, w); memcpy(p, q, w);
p = (char *)((int)p + w); p = (char *)((int)p + w);
@ -313,8 +313,8 @@ int _task_fifo_get(kfifo_t queue, void *data, int32_t time)
A.Comm = _K_SVC_FIFO_DEQUE_REQUEST; A.Comm = _K_SVC_FIFO_DEQUE_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.q1.data = (char *)data; A.args.q1.data = (char *)data;
A.Args.q1.queue = queue; A.args.q1.queue = queue;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
@ -333,9 +333,9 @@ void _k_fifo_ioctl(struct k_args *A)
struct _k_fifo_struct *Q; struct _k_fifo_struct *Q;
int Qid; int Qid;
Qid = A->Args.q1.queue; Qid = A->args.q1.queue;
Q = (struct _k_fifo_struct *)Qid; Q = (struct _k_fifo_struct *)Qid;
if (A->Args.q1.size) { if (A->args.q1.size) {
if (Q->Nused) { if (Q->Nused) {
struct k_args *X; struct k_args *X;
@ -378,8 +378,8 @@ int _task_fifo_ioctl(kfifo_t queue, int op)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_FIFO_IOCTL; A.Comm = _K_SVC_FIFO_IOCTL;
A.Args.q1.queue = queue; A.args.q1.queue = queue;
A.Args.q1.size = op; A.args.q1.size = op;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }

6
kernel/microkernel/k_idle.c
View file

@ -217,12 +217,12 @@ void _k_workload_get(struct k_args *P)
iret = 0; iret = 0;
} }
P->Args.u1.rval = iret; P->args.u1.rval = iret;
} }
#else #else
void _k_workload_get(struct k_args *P) void _k_workload_get(struct k_args *P)
{ {
P->Args.u1.rval = 0; P->args.u1.rval = 0;
} }
#endif /* CONFIG_WORKLOAD_MONITOR */ #endif /* CONFIG_WORKLOAD_MONITOR */
@ -250,7 +250,7 @@ int task_workload_get(void)
A.Comm = _K_SVC_WORKLOAD_GET; A.Comm = _K_SVC_WORKLOAD_GET;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Args.u1.rval; return A.args.u1.rval;
} }
/** /**

194
kernel/microkernel/k_mailbox.c
View file

@ -76,35 +76,35 @@ static void copy_packet(struct k_args **out, struct k_args *in)
*/ */
static int match(struct k_args *Reader, struct k_args *Writer) static int match(struct k_args *Reader, struct k_args *Writer)
{ {
if ((Reader->Args.m1.mess.tx_task == ANYTASK || if ((Reader->args.m1.mess.tx_task == ANYTASK ||
Reader->Args.m1.mess.tx_task == Writer->Args.m1.mess.tx_task) && Reader->args.m1.mess.tx_task == Writer->args.m1.mess.tx_task) &&
(Writer->Args.m1.mess.rx_task == ANYTASK || (Writer->args.m1.mess.rx_task == ANYTASK ||
Writer->Args.m1.mess.rx_task == Reader->Args.m1.mess.rx_task)) { Writer->args.m1.mess.rx_task == Reader->args.m1.mess.rx_task)) {
if (!ISASYNCMSG(&(Writer->Args.m1.mess))) { if (!ISASYNCMSG(&(Writer->args.m1.mess))) {
int32_t info; int32_t info;
Reader->Args.m1.mess.tx_task = Reader->args.m1.mess.tx_task =
Writer->Args.m1.mess.tx_task; Writer->args.m1.mess.tx_task;
Writer->Args.m1.mess.rx_task = Writer->args.m1.mess.rx_task =
Reader->Args.m1.mess.rx_task; Reader->args.m1.mess.rx_task;
info = Reader->Args.m1.mess.info; info = Reader->args.m1.mess.info;
Reader->Args.m1.mess.info = Writer->Args.m1.mess.info; Reader->args.m1.mess.info = Writer->args.m1.mess.info;
Writer->Args.m1.mess.info = info; Writer->args.m1.mess.info = info;
} else { } else {
Reader->Args.m1.mess.tx_task = Reader->args.m1.mess.tx_task =
Writer->Args.m1.mess.tx_task; Writer->args.m1.mess.tx_task;
Reader->Args.m1.mess.tx_data = NULL; Reader->args.m1.mess.tx_data = NULL;
Reader->Args.m1.mess.tx_block = Reader->args.m1.mess.tx_block =
Writer->Args.m1.mess.tx_block; Writer->args.m1.mess.tx_block;
Reader->Args.m1.mess.info = Writer->Args.m1.mess.info; Reader->args.m1.mess.info = Writer->args.m1.mess.info;
} }
if (Reader->Args.m1.mess.size > Writer->Args.m1.mess.size) { if (Reader->args.m1.mess.size > Writer->args.m1.mess.size) {
Reader->Args.m1.mess.size = Writer->Args.m1.mess.size; Reader->args.m1.mess.size = Writer->args.m1.mess.size;
} else { } else {
Writer->Args.m1.mess.size = Reader->Args.m1.mess.size; Writer->args.m1.mess.size = Reader->args.m1.mess.size;
} }
/* /*
@ -112,12 +112,12 @@ static int match(struct k_args *Reader, struct k_args *Writer)
* the -1 will not be returned when there is a match. * the -1 will not be returned when there is a match.
*/ */
__ASSERT_NO_MSG(Writer->Args.m1.mess.size == __ASSERT_NO_MSG(Writer->args.m1.mess.size ==
Reader->Args.m1.mess.size); Reader->args.m1.mess.size);
__ASSERT_NO_MSG((uint32_t)(-1) != Reader->Args.m1.mess.size); __ASSERT_NO_MSG((uint32_t)(-1) != Reader->args.m1.mess.size);
return Reader->Args.m1.mess.size; return Reader->args.m1.mess.size;
} }
return -1; /* There was no match */ return -1; /* There was no match */
@ -159,44 +159,44 @@ static bool prepare_transfer(struct k_args *move,
*/ */
move->priority = max(writer->priority, reader->priority); move->priority = max(writer->priority, reader->priority);
move->Ctxt.task = NULL; move->Ctxt.task = NULL;
move->Args.MovedReq.Action = move->args.MovedReq.Action =
(MovedAction)(MVDACT_SNDACK | MVDACT_RCVACK); (MovedAction)(MVDACT_SNDACK | MVDACT_RCVACK);
move->Args.MovedReq.iTotalSize = writer->Args.m1.mess.size; move->args.MovedReq.iTotalSize = writer->args.m1.mess.size;
move->Args.MovedReq.Extra.Setup.ContSnd = NULL; move->args.MovedReq.Extra.Setup.ContSnd = NULL;
move->Args.MovedReq.Extra.Setup.ContRcv = NULL; move->args.MovedReq.Extra.Setup.ContRcv = NULL;
/* reader: */ /* reader: */
if (reader->Args.m1.mess.rx_data == NULL) { if (reader->args.m1.mess.rx_data == NULL) {
all_data_present = false; all_data_present = false;
__ASSERT_NO_MSG(0 == reader->Args.m1.mess.extra __ASSERT_NO_MSG(0 == reader->args.m1.mess.extra
.transfer); /* == extra.sema */ .transfer); /* == extra.sema */
reader->Args.m1.mess.extra.transfer = move; reader->args.m1.mess.extra.transfer = move;
/*SENDARGS(reader); */ /*SENDARGS(reader); */
} else { } else {
move->Args.MovedReq.destination = move->args.MovedReq.destination =
reader->Args.m1.mess.rx_data; reader->args.m1.mess.rx_data;
writer->Args.m1.mess.rx_data = writer->args.m1.mess.rx_data =
reader->Args.m1.mess.rx_data; reader->args.m1.mess.rx_data;
/* chain the reader */ /* chain the reader */
move->Args.MovedReq.Extra.Setup.ContRcv = reader; move->args.MovedReq.Extra.Setup.ContRcv = reader;
} }
/* writer: */ /* writer: */
if (ISASYNCMSG(&(writer->Args.m1.mess))) { if (ISASYNCMSG(&(writer->args.m1.mess))) {
move->Args.MovedReq.source = move->args.MovedReq.source =
writer->Args.m1.mess.tx_block.pointer_to_data; writer->args.m1.mess.tx_block.pointer_to_data;
reader->Args.m1.mess.tx_block = reader->args.m1.mess.tx_block =
writer->Args.m1.mess.tx_block; writer->args.m1.mess.tx_block;
} else { } else {
__ASSERT_NO_MSG(NULL != writer->Args.m1.mess.tx_data); __ASSERT_NO_MSG(NULL != writer->args.m1.mess.tx_data);
move->Args.MovedReq.source = move->args.MovedReq.source =
writer->Args.m1.mess.tx_data; writer->args.m1.mess.tx_data;
reader->Args.m1.mess.tx_data = reader->args.m1.mess.tx_data =
writer->Args.m1.mess.tx_data; writer->args.m1.mess.tx_data;
} }
/* chain the writer */ /* chain the writer */
move->Args.MovedReq.Extra.Setup.ContSnd = writer; move->args.MovedReq.Extra.Setup.ContSnd = writer;
return all_data_present; return all_data_present;
} else { } else {
@ -212,8 +212,8 @@ static bool prepare_transfer(struct k_args *move,
*/ */
static void transfer(struct k_args *pMvdReq) static void transfer(struct k_args *pMvdReq)
{ {
__ASSERT_NO_MSG(NULL != pMvdReq->Args.MovedReq.source); __ASSERT_NO_MSG(NULL != pMvdReq->args.MovedReq.source);
__ASSERT_NO_MSG(NULL != pMvdReq->Args.MovedReq.destination); __ASSERT_NO_MSG(NULL != pMvdReq->args.MovedReq.destination);
_k_movedata_request(pMvdReq); _k_movedata_request(pMvdReq);
FREEARGS(pMvdReq); FREEARGS(pMvdReq);
@ -226,8 +226,8 @@ static void transfer(struct k_args *pMvdReq)
*/ */
void _k_mbox_send_ack(struct k_args *pCopyWriter) void _k_mbox_send_ack(struct k_args *pCopyWriter)
{ {
if (ISASYNCMSG(&(pCopyWriter->Args.m1.mess))) { if (ISASYNCMSG(&(pCopyWriter->args.m1.mess))) {
if (pCopyWriter->Args.m1.mess.extra.sema) { if (pCopyWriter->args.m1.mess.extra.sema) {
/* /*
* Signal the semaphore. Alternatively, this could * Signal the semaphore. Alternatively, this could
* be done using the continuation mechanism. * be done using the continuation mechanism.
@ -238,7 +238,7 @@ void _k_mbox_send_ack(struct k_args *pCopyWriter)
memset(&A, 0xfd, sizeof(struct k_args)); memset(&A, 0xfd, sizeof(struct k_args));
#endif #endif
A.Comm = _K_SVC_SEM_SIGNAL; A.Comm = _K_SVC_SEM_SIGNAL;
A.Args.s1.sema = pCopyWriter->Args.m1.mess.extra.sema; A.args.s1.sema = pCopyWriter->args.m1.mess.extra.sema;
_k_sem_signal(&A); _k_sem_signal(&A);
} }
@ -248,22 +248,22 @@ void _k_mbox_send_ack(struct k_args *pCopyWriter)
*/ */
if ((uint32_t)(-1) != if ((uint32_t)(-1) !=
pCopyWriter->Args.m1.mess.tx_block.pool_id) { pCopyWriter->args.m1.mess.tx_block.pool_id) {
/* /*
* special value to tell if block should be * special value to tell if block should be
* freed or not * freed or not
*/ */
pCopyWriter->Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE; pCopyWriter->Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE;
pCopyWriter->Args.p1.pool_id = pCopyWriter->args.p1.pool_id =
pCopyWriter->Args.m1.mess.tx_block.pool_id; pCopyWriter->args.m1.mess.tx_block.pool_id;
pCopyWriter->Args.p1.rep_poolptr = pCopyWriter->args.p1.rep_poolptr =
pCopyWriter->Args.m1.mess.tx_block pCopyWriter->args.m1.mess.tx_block
.address_in_pool; .address_in_pool;
pCopyWriter->Args.p1.rep_dataptr = pCopyWriter->args.p1.rep_dataptr =
pCopyWriter->Args.m1.mess.tx_block pCopyWriter->args.m1.mess.tx_block
.pointer_to_data; .pointer_to_data;
pCopyWriter->Args.p1.req_size = pCopyWriter->args.p1.req_size =
pCopyWriter->Args.m1.mess.tx_block.req_size; pCopyWriter->args.m1.mess.tx_block.req_size;
SENDARGS(pCopyWriter); SENDARGS(pCopyWriter);
return; return;
} else { } else {
@ -282,7 +282,7 @@ void _k_mbox_send_ack(struct k_args *pCopyWriter)
Starter = pCopyWriter->Ctxt.args; Starter = pCopyWriter->Ctxt.args;
Starter->Time.rcode = pCopyWriter->Time.rcode; Starter->Time.rcode = pCopyWriter->Time.rcode;
Starter->Args.m1.mess = pCopyWriter->Args.m1.mess; Starter->args.m1.mess = pCopyWriter->args.m1.mess;
_k_state_bit_reset(Starter->Ctxt.task, TF_SEND | TF_SENDDATA); _k_state_bit_reset(Starter->Ctxt.task, TF_SEND | TF_SENDDATA);
FREEARGS(pCopyWriter); FREEARGS(pCopyWriter);
@ -312,14 +312,14 @@ void _k_mbox_send_reply(struct k_args *pCopyWriter)
*/ */
void _k_mbox_send_request(struct k_args *Writer) void _k_mbox_send_request(struct k_args *Writer)
{ {
kmbox_t MailBoxId = Writer->Args.m1.mess.mailbox; kmbox_t MailBoxId = Writer->args.m1.mess.mailbox;
struct _k_mbox_struct *MailBox; struct _k_mbox_struct *MailBox;
struct k_args *CopyReader; struct k_args *CopyReader;
struct k_args *CopyWriter; struct k_args *CopyWriter;
struct k_args *temp; struct k_args *temp;
bool bAsync; bool bAsync;
bAsync = ISASYNCMSG(&Writer->Args.m1.mess); bAsync = ISASYNCMSG(&Writer->args.m1.mess);
struct k_task *sender = NULL; struct k_task *sender = NULL;
@ -498,11 +498,11 @@ int _task_mbox_put(kmbox_t mbox,
A.priority = prio; A.priority = prio;
A.Comm = _K_SVC_MBOX_SEND_REQUEST; A.Comm = _K_SVC_MBOX_SEND_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.m1.mess = *M; A.args.m1.mess = *M;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
*M = A.Args.m1.mess; *M = A.args.m1.mess;
return A.Time.rcode; return A.Time.rcode;
} }
@ -527,7 +527,7 @@ void _k_mbox_receive_ack(struct k_args *pCopyReader)
Starter->Time.rcode = pCopyReader->Time.rcode; Starter->Time.rcode = pCopyReader->Time.rcode;
/* And copy the message information from the received packet. */ /* And copy the message information from the received packet. */
Starter->Args.m1.mess = pCopyReader->Args.m1.mess; Starter->args.m1.mess = pCopyReader->args.m1.mess;
/* Reschedule the sender task */ /* Reschedule the sender task */
_k_state_bit_reset(Starter->Ctxt.task, TF_RECV | TF_RECVDATA); _k_state_bit_reset(Starter->Ctxt.task, TF_RECV | TF_RECVDATA);
@ -558,7 +558,7 @@ void _k_mbox_receive_reply(struct k_args *pCopyReader)
*/ */
void _k_mbox_receive_request(struct k_args *Reader) void _k_mbox_receive_request(struct k_args *Reader)
{ {
kmbox_t MailBoxId = Reader->Args.m1.mess.mailbox; kmbox_t MailBoxId = Reader->args.m1.mess.mailbox;
struct _k_mbox_struct *MailBox; struct _k_mbox_struct *MailBox;
struct k_args *CopyWriter; struct k_args *CopyWriter;
struct k_args *temp; struct k_args *temp;
@ -695,10 +695,10 @@ int _task_mbox_get(kmbox_t mbox,
A.priority = _k_current_task->priority; A.priority = _k_current_task->priority;
A.Comm = _K_SVC_MBOX_RECEIVE_REQUEST; A.Comm = _K_SVC_MBOX_RECEIVE_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.m1.mess = *M; A.args.m1.mess = *M;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
*M = A.Args.m1.mess; *M = A.args.m1.mess;
return A.Time.rcode; return A.Time.rcode;
} }
@ -730,7 +730,7 @@ void _task_mbox_block_put(kmbox_t mbox,
#endif #endif
A.priority = prio; A.priority = prio;
A.Comm = _K_SVC_MBOX_SEND_REQUEST; A.Comm = _K_SVC_MBOX_SEND_REQUEST;
A.Args.m1.mess = *M; A.args.m1.mess = *M;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -753,26 +753,26 @@ void _k_mbox_receive_data(struct k_args *Starter)
memcpy(CopyStarter, Starter, sizeof(struct k_args)); memcpy(CopyStarter, Starter, sizeof(struct k_args));
CopyStarter->Ctxt.args = Starter; CopyStarter->Ctxt.args = Starter;
MoveD = CopyStarter->Args.m1.mess.extra.transfer; MoveD = CopyStarter->args.m1.mess.extra.transfer;
CopyStarter->Comm = _K_SVC_MBOX_RECEIVE_ACK; CopyStarter->Comm = _K_SVC_MBOX_RECEIVE_ACK;
CopyStarter->Time.rcode = RC_OK; CopyStarter->Time.rcode = RC_OK;
MoveD->Args.MovedReq.Extra.Setup.ContRcv = CopyStarter; MoveD->args.MovedReq.Extra.Setup.ContRcv = CopyStarter;
CopyStarter->next = NULL; CopyStarter->next = NULL;
MoveD->Args.MovedReq.destination = CopyStarter->Args.m1.mess.rx_data; MoveD->args.MovedReq.destination = CopyStarter->args.m1.mess.rx_data;
MoveD->Args.MovedReq.iTotalSize = CopyStarter->Args.m1.mess.size; MoveD->args.MovedReq.iTotalSize = CopyStarter->args.m1.mess.size;
Writer = MoveD->Args.MovedReq.Extra.Setup.ContSnd; Writer = MoveD->args.MovedReq.Extra.Setup.ContSnd;
if (Writer != NULL) { if (Writer != NULL) {
if (ISASYNCMSG(&(Writer->Args.m1.mess))) { if (ISASYNCMSG(&(Writer->args.m1.mess))) {
CopyStarter->Args.m1.mess.tx_block = CopyStarter->args.m1.mess.tx_block =
Writer->Args.m1.mess.tx_block; Writer->args.m1.mess.tx_block;
} else { } else {
Writer->Args.m1.mess.rx_data = Writer->args.m1.mess.rx_data =
CopyStarter->Args.m1.mess.rx_data; CopyStarter->args.m1.mess.rx_data;
CopyStarter->Args.m1.mess.tx_data = CopyStarter->args.m1.mess.tx_data =
Writer->Args.m1.mess.tx_data; Writer->args.m1.mess.tx_data;
} }
transfer(MoveD); /* and MoveD will be cleared as well */ transfer(MoveD); /* and MoveD will be cleared as well */
} }
@ -792,7 +792,7 @@ void _task_mbox_data_get(struct k_msg *M)
return; return;
} }
A.Args.m1.mess = *M; A.args.m1.mess = *M;
A.Comm = _K_SVC_MBOX_RECEIVE_DATA; A.Comm = _K_SVC_MBOX_RECEIVE_DATA;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
@ -840,11 +840,11 @@ int _task_mbox_data_block_get(struct k_msg *message,
* SEND_ACK is processed, change its [pool_id] to -1. * SEND_ACK is processed, change its [pool_id] to -1.
*/ */
Writer = MoveD->Args.MovedReq.Extra.Setup.ContSnd; Writer = MoveD->args.MovedReq.Extra.Setup.ContSnd;
__ASSERT_NO_MSG(NULL != Writer); __ASSERT_NO_MSG(NULL != Writer);
__ASSERT_NO_MSG(NULL == Writer->next); __ASSERT_NO_MSG(NULL == Writer->next);
Writer->Args.m1.mess.tx_block.pool_id = (uint32_t)(-1); Writer->args.m1.mess.tx_block.pool_id = (uint32_t)(-1);
nano_task_stack_push(&_k_command_stack, (uint32_t)Writer); nano_task_stack_push(&_k_command_stack, (uint32_t)Writer);
#ifdef ACTIV_ASSERTS #ifdef ACTIV_ASSERTS
@ -855,7 +855,7 @@ int _task_mbox_data_block_get(struct k_msg *message,
* for continuation on receive. * for continuation on receive.
*/ */
Dummy = MoveD->Args.MovedReq.Extra.Setup.ContRcv; Dummy = MoveD->args.MovedReq.Extra.Setup.ContRcv;
__ASSERT_NO_MSG(NULL == Dummy); __ASSERT_NO_MSG(NULL == Dummy);
#endif #endif
@ -883,7 +883,7 @@ int _task_mbox_data_block_get(struct k_msg *message,
*/ */
struct k_args A; struct k_args A;
A.Args.m1.mess = *message; A.args.m1.mess = *message;
A.Comm = _K_SVC_MBOX_RECEIVE_DATA; A.Comm = _K_SVC_MBOX_RECEIVE_DATA;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
@ -908,21 +908,21 @@ void _k_mbox_send_data(struct k_args *Starter)
memcpy(CopyStarter, Starter, sizeof(struct k_args)); memcpy(CopyStarter, Starter, sizeof(struct k_args));
CopyStarter->Ctxt.args = Starter; CopyStarter->Ctxt.args = Starter;
MoveD = CopyStarter->Args.m1.mess.extra.transfer; MoveD = CopyStarter->args.m1.mess.extra.transfer;
CopyStarter->Time.rcode = RC_OK; CopyStarter->Time.rcode = RC_OK;
CopyStarter->Comm = _K_SVC_MBOX_SEND_ACK; CopyStarter->Comm = _K_SVC_MBOX_SEND_ACK;
MoveD->Args.MovedReq.Extra.Setup.ContSnd = CopyStarter; MoveD->args.MovedReq.Extra.Setup.ContSnd = CopyStarter;
CopyStarter->next = NULL; CopyStarter->next = NULL;
MoveD->Args.MovedReq.source = CopyStarter->Args.m1.mess.rx_data; MoveD->args.MovedReq.source = CopyStarter->args.m1.mess.rx_data;
Reader = MoveD->Args.MovedReq.Extra.Setup.ContRcv; Reader = MoveD->args.MovedReq.Extra.Setup.ContRcv;
if (Reader != NULL) { if (Reader != NULL) {
Reader->Args.m1.mess.rx_data = Reader->args.m1.mess.rx_data =
CopyStarter->Args.m1.mess.rx_data; CopyStarter->args.m1.mess.rx_data;
CopyStarter->Args.m1.mess.tx_data = CopyStarter->args.m1.mess.tx_data =
Reader->Args.m1.mess.tx_data; Reader->args.m1.mess.tx_data;
transfer(MoveD); /* and MoveD will be cleared as well */ transfer(MoveD); /* and MoveD will be cleared as well */
} }

24
kernel/microkernel/k_memory_map.c
View file

@ -103,10 +103,10 @@ void _k_mem_map_alloc_timeout(struct k_args *A)
void _k_mem_map_alloc(struct k_args *A) void _k_mem_map_alloc(struct k_args *A)
{ {
struct _k_mem_map_struct *M = struct _k_mem_map_struct *M =
(struct _k_mem_map_struct *)(A->Args.a1.mmap); (struct _k_mem_map_struct *)(A->args.a1.mmap);
if (M->Free != NULL) { if (M->Free != NULL) {
*(A->Args.a1.mptr) = M->Free; *(A->args.a1.mptr) = M->Free;
M->Free = *(char **)(M->Free); M->Free = *(char **)(M->Free);
M->Nused++; M->Nused++;
@ -120,7 +120,7 @@ void _k_mem_map_alloc(struct k_args *A)
return; return;
} }
*(A->Args.a1.mptr) = NULL; *(A->args.a1.mptr) = NULL;
if (likely(A->Time.ticks != TICKS_NONE)) { if (likely(A->Time.ticks != TICKS_NONE)) {
A->priority = _k_current_task->priority; A->priority = _k_current_task->priority;
@ -156,8 +156,8 @@ int _task_mem_map_alloc(kmemory_map_t mmap, void **mptr, int32_t time)
A.Comm = _K_SVC_MEM_MAP_ALLOC; A.Comm = _K_SVC_MEM_MAP_ALLOC;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.a1.mmap = mmap; A.args.a1.mmap = mmap;
A.Args.a1.mptr = mptr; A.args.a1.mptr = mptr;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }
@ -172,17 +172,17 @@ int _task_mem_map_alloc(kmemory_map_t mmap, void **mptr, int32_t time)
void _k_mem_map_dealloc(struct k_args *A) void _k_mem_map_dealloc(struct k_args *A)
{ {
struct _k_mem_map_struct *M = struct _k_mem_map_struct *M =
(struct _k_mem_map_struct *)(A->Args.a1.mmap); (struct _k_mem_map_struct *)(A->args.a1.mmap);
struct k_args *X; struct k_args *X;
**(char ***)(A->Args.a1.mptr) = M->Free; **(char ***)(A->args.a1.mptr) = M->Free;
M->Free = *(char **)(A->Args.a1.mptr); M->Free = *(char **)(A->args.a1.mptr);
*(A->Args.a1.mptr) = NULL; *(A->args.a1.mptr) = NULL;
X = M->Waiters; X = M->Waiters;
if (X) { if (X) {
M->Waiters = X->next; M->Waiters = X->next;
*(X->Args.a1.mptr) = M->Free; *(X->args.a1.mptr) = M->Free;
M->Free = *(char **)(M->Free); M->Free = *(char **)(M->Free);
#ifdef CONFIG_SYS_CLOCK_EXISTS #ifdef CONFIG_SYS_CLOCK_EXISTS
@ -220,8 +220,8 @@ void _task_mem_map_free(kmemory_map_t mmap, void **mptr)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_MEM_MAP_DEALLOC; A.Comm = _K_SVC_MEM_MAP_DEALLOC;
A.Args.a1.mmap = mmap; A.args.a1.mmap = mmap;
A.Args.a1.mptr = mptr; A.args.a1.mptr = mptr;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }

44
kernel/microkernel/k_memory_pool.c
View file

@ -199,7 +199,7 @@ static void defrag(struct pool_struct *P,
void _k_defrag(struct k_args *A) void _k_defrag(struct k_args *A)
{ {
struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->Args.p1.pool_id); struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->args.p1.pool_id);
defrag(P, defrag(P,
P->nr_of_frags - 1, /* start from smallest blocks */ P->nr_of_frags - 1, /* start from smallest blocks */
@ -238,7 +238,7 @@ void task_mem_pool_defragment(kmemory_pool_t Pid /* pool to defragment */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_DEFRAG; A.Comm = _K_SVC_DEFRAG;
A.Args.p1.pool_id = Pid; A.args.p1.pool_id = Pid;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -422,7 +422,7 @@ static char *get_block_recusive(struct pool_struct *P, int index, int startindex
void _k_block_waiters_get(struct k_args *A) void _k_block_waiters_get(struct k_args *A)
{ {
struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->Args.p1.pool_id); struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->args.p1.pool_id);
char *found_block; char *found_block;
struct k_args *curr_task, *prev_task; struct k_args *curr_task, *prev_task;
int start_size, offset; int start_size, offset;
@ -436,7 +436,7 @@ void _k_block_waiters_get(struct k_args *A)
/* calculate size & offset */ /* calculate size & offset */
start_size = P->minblock_size; start_size = P->minblock_size;
offset = P->nr_of_frags - 1; offset = P->nr_of_frags - 1;
while (curr_task->Args.p1.req_size > start_size) { while (curr_task->args.p1.req_size > start_size) {
start_size = start_size << 2; /* try one larger */ start_size = start_size << 2; /* try one larger */
offset--; offset--;
} }
@ -448,8 +448,8 @@ void _k_block_waiters_get(struct k_args *A)
/* if success : remove task from list and reschedule */ /* if success : remove task from list and reschedule */
if (found_block != NULL) { if (found_block != NULL) {
/* return found block */ /* return found block */
curr_task->Args.p1.rep_poolptr = found_block; curr_task->args.p1.rep_poolptr = found_block;
curr_task->Args.p1.rep_dataptr = found_block; curr_task->args.p1.rep_dataptr = found_block;
/* reschedule task */ /* reschedule task */
@ -502,7 +502,7 @@ void _k_mem_pool_block_get_timeout_handle(struct k_args *A)
void _k_mem_pool_block_get(struct k_args *A) void _k_mem_pool_block_get(struct k_args *A)
{ {
struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->Args.p1.pool_id); struct pool_struct *P = _k_mem_pool_list + OBJ_INDEX(A->args.p1.pool_id);
char *found_block; char *found_block;
int start_size; int start_size;
@ -512,7 +512,7 @@ void _k_mem_pool_block_get(struct k_args *A)
start_size = P->minblock_size; start_size = P->minblock_size;
offset = P->nr_of_frags - 1; offset = P->nr_of_frags - 1;
while (A->Args.p1.req_size > start_size) { while (A->args.p1.req_size > start_size) {
start_size = start_size << 2; /*try one larger */ start_size = start_size << 2; /*try one larger */
offset--; offset--;
} }
@ -524,15 +524,15 @@ void _k_mem_pool_block_get(struct k_args *A)
get_block_recusive(P, offset, offset); /* allocate and fragment blocks */ get_block_recusive(P, offset, offset); /* allocate and fragment blocks */
if (found_block != NULL) { if (found_block != NULL) {
A->Args.p1.rep_poolptr = found_block; A->args.p1.rep_poolptr = found_block;
A->Args.p1.rep_dataptr = found_block; A->args.p1.rep_dataptr = found_block;
A->Time.rcode = RC_OK; A->Time.rcode = RC_OK;
return; /* return found block */ return; /* return found block */
} }
if (likely( if (likely(
(A->Time.ticks != TICKS_NONE) && (A->Time.ticks != TICKS_NONE) &&
(A->Args.p1.req_size <= (A->args.p1.req_size <=
P->maxblock_size))) {/* timeout? but not block to large */ P->maxblock_size))) {/* timeout? but not block to large */
A->priority = _k_current_task->priority; A->priority = _k_current_task->priority;
A->Ctxt.task = _k_current_task; A->Ctxt.task = _k_current_task;
@ -576,14 +576,14 @@ int _task_mem_pool_alloc(struct k_block *blockptr, /* ptr to requested block */
A.Comm = _K_SVC_MEM_POOL_BLOCK_GET; A.Comm = _K_SVC_MEM_POOL_BLOCK_GET;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.p1.pool_id = pool_id; A.args.p1.pool_id = pool_id;
A.Args.p1.req_size = reqsize; A.args.p1.req_size = reqsize;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
blockptr->pool_id = pool_id; blockptr->pool_id = pool_id;
blockptr->address_in_pool = A.Args.p1.rep_poolptr; blockptr->address_in_pool = A.args.p1.rep_poolptr;
blockptr->pointer_to_data = A.Args.p1.rep_dataptr; blockptr->pointer_to_data = A.args.p1.rep_dataptr;
blockptr->req_size = reqsize; blockptr->req_size = reqsize;
return A.Time.rcode; return A.Time.rcode;
@ -608,7 +608,7 @@ void _k_mem_pool_block_release(struct k_args *A)
int start_size, offset; int start_size, offset;
int i, j; int i, j;
Pid = A->Args.p1.pool_id; Pid = A->args.p1.pool_id;
P = _k_mem_pool_list + OBJ_INDEX(Pid); P = _k_mem_pool_list + OBJ_INDEX(Pid);
@ -617,7 +617,7 @@ void _k_mem_pool_block_release(struct k_args *A)
start_size = P->minblock_size; start_size = P->minblock_size;
offset = P->nr_of_frags - 1; offset = P->nr_of_frags - 1;
while (A->Args.p1.req_size > start_size) { while (A->args.p1.req_size > start_size) {
start_size = start_size << 2; /* try one larger */ start_size = start_size << 2; /* try one larger */
offset--; offset--;
} }
@ -631,7 +631,7 @@ void _k_mem_pool_block_release(struct k_args *A)
while ((j < block->nr_of_entries) && while ((j < block->nr_of_entries) &&
((blockstat = block->blocktable + j)->mem_blocks != 0)) { ((blockstat = block->blocktable + j)->mem_blocks != 0)) {
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (A->Args.p1.rep_poolptr == if (A->args.p1.rep_poolptr ==
(blockstat->mem_blocks + (blockstat->mem_blocks +
(OCTET_TO_SIZEOFUNIT(i * block->block_size)))) { (OCTET_TO_SIZEOFUNIT(i * block->block_size)))) {
/* we've found the right pointer, so free it */ /* we've found the right pointer, so free it */
@ -677,9 +677,9 @@ void task_mem_pool_free(struct k_block *blockptr /* pointer to block to free */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE; A.Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE;
A.Args.p1.pool_id = blockptr->pool_id; A.args.p1.pool_id = blockptr->pool_id;
A.Args.p1.req_size = blockptr->req_size; A.args.p1.req_size = blockptr->req_size;
A.Args.p1.rep_poolptr = blockptr->address_in_pool; A.args.p1.rep_poolptr = blockptr->address_in_pool;
A.Args.p1.rep_dataptr = blockptr->pointer_to_data; A.args.p1.rep_dataptr = blockptr->pointer_to_data;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }

2
kernel/microkernel/k_move_data.c
View file

@ -83,7 +83,7 @@ void _k_movedata_request(struct k_args *Req)
{ {
struct moved_req *ReqArgs; struct moved_req *ReqArgs;
ReqArgs = &(Req->Args.MovedReq); ReqArgs = &(Req->args.MovedReq);
__ASSERT_NO_MSG(0 == __ASSERT_NO_MSG(0 ==
(ReqArgs->iTotalSize % (ReqArgs->iTotalSize %

34
kernel/microkernel/k_mutex.c
View file

@ -87,7 +87,7 @@ void _k_mutex_lock_reply(
REMOVE_ELM(A); REMOVE_ELM(A);
A->Time.rcode = RC_TIME; A->Time.rcode = RC_TIME;
MutexId = A->Args.l1.mutex; MutexId = A->args.l1.mutex;
Mutex = (struct _k_mutex_struct *)MutexId; Mutex = (struct _k_mutex_struct *)MutexId;
FirstWaiter = Mutex->Waiters; FirstWaiter = Mutex->Waiters;
@ -124,8 +124,8 @@ void _k_mutex_lock_reply(
PrioChanger->alloc = true; PrioChanger->alloc = true;
PrioChanger->Comm = _K_SVC_TASK_PRIORITY_SET; PrioChanger->Comm = _K_SVC_TASK_PRIORITY_SET;
PrioChanger->priority = newPriority; PrioChanger->priority = newPriority;
PrioChanger->Args.g1.task = Mutex->Owner; PrioChanger->args.g1.task = Mutex->Owner;
PrioChanger->Args.g1.prio = newPriority; PrioChanger->args.g1.prio = newPriority;
SENDARGS(PrioChanger); SENDARGS(PrioChanger);
Mutex->OwnerCurrentPrio = newPriority; Mutex->OwnerCurrentPrio = newPriority;
} }
@ -175,17 +175,17 @@ void _k_mutex_lock_request(struct k_args *A /* pointer to mutex lock
struct k_args *PrioBooster; /* used to change a task's priority level */ struct k_args *PrioBooster; /* used to change a task's priority level */
kpriority_t BoostedPrio; /* new "boosted" priority level */ kpriority_t BoostedPrio; /* new "boosted" priority level */
MutexId = A->Args.l1.mutex; MutexId = A->args.l1.mutex;
Mutex = (struct _k_mutex_struct *)MutexId; Mutex = (struct _k_mutex_struct *)MutexId;
if (Mutex->Level == 0 || Mutex->Owner == A->Args.l1.task) { if (Mutex->Level == 0 || Mutex->Owner == A->args.l1.task) {
/* The mutex is either unowned or this is a nested lock. */ /* The mutex is either unowned or this is a nested lock. */
#ifdef CONFIG_OBJECT_MONITOR #ifdef CONFIG_OBJECT_MONITOR
Mutex->Count++; Mutex->Count++;
#endif #endif
Mutex->Owner = A->Args.l1.task; Mutex->Owner = A->args.l1.task;
/* /*
* Assign the task's priority directly if the requesting * Assign the task's priority directly if the requesting
@ -260,8 +260,8 @@ void _k_mutex_lock_request(struct k_args *A /* pointer to mutex lock
PrioBooster->alloc = true; PrioBooster->alloc = true;
PrioBooster->Comm = _K_SVC_TASK_PRIORITY_SET; PrioBooster->Comm = _K_SVC_TASK_PRIORITY_SET;
PrioBooster->priority = BoostedPrio; PrioBooster->priority = BoostedPrio;
PrioBooster->Args.g1.task = Mutex->Owner; PrioBooster->args.g1.task = Mutex->Owner;
PrioBooster->Args.g1.prio = BoostedPrio; PrioBooster->args.g1.prio = BoostedPrio;
SENDARGS(PrioBooster); SENDARGS(PrioBooster);
Mutex->OwnerCurrentPrio = BoostedPrio; Mutex->OwnerCurrentPrio = BoostedPrio;
} }
@ -295,8 +295,8 @@ int _task_mutex_lock(
A.Comm = _K_SVC_MUTEX_LOCK_REQUEST; A.Comm = _K_SVC_MUTEX_LOCK_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.l1.mutex = mutex; A.args.l1.mutex = mutex;
A.Args.l1.task = _k_current_task->id; A.args.l1.task = _k_current_task->id;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }
@ -321,9 +321,9 @@ void _k_mutex_unlock(struct k_args *A /* pointer to mutex unlock
int MutexId; /* mutex ID obtained from unlock request */ int MutexId; /* mutex ID obtained from unlock request */
struct k_args *PrioDowner; /* used to change a task's priority level */ struct k_args *PrioDowner; /* used to change a task's priority level */
MutexId = A->Args.l1.mutex; MutexId = A->args.l1.mutex;
Mutex = (struct _k_mutex_struct *)MutexId; Mutex = (struct _k_mutex_struct *)MutexId;
if (Mutex->Owner == A->Args.l1.task && --(Mutex->Level) == 0) { if (Mutex->Owner == A->args.l1.task && --(Mutex->Level) == 0) {
/* /*
* The requesting task owns the mutex and all locks * The requesting task owns the mutex and all locks
* have been released. * have been released.
@ -347,8 +347,8 @@ void _k_mutex_unlock(struct k_args *A /* pointer to mutex unlock
PrioDowner->alloc = true; PrioDowner->alloc = true;
PrioDowner->Comm = _K_SVC_TASK_PRIORITY_SET; PrioDowner->Comm = _K_SVC_TASK_PRIORITY_SET;
PrioDowner->priority = Mutex->OwnerOriginalPrio; PrioDowner->priority = Mutex->OwnerOriginalPrio;
PrioDowner->Args.g1.task = Mutex->Owner; PrioDowner->args.g1.task = Mutex->Owner;
PrioDowner->Args.g1.prio = Mutex->OwnerOriginalPrio; PrioDowner->args.g1.prio = Mutex->OwnerOriginalPrio;
SENDARGS(PrioDowner); SENDARGS(PrioDowner);
} }
@ -361,7 +361,7 @@ void _k_mutex_unlock(struct k_args *A /* pointer to mutex unlock
*/ */
Mutex->Waiters = X->next; Mutex->Waiters = X->next;
Mutex->Owner = X->Args.l1.task; Mutex->Owner = X->args.l1.task;
Mutex->Level = 1; Mutex->Level = 1;
Mutex->OwnerCurrentPrio = X->priority; Mutex->OwnerCurrentPrio = X->priority;
Mutex->OwnerOriginalPrio = X->priority; Mutex->OwnerOriginalPrio = X->priority;
@ -408,8 +408,8 @@ void _task_mutex_unlock(kmutex_t mutex /* mutex to unlock */
struct k_args A; /* argument packet */ struct k_args A; /* argument packet */
A.Comm = _K_SVC_MUTEX_UNLOCK; A.Comm = _K_SVC_MUTEX_UNLOCK;
A.Args.l1.mutex = mutex; A.args.l1.mutex = mutex;
A.Args.l1.task = _k_current_task->id; A.args.l1.task = _k_current_task->id;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }

8
kernel/microkernel/k_offload.c
View file

@ -45,7 +45,7 @@
void _k_offload_to_fiber(struct k_args *A) void _k_offload_to_fiber(struct k_args *A)
{ {
A->Args.u1.rval = (*A->Args.u1.func)(A->Args.u1.argp); A->args.u1.rval = (*A->args.u1.func)(A->args.u1.argp);
} }
/** /**
@ -66,8 +66,8 @@ int task_offload_to_fiber(int (*func)(), void *argp)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_OFFLOAD_TO_FIBER; A.Comm = _K_SVC_OFFLOAD_TO_FIBER;
A.Args.u1.func = func; A.args.u1.func = func;
A.Args.u1.argp = argp; A.args.u1.argp = argp;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Args.u1.rval; return A.args.u1.rval;
} }

36
kernel/microkernel/k_pipe.c
View file

@ -100,16 +100,16 @@ int _task_pipe_get(kpipe_t Id, void *pBuffer,
A.Comm = _K_SVC_PIPE_GET_REQUEST; A.Comm = _K_SVC_PIPE_GET_REQUEST;
A.Time.ticks = TimeOut; A.Time.ticks = TimeOut;
A.Args.pipe_req.ReqInfo.pipe.id = Id; A.args.pipe_req.ReqInfo.pipe.id = Id;
A.Args.pipe_req.ReqType.Sync.iSizeTotal = iNbrBytesToRead; A.args.pipe_req.ReqType.Sync.iSizeTotal = iNbrBytesToRead;
A.Args.pipe_req.ReqType.Sync.pData = pBuffer; A.args.pipe_req.ReqType.Sync.pData = pBuffer;
_k_pipe_option_set(&A.Args, Option); _k_pipe_option_set(&A.args, Option);
_k_pipe_request_type_set(&A.Args, _SYNCREQ); _k_pipe_request_type_set(&A.args, _SYNCREQ);
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
*piNbrBytesRead = A.Args.pipe_ack.iSizeXferred; *piNbrBytesRead = A.args.pipe_ack.iSizeXferred;
return A.Time.rcode; return A.Time.rcode;
} }
@ -152,16 +152,16 @@ int _task_pipe_put(kpipe_t Id, void *pBuffer,
A.Comm = _K_SVC_PIPE_PUT_REQUEST; A.Comm = _K_SVC_PIPE_PUT_REQUEST;
A.Time.ticks = TimeOut; A.Time.ticks = TimeOut;
A.Args.pipe_req.ReqInfo.pipe.id = Id; A.args.pipe_req.ReqInfo.pipe.id = Id;
A.Args.pipe_req.ReqType.Sync.iSizeTotal = iNbrBytesToWrite; A.args.pipe_req.ReqType.Sync.iSizeTotal = iNbrBytesToWrite;
A.Args.pipe_req.ReqType.Sync.pData = pBuffer; A.args.pipe_req.ReqType.Sync.pData = pBuffer;
_k_pipe_option_set(&A.Args, Option); _k_pipe_option_set(&A.args, Option);
_k_pipe_request_type_set(&A.Args, _SYNCREQ); _k_pipe_request_type_set(&A.args, _SYNCREQ);
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
*piNbrBytesWritten = A.Args.pipe_ack.iSizeXferred; *piNbrBytesWritten = A.args.pipe_ack.iSizeXferred;
return A.Time.rcode; return A.Time.rcode;
} }
@ -198,13 +198,13 @@ int _task_pipe_block_put(kpipe_t Id, struct k_block Block,
A.Time.ticks = TICKS_UNLIMITED; A.Time.ticks = TICKS_UNLIMITED;
/* same behavior in flow as a blocking call w/o a timeout */ /* same behavior in flow as a blocking call w/o a timeout */
A.Args.pipe_req.ReqInfo.pipe.id = Id; A.args.pipe_req.ReqInfo.pipe.id = Id;
A.Args.pipe_req.ReqType.Async.block = Block; A.args.pipe_req.ReqType.Async.block = Block;
A.Args.pipe_req.ReqType.Async.iSizeTotal = iSize2Xfer; A.args.pipe_req.ReqType.Async.iSizeTotal = iSize2Xfer;
A.Args.pipe_req.ReqType.Async.sema = Sema; A.args.pipe_req.ReqType.Async.sema = Sema;
_k_pipe_request_type_set(&A.Args, _ASYNCREQ); _k_pipe_request_type_set(&A.args, _ASYNCREQ);
_k_pipe_option_set(&A.Args, _ALL_N); /* force ALL_N */ _k_pipe_option_set(&A.args, _ALL_N); /* force ALL_N */
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return RC_OK; return RC_OK;

64
kernel/microkernel/k_pipe_get.c
View file

@ -48,7 +48,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
struct k_args *Request; struct k_args *Request;
struct k_args *RequestProc; struct k_args *RequestProc;
kpipe_t pipeId = RequestOrig->Args.pipe_req.ReqInfo.pipe.id; kpipe_t pipeId = RequestOrig->args.pipe_req.ReqInfo.pipe.id;
/* If it's a poster, then don't deschedule the task */ /* If it's a poster, then don't deschedule the task */
@ -67,36 +67,36 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
*/ */
mycopypacket(&RequestProc, Request); mycopypacket(&RequestProc, Request);
RequestProc->Args.pipe_xfer_req.ReqInfo.pipe.ptr = RequestProc->args.pipe_xfer_req.ReqInfo.pipe.ptr =
(struct _k_pipe_struct *)pipeId; (struct _k_pipe_struct *)pipeId;
switch (_k_pipe_request_type_get(&RequestProc->Args)) { switch (_k_pipe_request_type_get(&RequestProc->args)) {
case _SYNCREQ: case _SYNCREQ:
RequestProc->Args.pipe_xfer_req.pData = RequestProc->args.pipe_xfer_req.pData =
Request->Args.pipe_req.ReqType.Sync.pData; Request->args.pipe_req.ReqType.Sync.pData;
RequestProc->Args.pipe_xfer_req.iSizeTotal = RequestProc->args.pipe_xfer_req.iSizeTotal =
Request->Args.pipe_req.ReqType.Sync.iSizeTotal; Request->args.pipe_req.ReqType.Sync.iSizeTotal;
break; break;
default: default:
break; break;
} }
RequestProc->Args.pipe_xfer_req.status = XFER_IDLE; RequestProc->args.pipe_xfer_req.status = XFER_IDLE;
RequestProc->Args.pipe_xfer_req.iNbrPendXfers = 0; RequestProc->args.pipe_xfer_req.iNbrPendXfers = 0;
RequestProc->Args.pipe_xfer_req.iSizeXferred = 0; RequestProc->args.pipe_xfer_req.iSizeXferred = 0;
RequestProc->next = NULL; RequestProc->next = NULL;
RequestProc->Head = NULL; RequestProc->Head = NULL;
switch (RequestProc->Time.ticks) { switch (RequestProc->Time.ticks) {
case TICKS_NONE: case TICKS_NONE:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_NB); _k_pipe_time_type_set(&RequestProc->args, _TIME_NB);
break; break;
case TICKS_UNLIMITED: case TICKS_UNLIMITED:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_B); _k_pipe_time_type_set(&RequestProc->args, _TIME_B);
break; break;
default: default:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_BT); _k_pipe_time_type_set(&RequestProc->args, _TIME_BT);
break; break;
} }
@ -104,7 +104,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
struct _k_pipe_struct *pPipe; struct _k_pipe_struct *pPipe;
pPipe = RequestProc->Args.pipe_xfer_req.ReqInfo.pipe.ptr; pPipe = RequestProc->args.pipe_xfer_req.ReqInfo.pipe.ptr;
do { do {
int iData2ReadFromWriters; int iData2ReadFromWriters;
@ -128,7 +128,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
RequestProc->Time.ticks = ticks; RequestProc->Time.ticks = ticks;
/* check if request was processed */ /* check if request was processed */
if (TERM_XXX & RequestProc->Args.pipe_xfer_req.status) { if (TERM_XXX & RequestProc->args.pipe_xfer_req.status) {
RequestProc->Time.timer = NULL; /* not really required */ RequestProc->Time.timer = NULL; /* not really required */
return; /* not listed anymore --> completely processed */ return; /* not listed anymore --> completely processed */
} }
@ -140,7 +140,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
* processing on the request * processing on the request
*/ */
if (_TIME_NB != _k_pipe_time_type_get(&RequestProc->Args)) { if (_TIME_NB != _k_pipe_time_type_get(&RequestProc->args)) {
/* call is blocking */ /* call is blocking */
INSERT_ELM(pPipe->Readers, RequestProc); INSERT_ELM(pPipe->Readers, RequestProc);
/* /*
@ -149,7 +149,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
* is only useful to the finite timeout case. * is only useful to the finite timeout case.
*/ */
RequestProc->Comm = _K_SVC_PIPE_GET_TIMEOUT; RequestProc->Comm = _K_SVC_PIPE_GET_TIMEOUT;
if (_TIME_B == _k_pipe_time_type_get(&RequestProc->Args)) { if (_TIME_B == _k_pipe_time_type_get(&RequestProc->args)) {
/* /*
* The writer specified TICKS_UNLIMITED, so NULL the timer. * The writer specified TICKS_UNLIMITED, so NULL the timer.
*/ */
@ -158,7 +158,7 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
} else { } else {
/* { TIME_BT } */ /* { TIME_BT } */
#ifdef CANCEL_TIMERS #ifdef CANCEL_TIMERS
if (RequestProc->Args.pipe_xfer_req.iSizeXferred != 0) { if (RequestProc->args.pipe_xfer_req.iSizeXferred != 0) {
RequestProc->Time.timer = NULL; RequestProc->Time.timer = NULL;
} else } else
#endif #endif
@ -174,12 +174,12 @@ void _k_pipe_get_request(struct k_args *RequestOrig)
*/ */
RequestProc->Time.timer = NULL; RequestProc->Time.timer = NULL;
if (XFER_BUSY == RequestProc->Args.pipe_xfer_req.status) { if (XFER_BUSY == RequestProc->args.pipe_xfer_req.status) {
INSERT_ELM(pPipe->Readers, RequestProc); INSERT_ELM(pPipe->Readers, RequestProc);
} else { } else {
__ASSERT_NO_MSG(XFER_IDLE == __ASSERT_NO_MSG(XFER_IDLE ==
RequestProc->Args.pipe_xfer_req.status); RequestProc->args.pipe_xfer_req.status);
__ASSERT_NO_MSG(0 == RequestProc->Args.pipe_xfer_req.iSizeXferred); __ASSERT_NO_MSG(0 == RequestProc->args.pipe_xfer_req.iSizeXferred);
RequestProc->Comm = _K_SVC_PIPE_GET_REPLY; RequestProc->Comm = _K_SVC_PIPE_GET_REPLY;
_k_pipe_get_reply(RequestProc); _k_pipe_get_reply(RequestProc);
} }
@ -199,10 +199,10 @@ void _k_pipe_get_timeout(struct k_args *ReqProc)
__ASSERT_NO_MSG(NULL != ReqProc->Time.timer); __ASSERT_NO_MSG(NULL != ReqProc->Time.timer);
myfreetimer(&(ReqProc->Time.timer)); myfreetimer(&(ReqProc->Time.timer));
_k_pipe_request_status_set(&ReqProc->Args.pipe_xfer_req, TERM_TMO); _k_pipe_request_status_set(&ReqProc->args.pipe_xfer_req, TERM_TMO);
DeListWaiter(ReqProc); DeListWaiter(ReqProc);
if (0 == ReqProc->Args.pipe_xfer_req.iNbrPendXfers) { if (0 == ReqProc->args.pipe_xfer_req.iNbrPendXfers) {
_k_pipe_get_reply(ReqProc); _k_pipe_get_reply(ReqProc);
} }
} }
@ -217,7 +217,7 @@ void _k_pipe_get_timeout(struct k_args *ReqProc)
void _k_pipe_get_reply(struct k_args *ReqProc) void _k_pipe_get_reply(struct k_args *ReqProc)
{ {
__ASSERT_NO_MSG( __ASSERT_NO_MSG(
(0 == ReqProc->Args.pipe_xfer_req.iNbrPendXfers) /* no pending Xfers */ (0 == ReqProc->args.pipe_xfer_req.iNbrPendXfers) /* no pending Xfers */
&& (NULL == ReqProc->Time.timer) /* no pending timer */ && (NULL == ReqProc->Time.timer) /* no pending timer */
&& (NULL == ReqProc->Head)); /* not in list */ && (NULL == ReqProc->Head)); /* not in list */
@ -229,17 +229,17 @@ void _k_pipe_get_reply(struct k_args *ReqProc)
/* determine return value */ /* determine return value */
status = ReqProc->Args.pipe_xfer_req.status; status = ReqProc->args.pipe_xfer_req.status;
if (TERM_TMO == status) { if (TERM_TMO == status) {
ReqOrig->Time.rcode = RC_TIME; ReqOrig->Time.rcode = RC_TIME;
} else if ((TERM_XXX | XFER_IDLE) & status) { } else if ((TERM_XXX | XFER_IDLE) & status) {
K_PIPE_OPTION Option = _k_pipe_option_get(&ReqProc->Args); K_PIPE_OPTION Option = _k_pipe_option_get(&ReqProc->args);
if (likely(ReqProc->Args.pipe_xfer_req.iSizeXferred == if (likely(ReqProc->args.pipe_xfer_req.iSizeXferred ==
ReqProc->Args.pipe_xfer_req.iSizeTotal)) { ReqProc->args.pipe_xfer_req.iSizeTotal)) {
/* All data has been transferred */ /* All data has been transferred */
ReqOrig->Time.rcode = RC_OK; ReqOrig->Time.rcode = RC_OK;
} else if (ReqProc->Args.pipe_xfer_req.iSizeXferred != 0) { } else if (ReqProc->args.pipe_xfer_req.iSizeXferred != 0) {
/* Some but not all data has been transferred */ /* Some but not all data has been transferred */
ReqOrig->Time.rcode = (Option == _ALL_N) ? ReqOrig->Time.rcode = (Option == _ALL_N) ?
RC_INCOMPLETE : RC_OK; RC_INCOMPLETE : RC_OK;
@ -252,8 +252,8 @@ void _k_pipe_get_reply(struct k_args *ReqProc)
__ASSERT_NO_MSG(1 == 0); /* should not come here */ __ASSERT_NO_MSG(1 == 0); /* should not come here */
} }
ReqOrig->Args.pipe_ack.iSizeXferred = ReqOrig->args.pipe_ack.iSizeXferred =
ReqProc->Args.pipe_xfer_req.iSizeXferred; ReqProc->args.pipe_xfer_req.iSizeXferred;
SENDARGS(ReqOrig); SENDARGS(ReqOrig);
FREEARGS(ReqProc); FREEARGS(ReqProc);
@ -272,7 +272,7 @@ void _k_pipe_get_ack(struct k_args *Request)
LocalReq = Request->Ctxt.args; LocalReq = Request->Ctxt.args;
LocalReq->Time.rcode = Request->Time.rcode; LocalReq->Time.rcode = Request->Time.rcode;
LocalReq->Args.pipe_ack = Request->Args.pipe_ack; LocalReq->args.pipe_ack = Request->args.pipe_ack;
/* Reschedule the sender task */ /* Reschedule the sender task */

90
kernel/microkernel/k_pipe_put.c
View file

@ -49,11 +49,11 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
struct k_args *Request; struct k_args *Request;
struct k_args *RequestProc; struct k_args *RequestProc;
kpipe_t pipeId = RequestOrig->Args.pipe_req.ReqInfo.pipe.id; kpipe_t pipeId = RequestOrig->args.pipe_req.ReqInfo.pipe.id;
bool bAsync; bool bAsync;
if (_ASYNCREQ == _k_pipe_request_type_get(&RequestOrig->Args)) { if (_ASYNCREQ == _k_pipe_request_type_get(&RequestOrig->args)) {
bAsync = true; bAsync = true;
} else { } else {
bAsync = false; bAsync = false;
@ -79,41 +79,41 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
*/ */
mycopypacket(&RequestProc, Request); mycopypacket(&RequestProc, Request);
RequestProc->Args.pipe_xfer_req.ReqInfo.pipe.ptr = RequestProc->args.pipe_xfer_req.ReqInfo.pipe.ptr =
(struct _k_pipe_struct *)pipeId; (struct _k_pipe_struct *)pipeId;
switch (_k_pipe_request_type_get(&RequestProc->Args)) { switch (_k_pipe_request_type_get(&RequestProc->args)) {
case _SYNCREQ: case _SYNCREQ:
RequestProc->Args.pipe_xfer_req.pData = RequestProc->args.pipe_xfer_req.pData =
Request->Args.pipe_req.ReqType.Sync.pData; Request->args.pipe_req.ReqType.Sync.pData;
RequestProc->Args.pipe_xfer_req.iSizeTotal = RequestProc->args.pipe_xfer_req.iSizeTotal =
Request->Args.pipe_req.ReqType.Sync.iSizeTotal; Request->args.pipe_req.ReqType.Sync.iSizeTotal;
break; break;
case _ASYNCREQ: case _ASYNCREQ:
RequestProc->Args.pipe_xfer_req.pData = RequestProc->args.pipe_xfer_req.pData =
Request->Args.pipe_req.ReqType.Async.block.pointer_to_data; Request->args.pipe_req.ReqType.Async.block.pointer_to_data;
RequestProc->Args.pipe_xfer_req.iSizeTotal = RequestProc->args.pipe_xfer_req.iSizeTotal =
Request->Args.pipe_req.ReqType.Async.iSizeTotal; Request->args.pipe_req.ReqType.Async.iSizeTotal;
break; break;
default: default:
break; break;
} }
RequestProc->Args.pipe_xfer_req.status = XFER_IDLE; RequestProc->args.pipe_xfer_req.status = XFER_IDLE;
RequestProc->Args.pipe_xfer_req.iNbrPendXfers = 0; RequestProc->args.pipe_xfer_req.iNbrPendXfers = 0;
RequestProc->Args.pipe_xfer_req.iSizeXferred = 0; RequestProc->args.pipe_xfer_req.iSizeXferred = 0;
RequestProc->next = NULL; RequestProc->next = NULL;
RequestProc->Head = NULL; RequestProc->Head = NULL;
switch (RequestProc->Time.ticks) { switch (RequestProc->Time.ticks) {
case TICKS_NONE: case TICKS_NONE:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_NB); _k_pipe_time_type_set(&RequestProc->args, _TIME_NB);
break; break;
case TICKS_UNLIMITED: case TICKS_UNLIMITED:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_B); _k_pipe_time_type_set(&RequestProc->args, _TIME_B);
break; break;
default: default:
_k_pipe_time_type_set(&RequestProc->Args, _TIME_BT); _k_pipe_time_type_set(&RequestProc->args, _TIME_BT);
break; break;
} }
@ -121,7 +121,7 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
struct _k_pipe_struct *pPipe; struct _k_pipe_struct *pPipe;
pPipe = RequestProc->Args.pipe_xfer_req.ReqInfo.pipe.ptr; pPipe = RequestProc->args.pipe_xfer_req.ReqInfo.pipe.ptr;
do { do {
int iSpace2WriteinReaders; int iSpace2WriteinReaders;
@ -147,7 +147,7 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
/* check if request was processed */ /* check if request was processed */
if (TERM_XXX & RequestProc->Args.pipe_xfer_req.status) { if (TERM_XXX & RequestProc->args.pipe_xfer_req.status) {
RequestProc->Time.timer = NULL; /* not really required */ RequestProc->Time.timer = NULL; /* not really required */
return; /* not listed anymore --> completely processed */ return; /* not listed anymore --> completely processed */
} }
@ -159,7 +159,7 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
*/ */
if (_TIME_NB != if (_TIME_NB !=
_k_pipe_time_type_get(&RequestProc->Args)) { _k_pipe_time_type_get(&RequestProc->args)) {
/* call is blocking */ /* call is blocking */
INSERT_ELM(pPipe->Writers, RequestProc); INSERT_ELM(pPipe->Writers, RequestProc);
/* /*
@ -168,7 +168,7 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
* is only useful to the finite timeout case. * is only useful to the finite timeout case.
*/ */
RequestProc->Comm = _K_SVC_PIPE_PUT_TIMEOUT; RequestProc->Comm = _K_SVC_PIPE_PUT_TIMEOUT;
if (_TIME_B == _k_pipe_time_type_get(&RequestProc->Args)) { if (_TIME_B == _k_pipe_time_type_get(&RequestProc->args)) {
/* /*
* The writer specified TICKS_UNLIMITED; NULL the timer. * The writer specified TICKS_UNLIMITED; NULL the timer.
*/ */
@ -177,7 +177,7 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
} else { } else {
/* { TIME_BT } */ /* { TIME_BT } */
#ifdef CANCEL_TIMERS #ifdef CANCEL_TIMERS
if (RequestProc->Args.pipe_xfer_req.iSizeXferred != 0) { if (RequestProc->args.pipe_xfer_req.iSizeXferred != 0) {
RequestProc->Time.timer = NULL; RequestProc->Time.timer = NULL;
} else } else
#endif #endif
@ -193,12 +193,12 @@ void _k_pipe_put_request(struct k_args *RequestOrig)
*/ */
RequestProc->Time.timer = NULL; RequestProc->Time.timer = NULL;
if (XFER_BUSY == RequestProc->Args.pipe_xfer_req.status) { if (XFER_BUSY == RequestProc->args.pipe_xfer_req.status) {
INSERT_ELM(pPipe->Writers, RequestProc); INSERT_ELM(pPipe->Writers, RequestProc);
} else { } else {
__ASSERT_NO_MSG(XFER_IDLE == __ASSERT_NO_MSG(XFER_IDLE ==
RequestProc->Args.pipe_xfer_req.status); RequestProc->args.pipe_xfer_req.status);
__ASSERT_NO_MSG(0 == RequestProc->Args.pipe_xfer_req.iSizeXferred); __ASSERT_NO_MSG(0 == RequestProc->args.pipe_xfer_req.iSizeXferred);
RequestProc->Comm = _K_SVC_PIPE_PUT_REPLY; RequestProc->Comm = _K_SVC_PIPE_PUT_REPLY;
_k_pipe_put_reply(RequestProc); _k_pipe_put_reply(RequestProc);
} }
@ -218,10 +218,10 @@ void _k_pipe_put_timeout(struct k_args *ReqProc)
__ASSERT_NO_MSG(NULL != ReqProc->Time.timer); __ASSERT_NO_MSG(NULL != ReqProc->Time.timer);
myfreetimer(&(ReqProc->Time.timer)); myfreetimer(&(ReqProc->Time.timer));
_k_pipe_request_status_set(&ReqProc->Args.pipe_xfer_req, TERM_TMO); _k_pipe_request_status_set(&ReqProc->args.pipe_xfer_req, TERM_TMO);
DeListWaiter(ReqProc); DeListWaiter(ReqProc);
if (0 == ReqProc->Args.pipe_xfer_req.iNbrPendXfers) { if (0 == ReqProc->args.pipe_xfer_req.iNbrPendXfers) {
_k_pipe_put_reply(ReqProc); _k_pipe_put_reply(ReqProc);
} }
} }
@ -236,7 +236,7 @@ void _k_pipe_put_timeout(struct k_args *ReqProc)
void _k_pipe_put_reply(struct k_args *ReqProc) void _k_pipe_put_reply(struct k_args *ReqProc)
{ {
__ASSERT_NO_MSG( __ASSERT_NO_MSG(
0 == ReqProc->Args.pipe_xfer_req.iNbrPendXfers /* no pending Xfers */ 0 == ReqProc->args.pipe_xfer_req.iNbrPendXfers /* no pending Xfers */
&& NULL == ReqProc->Time.timer /* no pending timer */ && NULL == ReqProc->Time.timer /* no pending timer */
&& NULL == ReqProc->Head); /* not in list */ && NULL == ReqProc->Head); /* not in list */
@ -249,17 +249,17 @@ void _k_pipe_put_reply(struct k_args *ReqProc)
/* determine return value: /* determine return value:
*/ */
status = ReqProc->Args.pipe_xfer_req.status; status = ReqProc->args.pipe_xfer_req.status;
if (unlikely(TERM_TMO == status)) { if (unlikely(TERM_TMO == status)) {
ReqOrig->Time.rcode = RC_TIME; ReqOrig->Time.rcode = RC_TIME;
} else if ((TERM_XXX | XFER_IDLE) & status) { } else if ((TERM_XXX | XFER_IDLE) & status) {
K_PIPE_OPTION Option = _k_pipe_option_get(&ReqProc->Args); K_PIPE_OPTION Option = _k_pipe_option_get(&ReqProc->args);
if (likely(ReqProc->Args.pipe_xfer_req.iSizeXferred == if (likely(ReqProc->args.pipe_xfer_req.iSizeXferred ==
ReqProc->Args.pipe_xfer_req.iSizeTotal)) { ReqProc->args.pipe_xfer_req.iSizeTotal)) {
/* All data has been transferred */ /* All data has been transferred */
ReqOrig->Time.rcode = RC_OK; ReqOrig->Time.rcode = RC_OK;
} else if (ReqProc->Args.pipe_xfer_req.iSizeXferred != 0) { } else if (ReqProc->args.pipe_xfer_req.iSizeXferred != 0) {
/* Some but not all data has been transferred */ /* Some but not all data has been transferred */
ReqOrig->Time.rcode = (Option == _ALL_N) ? RC_INCOMPLETE : RC_OK; ReqOrig->Time.rcode = (Option == _ALL_N) ? RC_INCOMPLETE : RC_OK;
} else { } else {
@ -270,9 +270,9 @@ void _k_pipe_put_reply(struct k_args *ReqProc)
/* unknown (invalid) status */ /* unknown (invalid) status */
__ASSERT_NO_MSG(1 == 0); /* should not come here */ __ASSERT_NO_MSG(1 == 0); /* should not come here */
} }
if (_ASYNCREQ != _k_pipe_request_type_get(&ReqOrig->Args)) { if (_ASYNCREQ != _k_pipe_request_type_get(&ReqOrig->args)) {
ReqOrig->Args.pipe_ack.iSizeXferred = ReqOrig->args.pipe_ack.iSizeXferred =
ReqProc->Args.pipe_xfer_req.iSizeXferred; ReqProc->args.pipe_xfer_req.iSizeXferred;
} }
SENDARGS(ReqOrig); SENDARGS(ReqOrig);
@ -289,18 +289,18 @@ void _k_pipe_put_reply(struct k_args *ReqProc)
void _k_pipe_put_ack(struct k_args *Request) void _k_pipe_put_ack(struct k_args *Request)
{ {
if (_ASYNCREQ == _k_pipe_request_type_get(&Request->Args)) { if (_ASYNCREQ == _k_pipe_request_type_get(&Request->args)) {
struct _pipe_ack_arg *pipe_ack = &Request->Args.pipe_ack; struct _pipe_ack_arg *pipe_ack = &Request->args.pipe_ack;
struct k_args A; struct k_args A;
struct k_block *blockptr; struct k_block *blockptr;
/* invoke command to release block */ /* invoke command to release block */
blockptr = &pipe_ack->ReqType.Async.block; blockptr = &pipe_ack->ReqType.Async.block;
A.Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE; A.Comm = _K_SVC_MEM_POOL_BLOCK_RELEASE;
A.Args.p1.pool_id = blockptr->pool_id; A.args.p1.pool_id = blockptr->pool_id;
A.Args.p1.req_size = blockptr->req_size; A.args.p1.req_size = blockptr->req_size;
A.Args.p1.rep_poolptr = blockptr->address_in_pool; A.args.p1.rep_poolptr = blockptr->address_in_pool;
A.Args.p1.rep_dataptr = blockptr->pointer_to_data; A.args.p1.rep_dataptr = blockptr->pointer_to_data;
_k_mem_pool_block_release(&A); /* will return immediately */ _k_mem_pool_block_release(&A); /* will return immediately */
if ((ksem_t)NULL != pipe_ack->ReqType.Async.sema) { if ((ksem_t)NULL != pipe_ack->ReqType.Async.sema) {
@ -308,7 +308,7 @@ void _k_pipe_put_ack(struct k_args *Request)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_SIGNAL; A.Comm = _K_SVC_SEM_SIGNAL;
A.Args.s1.sema = pipe_ack->ReqType.Async.sema; A.args.s1.sema = pipe_ack->ReqType.Async.sema;
_k_sem_signal(&A); /* will return immediately */ _k_sem_signal(&A); /* will return immediately */
} }
} else { } else {
@ -317,7 +317,7 @@ void _k_pipe_put_ack(struct k_args *Request)
LocalReq = Request->Ctxt.args; LocalReq = Request->Ctxt.args;
LocalReq->Time.rcode = Request->Time.rcode; LocalReq->Time.rcode = Request->Time.rcode;
LocalReq->Args.pipe_ack = Request->Args.pipe_ack; LocalReq->args.pipe_ack = Request->args.pipe_ack;
_k_state_bit_reset(LocalReq->Ctxt.task, TF_SEND | TF_SENDDATA); _k_state_bit_reset(LocalReq->Ctxt.task, TF_SEND | TF_SENDDATA);
} }

8
kernel/microkernel/k_pipe_util.c
View file

@ -71,8 +71,8 @@ int CalcFreeReaderSpace(struct k_args *pReaderList)
if (pReaderList) { if (pReaderList) {
struct k_args *pReader = pReaderList; struct k_args *pReader = pReaderList;
while (pReader != NULL) { while (pReader != NULL) {
iSize += (pReader->Args.pipe_xfer_req.iSizeTotal - iSize += (pReader->args.pipe_xfer_req.iSizeTotal -
pReader->Args.pipe_xfer_req.iSizeXferred); pReader->args.pipe_xfer_req.iSizeXferred);
pReader = pReader->next; pReader = pReader->next;
} }
} }
@ -86,8 +86,8 @@ int CalcAvailWriterData(struct k_args *pWriterList)
if (pWriterList) { if (pWriterList) {
struct k_args *pWriter = pWriterList; struct k_args *pWriter = pWriterList;
while (pWriter != NULL) { while (pWriter != NULL) {
iSize += (pWriter->Args.pipe_xfer_req.iSizeTotal - iSize += (pWriter->args.pipe_xfer_req.iSizeTotal -
pWriter->Args.pipe_xfer_req.iSizeXferred); pWriter->args.pipe_xfer_req.iSizeXferred);
pWriter = pWriter->next; pWriter = pWriter->next;
} }
} }

158
kernel/microkernel/k_pipe_xfer.c
View file

@ -63,7 +63,7 @@ possibly copy the remaining data
void _k_pipe_movedata_ack(struct k_args *pEOXfer) void _k_pipe_movedata_ack(struct k_args *pEOXfer)
{ {
struct _pipe_xfer_ack_arg *pipe_xfer_ack = &pEOXfer->Args.pipe_xfer_ack; struct _pipe_xfer_ack_arg *pipe_xfer_ack = &pEOXfer->args.pipe_xfer_ack;
switch (pipe_xfer_ack->XferType) { switch (pipe_xfer_ack->XferType) {
case XFER_W2B: /* Writer to Buffer */ case XFER_W2B: /* Writer to Buffer */
@ -72,7 +72,7 @@ void _k_pipe_movedata_ack(struct k_args *pEOXfer)
if (pWriter) { /* Xfer from Writer finished */ if (pWriter) { /* Xfer from Writer finished */
struct _pipe_xfer_req_arg *pipe_write_req = struct _pipe_xfer_req_arg *pipe_write_req =
&pipe_xfer_ack->pWriter->Args.pipe_xfer_req; &pipe_xfer_ack->pWriter->args.pipe_xfer_req;
--pipe_write_req->iNbrPendXfers; --pipe_write_req->iNbrPendXfers;
if (0 == pipe_write_req->iNbrPendXfers) { if (0 == pipe_write_req->iNbrPendXfers) {
@ -112,7 +112,7 @@ void _k_pipe_movedata_ack(struct k_args *pEOXfer)
if (pReader) { /* Xfer to Reader finished */ if (pReader) { /* Xfer to Reader finished */
struct _pipe_xfer_req_arg *pipe_read_req = struct _pipe_xfer_req_arg *pipe_read_req =
&pipe_xfer_ack->pReader->Args.pipe_xfer_req; &pipe_xfer_ack->pReader->args.pipe_xfer_req;
--pipe_read_req->iNbrPendXfers; --pipe_read_req->iNbrPendXfers;
if (0 == pipe_read_req->iNbrPendXfers) { if (0 == pipe_read_req->iNbrPendXfers) {
@ -152,7 +152,7 @@ void _k_pipe_movedata_ack(struct k_args *pEOXfer)
if (pWriter) { /* Transfer from writer finished */ if (pWriter) { /* Transfer from writer finished */
struct _pipe_xfer_req_arg *pipe_write_req = struct _pipe_xfer_req_arg *pipe_write_req =
&pipe_xfer_ack->pWriter->Args.pipe_xfer_req; &pipe_xfer_ack->pWriter->args.pipe_xfer_req;
--pipe_write_req->iNbrPendXfers; --pipe_write_req->iNbrPendXfers;
if (0 == pipe_write_req->iNbrPendXfers) { if (0 == pipe_write_req->iNbrPendXfers) {
@ -174,7 +174,7 @@ void _k_pipe_movedata_ack(struct k_args *pEOXfer)
/* Transfer to Reader finished */ /* Transfer to Reader finished */
struct _pipe_xfer_req_arg *pipe_read_req = struct _pipe_xfer_req_arg *pipe_read_req =
&pipe_xfer_ack->pReader->Args.pipe_xfer_req; &pipe_xfer_ack->pReader->args.pipe_xfer_req;
--pipe_read_req->iNbrPendXfers; --pipe_read_req->iNbrPendXfers;
if (0 == pipe_read_req->iNbrPendXfers) { if (0 == pipe_read_req->iNbrPendXfers) {
@ -255,10 +255,10 @@ static void setup_movedata(struct k_args *A,
A->Ctxt.task = NULL; A->Ctxt.task = NULL;
/* this caused problems when != NULL related to set/reset of state bits */ /* this caused problems when != NULL related to set/reset of state bits */
A->Args.MovedReq.Action = (MovedAction)(MVDACT_SNDACK | MVDACT_RCVACK); A->args.MovedReq.Action = (MovedAction)(MVDACT_SNDACK | MVDACT_RCVACK);
A->Args.MovedReq.source = source; A->args.MovedReq.source = source;
A->Args.MovedReq.destination = destination; A->args.MovedReq.destination = destination;
A->Args.MovedReq.iTotalSize = size; A->args.MovedReq.iTotalSize = size;
/* continuation packet */ /* continuation packet */
@ -267,17 +267,17 @@ static void setup_movedata(struct k_args *A,
pContSend->next = NULL; pContSend->next = NULL;
pContSend->Comm = _K_SVC_PIPE_MOVEDATA_ACK; pContSend->Comm = _K_SVC_PIPE_MOVEDATA_ACK;
pContSend->Args.pipe_xfer_ack.pPipe = pPipe; pContSend->args.pipe_xfer_ack.pPipe = pPipe;
pContSend->Args.pipe_xfer_ack.XferType = XferType; pContSend->args.pipe_xfer_ack.XferType = XferType;
pContSend->Args.pipe_xfer_ack.ID = XferID; pContSend->args.pipe_xfer_ack.ID = XferID;
pContSend->Args.pipe_xfer_ack.iSize = size; pContSend->args.pipe_xfer_ack.iSize = size;
pContRecv->next = NULL; pContRecv->next = NULL;
pContRecv->Comm = _K_SVC_PIPE_MOVEDATA_ACK; pContRecv->Comm = _K_SVC_PIPE_MOVEDATA_ACK;
pContRecv->Args.pipe_xfer_ack.pPipe = pPipe; pContRecv->args.pipe_xfer_ack.pPipe = pPipe;
pContRecv->Args.pipe_xfer_ack.XferType = XferType; pContRecv->args.pipe_xfer_ack.XferType = XferType;
pContRecv->Args.pipe_xfer_ack.ID = XferID; pContRecv->args.pipe_xfer_ack.ID = XferID;
pContRecv->Args.pipe_xfer_ack.iSize = size; pContRecv->args.pipe_xfer_ack.iSize = size;
A->priority = move_priority_compute(pWriter, pReader); A->priority = move_priority_compute(pWriter, pReader);
pContSend->priority = A->priority; pContSend->priority = A->priority;
@ -287,30 +287,30 @@ static void setup_movedata(struct k_args *A,
case XFER_W2B: /* Writer to Buffer */ case XFER_W2B: /* Writer to Buffer */
{ {
__ASSERT_NO_MSG(NULL == pReader); __ASSERT_NO_MSG(NULL == pReader);
pContSend->Args.pipe_xfer_ack.pWriter = pWriter; pContSend->args.pipe_xfer_ack.pWriter = pWriter;
pContRecv->Args.pipe_xfer_ack.pWriter = NULL; pContRecv->args.pipe_xfer_ack.pWriter = NULL;
break; break;
} }
case XFER_B2R: { case XFER_B2R: {
__ASSERT_NO_MSG(NULL == pWriter); __ASSERT_NO_MSG(NULL == pWriter);
pContSend->Args.pipe_xfer_ack.pReader = NULL; pContSend->args.pipe_xfer_ack.pReader = NULL;
pContRecv->Args.pipe_xfer_ack.pReader = pReader; pContRecv->args.pipe_xfer_ack.pReader = pReader;
break; break;
} }
case XFER_W2R: { case XFER_W2R: {
__ASSERT_NO_MSG(NULL != pWriter && NULL != pReader); __ASSERT_NO_MSG(NULL != pWriter && NULL != pReader);
pContSend->Args.pipe_xfer_ack.pWriter = pWriter; pContSend->args.pipe_xfer_ack.pWriter = pWriter;
pContSend->Args.pipe_xfer_ack.pReader = NULL; pContSend->args.pipe_xfer_ack.pReader = NULL;
pContRecv->Args.pipe_xfer_ack.pWriter = NULL; pContRecv->args.pipe_xfer_ack.pWriter = NULL;
pContRecv->Args.pipe_xfer_ack.pReader = pReader; pContRecv->args.pipe_xfer_ack.pReader = pReader;
break; break;
} }
default: default:
__ASSERT_NO_MSG(1 == 0); /* we should not come here */ __ASSERT_NO_MSG(1 == 0); /* we should not come here */
} }
A->Args.MovedReq.Extra.Setup.ContSnd = pContSend; A->args.MovedReq.Extra.Setup.ContSnd = pContSend;
A->Args.MovedReq.Extra.Setup.ContRcv = pContRecv; A->args.MovedReq.Extra.Setup.ContRcv = pContRecv;
/* /*
* (possible optimisation) * (possible optimisation)
@ -330,11 +330,11 @@ static int ReaderInProgressIsBlocked(struct _k_pipe_struct *pPipe,
/* first condition: request cannot wait any longer: must be - /* first condition: request cannot wait any longer: must be -
* (non-blocked) or a finite timed wait with a killed timer */ * (non-blocked) or a finite timed wait with a killed timer */
TimeType = _k_pipe_time_type_get(&pReader->Args); TimeType = _k_pipe_time_type_get(&pReader->args);
option = _k_pipe_option_get(&pReader->Args); option = _k_pipe_option_get(&pReader->args);
if (((_TIME_B == TimeType) && (_ALL_N == option)) || if (((_TIME_B == TimeType) && (_ALL_N == option)) ||
((_TIME_B == TimeType) && (_X_TO_N & option) && ((_TIME_B == TimeType) && (_X_TO_N & option) &&
!(pReader->Args.pipe_xfer_req.iSizeXferred)) !(pReader->args.pipe_xfer_req.iSizeXferred))
#ifdef CANCEL_TIMERS #ifdef CANCEL_TIMERS
|| ((_TIME_BT == TimeType) && pReader->Time.timer) || ((_TIME_BT == TimeType) && pReader->Time.timer)
#endif #endif
@ -355,8 +355,8 @@ static int ReaderInProgressIsBlocked(struct _k_pipe_struct *pPipe,
/* third condition: */ /* third condition: */
iSizeSpaceInReader = iSizeSpaceInReader =
pReader->Args.pipe_xfer_req.iSizeTotal - pReader->args.pipe_xfer_req.iSizeTotal -
pReader->Args.pipe_xfer_req.iSizeXferred; pReader->args.pipe_xfer_req.iSizeXferred;
BuffGetAvailDataTotal(&pPipe->desc, &iAvailBufferData); BuffGetAvailDataTotal(&pPipe->desc, &iAvailBufferData);
if (iAvailBufferData >= iSizeSpaceInReader) { if (iAvailBufferData >= iSizeSpaceInReader) {
return 0; return 0;
@ -376,11 +376,11 @@ static int WriterInProgressIsBlocked(struct _k_pipe_struct *pPipe,
/* first condition: request cannot wait any longer: must be - /* first condition: request cannot wait any longer: must be -
* (non-blocked) or a finite timed wait with a killed timer */ * (non-blocked) or a finite timed wait with a killed timer */
TimeType = _k_pipe_time_type_get(&pWriter->Args); TimeType = _k_pipe_time_type_get(&pWriter->args);
option = _k_pipe_option_get(&pWriter->Args); option = _k_pipe_option_get(&pWriter->args);
if (((_TIME_B == TimeType) && (_ALL_N == option)) || if (((_TIME_B == TimeType) && (_ALL_N == option)) ||
((_TIME_B == TimeType) && (_X_TO_N & option) && ((_TIME_B == TimeType) && (_X_TO_N & option) &&
!(pWriter->Args.pipe_xfer_req.iSizeXferred)) !(pWriter->args.pipe_xfer_req.iSizeXferred))
#ifdef CANCEL_TIMERS #ifdef CANCEL_TIMERS
|| ((_TIME_BT == TimeType) && pWriter->Time.timer) || ((_TIME_BT == TimeType) && pWriter->Time.timer)
#endif #endif
@ -401,8 +401,8 @@ static int WriterInProgressIsBlocked(struct _k_pipe_struct *pPipe,
/* third condition: */ /* third condition: */
iSizeDataInWriter = iSizeDataInWriter =
pWriter->Args.pipe_xfer_req.iSizeTotal - pWriter->args.pipe_xfer_req.iSizeTotal -
pWriter->Args.pipe_xfer_req.iSizeXferred; pWriter->args.pipe_xfer_req.iSizeXferred;
BuffGetFreeSpaceTotal(&pPipe->desc, &iFreeBufferSpace); BuffGetFreeSpaceTotal(&pPipe->desc, &iFreeBufferSpace);
if (iFreeBufferSpace >= iSizeDataInWriter) { if (iFreeBufferSpace >= iSizeDataInWriter) {
return 0; return 0;
@ -438,7 +438,7 @@ static void pipe_read(struct _k_pipe_struct *pPipe, struct k_args *pNewReader)
__ASSERT_NO_MSG((pPipe->Readers == pNewReader) || __ASSERT_NO_MSG((pPipe->Readers == pNewReader) ||
(NULL == pPipe->Readers) || (NULL == pNewReader)); (NULL == pPipe->Readers) || (NULL == pNewReader));
pipe_read_req = &pReader->Args.pipe_xfer_req; pipe_read_req = &pReader->args.pipe_xfer_req;
do { do {
iSize = min(pPipe->desc.iAvailDataCont, iSize = min(pPipe->desc.iAvailDataCont,
@ -507,7 +507,7 @@ static void pipe_write(struct _k_pipe_struct *pPipe, struct k_args *pNewWriter)
__ASSERT_NO_MSG(!((pPipe->Writers != pNewWriter) && __ASSERT_NO_MSG(!((pPipe->Writers != pNewWriter) &&
(NULL != pPipe->Writers) && (NULL != pNewWriter))); (NULL != pPipe->Writers) && (NULL != pNewWriter)));
pipe_write_req = &pWriter->Args.pipe_xfer_req; pipe_write_req = &pWriter->args.pipe_xfer_req;
do { do {
iSize = min((numIterations == 2) ? pPipe->desc.iFreeSpaceCont iSize = min((numIterations == 2) ? pPipe->desc.iFreeSpaceCont
@ -611,8 +611,8 @@ static void pipe_read_write(
(NULL == pPipe->Readers) || (NULL == pNewReader)); (NULL == pPipe->Readers) || (NULL == pNewReader));
/* Preparation */ /* Preparation */
pipe_write_req = &pWriter->Args.pipe_xfer_req; pipe_write_req = &pWriter->args.pipe_xfer_req;
pipe_read_req = &pReader->Args.pipe_xfer_req; pipe_read_req = &pReader->args.pipe_xfer_req;
/* Calculate iT1, iT2 and iT3 */ /* Calculate iT1, iT2 and iT3 */
int iFreeSpaceReader = int iFreeSpaceReader =
@ -660,7 +660,7 @@ static void pipe_read_write(
if (iT2 != 0) { if (iT2 != 0) {
struct k_args *Moved_req; struct k_args *Moved_req;
__ASSERT_NO_MSG(TERM_SATISFIED != pReader->Args.pipe_xfer_req.status); __ASSERT_NO_MSG(TERM_SATISFIED != pReader->args.pipe_xfer_req.status);
GETARGS(Moved_req); GETARGS(Moved_req);
setup_movedata(Moved_req, pPipe, XFER_W2R, pWriter, pReader, setup_movedata(Moved_req, pPipe, XFER_W2R, pWriter, pReader,
@ -679,7 +679,7 @@ static void pipe_read_write(
/* T3 transfer */ /* T3 transfer */
if (iT3 != 0) { if (iT3 != 0) {
__ASSERT_NO_MSG(TERM_SATISFIED != pWriter->Args.pipe_xfer_req.status); __ASSERT_NO_MSG(TERM_SATISFIED != pWriter->args.pipe_xfer_req.status);
pipe_write(pPipe, pWriter); pipe_write(pPipe, pWriter);
} }
} }
@ -709,12 +709,12 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
if (pReader != pNLReader) { if (pReader != pNLReader) {
pNextReader = pPipe->Readers; pNextReader = pPipe->Readers;
if (NULL == pNextReader) { if (NULL == pNextReader) {
if (!(TERM_XXX & pNLReader->Args.pipe_xfer_req.status)) if (!(TERM_XXX & pNLReader->args.pipe_xfer_req.status))
pNextReader = pNLReader; pNextReader = pNLReader;
} }
} else { } else {
/* we already used the extra non-listed Reader */ /* we already used the extra non-listed Reader */
if (TERM_XXX & pReader->Args.pipe_xfer_req.status) { if (TERM_XXX & pReader->args.pipe_xfer_req.status) {
pNextReader = NULL; pNextReader = NULL;
} else { } else {
pNextReader = pReader; /* == pNLReader */ pNextReader = pReader; /* == pNLReader */
@ -730,12 +730,12 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
if (pWriter != pNLWriter) { if (pWriter != pNLWriter) {
pNextWriter = pPipe->Writers; pNextWriter = pPipe->Writers;
if (NULL == pNextWriter) { if (NULL == pNextWriter) {
if (!(TERM_XXX & pNLWriter->Args.pipe_xfer_req.status)) if (!(TERM_XXX & pNLWriter->args.pipe_xfer_req.status))
pNextWriter = pNLWriter; pNextWriter = pNLWriter;
} }
} else { } else {
/* we already used the extra non-listed Writer */ /* we already used the extra non-listed Writer */
if (TERM_XXX & pWriter->Args.pipe_xfer_req.status) { if (TERM_XXX & pWriter->args.pipe_xfer_req.status) {
pNextWriter = NULL; pNextWriter = NULL;
} else { } else {
pNextWriter = pWriter; pNextWriter = pWriter;
@ -758,9 +758,9 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
pWriter = pNextWriter; pWriter = pNextWriter;
if (pWriter) { if (pWriter) {
if (_ALL_N == _k_pipe_option_get(&pWriter->Args) && if (_ALL_N == _k_pipe_option_get(&pWriter->args) &&
(pWriter->Args.pipe_xfer_req.iSizeXferred == 0) && (pWriter->args.pipe_xfer_req.iSizeXferred == 0) &&
_TIME_B != _k_pipe_time_type_get(&pWriter->Args)) { _TIME_B != _k_pipe_time_type_get(&pWriter->args)) {
/* investigate if there is a problem for /* investigate if there is a problem for
* his request to be satisfied * his request to be satisfied
*/ */
@ -772,14 +772,14 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
iSpace2WriteinReaders = CalcFreeReaderSpace(pPipe->Readers); iSpace2WriteinReaders = CalcFreeReaderSpace(pPipe->Readers);
if (pNLReader) if (pNLReader)
iSpace2WriteinReaders += iSpace2WriteinReaders +=
(pNLReader->Args.pipe_xfer_req.iSizeTotal - (pNLReader->args.pipe_xfer_req.iSizeTotal -
pNLReader->Args.pipe_xfer_req.iSizeXferred); pNLReader->args.pipe_xfer_req.iSizeXferred);
BuffGetFreeSpaceTotal(&pPipe->desc, &iFreeBufferSpace); BuffGetFreeSpaceTotal(&pPipe->desc, &iFreeBufferSpace);
iTotalSpace2Write = iTotalSpace2Write =
iFreeBufferSpace + iSpace2WriteinReaders; iFreeBufferSpace + iSpace2WriteinReaders;
iSizeDataInWriter = iSizeDataInWriter =
pWriter->Args.pipe_xfer_req.iSizeTotal - pWriter->args.pipe_xfer_req.iSizeTotal -
pWriter->Args.pipe_xfer_req.iSizeXferred; pWriter->args.pipe_xfer_req.iSizeXferred;
if (iSizeDataInWriter > iTotalSpace2Write) { if (iSizeDataInWriter > iTotalSpace2Write) {
bALLNWriterNoGo = true; bALLNWriterNoGo = true;
@ -787,9 +787,9 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
} }
} }
if (pReader) { if (pReader) {
if (_ALL_N == _k_pipe_option_get(&pReader->Args) && if (_ALL_N == _k_pipe_option_get(&pReader->args) &&
(pReader->Args.pipe_xfer_req.iSizeXferred == 0) && (pReader->args.pipe_xfer_req.iSizeXferred == 0) &&
_TIME_B != _k_pipe_time_type_get(&pReader->Args)) { _TIME_B != _k_pipe_time_type_get(&pReader->args)) {
/* investigate if there is a problem for /* investigate if there is a problem for
* his request to be satisfied * his request to be satisfied
*/ */
@ -801,13 +801,13 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
iData2ReadFromWriters = CalcAvailWriterData(pPipe->Writers); iData2ReadFromWriters = CalcAvailWriterData(pPipe->Writers);
if (pNLWriter) if (pNLWriter)
iData2ReadFromWriters += iData2ReadFromWriters +=
(pNLWriter->Args.pipe_xfer_req.iSizeTotal - (pNLWriter->args.pipe_xfer_req.iSizeTotal -
pNLWriter->Args.pipe_xfer_req.iSizeXferred); pNLWriter->args.pipe_xfer_req.iSizeXferred);
BuffGetAvailDataTotal(&pPipe->desc, &iAvailBufferData); BuffGetAvailDataTotal(&pPipe->desc, &iAvailBufferData);
iTotalData2Read = iAvailBufferData + iData2ReadFromWriters; iTotalData2Read = iAvailBufferData + iData2ReadFromWriters;
iSizeFreeSpaceInReader = iSizeFreeSpaceInReader =
pReader->Args.pipe_xfer_req.iSizeTotal - pReader->args.pipe_xfer_req.iSizeTotal -
pReader->Args.pipe_xfer_req.iSizeXferred; pReader->args.pipe_xfer_req.iSizeXferred;
if (iSizeFreeSpaceInReader > iTotalData2Read) { if (iSizeFreeSpaceInReader > iTotalData2Read) {
bALLNReaderNoGo = true; bALLNReaderNoGo = true;
@ -835,7 +835,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
} else { } else {
#ifdef FORCE_XFER_ON_STALL #ifdef FORCE_XFER_ON_STALL
if (pReader && (_TIME_NB != if (pReader && (_TIME_NB !=
_k_pipe_time_type_get(&pWriter->Args))) { _k_pipe_time_type_get(&pWriter->args))) {
/* force transfer /* force transfer
(we make exception for non-blocked writer) */ (we make exception for non-blocked writer) */
pipe_read_write(pPipe, pWriter, pReader); pipe_read_write(pPipe, pWriter, pReader);
@ -858,7 +858,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
} else { } else {
#ifdef FORCE_XFER_ON_STALL #ifdef FORCE_XFER_ON_STALL
if (pWriter && (_TIME_NB != if (pWriter && (_TIME_NB !=
_k_pipe_time_type_get(&pReader->Args))) { _k_pipe_time_type_get(&pReader->args))) {
/* force transfer /* force transfer
(we make exception for non-blocked reader) */ (we make exception for non-blocked reader) */
pipe_read_write(pPipe, pWriter, pReader); pipe_read_write(pPipe, pWriter, pReader);
@ -927,8 +927,8 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
processing is really blocked (for some reason) processing is really blocked (for some reason)
*/ */
if (pReader && pWriter) { if (pReader && pWriter) {
__ASSERT_NO_MSG(!(TERM_XXX & pReader->Args.pipe_xfer_req.status) && __ASSERT_NO_MSG(!(TERM_XXX & pReader->args.pipe_xfer_req.status) &&
!(TERM_XXX & pWriter->Args.pipe_xfer_req.status)); !(TERM_XXX & pWriter->args.pipe_xfer_req.status));
/* this could be possible when data Xfer operations are jammed /* this could be possible when data Xfer operations are jammed
(out of data Xfer resources e.g.) */ (out of data Xfer resources e.g.) */
@ -949,19 +949,19 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
*/ */
; ;
} else if (pReader) { } else if (pReader) {
__ASSERT_NO_MSG(!(TERM_XXX & pReader->Args.pipe_xfer_req.status)); __ASSERT_NO_MSG(!(TERM_XXX & pReader->args.pipe_xfer_req.status));
/* check if this lonely reader is really blocked, then we will /* check if this lonely reader is really blocked, then we will
delist him delist him
(if he was listed uberhaupt) == EMERGENCY BREAK */ (if he was listed uberhaupt) == EMERGENCY BREAK */
if (ReaderInProgressIsBlocked(pPipe, pReader)) { if (ReaderInProgressIsBlocked(pPipe, pReader)) {
if (_X_TO_N & _k_pipe_option_get(&pReader->Args) && if (_X_TO_N & _k_pipe_option_get(&pReader->args) &&
(pReader->Args.pipe_xfer_req.iSizeXferred != 0)) { (pReader->args.pipe_xfer_req.iSizeXferred != 0)) {
_k_pipe_request_status_set(&pReader->Args.pipe_xfer_req, _k_pipe_request_status_set(&pReader->args.pipe_xfer_req,
TERM_SATISFIED); TERM_SATISFIED);
} else { } else {
/* in all other cases: forced termination */ /* in all other cases: forced termination */
_k_pipe_request_status_set(&pReader->Args.pipe_xfer_req, _k_pipe_request_status_set(&pReader->args.pipe_xfer_req,
TERM_FORCED); TERM_FORCED);
} }
@ -969,7 +969,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
DeListWaiter(pReader); DeListWaiter(pReader);
myfreetimer(&(pReader->Time.timer)); myfreetimer(&(pReader->Time.timer));
} }
if (0 == pReader->Args.pipe_xfer_req.iNbrPendXfers) { if (0 == pReader->args.pipe_xfer_req.iNbrPendXfers) {
pReader->Comm = _K_SVC_PIPE_GET_REPLY; pReader->Comm = _K_SVC_PIPE_GET_REPLY;
/* if terminated and no pending Xfers anymore, /* if terminated and no pending Xfers anymore,
we have to reply */ we have to reply */
@ -980,18 +980,18 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
* later on) */ * later on) */
} }
} else if (pWriter) { } else if (pWriter) {
__ASSERT_NO_MSG(!(TERM_SATISFIED & pWriter->Args.pipe_xfer_req.status)); __ASSERT_NO_MSG(!(TERM_SATISFIED & pWriter->args.pipe_xfer_req.status));
/* check if this lonely Writer is really blocked, then we will /* check if this lonely Writer is really blocked, then we will
delist him (if he was listed uberhaupt) == EMERGENCY BREAK */ delist him (if he was listed uberhaupt) == EMERGENCY BREAK */
if (WriterInProgressIsBlocked(pPipe, pWriter)) { if (WriterInProgressIsBlocked(pPipe, pWriter)) {
if (_X_TO_N & _k_pipe_option_get(&pWriter->Args) && if (_X_TO_N & _k_pipe_option_get(&pWriter->args) &&
(pWriter->Args.pipe_xfer_req.iSizeXferred != 0)) { (pWriter->args.pipe_xfer_req.iSizeXferred != 0)) {
_k_pipe_request_status_set(&pWriter->Args.pipe_xfer_req, _k_pipe_request_status_set(&pWriter->args.pipe_xfer_req,
TERM_SATISFIED); TERM_SATISFIED);
} else { } else {
/* in all other cases: forced termination */ /* in all other cases: forced termination */
_k_pipe_request_status_set(&pWriter->Args.pipe_xfer_req, _k_pipe_request_status_set(&pWriter->args.pipe_xfer_req,
TERM_FORCED); TERM_FORCED);
} }
@ -999,7 +999,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
DeListWaiter(pWriter); DeListWaiter(pWriter);
myfreetimer(&(pWriter->Time.timer)); myfreetimer(&(pWriter->Time.timer));
} }
if (0 == pWriter->Args.pipe_xfer_req.iNbrPendXfers) { if (0 == pWriter->args.pipe_xfer_req.iNbrPendXfers) {
pWriter->Comm = _K_SVC_PIPE_PUT_REPLY; pWriter->Comm = _K_SVC_PIPE_PUT_REPLY;
/* if terminated and no pending Xfers anymore, /* if terminated and no pending Xfers anymore,
we have to reply */ we have to reply */
@ -1019,7 +1019,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
#ifdef CANCEL_TIMERS #ifdef CANCEL_TIMERS
if (pReader) { if (pReader) {
if (pReader->Args.pipe_xfer_req.iSizeXferred != 0) { if (pReader->args.pipe_xfer_req.iSizeXferred != 0) {
if (pReader->Head) { if (pReader->Head) {
myfreetimer(&(pReader->Time.timer)); myfreetimer(&(pReader->Time.timer));
/* do not delist however */ /* do not delist however */
@ -1027,7 +1027,7 @@ void _k_pipe_process(struct _k_pipe_struct *pPipe, struct k_args *pNLWriter,
} }
} }
if (pWriter) { if (pWriter) {
if (pWriter->Args.pipe_xfer_req.iSizeXferred != 0) { if (pWriter->args.pipe_xfer_req.iSizeXferred != 0) {
if (pWriter->Head) { if (pWriter->Head) {
myfreetimer(&(pWriter->Time.timer)); myfreetimer(&(pWriter->Time.timer));
/* do not delist however */ /* do not delist however */

66
kernel/microkernel/k_semaphore.c
View file

@ -103,14 +103,14 @@ void _k_sem_group_wait(struct k_args *R)
struct k_args *A = R->Ctxt.args; struct k_args *A = R->Ctxt.args;
FREEARGS(R); FREEARGS(R);
if (--(A->Args.s1.nsem) == 0) { if (--(A->args.s1.nsem) == 0) {
_k_state_bit_reset(A->Ctxt.task, TF_LIST); _k_state_bit_reset(A->Ctxt.task, TF_LIST);
} }
} }
void _k_sem_group_wait_cancel(struct k_args *A) void _k_sem_group_wait_cancel(struct k_args *A)
{ {
struct _k_sem_struct *S = (struct _k_sem_struct *)A->Args.s1.sema; struct _k_sem_struct *S = (struct _k_sem_struct *)A->args.s1.sema;
struct k_args *X = S->Waiters; struct k_args *X = S->Waiters;
struct k_args *Y = NULL; struct k_args *Y = NULL;
@ -137,9 +137,9 @@ void _k_sem_group_wait_cancel(struct k_args *A)
* timer expiry occurs between the update of the packet state * timer expiry occurs between the update of the packet state
* and the processing of the WAITMRDY packet. * and the processing of the WAITMRDY packet.
*/ */
if (unlikely(waitTaskArgs->Args.s1.sema == if (unlikely(waitTaskArgs->args.s1.sema ==
ENDLIST)) { ENDLIST)) {
waitTaskArgs->Args.s1.sema = A->Args.s1.sema; waitTaskArgs->args.s1.sema = A->args.s1.sema;
} else { } else {
signal_semaphore(1, S); signal_semaphore(1, S);
} }
@ -166,7 +166,7 @@ void _k_sem_group_wait_cancel(struct k_args *A)
void _k_sem_group_wait_accept(struct k_args *A) void _k_sem_group_wait_accept(struct k_args *A)
{ {
struct _k_sem_struct *S = (struct _k_sem_struct *)A->Args.s1.sema; struct _k_sem_struct *S = (struct _k_sem_struct *)A->args.s1.sema;
struct k_args *X = S->Waiters; struct k_args *X = S->Waiters;
struct k_args *Y = NULL; struct k_args *Y = NULL;
@ -202,17 +202,17 @@ void _k_sem_group_wait_timeout(struct k_args *A)
} }
#endif #endif
L = A->Args.s1.list; L = A->args.s1.list;
while (*L != ENDLIST) { while (*L != ENDLIST) {
struct k_args *R; struct k_args *R;
GETARGS(R); GETARGS(R);
R->priority = A->priority; R->priority = A->priority;
R->Comm = R->Comm =
((*L == A->Args.s1.sema) ? ((*L == A->args.s1.sema) ?
_K_SVC_SEM_GROUP_WAIT_ACCEPT : _K_SVC_SEM_GROUP_WAIT_CANCEL); _K_SVC_SEM_GROUP_WAIT_ACCEPT : _K_SVC_SEM_GROUP_WAIT_CANCEL);
R->Ctxt.args = A; R->Ctxt.args = A;
R->Args.s1.sema = *L++; R->args.s1.sema = *L++;
SENDARGS(R); SENDARGS(R);
} }
} }
@ -221,8 +221,8 @@ void _k_sem_group_ready(struct k_args *R)
{ {
struct k_args *A = R->Ctxt.args; struct k_args *A = R->Ctxt.args;
if (A->Args.s1.sema == ENDLIST) { if (A->args.s1.sema == ENDLIST) {
A->Args.s1.sema = R->Args.s1.sema; A->args.s1.sema = R->args.s1.sema;
A->Comm = _K_SVC_SEM_GROUP_WAIT_TIMEOUT; A->Comm = _K_SVC_SEM_GROUP_WAIT_TIMEOUT;
#ifdef CONFIG_SYS_CLOCK_EXISTS #ifdef CONFIG_SYS_CLOCK_EXISTS
if (A->Time.timer) { if (A->Time.timer) {
@ -256,7 +256,7 @@ void _k_sem_wait_reply_timeout(struct k_args *A)
void _k_sem_group_wait_request(struct k_args *A) void _k_sem_group_wait_request(struct k_args *A)
{ {
struct _k_sem_struct *S = (struct _k_sem_struct *)A->Args.s1.sema; struct _k_sem_struct *S = (struct _k_sem_struct *)A->args.s1.sema;
struct k_args *X = S->Waiters; struct k_args *X = S->Waiters;
struct k_args *Y = NULL; struct k_args *Y = NULL;
@ -292,9 +292,9 @@ void _k_sem_group_wait_any(struct k_args *A)
{ {
ksem_t *L; ksem_t *L;
L = A->Args.s1.list; L = A->args.s1.list;
A->Args.s1.sema = ENDLIST; A->args.s1.sema = ENDLIST;
A->Args.s1.nsem = 0; A->args.s1.nsem = 0;
if (*L == ENDLIST) { if (*L == ENDLIST) {
return; return;
@ -307,9 +307,9 @@ void _k_sem_group_wait_any(struct k_args *A)
R->priority = _k_current_task->priority; R->priority = _k_current_task->priority;
R->Comm = _K_SVC_SEM_GROUP_WAIT_REQUEST; R->Comm = _K_SVC_SEM_GROUP_WAIT_REQUEST;
R->Ctxt.args = A; R->Ctxt.args = A;
R->Args.s1.sema = *L++; R->args.s1.sema = *L++;
SENDARGS(R); SENDARGS(R);
(A->Args.s1.nsem)++; (A->args.s1.nsem)++;
} }
A->Ctxt.task = _k_current_task; A->Ctxt.task = _k_current_task;
@ -332,7 +332,7 @@ void _k_sem_wait_request(struct k_args *A)
struct _k_sem_struct *S; struct _k_sem_struct *S;
uint32_t Sid; uint32_t Sid;
Sid = A->Args.s1.sema; Sid = A->args.s1.sema;
S = (struct _k_sem_struct *)Sid; S = (struct _k_sem_struct *)Sid;
if (S->Level) { if (S->Level) {
@ -363,7 +363,7 @@ int _task_sem_take(ksem_t sema, int32_t time)
A.Comm = _K_SVC_SEM_WAIT_REQUEST; A.Comm = _K_SVC_SEM_WAIT_REQUEST;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.s1.sema = sema; A.args.s1.sema = sema;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }
@ -375,14 +375,14 @@ ksem_t _task_sem_group_take(ksemg_t group, int32_t time)
A.Comm = _K_SVC_SEM_GROUP_WAIT_ANY; A.Comm = _K_SVC_SEM_GROUP_WAIT_ANY;
A.priority = _k_current_task->priority; A.priority = _k_current_task->priority;
A.Time.ticks = time; A.Time.ticks = time;
A.Args.s1.list = group; A.args.s1.list = group;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Args.s1.sema; return A.args.s1.sema;
} }
void _k_sem_signal(struct k_args *A) void _k_sem_signal(struct k_args *A)
{ {
uint32_t Sid = A->Args.s1.sema; uint32_t Sid = A->args.s1.sema;
struct _k_sem_struct *S = (struct _k_sem_struct *)Sid; struct _k_sem_struct *S = (struct _k_sem_struct *)Sid;
signal_semaphore(1, S); signal_semaphore(1, S);
@ -390,9 +390,9 @@ void _k_sem_signal(struct k_args *A)
void _k_sem_group_signal(struct k_args *A) void _k_sem_group_signal(struct k_args *A)
{ {
ksem_t *L = A->Args.s1.list; ksem_t *L = A->args.s1.list;
while ((A->Args.s1.sema = *L++) != ENDLIST) { while ((A->args.s1.sema = *L++) != ENDLIST) {
_k_sem_signal(A); _k_sem_signal(A);
} }
} }
@ -402,7 +402,7 @@ void task_sem_give(ksem_t sema)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_SIGNAL; A.Comm = _K_SVC_SEM_SIGNAL;
A.Args.s1.sema = sema; A.args.s1.sema = sema;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -411,7 +411,7 @@ void task_sem_group_give(ksemg_t group)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_GROUP_SIGNAL; A.Comm = _K_SVC_SEM_GROUP_SIGNAL;
A.Args.s1.list = group; A.args.s1.list = group;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -429,14 +429,14 @@ void isr_sem_give(ksem_t sema, struct cmd_pkt_set *pSet)
pCommand = (struct k_args *)_cmd_pkt_get(pSet); pCommand = (struct k_args *)_cmd_pkt_get(pSet);
pCommand->Comm = _K_SVC_SEM_SIGNAL; pCommand->Comm = _K_SVC_SEM_SIGNAL;
pCommand->Args.s1.sema = sema; pCommand->args.s1.sema = sema;
nano_isr_stack_push(&_k_command_stack, (uint32_t)pCommand); nano_isr_stack_push(&_k_command_stack, (uint32_t)pCommand);
} }
void _k_sem_reset(struct k_args *A) void _k_sem_reset(struct k_args *A)
{ {
uint32_t Sid = A->Args.s1.sema; uint32_t Sid = A->args.s1.sema;
struct _k_sem_struct *S = (struct _k_sem_struct *)Sid; struct _k_sem_struct *S = (struct _k_sem_struct *)Sid;
S->Level = 0; S->Level = 0;
@ -444,9 +444,9 @@ void _k_sem_reset(struct k_args *A)
void _k_sem_group_reset(struct k_args *A) void _k_sem_group_reset(struct k_args *A)
{ {
ksem_t *L = A->Args.s1.list; ksem_t *L = A->args.s1.list;
while ((A->Args.s1.sema = *L++) != ENDLIST) { while ((A->args.s1.sema = *L++) != ENDLIST) {
_k_sem_reset(A); _k_sem_reset(A);
} }
} }
@ -456,7 +456,7 @@ void task_sem_reset(ksem_t sema)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_RESET; A.Comm = _K_SVC_SEM_RESET;
A.Args.s1.sema = sema; A.args.s1.sema = sema;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -465,7 +465,7 @@ void task_sem_group_reset(ksemg_t group)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_GROUP_RESET; A.Comm = _K_SVC_SEM_GROUP_RESET;
A.Args.s1.list = group; A.args.s1.list = group;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -474,7 +474,7 @@ void _k_sem_inquiry(struct k_args *A)
struct _k_sem_struct *S; struct _k_sem_struct *S;
uint32_t Sid; uint32_t Sid;
Sid = A->Args.s1.sema; Sid = A->args.s1.sema;
S = (struct _k_sem_struct *)Sid; S = (struct _k_sem_struct *)Sid;
A->Time.rcode = S->Level; A->Time.rcode = S->Level;
} }
@ -484,7 +484,7 @@ int task_sem_count_get(ksem_t sema)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_SEM_INQUIRY; A.Comm = _K_SVC_SEM_INQUIRY;
A.Args.s1.sema = sema; A.args.s1.sema = sema;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return A.Time.rcode; return A.Time.rcode;
} }

24
kernel/microkernel/k_task.c
View file

@ -328,10 +328,10 @@ void task_abort_handler_set(void (*func)(void) /* abort handler */
void _k_task_op(struct k_args *A) void _k_task_op(struct k_args *A)
{ {
ktask_t Tid = A->Args.g1.task; ktask_t Tid = A->args.g1.task;
struct k_task *X = (struct k_task *)Tid; struct k_task *X = (struct k_task *)Tid;
switch (A->Args.g1.opt) { switch (A->args.g1.opt) {
case TASK_START: case TASK_START:
start_task(X, X->fn_start); start_task(X, X->fn_start);
break; break;
@ -367,8 +367,8 @@ void _task_ioctl(ktask_t task, /* task on which to operate */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TASK_OP; A.Comm = _K_SVC_TASK_OP;
A.Args.g1.task = task; A.args.g1.task = task;
A.Args.g1.opt = opt; A.args.g1.opt = opt;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -385,8 +385,8 @@ void _task_ioctl(ktask_t task, /* task on which to operate */
void _k_task_group_op(struct k_args *A) void _k_task_group_op(struct k_args *A)
{ {
ktask_group_t grp = A->Args.g1.group; ktask_group_t grp = A->args.g1.group;
int opt = A->Args.g1.opt; int opt = A->args.g1.opt;
struct k_task *X; struct k_task *X;
#ifdef CONFIG_TASK_DEBUG #ifdef CONFIG_TASK_DEBUG
@ -437,8 +437,8 @@ void _task_group_ioctl(ktask_group_t group, /* task group */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TASK_GROUP_OP; A.Comm = _K_SVC_TASK_GROUP_OP;
A.Args.g1.group = group; A.args.g1.group = group;
A.Args.g1.opt = opt; A.args.g1.opt = opt;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -499,11 +499,11 @@ kpriority_t task_priority_get(void)
void _k_task_priority_set(struct k_args *A) void _k_task_priority_set(struct k_args *A)
{ {
ktask_t Tid = A->Args.g1.task; ktask_t Tid = A->args.g1.task;
struct k_task *X = (struct k_task *)Tid; struct k_task *X = (struct k_task *)Tid;
_k_state_bit_set(X, TF_PRIO); _k_state_bit_set(X, TF_PRIO);
X->priority = A->Args.g1.prio; X->priority = A->args.g1.prio;
_k_state_bit_reset(X, TF_PRIO); _k_state_bit_reset(X, TF_PRIO);
if (A->alloc) if (A->alloc)
@ -532,8 +532,8 @@ void task_priority_set(ktask_t task, /* task whose priority is to be set */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TASK_PRIORITY_SET; A.Comm = _K_SVC_TASK_PRIORITY_SET;
A.Args.g1.task = task; A.args.g1.task = task;
A.Args.g1.prio = prio; A.args.g1.prio = prio;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }

8
kernel/microkernel/k_task_monitor.c
View file

@ -110,13 +110,13 @@ void _k_task_monitor_args(struct k_args *A)
void _k_task_monitor_read(struct k_args *A) void _k_task_monitor_read(struct k_args *A)
{ {
A->Args.z4.nrec = k_monitor_nrec; A->args.z4.nrec = k_monitor_nrec;
if (A->Args.z4.rind < k_monitor_nrec) { if (A->args.z4.rind < k_monitor_nrec) {
int i = K_monitor_wind - k_monitor_nrec + A->Args.z4.rind; int i = K_monitor_wind - k_monitor_nrec + A->args.z4.rind;
if (i < 0) { if (i < 0) {
i += k_monitor_capacity; i += k_monitor_capacity;
} }
A->Args.z4.mrec = k_monitor_buff[i]; A->args.z4.mrec = k_monitor_buff[i];
} }
} }

10
kernel/microkernel/k_ticker.c
View file

@ -238,8 +238,8 @@ void _k_time_elapse(struct k_args *P)
{ {
int64_t now = task_tick_get(); int64_t now = task_tick_get();
P->Args.c1.time2 = now - P->Args.c1.time1; P->args.c1.time2 = now - P->args.c1.time1;
P->Args.c1.time1 = now; P->args.c1.time1 = now;
} }
int64_t task_tick_delta(int64_t *reftime /* pointer to reference time */ int64_t task_tick_delta(int64_t *reftime /* pointer to reference time */
@ -248,8 +248,8 @@ int64_t task_tick_delta(int64_t *reftime /* pointer to reference time */
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TIME_ELAPSE; A.Comm = _K_SVC_TIME_ELAPSE;
A.Args.c1.time1 = *reftime; A.args.c1.time1 = *reftime;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
*reftime = A.Args.c1.time1; *reftime = A.args.c1.time1;
return A.Args.c1.time2; return A.args.c1.time2;
} }

42
kernel/microkernel/k_timer.c
View file

@ -115,7 +115,7 @@ void _k_timeout_alloc(struct k_args *P)
GETTIMER(T); GETTIMER(T);
T->duration = P->Time.ticks; T->duration = P->Time.ticks;
T->period = 0; T->period = 0;
T->Args = P; T->args = P;
_k_timer_enlist(T); _k_timer_enlist(T);
P->Time.timer = T; P->Time.timer = T;
} }
@ -203,7 +203,7 @@ void _k_timer_list_update(int ticks)
} else { } else {
T->duration = -1; T->duration = -1;
} }
TO_ALIST(&_k_command_stack, T->Args); TO_ALIST(&_k_command_stack, T->args);
ticks = 0; /* don't decrement duration for subsequent timer(s) */ ticks = 0; /* don't decrement duration for subsequent timer(s) */
} }
@ -227,10 +227,10 @@ void _k_timer_alloc(struct k_args *P)
struct k_args *A; struct k_args *A;
GETTIMER(T); GETTIMER(T);
P->Args.c1.timer = T; P->args.c1.timer = T;
GETARGS(A); GETARGS(A);
T->Args = A; T->args = A;
T->duration = -1; /* -1 indicates that timer is disabled */ T->duration = -1; /* -1 indicates that timer is disabled */
} }
@ -248,7 +248,7 @@ ktimer_t task_timer_alloc(void)
A.Comm = _K_SVC_TIMER_ALLOC; A.Comm = _K_SVC_TIMER_ALLOC;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
return (ktimer_t)A.Args.c1.timer; return (ktimer_t)A.args.c1.timer;
} }
/** /**
@ -263,8 +263,8 @@ ktimer_t task_timer_alloc(void)
void _k_timer_dealloc(struct k_args *P) void _k_timer_dealloc(struct k_args *P)
{ {
struct k_timer *T = P->Args.c1.timer; struct k_timer *T = P->args.c1.timer;
struct k_args *A = T->Args; struct k_args *A = T->args;
if (T->duration != -1) if (T->duration != -1)
_k_timer_delist(T); _k_timer_delist(T);
@ -290,7 +290,7 @@ void task_timer_free(ktimer_t timer)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TIMER_DEALLOC; A.Comm = _K_SVC_TIMER_DEALLOC;
A.Args.c1.timer = (struct k_timer *)timer; A.args.c1.timer = (struct k_timer *)timer;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -308,14 +308,14 @@ void task_timer_free(ktimer_t timer)
void _k_timer_start(struct k_args *P) void _k_timer_start(struct k_args *P)
{ {
struct k_timer *T = P->Args.c1.timer; /* ptr to the timer to start */ struct k_timer *T = P->args.c1.timer; /* ptr to the timer to start */
if (T->duration != -1) { /* Stop the timer if it is active */ if (T->duration != -1) { /* Stop the timer if it is active */
_k_timer_delist(T); _k_timer_delist(T);
} }
T->duration = (int32_t)P->Args.c1.time1; /* Set the initial delay */ T->duration = (int32_t)P->args.c1.time1; /* Set the initial delay */
T->period = P->Args.c1.time2; /* Set the period */ T->period = P->args.c1.time2; /* Set the period */
/* /*
* Either the initial delay and/or the period is invalid. Mark * Either the initial delay and/or the period is invalid. Mark
@ -327,9 +327,9 @@ void _k_timer_start(struct k_args *P)
} }
/* Track the semaphore to signal for when the timer expires. */ /* Track the semaphore to signal for when the timer expires. */
if (P->Args.c1.sema != _USE_CURRENT_SEM) { if (P->args.c1.sema != _USE_CURRENT_SEM) {
T->Args->Comm = _K_SVC_SEM_SIGNAL; T->args->Comm = _K_SVC_SEM_SIGNAL;
T->Args->Args.s1.sema = P->Args.c1.sema; T->args->args.s1.sema = P->args.c1.sema;
} }
_k_timer_enlist(T); _k_timer_enlist(T);
} }
@ -365,10 +365,10 @@ void task_timer_start(ktimer_t timer, int32_t duration, int32_t period,
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TIMER_START; A.Comm = _K_SVC_TIMER_START;
A.Args.c1.timer = (struct k_timer *)timer; A.args.c1.timer = (struct k_timer *)timer;
A.Args.c1.time1 = (int64_t)duration; A.args.c1.time1 = (int64_t)duration;
A.Args.c1.time2 = period; A.args.c1.time2 = period;
A.Args.c1.sema = sema; A.args.c1.sema = sema;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -384,7 +384,7 @@ void task_timer_start(ktimer_t timer, int32_t duration, int32_t period,
void _k_timer_stop(struct k_args *P) void _k_timer_stop(struct k_args *P)
{ {
struct k_timer *T = P->Args.c1.timer; struct k_timer *T = P->args.c1.timer;
if (T->duration != -1) if (T->duration != -1)
_k_timer_delist(T); _k_timer_delist(T);
@ -407,7 +407,7 @@ void task_timer_stop(ktimer_t timer)
struct k_args A; struct k_args A;
A.Comm = _K_SVC_TIMER_STOP; A.Comm = _K_SVC_TIMER_STOP;
A.Args.c1.timer = (struct k_timer *)timer; A.args.c1.timer = (struct k_timer *)timer;
KERNEL_ENTRY(&A); KERNEL_ENTRY(&A);
} }
@ -454,7 +454,7 @@ void _k_task_sleep(struct k_args *P)
GETTIMER(T); GETTIMER(T);
T->duration = P->Time.ticks; T->duration = P->Time.ticks;
T->period = 0; T->period = 0;
T->Args = P; T->args = P;
P->Comm = _K_SVC_TASK_WAKEUP; P->Comm = _K_SVC_TASK_WAKEUP;
P->Ctxt.task = _k_current_task; P->Ctxt.task = _k_current_task;