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

Merge pull request #474 from kanoi/master 

cgsem - increase information on failure
nfactor-troky
Con Kolivas 11 years ago
parent
fb94dfa098 eca6ace2d5
commit
c48e28a8d0
4 changed files with 80 additions and 44 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. 22
      logging.h
  2. 36
      miner.h
  3. 53
      util.c
  4. 13
      util.h

22
logging.h
Unescape View File

@ -30,6 +30,8 @@ extern int opt_log_level;
extern void _applog(int prio, const char *str); extern void _applog(int prio, const char *str);
#define IN_FMT_FFL " in %s %s():%d"
#define applog(prio, fmt, ...) do { \ #define applog(prio, fmt, ...) do { \
if (opt_debug || prio != LOG_DEBUG) { \ if (opt_debug || prio != LOG_DEBUG) { \
if (use_syslog || opt_log_output || prio <= opt_log_level) { \ if (use_syslog || opt_log_output || prio <= opt_log_level) { \
@ -49,6 +51,26 @@ extern void _applog(int prio, const char *str);
_quit(status); \ _quit(status); \
} while (0) } while (0)
#define quithere(status, fmt, ...) do { \
if (fmt) { \
char tmp42[LOGBUFSIZ]; \
snprintf(tmp42, sizeof(tmp42), fmt IN_FMT_FFL, \
##__VA_ARGS__, __FILE__, __func__, __LINE__); \
_applog(LOG_ERR, tmp42); \
} \
_quit(status); \
} while (0)
#define quitfrom(status, _file, _func, _line, fmt, ...) do { \
if (fmt) { \
char tmp42[LOGBUFSIZ]; \
snprintf(tmp42, sizeof(tmp42), fmt IN_FMT_FFL, \
##__VA_ARGS__, _file, _func, _line); \
_applog(LOG_ERR, tmp42); \
} \
_quit(status); \
} while (0)
#ifdef HAVE_CURSES #ifdef HAVE_CURSES
#define wlog(fmt, ...) do { \ #define wlog(fmt, ...) do { \

36
miner.h
Unescape View File

@ -715,16 +715,24 @@ endian_flip128(void __maybe_unused *dest_p, const void __maybe_unused *src_p)
extern void _quit(int status); extern void _quit(int status);
static inline void mutex_lock(pthread_mutex_t *lock) #define mutex_lock(_lock) _mutex_lock(_lock, __FILE__, __func__, __LINE__)
#define mutex_unlock_noyield(_lock) _mutex_unlock_noyield(_lock, __FILE__, __func__, __LINE__)
#define wr_lock(_lock) _wr_lock(_lock, __FILE__, __func__, __LINE__)
#define rd_lock(_lock) _rd_lock(_lock, __FILE__, __func__, __LINE__)
#define rw_unlock(_lock) _rw_unlock(_lock, __FILE__, __func__, __LINE__)
#define mutex_init(_lock) _mutex_init(_lock, __FILE__, __func__, __LINE__)
#define rwlock_init(_lock) _rwlock_init(_lock, __FILE__, __func__, __LINE__)
static inline void _mutex_lock(pthread_mutex_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_mutex_lock(lock))) if (unlikely(pthread_mutex_lock(lock)))
quit(1, "WTF MUTEX ERROR ON LOCK!"); quitfrom(1, file, func, line, "WTF MUTEX ERROR ON LOCK! errno=%d", errno);
} }
static inline void mutex_unlock_noyield(pthread_mutex_t *lock) static inline void _mutex_unlock_noyield(pthread_mutex_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_mutex_unlock(lock))) if (unlikely(pthread_mutex_unlock(lock)))
quit(1, "WTF MUTEX ERROR ON UNLOCK!"); quitfrom(1, file, func, line, "WTF MUTEX ERROR ON UNLOCK! errno=%d", errno);
} }
static inline void mutex_unlock(pthread_mutex_t *lock) static inline void mutex_unlock(pthread_mutex_t *lock)
@ -738,22 +746,22 @@ static inline int mutex_trylock(pthread_mutex_t *lock)
return pthread_mutex_trylock(lock); return pthread_mutex_trylock(lock);
} }
static inline void wr_lock(pthread_rwlock_t *lock) static inline void _wr_lock(pthread_rwlock_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_rwlock_wrlock(lock))) if (unlikely(pthread_rwlock_wrlock(lock)))
quit(1, "WTF WRLOCK ERROR ON LOCK!"); quitfrom(1, file, func, line, "WTF WRLOCK ERROR ON LOCK! errno=%d", errno);
} }
static inline void rd_lock(pthread_rwlock_t *lock) static inline void _rd_lock(pthread_rwlock_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_rwlock_rdlock(lock))) if (unlikely(pthread_rwlock_rdlock(lock)))
quit(1, "WTF RDLOCK ERROR ON LOCK!"); quitfrom(1, file, func, line, "WTF RDLOCK ERROR ON LOCK! errno=%d", errno);
} }
static inline void rw_unlock(pthread_rwlock_t *lock) static inline void _rw_unlock(pthread_rwlock_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_rwlock_unlock(lock))) if (unlikely(pthread_rwlock_unlock(lock)))
quit(1, "WTF RWLOCK ERROR ON UNLOCK!"); quitfrom(1, file, func, line, "WTF RWLOCK ERROR ON UNLOCK! errno=%d", errno);
} }
static inline void rd_unlock_noyield(pthread_rwlock_t *lock) static inline void rd_unlock_noyield(pthread_rwlock_t *lock)
@ -778,16 +786,16 @@ static inline void wr_unlock(pthread_rwlock_t *lock)
sched_yield(); sched_yield();
} }
static inline void mutex_init(pthread_mutex_t *lock) static inline void _mutex_init(pthread_mutex_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_mutex_init(lock, NULL))) if (unlikely(pthread_mutex_init(lock, NULL)))
quit(1, "Failed to pthread_mutex_init"); quitfrom(1, file, func, line, "Failed to pthread_mutex_init errno=%d", errno);
} }
static inline void rwlock_init(pthread_rwlock_t *lock) static inline void _rwlock_init(pthread_rwlock_t *lock, const char *file, const char *func, const int line)
{ {
if (unlikely(pthread_rwlock_init(lock, NULL))) if (unlikely(pthread_rwlock_init(lock, NULL)))
quit(1, "Failed to pthread_rwlock_init"); quitfrom(1, file, func, line, "Failed to pthread_rwlock_init errno=%d", errno);
} }
/* cgminer locks, a write biased variant of rwlocks */ /* cgminer locks, a write biased variant of rwlocks */

53
util.c
Unescape View File

@ -564,7 +564,7 @@ char *get_proxy(char *url, struct pool *pool)
len = split - url; len = split - url;
pool->rpc_proxy = malloc(1 + len - plen); pool->rpc_proxy = malloc(1 + len - plen);
if (!(pool->rpc_proxy)) if (!(pool->rpc_proxy))
quit(1, "Failed to malloc rpc_proxy"); quithere(1, "Failed to malloc rpc_proxy");
strcpy(pool->rpc_proxy, url + plen); strcpy(pool->rpc_proxy, url + plen);
pool->rpc_proxytype = proxynames[i].proxytype; pool->rpc_proxytype = proxynames[i].proxytype;
@ -590,7 +590,7 @@ char *bin2hex(const unsigned char *p, size_t len)
slen += 4 - (slen % 4); slen += 4 - (slen % 4);
s = calloc(slen, 1); s = calloc(slen, 1);
if (unlikely(!s)) if (unlikely(!s))
quit(1, "Failed to calloc in bin2hex"); quithere(1, "Failed to calloc");
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
sprintf(s + (i * 2), "%02x", (unsigned int) p[i]); sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);
@ -1090,7 +1090,7 @@ static void recalloc_sock(struct pool *pool, size_t len)
// applog(LOG_DEBUG, "Recallocing pool sockbuf to %d", new); // applog(LOG_DEBUG, "Recallocing pool sockbuf to %d", new);
pool->sockbuf = realloc(pool->sockbuf, new); pool->sockbuf = realloc(pool->sockbuf, new);
if (!pool->sockbuf) if (!pool->sockbuf)
quit(1, "Failed to realloc pool sockbuf in recalloc_sock"); quithere(1, "Failed to realloc pool sockbuf");
memset(pool->sockbuf + old, 0, new - old); memset(pool->sockbuf + old, 0, new - old);
pool->sockbuf_size = new; pool->sockbuf_size = new;
} }
@ -1282,11 +1282,11 @@ static bool parse_notify(struct pool *pool, json_t *val)
free(pool->swork.cb2); free(pool->swork.cb2);
pool->swork.cb1 = calloc(pool->swork.cb1_len, 1); pool->swork.cb1 = calloc(pool->swork.cb1_len, 1);
if (unlikely(!pool->swork.cb1)) if (unlikely(!pool->swork.cb1))
quit(1, "Failed to calloc swork cb1 in parse_notify"); quithere(1, "Failed to calloc swork cb1");
hex2bin(pool->swork.cb1, pool->swork.coinbase1, pool->swork.cb1_len); hex2bin(pool->swork.cb1, pool->swork.coinbase1, pool->swork.cb1_len);
pool->swork.cb2 = calloc(pool->swork.cb2_len, 1); pool->swork.cb2 = calloc(pool->swork.cb2_len, 1);
if (unlikely(!pool->swork.cb2)) if (unlikely(!pool->swork.cb2))
quit(1, "Failed to calloc swork cb2 in parse_notify"); quithere(1, "Failed to calloc swork cb2");
hex2bin(pool->swork.cb2, pool->swork.coinbase2, pool->swork.cb2_len); hex2bin(pool->swork.cb2, pool->swork.coinbase2, pool->swork.cb2_len);
cg_wunlock(&pool->data_lock); cg_wunlock(&pool->data_lock);
@ -1578,7 +1578,7 @@ static bool setup_stratum_socket(struct pool *pool)
if (!pool->sockbuf) { if (!pool->sockbuf) {
pool->sockbuf = calloc(RBUFSIZE, 1); pool->sockbuf = calloc(RBUFSIZE, 1);
if (!pool->sockbuf) if (!pool->sockbuf)
quit(1, "Failed to calloc pool sockbuf in initiate_stratum"); quithere(1, "Failed to calloc pool sockbuf");
pool->sockbuf_size = RBUFSIZE; pool->sockbuf_size = RBUFSIZE;
} }
@ -1721,7 +1721,7 @@ resend:
free(pool->nonce1bin); free(pool->nonce1bin);
pool->nonce1bin = calloc(pool->n1_len, 1); pool->nonce1bin = calloc(pool->n1_len, 1);
if (unlikely(!pool->nonce1bin)) if (unlikely(!pool->nonce1bin))
quit(1, "Failed to calloc pool->nonce1bin in initiate_stratum"); quithere(1, "Failed to calloc pool->nonce1bin");
hex2bin(pool->nonce1bin, pool->nonce1, pool->n1_len); hex2bin(pool->nonce1bin, pool->nonce1, pool->n1_len);
pool->n2size = n2size; pool->n2size = n2size;
cg_wunlock(&pool->data_lock); cg_wunlock(&pool->data_lock);
@ -1830,7 +1830,7 @@ void *realloc_strcat(char *ptr, char *s)
ret = malloc(len); ret = malloc(len);
if (unlikely(!ret)) if (unlikely(!ret))
quit(1, "Failed to malloc in realloc_strcat"); quithere(1, "Failed to malloc");
sprintf(ret, "%s%s", ptr, s); sprintf(ret, "%s%s", ptr, s);
free(ptr); free(ptr);
@ -1849,14 +1849,14 @@ void *str_text(char *ptr)
ret = strdup("(null)"); ret = strdup("(null)");
if (unlikely(!ret)) if (unlikely(!ret))
quit(1, "Failed to malloc in text_str null"); quithere(1, "Failed to malloc null");
} }
uptr = (unsigned char *)ptr; uptr = (unsigned char *)ptr;
ret = txt = malloc(strlen(ptr)*4+5); // Guaranteed >= needed ret = txt = malloc(strlen(ptr)*4+5); // Guaranteed >= needed
if (unlikely(!txt)) if (unlikely(!txt))
quit(1, "Failed to malloc in text_str txt"); quithere(1, "Failed to malloc txt");
do { do {
if (*uptr < ' ' || *uptr > '~') { if (*uptr < ' ' || *uptr > '~') {
@ -1890,12 +1890,12 @@ void RenameThread(const char* name)
* that support them and for apple which does not. We use a single byte across * that support them and for apple which does not. We use a single byte across
* a pipe to emulate semaphore behaviour there. */ * a pipe to emulate semaphore behaviour there. */
#ifdef __APPLE__ #ifdef __APPLE__
void cgsem_init(cgsem_t *cgsem) void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
int flags, fd, i; int flags, fd, i;
if (pipe(cgsem->pipefd) == -1) if (pipe(cgsem->pipefd) == -1)
quit(1, "Failed pipe in cgsem_init"); quitfrom(1, file, func, line, "Failed pipe errno=%d", errno);
/* Make the pipes FD_CLOEXEC to allow them to close should we call /* Make the pipes FD_CLOEXEC to allow them to close should we call
* execv on restart. */ * execv on restart. */
@ -1904,55 +1904,56 @@ void cgsem_init(cgsem_t *cgsem)
flags = fcntl(fd, F_GETFD, 0); flags = fcntl(fd, F_GETFD, 0);
flags |= FD_CLOEXEC; flags |= FD_CLOEXEC;
if (fcntl(fd, F_SETFD, flags) == -1) if (fcntl(fd, F_SETFD, flags) == -1)
quit(1, "Failed to fcntl in cgsem_init"); quitfrom(1, file, func, line, "Failed to fcntl errno=%d", errno);
} }
} }
void cgsem_post(cgsem_t *cgsem) void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
const char buf = 1; const char buf = 1;
int ret; int ret;
ret = write(cgsem->pipefd[1], &buf, 1); ret = write(cgsem->pipefd[1], &buf, 1);
if (unlikely(ret == 0)) if (unlikely(ret == 0))
applog(LOG_WARNING, "Failed to write in cgsem_post"); applog(LOG_WARNING, "Failed to write errno=%d" IN_FMT_FFL, errno, file, func, line);
} }
void cgsem_wait(cgsem_t *cgsem) void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
char buf; char buf;
int ret; int ret;
ret = read(cgsem->pipefd[0], &buf, 1); ret = read(cgsem->pipefd[0], &buf, 1);
if (unlikely(ret == 0)) if (unlikely(ret == 0))
applog(LOG_WARNING, "Failed to read in cgsem_wait"); applog(LOG_WARNING, "Failed to read errno=%d" IN_FMT_FFL, errno, file, func, line);
} }
void cgsem_destroy(cgsem_t *cgsem) void _cgsem_destroy(cgsem_t *cgsem)
{ {
close(cgsem->pipefd[1]); close(cgsem->pipefd[1]);
close(cgsem->pipefd[0]); close(cgsem->pipefd[0]);
} }
#else #else
void cgsem_init(cgsem_t *cgsem) void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
if (sem_init(cgsem, 0, 0)) int ret;
quit(1, "Failed to sem_init in cgsem_init"); if ((ret = sem_init(cgsem, 0, 0)))
quitfrom(1, file, func, line, "Failed to sem_init ret=%d errno=%d", ret, errno);
} }
void cgsem_post(cgsem_t *cgsem) void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
if (unlikely(sem_post(cgsem))) if (unlikely(sem_post(cgsem)))
quit(1, "Failed to sem_post in cgsem_post"); quitfrom(1, file, func, line, "Failed to sem_post errno=%d cgsem=0x%p", errno, cgsem);
} }
void cgsem_wait(cgsem_t *cgsem) void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line)
{ {
if (unlikely(sem_wait(cgsem))) if (unlikely(sem_wait(cgsem)))
quit(1, "Failed to sem_wait in cgsem_wait"); quitfrom(1, file, func, line, "Failed to sem_wait errno=%d cgsem=0x%p", errno, cgsem);
} }
void cgsem_destroy(cgsem_t *cgsem) void _cgsem_destroy(cgsem_t *cgsem)
{ {
sem_destroy(cgsem); sem_destroy(cgsem);
} }

13
util.h
Unescape View File

@ -93,10 +93,15 @@ void dev_error(struct cgpu_info *dev, enum dev_reason reason);
void *realloc_strcat(char *ptr, char *s); void *realloc_strcat(char *ptr, char *s);
void *str_text(char *ptr); void *str_text(char *ptr);
void RenameThread(const char* name); void RenameThread(const char* name);
void cgsem_init(cgsem_t *cgsem); void _cgsem_init(cgsem_t *cgsem, const char *file, const char *func, const int line);
void cgsem_post(cgsem_t *cgsem); void _cgsem_post(cgsem_t *cgsem, const char *file, const char *func, const int line);
void cgsem_wait(cgsem_t *cgsem); void _cgsem_wait(cgsem_t *cgsem, const char *file, const char *func, const int line);
void cgsem_destroy(cgsem_t *cgsem); void _cgsem_destroy(cgsem_t *cgsem);
#define cgsem_init(_sem) _cgsem_init(_sem, __FILE__, __func__, __LINE__)
#define cgsem_post(_sem) _cgsem_post(_sem, __FILE__, __func__, __LINE__)
#define cgsem_wait(_sem) _cgsem_wait(_sem, __FILE__, __func__, __LINE__)
#define cgsem_destroy(_sem) _cgsem_destroy(_sem)
/* Align a size_t to 4 byte boundaries for fussy arches */ /* Align a size_t to 4 byte boundaries for fussy arches */
static inline void align_len(size_t *len) static inline void align_len(size_t *len)

Write Preview
Loading…
Cancel
Save