git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/timing.c

   1 /*\r
   2  *  Portable interface to the CPU cycle counter\r
   3  *\r
   4  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved\r
   5  *  SPDX-License-Identifier: Apache-2.0\r
   6  *\r
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may\r
   8  *  not use this file except in compliance with the License.\r
   9  *  You may obtain a copy of the License at\r
  10  *\r
  11  *  http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  *  Unless required by applicable law or agreed to in writing, software\r
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  *  See the License for the specific language governing permissions and\r
  17  *  limitations under the License.\r
  18  *\r
  19  *  This file is part of mbed TLS (https://tls.mbed.org)\r
  20  */\r
  21 \r
  22 #if !defined(MBEDTLS_CONFIG_FILE)\r
  23 #include "mbedtls/config.h"\r
  24 #else\r
  25 #include MBEDTLS_CONFIG_FILE\r
  26 #endif\r
  27 \r
  28 #if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_PLATFORM_C)\r
  29 #include "mbedtls/platform.h"\r
  30 #else\r
  31 #include <stdio.h>\r
  32 #define mbedtls_printf     printf\r
  33 #endif\r
  34 \r
  35 #if defined(MBEDTLS_TIMING_C)\r
  36 \r
  37 #include "mbedtls/timing.h"\r
  38 \r
  39 #if !defined(MBEDTLS_TIMING_ALT)\r
  40 \r
  41 #if !defined(unix) && !defined(__unix__) && !defined(__unix) && \\r
  42     !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \\r
  43     !defined(__HAIKU__)\r
  44 #error "This module only works on Unix and Windows, see MBEDTLS_TIMING_C in config.h"\r
  45 #endif\r
  46 \r
  47 #ifndef asm\r
  48 #define asm __asm\r
  49 #endif\r
  50 \r
  51 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)\r
  52 \r
  53 #include <windows.h>\r
  54 #include <winbase.h>\r
  55 #include <process.h>\r
  56 \r
  57 struct _hr_time\r
  58 {\r
  59     LARGE_INTEGER start;\r
  60 };\r
  61 \r
  62 #else\r
  63 \r
  64 #include <unistd.h>\r
  65 #include <sys/types.h>\r
  66 #include <sys/time.h>\r
  67 #include <signal.h>\r
  68 #include <time.h>\r
  69 \r
  70 struct _hr_time\r
  71 {\r
  72     struct timeval start;\r
  73 };\r
  74 \r
  75 #endif /* _WIN32 && !EFIX64 && !EFI32 */\r
  76 \r
  77 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
  78     ( defined(_MSC_VER) && defined(_M_IX86) ) || defined(__WATCOMC__)\r
  79 \r
  80 #define HAVE_HARDCLOCK\r
  81 \r
  82 unsigned long mbedtls_timing_hardclock( void )\r
  83 {\r
  84     unsigned long tsc;\r
  85     __asm   rdtsc\r
  86     __asm   mov  [tsc], eax\r
  87     return( tsc );\r
  88 }\r
  89 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
  90           ( _MSC_VER && _M_IX86 ) || __WATCOMC__ */\r
  91 \r
  92 /* some versions of mingw-64 have 32-bit longs even on x84_64 */\r
  93 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
  94     defined(__GNUC__) && ( defined(__i386__) || (                       \\r
  95     ( defined(__amd64__) || defined( __x86_64__) ) && __SIZEOF_LONG__ == 4 ) )\r
  96 \r
  97 #define HAVE_HARDCLOCK\r
  98 \r
  99 unsigned long mbedtls_timing_hardclock( void )\r
 100 {\r
 101     unsigned long lo, hi;\r
 102     asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );\r
 103     return( lo );\r
 104 }\r
 105 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 106           __GNUC__ && __i386__ */\r
 107 \r
 108 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
 109     defined(__GNUC__) && ( defined(__amd64__) || defined(__x86_64__) )\r
 110 \r
 111 #define HAVE_HARDCLOCK\r
 112 \r
 113 unsigned long mbedtls_timing_hardclock( void )\r
 114 {\r
 115     unsigned long lo, hi;\r
 116     asm volatile( "rdtsc" : "=a" (lo), "=d" (hi) );\r
 117     return( lo | ( hi << 32 ) );\r
 118 }\r
 119 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 120           __GNUC__ && ( __amd64__ || __x86_64__ ) */\r
 121 \r
 122 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
 123     defined(__GNUC__) && ( defined(__powerpc__) || defined(__ppc__) )\r
 124 \r
 125 #define HAVE_HARDCLOCK\r
 126 \r
 127 unsigned long mbedtls_timing_hardclock( void )\r
 128 {\r
 129     unsigned long tbl, tbu0, tbu1;\r
 130 \r
 131     do\r
 132     {\r
 133         asm volatile( "mftbu %0" : "=r" (tbu0) );\r
 134         asm volatile( "mftb  %0" : "=r" (tbl ) );\r
 135         asm volatile( "mftbu %0" : "=r" (tbu1) );\r
 136     }\r
 137     while( tbu0 != tbu1 );\r
 138 \r
 139     return( tbl );\r
 140 }\r
 141 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 142           __GNUC__ && ( __powerpc__ || __ppc__ ) */\r
 143 \r
 144 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
 145     defined(__GNUC__) && defined(__sparc64__)\r
 146 \r
 147 #if defined(__OpenBSD__)\r
 148 #warning OpenBSD does not allow access to tick register using software version instead\r
 149 #else\r
 150 #define HAVE_HARDCLOCK\r
 151 \r
 152 unsigned long mbedtls_timing_hardclock( void )\r
 153 {\r
 154     unsigned long tick;\r
 155     asm volatile( "rdpr %%tick, %0;" : "=&r" (tick) );\r
 156     return( tick );\r
 157 }\r
 158 #endif /* __OpenBSD__ */\r
 159 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 160           __GNUC__ && __sparc64__ */\r
 161 \r
 162 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&  \\r
 163     defined(__GNUC__) && defined(__sparc__) && !defined(__sparc64__)\r
 164 \r
 165 #define HAVE_HARDCLOCK\r
 166 \r
 167 unsigned long mbedtls_timing_hardclock( void )\r
 168 {\r
 169     unsigned long tick;\r
 170     asm volatile( ".byte 0x83, 0x41, 0x00, 0x00" );\r
 171     asm volatile( "mov   %%g1, %0" : "=r" (tick) );\r
 172     return( tick );\r
 173 }\r
 174 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 175           __GNUC__ && __sparc__ && !__sparc64__ */\r
 176 \r
 177 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&      \\r
 178     defined(__GNUC__) && defined(__alpha__)\r
 179 \r
 180 #define HAVE_HARDCLOCK\r
 181 \r
 182 unsigned long mbedtls_timing_hardclock( void )\r
 183 {\r
 184     unsigned long cc;\r
 185     asm volatile( "rpcc %0" : "=r" (cc) );\r
 186     return( cc & 0xFFFFFFFF );\r
 187 }\r
 188 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 189           __GNUC__ && __alpha__ */\r
 190 \r
 191 #if !defined(HAVE_HARDCLOCK) && defined(MBEDTLS_HAVE_ASM) &&      \\r
 192     defined(__GNUC__) && defined(__ia64__)\r
 193 \r
 194 #define HAVE_HARDCLOCK\r
 195 \r
 196 unsigned long mbedtls_timing_hardclock( void )\r
 197 {\r
 198     unsigned long itc;\r
 199     asm volatile( "mov %0 = ar.itc" : "=r" (itc) );\r
 200     return( itc );\r
 201 }\r
 202 #endif /* !HAVE_HARDCLOCK && MBEDTLS_HAVE_ASM &&\r
 203           __GNUC__ && __ia64__ */\r
 204 \r
 205 #if !defined(HAVE_HARDCLOCK) && defined(_MSC_VER) && \\r
 206     !defined(EFIX64) && !defined(EFI32)\r
 207 \r
 208 #define HAVE_HARDCLOCK\r
 209 \r
 210 unsigned long mbedtls_timing_hardclock( void )\r
 211 {\r
 212     LARGE_INTEGER offset;\r
 213 \r
 214     QueryPerformanceCounter( &offset );\r
 215 \r
 216     return( (unsigned long)( offset.QuadPart ) );\r
 217 }\r
 218 #endif /* !HAVE_HARDCLOCK && _MSC_VER && !EFIX64 && !EFI32 */\r
 219 \r
 220 #if !defined(HAVE_HARDCLOCK)\r
 221 \r
 222 #define HAVE_HARDCLOCK\r
 223 \r
 224 static int hardclock_init = 0;\r
 225 static struct timeval tv_init;\r
 226 \r
 227 unsigned long mbedtls_timing_hardclock( void )\r
 228 {\r
 229     struct timeval tv_cur;\r
 230 \r
 231     if( hardclock_init == 0 )\r
 232     {\r
 233         gettimeofday( &tv_init, NULL );\r
 234         hardclock_init = 1;\r
 235     }\r
 236 \r
 237     gettimeofday( &tv_cur, NULL );\r
 238     return( ( tv_cur.tv_sec  - tv_init.tv_sec  ) * 1000000\r
 239           + ( tv_cur.tv_usec - tv_init.tv_usec ) );\r
 240 }\r
 241 #endif /* !HAVE_HARDCLOCK */\r
 242 \r
 243 volatile int mbedtls_timing_alarmed = 0;\r
 244 \r
 245 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)\r
 246 \r
 247 unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )\r
 248 {\r
 249     struct _hr_time *t = (struct _hr_time *) val;\r
 250 \r
 251     if( reset )\r
 252     {\r
 253         QueryPerformanceCounter( &t->start );\r
 254         return( 0 );\r
 255     }\r
 256     else\r
 257     {\r
 258         unsigned long delta;\r
 259         LARGE_INTEGER now, hfreq;\r
 260         QueryPerformanceCounter(  &now );\r
 261         QueryPerformanceFrequency( &hfreq );\r
 262         delta = (unsigned long)( ( now.QuadPart - t->start.QuadPart ) * 1000ul\r
 263                                  / hfreq.QuadPart );\r
 264         return( delta );\r
 265     }\r
 266 }\r
 267 \r
 268 /* It's OK to use a global because alarm() is supposed to be global anyway */\r
 269 static DWORD alarmMs;\r
 270 \r
 271 static void TimerProc( void *TimerContext )\r
 272 {\r
 273     (void) TimerContext;\r
 274     Sleep( alarmMs );\r
 275     mbedtls_timing_alarmed = 1;\r
 276     /* _endthread will be called implicitly on return\r
 277      * That ensures execution of thread funcition's epilogue */\r
 278 }\r
 279 \r
 280 void mbedtls_set_alarm( int seconds )\r
 281 {\r
 282     if( seconds == 0 )\r
 283     {\r
 284         /* No need to create a thread for this simple case.\r
 285          * Also, this shorcut is more reliable at least on MinGW32 */\r
 286         mbedtls_timing_alarmed = 1;\r
 287         return;\r
 288     }\r
 289 \r
 290     mbedtls_timing_alarmed = 0;\r
 291     alarmMs = seconds * 1000;\r
 292     (void) _beginthread( TimerProc, 0, NULL );\r
 293 }\r
 294 \r
 295 #else /* _WIN32 && !EFIX64 && !EFI32 */\r
 296 \r
 297 unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )\r
 298 {\r
 299     struct _hr_time *t = (struct _hr_time *) val;\r
 300 \r
 301     if( reset )\r
 302     {\r
 303         gettimeofday( &t->start, NULL );\r
 304         return( 0 );\r
 305     }\r
 306     else\r
 307     {\r
 308         unsigned long delta;\r
 309         struct timeval now;\r
 310         gettimeofday( &now, NULL );\r
 311         delta = ( now.tv_sec  - t->start.tv_sec  ) * 1000ul\r
 312               + ( now.tv_usec - t->start.tv_usec ) / 1000;\r
 313         return( delta );\r
 314     }\r
 315 }\r
 316 \r
 317 static void sighandler( int signum )\r
 318 {\r
 319     mbedtls_timing_alarmed = 1;\r
 320     signal( signum, sighandler );\r
 321 }\r
 322 \r
 323 void mbedtls_set_alarm( int seconds )\r
 324 {\r
 325     mbedtls_timing_alarmed = 0;\r
 326     signal( SIGALRM, sighandler );\r
 327     alarm( seconds );\r
 328     if( seconds == 0 )\r
 329     {\r
 330         /* alarm(0) cancelled any previous pending alarm, but the\r
 331            handler won't fire, so raise the flag straight away. */\r
 332         mbedtls_timing_alarmed = 1;\r
 333     }\r
 334 }\r
 335 \r
 336 #endif /* _WIN32 && !EFIX64 && !EFI32 */\r
 337 \r
 338 /*\r
 339  * Set delays to watch\r
 340  */\r
 341 void mbedtls_timing_set_delay( void *data, uint32_t int_ms, uint32_t fin_ms )\r
 342 {\r
 343     mbedtls_timing_delay_context *ctx = (mbedtls_timing_delay_context *) data;\r
 344 \r
 345     ctx->int_ms = int_ms;\r
 346     ctx->fin_ms = fin_ms;\r
 347 \r
 348     if( fin_ms != 0 )\r
 349         (void) mbedtls_timing_get_timer( &ctx->timer, 1 );\r
 350 }\r
 351 \r
 352 /*\r
 353  * Get number of delays expired\r
 354  */\r
 355 int mbedtls_timing_get_delay( void *data )\r
 356 {\r
 357     mbedtls_timing_delay_context *ctx = (mbedtls_timing_delay_context *) data;\r
 358     unsigned long elapsed_ms;\r
 359 \r
 360     if( ctx->fin_ms == 0 )\r
 361         return( -1 );\r
 362 \r
 363     elapsed_ms = mbedtls_timing_get_timer( &ctx->timer, 0 );\r
 364 \r
 365     if( elapsed_ms >= ctx->fin_ms )\r
 366         return( 2 );\r
 367 \r
 368     if( elapsed_ms >= ctx->int_ms )\r
 369         return( 1 );\r
 370 \r
 371     return( 0 );\r
 372 }\r
 373 \r
 374 #endif /* !MBEDTLS_TIMING_ALT */\r
 375 \r
 376 #if defined(MBEDTLS_SELF_TEST)\r
 377 \r
 378 /*\r
 379  * Busy-waits for the given number of milliseconds.\r
 380  * Used for testing mbedtls_timing_hardclock.\r
 381  */\r
 382 static void busy_msleep( unsigned long msec )\r
 383 {\r
 384     struct mbedtls_timing_hr_time hires;\r
 385     unsigned long i = 0; /* for busy-waiting */\r
 386     volatile unsigned long j; /* to prevent optimisation */\r
 387 \r
 388     (void) mbedtls_timing_get_timer( &hires, 1 );\r
 389 \r
 390     while( mbedtls_timing_get_timer( &hires, 0 ) < msec )\r
 391         i++;\r
 392 \r
 393     j = i;\r
 394     (void) j;\r
 395 }\r
 396 \r
 397 #define FAIL    do                                                      \\r
 398     {                                                                   \\r
 399         if( verbose != 0 )                                              \\r
 400         {                                                               \\r
 401             mbedtls_printf( "failed at line %d\n", __LINE__ );          \\r
 402             mbedtls_printf( " cycles=%lu ratio=%lu millisecs=%lu secs=%lu hardfail=%d a=%lu b=%lu\n", \\r
 403                             cycles, ratio, millisecs, secs, hardfail,   \\r
 404                             (unsigned long) a, (unsigned long) b );     \\r
 405             mbedtls_printf( " elapsed(hires)=%lu elapsed(ctx)=%lu status(ctx)=%d\n", \\r
 406                             mbedtls_timing_get_timer( &hires, 0 ),      \\r
 407                             mbedtls_timing_get_timer( &ctx.timer, 0 ),  \\r
 408                             mbedtls_timing_get_delay( &ctx ) );         \\r
 409         }                                                               \\r
 410         return( 1 );                                                    \\r
 411     } while( 0 )\r
 412 \r
 413 /*\r
 414  * Checkup routine\r
 415  *\r
 416  * Warning: this is work in progress, some tests may not be reliable enough\r
 417  * yet! False positives may happen.\r
 418  */\r
 419 int mbedtls_timing_self_test( int verbose )\r
 420 {\r
 421     unsigned long cycles = 0, ratio = 0;\r
 422     unsigned long millisecs = 0, secs = 0;\r
 423     int hardfail = 0;\r
 424     struct mbedtls_timing_hr_time hires;\r
 425     uint32_t a = 0, b = 0;\r
 426     mbedtls_timing_delay_context ctx;\r
 427 \r
 428     if( verbose != 0 )\r
 429         mbedtls_printf( "  TIMING tests note: will take some time!\n" );\r
 430 \r
 431     if( verbose != 0 )\r
 432         mbedtls_printf( "  TIMING test #1 (set_alarm / get_timer): " );\r
 433 \r
 434     {\r
 435         secs = 1;\r
 436 \r
 437         (void) mbedtls_timing_get_timer( &hires, 1 );\r
 438 \r
 439         mbedtls_set_alarm( (int) secs );\r
 440         while( !mbedtls_timing_alarmed )\r
 441             ;\r
 442 \r
 443         millisecs = mbedtls_timing_get_timer( &hires, 0 );\r
 444 \r
 445         /* For some reason on Windows it looks like alarm has an extra delay\r
 446          * (maybe related to creating a new thread). Allow some room here. */\r
 447         if( millisecs < 800 * secs || millisecs > 1200 * secs + 300 )\r
 448             FAIL;\r
 449     }\r
 450 \r
 451     if( verbose != 0 )\r
 452         mbedtls_printf( "passed\n" );\r
 453 \r
 454     if( verbose != 0 )\r
 455         mbedtls_printf( "  TIMING test #2 (set/get_delay        ): " );\r
 456 \r
 457     {\r
 458         a = 800;\r
 459         b = 400;\r
 460         mbedtls_timing_set_delay( &ctx, a, a + b );          /* T = 0 */\r
 461 \r
 462         busy_msleep( a - a / 4 );                      /* T = a - a/4 */\r
 463         if( mbedtls_timing_get_delay( &ctx ) != 0 )\r
 464             FAIL;\r
 465 \r
 466         busy_msleep( a / 4 + b / 4 );                  /* T = a + b/4 */\r
 467         if( mbedtls_timing_get_delay( &ctx ) != 1 )\r
 468             FAIL;\r
 469 \r
 470         busy_msleep( b );                          /* T = a + b + b/4 */\r
 471         if( mbedtls_timing_get_delay( &ctx ) != 2 )\r
 472             FAIL;\r
 473     }\r
 474 \r
 475     mbedtls_timing_set_delay( &ctx, 0, 0 );\r
 476     busy_msleep( 200 );\r
 477     if( mbedtls_timing_get_delay( &ctx ) != -1 )\r
 478         FAIL;\r
 479 \r
 480     if( verbose != 0 )\r
 481         mbedtls_printf( "passed\n" );\r
 482 \r
 483     if( verbose != 0 )\r
 484         mbedtls_printf( "  TIMING test #3 (hardclock / get_timer): " );\r
 485 \r
 486     /*\r
 487      * Allow one failure for possible counter wrapping.\r
 488      * On a 4Ghz 32-bit machine the cycle counter wraps about once per second;\r
 489      * since the whole test is about 10ms, it shouldn't happen twice in a row.\r
 490      */\r
 491 \r
 492 hard_test:\r
 493     if( hardfail > 1 )\r
 494     {\r
 495         if( verbose != 0 )\r
 496             mbedtls_printf( "failed (ignored)\n" );\r
 497 \r
 498         goto hard_test_done;\r
 499     }\r
 500 \r
 501     /* Get a reference ratio cycles/ms */\r
 502     millisecs = 1;\r
 503     cycles = mbedtls_timing_hardclock();\r
 504     busy_msleep( millisecs );\r
 505     cycles = mbedtls_timing_hardclock() - cycles;\r
 506     ratio = cycles / millisecs;\r
 507 \r
 508     /* Check that the ratio is mostly constant */\r
 509     for( millisecs = 2; millisecs <= 4; millisecs++ )\r
 510     {\r
 511         cycles = mbedtls_timing_hardclock();\r
 512         busy_msleep( millisecs );\r
 513         cycles = mbedtls_timing_hardclock() - cycles;\r
 514 \r
 515         /* Allow variation up to 20% */\r
 516         if( cycles / millisecs < ratio - ratio / 5 ||\r
 517             cycles / millisecs > ratio + ratio / 5 )\r
 518         {\r
 519             hardfail++;\r
 520             goto hard_test;\r
 521         }\r
 522     }\r
 523 \r
 524     if( verbose != 0 )\r
 525         mbedtls_printf( "passed\n" );\r
 526 \r
 527 hard_test_done:\r
 528 \r
 529     if( verbose != 0 )\r
 530         mbedtls_printf( "\n" );\r
 531 \r
 532     return( 0 );\r
 533 }\r
 534 \r
 535 #endif /* MBEDTLS_SELF_TEST */\r
 536 \r
 537 #endif /* MBEDTLS_TIMING_C */\r