ffs_tst.c.svn-base
上传用户:hujq123
上传日期:2016-04-10
资源大小:153k
文件大小:15k
源码类别:

Telnet服务器

开发平台:

Unix_Linux

  1. /* 
  2.  * Copyright (C) 2002 Koninklijke Philips Electronics N.V., 
  3.  * All Rights Reserved. 
  4.  *
  5.  * This source code and any compilation or derivative thereof is the 
  6.  * proprietary information of Koninklijke Philips Electronics N.V. 
  7.  * and is confidential in nature. 
  8.  * Under no circumstances is this software to be exposed to or placed 
  9.  * under an Open Source License of any type without the expressed 
  10.  * written permission of Koninklijke Philips Electronics N.V. 
  11.  * 
  12.  *###########################################################
  13.  */ 
  14. /*! 
  15.  *      file           ffs_tst.c 
  16.  * 
  17.  *      brief          - 
  18.  * 
  19.  */ 
  20. /*-----------------------------------------------------------*
  21.  * 
  22.  *      %version:       2.1.2 % 
  23.  *      instance:       DS_6 
  24.  *      %date_created:  Fri Feb 21 08:04:54 2003 % 
  25.  *
  26.  *###########################################################
  27.  */ 
  28. /*------------------------------ Includes ------------------------------------*/
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <string.h>
  32. #include <stdio.h>
  33. #include <unistd.h>
  34. #include <errno.h>
  35. //#include <tmlib/dprintf.h>
  36. #include <psos.h>
  37. #include <math.h>
  38. #include <fcntl.h>
  39. #include <sys/stat.h>
  40. #include <dirent.h>
  41. #include <tmlib/tmFlash.h>
  42. #include <ops/custom_ops.h>
  43. #if defined(PROFILING)
  44. #include <tmlib/profile_api.h>
  45. #endif
  46. typedef void (*FfsTstPrintf_t)(void *, char *, ...) ;
  47. static FfsTstPrintf_t FfsTstPrintf ;
  48. static void *FfsTstHandle ;
  49. /*---------------------------- Test parameters -------------------------------*/
  50. #define  MAX_FILE_SIZE    (32*1024)
  51. #define  MIN_FILE_SIZE    100
  52. #define E(command) command
  53. #define EE(command) 
  54.      FfsTstPrintf(FfsTstHandle, " [%d] ----------- %20s == %dn", i, #command, command ); 
  55.      dump_flash(); 
  56. }
  57. #define FS_ASSERT( assertion, code ) 
  58.     { if (!(assertion)) { 
  59.     fprintf(stderr, "Flash file system assert failed; %s (exiting)n", #code); 
  60.     exit(-1); 
  61.     } }
  62. /*----------------------- Directory creating / deletion ----------------------*/
  63. #define DIR_CREATE(TOP) 
  64. {      
  65. E( mkdir ("/flash/"TOP,           0777                   )); 
  66. E( touch ("/flash/"TOP"/a"                               )); 
  67. E( touch ("/flash/"TOP"/b"                               )); 
  68. E( touch ("/flash/"TOP"/c"                               )); 
  69. E( mkdir ("/flash/"TOP"/KLOP",    0777                   )); 
  70. E( link  ("/flash/"TOP"/a",       "/flash/"TOP"/KLOP/aa" )); 
  71. E( link  ("/flash/"TOP"/KLOP/aa", "/flash/"TOP           )); 
  72. }
  73. #define DIR_DELETE( TOP) 
  74. {       
  75. E( unlink ("/flash/"TOP"/a"       )); 
  76. E( unlink ("/flash/"TOP"/KLOP"    )); 
  77. E( unlink ("/flash/"TOP"/a"       )); 
  78. E( unlink ("/flash/"TOP"/KLOP/aa" )); 
  79. E( unlink ("/flash/"TOP"/KLOP"    )); 
  80. E( unlink ("/flash/"TOP"/aa"      )); 
  81. E( unlink ("/flash/"TOP"/b"       )); 
  82. E( unlink ("/flash/"TOP"/c"       )); 
  83. E( unlink ("/flash/"TOP           )); 
  84. }
  85. /*------------------------ Recursive directory printing ----------------------*/
  86. Int touch ( String f)
  87. {
  88.     Int fd= open(f, O_CREAT | O_WRONLY);
  89.     if (fd != -1 && close(fd)) {
  90.         return 0;
  91.     } else {
  92.         return -1;
  93.     }
  94. }
  95. void dump_flash() { dump_file_system("/flash", NULL); }
  96. /*------------------------------- Event handler ------------------------------*/
  97. static Int nrof_write_errors;
  98. static void event_handler(FlashEvent);
  99. static void event_handler(FlashEvent event)
  100. {
  101.     if (event == FlashWriteError) {
  102.         nrof_write_errors++;
  103.     } else 
  104.     if (event == FlashFull) {
  105.         fprintf(stderr,"Flash fulln");
  106.         exit(-1);
  107.     } else 
  108.     if (event == FlashDangerousWriteError) {
  109.         fprintf(stderr,"Dangerous write errorn");
  110.         exit(-1);
  111.     }
  112. }
  113. /*-------------------------- Cycles handler ----------------------------*/
  114. typedef struct
  115. {
  116.     UInt32  lo ;
  117.     UInt32  hi ;
  118. } Cycles_t ;
  119. static float    WriteBytes ;
  120. static float    ReadBytes ;
  121. static Cycles_t ElapsedWrite ;
  122. static Cycles_t ElapsedRead ;
  123. void CyclesAdd(Cycles_t *pCyclesAccum, Cycles_t *pCycles)
  124. {
  125.     UInt32  add_lo ;
  126.     UInt32  add_hi ;
  127.     add_hi = pCycles->hi + pCyclesAccum->hi ;
  128.     add_lo = pCycles->lo + pCyclesAccum->lo ;
  129.     if ((add_lo < pCycles->lo) || (add_lo < pCyclesAccum->lo))
  130.     {
  131.         add_hi++ ;
  132.     }
  133. #if defined(DEBUG)
  134.     FfsTstPrintf(FfsTstHandle, "CyclesAdd #0 %08x %08xn", pCycles->hi, pCycles->lo) ;
  135.     FfsTstPrintf(FfsTstHandle, "CyclesAdd #1 %08x %08xn", pCyclesAccum->hi, pCyclesAccum->lo) ;
  136.     FfsTstPrintf(FfsTstHandle, "CyclesAdd #2 %08x %08xn", add_hi, add_lo) ;
  137. #endif
  138.     pCyclesAccum->hi = add_hi ;
  139.     pCyclesAccum->lo = add_lo ;
  140. }
  141. void CyclesSub(Cycles_t *pCyclesAccum, Cycles_t *pCycles)
  142. {
  143.     UInt32  sub_lo ;
  144.     UInt32  sub_hi ;
  145.     sub_hi = pCycles->hi - pCyclesAccum->hi ;
  146.     sub_lo = pCycles->lo - pCyclesAccum->lo ;
  147.     if (pCycles->lo < pCyclesAccum->lo)
  148.     {
  149.         sub_hi-- ;
  150.     }
  151. #if defined(DEBUG)
  152.     FfsTstPrintf(FfsTstHandle, "CyclesSub #0 %08x %08xn", pCycles->hi, pCycles->lo) ;
  153.     FfsTstPrintf(FfsTstHandle, "CyclesSub #1 %08x %08xn", pCyclesAccum->hi, pCyclesAccum->lo) ;
  154.     FfsTstPrintf(FfsTstHandle, "CyclesSub #2 %08x %08xn", sub_hi, sub_lo) ;
  155. #endif
  156.     pCyclesAccum->hi = sub_hi ;
  157.     pCyclesAccum->lo = sub_lo ;
  158. }
  159. void CyclesZero(Cycles_t *pCycles)
  160. {
  161.     pCycles->hi = 0 ;
  162.     pCycles->lo = 0 ;
  163. }
  164. void CyclesStart(Cycles_t *pCycles)
  165. {
  166.     pCycles->hi = hicycles() ;
  167.     pCycles->lo = cycles() ;
  168. #if defined(DEBUG)
  169.     FfsTstPrintf(FfsTstHandle, "CyclesStart %08x %08xn", pCycles->hi, pCycles->lo) ;
  170. #endif
  171. }
  172. void CyclesDone(Cycles_t *pCyclesStart)
  173. {
  174.     Cycles_t Cycles ;
  175.     Cycles.hi = hicycles() ;
  176.     Cycles.lo = cycles() ;
  177.     CyclesSub(pCyclesStart, &Cycles) ;
  178. #if defined(DEBUG)
  179.     FfsTstPrintf(FfsTstHandle, "CyclesDone  %08x %08xn", pCyclesStart->hi, pCyclesStart->lo) ;
  180. #endif
  181. }
  182. float CyclesToSeconds(Cycles_t *pCycles)
  183. {
  184.     float   fCyclesPerSecond ;
  185.     float   fLo ;
  186.     float   fHi ;
  187.     float   fCycles ;
  188.     float   fSeconds ;
  189.     fLo = (float) pCycles->lo ;
  190.     fHi = pow(2.0, 32.0) * ((float) pCycles->hi) ;
  191.     fCycles = fLo + fHi ;
  192.     fCyclesPerSecond = (float) Clocks_GetCpuFrequency() ;
  193.     fSeconds = fCycles / fCyclesPerSecond ;
  194. #if defined(DEBUG)
  195.     FfsTstPrintf(FfsTstHandle, "CyclesToSeconds %10f %10f %10f %10f %10fn",
  196.            fLo, fHi, fCycles, fCyclesPerSecond, fSeconds) ;
  197. #endif
  198.     return fSeconds ;
  199. }
  200. /*-------------------------- File read/write test ----------------------------*/
  201. Bool write_read_test(Int task, Int count)
  202. {
  203.     Int         i;
  204.     Int         fp;
  205.     Int         size;
  206.     Int         ws;
  207.     Int         transfer_size ;
  208.     Int         bytes_left ;
  209.     Int         errors_found;
  210.     Char        *write_data ;
  211.     Char        *read_data  ;
  212.     Char        *data ;
  213.     Char        fName[80];
  214.     Cycles_t    Elapsed ;
  215.     nrof_write_errors= 0;
  216.     size = (rand() * rand()) % MAX_FILE_SIZE;
  217.     if (size < MIN_FILE_SIZE) {
  218.       size = MIN_FILE_SIZE ;
  219.     }
  220.     write_data = malloc(size) ;
  221.     if (write_data == NULL)
  222.     {
  223.         FfsTstPrintf(FfsTstHandle, "No memory for write buffern") ;
  224.         return False ;
  225.     }
  226.     read_data = malloc(size) ;
  227.     if (read_data == NULL)
  228.     {
  229.         FfsTstPrintf(FfsTstHandle, "No memory for read buffern") ;
  230.         return False ;
  231.     }
  232.     sprintf(fName, "/flash/fst%xf%x.bin", task, count & 0xf);
  233.     for (i = 0; i < size; i++) { write_data[i] = i & 255; }
  234.     for (i = 0; i < size; i++) { read_data [i] = 47;      }
  235.     fp = open(fName, O_CREAT | O_BINARY | O_WRONLY, 0777);
  236.     if (fp == -1)
  237.     {
  238.         FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : open for write failed, errno %dn",
  239.                      task, count, fName, errno) ;
  240.         free(write_data) ;
  241.         free(read_data) ;
  242.         return False ;
  243.     }
  244.     CyclesStart(&Elapsed) ;
  245.     bytes_left = size ;
  246.     data = write_data ;
  247.     while (bytes_left != 0)
  248.     {
  249.         transfer_size = rand() % (size/2) ;
  250.         if (bytes_left < transfer_size)
  251.         {
  252.             transfer_size = bytes_left ;
  253.         }
  254.         ws = write(fp, data, transfer_size);
  255.         if (transfer_size != ws)
  256.         {
  257.             FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : write failed exp %d obs %dn",
  258.                          task, count, fName, transfer_size, ws) ;
  259.             free(write_data) ;
  260.             free(read_data) ;
  261.             return False ;
  262.         }
  263.         bytes_left -= transfer_size ;
  264.         data += transfer_size ;
  265.     }
  266.     CyclesDone(&Elapsed) ;
  267.     CyclesAdd(&ElapsedWrite, &Elapsed) ;
  268.     WriteBytes += (float) size ;
  269.     
  270.     if (close(fp) != 0)
  271.     {
  272.         FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : close for write failed, errno %dn",
  273.                      task, count, fName, errno) ;
  274.         free(write_data) ;
  275.         free(read_data) ;
  276.         return False ;
  277.     }
  278.     
  279.     fp = open(fName, O_BINARY | O_RDONLY, 0777);
  280.     if (fp == -1)
  281.     {
  282.         FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : open for read failed, errno %dn",
  283.                      task, count, fName, errno) ;
  284.         free(write_data) ;
  285.         free(read_data) ;
  286.         return False ;
  287.     }
  288.     CyclesStart(&Elapsed) ;
  289.     bytes_left = size ;
  290.     data = read_data ;
  291.     while (bytes_left != 0)
  292.     {
  293.         transfer_size = rand() % (size/2) ;
  294.         if (bytes_left < transfer_size)
  295.         {
  296.             transfer_size = bytes_left ;
  297.         }
  298.         ws = read(fp, data, transfer_size);
  299.         if (transfer_size != ws)
  300.         {
  301.             FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : read failed exp %d obs %dn",
  302.                          task, count, fName, transfer_size, ws) ;
  303.             free(write_data) ;
  304.             free(read_data) ;
  305.             return False ;
  306.         }
  307.         bytes_left -= transfer_size ;
  308.         data += transfer_size ;
  309.     }
  310.     CyclesDone(&Elapsed) ;
  311.     CyclesAdd(&ElapsedRead, &Elapsed) ;
  312.     ReadBytes += (float) size ;
  313.     
  314.     if (close(fp) != 0)
  315.     {
  316.         FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : close for read failed, errno %dn",
  317.                      task, count, fName, errno) ;
  318.         free(write_data) ;
  319.         free(read_data) ;
  320.         return False ;
  321.     }
  322.     errors_found = 0;
  323.     for (i = 0; i < size; i++) {
  324.         if (write_data[i] != read_data[i]) {
  325.             errors_found++;
  326.             if (errors_found < 10) {
  327.                 FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : Data error %d, offset %08x. exp %02x obs %02xn",
  328.                              task, count, fName, errors_found, i, write_data[i], read_data[i]);
  329.             }
  330.         }
  331.     }
  332.     if (errors_found != 0)
  333.     {
  334.         FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : %7d bytes failed, errors %dn",
  335.                      task, count, fName, size, errors_found);
  336.         free(write_data) ;
  337.         free(read_data) ;
  338.         return False ;
  339.     }
  340. #if defined(SHOW_PROGRESS)
  341.     FfsTstPrintf(FfsTstHandle, "FfsTst %d %6d %s : %7d bytes passedn",
  342.                  task, count, fName, size);
  343. #endif
  344.     free(write_data) ;
  345.     free(read_data) ;
  346.     return True ;
  347. }
  348. /*------------------------------ Main program --------------------------------*/
  349. void dump_status()
  350. {
  351.     FfsTstPrintf(FfsTstHandle, "--------------------------------------------------n");
  352.     dump_flash();
  353.     FlashUtil_print();
  354.     FfsTstPrintf(FfsTstHandle, "--------------------------------------------------n");
  355. }
  356. void print_heap()
  357. {
  358.     Pointer x= (Pointer)malloc(0x1030);
  359.     FfsTstPrintf(FfsTstHandle, "0x%08x ", x); 
  360.     free(x);
  361. }
  362. void ffs_test(FfsTstPrintf_t Printf, void * Handle, int task, int nrof_iterations)
  363.     {
  364.         Int i;
  365.         Int count ;
  366.         Char fName[80];
  367. #if defined(DEBUG)
  368.         atexit(dump_status);
  369. #endif
  370.         FfsTstPrintf = Printf ;
  371.         FfsTstHandle = Handle ;
  372.         CyclesZero(&ElapsedWrite) ;
  373.         CyclesZero(&ElapsedRead) ;
  374.         WriteBytes = 0.0 ;
  375.         ReadBytes = 0.0 ;
  376.         FfsTstPrintf(FfsTstHandle, "ffs_test task %d startn", task);
  377. #if !defined(__FFS_TEST_IN_TW_CLI_FS__)
  378.         dump_flash() ;
  379. #endif
  380.         for (i = 0; i < nrof_iterations; i++) {
  381.             if (write_read_test(task, i) != True)
  382.             {
  383.                 return ;
  384.             }
  385.         }
  386.         for (count = 0 ; count < 16; count++)
  387.         {
  388.             sprintf(fName, "/flash/fst%xf%x.bin", task, count) ;
  389.             unlink(fName) ;
  390.         }
  391. #if 0
  392.         FfsTstPrintf(FfsTstHandle, "n");
  393.         FfsTstPrintf(FfsTstHandle, "Transfer rates:n") ;
  394.         FfsTstPrintf(FfsTstHandle, "    Write %7.2f KB/secondn",
  395.                WriteBytes/CyclesToSeconds(&ElapsedWrite)/1024.0) ;
  396.         FfsTstPrintf(FfsTstHandle, "    Read  %7.2f KB/secondn",
  397.                      ReadBytes/CyclesToSeconds(&ElapsedRead)/1024.0) ;
  398.         FfsTstPrintf(FfsTstHandle, "    Write  bytes %f seconds %10f cycles %08x %08xn",
  399.                      WriteBytes, CyclesToSeconds(&ElapsedWrite),
  400.                      ElapsedWrite.hi, ElapsedWrite.lo) ;
  401.         FfsTstPrintf(FfsTstHandle, "    Read   bytes %f seconds %10f cycles %08x %08xn",
  402.                      ReadBytes, CyclesToSeconds(&ElapsedRead),
  403.                      ElapsedRead.hi, ElapsedRead.lo) ;
  404.         FfsTstPrintf(FfsTstHandle, "n");
  405. #endif
  406.         FfsTstPrintf(FfsTstHandle, "ffs_test task %d donen", task);
  407.     }
  408. int dump_profile(int handle, void *array, int nbytes)
  409. {
  410.     int bytes_per_line ;
  411.     unsigned char *cp ;
  412.     cp = (unsigned char *) array ;
  413.     bytes_per_line = 32 ;
  414.     while (nbytes-- != 0)
  415.     {
  416.         if (bytes_per_line == 32)
  417.         {
  418.             printf("prof:") ;
  419.         }
  420.         printf(" %02x", *cp++) ;
  421.         bytes_per_line-- ;
  422.         if (bytes_per_line == 0)
  423.         {
  424.             bytes_per_line = 32 ;
  425.             printf("n") ;
  426.         }
  427.     }
  428.     if (bytes_per_line != 32)
  429.     {
  430.         printf("n") ;
  431.     }
  432.     return nbytes ;
  433. }
  434. #if !defined(__FFS_TEST_IN_TW_CLI_FS__)
  435. void main(void)
  436. {
  437.     Int i;
  438.     Cycles_t Elapsed ;
  439.     tmLibdevErr_t TmErr ;
  440. #if defined(PROFILING)
  441.     struct profileCaps caps ;
  442. #endif
  443.     JtagStdio_Init() ;
  444.     printf("n") ;
  445.     printf("startn") ;
  446.     printf("n") ;
  447.     DPsize(1024*32);
  448.     DP(("startn")) ;
  449.     TmErr = TwFlash_InitFileSystem() ;
  450.     if (TmErr != TMLIBDEV_OK)
  451.     {
  452.         printf("Error in TwFlash_InitFileSystem() %08xn", TmErr) ;
  453.         exit(1) ;
  454.     }
  455. #if defined(PROFILING)
  456.     memset(&caps, 0, sizeof(caps)) ;
  457.     strcpy(caps.version, TMPROF_VERSION) ;
  458.     strcpy(caps.args, "") ;
  459.     printf("profileInitn") ;
  460.     profileInit(&caps, dump_profile, 0) ;
  461.     printf("profileStartn") ;
  462.     profileStart() ;
  463. #endif
  464.     CyclesStart(&Elapsed) ;
  465.     ffs_test((FfsTstPrintf_t) fprintf, stdout, 0, 100) ;
  466.     CyclesDone(&Elapsed) ;
  467.     printf("elapsed seconds   %fn", CyclesToSeconds(&Elapsed)) ;
  468.     printf("elapsed cycles    %08x %08xn", Elapsed.hi, Elapsed.lo) ;
  469. #if defined(PROFILING)
  470.     printf("profileStopn") ;
  471.     profileStop() ;
  472.     printf("profileFlushn") ;
  473.     profileFlush() ;
  474. #endif
  475.     exit (0);
  476. }
  477. #endif /* !defined(__FFS_TEST_IN_TW_CLI_FS__) */