/* Encodes the property APDU and returns the length,
or sets the error, and returns -1 */
int Encode_Property_APDU(
uint8_t * apdu,
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance,
BACNET_PROPERTY_ID property,
int32_t array_index,
BACNET_ERROR_CLASS * error_class,
BACNET_ERROR_CODE * error_code)
{
int apdu_len = -1;
read_property_function object_rp = NULL;
object_valid_instance_function object_valid = NULL;
/* initialize the default return values */
*error_class = ERROR_CLASS_OBJECT;
*error_code = ERROR_CODE_UNKNOWN_OBJECT;
/* handle each object type */
if (object_type < MAX_BACNET_OBJECT_TYPE) {
object_rp = Read_Property[object_type];
object_valid = Valid_Instance[object_type];
}
if (object_rp && object_valid && object_valid(object_instance)) {
apdu_len =
object_rp(&apdu[0], object_instance, property, array_index,
error_class, error_code);
} else {
*error_class = ERROR_CLASS_OBJECT;
*error_code = ERROR_CODE_UNSUPPORTED_OBJECT_TYPE;
}
return apdu_len;
}
/*
* Send a reply message.
*
* The target object must be the object that we are receiving.
* Otherwise, this function will be failed.
*/
int
msg_reply(object_t obj, void *msg, size_t size)
{
thread_t t;
size_t len;
if (!user_area(msg))
return EFAULT;
sched_lock();
if (!object_valid(obj) || obj != curthread->recvobj) {
sched_unlock();
return EINVAL;
}
/*
* Check if sender still exists
*/
if (curthread->sender == NULL) {
/* Clear receive state */
curthread->recvobj = NULL;
sched_unlock();
return EINVAL;
}
/*
* Copy a message to the sender's buffer.
*/
t = curthread->sender;
len = MIN(size, t->msgsize);
if (len > 0) {
if (copyin(msg, t->msgaddr, len)) {
sched_unlock();
return EFAULT;
}
}
/*
* Wakeup sender with no error.
*/
sched_unsleep(t, 0);
t->receiver = NULL;
/* Clear transmit state */
curthread->sender = NULL;
curthread->recvobj = NULL;
sched_unlock();
return 0;
}
/*
* Send a reply message.
*
* The target object must be an appropriate object that current
* thread has been received from. Otherwise, this function will
* be failed.
*
* Since the target object may already be deleted, we can not
* access the data of the object within this routine.
*/
int
msg_reply(object_t obj, void *msg, size_t size)
{
thread_t th;
size_t len;
int err = 0;
if (!user_area(msg))
return EFAULT;
sched_lock();
if (!object_valid(obj) || obj != cur_thread->recvobj) {
sched_unlock();
return EINVAL;
}
/*
* Check if sender still exists
*/
if (cur_thread->sender == NULL) {
err = EINVAL;
goto out;
}
/*
* Copy message to the sender's buffer.
*/
th = cur_thread->sender;
len = min(size, th->msgsize);
if (len > 0) {
if (umem_copyin(msg, th->msgaddr, len)) {
sched_unlock();
return EFAULT;
}
}
/*
* Wakeup sender with no error.
*/
sched_unsleep(th, 0);
th->receiver = NULL;
out:
/* Clear transmit state */
cur_thread->sender = NULL;
cur_thread->recvobj = NULL;
sched_unlock();
return err;
}
/*
* Send a message.
*
* The current thread will be blocked until any other thread
* receives and reply the message. A thread can send a
* message to any object if it knows the object id.
*/
int
msg_send(object_t obj, void *msg, size_t size)
{
struct msg_header *hdr;
thread_t t;
void *kmsg;
int rc;
if (!user_area(msg))
return EFAULT;
if (size < sizeof(struct msg_header))
return EINVAL;
sched_lock();
if (!object_valid(obj)) {
sched_unlock();
return EINVAL;
}
/*
* A thread can not send a message when it is
* already receiving from the target object.
* It will obviously cause a deadlock.
*/
if (obj == curthread->recvobj) {
sched_unlock();
return EDEADLK;
}
/*
* Translate message address to the kernel linear
* address. So that a receiver thread can access
* the message via kernel pointer. We can catch
* the page fault here.
*/
if ((kmsg = kmem_map(msg, size)) == NULL) {
sched_unlock();
return EFAULT;
}
curthread->msgaddr = kmsg;
curthread->msgsize = size;
/*
* The sender ID is filled in the message header
* by the kernel. So, the receiver can trust it.
*/
hdr = (struct msg_header *)kmsg;
hdr->task = curtask;
/*
* If receiver already exists, wake it up.
* The highest priority thread can get the message.
*/
if (!queue_empty(&obj->recvq)) {
t = msg_dequeue(&obj->recvq);
sched_unsleep(t, 0);
}
/*
* Sleep until we get a reply message.
* Note: Do not touch any data in the object
* structure after we wakeup. This is because the
* target object may be deleted while we are sleeping.
*/
curthread->sendobj = obj;
msg_enqueue(&obj->sendq, curthread);
rc = sched_sleep(&ipc_event);
if (rc == SLP_INTR)
queue_remove(&curthread->ipc_link);
curthread->sendobj = NULL;
sched_unlock();
/*
* Check sleep result.
*/
switch (rc) {
case SLP_BREAK:
return EAGAIN; /* Receiver has been terminated */
case SLP_INVAL:
return EINVAL; /* Object has been deleted */
case SLP_INTR:
return EINTR; /* Exception */
default:
/* DO NOTHING */
break;
}
return 0;
}
/*
* Receive a message.
*
* A thread can receive a message from the object which was
* created by any thread belongs to same task. If the message
* has not reached yet, it blocks until any message comes in.
*
* The size argument specifies the "maximum" size of the message
* buffer to receive. If the sent message is larger than this
* size, the kernel will automatically clip the message to this
* maximum buffer size.
*
* When a message is received, the sender thread is removed from
* object's send queue. So, another thread can receive the
* subsequent message from that object. This is important for
* the multi-thread server which must receive multiple messages
* simultaneously.
*/
int
msg_receive(object_t obj, void *msg, size_t size)
{
thread_t t;
size_t len;
int rc, error = 0;
if (!user_area(msg))
return EFAULT;
sched_lock();
if (!object_valid(obj)) {
sched_unlock();
return EINVAL;
}
if (obj->owner != curtask) {
sched_unlock();
return EACCES;
}
/*
* Check if this thread finished previous receive
* operation. A thread can not receive different
* messages at once.
*/
if (curthread->recvobj) {
sched_unlock();
return EBUSY;
}
curthread->recvobj = obj;
/*
* If no message exists, wait until message arrives.
*/
while (queue_empty(&obj->sendq)) {
/*
* Block until someone sends a message.
*/
msg_enqueue(&obj->recvq, curthread);
rc = sched_sleep(&ipc_event);
if (rc != 0) {
/*
* Receive is failed due to some reasons.
*/
switch (rc) {
case SLP_INVAL:
error = EINVAL; /* Object has been deleted */
break;
case SLP_INTR:
queue_remove(&curthread->ipc_link);
error = EINTR; /* Got exception */
break;
default:
panic("msg_receive");
break;
}
curthread->recvobj = NULL;
sched_unlock();
return error;
}
/*
* Check the existence of the sender thread again.
* Even if this thread is woken by the sender thread,
* the message may be received by another thread.
* This may happen when another high priority thread
* becomes runnable before we receive the message.
*/
}
t = msg_dequeue(&obj->sendq);
/*
* Copy out the message to the user-space.
*/
len = MIN(size, t->msgsize);
if (len > 0) {
if (copyout(t->msgaddr, msg, len)) {
msg_enqueue(&obj->sendq, t);
curthread->recvobj = NULL;
sched_unlock();
return EFAULT;
}
}
/*
* Detach the message from the target object.
*/
curthread->sender = t;
t->receiver = curthread;
sched_unlock();
return error;
}
/*
* Send a message.
*
* The current thread will be blocked until any other thread
* receives the message and calls msg_reply() for the target
* object. When new message has been reached to the object, it
* will be received by highest priority thread waiting for
* that message. A thread can send a message to any object if
* it knows the object id.
*/
int
msg_send(object_t obj, void *msg, size_t size, u_long timeout)
{
struct msg_header *hdr;
thread_t th;
void *kmsg;
int rc;
if (!user_area(msg))
return EFAULT;
if (size < sizeof(struct msg_header))
return EINVAL;
sched_lock();
if (!object_valid(obj)) {
sched_unlock();
return EINVAL;
}
if (obj->owner != cur_task() && !task_capable(CAP_IPC)) {
sched_unlock();
return EPERM;
}
/*
* A thread can not send a message when the
* thread is already receiving from the target
* object. This will obviously cause a deadlock.
*/
if (obj == cur_thread->recvobj) {
sched_unlock();
return EDEADLK;
}
/*
* Translate message address to the kernel linear
* address. So that a receiver thread can access
* the message via kernel pointer. We can catch
* the page fault here.
*/
if ((kmsg = kmem_map(msg, size)) == NULL) {
/* Error - no physical address for the message */
sched_unlock();
return EFAULT;
}
/*
* The sender ID in the message header is filled
* by the kernel. So, the receiver can trust it.
*/
hdr = (struct msg_header *)kmsg;
hdr->task = cur_task();
/* Save information about the message block. */
cur_thread->msgaddr = kmsg;
cur_thread->msgsize = size;
/*
* If receiver already exists, wake it up.
* Highest priority thread will get this message.
*/
if (!queue_empty(&obj->recvq)) {
th = msg_dequeue(&obj->recvq);
sched_unsleep(th, 0);
}
/*
* Sleep until we get a reply message.
* Note: Do not touch any data in the object
* structure after we wakeup. This is because the
* target object may be deleted during we were
* sleeping.
*/
cur_thread->sendobj = obj;
msg_enqueue(&obj->sendq, cur_thread);
rc = sched_tsleep(&ipc_event, timeout);
if (rc == SLP_INTR)
queue_remove(&cur_thread->ipc_link);
cur_thread->sendobj = NULL;
sched_unlock();
/*
* Check sleep result.
*/
switch (rc) {
case SLP_BREAK:
return EAGAIN; /* Receiver has been terminated */
case SLP_INVAL:
return EINVAL; /* Object has been deleted */
case SLP_INTR:
return EINTR; /* Exception */
case SLP_TIMEOUT:
return ETIMEDOUT; /* Timeout */
default:
/* DO NOTHING */
break;
}
return 0;
}
/*
* Receive a message.
*
* A thread can receive a message from the object which was
* created by any thread belongs to same task. If the message
* has not arrived yet, it blocks until any message comes in.
*
* The size argument specifies the "maximum" size of the message
* buffer to receive. If the sent message is larger than this
* size, the kernel will automatically clip the message to the
* receive buffer size.
*
* When message is received, the sender thread is removed from
* object's send queue. So, another thread can receive the
* subsequent message from that object. This is important for
* the multi-thread server which receives some messages
* simultaneously.
*/
int
msg_receive(object_t obj, void *msg, size_t size, u_long timeout)
{
thread_t th;
size_t len;
int rc, err = 0;
if (!user_area(msg))
return EFAULT;
sched_lock();
if (!object_valid(obj)) {
err = EINVAL;
goto out;
}
if (obj->owner != cur_task()) {
err = EACCES;
goto out;
}
/*
* Check if this thread finished previous receive
* operation. A thread can not receive different
* messages at once.
*/
if (cur_thread->recvobj) {
err = EBUSY;
goto out;
}
cur_thread->recvobj = obj;
/*
* If no message exists, wait until message arrives.
*/
while (queue_empty(&obj->sendq)) {
/*
* Block until someone sends the message.
*/
msg_enqueue(&obj->recvq, cur_thread);
rc = sched_tsleep(&ipc_event, timeout);
if (rc != 0) {
/*
* Receive is failed due to some reasons.
*/
switch (rc) {
case SLP_INVAL:
err = EINVAL; /* Object has been deleted */
break;
case SLP_INTR:
queue_remove(&cur_thread->ipc_link);
err = EINTR; /* Got exception */
break;
case SLP_TIMEOUT:
err = ETIMEDOUT; /* Timeout */
break;
default:
panic("msg_receive");
break;
}
cur_thread->recvobj = NULL;
goto out;
}
/*
* Even if this thread is woken by the sender thread,
* the message may be received by another thread
* before this thread runs. This can occur when
* higher priority thread becomes runnable at that
* time. So, it is necessary to check the existence
* of the sender, again.
*/
}
th = msg_dequeue(&obj->sendq);
/*
* Copy out the message to the user-space.
* The smaller buffer size is used as copy length
* between sender and receiver thread.
*/
len = min(size, th->msgsize);
if (len > 0) {
if (umem_copyout(th->msgaddr, msg, len)) {
msg_enqueue(&obj->sendq, th);
cur_thread->recvobj = NULL;
err = EFAULT;
goto out;
}
}
/*
* Detach the message from the target object.
*/
cur_thread->sender = th;
th->receiver = cur_thread;
out:
sched_unlock();
return err;
}
