static inline POSIX_Shm_Control *shm_allocate(
const char *name_arg,
size_t name_len,
int oflag,
mode_t mode,
int *error
)
{
POSIX_Shm_Control *shm;
char *name;
struct timeval tv;
/* Reject any name without a leading slash. */
if ( name_arg[0] != '/' ) {
*error = EINVAL;
return NULL;
}
/* Only create the object if requested. */
if ( ( oflag & O_CREAT ) != O_CREAT ) {
*error = ENOENT;
return NULL;
}
name = _Workspace_String_duplicate( name_arg, name_len );
if ( name == NULL ) {
*error = ENOSPC;
return NULL;
}
shm = _POSIX_Shm_Allocate_unprotected();
if ( shm == NULL ) {
_Workspace_Free( name );
*error = ENFILE;
return NULL;
}
gettimeofday( &tv, 0 );
shm->reference_count = 1;
shm->shm_object.handle = NULL;
shm->shm_object.size = 0;
shm->shm_object.ops = &_POSIX_Shm_Object_operations;
shm->mode = mode & ~rtems_filesystem_umask;
shm->oflag = oflag;
shm->uid = geteuid();
shm->gid = getegid();
shm->atime = (time_t) tv.tv_sec;
shm->mtime = (time_t) tv.tv_sec;
shm->ctime = (time_t) tv.tv_sec;
_Objects_Open_string( &_POSIX_Shm_Information, &shm->Object, name );
return shm;
}
static mqd_t _POSIX_Message_queue_Create(
const char *name_arg,
size_t name_len,
int oflag,
const struct mq_attr *attr
)
{
POSIX_Message_queue_Control *the_mq;
char *name;
/* length of name has already been validated */
if ( attr->mq_maxmsg <= 0 ){
rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED );
}
if ( attr->mq_msgsize <= 0 ){
rtems_set_errno_and_return_value( EINVAL, MQ_OPEN_FAILED );
}
the_mq = _POSIX_Message_queue_Allocate_unprotected();
if ( !the_mq ) {
rtems_set_errno_and_return_value( ENFILE, MQ_OPEN_FAILED );
}
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Message_queue_Free( the_mq );
rtems_set_errno_and_return_value( ENOMEM, MQ_OPEN_FAILED );
}
the_mq->open_count = 1;
the_mq->linked = true;
the_mq->oflag = oflag;
/*
* NOTE: That thread blocking discipline should be based on the
* current scheduling policy.
*
* Joel: Cite POSIX or OpenGroup on above statement so we can determine
* if it is a real requirement.
*/
if (
!_CORE_message_queue_Initialize(
&the_mq->Message_queue,
CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO,
attr->mq_maxmsg,
attr->mq_msgsize
)
) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free( name );
rtems_set_errno_and_return_value( ENOSPC, MQ_OPEN_FAILED );
}
_Objects_Open_string(
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
return the_mq->Object.id;
}
/*
* _POSIX_Semaphore_Create_support
*
* This routine does the actual creation and initialization of
* a poxix semaphore. It is a support routine for sem_init and
* sem_open.
*/
int _POSIX_Semaphore_Create_support(
const char *name_arg,
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
the_semaphore = _POSIX_Semaphore_Allocate_unprotected();
if ( !the_semaphore ) {
rtems_set_errno_and_return_minus_one( ENOSPC );
}
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Semaphore_Free( the_semaphore );
rtems_set_errno_and_return_minus_one( ENOMEM );
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
the_semaphore->open_count = 0;
the_semaphore->linked = false;
}
the_sem_attr = &the_semaphore->Semaphore.Attributes;
/*
* POSIX does not appear to specify what the discipline for
* blocking tasks on this semaphore should be. It could somehow
* be derived from the current scheduling policy. One
* thing is certain, no matter what we decide, it won't be
* the same as all other POSIX implementations. :)
*/
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
/*
* Make the semaphore available for use.
*/
_Objects_Open_string(
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
return 0;
}
int _POSIX_Message_queue_Create_support(
const char *name_arg,
size_t name_len,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
POSIX_Message_queue_Control *the_mq;
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
/* length of name has already been validated */
_Thread_Disable_dispatch();
/*
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_String_duplicate( name_arg, name_len );
if ( !name ) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
the_mq->process_shared = pshared;
the_mq->named = true;
the_mq->open_count = 1;
the_mq->linked = true;
/*
* NOTE: That thread blocking discipline should be based on the
* current scheduling policy.
*
* Joel: Cite POSIX or OpenGroup on above statement so we can determine
* if it is a real requirement.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
&the_mq->Message_queue,
the_mq_attr,
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
_Objects_Open_string(
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
_Thread_Enable_dispatch();
return 0;
}
