/* * Copyright 2010 Jeff Garzik * 2011 Nils Schneider * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. See COPYING for more details. */ #include #include #include #include #include #include #include #ifdef _WIN32 #include #else #include #include #endif #include #include #include #include #include #include "miner.h" #include "ocl.h" #include "streebog.h" #define VERSION "0.1" #define PROGRAM_NAME "gostoclminer" #define DEF_RPC_URL "http://127.0.0.1:9376/" #define DEF_RPC_USERPASS "rpcuser:rpcpass" enum { STAT_SLEEP_INTERVAL = 1, STAT_CTR_INTERVAL = 10000000, FAILURE_INTERVAL = 30, }; int opt_debug = false; int opt_protocol = false; int opt_ndevs = false; int opt_pool = false; static int opt_retries = 10; static bool program_running = true; static const bool opt_time = true; static int opt_n_threads = 1; static char *rpc_url = DEF_RPC_URL; static char *userpass = DEF_RPC_USERPASS; int block = 0; double hashrates[16]; _clState *clStates[16]; struct option_help { const char *name; const char *helptext; }; static struct option_help options_help[] = { { "help", "(-h) Display this help text" }, { "ndevs", "(-n) Display number of detected GPUs" }, { "debug", "(-D) Enable debug output (default: off)" }, { "pool", "(-m) Enable pool mode (default: off)" }, { "protocol-dump", "(-P) Verbose dump of protocol-level activities (default: off)" }, { "retries N", "(-r N) Number of times to retry, if JSON-RPC call fails\n" "\t(default: 10; use -1 for \"never\")" }, { "url URL", "URL for bitcoin JSON-RPC server " "(default: " DEF_RPC_URL ")" }, { "userpass USERNAME:PASSWORD", "Username:Password pair for bitcoin JSON-RPC server " "(default: " DEF_RPC_USERPASS ")" }, }; static struct option options[] = { { "help", 0, NULL, 'h' }, { "debug", 0, NULL, 'D' }, { "protocol-dump", 0, NULL, 'P' }, { "retries", 1, NULL, 'r' }, { "url", 1, NULL, 1001 }, { "userpass", 1, NULL, 1002 }, { "ndevs", 0, NULL, 'n' }, { "pool", 0, NULL, 'm' }, { } }; static bool jobj_binary(const json_t *obj, const char *key, void *buf, size_t buflen) { const char *hexstr; json_t *tmp; tmp = json_object_get(obj, key); if (!tmp) { fprintf(stderr, "JSON key '%s' not found\n", key); return false; } hexstr = json_string_value(tmp); if (!hexstr) { fprintf(stderr, "JSON key '%s' is not a string\n", key); return false; } if (!hex2bin(buf, hexstr, buflen)) return false; return true; } static bool work_decode(const json_t *val, struct work_t *work) { if (!jobj_binary(val, "data", work->data, sizeof(work->data))) { fprintf(stderr, "JSON inval data\n"); goto err_out; } if (!jobj_binary(val, "hash1", work->hash1, sizeof(work->hash1))) { fprintf(stderr, "JSON inval hash1\n"); goto err_out; } if (!jobj_binary(val, "target", work->target, sizeof(work->target))) { fprintf(stderr, "JSON inval target\n"); goto err_out; } memset(work->hash, 0, sizeof(work->hash)); return true; err_out: return false; } static void submit_work(struct work_t *work) { char *hexstr = NULL; json_t *val, *res; char s[345]; printf("PROOF OF WORK FOUND? submitting...\n"); /* build hex string */ hexstr = bin2hex(work->data, sizeof(work->data)); if (!hexstr) goto out; /* build JSON-RPC request */ sprintf(s, "{\"method\": \"getwork\", \"params\": [ \"%s\" ], \"id\":1}\r\n", hexstr); if (opt_debug) fprintf(stderr, "DBG: sending RPC call:\n%s", s); /* issue JSON-RPC request */ val = json_rpc_call(rpc_url, userpass, s); if (!val) { fprintf(stderr, "submit_work json_rpc_call failed\n"); goto out; } res = json_object_get(val, "result"); printf("PROOF OF WORK RESULT: %s\n", json_is_true(res) ? "true (yay!!!)" : "false (booooo)"); if (!json_is_true(res)) printf ("REASON: %s\n", json_string_value(json_object_get(val, "reject-reason"))); json_decref(val); out: free(hexstr); } double time2secs(struct timeval *tv_start) { struct timeval tv_end, diff; double secs; gettimeofday(&tv_end, NULL); timeval_subtract(&diff, &tv_end, tv_start); secs = (double)diff.tv_sec + ((double)diff.tv_usec / 1000000.0); return secs; } static void hashmeter(int thr_id, struct timeval *tv_start, unsigned long hashes_done) { double khashes, secs; secs = time2secs(tv_start); khashes = hashes_done / 1000.0; hashrates[thr_id] = khashes / secs; } static void print_hashmeter(double hashrate, char *rates) { printf("\r \rHashMeter: %.2f Mhash/sec (%s)", hashrate, rates); fflush(stdout); } static bool getwork(struct work_t *work) { static const char *rpc_req = "{\"method\": \"getwork\", \"params\": [], \"id\":0}\r\n"; json_t *val; bool rc; /* obtain new work from bitcoin */ val = json_rpc_call(rpc_url, userpass, rpc_req); if (!val) { fprintf(stderr, "json_rpc_call failed, "); return false; } /* decode result into work state struct */ rc = work_decode(json_object_get(val, "result"), work); if (!rc) { fprintf(stderr, "JSON-decode of work failed, "); return false; } json_decref(val); return true; } void submit_nonce(struct work_t *work, uint32_t nonce) { work->data[64+12+0] = (nonce>>0) & 0xff; work->data[64+12+1] = (nonce>>8) & 0xff; work->data[64+12+2] = (nonce>>16) & 0xff; work->data[64+12+3] = (nonce>>24) & 0xff; submit_work(work); } static void *miner_thread(void *thr_id_int) { int thr_id = (unsigned long) thr_id_int; int failures = 0; uint32_t res[MAXTHREADS]; size_t globalThreads[1]; size_t localThreads[1]; cl_int status; _clState *clState = clStates[thr_id]; status = clSetKernelArg(clState->kernel, 0, sizeof(cl_mem), (void *)&clState->inputBuffer); if(status != CL_SUCCESS) { printf("Error: Setting kernel argument 1.\n"); return false; } status = clSetKernelArg(clState->kernel, 1, sizeof(cl_mem), (void *)&clState->outputBuffer); if(status != CL_SUCCESS) { printf("Error: Setting kernel argument 2.\n"); return false; } struct work_t *work; work = malloc(sizeof(struct work_t)*2); work[0].ready = 0; work[1].ready = 0; int frame = 0; int res_frame = 0; int my_block = block; bool need_work = true; unsigned long hashes_done; hashes_done = 0; unsigned int h0count = 0; struct timeval tv_start0; gettimeofday(&tv_start0, NULL); while (1) { struct timeval tv_start; bool rc; if (need_work || my_block != block) { frame++; frame %= 2; if (opt_debug) fprintf(stderr, "getwork\n"); rc = getwork(&work[frame]); if (!rc) { fprintf(stderr, "getwork failed, "); if ((opt_retries >= 0) && (++failures > opt_retries)) { fprintf(stderr, "terminating thread\n"); return NULL; /* exit thread */ } /* pause, then restart work loop */ fprintf(stderr, "retry after %d seconds\n", FAILURE_INTERVAL); sleep(FAILURE_INTERVAL); continue; } memcpy (work[frame].blk.data, work[frame].data, 80); int k; for (k = 0; k < 19; k++) work[frame].blk.data[k] = swap32 (work[frame].blk.data[k]); memcpy (work[frame].blk.target, work[frame].target, 32); /*work[frame].blk.target[6] = 0xFFFFFFFF; work[frame].blk.target[7] = 0x000000FF;*/ work[frame].blk.data[19] = 0; work[frame].valid = true; work[frame].ready = 0; my_block = block; need_work = false; } gettimeofday(&tv_start, NULL); int threads = 65536; // TODO: globalThreads[0] = threads; localThreads[0] = 256; status = clEnqueueWriteBuffer(clState->commandQueue, clState->inputBuffer, CL_TRUE, 0, sizeof(dev_blk_ctx), (void *)&work[frame].blk, 0, NULL, NULL); if(status != CL_SUCCESS) { printf("Error: clEnqueueWriteBuffer failed.\n"); return 0; } clFinish(clState->commandQueue); status = clEnqueueNDRangeKernel(clState->commandQueue, clState->kernel, 1, NULL, globalThreads, localThreads, 0, NULL, NULL); if(status != CL_SUCCESS) { printf("Error: Enqueueing kernel onto command queue. (clEnqueueNDRangeKernel)\n"); return 0; } clFlush(clState->commandQueue); hashes_done = 1024 * threads; if (work[res_frame].ready) { int j; for(j = 0; j < work[res_frame].ready; j++) { if(res[j]) { uint32_t hash[8]; work[frame].blk.data[19] = res[j]; gostd_hash (hash, work[frame].blk.data); work[frame].blk.data[19] = 0; int k; for (k = 0; k < 8; k++) printf ("%08x ", hash[k]); printf ("\n"); if (swap32 (hash[0]) <= work[frame].blk.target[7]) { uint32_t *target1 = (uint32_t *)(work[res_frame].target + 24); uint32_t *target2 = (uint32_t *)(work[res_frame].target + 28); printf("Found solution for %08x %08x: %08x\n", *target1, *target2, res[j]); submit_nonce(&work[res_frame], swap32 (res[j])); block++; h0count++; need_work = true; break; } else printf ("result for %08x does not validate on CPU!", res[j]); } } work[res_frame].ready = false; } if (h0count != 0) { double secs; secs = time2secs(&tv_start0); hashrates[thr_id] = h0count * pow (2, 256) / (secs * 1e6 * (pow (2, 224) - 1.0)); } status = clEnqueueReadBuffer(clState->commandQueue, clState->outputBuffer, CL_TRUE, 0, sizeof(uint32_t) * threads, res, 0, NULL, NULL); if(status != CL_SUCCESS) { printf("Error: clEnqueueReadBuffer failed. (clEnqueueReadBuffer)\n"); return 0; } res_frame = frame; work[res_frame].ready = threads; work[res_frame].res_nonce = work[res_frame].blk.data[19]; work[frame].blk.data[19] += threads; if (work[frame].blk.data[19] > 4000000 - threads) need_work = true; failures = 0; } return NULL; } static void show_usage(void) { int i; printf("gostoclminer version %s\n\n", VERSION); printf("Usage:\tgostoclminer [options]\n\nSupported options:\n"); for (i = 0; i < ARRAY_SIZE(options_help); i++) { struct option_help *h; h = &options_help[i]; printf("--%s\n%s\n\n", h->name, h->helptext); } exit(1); } static void parse_arg (int key, char *arg) { int v, i; switch(key) { case 'm': opt_pool = true; break; case 'n': opt_ndevs = true; break; case 'D': opt_debug = true; break; case 'P': opt_protocol = true; break; case 'r': v = atoi(arg); if (v < -1 || v > 9999) /* sanity check */ show_usage(); opt_retries = v; break; case 1001: /* --url */ if (strncmp(arg, "http://", 7) && strncmp(arg, "https://", 8)) show_usage(); rpc_url = arg; break; case 1002: /* --userpass */ if (!strchr(arg, ':')) show_usage(); userpass = arg; break; default: show_usage(); } } static void parse_cmdline(int argc, char *argv[]) { int key; while (1) { key = getopt_long(argc, argv, "DPh?nm", options, NULL); if (key < 0) break; parse_arg(key, optarg); } } int main (int argc, char *argv[]) { int i, nDevs; /* parse command line */ parse_cmdline(argc, argv); nDevs = clDevicesNum(); if (opt_ndevs) { printf("%i\n", nDevs); return nDevs; } char name[32]; memset(hashrates, 0, sizeof(hashrates)); /* start mining threads */ for (i = 0; i < nDevs; i++) { pthread_t t; printf("Init GPU %i\n", i); clStates[i] = initCl(i, name, sizeof(name)); printf("initCl() finished. Found %s\n", name); if (pthread_create(&t, NULL, miner_thread, (void *)(unsigned long) i)) { fprintf(stderr, "thread %d create failed\n", i); return 1; } sleep(1); /* don't pound RPC server all at once */ } fprintf(stderr, "%d miner threads started\n", i); /* main loop */ struct timeval tv; fd_set readfds; int ret; while (program_running) { FD_ZERO(&readfds); FD_SET(0, &readfds); tv.tv_sec = STAT_SLEEP_INTERVAL; tv.tv_usec = 0; ret = select(1, &readfds, NULL, NULL, &tv); if (ret) { if (FD_ISSET(0, &readfds)) { getchar(); printf("Forcing getwork\n"); block++; } } double hashrate = 0; char rates[128]; char buffer[16]; rates[0] = 0; for(i = 0; i < nDevs; i++) { hashrate += hashrates[i]; sprintf(buffer, "%.02f", hashrates[i]); strcat(rates, buffer); if (i != nDevs-1) strcat(rates, " "); } print_hashmeter(hashrate, rates); } return 0; }