예제 #1
0
파일: u_waitset.c 프로젝트: osrf/opensplice
u_waitset
u_waitsetNew(void)
{
    u_waitset _this = NULL;
    u_result result;

    result = u_userInitialise();
    if (result == U_RESULT_OK) {
        _this = u_objectAlloc(sizeof(*_this), U_WAITSET, u__waitsetDeinitW, u__waitsetFreeW);

        _this->entries = NULL;
        _this->eventMask = V_EVENTMASK_ALL;
        _this->alive = TRUE;
        _this->waitBusy = FALSE;
        _this->detachCnt = 0;
        _this->multi_mode = OS_TRUE;
        _this->eventsEnabled = OS_TRUE;
        _this->notifyDetached = OS_FALSE;
        pa_st32(&_this->useCount, 0);

        os_mutexInit(&_this->mutex, NULL);
        os_condInit(&_this->cv, &_this->mutex, NULL);
        os_condInit(&_this->waitCv, &_this->mutex, NULL);
    } else {
        OS_REPORT(OS_ERROR, "u_waitsetNew", result,
                  "Initialization failed. ");
    }

    return _this;
}
예제 #2
0
jni_nameService
jni_nameServiceNew()
{
    u_result r;
    
    if(ns == NULL){
        r = u_userInitialise();
        
        if(r == U_RESULT_OK){
            ns = jni_nameService(os_malloc((size_t)(C_SIZEOF(jni_nameService))));
            mappings = c_iterNew(NULL);
            ns->refCount = 1;
        }
    } else{
        ns->refCount++;
    }
    return ns;
}
예제 #3
0
파일: mmstat.c 프로젝트: cynron/opensplice
int
main (int argc, char *argv[])
{
   int opt;
   int interval = 3000;
   int sampleCount = 0;
   c_bool extended = FALSE;
   c_bool raw = FALSE;
   c_bool delta = FALSE;
   c_bool preallocated = FALSE;
   char *uri = "";
   u_result ur;
   u_participant participant;
   v_participantQos pqos;
   int no_break = TRUE;
   char c;
   int lost;
   const char* sddsURI = NULL;
   monitorMode selectedAction = memoryStats;
   monitor_ms msData = NULL;
   monitor_trc trcData = NULL;
   monitor_orc orcData = NULL;
   int delay = 0;
   int trigger = 0;
   int sample = 0;
   c_long objectCountLimit = 0;
   char *filterExpression = NULL;


   HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
   INPUT_RECORD buffer[1];
   DWORD events;

   orderKind selectedOrdering  = NO_ORDERING;
   int orderCount = INT_MAX;

   while (((opt = getopt (argc, argv, optflags)) != -1) && !errno) {
       switch (opt) {
           case 'i':
               if (!(sscanf (optarg, "%d", &interval)) > 0) {
                   fprintf(stderr, "mmstat: Not a valid interval.\n");
                   print_usage();
                   exit(-1);
               }
               break;
           case 's':
               if (!(sscanf (optarg, "%d", &sampleCount)) > 0) {
                   fprintf(stderr, "mmstat: Not a valid sample count.\n");
                   print_usage();
                   exit(-1);
               }
               break;
           case 'l':
               if (!(sscanf (optarg, "%d", &objectCountLimit)) > 0) {
                   fprintf(stderr, "mmstat: Not a valid limit.\n");
                   print_usage();
                   exit(-1);
               }
               break;
           case 'f':
               filterExpression = optarg;
               break;
           case 'e':
               extended = TRUE;
               break;
           case 'r':
               raw = TRUE;
               break;
           case 'a':
               preallocated = TRUE;
               break;
           case 'm':
               selectedAction = memoryStats;
               break;
           case 'M':
               selectedAction = memoryStats;
               delta = TRUE;
               break;
           case 't':
               selectedAction = typeRefCount;
               break;
           case 'T':
               selectedAction = typeRefCount;
               delta = TRUE;
               break;
           case 'o':
               if (selectedOrdering  == NO_ORDERING && strlen(optarg) == 1)
               {
                   switch (optarg[0])
                   {
                       case 'C':
                           selectedOrdering = ORDER_BY_COUNT;
                           break;
                       case 'S':
                           selectedOrdering = ORDER_BY_SIZE;
                           break;
                       case 'T':
                           selectedOrdering = ORDER_BY_TOTAL;
                           break;
                       default:
                           fprintf(stderr, "mmstat: Unknown ordering kind.\n");
                           print_usage();
                           exit(-1);
                   }
               }
               else
               {
                   fprintf(stderr, "mmstat: Cannot specify multiple orderings at the same time.\n");
                   print_usage();
                   exit(-1);
               }
               break;
           case 'n':
               if (!(sscanf (optarg, "%d", &orderCount)) > 0)
               {
                   fprintf(stderr, "mmstat: Not a valid ordering nrEntries.\n");
                   print_usage();
                   exit(-1);
               }
               break;
#ifdef OBJECT_WALK
           case 'r':
               selectedAction = objectRefCount;
               break;
           case 'R':
               selectedAction = objectRefCount;
               delta = TRUE;
               break;
#endif
           case 'h':
           case '?':
           default:
               print_usage ();
               exit(0);
               break;
       }
   }
   if (errno) {
       fprintf(stderr, strerror(errno));
       fprintf(stderr, "\n");
       print_usage();
       exit (-1);
   }
   if ((argc - optind) > 1) {
       fprintf(stderr, "Too many arguments");
       print_usage ();
       exit (-1);
   }
   if (selectedAction == memoryStats) {
       if (objectCountLimit > 0) {
           fprintf(stderr, "Can't use object limit in memory stats mode.\n");
           print_usage();
           exit(-1);
       }
       if (filterExpression != NULL) {
           fprintf(stderr, "Can't use filter expression in memory stats mode.\n");
           print_usage();
           exit(-1);
       }
   } else {
       if (extended) {
           fprintf(stderr, "Extended mode can only be used in memory stats mode.\n");
           print_usage();
           exit(-1);
       }
       if (preallocated) {
           fprintf(stderr, "Preallocated memory can only be shown in memory stats mode.\n");
           print_usage();
           exit(-1);
       }
   }
   if ((argc - optind) == 1)
   {
      uri = argv[optind];
   }

   if( !raw) {
      if(strlen(uri) > 0) {
         sddsURI = uri;
      } else {
         sddsURI = os_getenv ("OSPL_URI");
         if(!sddsURI) {
            sddsURI = DOMAIN_NAME;
         }
      }
      printf("Trying to open connection with the OpenSplice system using URI:\n" \
             "'%s'...\n", sddsURI);
   } else {
       sddsURI = uri;
   }

   ur = u_userInitialise();

   if(ur == U_RESULT_OK)
   {
      pqos = u_participantQosNew(NULL);
      participant = u_participantNew(sddsURI, 30, "mmstat", (v_qos)pqos, TRUE);
      u_participantQosFree(pqos);

      if(participant)
      {
         if( !raw )
         {
            printf("Connection established.\n\n");
         }

         lost = 0;
         switch (selectedAction)
         {
         case memoryStats:
            msData = monitor_msNew (extended, raw, delta, preallocated);
            break;
         case typeRefCount:
            trcData = monitor_trcNew (objectCountLimit, filterExpression, selectedOrdering, orderCount, delta);
            break;
         case objectRefCount:
            orcData = monitor_orcNew (objectCountLimit, filterExpression, delta);
            break;
         }

         while (no_break && !lost)
         {
            if (delay <= 0 || trigger)
            {
               switch (selectedAction)
               {
               case memoryStats:
                  ur = u_entityAction(u_entity(participant), monitor_msAction, msData);
                  break;
               case typeRefCount:
                  ur = u_entityAction(u_entity(participant), monitor_trcAction, trcData);
                  break;
               case objectRefCount:
                  ur = u_entityAction(u_entity(participant), monitor_orcAction, orcData);
                  break;
               }
               fflush (stdout);
               sample++;
               if (trigger)
               {
                  trigger = 0;
               }
               else
               {
                  delay = interval;
               }
            }

            if(ur == U_RESULT_OK)
            {
               if (_isatty(_fileno(stdin)) && !raw)
               {
                  c = '\0';
                  PeekConsoleInput( handle, buffer, 1, &events );

                  if(events > 0)
                  {
                     ReadConsoleInput(handle, buffer, 1, &events);

                     if(buffer[0].EventType == KEY_EVENT
                        && buffer[0].Event.KeyEvent.bKeyDown)
                     {
                        c = buffer[0].Event.KeyEvent.uChar.AsciiChar;
                     }

                  }

                  if (c == 'q' || c == '\03' /* ^C */)
                  {
                     no_break = FALSE;
                  }
                  else if (c == 't')
                  {
                     trigger = 1;
                  }

                  PeekConsoleInput( handle, buffer, 1, &events );

                  if(events > 0)
                  {
                     ReadConsoleInput(handle, buffer, 1, &events);

                     if(buffer[0].EventType == KEY_EVENT
                        && buffer[0].Event.KeyEvent.bKeyDown)
                     {
                        c = buffer[0].Event.KeyEvent.uChar.AsciiChar;
                     }
                  }
               }
               if (no_break && interval)
               {
                  delay -= 100;
                  os_nanoSleep (SLEEP_INTERVAL);
               }
            }
            else
            {
               /* Participant is no longer accessible, terminate now... */
               no_break = 0;
               lost = TRUE;
            }
            if (sampleCount && (sample == sampleCount))
            {
               printf ("\nsample_count limit reached\n");
               no_break = 0;
            }
         }
         PeekConsoleInput( handle, buffer, 1, &events );

         if(events > 0)
         {
            ReadConsoleInput(handle, buffer, 1, &events);

            if(buffer[0].EventType == KEY_EVENT
               && buffer[0].Event.KeyEvent.bKeyDown)
            {
               c = buffer[0].Event.KeyEvent.uChar.AsciiChar;
            }
         }

         if(lost)
         {
            printf("\nConnection with domain lost. The OpenSplice system has\n" \
                   "probably been shut down.\n");
         }
         u_participantFree(participant);
      }
      else
      {
         printf("Connection could NOT be established (creation of participant failed).\n");
         printf("Is the OpenSplice system running?\n");
         OS_REPORT(OS_ERROR,"mmstat", 0, "Creation of participant failed.");
      }
      u_userDetach();
      switch (selectedAction)
      {
      case memoryStats:
         monitor_msFree (msData);
         break;
      case typeRefCount:
         monitor_trcFree (trcData);
         break;
      case objectRefCount:
         monitor_orcFree (orcData);
         break;
      }
   }
   else
   {
      printf("Connection could NOT be established (could not initialise).\n");
      printf("Is the OpenSplice system running?\n");
      OS_REPORT(OS_ERROR,"mmstat", 0, "Failed to initialise.");
   }
   printf("\nExiting now...\n");


   return 0;
}
예제 #4
0
int
main(
    int argc,
    char* argv[])
{
    int result = 0;
    v_participantQos participantQos;
    u_result uresult;
    os_boolean success;
    v_subscriberQos subscriberQos;
    c_time resolution;
    c_base base;
    v_kernel kernel;

    /* Necessary to initialize the user layer. Do this just once per process.*/
    mlv_init ();
    uresult = u_userInitialise();
    mlv_setforreal (1);

    if(uresult == U_RESULT_OK){
        /* Allocate default participant qos*/
        participantQos = u_participantQosNew(NULL);

        {
          os_mutexAttr mattr;
          os_mutexAttrInit (&mattr);
          mattr.scopeAttr = OS_SCOPE_PRIVATE;
          os_mutexInit (&gluelock, &mattr);
        }

        if(participantQos){
            if(argc > 1){
                SERVICE_NAME = argv[1];
            }
            if(argc > 2){
                SERVICE_URI = argv[2];
            }
            /*create participant*/
            participant = u_participant(u_serviceNew(
                                SERVICE_URI, 0, SERVICE_NAME,
                                NULL,
                                U_SERVICE_NETWORKING,
                                (v_qos)participantQos));

            if(participant){
                struct cfgst *cfgst;
                ddsi2_participant_gid = u_entityGid (u_entity (participant));

                /*Notify kernel that I am initializing. */
                u_serviceChangeState(u_service(participant),STATE_INITIALISING);

                /*Start monitoring the splicedaemon state. I need to terminate if he says so*/
                u_serviceWatchSpliceDaemon(
                        u_service(participant),
                        in_discoveryWatchSpliced,
                        &terminate);

                if ((cfgst = config_init (participant, SERVICE_NAME)) != NULL)
                {
                  unsigned rtps_flags = 0;
                  struct nn_servicelease *servicelease;

                  open_tracing_file ();
                  /* Dependencies between default values is not
                     handled automatically by the config processing
                     (yet) */
                  if (config.many_sockets_mode)
                  {
                    if (config.max_participants == 0)
                      config.max_participants = 100;
                  }
                  if (NN_STRICT_P)
                  {
                    /* Should not be sending invalid messages when strict */
                    config.respond_to_rti_init_zero_ack_with_invalid_heartbeat = 0;
                    config.acknack_numbits_emptyset = 1;
                  }
                  config_print_and_free_cfgst (cfgst);

                  servicelease = nn_servicelease_new (participant);
                  nn_servicelease_start_renewing (servicelease);

                  myNetworkId = getNetworkId ();

                  u_entityAction(u_entity(participant), resolveKernelService, NULL);
                  base = c_getBase(service);
                  kernel = v_object(service)->kernel;
                  rtps_init (base, kernel, config.domainId, config.participantIndex,
                             rtps_flags, config.networkAddressString, config.peers);

                  /* Initialize entity administration. */
                  success = in_entityAdminInit(participant);

                  if(success){
                    /*Create subscriber to receive client writers' messages.*/
                    subscriberQos = u_subscriberQosNew(NULL);
                    os_free(subscriberQos->partition);
                    subscriberQos->partition = NULL;

                    clientSubscriber = u_subscriberNew(
                            participant,
                            "clientSubscriber",
                            subscriberQos,
                            TRUE);

                    if(clientSubscriber){
                      /*Create networkReader to be able to receive client writers' messages.*/
                      clientReader = u_networkReaderNew(
                              clientSubscriber,
                              "clientReader",
                              NULL,
                              TRUE);

                      if(clientReader){
                        resolution.seconds = 0;
                        resolution.nanoseconds = 10 * 1000 * 1000; /*10 ms*/

                        /*Create network queue*/
                        uresult = u_networkReaderCreateQueue(
                                clientReader,
                                1000, 0, FALSE, FALSE,
                                resolution,
                                TRUE, &queueId,
                                "DDSi");

                        if(uresult == U_RESULT_OK){
                          struct builtin_datareader_set drset;
                          u_entityAction(u_entity(clientReader), resolveKernelReader, NULL);

                          uresult = create_builtin_readers (&drset, participant);
                          if (uresult == U_RESULT_OK)
                          {
                            u_serviceChangeState(u_service(participant),STATE_OPERATIONAL);
                            uresult = attachAndMonitor(participant, &drset);

                            if((uresult != U_RESULT_OK) &&
                               (uresult != U_RESULT_DETACHING))
                            {
                              nn_log (LC_ERROR, "Abnormal termination...\n");
                              result = -1;
                            } else {
                              nn_log (LC_INFO, "Deleting entities...\n");
                            }
                            destroy_builtin_readers (&drset);
                          } else {
                            nn_log (LC_FATAL, "Could not create subscription + readers for builtin topics.\n");
                            result = -1;
                          }
                          terminate = TRUE;
                          v_networkReaderTrigger(vclientReader, queueId);
                          os_threadWaitExit(clientWriterThread, NULL);
                        } else {
                          nn_log (LC_FATAL, "Could not create networkQueue.\n");
                          result = -1;
                        }
                        /*Clean up networkReader*/
                        os_mutexLock (&gluelock);
                        u_networkReaderFree(clientReader);
                        clientReader = NULL;
                        vclientReader = NULL;
                        os_mutexUnlock (&gluelock);
                      } else {
                        nn_log (LC_FATAL, "Could not create networkReader.\n");
                        result = -1;
                      }
                      /*Clean up subscriber*/
                      u_subscriberFree(clientSubscriber);
                    } else {
                      nn_log (LC_FATAL, "Could not create subscriber.\n");
                      result = -1;
                    }

                    /*Clean up entity administration*/
                    in_entityAdminDestroy();
                  } else {
                    nn_log (LC_FATAL, "Could not initialize entity adminstration.\n");
                    result = -1;
                  }

                  /* RTPS layer now defines types, cleanup before detaching */
                  rtps_term();

                  /*Notify kernel that I've terminated*/
                  u_serviceChangeState(u_service(participant),STATE_TERMINATED);
                  nn_servicelease_free (servicelease);
                  /*Delete participant*/
                  uresult = u_serviceFree(u_service(participant));

                  if(uresult != U_RESULT_OK){
                    nn_log (LC_FATAL, "Deletion of participant failed.\n");
                    result = -1;
                  }
                } else {
                    nn_log (LC_FATAL, "Initialization of configuration failed.\n");
                    result = -1;
                }
            } else {
                nn_log (LC_FATAL, "Could not create participant.\n");
                result = -1;
            }
            u_participantQosFree (participantQos);
        } else {
            nn_log (LC_FATAL, "Could not allocate participantQos.\n");
            result = -1;
        }
        os_mutexDestroy (&gluelock);
        /* Detach user layer */
        mlv_setforreal (0);
        uresult = u_userDetach();
        mlv_fini ();

        if(uresult != U_RESULT_OK){
            nn_log (LC_FATAL, "Detachment of user layer failed.\n");
            result = -1;
        }
    } else {
        nn_log (LC_FATAL, "Initialization of user layer failed.\n");
        result = -1;
    }
    nn_log (LC_INFO, "Finis.\n");

    /* Must be really late, or nn_log becomes unhappy -- but it should
       be before os_osExit (which appears to be called from
       u_userExit(), which is not called by u_userDetach but by an
       exit handler, it appears.) */
    config_fini ();
    return result;
}
예제 #5
0
int
ospl_main(
    int argc,
    char *argv[])
{
    u_result retVal;
    char *name;
    char *config;
#ifdef INTEGRITY
    Error err;
    Semaphore networkSvcStartSem = SemaphoreObjectNumber(13);
    name = "networking";
    config = "file:///ospl.xml";

    err = WaitForSemaphore(networkSvcStartSem);
    assert ( err == Success );

    argc = 3;
#else

#ifdef NW_DEBUGGING
    /* Stop and wait for debugger */
    if (argc > 3) {
        if (strcmp(argv[3], "wait") == 0) {
            int p = 0;
            while (p==0) {
                os_time delay = {1, 0};
                printf("Networking sleeping, waiting for debugger\n");
                os_nanoSleep(delay);
            }
        }
        argc--;
    }

    if (argc > 3) {
        int i;
        printf("Ignoring superfluous parameters: ");
        for (i=3; i<argc; i++) {
            printf(" %s", argv[i]);
        }
        printf("\n");
    }
#endif

#endif
    /* First check command line arguments */
    if (argc == 3)
    {
#ifndef INTEGRITY
        name = argv[1];
        config = argv[2];
#endif
        /* Initialize user API */
        retVal = u_userInitialise();
        if (retVal == U_RESULT_OK) {
                /* The actual service actions */
            nw_serviceMain(name, config);

            u_userDetach();
        } else {
           NW_REPORT_ERROR("networking main loop",
                           "Error attaching to kernel, bailing out");
        }
    } else {
       NW_REPORT_ERROR("networking main loop",
                       "Usage: networking name <configuration-URI>");
    }

    return 0;

}