nsframework/framework_unified/client/NS_SharedMemIf/api/nsapi_sharedmem.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*************************************************************************
  18  *
  19  * FILENAME    : nsapi_sharedmem.cpp
  20  *
  21  * DESCRIPTION : TestApp - NS_SharedMem
  22  *
  23  ************************************************************************/
  24
  25 #include <native_service/ns_logger_if.h>
  26 #include <native_service/ns_version_if.h>
  27 #include <native_service/ns_sharedmem.h>
  28 #include <native_service/ns_shared_mem_if.h>
  29 #include <native_service/ns_transmit_log.h>
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34
  35 #include "ss_version.h"
  36 #include "ns_unittest_internal.h"
  37
  38 #define AVAILABLE_API
  39 #if defined(AVAILABLE_API)
  40 static CNSSharedMem *g_pTransmitLogSharedBuf = NULL;
  41
  42 ////////////////////////////////////////////////////////////////////////////////////////////
  43 /// NSSharedMemTransmitLogOpen
  44 /// Open the shared memory for transmit logging
  45 ////////////////////////////////////////////////////////////////////////////////////////////
  46 EFrameworkunifiedStatus NSSharedMemTransmitLogOpen() {
  47   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  48
  49   if (NULL == g_pTransmitLogSharedBuf) {
  50     // Create the instance
  51     g_pTransmitLogSharedBuf = new(std::nothrow) CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
  52   }
  53
  54   if (NULL != g_pTransmitLogSharedBuf) {
  55     if (!g_pTransmitLogSharedBuf->IsOpen()) {
  56       // maps the shared memory buffer
  57       l_eStatus = g_pTransmitLogSharedBuf->Open();
  58     }
  59   } else {
  60     l_eStatus = eFrameworkunifiedStatusNullPointer;
  61   }
  62
  63   return l_eStatus;
  64 }
  65
  66 ////////////////////////////////////////////////////////////////////////////////////////////
  67 /// NSSharedMemTransmitLogClose
  68 /// Close the transmit logging shared memory
  69 ////////////////////////////////////////////////////////////////////////////////////////////
  70 EFrameworkunifiedStatus NSSharedMemTransmitLogClose() {
  71   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  72
  73   if (NULL != g_pTransmitLogSharedBuf) {
  74     // un-map the shared memory object
  75     l_eStatus = g_pTransmitLogSharedBuf->Close();
  76
  77     delete g_pTransmitLogSharedBuf;
  78     g_pTransmitLogSharedBuf = NULL;
  79   } else {
  80     l_eStatus = eFrameworkunifiedStatusNullPointer;
  81   }
  82
  83   return l_eStatus;
  84 }
  85
  86 ////////////////////////////////////////////////////////////////////////////////////////////
  87 /// NSSharedMemReadTransmitLog
  88 /// Reads transmit log from the shared memory buffer.
  89 ////////////////////////////////////////////////////////////////////////////////////////////
  90 SI_32 NSSharedMemReadTransmitLog(PSTR f_pBuffer, const UI_32 f_uiLength, const BOOL f_bBlock) {
  91   // no. of bytes read
  92   SI_32 l_iReadSize = NS_SHM_ERROR;
  93
  94   if (NULL != g_pTransmitLogSharedBuf && NULL != f_pBuffer) {
  95     // Writes log data into shared memory buffer
  96     l_iReadSize = g_pTransmitLogSharedBuf->Read(f_pBuffer, f_uiLength, f_bBlock);
  97   }
  98
  99   return l_iReadSize;
 100 }
 101
 102 ////////////////////////////////////////////////////////////////////////////////////////////
 103 /// NSSharedMemWriteTransmitLog
 104 /// Write transmit log into the shared memory buffer.
 105 ////////////////////////////////////////////////////////////////////////////////////////////
 106 SI_32 NSSharedMemWriteTransmitLog(PCSTR f_pBuffer, const UI_32 f_uiLength) {
 107   // no. of bytes read
 108   SI_32 l_iWriteSize = NS_SHM_ERROR;
 109
 110   if (NULL != g_pTransmitLogSharedBuf && NULL != f_pBuffer) {
 111     // Writes log data into shared memory buffer
 112     l_iWriteSize = g_pTransmitLogSharedBuf->Write(f_pBuffer, f_uiLength);
 113   }
 114
 115   return l_iWriteSize;
 116 }
 117 #endif
 118
 119
 120 // For NsLog
 121 CFrameworkunifiedVersion g_FrameworkunifiedVersion(MAJORNO, MINORNO, REVISION);
 122 #define ZONE_INIT    ZONEMASK(10)
 123 #define ZONE_FUNC    ZONEMASK(11)
 124 #define ZONE_MEM     ZONEMASK(12)
 125 #define ZONE_INFO    ZONEMASK(29)
 126 #define ZONE_WARN    ZONEMASK(30)
 127 #define ZONE_ERR     ZONEMASK(31)
 128 #define FRAMEWORKUNIFIEDLOGAPPZONES  ZONE_INFO, ZONE_WARN, ZONE_ERR
 129 FRAMEWORKUNIFIEDLOGPARAM   g_FrameworkunifiedLogParams = {
 130   LPRINT,
 131   {
 132     "Init",   "Function", "Memory",
 133     "",     "",     "",
 134     "",     "",     "",
 135     "",     "",     "",
 136     "",     "",     "",
 137     "",     "",     "",
 138     "",
 139     "Info",   "Warning",  "Error"
 140   },
 141   FRAMEWORKUNIFIEDLOGZONES
 142 };
 143
 144 /** sleep */
 145 static int
 146 sleep_msec(int msec) {
 147   struct timespec ts, rem;
 148   ts.tv_sec = msec / 1000;
 149   ts.tv_nsec = (msec % 1000) * 1000000;
 150   int ret;
 151   for (;;) {
 152     ret = nanosleep(&ts, &rem);
 153     if (ret == 0 || (ret < 0 && errno != EINTR)) {
 154       break;
 155     }
 156     ts = rem;
 157   }
 158   return ret;
 159 }
 160
 161 /** usage */
 162 void usage(void) {
 163   printf("nsapi_sharedmem [command] [option]\n");
 164   printf("  command: preset\n");
 165 #if !defined(AVAILABLE_API)
 166   printf("    preset service_write\n");
 167   printf("    preset service_write_read n\n");
 168 #endif
 169   printf("    preset sharedmem_write\n");
 170   printf("    preset sharedmem_write_read n\n");
 171   printf("    preset write_6_A\n");
 172   printf("    preset write_6_B\n");
 173   printf("    preset write_7_A\n");
 174   printf("    preset write_7_B\n");
 175   printf("  command: manual\n");
 176   printf("    manual ***\n");
 177 }
 178
 179 /** main */
 180 int main(int argc, char *argv[]) {
 181   int status = 0;
 182
 183   FRAMEWORKUNIFIED_SET_ZONES();
 184
 185   if (argc < 2) {
 186     usage();
 187     return 0;
 188   } else {
 189     char *command = argv[1];
 190     int  option   = 0;
 191
 192     /* Execute command */
 193     if (strcmp(command, "preset") == 0) {
 194       if (argc > 2) {
 195         char *preset = argv[2];
 196         if (argc > 3) {
 197           option = atoi(argv[3]);
 198         }
 199
 200 #if defined(AVAILABLE_API)
 201         if (strcmp(preset, "sharedmem_write") == 0) {
 202           NSUT_ASSERT(NSSharedMemTransmitLogOpen() ==  eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogOpen() error.");
 203           SI_32 size = NSSharedMemWriteTransmitLog(argv[2], static_cast<UI_32>(strlen(argv[2]) + 1));
 204           NSUT_ASSERT(size == (SI_32)(strlen(argv[2]) + 1), "NSSharedMemWriteTransmitLog() error.");
 205           NSUT_ASSERT(NSSharedMemTransmitLogClose() == eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogClose() error.");
 206           if (size != (SI_32)(strlen(argv[2]) + 1)) {
 207             return -1;
 208           }
 209         } else if (strcmp(preset, "sharedmem_write_read") == 0) {
 210           for (int i = 0; i < option; i++) {
 211             NSUT_ASSERT(NSSharedMemTransmitLogOpen() ==  eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogOpen() error.");
 212             SI_32 size = NSSharedMemWriteTransmitLog(argv[2], static_cast<UI_32>(strlen(argv[2]) + 1));
 213             NSUT_ASSERT(size == (SI_32)(strlen(argv[2]) + 1), "NSSharedMemWriteTransmitLog() error.");
 214             char f_pBuffer[100] = {0};
 215             NSSharedMemReadTransmitLog(f_pBuffer, sizeof(f_pBuffer), FALSE);
 216             NSUT_ASSERT(NSSharedMemTransmitLogClose() == eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogClose() error.");
 217           }
 218         }
 219 #else
 220         if (strcmp(preset, "service_write") == 0) {
 221           TMemID id = SetDataToShared(argv[2], strlen(argv[2]) + 1);
 222           NSUT_ASSERT(id != BAD_MEM_ID, "SetDataToShared() error.");
 223           if (id == BAD_MEM_ID) {
 224             return -1;
 225           }
 226         } else if (strcmp(preset, "service_write_read") == 0) {
 227           for (int i = 0; i < option; i++) {
 228             EFrameworkunifiedStatus status;
 229             TMemID id = SetDataToShared(argv[2], strlen(argv[2]) + 1);
 230             NSUT_ASSERT(id != BAD_MEM_ID, "SetDataToShared() error.");
 231             UI_32 size = GetLengthOfDataFromShared(id);
 232             NSUT_ASSERT(size == (strlen(argv[2]) + 1), "NSSharedMemWriteTransmitLog() error.");
 233             void *data[100] = { 0 };
 234             status = GetDataFromShared(id, data, sizeof(data));
 235             NSUT_ASSERT(eFrameworkunifiedStatusOK == status, "GetDataFromShared()");
 236             status = DiscardDataFromShared(id);
 237             NSUT_ASSERT(eFrameworkunifiedStatusOK == status, "DiscardDataFromShared()");
 238           }
 239         } else if (strcmp(preset, "sharedmem_write") == 0) {
 240           NSUT_ASSERT(NSSharedMemTransmitLogOpen() ==  eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogOpen() error.");
 241           SI_32 size = NSSharedMemWriteTransmitLog(argv[2], strlen(argv[2]) + 1);
 242           NSUT_ASSERT(size == (SI_32)(strlen(argv[2]) + 1), "NSSharedMemWriteTransmitLog() error.");
 243           NSUT_ASSERT(NSSharedMemTransmitLogClose() == eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogClose() error.");
 244           if (size != (SI_32)(strlen(argv[2]) + 1)) {
 245             return -1;
 246           }
 247         } else if (strcmp(preset, "sharedmem_write_read") == 0) {
 248           for (int i = 0; i < option; i++) {
 249             NSUT_ASSERT(NSSharedMemTransmitLogOpen() ==  eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogOpen() error.");
 250             SI_32 size = NSSharedMemWriteTransmitLog(argv[2], strlen(argv[2]) + 1);
 251             NSUT_ASSERT(size == (SI_32)(strlen(argv[2]) + 1), "NSSharedMemWriteTransmitLog() error.");
 252             char f_pBuffer[100] = {0};
 253             NSSharedMemReadTransmitLog(f_pBuffer, sizeof(f_pBuffer), FALSE);
 254             NSUT_ASSERT(NSSharedMemTransmitLogClose() == eFrameworkunifiedStatusOK, "NSSharedMemTransmitLogClose() error.");
 255           }
 256         }
 257 #endif
 258         else if (strcmp(preset, "write_6_A") == 0) {  // NOLINT  (readability/nolint)
 259           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 260           if (testObj->Open() != eFrameworkunifiedStatusOK) {
 261             status = -1;
 262           }
 263           sleep(2);
 264           char f_pBuffer[100] = {0};
 265           if (testObj->Read(f_pBuffer, sizeof(f_pBuffer), FALSE) != 7) {
 266             status = -1;
 267           }
 268           if (memcmp(f_pBuffer, "ABCDEFG", 7) != 0) {
 269             printf("memcmp() error.");
 270             return -1;
 271           }
 272           if (testObj->Close() != eFrameworkunifiedStatusOK) {
 273             status = -1;
 274           }
 275           delete testObj;
 276         } else if (strcmp(preset, "write_6_B") == 0)  {
 277           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 278           if (testObj->Open() != eFrameworkunifiedStatusOK) {
 279             status = -1;
 280           }
 281           if (testObj->Write("ABCDEFG", static_cast<UI_32>(strlen("ABCDEFG"))) != 7) {
 282             status = -1;
 283           }
 284           if (testObj->Close() != eFrameworkunifiedStatusOK) {
 285             status = -1;
 286           }
 287           delete testObj;
 288         } else if (strcmp(preset, "write_7_A") == 0) {
 289           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 290           if (testObj->Open() != eFrameworkunifiedStatusOK) {
 291             status = -1;
 292           }
 293           sleep(2);
 294           char f_pBuffer[100] = {0};
 295           if (testObj->Read(f_pBuffer, sizeof(f_pBuffer), FALSE) == 7) {
 296             status = -1;
 297           }
 298           if (testObj->Close() != eFrameworkunifiedStatusOK) {
 299             status = -1;
 300           }
 301           delete testObj;
 302         } else if (strcmp(preset, "write_7_B") == 0) {
 303           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 304           if (testObj->Open() == eFrameworkunifiedStatusOK) {
 305             status = -1;
 306           }
 307           if (testObj->Write("ABCDEFG", static_cast<UI_32>(strlen("ABCDEFG"))) == 7) {
 308             status = -1;
 309           }
 310           if (testObj->Close() == eFrameworkunifiedStatusOK) {
 311             status = -1;
 312           }
 313           delete testObj;
 314         } else if (strcmp(preset, "stress_4") == 0) {
 315           int i;
 316           char *writeBuffer = new char[0x400]();
 317           for (i = 0; i < 0x400; i++) {
 318             writeBuffer[i] = static_cast<char>(i);
 319           }
 320
 321           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 322           if (testObj->Open() != eFrameworkunifiedStatusOK) {
 323             status = -1;
 324           }
 325           int timeout = 0;
 326           int test_count = 0;
 327           while ((timeout < 10) && (test_count < option)) {
 328             if (testObj->GetSize() > (SI_32)(TRANSMIT_LOG_SHAREDMEM_SIZE - 0x800)) {
 329               sleep_msec(100);
 330               timeout++;
 331               // printf("timeout = %d\n", timeout);
 332               continue;
 333             }
 334             if (testObj->ClearBuf() != eFrameworkunifiedStatusOK) {
 335               status = -1;
 336             }
 337             if (testObj->SetReadPtrToWritePtr() != eFrameworkunifiedStatusOK) {
 338               status = -1;
 339             }
 340             if (testObj->Write(writeBuffer, 0x400) != 0x400) {
 341               status = -1;
 342             }
 343             timeout = 0;
 344             test_count++;
 345           }
 346           if (testObj->Close() != eFrameworkunifiedStatusOK) {
 347             status = -1;
 348           }
 349           delete testObj;
 350
 351           delete[] writeBuffer;
 352         } else if (strcmp(preset, "stress_5") == 0) {
 353           int i;
 354           char *writeBuffer = new char[0x100]();
 355           for (i = 0; i < 0x100; i++) {
 356             writeBuffer[i] = static_cast<char>(0xff - i);
 357           }
 358
 359           CNSSharedMem *testObj = new CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
 360           if (testObj->Open() != eFrameworkunifiedStatusOK) {
 361             status = -1;
 362           }
 363           int timeout = 0;
 364           int count = 0;
 365           while (timeout < 10) {
 366             int size = (count % 0xff) + 1;
 367             if (testObj->GetSize() > (SI_32)(TRANSMIT_LOG_SHAREDMEM_SIZE - 0x800)) {
 368               sleep_msec(100);
 369               timeout++;
 370               continue;
 371             }
 372             if (testObj->Write(&writeBuffer[0xff - size], size) != size) {
 373               status = -1;
 374             }
 375             timeout = 0;
 376             count++;
 377           }
 378           if (testObj->Close() != eFrameworkunifiedStatusOK) {
 379             status = -1;
 380           }
 381           delete testObj;
 382
 383           delete[] writeBuffer;
 384         } else {
 385           usage();
 386         }
 387       } else {
 388         usage();
 389       }
 390     } else if (strcmp(command, "manual") == 0) {
 391       int   testno;
 392       char  buf[32];
 393       INT8  active = 1;
 394
 395       while (active) {
 396         printf(" ----- imageapi ----------\n");
 397         printf("   0: debug_test()\n");
 398         printf("   1: gfx_ut_image_api()\n");
 399         printf("   2: gfx_ut_image_csv()\n");
 400         printf("   q: quit\n");
 401         printf(" -------------------------\n");
 402
 403         fgets(buf, sizeof(buf), stdin);
 404         if (buf[0] == '\n') {
 405           continue;
 406         } else if (buf[0] == 'q' || buf[0] == 'Q') {
 407           active = 0;
 408           continue;
 409         }
 410         testno = atoi(buf);
 411
 412         switch (testno) {
 413           case 0:
 414             // debug_test();
 415             break;
 416           case 1:
 417             // gfx_ut_image_api();
 418             break;
 419           case 2:
 420             // gfx_ut_image_csv((char *)"it_image.csv");
 421             break;
 422           default:
 423             break;
 424         }
 425       }
 426     } else {
 427       usage();
 428     }
 429   }
 430   return status;
 431 }