int main(int argc, char *argv[]) { int i; int max_cpus = sysconf(_SC_NPROCESSORS_CONF); struct params *receiver = NULL; struct params *sender = NULL; sigset_t sigset; int oldsamples = INT_MAX; int oldtimeoutcount = INT_MAX; int first = 1; int errorlines = 0; struct timespec maindelay; int oflag = O_CREAT|O_RDWR; struct mq_attr mqstat; memset(&mqstat, 0, sizeof(mqstat)); mqstat.mq_maxmsg = 1; mqstat.mq_msgsize = 8; mqstat.mq_flags = 0; process_options(argc, argv); if (check_privs()) return 1; if (mlockall(MCL_CURRENT|MCL_FUTURE) == -1) { perror("mlockall"); return 1; } sigemptyset(&sigset); sigaddset(&sigset, SIGTERM); sigaddset(&sigset, SIGINT); pthread_sigmask(SIG_SETMASK, &sigset, NULL); signal(SIGINT, sighand); signal(SIGTERM, sighand); receiver = calloc(num_threads, sizeof(struct params)); sender = calloc(num_threads, sizeof(struct params)); if (receiver == NULL || sender == NULL) goto nomem; for (i = 0; i < num_threads; i++) { char mqname[16]; sprintf(mqname, SYNCMQ_NAME, i); receiver[i].syncmq = mq_open(mqname, oflag, 0777, &mqstat); if (receiver[i].syncmq == (mqd_t) -1) { fprintf(stderr, "could not open POSIX message queue #1\n"); return 1; } sprintf(mqname, TESTMQ_NAME, i); receiver[i].testmq = mq_open(mqname, oflag, 0777, &mqstat); if (receiver[i].testmq == (mqd_t) -1) { fprintf(stderr, "could not open POSIX message queue #2\n"); return 1; } receiver[i].mindiff = UINT_MAX; receiver[i].maxdiff = 0; receiver[i].sumdiff = 0.0; receiver[i].num = i; receiver[i].cpu = i; switch (setaffinity) { case AFFINITY_UNSPECIFIED: receiver[i].cpu = -1; break; case AFFINITY_SPECIFIED: receiver[i].cpu = affinity; break; case AFFINITY_USEALL: receiver[i].cpu = i % max_cpus; break; } receiver[i].priority = priority; receiver[i].tracelimit = tracelimit; if (priority > 1 && !sameprio) priority--; receiver[i].delay.tv_sec = interval / USEC_PER_SEC; receiver[i].delay.tv_nsec = (interval % USEC_PER_SEC) * 1000; interval += distance; receiver[i].max_cycles = max_cycles; receiver[i].sender = 0; receiver[i].neighbor = &sender[i]; receiver[i].timeout = timeout; receiver[i].forcetimeout = forcetimeout; pthread_create(&receiver[i].threadid, NULL, pmqthread, &receiver[i]); memcpy(&sender[i], &receiver[i], sizeof(receiver[0])); sender[i].sender = 1; sender[i].neighbor = &receiver[i]; pthread_create(&sender[i].threadid, NULL, pmqthread, &sender[i]); } maindelay.tv_sec = 0; maindelay.tv_nsec = 50000000; /* 50 ms */ sigemptyset(&sigset); pthread_sigmask(SIG_SETMASK, &sigset, NULL); do { int newsamples = 0, newtimeoutcount = 0; int minsamples = INT_MAX; for (i = 0; i < num_threads; i++) { newsamples += receiver[i].samples; newtimeoutcount += receiver[i].timeoutcount; if (receiver[i].samples < minsamples) minsamples = receiver[i].samples; } if (minsamples > 1 && (shutdown || newsamples > oldsamples || newtimeoutcount > oldtimeoutcount)) { if (!first) printf("\033[%dA", num_threads*2 + errorlines); first = 0; for (i = 0; i < num_threads; i++) { printf("#%1d: ID%d, P%d, CPU%d, I%ld; #%1d: ID%d, P%d, CPU%d, TO %d, Cycles %d \n", i*2, receiver[i].tid, receiver[i].priority, receiver[i].cpu, receiver[i].delay.tv_nsec / 1000, i*2+1, sender[i].tid, sender[i].priority, sender[i].cpu, receiver[i].timeoutcount, sender[i].samples); } for (i = 0; i < num_threads; i++) { printf("#%d -> #%d, Min %4d, Cur %4d, Avg %4d, Max %4d\n", i*2+1, i*2, receiver[i].mindiff, (int) receiver[i].diff.tv_usec, (int) ((receiver[i].sumdiff / receiver[i].samples) + 0.5), receiver[i].maxdiff); if (receiver[i].error[0] != '\0') { printf("%s", receiver[i].error); errorlines++; receiver[i].error[0] = '\0'; } if (sender[i].error[0] != '\0') { printf("%s", sender[i].error); errorlines++; receiver[i].error[0] = '\0'; } } } else { if (minsamples < 1) printf("Collecting ...\n\033[1A"); } fflush(NULL); oldsamples = 0; oldtimeoutcount = 0; for (i = 0; i < num_threads; i++) { oldsamples += receiver[i].samples; oldtimeoutcount += receiver[i].timeoutcount; } nanosleep(&maindelay, NULL); for (i = 0; i < num_threads; i++) shutdown |= receiver[i].shutdown | sender[i].shutdown; } while (!shutdown); for (i = 0; i < num_threads; i++) { receiver[i].shutdown = 1; sender[i].shutdown = 1; } for (i = 0; i < num_threads; i++) { if (!receiver[i].stopped) pthread_kill(receiver[i].threadid, SIGTERM); if (!sender[i].stopped) pthread_kill(sender[i].threadid, SIGTERM); } nanosleep(&maindelay, NULL); for (i = 0; i < num_threads; i++) { char mqname[16]; mq_close(receiver[i].syncmq); sprintf(mqname, SYNCMQ_NAME, i); mq_unlink(mqname); mq_close(receiver[i].testmq); sprintf(mqname, TESTMQ_NAME, i); mq_unlink(mqname); } nomem: return 0; }
int privateOpenMessageQueue(MessageQueue* messageQueue, int __oflag, ...) { /* Check if O_CREATE is set in __oflag */ if ((__oflag & O_CREAT) == O_CREAT) // O_CREAT is set { // Get __mode parameter mode_t __mode; va_list ap; va_start(ap, __oflag); __mode = va_arg(ap, mode_t); va_end(ap); messageQueue->mq_des = mq_open(messageQueue->name, __oflag, __mode, &messageQueue->attributes); } else // O_CREAT is NOT set messageQueue->mq_des = mq_open(messageQueue->name, __oflag); if (messageQueue->mq_des == (mqd_t) -1) { perror("\n\rmq_open failed !!!\n"); switch(errno) { case EACCES: perror("The queue exists, but the caller does not have permission to open it in the specified mode or name contained more than one slash.\n"); break; case EEXIST: perror("Both O_CREAT and O_EXCL were specified in oflag, but a queue with this name already exists.\n"); break; case EINVAL: perror("O_CREAT was specified in oflag, and attr was not NULL, but attr->mq_maxmsg or attr->mq_msqsize was invalid. Both of these fields must be greater than zero.\n"); break; case EMFILE: perror("The process already has the maximum number of files and message queues open.\n"); break; case ENAMETOOLONG: perror("Name was too long.\n"); break; case ENFILE: perror("The system limit on the total number of open files and message queues has been reached.\n"); break; case ENOENT: perror("The O_CREAT flag was not specified in oflag, and no queue with this name exists or name was just '/' followed by no other characters.\n"); break; case ENOMEM: perror("Insufficient memory.\n"); break; case ENOSPC: perror("Insufficient space for the creation of a new message queue. This probably occurred because the queues_max limit was encountered.\n"); break; default: perror("Unknown error\n"); break; } return -1; } return 0; }
/*----------------------------------------------------------------------------- FUNCTION: phDal4Nfc_Config PURPOSE: Configure the serial port. -----------------------------------------------------------------------------*/ NFCSTATUS phDal4Nfc_Config(pphDal4Nfc_sConfig_t config,void **phwref) { NFCSTATUS retstatus = NFCSTATUS_SUCCESS; const hw_module_t* hw_module; nfc_pn544_device_t* pn544_dev; uint8_t num_eeprom_settings; uint8_t* eeprom_settings; int ret; /* Retrieve the hw module from the Android NFC HAL */ ret = hw_get_module(NFC_HARDWARE_MODULE_ID, &hw_module); if (ret) { ALOGE("hw_get_module() failed"); return NFCSTATUS_FAILED; } ret = nfc_pn544_open(hw_module, &pn544_dev); if (ret) { ALOGE("Could not open pn544 hw_module"); return NFCSTATUS_FAILED; } config->deviceNode = pn544_dev->device_node; if (config->deviceNode == NULL) { ALOGE("deviceNode NULL"); return NFCSTATUS_FAILED; } DAL_PRINT("phDal4Nfc_Config"); if ((config == NULL) || (phwref == NULL)) return NFCSTATUS_INVALID_PARAMETER; /* Register the link callbacks */ memset(&gLinkFunc, 0, sizeof(phDal4Nfc_link_cbk_interface_t)); switch(pn544_dev->linktype) { case PN544_LINK_TYPE_UART: case PN544_LINK_TYPE_USB: { DAL_PRINT("UART link Config"); /* Uart link interface */ gLinkFunc.init = phDal4Nfc_uart_initialize; gLinkFunc.open_from_handle = phDal4Nfc_uart_set_open_from_handle; gLinkFunc.is_opened = phDal4Nfc_uart_is_opened; gLinkFunc.flush = phDal4Nfc_uart_flush; gLinkFunc.close = phDal4Nfc_uart_close; gLinkFunc.open_and_configure = phDal4Nfc_uart_open_and_configure; gLinkFunc.read = phDal4Nfc_uart_read; gLinkFunc.write = phDal4Nfc_uart_write; gLinkFunc.reset = phDal4Nfc_uart_reset; } break; case PN544_LINK_TYPE_I2C: { DAL_PRINT("I2C link Config"); /* i2c link interface */ gLinkFunc.init = phDal4Nfc_i2c_initialize; gLinkFunc.open_from_handle = phDal4Nfc_i2c_set_open_from_handle; gLinkFunc.is_opened = phDal4Nfc_i2c_is_opened; gLinkFunc.flush = phDal4Nfc_i2c_flush; gLinkFunc.close = phDal4Nfc_i2c_close; gLinkFunc.open_and_configure = phDal4Nfc_i2c_open_and_configure; gLinkFunc.read = phDal4Nfc_i2c_read; gLinkFunc.write = phDal4Nfc_i2c_write; gLinkFunc.reset = phDal4Nfc_i2c_reset; break; } default: { /* Shound not happen : Bad parameter */ return PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_INVALID_PARAMETER); } } gLinkFunc.init(); /* So that link interface can initialize its internal state */ retstatus = gLinkFunc.open_and_configure(config, phwref); if (retstatus != NFCSTATUS_SUCCESS) return retstatus; /* Iniatilize the DAL context */ (void)memset(&gDalContext,0,sizeof(phDal4Nfc_SContext_t)); pgDalContext = &gDalContext; /* Reset the Reader Thread values to NULL */ memset((void *)&gReadWriteContext,0,sizeof(gReadWriteContext)); gReadWriteContext.nReadThreadAlive = TRUE; gReadWriteContext.nWriteBusy = FALSE; gReadWriteContext.nWaitingOnWrite = FALSE; /* Prepare the message queue for the defered calls */ #ifdef USE_MQ_MESSAGE_QUEUE nDeferedCallMessageQueueId = mq_open(MQ_NAME_IDENTIFIER, O_CREAT|O_RDWR, 0666, &MQ_QUEUE_ATTRIBUTES); #else nDeferedCallMessageQueueId = config->nClientId; #endif gDalContext.pDev = pn544_dev; /* Start Read and Write Threads */ if(NFCSTATUS_SUCCESS != phDal4Nfc_StartThreads()) { return PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_FAILED); } gDalContext.hw_valid = TRUE; phDal4Nfc_Reset(1); phDal4Nfc_Reset(0); phDal4Nfc_Reset(1); return NFCSTATUS_SUCCESS; }
void cs_post(const char* name) { mqd_t mq = mq_open(name, O_RDWR); mq_send(mq, "X", 1, 0); mq_close(mq); }
static void *receiver_thread(void *arg) { mqd_t mqfd; char msg_buffer[TEST_MSGLEN]; struct mq_attr attr; int nbytes; int nerrors = 0; int i; printf("receiver_thread: Starting\n"); /* Fill in attributes for message queue */ attr.mq_maxmsg = 20; attr.mq_msgsize = TEST_MSGLEN; attr.mq_flags = 0; /* Set the flags for the open of the queue. * Make it a blocking open on the queue, meaning it will block if * this task tries to read from the queue when the queue is empty * * O_CREAT - the queue will get created if it does not already exist. * O_RDONLY - we are only planning to read from the queue. * * Open the queue, and create it if the sending process hasn't * already created it. */ mqfd = mq_open("testmq", O_RDONLY|O_CREAT, 0666, &attr); if (mqfd < 0) { printf("receiver_thread: ERROR mq_open failed\n"); pthread_exit((pthread_addr_t)1); } /* Perform the receive TEST_RECEIVE_NMSGS times */ for (i = 0; i < TEST_RECEIVE_NMSGS; i++) { memset(msg_buffer, 0xaa, TEST_MSGLEN); nbytes = mq_receive(mqfd, msg_buffer, TEST_MSGLEN, 0); if (nbytes < 0) { /* mq_receive failed. If the error is because of EINTR then * it is not a failure. */ if (errno != EINTR) { printf("receiver_thread: ERROR mq_receive failure on msg %d, errno=%d\n", i, errno); nerrors++; } else { printf("receiver_thread: mq_receive interrupted!\n", i); } } else if (nbytes != TEST_MSGLEN) { printf("receiver_thread: mq_receive return bad size %d on msg %d\n", nbytes, i); nerrors++; } else if (memcmp(TEST_MESSAGE, msg_buffer, nbytes) != 0) { int j; printf("receiver_thread: mq_receive returned corrupt message on msg %d\n", i); printf("receiver_thread: i Expected Received\n"); for (j = 0; j < TEST_MSGLEN-1; j++) { if (isprint(msg_buffer[j])) { printf("receiver_thread: %2d %02x (%c) %02x (%c)\n", j, TEST_MESSAGE[j], TEST_MESSAGE[j], msg_buffer[j], msg_buffer[j]); } else { printf("receiver_thread: %2d %02x (%c) %02x\n", j, TEST_MESSAGE[j], TEST_MESSAGE[j], msg_buffer[j]); } } printf("receiver_thread: %2d 00 %02x\n", j, msg_buffer[j]); } else { printf("receiver_thread: mq_receive succeeded on msg %d\n", i); } } /* Close the queue and return success */ if (mq_close(mqfd) < 0) { printf("receiver_thread: ERROR mq_close failed\n"); nerrors++; } /* Destroy the queue */ if (mq_unlink("testmq") < 0) { printf("receiver_thread: ERROR mq_close failed\n"); nerrors++; } printf("receiver_thread: returning nerrors=%d\n", nerrors); pthread_exit((pthread_addr_t)nerrors); return (pthread_addr_t)nerrors; }
int main(void) { mqd_t q1, q2; char buf[20]; ssize_t recvlen; unsigned int prio; struct mq_attr attr, oattr; mode_t mode; int err; CYG_TEST_INIT(); CYG_TEST_INFO( "Starting POSIX message test 1" ); q1 = mq_open( "/mq1", O_RDWR ); CYG_TEST_PASS_FAIL( q1 == (mqd_t)-1, "error for non-existent queue" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for non-existent queue" ); attr.mq_flags = 0; attr.mq_maxmsg = 4; attr.mq_msgsize = 20; mode = S_IRWXU|S_IRWXG|S_IRWXO; // rwx for all q1 = mq_open( "/mq1", O_CREAT|O_NONBLOCK|O_WRONLY, mode, &attr ); CYG_TEST_PASS_FAIL( q1 != (mqd_t)-1, "simple mq_open (write only)" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "getattr attributes correct" ); err = mq_send( q1, "Vik is brill", sizeof("Vik is brill"), 10 ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_send" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr after send" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #2" ); q2 = mq_open( "/mq1", O_RDONLY|O_CREAT|O_EXCL ); CYG_TEST_PASS_FAIL( q2 == (mqd_t)-1, "error for exclusive open of existing queue" ); CYG_TEST_PASS_FAIL( EEXIST == errno, "errno correct for exclusive open of existing queue" ); q2 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q2 != (mqd_t)-1, "simple mq_open (read only)" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr, different mqd_t" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK != (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #3" ); err = mq_close( q2 ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_close" ); q2 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q2 != (mqd_t)-1, "mq_open reopen (read only)" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr, different mqd_t" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK != (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #4" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("Vik is brill"), "receive message length" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "Vik is brill", sizeof("Vik is brill")), "received message data intact" ); CYG_TEST_PASS_FAIL( 10 == prio, "received at correct priority" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr after send" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "getattr attributes correct #5" ); attr.mq_flags |= O_NONBLOCK; err = mq_setattr( q2, &attr, &oattr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_setattr O_NONBLOCK" ); CYG_TEST_PASS_FAIL( (4 == oattr.mq_maxmsg) && (20 == oattr.mq_msgsize) && (O_NONBLOCK != (oattr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (oattr.mq_flags & O_RDONLY)) && (O_WRONLY != (oattr.mq_flags & O_WRONLY)) && (O_RDWR != (oattr.mq_flags & O_RDWR)) && (0 == oattr.mq_curmsgs ), "old attribute correct" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_getattr after O_NONBLOCK" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "new attribute correct" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, empty buffer, non-blocking" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for non-blocking" ); err = mq_send( q2, "foo", sizeof("foo"), 1 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send on read-only descriptor" ); CYG_TEST_PASS_FAIL( EBADF == errno, "errno correct for mq_send on r/o descriptor" ); err = mq_send( q2, "supercalifragilisticexpealidocious", 21, 2 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send (message too long)" ); CYG_TEST_PASS_FAIL( EMSGSIZE == errno, "errno correct for mq_send (message too long)" ); err = mq_send( q1, "", sizeof(""), 5 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send \"\"" ); err = mq_send( q1, "I love Vik", sizeof("I love Vik"), 7 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (different priority)" ); err = mq_send( q1, "a lot!", sizeof("a lot!"), 7 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (same priority)" ); err = mq_send( q1, "Vik is a babe", sizeof("Vik is a babe"), 6 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (middle priority)" ); err = mq_send( q1, "wibble", sizeof("wibble"), 6 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send with full queue" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for mq_send full queue" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_getattr after sends" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (4 == attr.mq_curmsgs ), "getattr attributes correct #5" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("I love Vik"), "receive message length (prioritized) #1" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "I love Vik", sizeof("I love Vik")), "received message data intact (prioritized) #1" ); CYG_TEST_PASS_FAIL( 7 == prio, "received at correct priority (prioritized) #1" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("a lot!"), "receive message length (prioritized) #2" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "a lot!", sizeof("a lot!")), "received message data intact (prioritized) #2" ); CYG_TEST_PASS_FAIL( 7 == prio, "received at correct priority (prioritized) #2" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("Vik is a babe"), "receive message length (prioritized) #3" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "Vik is a babe", sizeof("Vik is a babe")), "received message data intact (prioritized) #3" ); CYG_TEST_PASS_FAIL( 6 == prio, "received at correct priority (prioritized) #3" ); recvlen = mq_receive( q2, buf, 0, &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, zero-sized buffer" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof(""), "receive message length (prioritized) #4" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "", sizeof("")), "received message data intact (prioritized) #4" ); CYG_TEST_PASS_FAIL( 5 == prio, "received at correct priority (prioritzed) #4" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, empty buffer, non-blocking #2" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for non-blocking #2" ); err = mq_send( q1, "12345678901234567890", 20, 15 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (before closing)" ); err = mq_unlink( "/foo" ); CYG_TEST_PASS_FAIL( -1 == err, "mq_unlink (wrong name)" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for mq_unlink (wrong name)" ); err = mq_unlink( "/mq1" ); CYG_TEST_PASS_FAIL( 0 == err, "mq_unlink (before closing)" ); err = mq_close( q1 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_close (send descriptor)" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == 20, "receive message length (mid close)" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "12345678901234567890", 20 ), "received message data intact (mid close)" ); CYG_TEST_PASS_FAIL( 15 == prio, "received at correct priority (mid close)" ); err = mq_close( q2 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_close (receive descriptor)" ); q1 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q1 == (mqd_t)-1, "error for non-existent queue" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for non-existent queue" ); CYG_TEST_EXIT("POSIX message test 1"); return 0; } // main()
void producer (int N, const int B) { int randNum; int child_status; mqd_t qdes; mqd_t ret_open; char qname[] = "/mailbox_rsawhney"; mode_t mode = S_IRUSR | S_IWUSR; struct mq_attr attr; attr.mq_maxmsg = B; attr.mq_msgsize = sizeof(randNum); attr.mq_flags = 0; // blocking queue //GET TIME A gettimeofday(&t_a, NULL); ta = t_a.tv_sec + t_a.tv_usec/1000000.0; pid_t child_pid; child_pid = fork(); //printf("child_pid AFTER FORK(): %d\n", child_pid); if (child_pid != 0) { //In parent process (PRODUCER) //printf("PARENT Process ID: %d\n", (int)getpid()); //printf("CHILD PROCESS ID within PARENT PROCESS: %d\n", (int)child_pid); qdes = mq_open(qname, O_RDWR |O_CREAT, mode, &attr); //printf("PRODUCER - mq_open result after creater and initializing: %d\n", qdes); if (qdes == -1) { perror("PRODUCER - mq_open() failed"); exit(1); } int i = 0; gettimeofday(&t_b, NULL); tb = t_b.tv_sec + t_b.tv_usec/1000000.0; printf("Time to initialize system: %.6lf seconds\n", (tb - ta)); fflush(stdout); while (i < N) { randNum = (rand() % 9); if (mq_send(qdes, (char *)&randNum, sizeof(randNum), 0) == -1) { perror("PRODUCER - FAILED TO SEND TO QUEUE"); } //printf("PRODUCER - Random Number %d added to queue\n", randNum); //fflush(stdout); i++; } wait(&child_status); if (WIFEXITED (child_status)) { gettimeofday(&t_c, NULL); tc = t_c.tv_sec + t_c.tv_usec/1000000.0; printf("Time to transmit data: %.6lf seconds\n", tc-tb); fflush(stdout); } else { printf("child did not end properly"); } if (mq_close(qdes) == -1) { perror("PRODUCER - mq_close() failed"); exit(2); } if (mq_unlink(qname) != 0) { perror("mq_unlink() failed"); exit(3); } } else { //In child process (CONSUMER) if (B < N) { int i = 0; int receivedInt = 0; ret_open = mq_open(qname, O_RDONLY | O_CREAT, mode, &attr); //printf("CONSUMER - mq_open: Success! ret_open: %d\n", ret_open); while (i < N) { if (mq_receive(ret_open, (char *)&receivedInt, sizeof(int), 0) == -1) { perror("CONSUMER - ERROR"); } //printf("CONSUMER - Received %d from queue\n",receivedInt); //fflush(stdout); i++; } } if (mq_close(ret_open) == -1) { perror("CONSUMER - mq_close() failed"); exit(2); } } }
extern int message_handling(char* que_name,char* message){ mqd_t q; struct mq_attr *attributes; attributes = malloc(sizeof(struct mq_attr)); q = mq_open(que_name,O_RDWR); }
int main(int argc, char *argv[]) { int nfds; char c; fd_set rset; mqd_t mqd; void *buff; ssize_t n; struct mq_attr attr; struct sigevent sigev; if (2 != argc){ printf("Usage: mqnotifysig5 <name>\n"); exit(1); } if (-1 == (mqd = mq_open(argv[1], O_RDONLY | O_NONBLOCK))){ printf("mq_open failed\n"); exit(1); } if (-1 == mq_getattr(mqd, &attr)){ perror("Failed to get mq_attr"); exit(1); } if (NULL == (buff = malloc(attr.mq_msgsize))){ printf("Alloc buff failed\n"); exit(1); } if (pipe(pipefd) !=0 ){ printf("Initialize pipe failed\n"); exit(1); } signal(SIGUSR1, sig_usr1); sigev.sigev_notify = SIGEV_SIGNAL; sigev.sigev_signo = SIGUSR1; if(-1 == mq_notify(mqd, &sigev)){ printf("mq_notify failed\n"); exit(1); } FD_ZERO(&rset); for (;;){ FD_SET(pipefd[0], &rset); nfds = select(pipefd[0] + 1, &rset, NULL, NULL, NULL); if (FD_ISSET(pipefd[0], &rset)){ read(pipefd[0], &c, 1); if(-1 == mq_notify(mqd, &sigev)){ printf("mq_notify failed\n"); exit(1); } while((n = mq_receive(mqd, buff, attr.mq_msgsize, NULL)) >= 0){ printf("read %ld bytes\n", (long) n); } if (errno != EAGAIN){ printf("mq_receive error\n"); exit(1); } } } exit(0); }
int main(int argc, char** argv) { mqd_t msg_queue = mq_open("/CprE308-Queue", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP, NULL); if(msg_queue == -1) { perror("mq_open\n"); return -1; } // Determine max. msg size; allocate buffer to receive msg struct mq_attr attr; char *buf; if (mq_getattr(msg_queue, &attr)) { perror("mq_getattr\n"); exit(-1); } buf = malloc(attr.mq_msgsize); if (buf == NULL) { perror("malloc"); exit(-1); } sleep(10); ssize_t size; size = mq_receive(msg_queue, buf, attr.mq_msgsize, NULL); if (size == -1) { perror("mq_receive\n"); exit(-1); } printf("Received message \"%s\"\n", buf); size = mq_receive(msg_queue, buf, attr.mq_msgsize, NULL); if (size == -1) { perror("mq_receive\n"); exit(-1); } printf("Received message \"%s\"\n", buf); free(buf); char * my_string = "I am Clara"; if( mq_send(msg_queue, my_string, strlen(my_string), 12)) { perror("mq_send\n"); return -1; } char * my_string2 = "I am Amelia"; if( mq_send(msg_queue, my_string2, strlen(my_string2), 20)) { perror("mq_send\n"); return -1; } return 0; }
int main(void) { pthread_t tBrain; pthread_t tNerves; /* Create a message queue using O_CREAT so that if the queue doesn't * already exist, it will be created. When using mq_open with * O_CREAT, one must supply four arguments. The first "name" * argument must begin with a slash. The third "mode" argument is * derived from the symbolic constants is <sys/stat.h>. */ mqd_t mqd_c = mq_open("/q_cmd", O_RDWR | O_CREAT , S_IRWXU | S_IRWXG | S_IRWXO, NULL); mqd_t mqd_sns = mq_open("/q_sns", O_RDWR | O_CREAT , S_IRWXU | S_IRWXG | S_IRWXO, NULL); static const mqd_t mqd_cmd = mqd_c; if( mqd_cmd == -1) { perror("mq_open() cmd:"); return -1; } if( mqd_sns == -1) { perror("mq_open() sns:"); return -1; } printf("cmd: %d sns: %d\n",mqd_cmd,mqd_sns); printf("cmd: %d sns: %d\n",*(&mqd_cmd),*(&mqd_sns)); mq_holder holder = {mqd_cmd,mqd_sns}; printf("cmd: %d sns: %d\n",holder.cmd,holder.sns); printf("cmd: %d sns: %d\n",(&holder)->cmd,(&holder)->sns); printf("cmda: %d snsa: %d\n",&mqd_cmd,&mqd_sns); /* Create a posix thread for each Alice and Bob threads. */ if(pthread_create(&tBrain, NULL, thread_brain_start, &holder) != 0) { perror("pthread_create(), brain:"); return -1; } if(pthread_create(&tNerves, NULL, thread_nerves_start, &holder) != 0) { perror("pthread_create(), nerves:"); return -1; } //sleep(1); printf("cmd: %d sns: %d\n",(&holder)->cmd,(&holder)->sns); /* Cleanup */ pthread_exit(NULL); mq_close(mqd_cmd); mq_close(mqd_sns); return 0; }
/** * rtevald_parser main function. * * @param argc * @param argv * * @return Returns the result of the process_submission_queue() function. */ int main(int argc, char **argv) { eurephiaVALUES *config = NULL, *prgargs = NULL; char xsltfile[2050], *reportdir = NULL; xsltStylesheet *xslt = NULL; dbconn *dbc = NULL; pthread_t **threads = NULL; pthread_attr_t **thread_attrs = NULL; pthread_mutex_t mtx_sysreg = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mtx_thrcnt = PTHREAD_MUTEX_INITIALIZER; threadData_t **thrdata = NULL; struct mq_attr msgq_attr; mqd_t msgq = 0; int i,rc, mq_init = 0, max_threads = 0, started_threads = 0, activethreads = 0; unsigned int max_report_size = 0; // Initialise XML and XSLT libraries xsltInit(); xmlInitParser(); prgargs = parse_arguments(argc, argv); if( prgargs == NULL ) { fprintf(stderr, "** ERROR ** Failed to parse program arguments\n"); rc = 2; goto exit; } // Setup a log context logctx = init_log(eGet_value(prgargs, "log"), eGet_value(prgargs, "loglevel")); if( !logctx ) { fprintf(stderr, "** ERROR ** Could not setup a log context\n"); eFree_values(prgargs); rc = 2; goto exit; } // Fetch configuration config = read_config(logctx, prgargs, "xmlrpc_parser"); eFree_values(prgargs); // read_config() copies prgargs into config, we don't need prgargs anymore // Daemonise process if requested if( atoi_nullsafe(eGet_value(config, "daemon")) == 1 ) { if( daemonise(logctx) < 1 ) { rc = 3; goto exit; } } // Parse XSLT template snprintf(xsltfile, 512, "%s/%s", eGet_value(config, "xsltpath"), XMLPARSER_XSL); writelog(logctx, LOG_DEBUG, "Parsing XSLT file: %s", xsltfile); xslt = xsltParseStylesheetFile((xmlChar *) xsltfile); if( !xslt ) { writelog(logctx, LOG_EMERG, "Could not parse XSLT template: %s", xsltfile); rc = 2; goto exit; } // Open a POSIX MQ writelog(logctx, LOG_DEBUG, "Preparing POSIX MQ queue: /rteval_parsequeue"); memset(&msgq, 0, sizeof(mqd_t)); msgq_attr.mq_maxmsg = get_mqueue_msg_max(logctx); msgq_attr.mq_msgsize = sizeof(parseJob_t); msgq_attr.mq_flags = O_NONBLOCK; msgq = mq_open("/rteval_parsequeue", O_RDWR | O_CREAT, 0600, &msgq_attr); if( msgq < 0 ) { writelog(logctx, LOG_EMERG, "Could not open message queue: %s", strerror(errno)); rc = 2; goto exit; } mq_init = 1; // Get the number of worker threads max_threads = atoi_nullsafe(eGet_value(config, "threads")); if( max_threads == 0 ) { max_threads = 4; } // Get a database connection for the main thread dbc = db_connect(config, max_threads, logctx); if( !dbc ) { rc = 4; goto exit; } // Prepare all threads threads = calloc(max_threads + 1, sizeof(pthread_t *)); thread_attrs = calloc(max_threads + 1, sizeof(pthread_attr_t *)); thrdata = calloc(max_threads + 1, sizeof(threadData_t *)); assert( (threads != NULL) && (thread_attrs != NULL) && (thrdata != NULL) ); reportdir = eGet_value(config, "reportdir"); writelog(logctx, LOG_INFO, "Starting %i worker threads", max_threads); max_report_size = defaultIntValue(atoi_nullsafe(eGet_value(config, "max_report_size")), 1024*1024); for( i = 0; i < max_threads; i++ ) { // Prepare thread specific data thrdata[i] = malloc_nullsafe(logctx, sizeof(threadData_t)); if( !thrdata[i] ) { writelog(logctx, LOG_EMERG, "Could not allocate memory for thread data"); rc = 2; goto exit; } // Get a database connection for the thread thrdata[i]->dbc = db_connect(config, i, logctx); if( !thrdata[i]->dbc ) { writelog(logctx, LOG_EMERG, "Could not connect to the database for thread %i", i); rc = 2; shutdown = 1; goto exit; } thrdata[i]->shutdown = &shutdown; thrdata[i]->threadcount = &activethreads; thrdata[i]->mtx_thrcnt = &mtx_thrcnt; thrdata[i]->id = i; thrdata[i]->msgq = msgq; thrdata[i]->mtx_sysreg = &mtx_sysreg; thrdata[i]->xslt = xslt; thrdata[i]->destdir = reportdir; thrdata[i]->max_report_size = max_report_size; thread_attrs[i] = malloc_nullsafe(logctx, sizeof(pthread_attr_t)); if( !thread_attrs[i] ) { writelog(logctx, LOG_EMERG, "Could not allocate memory for thread attributes"); rc = 2; goto exit; } pthread_attr_init(thread_attrs[i]); pthread_attr_setdetachstate(thread_attrs[i], PTHREAD_CREATE_JOINABLE); threads[i] = malloc_nullsafe(logctx, sizeof(pthread_t)); if( !threads[i] ) { writelog(logctx, LOG_EMERG, "Could not allocate memory for pthread_t"); rc = 2; goto exit; } } // Setup signal catching signal(SIGINT, sigcatch); signal(SIGTERM, sigcatch); signal(SIGHUP, SIG_IGN); signal(SIGUSR1, sigcatch); signal(SIGUSR2, SIG_IGN); // Start the threads for( i = 0; i < max_threads; i++ ) { int thr_rc = pthread_create(threads[i], thread_attrs[i], parsethread, thrdata[i]); if( thr_rc < 0 ) { writelog(logctx, LOG_EMERG, "** ERROR ** Failed to start thread %i: %s", i, strerror(thr_rc)); rc = 3; goto exit; } started_threads++; } // Main routine // // checks the submission queue and puts unprocessed records on the POSIX MQ // to be parsed by one of the threads // sleep(3); // Allow at least a few parser threads to settle down first before really starting writelog(logctx, LOG_DEBUG, "Starting submission queue checker"); rc = process_submission_queue(dbc, msgq, &activethreads); writelog(logctx, LOG_DEBUG, "Submission queue checker shut down"); exit: // Clean up all threads for( i = 0; i < max_threads; i++ ) { // Wait for all threads to exit if( (i < started_threads) && threads && threads[i] ) { void *thread_rc; int j_rc; if( (j_rc = pthread_join(*threads[i], &thread_rc)) != 0 ) { writelog(logctx, LOG_CRIT, "Failed to join thread %i: %s", i, strerror(j_rc)); } pthread_attr_destroy(thread_attrs[i]); } if( threads ) { free_nullsafe(threads[i]); } if( thread_attrs ) { free_nullsafe(thread_attrs[i]); } // Disconnect threads database connection if( thrdata && thrdata[i] ) { db_disconnect(thrdata[i]->dbc); free_nullsafe(thrdata[i]); } } free_nullsafe(thrdata); free_nullsafe(threads); free_nullsafe(thread_attrs); // Close message queue if( mq_init == 1 ) { errno = 0; if( mq_close(msgq) < 0 ) { writelog(logctx, LOG_CRIT, "Failed to close message queue: %s", strerror(errno)); } errno = 0; if( mq_unlink("/rteval_parsequeue") < 0 ) { writelog(logctx, LOG_ALERT, "Failed to remove the message queue: %s", strerror(errno)); } } // Disconnect from database, main thread connection db_disconnect(dbc); // Free up the rest eFree_values(config); xsltFreeStylesheet(xslt); xmlCleanupParser(); xsltCleanupGlobals(); writelog(logctx, LOG_EMERG, "rteval-parserd is stopped"); close_log(logctx); return rc; }
void *transmitter(void *arg) { struct sched_param param = { .sched_priority = 80 }; struct timespec next_period; struct timespec time; struct can_frame frame; long long *rtt_time = (long long *)&frame.data; /* Pre-fill CAN frame */ frame.can_id = can_id; frame.can_dlc = sizeof(*rtt_time); pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); clock_gettime(CLOCK_MONOTONIC, &next_period); while(1) { next_period.tv_nsec += cycle * 1000; while (next_period.tv_nsec >= NSEC_PER_SEC) { next_period.tv_nsec -= NSEC_PER_SEC; next_period.tv_sec++; } clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_period, NULL); if (rxcount != txcount) { overruns++; continue; } clock_gettime(CLOCK_MONOTONIC, &time); *rtt_time = time.tv_sec * NSEC_PER_SEC + time.tv_nsec; /* Transmit the message containing the local time */ if (send(txsock, (void *)&frame, sizeof(can_frame_t), 0) < 0) { if (errno == EBADF) printf("terminating transmitter thread\n"); else perror("send failed"); return NULL; } txcount++; } } void *receiver(void *arg) { struct sched_param param = { .sched_priority = 82 }; struct timespec time; struct can_frame frame; long long *rtt_time = (long long *)frame.data; struct rtt_stat rtt_stat = {0, 1000000000000000000LL, -1000000000000000000LL, 0, 0, 0}; pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); rtt_stat.counts_per_sec = 1000000 / cycle; while (1) { if (recv(rxsock, (void *)&frame, sizeof(can_frame_t), 0) < 0) { if (errno == EBADF) printf("terminating receiver thread\n"); else perror("recv failed"); return NULL; } if (repeater) { /* Transmit the message back as is */ if (send(txsock, (void *)&frame, sizeof(can_frame_t), 0) < 0) { if (errno == EBADF) printf("terminating transmitter thread\n"); else perror("send failed"); return NULL; } txcount++; } else { clock_gettime(CLOCK_MONOTONIC, &time); if (rxcount > 0) { rtt_stat.rtt = (time.tv_sec * 1000000000LL + time.tv_nsec - *rtt_time); rtt_stat.rtt_sum += rtt_stat.rtt; if (rtt_stat.rtt < rtt_stat.rtt_min) rtt_stat.rtt_min = rtt_stat.rtt; if (rtt_stat.rtt > rtt_stat.rtt_max) rtt_stat.rtt_max = rtt_stat.rtt; } } rxcount++; if ((rxcount % rtt_stat.counts_per_sec) == 0) { mq_send(mq, (char *)&rtt_stat, sizeof(rtt_stat), 0); rtt_stat.rtt_sum_last = rtt_stat.rtt_sum; } } } void catch_signal(int sig) { mq_close(mq); } int main(int argc, char *argv[]) { struct sched_param param = { .sched_priority = 1 }; pthread_attr_t thattr; struct mq_attr mqattr; struct sockaddr_can rxaddr, txaddr; struct can_filter rxfilter[1]; struct rtt_stat rtt_stat; char mqname[32]; char *txdev, *rxdev; struct ifreq ifr; int ret, opt; struct option long_options[] = { { "id", required_argument, 0, 'i'}, { "cycle", required_argument, 0, 'c'}, { "repeater", required_argument, 0, 'r'}, { "help", no_argument, 0, 'h'}, { 0, 0, 0, 0}, }; while ((opt = getopt_long(argc, argv, "hri:c:", long_options, NULL)) != -1) { switch (opt) { case 'c': cycle = atoi(optarg); break; case 'i': can_id = strtoul(optarg, NULL, 0); break; case 'r': repeater = 1; break; default: fprintf(stderr, "Unknown option %c\n", opt); case 'h': print_usage(argv[0]); exit(-1); } } printf("%d %d\n", optind, argc); if (optind + 2 != argc) { print_usage(argv[0]); exit(0); } txdev = argv[optind]; rxdev = argv[optind + 1]; /* Create and configure RX socket */ if ((rxsock = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) { perror("RX socket failed"); return -1; } strncpy(ifr.ifr_name, rxdev, IFNAMSIZ); printf("RX rxsock=%d, ifr_name=%s\n", rxsock, ifr.ifr_name); if (ioctl(rxsock, SIOCGIFINDEX, &ifr) < 0) { perror("RX ioctl SIOCGIFINDEX failed"); goto failure1; } /* We only want to receive our own messages */ rxfilter[0].can_id = can_id; rxfilter[0].can_mask = 0x3ff; if (setsockopt(rxsock, SOL_CAN_RAW, CAN_RAW_FILTER, &rxfilter, sizeof(struct can_filter)) < 0) { perror("RX setsockopt CAN_RAW_FILTER failed"); goto failure1; } memset(&rxaddr, 0, sizeof(rxaddr)); rxaddr.can_ifindex = ifr.ifr_ifindex; rxaddr.can_family = AF_CAN; if (bind(rxsock, (struct sockaddr *)&rxaddr, sizeof(rxaddr)) < 0) { perror("RX bind failed\n"); goto failure1; } /* Create and configure TX socket */ if (strcmp(rxdev, txdev) == 0) { txsock = rxsock; } else { if ((txsock = socket(PF_CAN, SOCK_RAW, 0)) < 0) { perror("TX socket failed"); goto failure1; } strncpy(ifr.ifr_name, txdev, IFNAMSIZ); printf("TX txsock=%d, ifr_name=%s\n", txsock, ifr.ifr_name); if (ioctl(txsock, SIOCGIFINDEX, &ifr) < 0) { perror("TX ioctl SIOCGIFINDEX failed"); goto failure2; } /* Suppress definiton of a default receive filter list */ if (setsockopt(txsock, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0) < 0) { perror("TX setsockopt CAN_RAW_FILTER failed"); goto failure2; } memset(&txaddr, 0, sizeof(txaddr)); txaddr.can_ifindex = ifr.ifr_ifindex; txaddr.can_family = AF_CAN; if (bind(txsock, (struct sockaddr *)&txaddr, sizeof(txaddr)) < 0) { perror("TX bind failed\n"); goto failure2; } } signal(SIGTERM, catch_signal); signal(SIGINT, catch_signal); signal(SIGHUP, catch_signal); mlockall(MCL_CURRENT|MCL_FUTURE); printf("Round-Trip-Time test %s -> %s with CAN ID 0x%x\n", argv[optind], argv[optind + 1], can_id); printf("Cycle time: %d us\n", cycle); printf("All RTT timing figures are in us.\n"); /* Create statistics message queue */ snprintf(mqname, sizeof(mqname), "/rtcan_rtt-%d", getpid()); mqattr.mq_flags = 0; mqattr.mq_maxmsg = 100; mqattr.mq_msgsize = sizeof(struct rtt_stat); mq = mq_open(mqname, O_RDWR | O_CREAT | O_EXCL, 0600, &mqattr); if (mq == (mqd_t)-1) { perror("opening mqueue failed"); goto failure2; } /* Create receiver RT-thread */ pthread_attr_init(&thattr); pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); pthread_attr_setstacksize(&thattr, PTHREAD_STACK_MIN); ret = pthread_create(&rxthread, &thattr, &receiver, NULL); if (ret) { fprintf(stderr, "%s: pthread_create(receiver) failed\n", strerror(-ret)); goto failure3; } if (!repeater) { /* Create transitter RT-thread */ ret = pthread_create(&txthread, &thattr, &transmitter, NULL); if (ret) { fprintf(stderr, "%s: pthread_create(transmitter) failed\n", strerror(-ret)); goto failure4; } } pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); if (repeater) printf("Messages\n"); else printf("Messages RTTlast RTT_avg RTT_min RTT_max Overruns\n"); while (1) { long long rtt_avg; ret = mq_receive(mq, (char *)&rtt_stat, sizeof(rtt_stat), NULL); if (ret != sizeof(rtt_stat)) { if (ret < 0) { if (errno == EBADF) printf("terminating mq_receive\n"); else perror("mq_receive failed"); } else fprintf(stderr, "mq_receive returned invalid length %d\n", ret); break; } if (repeater) { printf("%8d\n", rxcount); } else { rtt_avg = ((rtt_stat.rtt_sum - rtt_stat.rtt_sum_last) / rtt_stat.counts_per_sec); printf("%8d %7ld %7ld %7ld %7ld %8d\n", rxcount, (long)(rtt_stat.rtt / 1000), (long)(rtt_avg / 1000), (long)(rtt_stat.rtt_min / 1000), (long)(rtt_stat.rtt_max / 1000), overruns); } } /* This call also leaves primary mode, required for socket cleanup. */ printf("shutting down\n"); /* Important: First close the sockets! */ while ((close(rxsock) < 0) && (errno == EAGAIN)) { printf("RX socket busy - waiting...\n"); sleep(1); } while ((close(txsock) < 0) && (errno == EAGAIN)) { printf("TX socket busy - waiting...\n"); sleep(1); } pthread_join(txthread, NULL); pthread_kill(rxthread, SIGHUP); pthread_join(rxthread, NULL); return 0; failure4: pthread_kill(rxthread, SIGHUP); pthread_join(rxthread, NULL); failure3: mq_close(mq); failure2: close(txsock); failure1: close(rxsock); return 1; }
int main() { mqd_t mq; int status; struct mq_attr attr; int pid; sigset_t set; struct sigaction sa; siginfo_t info; mq_unlink(MQNAME); sigemptyset(&set); sigaddset(&set, SIGRTMIN); sigprocmask(SIG_BLOCK, &set, NULL); sigemptyset(&sa.sa_mask); sa.sa_flags = SA_SIGINFO; sa.sa_sigaction = (void *) SIG_DFL; sigaction(SIGRTMIN, &sa, NULL); attr.mq_maxmsg = 5; attr.mq_msgsize = 128; mq = mq_open(MQNAME, O_CREAT | O_RDWR | O_EXCL, 0666, &attr); if (mq == (mqd_t)-1) err(1, "mq_open()"); status = mq_getattr(mq, &attr); if (status) err(1, "mq_getattr()"); pid = fork(); if (pid == 0) { /* child */ int prio, j, i; char *buf; struct sigevent sigev; signal(SIGALRM, sighandler); sigev.sigev_notify = SIGEV_SIGNAL; sigev.sigev_signo = SIGRTMIN; sigev.sigev_value.sival_int = 2; mq_close(mq); mq = mq_open(MQNAME, O_RDWR | O_NONBLOCK); if (mq == (mqd_t)-1) err(1, "child: mq_open"); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { alarm(3); status = mq_notify(mq, &sigev); if (status) err(1, "child: mq_notify"); status = sigwaitinfo(&set, &info); if (status == -1) err(1, "child: sigwaitinfo"); if (info.si_value.sival_int != 2) err(1, "child: sival_int"); status = mq_receive(mq, buf, attr.mq_msgsize, &prio); if (status == -1) err(2, "child: mq_receive"); for (i = 0; i < attr.mq_msgsize; ++i) if (buf[i] != i) err(3, "child: message data corrupted"); if (prio != PRIO) err(4, "child: priority is incorrect: %d", prio); } alarm(0); free(buf); mq_close(mq); return (0); } else if (pid == -1) { err(1, "fork()"); } else { char *buf; int i, j, prio; signal(SIGALRM, sighandler); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { for (i = 0; i < attr.mq_msgsize; ++i) { buf[i] = i; } alarm(3); status = mq_send(mq, buf, attr.mq_msgsize, PRIO); if (status) { kill(pid, SIGKILL); err(2, "mq_send()"); } } alarm(3); wait(&status); alarm(0); } status = mq_close(mq); if (status) err(1, "mq_close"); mq_unlink(MQNAME); return (0); }
/* * Setup event receive. */ static int init_event_rx(UAMP_STATE *uamp) { struct ifreq ifr; int fd = -1; struct sockaddr_ll local; int err; int fd_pipe[2] = {-1, -1}; pthread_t h; memset(&ifr, 0, sizeof(ifr)); wl_get_interface_name(&ifr); UAMP_PRINT(("ifr_name (%s)\n", ifr.ifr_name)); /* Create and bind socket to receive packets. */ fd = socket(PF_PACKET, SOCK_RAW, htons(ETHER_TYPE_BRCM)); if (fd < 0) { UAMP_ERROR(("%s: Cannot open socket", __FUNCTION__)); return (-1); } err = ioctl(fd, SIOCGIFINDEX, &ifr); if (err < 0) { UAMP_ERROR(("%s: Cannot get index %d\n", __FUNCTION__, err)); close(fd); return (-1); } memset(&local, 0, sizeof(local)); local.sll_family = AF_PACKET; local.sll_protocol = htons(ETHER_TYPE_BRCM); local.sll_ifindex = ifr.ifr_ifindex; if (bind(fd, (struct sockaddr*)&local, sizeof(local)) < 0) { UAMP_ERROR(("%s: Cannot bind event socket", __FUNCTION__)); close(fd); return (-1); } /* Create pipe used to terminate receive packet thread. */ if (pipe(fd_pipe) != 0) { UAMP_ERROR(("%s: pipe failed\n", __FUNCTION__)); goto cleanup; } /* Save in instance memory. */ uamp->evt_fd = fd; uamp->evt_fd_pipe[0] = fd_pipe[0]; uamp->evt_fd_pipe[1] = fd_pipe[1]; /* Create message queue for received events. */ uamp->evt_q = mq_open(UAMP_EVT_Q_STR, O_RDWR | O_CREAT, 0666, NULL); UAMP_PRINT(("evt_q(0x%x)\n", (int)uamp->evt_q)); /* Spawn event handling thread. */ pthread_create(&h, NULL, event_thread, uamp); return (fd); cleanup: if (-1 != fd) close(fd); if (-1 != fd_pipe[0]) close(fd_pipe[0]); if (-1 != fd_pipe[1]) close(fd_pipe[1]); return (-1); }
int main(void) { struct kevent kev; struct mq_attr attr; mqd_t mq; int kq, status; pid_t pid; PLAIN_REQUIRE_KERNEL_MODULE("mqueuefs", 0); mq_unlink(MQNAME); attr.mq_maxmsg = 5; attr.mq_msgsize = 128; mq = mq_open(MQNAME, O_CREAT | O_RDWR | O_EXCL, 0666, &attr); if (mq == (mqd_t) -1) err(1, "mq_open()"); status = mq_getattr(mq, &attr); if (status) err(1, "mq_getattr()"); pid = fork(); if (pid == 0) { /* child */ char *buf; int j, i; unsigned int prio; mq_close(mq); kq = kqueue(); mq = mq_open(MQNAME, O_RDWR); if (mq == (mqd_t)-1) err(1, "child: mq_open"); EV_SET(&kev, __mq_oshandle(mq), EVFILT_READ, EV_ADD, 0, 0, 0); status = kevent(kq, &kev, 1, NULL, 0, NULL); if (status == -1) err(1, "child: kevent"); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { alarm(3); status = kevent(kq, NULL, 0, &kev, 1, NULL); if (status != 1) err(1, "child: kevent 2"); status = mq_receive(mq, buf, attr.mq_msgsize, &prio); if (status == -1) err(2, "child: mq_receive"); for (i = 0; i < attr.mq_msgsize; ++i) if (buf[i] != i) err(3, "child: message data corrupted"); if (prio != PRIO) err(4, "child: priority is incorrect: %d", prio); } alarm(0); free(buf); mq_close(mq); return (0); } else if (pid == -1) { err(1, "fork()"); } else { char *buf; int i, j; signal(SIGALRM, sighandler); kq = kqueue(); EV_SET(&kev, __mq_oshandle(mq), EVFILT_WRITE, EV_ADD, 0, 0, 0); status = kevent(kq, &kev, 1, NULL, 0, NULL); if (status == -1) err(1, "kevent"); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { for (i = 0; i < attr.mq_msgsize; ++i) { buf[i] = i; } alarm(3); status = kevent(kq, NULL, 0, &kev, 1, NULL); if (status != 1) err(1, "child: kevent 2"); status = mq_send(mq, buf, attr.mq_msgsize, PRIO); if (status) { err(2, "mq_send()"); } } free(buf); alarm(3); wait(&status); alarm(0); } status = mq_close(mq); if (status) err(1, "mq_close"); mq_unlink(MQNAME); return (0); }
int main(int argc,char** argv) { printf("********************************************************\n"); printf("this demo shows how mq_reqnotify works\n"); printf("the father process will create a new message queue\n"); printf("and then register for message notifying.after that\n"); printf("it will fork two children preocesses to send msgs to \n"); printf("itself.If the mq_reqnotify works,the father process should\n"); printf("print out all the msgs it receives\n"); printf("********************************************************\n"); mq_attr_t attr; attr_set(&attr,8,1,1); mqd = mq_open("hakaze",&attr); message_t msg1,msg2; msg_init(&msg1,1,"greeting from child1!"); msg_init(&msg2,1,"greeting from child2!"); msg_addreceiver(&msg1,getpid()); msg_addreceiver(&msg2,getpid()); int loopcount = 5; if(argc >= 2) { loopcount = atoi(argv[1]); } if(signal(SIGALRM,myhandler) != 0) { printf("cannot catch sig: %d\n",SIGALRM); return 0; } if(mq_reqnotify(mqd,SIGALRM) != 0) { printf("cannot register for notify with sig: %d\n",SIGALRM); return 0; } if(fork() == 0) { //this is child1 int i; int sendcount = 0; for(i = 0;i < loopcount;i++) //send msg 16 times { if(mq_send(mqd,&msg1) == 0) { sendcount++; } } printf("child1 exit, sendcount:%d\n",sendcount); return 0; } else { //this is father if(fork() == 0) { //this is child2 int i; int sendcount = 0;; for(i = 0;i < loopcount;i++) //send msg 16 times { if(mq_send(mqd,&msg2) == 0) { sendcount++; } } printf("child2 exit, sendcount:%d\n",sendcount); return 0; } } while(1) { ; } mq_close(mqd); return 0; }
static int do_test (void) { if (geteuid () != 0) { puts ("this test requires root"); return 0; } char name[sizeof "/tst-mqueue9-" + sizeof (pid_t) * 3]; snprintf (name, sizeof (name), "/tst-mqueue9-%u", getpid ()); struct mq_attr attr = { .mq_maxmsg = 1, .mq_msgsize = 1 }; mqd_t q = mq_open (name, O_CREAT | O_EXCL | O_RDWR, 0600, &attr); if (q == (mqd_t) -1) { printf ("mq_open failed with: %m\n"); return 0; } else add_temp_mq (name); if (seteuid (1) != 0) { printf ("failed to seteuid (1): %m\n"); mq_unlink (name); return 0; } int result = 0; if (mq_unlink (name) == 0) { puts ("mq_unlink unexpectedly succeeded"); result = 1; } else if (errno != EACCES) { printf ("mq_unlink did not fail with EACCES: %m\n"); result = 1;; } if (seteuid (0) != 0) { printf ("failed to seteuid (0): %m\n"); result = 1; } if (mq_unlink (name) != 0) { printf ("mq_unlink failed with: %m\n"); result = 1; } if (mq_close (q) != 0) { printf ("mq_close failed with: %m\n"); result = 1; } return result; }
int main() { char mqname[NAMESIZE], msgrv1[BUFFER], msgrv2[BUFFER]; const char *msgptr1 = "test message 1"; const char *msgptr2 = "test message 2"; mqd_t mqdes; unsigned rvprio; int sdprio1 = 1, sdprio2 = 2; struct mq_attr attr; int unresolved = 0, failure = 0; sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid()); attr.mq_msgsize = BUFFER; attr.mq_maxmsg = BUFFER; mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr); if (mqdes == (mqd_t)-1) { perror(ERROR_PREFIX "mq_open"); unresolved = 1; } if (mq_send(mqdes, msgptr1, strlen(msgptr1), sdprio1) != 0) { perror(ERROR_PREFIX "mq_send"); unresolved = 1; } if (mq_send(mqdes, msgptr2, strlen(msgptr2), sdprio2) != 0) { perror(ERROR_PREFIX "mq_send"); unresolved = 1; } if (mq_receive(mqdes, msgrv1, BUFFER, &rvprio) == -1) { perror(ERROR_PREFIX "mq_receive"); failure = 1; } if (strncmp(msgptr2, msgrv1, strlen(msgptr2)) != 0) { printf("FAIL: mq_receive didn't receive the highest priority message\n"); failure = 1; } if (rvprio != sdprio2) { printf("FAIL: receive priority %d != send priority %d \n", rvprio, sdprio2); failure = 1; } if (mq_receive(mqdes, msgrv2, BUFFER, &rvprio) == -1) { perror(ERROR_PREFIX "mq_receive"); failure = 1; } if (strncmp(msgptr1, msgrv2, strlen(msgptr1)) != 0) { printf("FAIL: mq_receive didn't receive the correct message\n"); failure = 1; } if (rvprio != sdprio1) { printf("FAIL: receive priority %d != send priority %d \n", rvprio, sdprio1); failure = 1; } if (mq_close(mqdes) != 0) { perror(ERROR_PREFIX "mq_close"); unresolved = 1; } if (mq_unlink(mqname) != 0) { perror(ERROR_PREFIX "mq_unlink"); unresolved = 1; } if (failure==1) { printf("Test FAILED\n"); return PTS_FAIL; } if (unresolved==1) { printf("Test UNRESOLVED\n"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; }
int main() { mqd_t mq; int status; struct mq_attr attr; int pid; fd_set set; mq_unlink(MQNAME); attr.mq_maxmsg = 5; attr.mq_msgsize = 128; mq = mq_open(MQNAME, O_CREAT | O_RDWR | O_EXCL, 0666, &attr); if (mq == (mqd_t)-1) err(1, "mq_open()"); status = mq_getattr(mq, &attr); if (status) err(1, "mq_getattr()"); pid = fork(); if (pid == 0) { /* child */ int prio, j, i; char *buf; mq_close(mq); signal(SIGALRM, sighandler); mq = mq_open(MQNAME, O_RDWR); if (mq == (mqd_t)-1) err(1, "child process: mq_open"); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { FD_ZERO(&set); FD_SET(__mq_oshandle(mq), &set); alarm(3); status = select(__mq_oshandle(mq)+1, &set, NULL, NULL, NULL); if (status != 1) err(1, "child process: select()"); status = mq_receive(mq, buf, attr.mq_msgsize, &prio); if (status == -1) err(2, "child process: mq_receive"); for (i = 0; i < attr.mq_msgsize; ++i) if (buf[i] != i) err(3, "message data corrupted"); if (prio != PRIO) err(4, "priority is incorrect: %d", prio); } alarm(0); free(buf); mq_close(mq); return (0); } else if (pid == -1) { err(1, "fork()"); } else { char *buf; int i, j, prio; signal(SIGALRM, sighandler); buf = malloc(attr.mq_msgsize); for (j = 0; j < LOOPS; ++j) { for (i = 0; i < attr.mq_msgsize; ++i) { buf[i] = i; } alarm(3); FD_ZERO(&set); FD_SET(__mq_oshandle(mq), &set); status = select(__mq_oshandle(mq)+1, NULL, &set, NULL, NULL); if (status != 1) err(1, "select()"); status = mq_send(mq, buf, attr.mq_msgsize, PRIO); if (status) { kill(pid, SIGKILL); err(2, "mq_send()"); } } alarm(3); wait(&status); alarm(0); } status = mq_close(mq); if (status) err(1, "mq_close"); mq_unlink(MQNAME); return (0); }
int main(int argc, char *argv[]) { int flags; int opt; mqd_t mqd; unsigned int prio; void *buffer; struct mq_attr attr; ssize_t numRead; struct timespec ts; struct timespec *tsp; flags = O_RDONLY; tsp = NULL; while ((opt = getopt(argc, argv, "t:n")) != -1) { switch (opt) { case 'n': flags |= O_NONBLOCK; break; case 't': if (clock_gettime(CLOCK_REALTIME, &ts) == -1) { errExit("clock_gettime"); } ts.tv_sec += getInt(optarg, GN_NONNEG, "timeout"); tsp = &ts; break; default: usageError(argv[0]); } } if (optind >= argc) { usageError(argv[0]); } mqd = mq_open(argv[optind], flags); if (mqd == (mqd_t)-1) { errExit("mq_open"); } if (mq_getattr(mqd, &attr) == -1) { errExit("mq_getattr"); } buffer = malloc(attr.mq_msgsize); if (buffer == NULL) { errExit("malloc"); } numRead = mq_timedreceive(mqd, buffer, attr.mq_msgsize, &prio, tsp); if (numRead == -1) { errExit("mq_receive"); } printf("Read %ld butes; priority = %u\n", (long)numRead, prio); if (write(STDOUT_FILENO, buffer, numRead) == -1) { errExit("write"); } write(STDOUT_FILENO, "\n", 1); exit(EXIT_SUCCESS); }
void runSuccess() { mq_open(anystring(), anyint()); }
static void *sender_thread(void *arg) { mqd_t mqfd; char msg_buffer[TEST_MSGLEN]; struct mq_attr attr; int status = 0; int nerrors = 0; int i; printf("sender_thread: Starting\n"); /* Fill in attributes for message queue */ attr.mq_maxmsg = 20; attr.mq_msgsize = TEST_MSGLEN; attr.mq_flags = 0; /* Set the flags for the open of the queue. * Make it a blocking open on the queue, meaning it will block if * this process tries to send to the queue and the queue is full. * * O_CREAT - the queue will get created if it does not already exist. * O_WRONLY - we are only planning to write to the queue. * * Open the queue, and create it if the receiving process hasn't * already created it. */ mqfd = mq_open("testmq", O_WRONLY|O_CREAT, 0666, &attr); if (mqfd < 0) { printf("sender_thread: ERROR mq_open failed\n"); pthread_exit((pthread_addr_t)1); } /* Fill in a test message buffer to send */ memcpy(msg_buffer, TEST_MESSAGE, TEST_MSGLEN); /* Perform the send TEST_SEND_NMSGS times */ for (i = 0; i < TEST_SEND_NMSGS; i++) { status = mq_send(mqfd, msg_buffer, TEST_MSGLEN, 42); if (status < 0) { printf("sender_thread: ERROR mq_send failure=%d on msg %d\n", status, i); nerrors++; } else { printf("sender_thread: mq_send succeeded on msg %d\n", i); } } /* Close the queue and return success */ if (mq_close(mqfd) < 0) { printf("sender_thread: ERROR mq_close failed\n"); } printf("sender_thread: returning nerrors=%d\n", nerrors); return (pthread_addr_t)nerrors; }
void runFailure() { mq_open(NULL, anyint()); }
int main() { char mqname[NAMESIZE], msgrv[BUFFER]; const char *msgptr = "test message"; mqd_t mqdes; unsigned int rvprio; int sdprio = 1; struct timespec ts; struct mq_attr attr; int unresolved = 0, failure = 0; sprintf(mqname, "/" FUNCTION "_" TEST "_%d", getpid()); attr.mq_msgsize = BUFFER; attr.mq_maxmsg = BUFFER; mqdes = mq_open(mqname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr); if (mqdes == (mqd_t)-1) { perror(ERROR_PREFIX "mq_open"); unresolved = 1; } if (mq_send(mqdes, msgptr, strlen(msgptr), sdprio) != 0) { perror(ERROR_PREFIX "mq_send"); unresolved = 1; } sleep(1); /* wait for a while */ ts.tv_sec = time(NULL) -1; /* No wait */ ts.tv_nsec = -1; /* Invalid */ if (mq_timedreceive(mqdes, msgrv, BUFFER, &rvprio, &ts) == -1) { if (errno == EINVAL) printf("FAIL: the validity of abs_timeout " "is checked\n"); else perror("Unexpected error at mq_timedreceive"); failure = 1; } if (mq_close(mqdes) != 0) { perror(ERROR_PREFIX "mq_close"); unresolved = 1; } if (mq_unlink(mqname) != 0) { perror(ERROR_PREFIX "mq_unlink"); unresolved = 1; } if (failure==1) { printf("Test FAILED\n"); return PTS_FAIL; } if (unresolved==1) { printf("Test UNRESOLVED\n"); return PTS_UNRESOLVED; } printf("Test PASSED\n"); return PTS_PASS; }
void *POSIX_Init( void *argument ) { struct mq_attr attr; mqd_t Queue, second_Queue; int sc; Heap_Information_block start; Heap_Information_block info; size_t to_alloc; void *alloced; bool sb; const char *name; puts( "\n\n*** POSIX MESSAGE QUEUE TEST 4 ***" ); attr.mq_maxmsg = 1; attr.mq_msgsize = sizeof(int); puts( "Init - Open message queue instance 1" ); Queue = mq_open( "Queue", O_CREAT | O_RDWR, 0x777, &attr ); if ( Queue == (-1) ) perror( "mq_open failed" ); rtems_test_assert( Queue != (-1) ); puts( "Init - Open message queue instance 2 - FAIL - ENFILE " ); second_Queue = mq_open( "Queue2", O_CREAT | O_RDWR, 0x777, &attr ); if ( second_Queue != (-1) ) puts( "mq_open did not failed" ); rtems_test_assert( second_Queue == (-1) ); rtems_test_assert( errno == ENFILE ); puts( "Init - Unlink message queue instance 1" ); sc = mq_unlink( "Queue" ); if ( sc != 0 ) perror( "mq_unlink failed" ); rtems_test_assert( sc == 0 ); puts( "Init - Close message queue instance 1" ); sc = mq_close( Queue ); if ( sc != 0 ) perror( "mq_close failed" ); rtems_test_assert( sc == 0 ); sb = rtems_workspace_get_information( &start ); rtems_test_assert( start.Free.number == 1 ); to_alloc = start.Free.largest; /* find the largest we can actually allocate */ while ( 1 ) { sb = rtems_workspace_allocate( to_alloc, &alloced ); if ( sb ) break; to_alloc -= 4; } rtems_workspace_free( alloced ); /* * Now do the test */ puts( "Init - Memory allocation error test" ); sb = rtems_workspace_get_information( &info ); attr.mq_maxmsg = 1; attr.mq_msgsize = 200; name = Get_Longest_Name(); while ( attr.mq_msgsize > 0 ) { sb = rtems_workspace_allocate( to_alloc, &alloced ); rtems_test_assert( sb ); second_Queue = mq_open(name,O_CREAT | O_RDWR, 0x777, &attr ); /* free the memory we snagged, then check the status */ rtems_workspace_free( alloced ); if ( second_Queue != (-1) ) break; /* attr.mq_msgsize -= 48; */ to_alloc -= 4; } if ( second_Queue == -1 ) rtems_test_exit(0); puts( "Init - Message Queue created" ); puts( "Init - Unlink message queue" ); sc = mq_unlink( name ); if ( sc != 0 ) perror( "mq_unlink failed" ); rtems_test_assert( sc == 0 ); puts( "Init - Close message queue" ); sc = mq_close( second_Queue ); if ( sc != 0 ) perror( "mq_close failed" ); rtems_test_assert( sc == 0 ); puts( "*** END OF POSIX MESSAGE QUEUE TEST 4 ***" ); rtems_test_exit( 0 ); return NULL; /* just so the compiler thinks we returned something */ }
int main() { char qname[NAMESIZE], msgrcd[BUFFER]; const char *msgptr = MSGSTR; mqd_t woqueue, woqueue2; struct mq_attr attr; unsigned pri; sprintf(qname, "/mq_open_8-1_%d", getpid()); attr.mq_msgsize = BUFFER; attr.mq_maxmsg = BUFFER; woqueue = mq_open(qname, O_CREAT |O_WRONLY, S_IRUSR | S_IWUSR, &attr); if (woqueue == (mqd_t)-1) { perror("mq_open() for write-only queue did not return success"); printf("Test UNRESOLVED\n"); return PTS_UNRESOLVED; } if (mq_send(woqueue, msgptr, strlen(msgptr), 1) != 0) { perror("mq_send() did not return success"); printf("Test UNRESOLVED\n"); /* close queue and exit */ mq_close(woqueue); mq_unlink(qname); return PTS_UNRESOLVED; } #ifdef DEBUG printf("Message %s sent\n", msgptr); #endif if (mq_receive(woqueue, msgrcd, BUFFER, &pri) != -1) { printf("mq_receive() returned success on write only queue\n"); printf("Test FAILED\n"); /* close queue and exit */ mq_close(woqueue); mq_unlink(qname); return PTS_FAIL; } #ifdef DEBUG printf("Message receive failed, as expected\n"); #endif woqueue2 = mq_open(qname, O_WRONLY, S_IRUSR | S_IWUSR, &attr); if (woqueue2 == (mqd_t)-1) { perror("mq_open() did not return success"); printf("Test UNRESOLVED\n"); /* close woqueue and exit */ mq_close(woqueue); mq_unlink(qname); return PTS_UNRESOLVED; } if (mq_send(woqueue2, msgptr, strlen(msgptr), 1) != 0) { perror("mq_send() did not return success"); printf("Test UNRESOLVED\n"); /* close queues and exit */ mq_close(woqueue); mq_close(woqueue2); mq_unlink(qname); return PTS_UNRESOLVED; } #ifdef DEBUG printf("Message %s sent to second queue\n", msgptr); #endif if (mq_receive(woqueue2, msgrcd, BUFFER, &pri) != -1) { printf("mq_receive() returned success on write only queue\n"); printf("Test FAILED\n"); /* close queues and exit */ mq_close(woqueue); mq_close(woqueue2); mq_unlink(qname); return PTS_FAIL; } #ifdef DEBUG printf("Message receive failed, as expected, on second queue\n"); #endif mq_close(woqueue); mq_close(woqueue2); mq_unlink(qname); printf("Test PASSED\n"); return PTS_PASS; }
void * llc_service_sdp_thread (void *arg) { struct llc_connection *connection = (struct llc_connection *) arg; mqd_t llc_up, llc_down; int old_cancelstate; pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &old_cancelstate); llc_up = mq_open (connection->mq_up_name, O_RDONLY); llc_down = mq_open (connection->mq_down_name, O_WRONLY); if (llc_up == (mqd_t)-1) LLC_SDP_LOG (LLC_PRIORITY_ERROR, "mq_open(%s)", connection->mq_up_name); if (llc_down == (mqd_t)-1) LLC_SDP_LOG (LLC_PRIORITY_ERROR, "mq_open(%s)", connection->mq_down_name); pthread_cleanup_push (llc_service_sdp_thread_cleanup, arg); pthread_setcancelstate (old_cancelstate, NULL); LLC_SDP_MSG (LLC_PRIORITY_INFO, "Service Discovery Protocol started"); int res; uint8_t buffer[1024]; LLC_SDP_MSG (LLC_PRIORITY_TRACE, "mq_receive+"); pthread_testcancel (); res = mq_receive (llc_up, (char *) buffer, sizeof (buffer), NULL); pthread_testcancel (); if (res < 0) { pthread_testcancel (); } LLC_SDP_LOG (LLC_PRIORITY_TRACE, "Received %d bytes", res); uint8_t tid; char *uri; switch (buffer[2]) { case LLCP_PARAMETER_SDREQ: if (parameter_decode_sdreq (buffer + 2, res - 2, &tid, &uri) < 0) { LLC_SDP_MSG (LLC_PRIORITY_ERROR, "Ignoring PDU"); } else { LLC_SDP_LOG (LLC_PRIORITY_TRACE, "Service Discovery Request #0x%02x for '%s'", tid, uri); uint8_t sap = llc_link_find_sap_by_uri (connection->link, uri); if (!sap) { LLC_SDP_LOG (LLC_PRIORITY_ERROR, "No registered service provide '%s'", uri); } buffer[0] = 0x06; buffer[1] = 0x41; int n = parameter_encode_sdres (buffer + 2, sizeof (buffer) -2, tid, sap); mq_send (llc_down, (char *) buffer, n + 2, 0); LLC_SDP_LOG (LLC_PRIORITY_TRACE, "Sent %d bytes", n+2); } break; default: LLC_SDP_MSG (LLC_PRIORITY_ERROR, "Invalid parameter type"); } pthread_cleanup_pop (1); llc_connection_stop (connection); return NULL; }
int main(int argc, char **argv) { struct mq_attr mqa; mqd_t mqdw; mqd_t mqdr; char buffer[MSGSIZEMAX]; unsigned int priority; int len; mqa.mq_maxmsg = MSGMAX; mqa.mq_msgsize = MSGSIZEMAX; if ((mqdw = mq_open("/valgrind-mqueue", O_CREAT|O_EXCL|O_WRONLY, 0600, &mqa)) < 0) { if (errno == ENOSYS) exit(0); perror("mq_open"); exit(1); } if ((mqdr = mq_open("/valgrind-mqueue", O_RDONLY)) < 0) { perror("mq_open"); mq_unlink("/valgrind-mqueue"); mq_close(mqdw); exit(1); } if (mq_unlink("/valgrind-mqueue") < 0) { perror("mq_unlink"); mq_close(mqdw); mq_close(mqdr); exit(1); } if (mq_send(mqdw, "PING", 4, 0) < 0) { perror("mq_send"); mq_close(mqdr); mq_close(mqdw); exit(1); } if ((len = mq_receive(mqdr, buffer, sizeof(buffer), &priority)) < 0) { perror("mq_receive"); mq_close(mqdr); mq_close(mqdw); exit(1); } #if !defined(VGO_solaris) /* On Solaris, there is no existing notification registration. */ if (mq_notify(mqdr, NULL) < 0) { perror("mq_notify"); mq_close(mqdr); mq_close(mqdw); exit(1); } #endif /* !VGO_solaris */ if (len != 4 || memcmp(buffer, "PING", 4) != 0) { fprintf(stderr, "Message corrupt!"); } if (mq_getattr(mqdr, &mqa) < 0) { perror("mq_getattr"); mq_close(mqdr); mq_close(mqdw); exit(1); } if (mq_setattr(mqdw, &mqa, &mqa) < 0) { perror("mq_setattr"); mq_close(mqdr); mq_close(mqdw); exit(1); } if (mq_close(mqdr) < 0) { perror("mq_close"); mq_close(mqdw); exit(1); } if (mq_close(mqdw) < 0) { perror("mq_close"); exit(1); } exit(0); }
int main() { char qname[NAMESIZE], msgrcd[BUFFER]; const char *msgptr = MSGSTR; mqd_t rdwrqueue, roqueue; struct mq_attr attr; unsigned pri; sprintf(qname, "/mq_open_7-1_%d", getpid()); attr.mq_msgsize = BUFFER; attr.mq_maxmsg = BUFFER; rdwrqueue = mq_open(qname, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr); if (rdwrqueue == (mqd_t) - 1) { perror("mq_open() did not return success"); printf("Test UNRESOLVED\n"); return PTS_UNRESOLVED; } if (mq_send(rdwrqueue, msgptr, strlen(msgptr), 1) != 0) { perror("mq_send() did not return success"); printf("Test UNRESOLVED\n"); /* close queue and exit */ mq_close(rdwrqueue); mq_unlink(qname); return PTS_UNRESOLVED; } #ifdef DEBUG printf("Message %s sent\n", msgptr); #endif roqueue = mq_open(qname, O_RDONLY, S_IRUSR | S_IWUSR, &attr); if (roqueue == (mqd_t) - 1) { perror("mq_open() for read-only queue did not return success"); printf("Test UNRESOLVED\n"); /* close read-write queue and exit */ mq_close(rdwrqueue); mq_unlink(qname); return PTS_UNRESOLVED; } #ifdef DEBUG printf("read-only message queue opened\n"); #endif if (mq_receive(roqueue, msgrcd, BUFFER, &pri) == -1) { perror("mq_receive() failed on read-only queue"); printf("Test FAILED\n"); /* close queues and exit */ mq_close(roqueue); mq_close(rdwrqueue); mq_unlink(qname); return PTS_FAIL; } #ifdef DEBUG printf("Message received\n"); #endif if (mq_send(roqueue, msgptr, strlen(msgptr), 1) == 0) { printf("mq_send() succeeded on read-only queue\n"); printf("Test FAILED\n"); /* close queues and exit */ mq_close(roqueue); mq_close(rdwrqueue); mq_unlink(qname); return PTS_FAIL; } #ifdef DEBUG printf("Message could not be sent, as expected\n"); #endif mq_close(rdwrqueue); mq_close(roqueue); mq_unlink(qname); printf("Test PASSED\n"); return PTS_PASS; }