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; }