Esempio n. 1
0
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;
}
Esempio n. 2
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;
}
Esempio n. 3
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;
}
Esempio n. 4
0
void cs_post(const char* name)
{
    mqd_t mq = mq_open(name, O_RDWR);
    mq_send(mq, "X", 1, 0);
    mq_close(mq); 
}
Esempio n. 5
0
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;
}
Esempio n. 6
0
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);
	        }
	}
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
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);
}
Esempio n. 10
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;
}
Esempio n. 11
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;
}
Esempio n. 12
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;
}
Esempio n. 13
0
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, &param);

    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, &param);

    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, &param);

    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;
}
Esempio n. 14
0
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);
}
Esempio n. 15
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);
}
Esempio n. 16
0
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;
}
Esempio n. 18
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;
}
Esempio n. 19
0
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;
}
Esempio n. 20
0
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);
}
Esempio n. 21
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);
}
Esempio n. 22
0
void runSuccess() {
    mq_open(anystring(), anyint());
}
Esempio n. 23
0
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;
}
Esempio n. 24
0
void runFailure() {
    mq_open(NULL, anyint());
}
Esempio n. 25
0
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;
}
Esempio n. 26
0
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 */
}
Esempio n. 27
0
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;
}
Esempio n. 28
0
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;
}
Esempio n. 29
0
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);
}
Esempio n. 30
0
File: 7-1.c Progetto: Nan619/ltp-ddt
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;
}