GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Stratum servers can now be named. 

The names will be used throughout the display in the program, when not set "Pool 1" will
simply be used instead. The names are not exposed through API yet, it's on my TODO list.

Use "poolname" like this:

	{
		"poolname" : "Example pool",
		"url" : "stratum+tcp://example.com:8080",
		"user" : "y",
		"pass" : "x"
	},

Conflicts:
	sgminer.c
	util.c
nfactor-troky
Martin Danielsen 11 years ago committed by Noel Maersk
parent
2f0fac6c66
commit
d7e469bd76
3 changed files with 96 additions and 91 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      miner.h
  2. 159
      sgminer.c
  3. 27
      util.c

1
miner.h
Unescape View File

@ -1151,6 +1151,7 @@ struct stratum_work {
struct pool { struct pool {
int pool_no; int pool_no;
char *poolname;
int prio; int prio;
int accepted, rejected; int accepted, rejected;
int seq_rejects; int seq_rejects;

159
sgminer.c
Unescape View File

@ -210,7 +210,7 @@ static struct pool *currentpool = NULL;
int total_pools, enabled_pools; int total_pools, enabled_pools;
enum pool_strategy pool_strategy = POOL_FAILOVER; enum pool_strategy pool_strategy = POOL_FAILOVER;
int opt_rotate_period; int opt_rotate_period;
static int total_urls, total_users, total_passes, total_userpasses; static int total_urls, total_users, total_passes, total_userpasses, total_poolnames;
static static
#ifndef HAVE_CURSES #ifndef HAVE_CURSES
@ -507,6 +507,9 @@ struct pool *add_pool(void)
if (!pool) if (!pool)
quit(1, "Failed to malloc pool in add_pool"); quit(1, "Failed to malloc pool in add_pool");
pool->pool_no = pool->prio = total_pools; pool->pool_no = pool->prio = total_pools;
char buf[32];
sprintf(buf, "Pool %d", pool->pool_no);
pool->poolname = strdup(buf);
pools = realloc(pools, sizeof(struct pool *) * (total_pools + 2)); pools = realloc(pools, sizeof(struct pool *) * (total_pools + 2));
pools[total_pools++] = pool; pools[total_pools++] = pool;
mutex_init(&pool->pool_lock); mutex_init(&pool->pool_lock);
@ -724,6 +727,20 @@ static char *set_url(char *arg)
return NULL; return NULL;
} }
static char *set_poolname(char *arg)
{
struct pool *pool;
total_poolnames++;
if (total_poolnames > total_pools)
add_pool();
pool = pools[total_poolnames - 1];
opt_set_charp(arg, &pool->poolname);
return NULL;
}
static char *set_quota(char *arg) static char *set_quota(char *arg)
{ {
char *semicolon = strchr(arg, ';'), *url; char *semicolon = strchr(arg, ';'), *url;
@ -747,7 +764,7 @@ static char *set_quota(char *arg)
pool = add_url(); pool = add_url();
setup_url(pool, url); setup_url(pool, url);
pool->quota = quota; pool->quota = quota;
applog(LOG_INFO, "Setting pool %d to quota %d", pool->pool_no, pool->quota); applog(LOG_INFO, "Setting %s to quota %d", pool->poolname, pool->quota);
adjust_quota_gcd(); adjust_quota_gcd();
return NULL; return NULL;
@ -1115,6 +1132,9 @@ static struct opt_table opt_config_table[] = {
OPT_WITHOUT_ARG("--per-device-stats", OPT_WITHOUT_ARG("--per-device-stats",
opt_set_bool, &want_per_device_stats, opt_set_bool, &want_per_device_stats,
"Force verbose mode and output per-device statistics"), "Force verbose mode and output per-device statistics"),
OPT_WITH_ARG("--poolname",
set_poolname, NULL, NULL,
"Name of pool."),
OPT_WITHOUT_ARG("--protocol-dump|-P", OPT_WITHOUT_ARG("--protocol-dump|-P",
opt_set_bool, &opt_protocol, opt_set_bool, &opt_protocol,
"Verbose dump of protocol-level activities"), "Verbose dump of protocol-level activities"),
@ -1581,20 +1601,17 @@ static void update_gbt(struct pool *pool)
total_getworks++; total_getworks++;
pool->getwork_requested++; pool->getwork_requested++;
if (rc) { if (rc) {
applog(LOG_DEBUG, "Successfully retrieved and updated GBT from pool %u %s", applog(LOG_DEBUG, "Successfully retrieved and updated GBT from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
cgtime(&pool->tv_idle); cgtime(&pool->tv_idle);
if (pool == current_pool()) if (pool == current_pool())
opt_work_update = true; opt_work_update = true;
} else { } else {
applog(LOG_DEBUG, "Successfully retrieved but FAILED to decipher GBT from pool %u %s", applog(LOG_DEBUG, "Successfully retrieved but FAILED to decipher GBT from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
} }
json_decref(val); json_decref(val);
free_work(work); free_work(work);
} else { } else {
applog(LOG_DEBUG, "FAILED to update GBT from pool %u %s", applog(LOG_DEBUG, "FAILED to update GBT from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
} }
curl_easy_cleanup(curl); curl_easy_cleanup(curl);
} }
@ -2307,10 +2324,10 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
pool->last_share_diff = work->work_difficulty; pool->last_share_diff = work->work_difficulty;
applog(LOG_DEBUG, "PROOF OF WORK RESULT: true (yay!!!)"); applog(LOG_DEBUG, "PROOF OF WORK RESULT: true (yay!!!)");
if (!QUIET) { if (!QUIET) {
if (total_pools > 1) if (total_pools > 1) {
applog(LOG_NOTICE, "Accepted %s %s %d pool %d %s%s", applog(LOG_NOTICE, "Accepted %s %s %d at %s %s%s",
hashshow, cgpu->drv->name, cgpu->device_id, work->pool->pool_no, resubmit ? "(resubmit)" : "", worktime); hashshow, cgpu->drv->name, cgpu->device_id, pool->poolname, resubmit ? "(resubmit)" : "", worktime);
else } else
applog(LOG_NOTICE, "Accepted %s %s %d %s%s", applog(LOG_NOTICE, "Accepted %s %s %d %s%s",
hashshow, cgpu->drv->name, cgpu->device_id, resubmit ? "(resubmit)" : "", worktime); hashshow, cgpu->drv->name, cgpu->device_id, resubmit ? "(resubmit)" : "", worktime);
} }
@ -2326,7 +2343,7 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
* This will only happen with the work returned from a * This will only happen with the work returned from a
* longpoll */ * longpoll */
if (unlikely(pool->enabled == POOL_REJECTING)) { if (unlikely(pool->enabled == POOL_REJECTING)) {
applog(LOG_WARNING, "Rejecting pool %d now accepting shares, re-enabling!", pool->pool_no); applog(LOG_WARNING, "Rejecting %s now accepting shares, re-enabling!", pool->poolname);
enable_pool(pool); enable_pool(pool);
switch_pools(NULL); switch_pools(NULL);
} }
@ -2353,7 +2370,7 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
strcpy(reason, ""); strcpy(reason, "");
if (total_pools > 1) if (total_pools > 1)
snprintf(where, sizeof(where), "pool %d", work->pool->pool_no); snprintf(where, sizeof(where), "%s", work->pool->poolname);
else else
strcpy(where, ""); strcpy(where, "");
@ -2395,8 +2412,8 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
double utility = total_accepted / total_secs * 60; double utility = total_accepted / total_secs * 60;
if (pool->seq_rejects > utility * 3) { if (pool->seq_rejects > utility * 3) {
applog(LOG_WARNING, "Pool %d rejected %d sequential shares, disabling!", applog(LOG_WARNING, "%s rejected %d sequential shares, disabling!",
pool->pool_no, pool->seq_rejects); pool->poolname, pool->seq_rejects);
reject_pool(pool); reject_pool(pool);
if (pool == current_pool()) if (pool == current_pool())
switch_pools(NULL); switch_pools(NULL);
@ -2525,15 +2542,15 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
total_ro++; total_ro++;
pool->remotefail_occasions++; pool->remotefail_occasions++;
if (opt_lowmem) { if (opt_lowmem) {
applog(LOG_WARNING, "Pool %d communication failure, discarding shares", pool->pool_no); applog(LOG_WARNING, "%s communication failure, discarding shares", pool->poolname);
goto out; goto out;
} }
applog(LOG_WARNING, "Pool %d communication failure, caching submissions", pool->pool_no); applog(LOG_WARNING, "%s communication failure, caching submissions", pool->poolname);
} }
cgsleep_ms(5000); cgsleep_ms(5000);
goto out; goto out;
} else if (pool_tclear(pool, &pool->submit_fail)) } else if (pool_tclear(pool, &pool->submit_fail))
applog(LOG_WARNING, "Pool %d communication resumed, submitting work", pool->pool_no); applog(LOG_WARNING, "%s communication resumed, submitting work", pool->poolname);
res = json_object_get(val, "result"); res = json_object_get(val, "result");
err = json_object_get(val, "error"); err = json_object_get(val, "error");
@ -2786,7 +2803,7 @@ static inline struct pool *select_pool(bool lagging)
if (!pool) if (!pool)
pool = cp; pool = cp;
out: out:
applog(LOG_DEBUG, "Selecting pool %d for work", pool->pool_no); applog(LOG_DEBUG, "Selecting %s for work", pool->poolname);
return pool; return pool;
} }
@ -3092,7 +3109,7 @@ retry:
mutex_unlock(&pool->pool_lock); mutex_unlock(&pool->pool_lock);
if (recruited) if (recruited)
applog(LOG_DEBUG, "Recruited curl for pool %d", pool->pool_no); applog(LOG_DEBUG, "Recruited curl for %s", pool->poolname);
return ce; return ce;
} }
@ -3174,12 +3191,12 @@ static void *submit_work_thread(void *userdata)
/* submit solution to bitcoin via JSON-RPC */ /* submit solution to bitcoin via JSON-RPC */
while (!submit_upstream_work(work, ce->curl, resubmit)) { while (!submit_upstream_work(work, ce->curl, resubmit)) {
if (opt_lowmem) { if (opt_lowmem) {
applog(LOG_NOTICE, "Pool %d share being discarded to minimise memory cache", pool->pool_no); applog(LOG_NOTICE, "%s share being discarded to minimise memory cache", pool->poolname);
break; break;
} }
resubmit = true; resubmit = true;
if (stale_work(work, true)) { if (stale_work(work, true)) {
applog(LOG_NOTICE, "Pool %d share became stale while retrying submit, discarding", pool->pool_no); applog(LOG_NOTICE, "%s share became stale while retrying submit, discarding", pool->poolname);
mutex_lock(&stats_lock); mutex_lock(&stats_lock);
total_stale++; total_stale++;
@ -3370,10 +3387,10 @@ static void pool_died(struct pool *pool)
if (!pool_tset(pool, &pool->idle)) { if (!pool_tset(pool, &pool->idle)) {
cgtime(&pool->tv_idle); cgtime(&pool->tv_idle);
if (pool == current_pool()) { if (pool == current_pool()) {
applog(LOG_WARNING, "Pool %d %s not responding!", pool->pool_no, pool->rpc_url); applog(LOG_WARNING, "%s %s not responding!", pool->poolname, pool->rpc_url);
switch_pools(NULL); switch_pools(NULL);
} else } else
applog(LOG_INFO, "Pool %d %s failed to return work", pool->pool_no, pool->rpc_url); applog(LOG_INFO, "%s %s failed to return work", pool->poolname, pool->rpc_url);
} }
} }
@ -3579,7 +3596,7 @@ void switch_pools(struct pool *selected)
pool_tset(pool, &pool->lagging); pool_tset(pool, &pool->lagging);
if (pool != last_pool && pool_strategy != POOL_LOADBALANCE && pool_strategy != POOL_BALANCE) { if (pool != last_pool && pool_strategy != POOL_LOADBALANCE && pool_strategy != POOL_BALANCE) {
applog(LOG_WARNING, "Switching to pool %d %s", pool->pool_no, pool->rpc_url); applog(LOG_WARNING, "Switching to %s", pool->poolname);
if (pool_localgen(pool) || opt_fail_only) if (pool_localgen(pool) || opt_fail_only)
clear_pool_work(last_pool); clear_pool_work(last_pool);
} }
@ -3841,14 +3858,12 @@ static bool test_work_current(struct work *work)
} }
work->work_block = ++work_block; work->work_block = ++work_block;
if (work->longpoll) { if (work->longpoll) {
if (work->stratum) { if (work->stratum) {
applog(LOG_NOTICE, "Stratum from pool %d detected new block", applog(LOG_NOTICE, "Stratum from %s detected new block", pool->poolname);
pool->pool_no);
} else { } else {
applog(LOG_NOTICE, "%sLONGPOLL from pool %d detected new block", applog(LOG_NOTICE, "%sLONGPOLL from %s detected new block",
work->gbt ? "GBT " : "", work->pool->pool_no); work->gbt ? "GBT " : "", work->pool->poolname);
} }
} else if (have_longpoll) } else if (have_longpoll)
applog(LOG_NOTICE, "New block detected on network before longpoll"); applog(LOG_NOTICE, "New block detected on network before longpoll");
@ -3863,12 +3878,12 @@ static bool test_work_current(struct work *work)
* block. */ * block. */
if (memcmp(bedata, current_block, 32)) { if (memcmp(bedata, current_block, 32)) {
/* Doesn't match current block. It's stale */ /* Doesn't match current block. It's stale */
applog(LOG_DEBUG, "Stale data from pool %d", pool->pool_no); applog(LOG_DEBUG, "Stale data from %s", pool->poolname);
ret = false; ret = false;
} else { } else {
/* Work is from new block and pool is up now /* Work is from new block and pool is up now
* current. */ * current. */
applog(LOG_INFO, "Pool %d now up to date", pool->pool_no); applog(LOG_INFO, "%s now up to date", pool->poolname);
memcpy(pool->prev_block, bedata, 32); memcpy(pool->prev_block, bedata, 32);
} }
} }
@ -3877,17 +3892,15 @@ static bool test_work_current(struct work *work)
* accepting shares from it. To maintain fair work distribution * accepting shares from it. To maintain fair work distribution
* we work on it anyway. */ * we work on it anyway. */
if (memcmp(bedata, current_block, 32)) if (memcmp(bedata, current_block, 32))
applog(LOG_DEBUG, "Pool %d still on old block", pool->pool_no); applog(LOG_DEBUG, "%s still on old block", pool->poolname);
#endif #endif
if (work->longpoll) { if (work->longpoll) {
work->work_block = ++work_block; work->work_block = ++work_block;
if (shared_strategy() || work->pool == current_pool()) { if (shared_strategy() || work->pool == current_pool()) {
if (work->stratum) { if (work->stratum) {
applog(LOG_NOTICE, "Stratum from pool %d requested work restart", applog(LOG_NOTICE, "Stratum from %s requested work restart", pool->poolname);
pool->pool_no);
} else { } else {
applog(LOG_NOTICE, "%sLONGPOLL from pool %d requested work restart", applog(LOG_NOTICE, "%sLONGPOLL from %s requested work restart", work->gbt ? "GBT " : "", work->pool->poolname);
work->gbt ? "GBT " : "", work->pool->pool_no);
} }
restart_threads(); restart_threads();
} }
@ -3929,7 +3942,7 @@ static bool hash_push(struct work *work)
static void stage_work(struct work *work) static void stage_work(struct work *work)
{ {
applog(LOG_DEBUG, "Pushing work from pool %d to hash queue", work->pool->pool_no); applog(LOG_DEBUG, "Pushing work from %s to hash queue", work->pool->poolname);
work->work_block = work_block; work->work_block = work_block;
test_work_current(work); test_work_current(work);
work->pool->works++; work->pool->works++;
@ -4956,7 +4969,7 @@ static bool parse_stratum_response(struct pool *pool, char *s)
cg_runlock(&pool->data_lock); cg_runlock(&pool->data_lock);
if (json_is_true(res_val)) { if (json_is_true(res_val)) {
applog(LOG_NOTICE, "Accepted untracked stratum share from pool %d", pool->pool_no); applog(LOG_NOTICE, "Accepted untracked stratum share from %s", pool->poolname);
/* We don't know what device this came from so we can't /* We don't know what device this came from so we can't
* attribute the work to the relevant cgpu */ * attribute the work to the relevant cgpu */
@ -4967,7 +4980,7 @@ static bool parse_stratum_response(struct pool *pool, char *s)
pool->diff_accepted += pool_diff; pool->diff_accepted += pool_diff;
mutex_unlock(&stats_lock); mutex_unlock(&stats_lock);
} else { } else {
applog(LOG_NOTICE, "Rejected untracked stratum share from pool %d", pool->pool_no); applog(LOG_NOTICE, "Rejected untracked stratum share from %s", pool->poolname);
mutex_lock(&stats_lock); mutex_lock(&stats_lock);
total_rejected++; total_rejected++;
@ -5010,7 +5023,7 @@ void clear_stratum_shares(struct pool *pool)
mutex_unlock(&sshare_lock); mutex_unlock(&sshare_lock);
if (cleared) { if (cleared) {
applog(LOG_WARNING, "Lost %d shares due to stratum disconnect on pool %d", cleared, pool->pool_no); applog(LOG_WARNING, "Lost %d shares due to stratum disconnect on %s", cleared, pool->poolname);
pool->stale_shares += cleared; pool->stale_shares += cleared;
total_stale += cleared; total_stale += cleared;
pool->diff_stale += diff_cleared; pool->diff_stale += diff_cleared;
@ -5097,7 +5110,7 @@ static void stratum_resumed(struct pool *pool)
if (!pool->stratum_notify) if (!pool->stratum_notify)
return; return;
if (pool_tclear(pool, &pool->idle)) { if (pool_tclear(pool, &pool->idle)) {
applog(LOG_INFO, "Stratum connection to pool %d resumed", pool->pool_no); applog(LOG_INFO, "Stratum connection to %s resumed", pool->poolname);
pool_resus(pool); pool_resus(pool);
} }
} }
@ -5165,12 +5178,12 @@ static void *stratum_rthread(void *userdata)
* assume the connection has been dropped and treat this pool * assume the connection has been dropped and treat this pool
* as dead */ * as dead */
if (!sock_full(pool) && (sel_ret = select(pool->sock + 1, &rd, NULL, NULL, &timeout)) < 1) { if (!sock_full(pool) && (sel_ret = select(pool->sock + 1, &rd, NULL, NULL, &timeout)) < 1) {
applog(LOG_DEBUG, "Stratum select failed on pool %d with value %d", pool->pool_no, sel_ret); applog(LOG_DEBUG, "Stratum select failed on %s with value %d", pool->poolname, sel_ret);
s = NULL; s = NULL;
} else } else
s = recv_line(pool); s = recv_line(pool);
if (!s) { if (!s) {
applog(LOG_NOTICE, "Stratum connection to pool %d interrupted", pool->pool_no); applog(LOG_NOTICE, "Stratum connection to %s interrupted", pool->poolname);
pool->getfail_occasions++; pool->getfail_occasions++;
total_go++; total_go++;
@ -5256,8 +5269,7 @@ static void *stratum_sthread(void *userdata)
quit(1, "Stratum q returned empty work"); quit(1, "Stratum q returned empty work");
if (unlikely(work->nonce2_len > 8)) { if (unlikely(work->nonce2_len > 8)) {
applog(LOG_ERR, "Pool %d asking for inappropriately long nonce2 length %d", applog(LOG_ERR, "%s asking for inappropriately long nonce2 length %d", pool->poolname, (int)work->nonce2_len);
pool->pool_no, (int)work->nonce2_len);
applog(LOG_ERR, "Not attempting to submit shares"); applog(LOG_ERR, "Not attempting to submit shares");
free_work(work); free_work(work);
continue; continue;
@ -5287,8 +5299,7 @@ static void *stratum_sthread(void *userdata)
"{\"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\": %d, \"method\": \"mining.submit\"}", "{\"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\": %d, \"method\": \"mining.submit\"}",
pool->rpc_user, work->job_id, nonce2hex, work->ntime, noncehex, sshare->id); pool->rpc_user, work->job_id, nonce2hex, work->ntime, noncehex, sshare->id);
applog(LOG_INFO, "Submitting share %08lx to pool %d", applog(LOG_INFO, "Submitting share %08lx to %s", (long unsigned int)htole32(hash32[6]), pool->poolname);
(long unsigned int)htole32(hash32[6]), pool->pool_no);
/* Try resubmitting for up to 2 minutes if we fail to submit /* Try resubmitting for up to 2 minutes if we fail to submit
* once and the stratum pool nonce1 still matches suggesting * once and the stratum pool nonce1 still matches suggesting
@ -5298,7 +5309,7 @@ static void *stratum_sthread(void *userdata)
if (likely(stratum_send(pool, s, strlen(s)))) { if (likely(stratum_send(pool, s, strlen(s)))) {
if (pool_tclear(pool, &pool->submit_fail)) if (pool_tclear(pool, &pool->submit_fail))
applog(LOG_WARNING, "Pool %d communication resumed, submitting work", pool->pool_no); applog(LOG_WARNING, "%s communication resumed, submitting work", pool->poolname);
mutex_lock(&sshare_lock); mutex_lock(&sshare_lock);
HASH_ADD_INT(stratum_shares, id, sshare); HASH_ADD_INT(stratum_shares, id, sshare);
@ -5310,7 +5321,7 @@ static void *stratum_sthread(void *userdata)
break; break;
} }
if (!pool_tset(pool, &pool->submit_fail) && cnx_needed(pool)) { if (!pool_tset(pool, &pool->submit_fail) && cnx_needed(pool)) {
applog(LOG_WARNING, "Pool %d stratum share submission failure", pool->pool_no); applog(LOG_WARNING, "%s stratum share submission failure", pool->poolname);
total_ro++; total_ro++;
pool->remotefail_occasions++; pool->remotefail_occasions++;
} }
@ -5362,7 +5373,7 @@ static void *longpoll_thread(void *userdata);
static bool stratum_works(struct pool *pool) static bool stratum_works(struct pool *pool)
{ {
applog(LOG_INFO, "Testing pool %d stratum %s", pool->pool_no, pool->stratum_url); applog(LOG_INFO, "Testing %s stratum %s", pool->poolname, pool->stratum_url);
if (!extract_sockaddr(pool->stratum_url, &pool->sockaddr_url, &pool->stratum_port)) if (!extract_sockaddr(pool->stratum_url, &pool->sockaddr_url, &pool->stratum_port))
return false; return false;
@ -5381,9 +5392,9 @@ static bool pool_active(struct pool *pool, bool pinging)
int uninitialised_var(rolltime); int uninitialised_var(rolltime);
if (pool->has_gbt) if (pool->has_gbt)
applog(LOG_DEBUG, "Retrieving block template from pool %s", pool->rpc_url); applog(LOG_DEBUG, "Retrieving block template from %s", pool->poolname);
else else
applog(LOG_INFO, "Testing pool %s", pool->rpc_url); applog(LOG_INFO, "Testing %s", pool->poolname);
/* This is the central point we activate stratum when we can */ /* This is the central point we activate stratum when we can */
retry_stratum: retry_stratum:
@ -5467,7 +5478,7 @@ retry_stratum:
/* Detect if a http getwork pool has an X-Stratum header at startup, /* Detect if a http getwork pool has an X-Stratum header at startup,
* and if so, switch to that in preference to getwork if it works */ * and if so, switch to that in preference to getwork if it works */
if (pool->stratum_url && !opt_fix_protocol && stratum_works(pool)) { if (pool->stratum_url && !opt_fix_protocol && stratum_works(pool)) {
applog(LOG_NOTICE, "Switching pool %d %s to %s", pool->pool_no, pool->rpc_url, pool->stratum_url); applog(LOG_NOTICE, "Switching %s %s to %s", pool->poolname, pool->rpc_url, pool->stratum_url);
if (!pool->rpc_url) if (!pool->rpc_url)
pool->rpc_url = strdup(pool->stratum_url); pool->rpc_url = strdup(pool->stratum_url);
pool->has_stratum = true; pool->has_stratum = true;
@ -5482,8 +5493,7 @@ retry_stratum:
rc = work_decode(pool, work, val); rc = work_decode(pool, work, val);
if (rc) { if (rc) {
applog(LOG_DEBUG, "Successfully retrieved and deciphered work from pool %u %s", applog(LOG_DEBUG, "Successfully retrieved and deciphered work from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
work->pool = pool; work->pool = pool;
work->rolltime = rolltime; work->rolltime = rolltime;
copy_time(&work->tv_getwork, &tv_getwork); copy_time(&work->tv_getwork, &tv_getwork);
@ -5498,8 +5508,7 @@ retry_stratum:
ret = true; ret = true;
cgtime(&pool->tv_idle); cgtime(&pool->tv_idle);
} else { } else {
applog(LOG_DEBUG, "Successfully retrieved but FAILED to decipher work from pool %u %s", applog(LOG_DEBUG, "Successfully retrieved but FAILED to decipher work from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
free_work(work); free_work(work);
} }
json_decref(val); json_decref(val);
@ -5547,10 +5556,9 @@ retry_stratum:
pool->has_stratum = true; pool->has_stratum = true;
goto retry_stratum; goto retry_stratum;
} }
applog(LOG_DEBUG, "FAILED to retrieve work from pool %u %s", applog(LOG_DEBUG, "FAILED to retrieve work from %s", pool->poolname);
pool->pool_no, pool->rpc_url);
if (!pinging) if (!pinging)
applog(LOG_WARNING, "Pool %u slow/down or URL or credentials invalid", pool->pool_no); applog(LOG_WARNING, "%s slow/down or URL or credentials invalid", pool->poolname);
} }
out: out:
curl_easy_cleanup(curl); curl_easy_cleanup(curl);
@ -5560,9 +5568,9 @@ out:
static void pool_resus(struct pool *pool) static void pool_resus(struct pool *pool)
{ {
if (pool_strategy == POOL_FAILOVER && pool->prio < cp_prio()) if (pool_strategy == POOL_FAILOVER && pool->prio < cp_prio())
applog(LOG_WARNING, "Pool %d %s alive, testing stability", pool->pool_no, pool->rpc_url); applog(LOG_WARNING, "%s alive, testing stability", pool->poolname);
else else
applog(LOG_INFO, "Pool %d %s alive", pool->pool_no, pool->rpc_url); applog(LOG_INFO, "%s alive", pool->poolname);
} }
static struct work *hash_pop(void) static struct work *hash_pop(void)
@ -5791,11 +5799,11 @@ static void submit_work_async(struct work *work)
if (stale_work(work, true)) { if (stale_work(work, true)) {
if (opt_submit_stale) if (opt_submit_stale)
applog(LOG_NOTICE, "Pool %d stale share detected, submitting as user requested", pool->pool_no); applog(LOG_NOTICE, "%s stale share detected, submitting as user requested", pool->poolname);
else if (pool->submit_old) else if (pool->submit_old)
applog(LOG_NOTICE, "Pool %d stale share detected, submitting as pool requested", pool->pool_no); applog(LOG_NOTICE, "%s stale share detected, submitting as pool requested", pool->poolname);
else { else {
applog(LOG_NOTICE, "Pool %d stale share detected, discarding", pool->pool_no); applog(LOG_NOTICE, "%s stale share detected, discarding", pool->poolname);
sharelog("discard", work); sharelog("discard", work);
mutex_lock(&stats_lock); mutex_lock(&stats_lock);
@ -5812,7 +5820,7 @@ static void submit_work_async(struct work *work)
} }
if (work->stratum) { if (work->stratum) {
applog(LOG_DEBUG, "Pushing pool %d work to stratum queue", pool->pool_no); applog(LOG_DEBUG, "Pushing %s work to stratum queue", pool->poolname);
if (unlikely(!tq_push(pool->stratum_q, work))) { if (unlikely(!tq_push(pool->stratum_q, work))) {
applog(LOG_DEBUG, "Discarding work from removed pool"); applog(LOG_DEBUG, "Discarding work from removed pool");
free_work(work); free_work(work);
@ -5885,7 +5893,7 @@ static void update_work_stats(struct thr_info *thr, struct work *work)
work->pool->solved++; work->pool->solved++;
found_blocks++; found_blocks++;
work->mandatory = true; work->mandatory = true;
applog(LOG_NOTICE, "Found block for pool %d!", work->pool->pool_no); applog(LOG_NOTICE, "Found block for %s!", work->pool->poolname);
} }
mutex_lock(&stats_lock); mutex_lock(&stats_lock);
@ -6709,7 +6717,7 @@ static void reap_curl(struct pool *pool)
mutex_unlock(&pool->pool_lock); mutex_unlock(&pool->pool_lock);
if (reaped) if (reaped)
applog(LOG_DEBUG, "Reaped %d curl%s from pool %d", reaped, reaped > 1 ? "s" : "", pool->pool_no); applog(LOG_DEBUG, "Reaped %d curl%s from %s", reaped, reaped > 1 ? "s" : "", pool->poolname);
} }
static void *watchpool_thread(void __maybe_unused *userdata) static void *watchpool_thread(void __maybe_unused *userdata)
@ -6767,8 +6775,7 @@ static void *watchpool_thread(void __maybe_unused *userdata)
* intermittently failing pools from being used. */ * intermittently failing pools from being used. */
if (!pool->idle && pool_strategy == POOL_FAILOVER && pool->prio < cp_prio() && if (!pool->idle && pool_strategy == POOL_FAILOVER && pool->prio < cp_prio() &&
now.tv_sec - pool->tv_idle.tv_sec > 60) { now.tv_sec - pool->tv_idle.tv_sec > 60) {
applog(LOG_WARNING, "Pool %d %s stable for 1 minute", applog(LOG_WARNING, "%s %s stable for 1 minute", pool->poolname, pool->rpc_url);
pool->pool_no, pool->rpc_url);
switch_pools(NULL); switch_pools(NULL);
} }
} }
@ -7130,7 +7137,7 @@ static void *test_pool_thread(void *arg)
cg_wunlock(&control_lock); cg_wunlock(&control_lock);
if (unlikely(first_pool)) if (unlikely(first_pool))
applog(LOG_NOTICE, "Switching to pool %d %s - first alive pool", pool->pool_no, pool->rpc_url); applog(LOG_NOTICE, "Switching to %s - first alive pool", pool->poolname);
pool_resus(pool); pool_resus(pool);
switch_pools(NULL); switch_pools(NULL);
@ -7766,7 +7773,7 @@ int main(int argc, char *argv[])
if (!pool->rpc_userpass) { if (!pool->rpc_userpass) {
if (!pool->rpc_user || !pool->rpc_pass) if (!pool->rpc_user || !pool->rpc_pass)
quit(1, "No login credentials supplied for pool %u %s", i, pool->rpc_url); quit(1, "No login credentials supplied for %s", pool->poolname);
siz = strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2; siz = strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2;
pool->rpc_userpass = malloc(siz); pool->rpc_userpass = malloc(siz);
if (!pool->rpc_userpass) if (!pool->rpc_userpass)
@ -7964,7 +7971,7 @@ begin_bench:
work = make_work(); work = make_work();
if (lagging && !pool_tset(cp, &cp->lagging)) { if (lagging && !pool_tset(cp, &cp->lagging)) {
applog(LOG_WARNING, "Pool %d not providing work fast enough", cp->pool_no); applog(LOG_WARNING, "%s not providing work fast enough", cp->poolname);
cp->getfail_occasions++; cp->getfail_occasions++;
total_go++; total_go++;
} }
@ -8022,7 +8029,7 @@ retry:
ce = pop_curl_entry(pool); ce = pop_curl_entry(pool);
/* obtain new work from bitcoin via JSON-RPC */ /* obtain new work from bitcoin via JSON-RPC */
if (!get_upstream_work(work, ce->curl)) { if (!get_upstream_work(work, ce->curl)) {
applog(LOG_DEBUG, "Pool %d json_rpc_call failed on get work, retrying in 5s", pool->pool_no); applog(LOG_DEBUG, "%s json_rpc_call failed on get work, retrying in 5s", pool->poolname);
/* Make sure the pool just hasn't stopped serving /* Make sure the pool just hasn't stopped serving
* requests but is up as we'll keep hammering it */ * requests but is up as we'll keep hammering it */
if (++pool->seq_getfails > mining_threads + opt_queue) if (++pool->seq_getfails > mining_threads + opt_queue)

27
util.c
Unescape View File

@ -1302,7 +1302,7 @@ bool stratum_send(struct pool *pool, char *s, ssize_t len)
case SEND_OK: case SEND_OK:
break; break;
case SEND_SELECTFAIL: case SEND_SELECTFAIL:
applog(LOG_DEBUG, "Write select failed on pool %d sock", pool->pool_no); applog(LOG_DEBUG, "Write select failed on %s sock", pool->poolname);
suspend_stratum(pool); suspend_stratum(pool);
break; break;
case SEND_SENDFAIL: case SEND_SENDFAIL:
@ -1651,14 +1651,11 @@ static bool parse_diff(struct pool *pool, json_t *val)
int idiff = diff; int idiff = diff;
if ((double)idiff == diff) if ((double)idiff == diff)
applog(LOG_NOTICE, "Pool %d difficulty changed to %d", applog(LOG_NOTICE, "%s difficulty changed to %d", pool->poolname ,idiff);
pool->pool_no, idiff);
else else
applog(LOG_NOTICE, "Pool %d difficulty changed to %f", applog(LOG_NOTICE, "%s difficulty changed to %f", pool->poolname, diff);
pool->pool_no, diff);
} else } else
applog(LOG_DEBUG, "Pool %d difficulty set to %f", pool->pool_no, applog(LOG_DEBUG, "%s difficulty set to %f", pool->poolname, diff);
diff);
return true; return true;
} }
@ -1683,7 +1680,7 @@ static bool parse_reconnect(struct pool *pool, json_t *val)
pool->stratum_url = pool->sockaddr_url; pool->stratum_url = pool->sockaddr_url;
applog(LOG_NOTICE, "Reconnect requested from pool %d to %s", pool->pool_no, address); applog(LOG_NOTICE, "Reconnect requested from %s to %s", pool->poolname, address);
if (!restart_stratum(pool)) if (!restart_stratum(pool))
return false; return false;
@ -1715,7 +1712,7 @@ static bool show_message(struct pool *pool, json_t *val)
msg = (char *)json_string_value(json_array_get(val, 0)); msg = (char *)json_string_value(json_array_get(val, 0));
if (!msg) if (!msg)
return false; return false;
applog(LOG_NOTICE, "Pool %d message: %s", pool->pool_no, msg); applog(LOG_NOTICE, "%s message: %s", pool->poolname, msg);
return true; return true;
} }
@ -1837,14 +1834,14 @@ bool auth_stratum(struct pool *pool)
ss = json_dumps(err_val, JSON_INDENT(3)); ss = json_dumps(err_val, JSON_INDENT(3));
else else
ss = strdup("(unknown reason)"); ss = strdup("(unknown reason)");
applog(LOG_INFO, "pool %d JSON stratum auth failed: %s", pool->pool_no, ss); applog(LOG_INFO, "%s JSON stratum auth failed: %s", pool->poolname, ss);
free(ss); free(ss);
goto out; goto out;
} }
ret = true; ret = true;
applog(LOG_INFO, "Stratum authorisation success for pool %d", pool->pool_no); applog(LOG_INFO, "Stratum authorisation success for %s", pool->poolname);
pool->probed = true; pool->probed = true;
successful_connect = true; successful_connect = true;
@ -2260,7 +2257,7 @@ out:
void suspend_stratum(struct pool *pool) void suspend_stratum(struct pool *pool)
{ {
clear_sockbuf(pool); clear_sockbuf(pool);
applog(LOG_INFO, "Closing socket for stratum pool %d", pool->pool_no); applog(LOG_INFO, "Closing socket for stratum %s", pool->poolname);
mutex_lock(&pool->stratum_lock); mutex_lock(&pool->stratum_lock);
pool->stratum_active = pool->stratum_notify = false; pool->stratum_active = pool->stratum_notify = false;
@ -2369,7 +2366,7 @@ resend:
cg_wunlock(&pool->data_lock); cg_wunlock(&pool->data_lock);
if (sessionid) if (sessionid)
applog(LOG_DEBUG, "Pool %d stratum session id: %s", pool->pool_no, pool->sessionid); applog(LOG_DEBUG, "%s stratum session id: %s", pool->poolname, pool->sessionid);
ret = true; ret = true;
out: out:
@ -2379,8 +2376,8 @@ out:
pool->stratum_active = true; pool->stratum_active = true;
pool->swork.diff = 1; pool->swork.diff = 1;
if (opt_protocol) { if (opt_protocol) {
applog(LOG_DEBUG, "Pool %d confirmed mining.subscribe with extranonce1 %s extran2size %d", applog(LOG_DEBUG, "%s confirmed mining.subscribe with extranonce1 %s extran2size %d",
pool->pool_no, pool->nonce1, pool->n2size); pool->poolname, pool->nonce1, pool->n2size);
} }
} else { } else {
if (recvd && !noresume) { if (recvd && !noresume) {

Write Preview
Loading…
Cancel
Save