static size_t GetHighResClock(void *buf, size_t maxbytes) { bigtime_t bigtime; /* Actually a int64 */ bigtime = real_time_clock_usecs(); return CopyLowBits(buf, maxbytes, &bigtime, sizeof(bigtime)); }
size_t RNG_GetNoise(void *buf, size_t maxbytes) { struct timeval tv; int n = 0; int c; n = GetHighResClock(buf, maxbytes); maxbytes -= n; (void)gettimeofday(&tv, 0); c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_usec, sizeof(tv.tv_usec)); n += c; maxbytes -= c; c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_sec, sizeof(tv.tv_sec)); n += c; return n; }
/* * Use the "get the cycle counter" instruction on the alpha. * The low 32 bits completely turn over in less than a minute. * The high 32 bits are some non-counter gunk that changes sometimes. */ static size_t GetHighResClock(void *buf, size_t maxbytes) { unsigned long t; t = asm("rpcc %v0"); return CopyLowBits(buf, maxbytes, &t, sizeof(t)); }
static size_t GetHighResClock(void *buf, size_t maxbytes) { PRUint64 t; t = _Asm_mov_from_ar(_AREG44); return CopyLowBits(buf, maxbytes, &t, sizeof(t)); }
static size_t GetHighResClock(void *buf, size_t maxbytes) { int ticks; struct tms buffer; ticks=times(&buffer); return CopyLowBits(buf, maxbytes, &ticks, sizeof(ticks)); }
static size_t GetHighResClock(void *buf, size_t maxbytes) { extern int ret_cr16(); int cr16val; cr16val = ret_cr16(); return CopyLowBits(buf, maxbytes, &cr16val, sizeof(cr16val)); }
static size_t GetHighResClock(void *buf, size_t maxbytes) { hrtime_t t; t = gethrtime(); if (t) { return CopyLowBits(buf, maxbytes, &t, sizeof(t)); } return 0; }
size_t RNG_GetNoise(void *buf, size_t maxbytes) { struct timeval tv; int n = 0; int c; n = GetHighResClock(buf, maxbytes); maxbytes -= n; #if defined(__sun) && (defined(_svr4) || defined(SVR4)) || defined(sony) (void)gettimeofday(&tv); #else (void)gettimeofday(&tv, 0); #endif c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_usec, sizeof(tv.tv_usec)); n += c; maxbytes -= c; c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_sec, sizeof(tv.tv_sec)); n += c; return n; }
static size_t GetHighResClock(void *buf, size_t maxbuf) { unsigned phys_addr, raddr, cycleval; static volatile unsigned *iotimer_addr = NULL; static int tries = 0; static int cntr_size; int mfd; long s0[2]; struct timeval tv; #ifndef SGI_CYCLECNTR_SIZE #define SGI_CYCLECNTR_SIZE 165 /* Size user needs to use to read CC */ #endif if (iotimer_addr == NULL) { if (tries++ > 1) { /* Don't keep trying if it didn't work */ return 0; } /* ** For SGI machines we can use the cycle counter, if it has one, ** to generate some truly random numbers */ phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &cycleval); if (phys_addr) { int pgsz = getpagesize(); int pgoffmask = pgsz - 1; raddr = phys_addr & ~pgoffmask; mfd = open("/dev/mmem", O_RDONLY); if (mfd < 0) { return 0; } iotimer_addr = (unsigned *) mmap(0, pgoffmask, PROT_READ, MAP_PRIVATE, mfd, (int)raddr); if (iotimer_addr == (void*)-1) { close(mfd); iotimer_addr = NULL; return 0; } iotimer_addr = (unsigned*) ((__psint_t)iotimer_addr | (phys_addr & pgoffmask)); /* * The file 'mfd' is purposefully not closed. */ cntr_size = syssgi(SGI_CYCLECNTR_SIZE); if (cntr_size < 0) { struct utsname utsinfo; /* * We must be executing on a 6.0 or earlier system, since the * SGI_CYCLECNTR_SIZE call is not supported. * * The only pre-6.1 platforms with 64-bit counters are * IP19 and IP21 (Challenge, PowerChallenge, Onyx). */ uname(&utsinfo); if (!strncmp(utsinfo.machine, "IP19", 4) || !strncmp(utsinfo.machine, "IP21", 4)) cntr_size = 64; else cntr_size = 32; } cntr_size /= 8; /* Convert from bits to bytes */ } } s0[0] = *iotimer_addr; if (cntr_size > 4) s0[1] = *(iotimer_addr + 1); memcpy(buf, (char *)&s0[0], cntr_size); return CopyLowBits(buf, maxbuf, &s0, cntr_size); }