/* * stress_rdrand() * stress Intel rdrand instruction */ static int stress_rdrand(const args_t *args) { if (rdrand_supported) { double time_start, duration, billion_bits; bool lock = false; time_start = time_now(); do { #if defined(__x86_64__) || defined(__x86_64) RDRAND64x32(); #else RDRAND32x64(); #endif inc_counter(args); } while (keep_stressing()); duration = time_now() - time_start; billion_bits = ((double)get_counter(args) * 64.0 * 32.0) / 1000000000.0; pr_lock(&lock); pr_dbg_lock(&lock, "%s: %.3f billion random bits read " "(instance %" PRIu32")\n", args->name, billion_bits, args->instance); if (duration > 0.0) { pr_dbg_lock(&lock, "%s: %.3f billion random bits per " "second (instance %" PRIu32")\n", args->name, (double)billion_bits / duration, args->instance); } pr_unlock(&lock); } return EXIT_SUCCESS; }
void process_command_connections(int port, int bus, bool verbose) { int i2c_handle, sock, result, con; socklen_t client_address_size; struct sockaddr_storage client_address; char client_ip[INET6_ADDRSTRLEN]; if (verbose) printf("Opening command I2C handle\n"); i2c_handle = open_i2c(bus, 1); if (i2c_handle == -1) { perror("ERROR => Couldn't open i2c bus. The error was:"); exit(1); } sock = create_and_bind_tcp_socket(port); if (sock == -1) { exit(1); } while (1) { if (verbose) printf("Listening for incoming command connections\n"); result = listen(sock, 20); if (result != 0) { fprintf(stderr, "ERROR: Error attempting to listen on socket"); continue; } client_address_size = sizeof(client_address); con = accept(sock, (struct sockaddr *) &client_address, &client_address_size); if (con < 0) { fprintf(stderr, "ERROR: Error attempting to accept connection"); continue; } get_address_ip((struct sockaddr*)&client_address, client_ip, sizeof(client_ip)); printf("Command connection accepted from %s\n", client_ip); process_command_connection(con, i2c_handle, verbose); printf("Closing command connection\n"); close(con); printf("Removing all poll records\n"); pr_lock("pcc"); pr_clear_and_free_all(); pr_unlock(); } printf("Closing command socket\n"); close(sock); printf("Closing command I2C handle\n"); close(i2c_handle); }
/* PR_SETCACHE -- Set the size of the process cache. This is automatically * called whenever the value of the parameter cl.szprcache is set. Changing * the cache size on an active cache causes the cache to be flushed and all * locked processes to be reconnected. */ void pr_setcache (int new_szprcache) { struct process *pr; char pname[MAXSUBPROC][SZ_PATHNAME+1]; int nprocs=0, pid, i; FILE *fdummy; if (pr_head == NULL) pr_initcache(); else { /* Get the names of any processes currently locked into the cache, * then dump the cache. */ for (pr=pr_head; pr != NULL; pr=pr->pr_dn) if (pr->pr_pid != NULL && (pr->pr_flags & P_LOCKED)) strcpy (pname[nprocs++], pr->pr_name); pr_dumpcache (0, 1); } /* Set the new value of sz_prcache. */ sz_prcache = new_szprcache; if (sz_prcache < 2) sz_prcache = 2; else if (sz_prcache > MAXSUBPROC) sz_prcache = MAXSUBPROC; /* Relink the empty cache for sz_prcache cache slots. */ pr_initcache(); /* Attempt to recache the formerly locked processes. There must be * at least one empty slot left for new subprocesses. */ if (nprocs+1 > sz_prcache) nprocs = sz_prcache-1; for (i=0; i < nprocs; i++) { pid = pr_connect (findexe(NULL,pname[i]), "\n", &fdummy, &fdummy, stdin, stdout, stderr, 0,0,0, 0); pr_disconnect (pid); pr_lock (pid); } }