mirror of https://github.com/GOSTSec/sgminer
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4748 lines
124 KiB
4748 lines
124 KiB
/* |
|
* Copyright 2011-2013 Andrew Smith |
|
* Copyright 2011-2013 Con Kolivas |
|
* |
|
* 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 3 of the License, or (at your option) |
|
* any later version. See COPYING for more details. |
|
* |
|
* Note: the code always includes GPU support even if there are no GPUs |
|
* this simplifies handling multiple other device code being included |
|
* depending on compile options |
|
*/ |
|
#define _MEMORY_DEBUG_MASTER 1 |
|
|
|
#include "config.h" |
|
|
|
#include <stdio.h> |
|
#include <ctype.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
#include <stdbool.h> |
|
#include <stdint.h> |
|
#include <unistd.h> |
|
#include <limits.h> |
|
#include <sys/types.h> |
|
|
|
#include "compat.h" |
|
#include "miner.h" |
|
#include "util.h" |
|
|
|
#if defined(USE_BFLSC) || defined(USE_AVALON) || defined(USE_BITFURY) || defined(USE_KLONDIKE) |
|
#define HAVE_AN_ASIC 1 |
|
#endif |
|
|
|
#if defined(USE_BITFORCE) || defined(USE_ICARUS) || defined(USE_MODMINER) |
|
#define HAVE_AN_FPGA 1 |
|
#endif |
|
|
|
// Big enough for largest API request |
|
// though a PC with 100s of PGAs may exceed the size ... |
|
// data is truncated at the end of the last record that fits |
|
// but still closed correctly for JSON |
|
// Current code assumes it can socket send this size + JSON_CLOSE + JSON_END |
|
#define SOCKBUFSIZ 65432 |
|
|
|
// BUFSIZ varies on Windows and Linux |
|
#define TMPBUFSIZ 8192 |
|
|
|
// Number of requests to queue - normally would be small |
|
// However lots of PGA's may mean more |
|
#define QUEUE 100 |
|
|
|
#if defined WIN32 |
|
static char WSAbuf[1024]; |
|
|
|
struct WSAERRORS { |
|
int id; |
|
char *code; |
|
} WSAErrors[] = { |
|
{ 0, "No error" }, |
|
{ WSAEINTR, "Interrupted system call" }, |
|
{ WSAEBADF, "Bad file number" }, |
|
{ WSAEACCES, "Permission denied" }, |
|
{ WSAEFAULT, "Bad address" }, |
|
{ WSAEINVAL, "Invalid argument" }, |
|
{ WSAEMFILE, "Too many open sockets" }, |
|
{ WSAEWOULDBLOCK, "Operation would block" }, |
|
{ WSAEINPROGRESS, "Operation now in progress" }, |
|
{ WSAEALREADY, "Operation already in progress" }, |
|
{ WSAENOTSOCK, "Socket operation on non-socket" }, |
|
{ WSAEDESTADDRREQ, "Destination address required" }, |
|
{ WSAEMSGSIZE, "Message too long" }, |
|
{ WSAEPROTOTYPE, "Protocol wrong type for socket" }, |
|
{ WSAENOPROTOOPT, "Bad protocol option" }, |
|
{ WSAEPROTONOSUPPORT, "Protocol not supported" }, |
|
{ WSAESOCKTNOSUPPORT, "Socket type not supported" }, |
|
{ WSAEOPNOTSUPP, "Operation not supported on socket" }, |
|
{ WSAEPFNOSUPPORT, "Protocol family not supported" }, |
|
{ WSAEAFNOSUPPORT, "Address family not supported" }, |
|
{ WSAEADDRINUSE, "Address already in use" }, |
|
{ WSAEADDRNOTAVAIL, "Can't assign requested address" }, |
|
{ WSAENETDOWN, "Network is down" }, |
|
{ WSAENETUNREACH, "Network is unreachable" }, |
|
{ WSAENETRESET, "Net connection reset" }, |
|
{ WSAECONNABORTED, "Software caused connection abort" }, |
|
{ WSAECONNRESET, "Connection reset by peer" }, |
|
{ WSAENOBUFS, "No buffer space available" }, |
|
{ WSAEISCONN, "Socket is already connected" }, |
|
{ WSAENOTCONN, "Socket is not connected" }, |
|
{ WSAESHUTDOWN, "Can't send after socket shutdown" }, |
|
{ WSAETOOMANYREFS, "Too many references, can't splice" }, |
|
{ WSAETIMEDOUT, "Connection timed out" }, |
|
{ WSAECONNREFUSED, "Connection refused" }, |
|
{ WSAELOOP, "Too many levels of symbolic links" }, |
|
{ WSAENAMETOOLONG, "File name too long" }, |
|
{ WSAEHOSTDOWN, "Host is down" }, |
|
{ WSAEHOSTUNREACH, "No route to host" }, |
|
{ WSAENOTEMPTY, "Directory not empty" }, |
|
{ WSAEPROCLIM, "Too many processes" }, |
|
{ WSAEUSERS, "Too many users" }, |
|
{ WSAEDQUOT, "Disc quota exceeded" }, |
|
{ WSAESTALE, "Stale NFS file handle" }, |
|
{ WSAEREMOTE, "Too many levels of remote in path" }, |
|
{ WSASYSNOTREADY, "Network system is unavailable" }, |
|
{ WSAVERNOTSUPPORTED, "Winsock version out of range" }, |
|
{ WSANOTINITIALISED, "WSAStartup not yet called" }, |
|
{ WSAEDISCON, "Graceful shutdown in progress" }, |
|
{ WSAHOST_NOT_FOUND, "Host not found" }, |
|
{ WSANO_DATA, "No host data of that type was found" }, |
|
{ -1, "Unknown error code" } |
|
}; |
|
|
|
char *WSAErrorMsg(void) { |
|
int i; |
|
int id = WSAGetLastError(); |
|
|
|
/* Assume none of them are actually -1 */ |
|
for (i = 0; WSAErrors[i].id != -1; i++) |
|
if (WSAErrors[i].id == id) |
|
break; |
|
|
|
sprintf(WSAbuf, "Socket Error: (%d) %s", id, WSAErrors[i].code); |
|
|
|
return &(WSAbuf[0]); |
|
} |
|
#endif |
|
|
|
static const char *UNAVAILABLE = " - API will not be available"; |
|
static const char *MUNAVAILABLE = " - API multicast listener will not be available"; |
|
|
|
static const char *BLANK = ""; |
|
static const char *COMMA = ","; |
|
#define COMSTR "," |
|
static const char SEPARATOR = '|'; |
|
#define SEPSTR "|" |
|
static const char GPUSEP = ','; |
|
|
|
static const char *APIVERSION = "1.30"; |
|
static const char *DEAD = "Dead"; |
|
#if defined(HAVE_OPENCL) || defined(HAVE_AN_FPGA) || defined(HAVE_AN_ASIC) |
|
static const char *SICK = "Sick"; |
|
static const char *NOSTART = "NoStart"; |
|
static const char *INIT = "Initialising"; |
|
#endif |
|
static const char *DISABLED = "Disabled"; |
|
static const char *ALIVE = "Alive"; |
|
static const char *REJECTING = "Rejecting"; |
|
static const char *UNKNOWN = "Unknown"; |
|
#define _DYNAMIC "D" |
|
#ifdef HAVE_OPENCL |
|
static const char *DYNAMIC = _DYNAMIC; |
|
#endif |
|
|
|
static __maybe_unused const char *NONE = "None"; |
|
|
|
static const char *YES = "Y"; |
|
static const char *NO = "N"; |
|
static const char *NULLSTR = "(null)"; |
|
|
|
static const char *TRUESTR = "true"; |
|
static const char *FALSESTR = "false"; |
|
|
|
#ifdef USE_SCRYPT |
|
static const char *SCRYPTSTR = "scrypt"; |
|
#endif |
|
static const char *SHA256STR = "sha256"; |
|
|
|
static const char *DEVICECODE = "" |
|
#ifdef HAVE_OPENCL |
|
"GPU " |
|
#endif |
|
#ifdef USE_BFLSC |
|
"BAS " |
|
#endif |
|
#ifdef USE_BITFORCE |
|
"BFL " |
|
#endif |
|
#ifdef USE_BITFURY |
|
"BFU " |
|
#endif |
|
#ifdef USE_ICARUS |
|
"ICA " |
|
#endif |
|
#ifdef USE_AVALON |
|
"AVA " |
|
#endif |
|
#ifdef USE_MODMINER |
|
"MMQ " |
|
#endif |
|
""; |
|
|
|
static const char *OSINFO = |
|
#if defined(__linux) |
|
"Linux"; |
|
#else |
|
#if defined(__APPLE__) |
|
"Apple"; |
|
#else |
|
#if defined (WIN32) |
|
"Windows"; |
|
#else |
|
#if defined(unix) |
|
"Unix"; |
|
#else |
|
"Unknown"; |
|
#endif |
|
#endif |
|
#endif |
|
#endif |
|
|
|
#define _DEVS "DEVS" |
|
#define _POOLS "POOLS" |
|
#define _SUMMARY "SUMMARY" |
|
#define _STATUS "STATUS" |
|
#define _VERSION "VERSION" |
|
#define _MINECONFIG "CONFIG" |
|
#define _GPU "GPU" |
|
|
|
#ifdef HAVE_AN_FPGA |
|
#define _PGA "PGA" |
|
#endif |
|
|
|
#ifdef HAVE_AN_ASIC |
|
#define _ASC "ASC" |
|
#endif |
|
|
|
#define _GPUS "GPUS" |
|
#define _PGAS "PGAS" |
|
#define _ASCS "ASCS" |
|
#define _NOTIFY "NOTIFY" |
|
#define _DEVDETAILS "DEVDETAILS" |
|
#define _BYE "BYE" |
|
#define _RESTART "RESTART" |
|
#define _MINESTATS "STATS" |
|
#define _CHECK "CHECK" |
|
#define _MINECOIN "COIN" |
|
#define _DEBUGSET "DEBUG" |
|
#define _SETCONFIG "SETCONFIG" |
|
#define _USBSTATS "USBSTATS" |
|
|
|
static const char ISJSON = '{'; |
|
#define JSON0 "{" |
|
#define JSON1 "\"" |
|
#define JSON2 "\":[" |
|
#define JSON3 "]" |
|
#define JSON4 ",\"id\":1" |
|
// If anyone cares, id=0 for truncated output |
|
#define JSON4_TRUNCATED ",\"id\":0" |
|
#define JSON5 "}" |
|
|
|
#define JSON_START JSON0 |
|
#define JSON_DEVS JSON1 _DEVS JSON2 |
|
#define JSON_POOLS JSON1 _POOLS JSON2 |
|
#define JSON_SUMMARY JSON1 _SUMMARY JSON2 |
|
#define JSON_STATUS JSON1 _STATUS JSON2 |
|
#define JSON_VERSION JSON1 _VERSION JSON2 |
|
#define JSON_MINECONFIG JSON1 _MINECONFIG JSON2 |
|
#define JSON_GPU JSON1 _GPU JSON2 |
|
|
|
#ifdef HAVE_AN_FPGA |
|
#define JSON_PGA JSON1 _PGA JSON2 |
|
#endif |
|
|
|
#ifdef HAVE_AN_ASIC |
|
#define JSON_ASC JSON1 _ASC JSON2 |
|
#endif |
|
|
|
#define JSON_GPUS JSON1 _GPUS JSON2 |
|
#define JSON_PGAS JSON1 _PGAS JSON2 |
|
#define JSON_ASCS JSON1 _ASCS JSON2 |
|
#define JSON_NOTIFY JSON1 _NOTIFY JSON2 |
|
#define JSON_DEVDETAILS JSON1 _DEVDETAILS JSON2 |
|
#define JSON_BYE JSON1 _BYE JSON1 |
|
#define JSON_RESTART JSON1 _RESTART JSON1 |
|
#define JSON_CLOSE JSON3 |
|
#define JSON_MINESTATS JSON1 _MINESTATS JSON2 |
|
#define JSON_CHECK JSON1 _CHECK JSON2 |
|
#define JSON_MINECOIN JSON1 _MINECOIN JSON2 |
|
#define JSON_DEBUGSET JSON1 _DEBUGSET JSON2 |
|
#define JSON_SETCONFIG JSON1 _SETCONFIG JSON2 |
|
#define JSON_USBSTATS JSON1 _USBSTATS JSON2 |
|
#define JSON_END JSON4 JSON5 |
|
#define JSON_END_TRUNCATED JSON4_TRUNCATED JSON5 |
|
|
|
static const char *JSON_COMMAND = "command"; |
|
static const char *JSON_PARAMETER = "parameter"; |
|
|
|
#define MSG_INVGPU 1 |
|
#define MSG_ALRENA 2 |
|
#define MSG_ALRDIS 3 |
|
#define MSG_GPUMRE 4 |
|
#define MSG_GPUREN 5 |
|
#define MSG_GPUNON 6 |
|
#define MSG_POOL 7 |
|
#define MSG_NOPOOL 8 |
|
#define MSG_DEVS 9 |
|
#define MSG_NODEVS 10 |
|
#define MSG_SUMM 11 |
|
#define MSG_GPUDIS 12 |
|
#define MSG_GPUREI 13 |
|
#define MSG_INVCMD 14 |
|
#define MSG_MISID 15 |
|
#define MSG_GPUDEV 17 |
|
|
|
#define MSG_NUMGPU 20 |
|
|
|
#define MSG_VERSION 22 |
|
#define MSG_INVJSON 23 |
|
#define MSG_MISCMD 24 |
|
#define MSG_MISPID 25 |
|
#define MSG_INVPID 26 |
|
#define MSG_SWITCHP 27 |
|
#define MSG_MISVAL 28 |
|
#define MSG_NOADL 29 |
|
#define MSG_NOGPUADL 30 |
|
#define MSG_INVINT 31 |
|
#define MSG_GPUINT 32 |
|
#define MSG_MINECONFIG 33 |
|
#define MSG_GPUMERR 34 |
|
#define MSG_GPUMEM 35 |
|
#define MSG_GPUEERR 36 |
|
#define MSG_GPUENG 37 |
|
#define MSG_GPUVERR 38 |
|
#define MSG_GPUVDDC 39 |
|
#define MSG_GPUFERR 40 |
|
#define MSG_GPUFAN 41 |
|
#define MSG_MISFN 42 |
|
#define MSG_BADFN 43 |
|
#define MSG_SAVED 44 |
|
#define MSG_ACCDENY 45 |
|
#define MSG_ACCOK 46 |
|
#define MSG_ENAPOOL 47 |
|
#define MSG_DISPOOL 48 |
|
#define MSG_ALRENAP 49 |
|
#define MSG_ALRDISP 50 |
|
#define MSG_DISLASTP 51 |
|
#define MSG_MISPDP 52 |
|
#define MSG_INVPDP 53 |
|
#define MSG_TOOMANYP 54 |
|
#define MSG_ADDPOOL 55 |
|
|
|
#ifdef HAVE_AN_FPGA |
|
#define MSG_PGANON 56 |
|
#define MSG_PGADEV 57 |
|
#define MSG_INVPGA 58 |
|
#endif |
|
|
|
#define MSG_NUMPGA 59 |
|
#define MSG_NOTIFY 60 |
|
|
|
#ifdef HAVE_AN_FPGA |
|
#define MSG_PGALRENA 61 |
|
#define MSG_PGALRDIS 62 |
|
#define MSG_PGAENA 63 |
|
#define MSG_PGADIS 64 |
|
#define MSG_PGAUNW 65 |
|
#endif |
|
|
|
#define MSG_REMLASTP 66 |
|
#define MSG_ACTPOOL 67 |
|
#define MSG_REMPOOL 68 |
|
#define MSG_DEVDETAILS 69 |
|
#define MSG_MINESTATS 70 |
|
#define MSG_MISCHK 71 |
|
#define MSG_CHECK 72 |
|
#define MSG_POOLPRIO 73 |
|
#define MSG_DUPPID 74 |
|
#define MSG_MISBOOL 75 |
|
#define MSG_INVBOOL 76 |
|
#define MSG_FOO 77 |
|
#define MSG_MINECOIN 78 |
|
#define MSG_DEBUGSET 79 |
|
#define MSG_PGAIDENT 80 |
|
#define MSG_PGANOID 81 |
|
#define MSG_SETCONFIG 82 |
|
#define MSG_UNKCON 83 |
|
#define MSG_INVNUM 84 |
|
#define MSG_CONPAR 85 |
|
#define MSG_CONVAL 86 |
|
#define MSG_USBSTA 87 |
|
#define MSG_NOUSTA 88 |
|
|
|
#ifdef HAVE_AN_FPGA |
|
#define MSG_MISPGAOPT 89 |
|
#define MSG_PGANOSET 90 |
|
#define MSG_PGAHELP 91 |
|
#define MSG_PGASETOK 92 |
|
#define MSG_PGASETERR 93 |
|
#endif |
|
|
|
#define MSG_ZERMIS 94 |
|
#define MSG_ZERINV 95 |
|
#define MSG_ZERSUM 96 |
|
#define MSG_ZERNOSUM 97 |
|
#define MSG_PGAUSBNODEV 98 |
|
#define MSG_INVHPLG 99 |
|
#define MSG_HOTPLUG 100 |
|
#define MSG_DISHPLG 101 |
|
#define MSG_NOHPLG 102 |
|
#define MSG_MISHPLG 103 |
|
|
|
#define MSG_NUMASC 104 |
|
#ifdef HAVE_AN_ASIC |
|
#define MSG_ASCNON 105 |
|
#define MSG_ASCDEV 106 |
|
#define MSG_INVASC 107 |
|
#define MSG_ASCLRENA 108 |
|
#define MSG_ASCLRDIS 109 |
|
#define MSG_ASCENA 110 |
|
#define MSG_ASCDIS 111 |
|
#define MSG_ASCUNW 112 |
|
#define MSG_ASCIDENT 113 |
|
#define MSG_ASCNOID 114 |
|
#endif |
|
#define MSG_ASCUSBNODEV 115 |
|
|
|
#ifdef HAVE_AN_ASIC |
|
#define MSG_MISASCOPT 116 |
|
#define MSG_ASCNOSET 117 |
|
#define MSG_ASCHELP 118 |
|
#define MSG_ASCSETOK 119 |
|
#define MSG_ASCSETERR 120 |
|
#endif |
|
|
|
#define MSG_INVNEG 121 |
|
#define MSG_SETQUOTA 122 |
|
|
|
enum code_severity { |
|
SEVERITY_ERR, |
|
SEVERITY_WARN, |
|
SEVERITY_INFO, |
|
SEVERITY_SUCC, |
|
SEVERITY_FAIL |
|
}; |
|
|
|
enum code_parameters { |
|
PARAM_GPU, |
|
PARAM_PGA, |
|
PARAM_ASC, |
|
PARAM_PID, |
|
PARAM_GPUMAX, |
|
PARAM_PGAMAX, |
|
PARAM_ASCMAX, |
|
PARAM_PMAX, |
|
PARAM_POOLMAX, |
|
|
|
// Single generic case: have the code resolve it - see below |
|
PARAM_DMAX, |
|
|
|
PARAM_CMD, |
|
PARAM_POOL, |
|
PARAM_STR, |
|
PARAM_BOTH, |
|
PARAM_BOOL, |
|
PARAM_SET, |
|
PARAM_INT, |
|
PARAM_NONE |
|
}; |
|
|
|
struct CODES { |
|
const enum code_severity severity; |
|
const int code; |
|
const enum code_parameters params; |
|
const char *description; |
|
} codes[] = { |
|
#ifdef HAVE_OPENCL |
|
{ SEVERITY_ERR, MSG_INVGPU, PARAM_GPUMAX, "Invalid GPU id %d - range is 0 - %d" }, |
|
{ SEVERITY_INFO, MSG_ALRENA, PARAM_GPU, "GPU %d already enabled" }, |
|
{ SEVERITY_INFO, MSG_ALRDIS, PARAM_GPU, "GPU %d already disabled" }, |
|
{ SEVERITY_WARN, MSG_GPUMRE, PARAM_GPU, "GPU %d must be restarted first" }, |
|
{ SEVERITY_INFO, MSG_GPUREN, PARAM_GPU, "GPU %d sent enable message" }, |
|
#endif |
|
{ SEVERITY_ERR, MSG_GPUNON, PARAM_NONE, "No GPUs" }, |
|
{ SEVERITY_SUCC, MSG_POOL, PARAM_PMAX, "%d Pool(s)" }, |
|
{ SEVERITY_ERR, MSG_NOPOOL, PARAM_NONE, "No pools" }, |
|
|
|
{ SEVERITY_SUCC, MSG_DEVS, PARAM_DMAX, |
|
#ifdef HAVE_OPENCL |
|
"%d GPU(s)" |
|
#endif |
|
#if defined(HAVE_AN_ASIC) && defined(HAVE_OPENCL) |
|
" - " |
|
#endif |
|
#ifdef HAVE_AN_ASIC |
|
"%d ASC(s)" |
|
#endif |
|
#if defined(HAVE_AN_FPGA) && (defined(HAVE_OPENCL) || defined(HAVE_AN_ASIC)) |
|
" - " |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
"%d PGA(s)" |
|
#endif |
|
#if (defined(HAVE_OPENCL) || defined(HAVE_AN_ASIC) || defined(HAVE_AN_FPGA)) |
|
" - " |
|
#endif |
|
}, |
|
|
|
{ SEVERITY_ERR, MSG_NODEVS, PARAM_NONE, "No GPUs" |
|
#ifdef HAVE_AN_ASIC |
|
"/ASCs" |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
"/PGAs" |
|
#endif |
|
}, |
|
|
|
{ SEVERITY_SUCC, MSG_SUMM, PARAM_NONE, "Summary" }, |
|
#ifdef HAVE_OPENCL |
|
{ SEVERITY_INFO, MSG_GPUDIS, PARAM_GPU, "GPU %d set disable flag" }, |
|
{ SEVERITY_INFO, MSG_GPUREI, PARAM_GPU, "GPU %d restart attempted" }, |
|
#endif |
|
{ SEVERITY_ERR, MSG_INVCMD, PARAM_NONE, "Invalid command" }, |
|
{ SEVERITY_ERR, MSG_MISID, PARAM_NONE, "Missing device id parameter" }, |
|
#ifdef HAVE_OPENCL |
|
{ SEVERITY_SUCC, MSG_GPUDEV, PARAM_GPU, "GPU%d" }, |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
{ SEVERITY_ERR, MSG_PGANON, PARAM_NONE, "No PGAs" }, |
|
{ SEVERITY_SUCC, MSG_PGADEV, PARAM_PGA, "PGA%d" }, |
|
{ SEVERITY_ERR, MSG_INVPGA, PARAM_PGAMAX, "Invalid PGA id %d - range is 0 - %d" }, |
|
{ SEVERITY_INFO, MSG_PGALRENA,PARAM_PGA, "PGA %d already enabled" }, |
|
{ SEVERITY_INFO, MSG_PGALRDIS,PARAM_PGA, "PGA %d already disabled" }, |
|
{ SEVERITY_INFO, MSG_PGAENA, PARAM_PGA, "PGA %d sent enable message" }, |
|
{ SEVERITY_INFO, MSG_PGADIS, PARAM_PGA, "PGA %d set disable flag" }, |
|
{ SEVERITY_ERR, MSG_PGAUNW, PARAM_PGA, "PGA %d is not flagged WELL, cannot enable" }, |
|
#endif |
|
{ SEVERITY_SUCC, MSG_NUMGPU, PARAM_NONE, "GPU count" }, |
|
{ SEVERITY_SUCC, MSG_NUMPGA, PARAM_NONE, "PGA count" }, |
|
{ SEVERITY_SUCC, MSG_NUMASC, PARAM_NONE, "ASC count" }, |
|
{ SEVERITY_SUCC, MSG_VERSION, PARAM_NONE, "CGMiner versions" }, |
|
{ SEVERITY_ERR, MSG_INVJSON, PARAM_NONE, "Invalid JSON" }, |
|
{ SEVERITY_ERR, MSG_MISCMD, PARAM_CMD, "Missing JSON '%s'" }, |
|
{ SEVERITY_ERR, MSG_MISPID, PARAM_NONE, "Missing pool id parameter" }, |
|
{ SEVERITY_ERR, MSG_INVPID, PARAM_POOLMAX, "Invalid pool id %d - range is 0 - %d" }, |
|
{ SEVERITY_SUCC, MSG_SWITCHP, PARAM_POOL, "Switching to pool %d:'%s'" }, |
|
{ SEVERITY_ERR, MSG_MISVAL, PARAM_NONE, "Missing comma after GPU number" }, |
|
{ SEVERITY_ERR, MSG_NOADL, PARAM_NONE, "ADL is not available" }, |
|
{ SEVERITY_ERR, MSG_NOGPUADL,PARAM_GPU, "GPU %d does not have ADL" }, |
|
{ SEVERITY_ERR, MSG_INVINT, PARAM_STR, "Invalid intensity (%s) - must be '" _DYNAMIC "' or range " MIN_SHA_INTENSITY_STR " - " MAX_SCRYPT_INTENSITY_STR }, |
|
{ SEVERITY_INFO, MSG_GPUINT, PARAM_BOTH, "GPU %d set new intensity to %s" }, |
|
{ SEVERITY_SUCC, MSG_MINECONFIG,PARAM_NONE, "CGMiner config" }, |
|
#ifdef HAVE_OPENCL |
|
{ SEVERITY_ERR, MSG_GPUMERR, PARAM_BOTH, "Setting GPU %d memoryclock to (%s) reported failure" }, |
|
{ SEVERITY_SUCC, MSG_GPUMEM, PARAM_BOTH, "Setting GPU %d memoryclock to (%s) reported success" }, |
|
{ SEVERITY_ERR, MSG_GPUEERR, PARAM_BOTH, "Setting GPU %d clock to (%s) reported failure" }, |
|
{ SEVERITY_SUCC, MSG_GPUENG, PARAM_BOTH, "Setting GPU %d clock to (%s) reported success" }, |
|
{ SEVERITY_ERR, MSG_GPUVERR, PARAM_BOTH, "Setting GPU %d vddc to (%s) reported failure" }, |
|
{ SEVERITY_SUCC, MSG_GPUVDDC, PARAM_BOTH, "Setting GPU %d vddc to (%s) reported success" }, |
|
{ SEVERITY_ERR, MSG_GPUFERR, PARAM_BOTH, "Setting GPU %d fan to (%s) reported failure" }, |
|
{ SEVERITY_SUCC, MSG_GPUFAN, PARAM_BOTH, "Setting GPU %d fan to (%s) reported success" }, |
|
#endif |
|
{ SEVERITY_ERR, MSG_MISFN, PARAM_NONE, "Missing save filename parameter" }, |
|
{ SEVERITY_ERR, MSG_BADFN, PARAM_STR, "Can't open or create save file '%s'" }, |
|
{ SEVERITY_SUCC, MSG_SAVED, PARAM_STR, "Configuration saved to file '%s'" }, |
|
{ SEVERITY_ERR, MSG_ACCDENY, PARAM_STR, "Access denied to '%s' command" }, |
|
{ SEVERITY_SUCC, MSG_ACCOK, PARAM_NONE, "Privileged access OK" }, |
|
{ SEVERITY_SUCC, MSG_ENAPOOL, PARAM_POOL, "Enabling pool %d:'%s'" }, |
|
{ SEVERITY_SUCC, MSG_POOLPRIO,PARAM_NONE, "Changed pool priorities" }, |
|
{ SEVERITY_ERR, MSG_DUPPID, PARAM_PID, "Duplicate pool specified %d" }, |
|
{ SEVERITY_SUCC, MSG_DISPOOL, PARAM_POOL, "Disabling pool %d:'%s'" }, |
|
{ SEVERITY_INFO, MSG_ALRENAP, PARAM_POOL, "Pool %d:'%s' already enabled" }, |
|
{ SEVERITY_INFO, MSG_ALRDISP, PARAM_POOL, "Pool %d:'%s' already disabled" }, |
|
{ SEVERITY_ERR, MSG_DISLASTP,PARAM_POOL, "Cannot disable last active pool %d:'%s'" }, |
|
{ SEVERITY_ERR, MSG_MISPDP, PARAM_NONE, "Missing addpool details" }, |
|
{ SEVERITY_ERR, MSG_INVPDP, PARAM_STR, "Invalid addpool details '%s'" }, |
|
{ SEVERITY_ERR, MSG_TOOMANYP,PARAM_NONE, "Reached maximum number of pools (%d)" }, |
|
{ SEVERITY_SUCC, MSG_ADDPOOL, PARAM_STR, "Added pool '%s'" }, |
|
{ SEVERITY_ERR, MSG_REMLASTP,PARAM_POOL, "Cannot remove last pool %d:'%s'" }, |
|
{ SEVERITY_ERR, MSG_ACTPOOL, PARAM_POOL, "Cannot remove active pool %d:'%s'" }, |
|
{ SEVERITY_SUCC, MSG_REMPOOL, PARAM_BOTH, "Removed pool %d:'%s'" }, |
|
{ SEVERITY_SUCC, MSG_NOTIFY, PARAM_NONE, "Notify" }, |
|
{ SEVERITY_SUCC, MSG_DEVDETAILS,PARAM_NONE, "Device Details" }, |
|
{ SEVERITY_SUCC, MSG_MINESTATS,PARAM_NONE, "CGMiner stats" }, |
|
{ SEVERITY_ERR, MSG_MISCHK, PARAM_NONE, "Missing check cmd" }, |
|
{ SEVERITY_SUCC, MSG_CHECK, PARAM_NONE, "Check command" }, |
|
{ SEVERITY_ERR, MSG_MISBOOL, PARAM_NONE, "Missing parameter: true/false" }, |
|
{ SEVERITY_ERR, MSG_INVBOOL, PARAM_NONE, "Invalid parameter should be true or false" }, |
|
{ SEVERITY_SUCC, MSG_FOO, PARAM_BOOL, "Failover-Only set to %s" }, |
|
{ SEVERITY_SUCC, MSG_MINECOIN,PARAM_NONE, "CGMiner coin" }, |
|
{ SEVERITY_SUCC, MSG_DEBUGSET,PARAM_NONE, "Debug settings" }, |
|
#ifdef HAVE_AN_FPGA |
|
{ SEVERITY_SUCC, MSG_PGAIDENT,PARAM_PGA, "Identify command sent to PGA%d" }, |
|
{ SEVERITY_WARN, MSG_PGANOID, PARAM_PGA, "PGA%d does not support identify" }, |
|
#endif |
|
{ SEVERITY_SUCC, MSG_SETCONFIG,PARAM_SET, "Set config '%s' to %d" }, |
|
{ SEVERITY_ERR, MSG_UNKCON, PARAM_STR, "Unknown config '%s'" }, |
|
{ SEVERITY_ERR, MSG_INVNUM, PARAM_BOTH, "Invalid number (%d) for '%s' range is 0-9999" }, |
|
{ SEVERITY_ERR, MSG_INVNEG, PARAM_BOTH, "Invalid negative number (%d) for '%s'" }, |
|
{ SEVERITY_SUCC, MSG_SETQUOTA,PARAM_SET, "Set pool '%s' to quota %d'" }, |
|
{ SEVERITY_ERR, MSG_CONPAR, PARAM_NONE, "Missing config parameters 'name,N'" }, |
|
{ SEVERITY_ERR, MSG_CONVAL, PARAM_STR, "Missing config value N for '%s,N'" }, |
|
{ SEVERITY_SUCC, MSG_USBSTA, PARAM_NONE, "USB Statistics" }, |
|
{ SEVERITY_INFO, MSG_NOUSTA, PARAM_NONE, "No USB Statistics" }, |
|
#ifdef HAVE_AN_FPGA |
|
{ SEVERITY_ERR, MSG_MISPGAOPT, PARAM_NONE, "Missing option after PGA number" }, |
|
{ SEVERITY_WARN, MSG_PGANOSET, PARAM_PGA, "PGA %d does not support pgaset" }, |
|
{ SEVERITY_INFO, MSG_PGAHELP, PARAM_BOTH, "PGA %d set help: %s" }, |
|
{ SEVERITY_SUCC, MSG_PGASETOK, PARAM_BOTH, "PGA %d set OK" }, |
|
{ SEVERITY_ERR, MSG_PGASETERR, PARAM_BOTH, "PGA %d set failed: %s" }, |
|
#endif |
|
{ SEVERITY_ERR, MSG_ZERMIS, PARAM_NONE, "Missing zero parameters" }, |
|
{ SEVERITY_ERR, MSG_ZERINV, PARAM_STR, "Invalid zero parameter '%s'" }, |
|
{ SEVERITY_SUCC, MSG_ZERSUM, PARAM_STR, "Zeroed %s stats with summary" }, |
|
{ SEVERITY_SUCC, MSG_ZERNOSUM, PARAM_STR, "Zeroed %s stats without summary" }, |
|
#ifdef USE_USBUTILS |
|
{ SEVERITY_ERR, MSG_PGAUSBNODEV, PARAM_PGA, "PGA%d has no device" }, |
|
{ SEVERITY_ERR, MSG_ASCUSBNODEV, PARAM_PGA, "ASC%d has no device" }, |
|
#endif |
|
{ SEVERITY_ERR, MSG_INVHPLG, PARAM_STR, "Invalid value for hotplug (%s) must be 0..9999" }, |
|
{ SEVERITY_SUCC, MSG_HOTPLUG, PARAM_INT, "Hotplug check set to %ds" }, |
|
{ SEVERITY_SUCC, MSG_DISHPLG, PARAM_NONE, "Hotplug disabled" }, |
|
{ SEVERITY_WARN, MSG_NOHPLG, PARAM_NONE, "Hotplug is not available" }, |
|
{ SEVERITY_ERR, MSG_MISHPLG, PARAM_NONE, "Missing hotplug parameter" }, |
|
#ifdef HAVE_AN_ASIC |
|
{ SEVERITY_ERR, MSG_ASCNON, PARAM_NONE, "No ASCs" }, |
|
{ SEVERITY_SUCC, MSG_ASCDEV, PARAM_ASC, "ASC%d" }, |
|
{ SEVERITY_ERR, MSG_INVASC, PARAM_ASCMAX, "Invalid ASC id %d - range is 0 - %d" }, |
|
{ SEVERITY_INFO, MSG_ASCLRENA,PARAM_ASC, "ASC %d already enabled" }, |
|
{ SEVERITY_INFO, MSG_ASCLRDIS,PARAM_ASC, "ASC %d already disabled" }, |
|
{ SEVERITY_INFO, MSG_ASCENA, PARAM_ASC, "ASC %d sent enable message" }, |
|
{ SEVERITY_INFO, MSG_ASCDIS, PARAM_ASC, "ASC %d set disable flag" }, |
|
{ SEVERITY_ERR, MSG_ASCUNW, PARAM_ASC, "ASC %d is not flagged WELL, cannot enable" }, |
|
{ SEVERITY_SUCC, MSG_ASCIDENT,PARAM_ASC, "Identify command sent to ASC%d" }, |
|
{ SEVERITY_WARN, MSG_ASCNOID, PARAM_ASC, "ASC%d does not support identify" }, |
|
{ SEVERITY_ERR, MSG_MISASCOPT, PARAM_NONE, "Missing option after ASC number" }, |
|
{ SEVERITY_WARN, MSG_ASCNOSET, PARAM_ASC, "ASC %d does not support pgaset" }, |
|
{ SEVERITY_INFO, MSG_ASCHELP, PARAM_BOTH, "ASC %d set help: %s" }, |
|
{ SEVERITY_SUCC, MSG_ASCSETOK, PARAM_BOTH, "ASC %d set OK" }, |
|
{ SEVERITY_ERR, MSG_ASCSETERR, PARAM_BOTH, "ASC %d set failed: %s" }, |
|
#endif |
|
{ SEVERITY_FAIL, 0, 0, NULL } |
|
}; |
|
|
|
static const char *localaddr = "127.0.0.1"; |
|
|
|
static int my_thr_id = 0; |
|
static bool bye; |
|
|
|
// Used to control quit restart access to shutdown variables |
|
static pthread_mutex_t quit_restart_lock; |
|
|
|
static bool do_a_quit; |
|
static bool do_a_restart; |
|
|
|
static time_t when = 0; // when the request occurred |
|
|
|
struct IP4ACCESS { |
|
in_addr_t ip; |
|
in_addr_t mask; |
|
char group; |
|
}; |
|
|
|
#define GROUP(g) (toupper(g)) |
|
#define PRIVGROUP GROUP('W') |
|
#define NOPRIVGROUP GROUP('R') |
|
#define ISPRIVGROUP(g) (GROUP(g) == PRIVGROUP) |
|
#define GROUPOFFSET(g) (GROUP(g) - GROUP('A')) |
|
#define VALIDGROUP(g) (GROUP(g) >= GROUP('A') && GROUP(g) <= GROUP('Z')) |
|
#define COMMANDS(g) (apigroups[GROUPOFFSET(g)].commands) |
|
#define DEFINEDGROUP(g) (ISPRIVGROUP(g) || COMMANDS(g) != NULL) |
|
|
|
struct APIGROUPS { |
|
// This becomes a string like: "|cmd1|cmd2|cmd3|" so it's quick to search |
|
char *commands; |
|
} apigroups['Z' - 'A' + 1]; // only A=0 to Z=25 (R: noprivs, W: allprivs) |
|
|
|
static struct IP4ACCESS *ipaccess = NULL; |
|
static int ips = 0; |
|
|
|
struct io_data { |
|
size_t siz; |
|
char *ptr; |
|
char *cur; |
|
bool sock; |
|
bool full; |
|
bool close; |
|
}; |
|
|
|
struct io_list { |
|
struct io_data *io_data; |
|
struct io_list *prev; |
|
struct io_list *next; |
|
}; |
|
|
|
static struct io_list *io_head = NULL; |
|
|
|
#define io_new(init) _io_new(init, false) |
|
#define sock_io_new() _io_new(SOCKBUFSIZ, true) |
|
|
|
static void io_reinit(struct io_data *io_data) |
|
{ |
|
io_data->cur = io_data->ptr; |
|
*(io_data->ptr) = '\0'; |
|
io_data->full = false; |
|
io_data->close = false; |
|
} |
|
|
|
static struct io_data *_io_new(size_t initial, bool socket_buf) |
|
{ |
|
struct io_data *io_data; |
|
struct io_list *io_list; |
|
|
|
io_data = malloc(sizeof(*io_data)); |
|
io_data->ptr = malloc(initial); |
|
io_data->siz = initial; |
|
io_data->sock = socket_buf; |
|
io_reinit(io_data); |
|
|
|
io_list = malloc(sizeof(*io_list)); |
|
|
|
io_list->io_data = io_data; |
|
|
|
if (io_head) { |
|
io_list->next = io_head; |
|
io_list->prev = io_head->prev; |
|
io_list->next->prev = io_list; |
|
io_list->prev->next = io_list; |
|
} else { |
|
io_list->prev = io_list; |
|
io_list->next = io_list; |
|
io_head = io_list; |
|
} |
|
|
|
return io_data; |
|
} |
|
|
|
static bool io_add(struct io_data *io_data, char *buf) |
|
{ |
|
size_t len, dif, tot; |
|
|
|
if (io_data->full) |
|
return false; |
|
|
|
len = strlen(buf); |
|
dif = io_data->cur - io_data->ptr; |
|
tot = len + 1 + dif; |
|
|
|
if (tot > io_data->siz) { |
|
size_t new = io_data->siz * 2; |
|
|
|
if (new < tot) |
|
new = tot * 2; |
|
|
|
if (io_data->sock) { |
|
if (new > SOCKBUFSIZ) { |
|
if (tot > SOCKBUFSIZ) { |
|
io_data->full = true; |
|
return false; |
|
} |
|
|
|
new = SOCKBUFSIZ; |
|
} |
|
} |
|
|
|
io_data->ptr = realloc(io_data->ptr, new); |
|
io_data->cur = io_data->ptr + dif; |
|
io_data->siz = new; |
|
} |
|
|
|
memcpy(io_data->cur, buf, len + 1); |
|
io_data->cur += len; |
|
|
|
return true; |
|
} |
|
|
|
static bool io_put(struct io_data *io_data, char *buf) |
|
{ |
|
io_reinit(io_data); |
|
return io_add(io_data, buf); |
|
} |
|
|
|
static void io_close(struct io_data *io_data) |
|
{ |
|
io_data->close = true; |
|
} |
|
|
|
static void io_free() |
|
{ |
|
struct io_list *io_list, *io_next; |
|
|
|
if (io_head) { |
|
io_list = io_head; |
|
do { |
|
io_next = io_list->next; |
|
|
|
free(io_list->io_data); |
|
free(io_list); |
|
|
|
io_list = io_next; |
|
} while (io_list != io_head); |
|
|
|
io_head = NULL; |
|
} |
|
} |
|
|
|
// This is only called when expected to be needed (rarely) |
|
// i.e. strings outside of the codes control (input from the user) |
|
static char *escape_string(char *str, bool isjson) |
|
{ |
|
char *buf, *ptr; |
|
int count; |
|
|
|
count = 0; |
|
for (ptr = str; *ptr; ptr++) { |
|
switch (*ptr) { |
|
case ',': |
|
case '|': |
|
case '=': |
|
if (!isjson) |
|
count++; |
|
break; |
|
case '"': |
|
if (isjson) |
|
count++; |
|
break; |
|
case '\\': |
|
count++; |
|
break; |
|
} |
|
} |
|
|
|
if (count == 0) |
|
return str; |
|
|
|
buf = malloc(strlen(str) + count + 1); |
|
if (unlikely(!buf)) |
|
quit(1, "Failed to malloc escape buf"); |
|
|
|
ptr = buf; |
|
while (*str) |
|
switch (*str) { |
|
case ',': |
|
case '|': |
|
case '=': |
|
if (!isjson) |
|
*(ptr++) = '\\'; |
|
*(ptr++) = *(str++); |
|
break; |
|
case '"': |
|
if (isjson) |
|
*(ptr++) = '\\'; |
|
*(ptr++) = *(str++); |
|
break; |
|
case '\\': |
|
*(ptr++) = '\\'; |
|
*(ptr++) = *(str++); |
|
break; |
|
default: |
|
*(ptr++) = *(str++); |
|
break; |
|
} |
|
|
|
*ptr = '\0'; |
|
|
|
return buf; |
|
} |
|
|
|
static struct api_data *api_add_extra(struct api_data *root, struct api_data *extra) |
|
{ |
|
struct api_data *tmp; |
|
|
|
if (root) { |
|
if (extra) { |
|
// extra tail |
|
tmp = extra->prev; |
|
|
|
// extra prev = root tail |
|
extra->prev = root->prev; |
|
|
|
// root tail next = extra |
|
root->prev->next = extra; |
|
|
|
// extra tail next = root |
|
tmp->next = root; |
|
|
|
// root prev = extra tail |
|
root->prev = tmp; |
|
} |
|
} else |
|
root = extra; |
|
|
|
return root; |
|
} |
|
|
|
static struct api_data *api_add_data_full(struct api_data *root, char *name, enum api_data_type type, void *data, bool copy_data) |
|
{ |
|
struct api_data *api_data; |
|
|
|
api_data = (struct api_data *)malloc(sizeof(struct api_data)); |
|
|
|
api_data->name = strdup(name); |
|
api_data->type = type; |
|
|
|
if (root == NULL) { |
|
root = api_data; |
|
root->prev = root; |
|
root->next = root; |
|
} |
|
else { |
|
api_data->prev = root->prev; |
|
root->prev = api_data; |
|
api_data->next = root; |
|
api_data->prev->next = api_data; |
|
} |
|
|
|
api_data->data_was_malloc = copy_data; |
|
|
|
// Avoid crashing on bad data |
|
if (data == NULL) { |
|
api_data->type = type = API_CONST; |
|
data = (void *)NULLSTR; |
|
api_data->data_was_malloc = copy_data = false; |
|
} |
|
|
|
if (!copy_data) |
|
api_data->data = data; |
|
else |
|
switch(type) { |
|
case API_ESCAPE: |
|
case API_STRING: |
|
case API_CONST: |
|
api_data->data = (void *)malloc(strlen((char *)data) + 1); |
|
strcpy((char*)(api_data->data), (char *)data); |
|
break; |
|
case API_INT: |
|
api_data->data = (void *)malloc(sizeof(int)); |
|
*((int *)(api_data->data)) = *((int *)data); |
|
break; |
|
case API_UINT: |
|
api_data->data = (void *)malloc(sizeof(unsigned int)); |
|
*((unsigned int *)(api_data->data)) = *((unsigned int *)data); |
|
break; |
|
case API_UINT32: |
|
api_data->data = (void *)malloc(sizeof(uint32_t)); |
|
*((uint32_t *)(api_data->data)) = *((uint32_t *)data); |
|
break; |
|
case API_UINT64: |
|
api_data->data = (void *)malloc(sizeof(uint64_t)); |
|
*((uint64_t *)(api_data->data)) = *((uint64_t *)data); |
|
break; |
|
case API_DOUBLE: |
|
case API_ELAPSED: |
|
case API_MHS: |
|
case API_MHTOTAL: |
|
case API_UTILITY: |
|
case API_FREQ: |
|
case API_HS: |
|
case API_DIFF: |
|
case API_PERCENT: |
|
api_data->data = (void *)malloc(sizeof(double)); |
|
*((double *)(api_data->data)) = *((double *)data); |
|
break; |
|
case API_BOOL: |
|
api_data->data = (void *)malloc(sizeof(bool)); |
|
*((bool *)(api_data->data)) = *((bool *)data); |
|
break; |
|
case API_TIMEVAL: |
|
api_data->data = (void *)malloc(sizeof(struct timeval)); |
|
memcpy(api_data->data, data, sizeof(struct timeval)); |
|
break; |
|
case API_TIME: |
|
api_data->data = (void *)malloc(sizeof(time_t)); |
|
*(time_t *)(api_data->data) = *((time_t *)data); |
|
break; |
|
case API_VOLTS: |
|
case API_TEMP: |
|
api_data->data = (void *)malloc(sizeof(float)); |
|
*((float *)(api_data->data)) = *((float *)data); |
|
break; |
|
default: |
|
applog(LOG_ERR, "API: unknown1 data type %d ignored", type); |
|
api_data->type = API_STRING; |
|
api_data->data_was_malloc = false; |
|
api_data->data = (void *)UNKNOWN; |
|
break; |
|
} |
|
|
|
return root; |
|
} |
|
|
|
struct api_data *api_add_escape(struct api_data *root, char *name, char *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_ESCAPE, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_string(struct api_data *root, char *name, char *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_STRING, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_const(struct api_data *root, char *name, const char *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_CONST, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_int(struct api_data *root, char *name, int *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_INT, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_uint(struct api_data *root, char *name, unsigned int *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_UINT, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_uint32(struct api_data *root, char *name, uint32_t *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_UINT32, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_uint64(struct api_data *root, char *name, uint64_t *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_UINT64, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_double(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_DOUBLE, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_elapsed(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_ELAPSED, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_bool(struct api_data *root, char *name, bool *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_BOOL, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_timeval(struct api_data *root, char *name, struct timeval *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_TIMEVAL, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_time(struct api_data *root, char *name, time_t *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_TIME, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_mhs(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_MHS, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_mhtotal(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_MHTOTAL, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_temp(struct api_data *root, char *name, float *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_TEMP, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_utility(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_UTILITY, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_freq(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_FREQ, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_volts(struct api_data *root, char *name, float *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_VOLTS, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_hs(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_HS, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_diff(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_DIFF, (void *)data, copy_data); |
|
} |
|
|
|
struct api_data *api_add_percent(struct api_data *root, char *name, double *data, bool copy_data) |
|
{ |
|
return api_add_data_full(root, name, API_PERCENT, (void *)data, copy_data); |
|
} |
|
|
|
static struct api_data *print_data(struct api_data *root, char *buf, bool isjson, bool precom) |
|
{ |
|
struct api_data *tmp; |
|
bool first = true; |
|
char *original, *escape; |
|
char *quote; |
|
|
|
*buf = '\0'; |
|
|
|
if (precom) { |
|
*(buf++) = *COMMA; |
|
*buf = '\0'; |
|
} |
|
|
|
if (isjson) { |
|
strcpy(buf, JSON0); |
|
buf = strchr(buf, '\0'); |
|
quote = JSON1; |
|
} else |
|
quote = (char *)BLANK; |
|
|
|
while (root) { |
|
if (!first) |
|
*(buf++) = *COMMA; |
|
else |
|
first = false; |
|
|
|
sprintf(buf, "%s%s%s%s", quote, root->name, quote, isjson ? ":" : "="); |
|
|
|
buf = strchr(buf, '\0'); |
|
|
|
switch(root->type) { |
|
case API_STRING: |
|
case API_CONST: |
|
sprintf(buf, "%s%s%s", quote, (char *)(root->data), quote); |
|
break; |
|
case API_ESCAPE: |
|
original = (char *)(root->data); |
|
escape = escape_string((char *)(root->data), isjson); |
|
sprintf(buf, "%s%s%s", quote, escape, quote); |
|
if (escape != original) |
|
free(escape); |
|
break; |
|
case API_INT: |
|
sprintf(buf, "%d", *((int *)(root->data))); |
|
break; |
|
case API_UINT: |
|
sprintf(buf, "%u", *((unsigned int *)(root->data))); |
|
break; |
|
case API_UINT32: |
|
sprintf(buf, "%"PRIu32, *((uint32_t *)(root->data))); |
|
break; |
|
case API_UINT64: |
|
sprintf(buf, "%"PRIu64, *((uint64_t *)(root->data))); |
|
break; |
|
case API_TIME: |
|
sprintf(buf, "%lu", *((unsigned long *)(root->data))); |
|
break; |
|
case API_DOUBLE: |
|
sprintf(buf, "%f", *((double *)(root->data))); |
|
break; |
|
case API_ELAPSED: |
|
sprintf(buf, "%.0f", *((double *)(root->data))); |
|
break; |
|
case API_UTILITY: |
|
case API_FREQ: |
|
case API_MHS: |
|
sprintf(buf, "%.2f", *((double *)(root->data))); |
|
break; |
|
case API_VOLTS: |
|
sprintf(buf, "%.3f", *((float *)(root->data))); |
|
break; |
|
case API_MHTOTAL: |
|
sprintf(buf, "%.4f", *((double *)(root->data))); |
|
break; |
|
case API_HS: |
|
sprintf(buf, "%.15f", *((double *)(root->data))); |
|
break; |
|
case API_DIFF: |
|
sprintf(buf, "%.8f", *((double *)(root->data))); |
|
break; |
|
case API_BOOL: |
|
sprintf(buf, "%s", *((bool *)(root->data)) ? TRUESTR : FALSESTR); |
|
break; |
|
case API_TIMEVAL: |
|
sprintf(buf, "%ld.%06ld", |
|
((struct timeval *)(root->data))->tv_sec, |
|
((struct timeval *)(root->data))->tv_usec); |
|
break; |
|
case API_TEMP: |
|
sprintf(buf, "%.2f", *((float *)(root->data))); |
|
break; |
|
case API_PERCENT: |
|
sprintf(buf, "%.4f", *((double *)(root->data)) * 100.0); |
|
break; |
|
default: |
|
applog(LOG_ERR, "API: unknown2 data type %d ignored", root->type); |
|
sprintf(buf, "%s%s%s", quote, UNKNOWN, quote); |
|
break; |
|
} |
|
|
|
buf = strchr(buf, '\0'); |
|
|
|
free(root->name); |
|
if (root->data_was_malloc) |
|
free(root->data); |
|
|
|
if (root->next == root) { |
|
free(root); |
|
root = NULL; |
|
} else { |
|
tmp = root; |
|
root = tmp->next; |
|
root->prev = tmp->prev; |
|
root->prev->next = root; |
|
free(tmp); |
|
} |
|
} |
|
|
|
strcpy(buf, isjson ? JSON5 : SEPSTR); |
|
|
|
return root; |
|
} |
|
|
|
#define DRIVER_COUNT_DRV(X) if (devices[i]->drv->drv_id == DRIVER_##X) \ |
|
count++; |
|
|
|
#ifdef HAVE_AN_ASIC |
|
static int numascs(void) |
|
{ |
|
int count = 0; |
|
int i; |
|
|
|
rd_lock(&devices_lock); |
|
for (i = 0; i < total_devices; i++) { |
|
ASIC_PARSE_COMMANDS(DRIVER_COUNT_DRV) |
|
} |
|
rd_unlock(&devices_lock); |
|
return count; |
|
} |
|
|
|
static int ascdevice(int ascid) |
|
{ |
|
int count = 0; |
|
int i; |
|
|
|
rd_lock(&devices_lock); |
|
for (i = 0; i < total_devices; i++) { |
|
ASIC_PARSE_COMMANDS(DRIVER_COUNT_DRV) |
|
if (count == (ascid + 1)) |
|
goto foundit; |
|
} |
|
|
|
rd_unlock(&devices_lock); |
|
return -1; |
|
|
|
foundit: |
|
|
|
rd_unlock(&devices_lock); |
|
return i; |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
static int numpgas(void) |
|
{ |
|
int count = 0; |
|
int i; |
|
|
|
rd_lock(&devices_lock); |
|
for (i = 0; i < total_devices; i++) { |
|
FPGA_PARSE_COMMANDS(DRIVER_COUNT_DRV) |
|
} |
|
rd_unlock(&devices_lock); |
|
return count; |
|
} |
|
|
|
static int pgadevice(int pgaid) |
|
{ |
|
int count = 0; |
|
int i; |
|
|
|
rd_lock(&devices_lock); |
|
for (i = 0; i < total_devices; i++) { |
|
FPGA_PARSE_COMMANDS(DRIVER_COUNT_DRV) |
|
if (count == (pgaid + 1)) |
|
goto foundit; |
|
} |
|
|
|
rd_unlock(&devices_lock); |
|
return -1; |
|
|
|
foundit: |
|
|
|
rd_unlock(&devices_lock); |
|
return i; |
|
} |
|
#endif |
|
|
|
// All replies (except BYE and RESTART) start with a message |
|
// thus for JSON, message() inserts JSON_START at the front |
|
// and send_result() adds JSON_END at the end |
|
static void message(struct io_data *io_data, int messageid, int paramid, char *param2, bool isjson) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
char buf2[TMPBUFSIZ]; |
|
char severity[2]; |
|
#ifdef HAVE_AN_ASIC |
|
int asc; |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
int pga; |
|
#endif |
|
int i; |
|
|
|
io_reinit(io_data); |
|
|
|
if (isjson) |
|
io_put(io_data, JSON_START JSON_STATUS); |
|
|
|
for (i = 0; codes[i].severity != SEVERITY_FAIL; i++) { |
|
if (codes[i].code == messageid) { |
|
switch (codes[i].severity) { |
|
case SEVERITY_WARN: |
|
severity[0] = 'W'; |
|
break; |
|
case SEVERITY_INFO: |
|
severity[0] = 'I'; |
|
break; |
|
case SEVERITY_SUCC: |
|
severity[0] = 'S'; |
|
break; |
|
case SEVERITY_ERR: |
|
default: |
|
severity[0] = 'E'; |
|
break; |
|
} |
|
severity[1] = '\0'; |
|
|
|
switch(codes[i].params) { |
|
case PARAM_GPU: |
|
case PARAM_PGA: |
|
case PARAM_ASC: |
|
case PARAM_PID: |
|
case PARAM_INT: |
|
sprintf(buf, codes[i].description, paramid); |
|
break; |
|
case PARAM_POOL: |
|
sprintf(buf, codes[i].description, paramid, pools[paramid]->rpc_url); |
|
break; |
|
#ifdef HAVE_OPENCL |
|
case PARAM_GPUMAX: |
|
sprintf(buf, codes[i].description, paramid, nDevs - 1); |
|
break; |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
case PARAM_PGAMAX: |
|
pga = numpgas(); |
|
sprintf(buf, codes[i].description, paramid, pga - 1); |
|
break; |
|
#endif |
|
#ifdef HAVE_AN_ASIC |
|
case PARAM_ASCMAX: |
|
asc = numascs(); |
|
sprintf(buf, codes[i].description, paramid, asc - 1); |
|
break; |
|
#endif |
|
case PARAM_PMAX: |
|
sprintf(buf, codes[i].description, total_pools); |
|
break; |
|
case PARAM_POOLMAX: |
|
sprintf(buf, codes[i].description, paramid, total_pools - 1); |
|
break; |
|
case PARAM_DMAX: |
|
#ifdef HAVE_AN_ASIC |
|
asc = numascs(); |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
pga = numpgas(); |
|
#endif |
|
|
|
sprintf(buf, codes[i].description |
|
#ifdef HAVE_OPENCL |
|
, nDevs |
|
#endif |
|
#ifdef HAVE_AN_ASIC |
|
, asc |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
, pga |
|
#endif |
|
); |
|
break; |
|
case PARAM_CMD: |
|
sprintf(buf, codes[i].description, JSON_COMMAND); |
|
break; |
|
case PARAM_STR: |
|
sprintf(buf, codes[i].description, param2); |
|
break; |
|
case PARAM_BOTH: |
|
sprintf(buf, codes[i].description, paramid, param2); |
|
break; |
|
case PARAM_BOOL: |
|
sprintf(buf, codes[i].description, paramid ? TRUESTR : FALSESTR); |
|
break; |
|
case PARAM_SET: |
|
sprintf(buf, codes[i].description, param2, paramid); |
|
break; |
|
case PARAM_NONE: |
|
default: |
|
strcpy(buf, codes[i].description); |
|
} |
|
|
|
root = api_add_string(root, _STATUS, severity, false); |
|
root = api_add_time(root, "When", &when, false); |
|
root = api_add_int(root, "Code", &messageid, false); |
|
root = api_add_escape(root, "Msg", buf, false); |
|
root = api_add_escape(root, "Description", opt_api_description, false); |
|
|
|
root = print_data(root, buf2, isjson, false); |
|
io_add(io_data, buf2); |
|
if (isjson) |
|
io_add(io_data, JSON_CLOSE); |
|
return; |
|
} |
|
} |
|
|
|
root = api_add_string(root, _STATUS, "F", false); |
|
root = api_add_time(root, "When", &when, false); |
|
int id = -1; |
|
root = api_add_int(root, "Code", &id, false); |
|
sprintf(buf, "%d", messageid); |
|
root = api_add_escape(root, "Msg", buf, false); |
|
root = api_add_escape(root, "Description", opt_api_description, false); |
|
|
|
root = print_data(root, buf2, isjson, false); |
|
io_add(io_data, buf2); |
|
if (isjson) |
|
io_add(io_data, JSON_CLOSE); |
|
} |
|
|
|
static void apiversion(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
|
|
message(io_data, MSG_VERSION, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_VERSION : _VERSION COMSTR); |
|
|
|
root = api_add_string(root, "CGMiner", VERSION, false); |
|
root = api_add_const(root, "API", APIVERSION, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void minerconfig(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
int gpucount = 0; |
|
int asccount = 0; |
|
int pgacount = 0; |
|
char *adlinuse = (char *)NO; |
|
#ifdef HAVE_ADL |
|
const char *adl = YES; |
|
int i; |
|
|
|
for (i = 0; i < nDevs; i++) { |
|
if (gpus[i].has_adl) { |
|
adlinuse = (char *)YES; |
|
break; |
|
} |
|
} |
|
#else |
|
const char *adl = NO; |
|
#endif |
|
|
|
#ifdef HAVE_OPENCL |
|
gpucount = nDevs; |
|
#endif |
|
|
|
#ifdef HAVE_AN_ASIC |
|
asccount = numascs(); |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
pgacount = numpgas(); |
|
#endif |
|
|
|
message(io_data, MSG_MINECONFIG, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_MINECONFIG : _MINECONFIG COMSTR); |
|
|
|
root = api_add_int(root, "GPU Count", &gpucount, false); |
|
root = api_add_int(root, "ASC Count", &asccount, false); |
|
root = api_add_int(root, "PGA Count", &pgacount, false); |
|
root = api_add_int(root, "Pool Count", &total_pools, false); |
|
root = api_add_const(root, "ADL", (char *)adl, false); |
|
root = api_add_string(root, "ADL in use", adlinuse, false); |
|
root = api_add_const(root, "Strategy", strategies[pool_strategy].s, false); |
|
root = api_add_int(root, "Log Interval", &opt_log_interval, false); |
|
root = api_add_const(root, "Device Code", DEVICECODE, false); |
|
root = api_add_const(root, "OS", OSINFO, false); |
|
root = api_add_bool(root, "Failover-Only", &opt_fail_only, false); |
|
root = api_add_int(root, "ScanTime", &opt_scantime, false); |
|
root = api_add_int(root, "Queue", &opt_queue, false); |
|
root = api_add_int(root, "Expiry", &opt_expiry, false); |
|
#ifdef USE_USBUTILS |
|
if (hotplug_time == 0) |
|
root = api_add_const(root, "Hotplug", DISABLED, false); |
|
else |
|
root = api_add_int(root, "Hotplug", &hotplug_time, false); |
|
#else |
|
root = api_add_const(root, "Hotplug", NONE, false); |
|
#endif |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
#if defined(HAVE_OPENCL) || defined(HAVE_AN_FPGA) || defined(HAVE_AN_ASIC) |
|
static const char *status2str(enum alive status) |
|
{ |
|
switch (status) { |
|
case LIFE_WELL: |
|
return ALIVE; |
|
case LIFE_SICK: |
|
return SICK; |
|
case LIFE_DEAD: |
|
return DEAD; |
|
case LIFE_NOSTART: |
|
return NOSTART; |
|
case LIFE_INIT: |
|
return INIT; |
|
default: |
|
return UNKNOWN; |
|
} |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_OPENCL |
|
static void gpustatus(struct io_data *io_data, int gpu, bool isjson, bool precom) |
|
{ |
|
struct api_data *root = NULL; |
|
char intensity[20]; |
|
char buf[TMPBUFSIZ]; |
|
char *enabled; |
|
char *status; |
|
float gt, gv; |
|
int ga, gf, gp, gc, gm, pt; |
|
|
|
if (gpu >= 0 && gpu < nDevs) { |
|
struct cgpu_info *cgpu = &gpus[gpu]; |
|
|
|
cgpu->utility = cgpu->accepted / ( total_secs ? total_secs : 1 ) * 60; |
|
|
|
#ifdef HAVE_ADL |
|
if (!gpu_stats(gpu, >, &gc, &gm, &gv, &ga, &gf, &gp, &pt)) |
|
#endif |
|
gt = gv = gm = gc = ga = gf = gp = pt = 0; |
|
|
|
if (cgpu->deven != DEV_DISABLED) |
|
enabled = (char *)YES; |
|
else |
|
enabled = (char *)NO; |
|
|
|
status = (char *)status2str(cgpu->status); |
|
|
|
if (cgpu->dynamic) |
|
strcpy(intensity, DYNAMIC); |
|
else |
|
sprintf(intensity, "%d", cgpu->intensity); |
|
|
|
root = api_add_int(root, "GPU", &gpu, false); |
|
root = api_add_string(root, "Enabled", enabled, false); |
|
root = api_add_string(root, "Status", status, false); |
|
root = api_add_temp(root, "Temperature", >, false); |
|
root = api_add_int(root, "Fan Speed", &gf, false); |
|
root = api_add_int(root, "Fan Percent", &gp, false); |
|
root = api_add_int(root, "GPU Clock", &gc, false); |
|
root = api_add_int(root, "Memory Clock", &gm, false); |
|
root = api_add_volts(root, "GPU Voltage", &gv, false); |
|
root = api_add_int(root, "GPU Activity", &ga, false); |
|
root = api_add_int(root, "Powertune", &pt, false); |
|
double mhs = cgpu->total_mhashes / total_secs; |
|
root = api_add_mhs(root, "MHS av", &mhs, false); |
|
char mhsname[27]; |
|
sprintf(mhsname, "MHS %ds", opt_log_interval); |
|
root = api_add_mhs(root, mhsname, &(cgpu->rolling), false); |
|
root = api_add_int(root, "Accepted", &(cgpu->accepted), false); |
|
root = api_add_int(root, "Rejected", &(cgpu->rejected), false); |
|
root = api_add_int(root, "Hardware Errors", &(cgpu->hw_errors), false); |
|
root = api_add_utility(root, "Utility", &(cgpu->utility), false); |
|
root = api_add_string(root, "Intensity", intensity, false); |
|
int last_share_pool = cgpu->last_share_pool_time > 0 ? |
|
cgpu->last_share_pool : -1; |
|
root = api_add_int(root, "Last Share Pool", &last_share_pool, false); |
|
root = api_add_time(root, "Last Share Time", &(cgpu->last_share_pool_time), false); |
|
root = api_add_mhtotal(root, "Total MH", &(cgpu->total_mhashes), false); |
|
root = api_add_int(root, "Diff1 Work", &(cgpu->diff1), false); |
|
root = api_add_diff(root, "Difficulty Accepted", &(cgpu->diff_accepted), false); |
|
root = api_add_diff(root, "Difficulty Rejected", &(cgpu->diff_rejected), false); |
|
root = api_add_diff(root, "Last Share Difficulty", &(cgpu->last_share_diff), false); |
|
root = api_add_time(root, "Last Valid Work", &(cgpu->last_device_valid_work), false); |
|
double hwp = (cgpu->hw_errors + cgpu->diff1) ? |
|
(double)(cgpu->hw_errors) / (double)(cgpu->hw_errors + cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Hardware%", &hwp, false); |
|
double rejp = cgpu->diff1 ? |
|
(double)(cgpu->diff_rejected) / (double)(cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Rejected%", &rejp, false); |
|
|
|
root = print_data(root, buf, isjson, precom); |
|
io_add(io_data, buf); |
|
} |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_AN_ASIC |
|
static void ascstatus(struct io_data *io_data, int asc, bool isjson, bool precom) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
char *enabled; |
|
char *status; |
|
int numasc = numascs(); |
|
|
|
if (numasc > 0 && asc >= 0 && asc < numasc) { |
|
int dev = ascdevice(asc); |
|
if (dev < 0) // Should never happen |
|
return; |
|
|
|
struct cgpu_info *cgpu = get_devices(dev); |
|
float temp = cgpu->temp; |
|
struct timeval now; |
|
double dev_runtime; |
|
|
|
if (cgpu->dev_start_tv.tv_sec == 0) |
|
dev_runtime = total_secs; |
|
else { |
|
cgtime(&now); |
|
dev_runtime = tdiff(&now, &(cgpu->dev_start_tv)); |
|
} |
|
|
|
if (dev_runtime < 1.0) |
|
dev_runtime = 1.0; |
|
|
|
cgpu->utility = cgpu->accepted / dev_runtime * 60; |
|
|
|
if (cgpu->deven != DEV_DISABLED) |
|
enabled = (char *)YES; |
|
else |
|
enabled = (char *)NO; |
|
|
|
status = (char *)status2str(cgpu->status); |
|
|
|
root = api_add_int(root, "ASC", &asc, false); |
|
root = api_add_string(root, "Name", cgpu->drv->name, false); |
|
root = api_add_int(root, "ID", &(cgpu->device_id), false); |
|
root = api_add_string(root, "Enabled", enabled, false); |
|
root = api_add_string(root, "Status", status, false); |
|
root = api_add_temp(root, "Temperature", &temp, false); |
|
double mhs = cgpu->total_mhashes / dev_runtime; |
|
root = api_add_mhs(root, "MHS av", &mhs, false); |
|
char mhsname[27]; |
|
sprintf(mhsname, "MHS %ds", opt_log_interval); |
|
root = api_add_mhs(root, mhsname, &(cgpu->rolling), false); |
|
root = api_add_int(root, "Accepted", &(cgpu->accepted), false); |
|
root = api_add_int(root, "Rejected", &(cgpu->rejected), false); |
|
root = api_add_int(root, "Hardware Errors", &(cgpu->hw_errors), false); |
|
root = api_add_utility(root, "Utility", &(cgpu->utility), false); |
|
int last_share_pool = cgpu->last_share_pool_time > 0 ? |
|
cgpu->last_share_pool : -1; |
|
root = api_add_int(root, "Last Share Pool", &last_share_pool, false); |
|
root = api_add_time(root, "Last Share Time", &(cgpu->last_share_pool_time), false); |
|
root = api_add_mhtotal(root, "Total MH", &(cgpu->total_mhashes), false); |
|
root = api_add_int(root, "Diff1 Work", &(cgpu->diff1), false); |
|
root = api_add_diff(root, "Difficulty Accepted", &(cgpu->diff_accepted), false); |
|
root = api_add_diff(root, "Difficulty Rejected", &(cgpu->diff_rejected), false); |
|
root = api_add_diff(root, "Last Share Difficulty", &(cgpu->last_share_diff), false); |
|
#ifdef USE_USBUTILS |
|
root = api_add_bool(root, "No Device", &(cgpu->usbinfo.nodev), false); |
|
#endif |
|
root = api_add_time(root, "Last Valid Work", &(cgpu->last_device_valid_work), false); |
|
double hwp = (cgpu->hw_errors + cgpu->diff1) ? |
|
(double)(cgpu->hw_errors) / (double)(cgpu->hw_errors + cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Hardware%", &hwp, false); |
|
double rejp = cgpu->diff1 ? |
|
(double)(cgpu->diff_rejected) / (double)(cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Rejected%", &rejp, false); |
|
|
|
root = print_data(root, buf, isjson, precom); |
|
io_add(io_data, buf); |
|
} |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
static void pgastatus(struct io_data *io_data, int pga, bool isjson, bool precom) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
char *enabled; |
|
char *status; |
|
int numpga = numpgas(); |
|
|
|
if (numpga > 0 && pga >= 0 && pga < numpga) { |
|
int dev = pgadevice(pga); |
|
if (dev < 0) // Should never happen |
|
return; |
|
|
|
struct cgpu_info *cgpu = get_devices(dev); |
|
double frequency = 0; |
|
float temp = cgpu->temp; |
|
struct timeval now; |
|
double dev_runtime; |
|
|
|
if (cgpu->dev_start_tv.tv_sec == 0) |
|
dev_runtime = total_secs; |
|
else { |
|
cgtime(&now); |
|
dev_runtime = tdiff(&now, &(cgpu->dev_start_tv)); |
|
} |
|
|
|
if (dev_runtime < 1.0) |
|
dev_runtime = 1.0; |
|
|
|
#ifdef USE_MODMINER |
|
if (cgpu->drv->drv_id == DRIVER_modminer) |
|
frequency = cgpu->clock; |
|
#endif |
|
|
|
cgpu->utility = cgpu->accepted / dev_runtime * 60; |
|
|
|
if (cgpu->deven != DEV_DISABLED) |
|
enabled = (char *)YES; |
|
else |
|
enabled = (char *)NO; |
|
|
|
status = (char *)status2str(cgpu->status); |
|
|
|
root = api_add_int(root, "PGA", &pga, false); |
|
root = api_add_string(root, "Name", cgpu->drv->name, false); |
|
root = api_add_int(root, "ID", &(cgpu->device_id), false); |
|
root = api_add_string(root, "Enabled", enabled, false); |
|
root = api_add_string(root, "Status", status, false); |
|
root = api_add_temp(root, "Temperature", &temp, false); |
|
double mhs = cgpu->total_mhashes / dev_runtime; |
|
root = api_add_mhs(root, "MHS av", &mhs, false); |
|
char mhsname[27]; |
|
sprintf(mhsname, "MHS %ds", opt_log_interval); |
|
root = api_add_mhs(root, mhsname, &(cgpu->rolling), false); |
|
root = api_add_int(root, "Accepted", &(cgpu->accepted), false); |
|
root = api_add_int(root, "Rejected", &(cgpu->rejected), false); |
|
root = api_add_int(root, "Hardware Errors", &(cgpu->hw_errors), false); |
|
root = api_add_utility(root, "Utility", &(cgpu->utility), false); |
|
int last_share_pool = cgpu->last_share_pool_time > 0 ? |
|
cgpu->last_share_pool : -1; |
|
root = api_add_int(root, "Last Share Pool", &last_share_pool, false); |
|
root = api_add_time(root, "Last Share Time", &(cgpu->last_share_pool_time), false); |
|
root = api_add_mhtotal(root, "Total MH", &(cgpu->total_mhashes), false); |
|
root = api_add_freq(root, "Frequency", &frequency, false); |
|
root = api_add_int(root, "Diff1 Work", &(cgpu->diff1), false); |
|
root = api_add_diff(root, "Difficulty Accepted", &(cgpu->diff_accepted), false); |
|
root = api_add_diff(root, "Difficulty Rejected", &(cgpu->diff_rejected), false); |
|
root = api_add_diff(root, "Last Share Difficulty", &(cgpu->last_share_diff), false); |
|
#ifdef USE_USBUTILS |
|
root = api_add_bool(root, "No Device", &(cgpu->usbinfo.nodev), false); |
|
#endif |
|
root = api_add_time(root, "Last Valid Work", &(cgpu->last_device_valid_work), false); |
|
double hwp = (cgpu->hw_errors + cgpu->diff1) ? |
|
(double)(cgpu->hw_errors) / (double)(cgpu->hw_errors + cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Hardware%", &hwp, false); |
|
double rejp = cgpu->diff1 ? |
|
(double)(cgpu->diff_rejected) / (double)(cgpu->diff1) : 0; |
|
root = api_add_percent(root, "Device Rejected%", &rejp, false); |
|
|
|
root = print_data(root, buf, isjson, precom); |
|
io_add(io_data, buf); |
|
} |
|
} |
|
#endif |
|
|
|
static void devstatus(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
bool io_open = false; |
|
int devcount = 0; |
|
int numgpu = 0; |
|
int numasc = 0; |
|
int numpga = 0; |
|
int i; |
|
|
|
#ifdef HAVE_OPENCL |
|
numgpu = nDevs; |
|
#endif |
|
|
|
#ifdef HAVE_AN_ASIC |
|
numasc = numascs(); |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
numpga = numpgas(); |
|
#endif |
|
|
|
if (numgpu == 0 && numpga == 0 && numasc == 0) { |
|
message(io_data, MSG_NODEVS, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
|
|
message(io_data, MSG_DEVS, 0, NULL, isjson); |
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_DEVS); |
|
|
|
#ifdef HAVE_OPENCL |
|
for (i = 0; i < nDevs; i++) { |
|
gpustatus(io_data, i, isjson, isjson && devcount > 0); |
|
|
|
devcount++; |
|
} |
|
#endif |
|
#ifdef HAVE_AN_ASIC |
|
if (numasc > 0) { |
|
for (i = 0; i < numasc; i++) { |
|
ascstatus(io_data, i, isjson, isjson && devcount > 0); |
|
|
|
devcount++; |
|
} |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
if (numpga > 0) { |
|
for (i = 0; i < numpga; i++) { |
|
pgastatus(io_data, i, isjson, isjson && devcount > 0); |
|
|
|
devcount++; |
|
} |
|
} |
|
#endif |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
#ifdef HAVE_OPENCL |
|
static void gpudev(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
bool io_open = false; |
|
int id; |
|
|
|
if (nDevs == 0) { |
|
message(io_data, MSG_GPUNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= nDevs) { |
|
message(io_data, MSG_INVGPU, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_GPUDEV, id, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_GPU); |
|
|
|
gpustatus(io_data, id, isjson, false); |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
#endif |
|
|
|
#ifdef HAVE_AN_FPGA |
|
static void pgadev(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
bool io_open = false; |
|
int numpga = numpgas(); |
|
int id; |
|
|
|
if (numpga == 0) { |
|
message(io_data, MSG_PGANON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numpga) { |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_PGADEV, id, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_PGA); |
|
|
|
pgastatus(io_data, id, isjson, false); |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void pgaenable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
int numpga = numpgas(); |
|
struct thr_info *thr; |
|
int pga; |
|
int id; |
|
int i; |
|
|
|
if (numpga == 0) { |
|
message(io_data, MSG_PGANON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numpga) { |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = pgadevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
|
|
applog(LOG_DEBUG, "API: request to pgaenable pgaid %d device %d %s%u", |
|
id, dev, cgpu->drv->name, cgpu->device_id); |
|
|
|
if (cgpu->deven != DEV_DISABLED) { |
|
message(io_data, MSG_PGALRENA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
#if 0 /* A DISABLED device wont change status FIXME: should disabling make it WELL? */ |
|
if (cgpu->status != LIFE_WELL) { |
|
message(io_data, MSG_PGAUNW, id, NULL, isjson); |
|
return; |
|
} |
|
#endif |
|
|
|
#ifdef USE_USBUTILS |
|
if (cgpu->usbinfo.nodev) { |
|
message(io_data, MSG_PGAUSBNODEV, id, NULL, isjson); |
|
return; |
|
} |
|
#endif |
|
|
|
for (i = 0; i < mining_threads; i++) { |
|
thr = get_thread(i); |
|
pga = thr->cgpu->cgminer_id; |
|
if (pga == dev) { |
|
cgpu->deven = DEV_ENABLED; |
|
applog(LOG_DEBUG, "API: Pushing sem post to thread %d", thr->id); |
|
cgsem_post(&thr->sem); |
|
} |
|
} |
|
|
|
message(io_data, MSG_PGAENA, id, NULL, isjson); |
|
} |
|
|
|
static void pgadisable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
int numpga = numpgas(); |
|
int id; |
|
|
|
if (numpga == 0) { |
|
message(io_data, MSG_PGANON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numpga) { |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = pgadevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
|
|
applog(LOG_DEBUG, "API: request to pgadisable pgaid %d device %d %s%u", |
|
id, dev, cgpu->drv->name, cgpu->device_id); |
|
|
|
if (cgpu->deven == DEV_DISABLED) { |
|
message(io_data, MSG_PGALRDIS, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu->deven = DEV_DISABLED; |
|
|
|
message(io_data, MSG_PGADIS, id, NULL, isjson); |
|
} |
|
|
|
static void pgaidentify(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
struct device_drv *drv; |
|
int numpga = numpgas(); |
|
int id; |
|
|
|
if (numpga == 0) { |
|
message(io_data, MSG_PGANON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numpga) { |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = pgadevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
drv = cgpu->drv; |
|
|
|
if (!drv->identify_device) |
|
message(io_data, MSG_PGANOID, id, NULL, isjson); |
|
else { |
|
drv->identify_device(cgpu); |
|
message(io_data, MSG_PGAIDENT, id, NULL, isjson); |
|
} |
|
} |
|
#endif |
|
|
|
static void poolstatus(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open = false; |
|
char *status, *lp; |
|
int i; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_POOL, 0, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_POOLS); |
|
|
|
for (i = 0; i < total_pools; i++) { |
|
struct pool *pool = pools[i]; |
|
|
|
if (pool->removed) |
|
continue; |
|
|
|
switch (pool->enabled) { |
|
case POOL_DISABLED: |
|
status = (char *)DISABLED; |
|
break; |
|
case POOL_REJECTING: |
|
status = (char *)REJECTING; |
|
break; |
|
case POOL_ENABLED: |
|
if (pool->idle) |
|
status = (char *)DEAD; |
|
else |
|
status = (char *)ALIVE; |
|
break; |
|
default: |
|
status = (char *)UNKNOWN; |
|
break; |
|
} |
|
|
|
if (pool->hdr_path) |
|
lp = (char *)YES; |
|
else |
|
lp = (char *)NO; |
|
|
|
root = api_add_int(root, "POOL", &i, false); |
|
root = api_add_escape(root, "URL", pool->rpc_url, false); |
|
root = api_add_string(root, "Status", status, false); |
|
root = api_add_int(root, "Priority", &(pool->prio), false); |
|
root = api_add_int(root, "Quota", &pool->quota, false); |
|
root = api_add_string(root, "Long Poll", lp, false); |
|
root = api_add_uint(root, "Getworks", &(pool->getwork_requested), false); |
|
root = api_add_int(root, "Accepted", &(pool->accepted), false); |
|
root = api_add_int(root, "Rejected", &(pool->rejected), false); |
|
root = api_add_uint(root, "Discarded", &(pool->discarded_work), false); |
|
root = api_add_uint(root, "Stale", &(pool->stale_shares), false); |
|
root = api_add_uint(root, "Get Failures", &(pool->getfail_occasions), false); |
|
root = api_add_uint(root, "Remote Failures", &(pool->remotefail_occasions), false); |
|
root = api_add_escape(root, "User", pool->rpc_user, false); |
|
root = api_add_time(root, "Last Share Time", &(pool->last_share_time), false); |
|
root = api_add_int(root, "Diff1 Shares", &(pool->diff1), false); |
|
if (pool->rpc_proxy) { |
|
root = api_add_const(root, "Proxy Type", proxytype(pool->rpc_proxytype), false); |
|
root = api_add_escape(root, "Proxy", pool->rpc_proxy, false); |
|
} else { |
|
root = api_add_const(root, "Proxy Type", BLANK, false); |
|
root = api_add_const(root, "Proxy", BLANK, false); |
|
} |
|
root = api_add_diff(root, "Difficulty Accepted", &(pool->diff_accepted), false); |
|
root = api_add_diff(root, "Difficulty Rejected", &(pool->diff_rejected), false); |
|
root = api_add_diff(root, "Difficulty Stale", &(pool->diff_stale), false); |
|
root = api_add_diff(root, "Last Share Difficulty", &(pool->last_share_diff), false); |
|
root = api_add_bool(root, "Has Stratum", &(pool->has_stratum), false); |
|
root = api_add_bool(root, "Stratum Active", &(pool->stratum_active), false); |
|
if (pool->stratum_active) |
|
root = api_add_escape(root, "Stratum URL", pool->stratum_url, false); |
|
else |
|
root = api_add_const(root, "Stratum URL", BLANK, false); |
|
root = api_add_bool(root, "Has GBT", &(pool->has_gbt), false); |
|
root = api_add_uint64(root, "Best Share", &(pool->best_diff), true); |
|
double rejp = (pool->diff_accepted + pool->diff_rejected + pool->diff_stale) ? |
|
(double)(pool->diff_rejected) / (double)(pool->diff_accepted + pool->diff_rejected + pool->diff_stale) : 0; |
|
root = api_add_percent(root, "Pool Rejected%", &rejp, false); |
|
double stalep = (pool->diff_accepted + pool->diff_rejected + pool->diff_stale) ? |
|
(double)(pool->diff_stale) / (double)(pool->diff_accepted + pool->diff_rejected + pool->diff_stale) : 0; |
|
root = api_add_percent(root, "Pool Stale%", &stalep, false); |
|
|
|
root = print_data(root, buf, isjson, isjson && (i > 0)); |
|
io_add(io_data, buf); |
|
} |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void summary(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
double utility, mhs, work_utility; |
|
|
|
message(io_data, MSG_SUMM, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_SUMMARY : _SUMMARY COMSTR); |
|
|
|
// stop hashmeter() changing some while copying |
|
mutex_lock(&hash_lock); |
|
|
|
utility = total_accepted / ( total_secs ? total_secs : 1 ) * 60; |
|
mhs = total_mhashes_done / total_secs; |
|
work_utility = total_diff1 / ( total_secs ? total_secs : 1 ) * 60; |
|
|
|
root = api_add_elapsed(root, "Elapsed", &(total_secs), true); |
|
root = api_add_mhs(root, "MHS av", &(mhs), false); |
|
root = api_add_uint(root, "Found Blocks", &(found_blocks), true); |
|
root = api_add_int(root, "Getworks", &(total_getworks), true); |
|
root = api_add_int(root, "Accepted", &(total_accepted), true); |
|
root = api_add_int(root, "Rejected", &(total_rejected), true); |
|
root = api_add_int(root, "Hardware Errors", &(hw_errors), true); |
|
root = api_add_utility(root, "Utility", &(utility), false); |
|
root = api_add_int(root, "Discarded", &(total_discarded), true); |
|
root = api_add_int(root, "Stale", &(total_stale), true); |
|
root = api_add_uint(root, "Get Failures", &(total_go), true); |
|
root = api_add_uint(root, "Local Work", &(local_work), true); |
|
root = api_add_uint(root, "Remote Failures", &(total_ro), true); |
|
root = api_add_uint(root, "Network Blocks", &(new_blocks), true); |
|
root = api_add_mhtotal(root, "Total MH", &(total_mhashes_done), true); |
|
root = api_add_utility(root, "Work Utility", &(work_utility), false); |
|
root = api_add_diff(root, "Difficulty Accepted", &(total_diff_accepted), true); |
|
root = api_add_diff(root, "Difficulty Rejected", &(total_diff_rejected), true); |
|
root = api_add_diff(root, "Difficulty Stale", &(total_diff_stale), true); |
|
root = api_add_uint64(root, "Best Share", &(best_diff), true); |
|
double hwp = (hw_errors + total_diff1) ? |
|
(double)(hw_errors) / (double)(hw_errors + total_diff1) : 0; |
|
root = api_add_percent(root, "Device Hardware%", &hwp, false); |
|
double rejp = total_diff1 ? |
|
(double)(total_diff_rejected) / (double)(total_diff1) : 0; |
|
root = api_add_percent(root, "Device Rejected%", &rejp, false); |
|
double prejp = (total_diff_accepted + total_diff_rejected + total_diff_stale) ? |
|
(double)(total_diff_rejected) / (double)(total_diff_accepted + total_diff_rejected + total_diff_stale) : 0; |
|
root = api_add_percent(root, "Pool Rejected%", &prejp, false); |
|
double stalep = (total_diff_accepted + total_diff_rejected + total_diff_stale) ? |
|
(double)(total_diff_stale) / (double)(total_diff_accepted + total_diff_rejected + total_diff_stale) : 0; |
|
root = api_add_percent(root, "Pool Stale%", &stalep, false); |
|
|
|
mutex_unlock(&hash_lock); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
#ifdef HAVE_OPENCL |
|
static void gpuenable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct thr_info *thr; |
|
int gpu; |
|
int id; |
|
int i; |
|
|
|
if (gpu_threads == 0) { |
|
message(io_data, MSG_GPUNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= nDevs) { |
|
message(io_data, MSG_INVGPU, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
applog(LOG_DEBUG, "API: request to gpuenable gpuid %d %s%u", |
|
id, gpus[id].drv->name, gpus[id].device_id); |
|
|
|
if (gpus[id].deven != DEV_DISABLED) { |
|
message(io_data, MSG_ALRENA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
for (i = 0; i < gpu_threads; i++) { |
|
thr = get_thread(i); |
|
gpu = thr->cgpu->device_id; |
|
if (gpu == id) { |
|
if (thr->cgpu->status != LIFE_WELL) { |
|
message(io_data, MSG_GPUMRE, id, NULL, isjson); |
|
return; |
|
} |
|
gpus[id].deven = DEV_ENABLED; |
|
applog(LOG_DEBUG, "API Pushing sem post to thread %d", thr->id); |
|
cgsem_post(&thr->sem); |
|
} |
|
} |
|
|
|
message(io_data, MSG_GPUREN, id, NULL, isjson); |
|
} |
|
|
|
static void gpudisable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
int id; |
|
|
|
if (nDevs == 0) { |
|
message(io_data, MSG_GPUNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= nDevs) { |
|
message(io_data, MSG_INVGPU, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
applog(LOG_DEBUG, "API: request to gpudisable gpuid %d %s%u", |
|
id, gpus[id].drv->name, gpus[id].device_id); |
|
|
|
if (gpus[id].deven == DEV_DISABLED) { |
|
message(io_data, MSG_ALRDIS, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
gpus[id].deven = DEV_DISABLED; |
|
|
|
message(io_data, MSG_GPUDIS, id, NULL, isjson); |
|
} |
|
|
|
static void gpurestart(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
int id; |
|
|
|
if (nDevs == 0) { |
|
message(io_data, MSG_GPUNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= nDevs) { |
|
message(io_data, MSG_INVGPU, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
reinit_device(&gpus[id]); |
|
|
|
message(io_data, MSG_GPUREI, id, NULL, isjson); |
|
} |
|
#endif |
|
|
|
static void gpucount(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
int numgpu = 0; |
|
|
|
#ifdef HAVE_OPENCL |
|
numgpu = nDevs; |
|
#endif |
|
|
|
message(io_data, MSG_NUMGPU, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_GPUS : _GPUS COMSTR); |
|
|
|
root = api_add_int(root, "Count", &numgpu, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void pgacount(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
int count = 0; |
|
|
|
#ifdef HAVE_AN_FPGA |
|
count = numpgas(); |
|
#endif |
|
|
|
message(io_data, MSG_NUMPGA, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_PGAS : _PGAS COMSTR); |
|
|
|
root = api_add_int(root, "Count", &count, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void switchpool(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct pool *pool; |
|
int id; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
cg_rlock(&control_lock); |
|
if (id < 0 || id >= total_pools) { |
|
cg_runlock(&control_lock); |
|
message(io_data, MSG_INVPID, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool = pools[id]; |
|
pool->enabled = POOL_ENABLED; |
|
cg_runlock(&control_lock); |
|
switch_pools(pool); |
|
|
|
message(io_data, MSG_SWITCHP, id, NULL, isjson); |
|
} |
|
|
|
static void copyadvanceafter(char ch, char **param, char **buf) |
|
{ |
|
#define src_p (*param) |
|
#define dst_b (*buf) |
|
|
|
while (*src_p && *src_p != ch) { |
|
if (*src_p == '\\' && *(src_p+1) != '\0') |
|
src_p++; |
|
|
|
*(dst_b++) = *(src_p++); |
|
} |
|
if (*src_p) |
|
src_p++; |
|
|
|
*(dst_b++) = '\0'; |
|
} |
|
|
|
static bool pooldetails(char *param, char **url, char **user, char **pass) |
|
{ |
|
char *ptr, *buf; |
|
|
|
ptr = buf = malloc(strlen(param)+1); |
|
if (unlikely(!buf)) |
|
quit(1, "Failed to malloc pooldetails buf"); |
|
|
|
*url = buf; |
|
|
|
// copy url |
|
copyadvanceafter(',', ¶m, &buf); |
|
|
|
if (!(*param)) // missing user |
|
goto exitsama; |
|
|
|
*user = buf; |
|
|
|
// copy user |
|
copyadvanceafter(',', ¶m, &buf); |
|
|
|
if (!*param) // missing pass |
|
goto exitsama; |
|
|
|
*pass = buf; |
|
|
|
// copy pass |
|
copyadvanceafter(',', ¶m, &buf); |
|
|
|
return true; |
|
|
|
exitsama: |
|
free(ptr); |
|
return false; |
|
} |
|
|
|
static void addpool(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
char *url, *user, *pass; |
|
struct pool *pool; |
|
char *ptr; |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPDP, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (!pooldetails(param, &url, &user, &pass)) { |
|
ptr = escape_string(param, isjson); |
|
message(io_data, MSG_INVPDP, 0, ptr, isjson); |
|
if (ptr != param) |
|
free(ptr); |
|
ptr = NULL; |
|
return; |
|
} |
|
|
|
pool = add_pool(); |
|
detect_stratum(pool, url); |
|
add_pool_details(pool, true, url, user, pass); |
|
|
|
ptr = escape_string(url, isjson); |
|
message(io_data, MSG_ADDPOOL, 0, ptr, isjson); |
|
if (ptr != url) |
|
free(ptr); |
|
ptr = NULL; |
|
} |
|
|
|
static void enablepool(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct pool *pool; |
|
int id; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= total_pools) { |
|
message(io_data, MSG_INVPID, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool = pools[id]; |
|
if (pool->enabled == POOL_ENABLED) { |
|
message(io_data, MSG_ALRENAP, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool->enabled = POOL_ENABLED; |
|
if (pool->prio < current_pool()->prio) |
|
switch_pools(pool); |
|
|
|
message(io_data, MSG_ENAPOOL, id, NULL, isjson); |
|
} |
|
|
|
static void poolpriority(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
char *ptr, *next; |
|
int i, pr, prio = 0; |
|
|
|
// TODO: all cgminer code needs a mutex added everywhere for change |
|
// access to total_pools and also parts of the pools[] array, |
|
// just copying total_pools here wont solve that |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
bool pools_changed[total_pools]; |
|
int new_prio[total_pools]; |
|
for (i = 0; i < total_pools; ++i) |
|
pools_changed[i] = false; |
|
|
|
next = param; |
|
while (next && *next) { |
|
ptr = next; |
|
next = strchr(ptr, ','); |
|
if (next) |
|
*(next++) = '\0'; |
|
|
|
i = atoi(ptr); |
|
if (i < 0 || i >= total_pools) { |
|
message(io_data, MSG_INVPID, i, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (pools_changed[i]) { |
|
message(io_data, MSG_DUPPID, i, NULL, isjson); |
|
return; |
|
} |
|
|
|
pools_changed[i] = true; |
|
new_prio[i] = prio++; |
|
} |
|
|
|
// Only change them if no errors |
|
for (i = 0; i < total_pools; i++) { |
|
if (pools_changed[i]) |
|
pools[i]->prio = new_prio[i]; |
|
} |
|
|
|
// In priority order, cycle through the unchanged pools and append them |
|
for (pr = 0; pr < total_pools; pr++) |
|
for (i = 0; i < total_pools; i++) { |
|
if (!pools_changed[i] && pools[i]->prio == pr) { |
|
pools[i]->prio = prio++; |
|
pools_changed[i] = true; |
|
break; |
|
} |
|
} |
|
|
|
if (current_pool()->prio) |
|
switch_pools(NULL); |
|
|
|
message(io_data, MSG_POOLPRIO, 0, NULL, isjson); |
|
} |
|
|
|
static void poolquota(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct pool *pool; |
|
int quota, id; |
|
char *comma; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
comma = strchr(param, ','); |
|
if (!comma) { |
|
message(io_data, MSG_CONVAL, 0, param, isjson); |
|
return; |
|
} |
|
|
|
*(comma++) = '\0'; |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= total_pools) { |
|
message(io_data, MSG_INVPID, id, NULL, isjson); |
|
return; |
|
} |
|
pool = pools[id]; |
|
|
|
quota = atoi(comma); |
|
if (quota < 0) { |
|
message(io_data, MSG_INVNEG, quota, pool->rpc_url, isjson); |
|
return; |
|
} |
|
|
|
pool->quota = quota; |
|
adjust_quota_gcd(); |
|
message(io_data, MSG_SETQUOTA, quota, pool->rpc_url, isjson); |
|
} |
|
|
|
static void disablepool(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct pool *pool; |
|
int id; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= total_pools) { |
|
message(io_data, MSG_INVPID, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool = pools[id]; |
|
if (pool->enabled == POOL_DISABLED) { |
|
message(io_data, MSG_ALRDISP, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (enabled_pools <= 1) { |
|
message(io_data, MSG_DISLASTP, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool->enabled = POOL_DISABLED; |
|
if (pool == current_pool()) |
|
switch_pools(NULL); |
|
|
|
message(io_data, MSG_DISPOOL, id, NULL, isjson); |
|
} |
|
|
|
static void removepool(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct pool *pool; |
|
char *rpc_url; |
|
bool dofree = false; |
|
int id; |
|
|
|
if (total_pools == 0) { |
|
message(io_data, MSG_NOPOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISPID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= total_pools) { |
|
message(io_data, MSG_INVPID, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (total_pools <= 1) { |
|
message(io_data, MSG_REMLASTP, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool = pools[id]; |
|
if (pool == current_pool()) |
|
switch_pools(NULL); |
|
|
|
if (pool == current_pool()) { |
|
message(io_data, MSG_ACTPOOL, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
pool->enabled = POOL_DISABLED; |
|
rpc_url = escape_string(pool->rpc_url, isjson); |
|
if (rpc_url != pool->rpc_url) |
|
dofree = true; |
|
|
|
remove_pool(pool); |
|
|
|
message(io_data, MSG_REMPOOL, id, rpc_url, isjson); |
|
|
|
if (dofree) |
|
free(rpc_url); |
|
rpc_url = NULL; |
|
} |
|
|
|
#ifdef HAVE_OPENCL |
|
static bool splitgpuvalue(struct io_data *io_data, char *param, int *gpu, char **value, bool isjson) |
|
{ |
|
int id; |
|
char *gpusep; |
|
|
|
if (nDevs == 0) { |
|
message(io_data, MSG_GPUNON, 0, NULL, isjson); |
|
return false; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return false; |
|
} |
|
|
|
gpusep = strchr(param, GPUSEP); |
|
if (gpusep == NULL) { |
|
message(io_data, MSG_MISVAL, 0, NULL, isjson); |
|
return false; |
|
} |
|
|
|
*(gpusep++) = '\0'; |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= nDevs) { |
|
message(io_data, MSG_INVGPU, id, NULL, isjson); |
|
return false; |
|
} |
|
|
|
*gpu = id; |
|
*value = gpusep; |
|
|
|
return true; |
|
} |
|
|
|
static void gpuintensity(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
int id; |
|
char *value; |
|
int intensity; |
|
char intensitystr[7]; |
|
|
|
if (!splitgpuvalue(io_data, param, &id, &value, isjson)) |
|
return; |
|
|
|
if (!strncasecmp(value, DYNAMIC, 1)) { |
|
gpus[id].dynamic = true; |
|
strcpy(intensitystr, DYNAMIC); |
|
} |
|
else { |
|
intensity = atoi(value); |
|
if (intensity < MIN_INTENSITY || intensity > MAX_INTENSITY) { |
|
message(io_data, MSG_INVINT, 0, value, isjson); |
|
return; |
|
} |
|
|
|
gpus[id].dynamic = false; |
|
gpus[id].intensity = intensity; |
|
sprintf(intensitystr, "%d", intensity); |
|
} |
|
|
|
message(io_data, MSG_GPUINT, id, intensitystr, isjson); |
|
} |
|
|
|
static void gpumem(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
#ifdef HAVE_ADL |
|
int id; |
|
char *value; |
|
int clock; |
|
|
|
if (!splitgpuvalue(io_data, param, &id, &value, isjson)) |
|
return; |
|
|
|
clock = atoi(value); |
|
|
|
if (set_memoryclock(id, clock)) |
|
message(io_data, MSG_GPUMERR, id, value, isjson); |
|
else |
|
message(io_data, MSG_GPUMEM, id, value, isjson); |
|
#else |
|
message(io_data, MSG_NOADL, 0, NULL, isjson); |
|
#endif |
|
} |
|
|
|
static void gpuengine(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
#ifdef HAVE_ADL |
|
int id; |
|
char *value; |
|
int clock; |
|
|
|
if (!splitgpuvalue(io_data, param, &id, &value, isjson)) |
|
return; |
|
|
|
clock = atoi(value); |
|
|
|
if (set_engineclock(id, clock)) |
|
message(io_data, MSG_GPUEERR, id, value, isjson); |
|
else |
|
message(io_data, MSG_GPUENG, id, value, isjson); |
|
#else |
|
message(io_data, MSG_NOADL, 0, NULL, isjson); |
|
#endif |
|
} |
|
|
|
static void gpufan(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
#ifdef HAVE_ADL |
|
int id; |
|
char *value; |
|
int fan; |
|
|
|
if (!splitgpuvalue(io_data, param, &id, &value, isjson)) |
|
return; |
|
|
|
fan = atoi(value); |
|
|
|
if (set_fanspeed(id, fan)) |
|
message(io_data, MSG_GPUFERR, id, value, isjson); |
|
else |
|
message(io_data, MSG_GPUFAN, id, value, isjson); |
|
#else |
|
message(io_data, MSG_NOADL, 0, NULL, isjson); |
|
#endif |
|
} |
|
|
|
static void gpuvddc(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
#ifdef HAVE_ADL |
|
int id; |
|
char *value; |
|
float vddc; |
|
|
|
if (!splitgpuvalue(io_data, param, &id, &value, isjson)) |
|
return; |
|
|
|
vddc = atof(value); |
|
|
|
if (set_vddc(id, vddc)) |
|
message(io_data, MSG_GPUVERR, id, value, isjson); |
|
else |
|
message(io_data, MSG_GPUVDDC, id, value, isjson); |
|
#else |
|
message(io_data, MSG_NOADL, 0, NULL, isjson); |
|
#endif |
|
} |
|
#endif |
|
|
|
void doquit(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
if (isjson) |
|
io_put(io_data, JSON_START JSON_BYE); |
|
else |
|
io_put(io_data, _BYE); |
|
|
|
bye = true; |
|
do_a_quit = true; |
|
} |
|
|
|
void dorestart(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
if (isjson) |
|
io_put(io_data, JSON_START JSON_RESTART); |
|
else |
|
io_put(io_data, _RESTART); |
|
|
|
bye = true; |
|
do_a_restart = true; |
|
} |
|
|
|
void privileged(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
message(io_data, MSG_ACCOK, 0, NULL, isjson); |
|
} |
|
|
|
void notifystatus(struct io_data *io_data, int device, struct cgpu_info *cgpu, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
char *reason; |
|
|
|
if (cgpu->device_last_not_well == 0) |
|
reason = REASON_NONE; |
|
else |
|
switch(cgpu->device_not_well_reason) { |
|
case REASON_THREAD_FAIL_INIT: |
|
reason = REASON_THREAD_FAIL_INIT_STR; |
|
break; |
|
case REASON_THREAD_ZERO_HASH: |
|
reason = REASON_THREAD_ZERO_HASH_STR; |
|
break; |
|
case REASON_THREAD_FAIL_QUEUE: |
|
reason = REASON_THREAD_FAIL_QUEUE_STR; |
|
break; |
|
case REASON_DEV_SICK_IDLE_60: |
|
reason = REASON_DEV_SICK_IDLE_60_STR; |
|
break; |
|
case REASON_DEV_DEAD_IDLE_600: |
|
reason = REASON_DEV_DEAD_IDLE_600_STR; |
|
break; |
|
case REASON_DEV_NOSTART: |
|
reason = REASON_DEV_NOSTART_STR; |
|
break; |
|
case REASON_DEV_OVER_HEAT: |
|
reason = REASON_DEV_OVER_HEAT_STR; |
|
break; |
|
case REASON_DEV_THERMAL_CUTOFF: |
|
reason = REASON_DEV_THERMAL_CUTOFF_STR; |
|
break; |
|
case REASON_DEV_COMMS_ERROR: |
|
reason = REASON_DEV_COMMS_ERROR_STR; |
|
break; |
|
default: |
|
reason = REASON_UNKNOWN_STR; |
|
break; |
|
} |
|
|
|
// ALL counters (and only counters) must start the name with a '*' |
|
// Simplifies future external support for identifying new counters |
|
root = api_add_int(root, "NOTIFY", &device, false); |
|
root = api_add_string(root, "Name", cgpu->drv->name, false); |
|
root = api_add_int(root, "ID", &(cgpu->device_id), false); |
|
root = api_add_time(root, "Last Well", &(cgpu->device_last_well), false); |
|
root = api_add_time(root, "Last Not Well", &(cgpu->device_last_not_well), false); |
|
root = api_add_string(root, "Reason Not Well", reason, false); |
|
root = api_add_int(root, "*Thread Fail Init", &(cgpu->thread_fail_init_count), false); |
|
root = api_add_int(root, "*Thread Zero Hash", &(cgpu->thread_zero_hash_count), false); |
|
root = api_add_int(root, "*Thread Fail Queue", &(cgpu->thread_fail_queue_count), false); |
|
root = api_add_int(root, "*Dev Sick Idle 60s", &(cgpu->dev_sick_idle_60_count), false); |
|
root = api_add_int(root, "*Dev Dead Idle 600s", &(cgpu->dev_dead_idle_600_count), false); |
|
root = api_add_int(root, "*Dev Nostart", &(cgpu->dev_nostart_count), false); |
|
root = api_add_int(root, "*Dev Over Heat", &(cgpu->dev_over_heat_count), false); |
|
root = api_add_int(root, "*Dev Thermal Cutoff", &(cgpu->dev_thermal_cutoff_count), false); |
|
root = api_add_int(root, "*Dev Comms Error", &(cgpu->dev_comms_error_count), false); |
|
root = api_add_int(root, "*Dev Throttle", &(cgpu->dev_throttle_count), false); |
|
|
|
root = print_data(root, buf, isjson, isjson && (device > 0)); |
|
io_add(io_data, buf); |
|
} |
|
|
|
static void notify(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
bool io_open = false; |
|
int i; |
|
|
|
if (total_devices == 0) { |
|
message(io_data, MSG_NODEVS, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_NOTIFY, 0, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_NOTIFY); |
|
|
|
for (i = 0; i < total_devices; i++) { |
|
cgpu = get_devices(i); |
|
notifystatus(io_data, i, cgpu, isjson, group); |
|
} |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void devdetails(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open = false; |
|
struct cgpu_info *cgpu; |
|
int i; |
|
|
|
if (total_devices == 0) { |
|
message(io_data, MSG_NODEVS, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_DEVDETAILS, 0, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_DEVDETAILS); |
|
|
|
for (i = 0; i < total_devices; i++) { |
|
cgpu = get_devices(i); |
|
|
|
root = api_add_int(root, "DEVDETAILS", &i, false); |
|
root = api_add_string(root, "Name", cgpu->drv->name, false); |
|
root = api_add_int(root, "ID", &(cgpu->device_id), false); |
|
root = api_add_string(root, "Driver", cgpu->drv->dname, false); |
|
root = api_add_const(root, "Kernel", cgpu->kname ? : BLANK, false); |
|
root = api_add_const(root, "Model", cgpu->name ? : BLANK, false); |
|
root = api_add_const(root, "Device Path", cgpu->device_path ? : BLANK, false); |
|
|
|
root = print_data(root, buf, isjson, isjson && (i > 0)); |
|
io_add(io_data, buf); |
|
} |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
void dosave(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
char filename[PATH_MAX]; |
|
FILE *fcfg; |
|
char *ptr; |
|
|
|
if (param == NULL || *param == '\0') { |
|
default_save_file(filename); |
|
param = filename; |
|
} |
|
|
|
fcfg = fopen(param, "w"); |
|
if (!fcfg) { |
|
ptr = escape_string(param, isjson); |
|
message(io_data, MSG_BADFN, 0, ptr, isjson); |
|
if (ptr != param) |
|
free(ptr); |
|
ptr = NULL; |
|
return; |
|
} |
|
|
|
write_config(fcfg); |
|
fclose(fcfg); |
|
|
|
ptr = escape_string(param, isjson); |
|
message(io_data, MSG_SAVED, 0, ptr, isjson); |
|
if (ptr != param) |
|
free(ptr); |
|
ptr = NULL; |
|
} |
|
|
|
static int itemstats(struct io_data *io_data, int i, char *id, struct cgminer_stats *stats, struct cgminer_pool_stats *pool_stats, struct api_data *extra, struct cgpu_info *cgpu, bool isjson) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
|
|
root = api_add_int(root, "STATS", &i, false); |
|
root = api_add_string(root, "ID", id, false); |
|
root = api_add_elapsed(root, "Elapsed", &(total_secs), false); |
|
root = api_add_uint32(root, "Calls", &(stats->getwork_calls), false); |
|
root = api_add_timeval(root, "Wait", &(stats->getwork_wait), false); |
|
root = api_add_timeval(root, "Max", &(stats->getwork_wait_max), false); |
|
root = api_add_timeval(root, "Min", &(stats->getwork_wait_min), false); |
|
|
|
if (pool_stats) { |
|
root = api_add_uint32(root, "Pool Calls", &(pool_stats->getwork_calls), false); |
|
root = api_add_uint32(root, "Pool Attempts", &(pool_stats->getwork_attempts), false); |
|
root = api_add_timeval(root, "Pool Wait", &(pool_stats->getwork_wait), false); |
|
root = api_add_timeval(root, "Pool Max", &(pool_stats->getwork_wait_max), false); |
|
root = api_add_timeval(root, "Pool Min", &(pool_stats->getwork_wait_min), false); |
|
root = api_add_double(root, "Pool Av", &(pool_stats->getwork_wait_rolling), false); |
|
root = api_add_bool(root, "Work Had Roll Time", &(pool_stats->hadrolltime), false); |
|
root = api_add_bool(root, "Work Can Roll", &(pool_stats->canroll), false); |
|
root = api_add_bool(root, "Work Had Expire", &(pool_stats->hadexpire), false); |
|
root = api_add_uint32(root, "Work Roll Time", &(pool_stats->rolltime), false); |
|
root = api_add_diff(root, "Work Diff", &(pool_stats->last_diff), false); |
|
root = api_add_diff(root, "Min Diff", &(pool_stats->min_diff), false); |
|
root = api_add_diff(root, "Max Diff", &(pool_stats->max_diff), false); |
|
root = api_add_uint32(root, "Min Diff Count", &(pool_stats->min_diff_count), false); |
|
root = api_add_uint32(root, "Max Diff Count", &(pool_stats->max_diff_count), false); |
|
root = api_add_uint64(root, "Times Sent", &(pool_stats->times_sent), false); |
|
root = api_add_uint64(root, "Bytes Sent", &(pool_stats->bytes_sent), false); |
|
root = api_add_uint64(root, "Times Recv", &(pool_stats->times_received), false); |
|
root = api_add_uint64(root, "Bytes Recv", &(pool_stats->bytes_received), false); |
|
root = api_add_uint64(root, "Net Bytes Sent", &(pool_stats->net_bytes_sent), false); |
|
root = api_add_uint64(root, "Net Bytes Recv", &(pool_stats->net_bytes_received), false); |
|
} |
|
|
|
if (extra) |
|
root = api_add_extra(root, extra); |
|
|
|
if (cgpu) { |
|
#ifdef USE_USBUTILS |
|
char details[256]; |
|
int val; |
|
|
|
if (cgpu->usbinfo.pipe_count) |
|
snprintf(details, sizeof(details), |
|
"%"PRIu64" %"PRIu64"/%"PRIu64"/%"PRIu64" %lu", |
|
cgpu->usbinfo.pipe_count, |
|
cgpu->usbinfo.clear_err_count, |
|
cgpu->usbinfo.retry_err_count, |
|
cgpu->usbinfo.clear_fail_count, |
|
(unsigned long)(cgpu->usbinfo.last_pipe)); |
|
else |
|
strcpy(details, "0"); |
|
|
|
root = api_add_string(root, "USB Pipe", details, true); |
|
|
|
snprintf(details, sizeof(details), |
|
"r%"PRIu64" %.6f w%"PRIu64" %.6f", |
|
cgpu->usbinfo.read_delay_count, |
|
cgpu->usbinfo.total_read_delay, |
|
cgpu->usbinfo.write_delay_count, |
|
cgpu->usbinfo.total_write_delay); |
|
|
|
root = api_add_string(root, "USB Delay", details, true); |
|
|
|
if (cgpu->usbinfo.usb_tmo[0].count == 0 && |
|
cgpu->usbinfo.usb_tmo[1].count == 0 && |
|
cgpu->usbinfo.usb_tmo[2].count == 0) { |
|
snprintf(details, sizeof(details), |
|
"%"PRIu64" 0", cgpu->usbinfo.tmo_count); |
|
} else { |
|
snprintf(details, sizeof(details), |
|
"%"PRIu64" %d=%d/%d/%d/%"PRIu64"/%"PRIu64 |
|
" %d=%d/%d/%d/%"PRIu64"/%"PRIu64 |
|
" %d=%d/%d/%d/%"PRIu64"/%"PRIu64" ", |
|
cgpu->usbinfo.tmo_count, |
|
USB_TMO_0, cgpu->usbinfo.usb_tmo[0].count, |
|
cgpu->usbinfo.usb_tmo[0].min_tmo, |
|
cgpu->usbinfo.usb_tmo[0].max_tmo, |
|
cgpu->usbinfo.usb_tmo[0].total_over, |
|
cgpu->usbinfo.usb_tmo[0].total_tmo, |
|
USB_TMO_1, cgpu->usbinfo.usb_tmo[1].count, |
|
cgpu->usbinfo.usb_tmo[1].min_tmo, |
|
cgpu->usbinfo.usb_tmo[1].max_tmo, |
|
cgpu->usbinfo.usb_tmo[1].total_over, |
|
cgpu->usbinfo.usb_tmo[1].total_tmo, |
|
USB_TMO_2, cgpu->usbinfo.usb_tmo[2].count, |
|
cgpu->usbinfo.usb_tmo[2].min_tmo, |
|
cgpu->usbinfo.usb_tmo[2].max_tmo, |
|
cgpu->usbinfo.usb_tmo[2].total_over, |
|
cgpu->usbinfo.usb_tmo[2].total_tmo); |
|
} |
|
|
|
root = api_add_string(root, "USB tmo", details, true); |
|
root = api_add_int(root, "USB cancellations", &cgpu->usb_cancels, false); |
|
root = api_add_int(root, "USB bulk reads", &cgpu->usb_bulk_reads, false); |
|
val = cgpu->usb_rlock_total_wait / (cgpu->usb_bulk_reads ? : 1); |
|
root = api_add_int(root, "USB avg rlock ms wait", &val, true); |
|
root = api_add_int(root, "USB max rlock ms wait", &cgpu->usb_rlock_max_wait, false); |
|
root = api_add_int(root, "USB bulk writes", &cgpu->usb_bulk_writes, false); |
|
val = cgpu->usb_wlock_total_wait / (cgpu->usb_bulk_writes ? : 1); |
|
root = api_add_int(root, "USB avg wlock ms wait", &val, true); |
|
root = api_add_int(root, "USB max wlock ms wait", &cgpu->usb_wlock_max_wait, false); |
|
#endif |
|
} |
|
|
|
root = print_data(root, buf, isjson, isjson && (i > 0)); |
|
io_add(io_data, buf); |
|
|
|
return ++i; |
|
} |
|
|
|
static void minerstats(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
bool io_open = false; |
|
struct api_data *extra; |
|
char id[20]; |
|
int i, j; |
|
|
|
message(io_data, MSG_MINESTATS, 0, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_MINESTATS); |
|
|
|
i = 0; |
|
for (j = 0; j < total_devices; j++) { |
|
cgpu = get_devices(j); |
|
|
|
if (cgpu && cgpu->drv) { |
|
if (cgpu->drv->get_api_stats) |
|
extra = cgpu->drv->get_api_stats(cgpu); |
|
else |
|
extra = NULL; |
|
|
|
sprintf(id, "%s%d", cgpu->drv->name, cgpu->device_id); |
|
i = itemstats(io_data, i, id, &(cgpu->cgminer_stats), NULL, extra, cgpu, isjson); |
|
} |
|
} |
|
|
|
for (j = 0; j < total_pools; j++) { |
|
struct pool *pool = pools[j]; |
|
|
|
sprintf(id, "POOL%d", j); |
|
i = itemstats(io_data, i, id, &(pool->cgminer_stats), &(pool->cgminer_pool_stats), NULL, NULL, isjson); |
|
} |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void failoveronly(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISBOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
*param = tolower(*param); |
|
|
|
if (*param != 't' && *param != 'f') { |
|
message(io_data, MSG_INVBOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
bool tf = (*param == 't'); |
|
|
|
opt_fail_only = tf; |
|
|
|
message(io_data, MSG_FOO, tf, NULL, isjson); |
|
} |
|
|
|
static void minecoin(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
|
|
message(io_data, MSG_MINECOIN, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_MINECOIN : _MINECOIN COMSTR); |
|
|
|
#ifdef USE_SCRYPT |
|
if (opt_scrypt) |
|
root = api_add_const(root, "Hash Method", SCRYPTSTR, false); |
|
else |
|
#endif |
|
root = api_add_const(root, "Hash Method", SHA256STR, false); |
|
|
|
cg_rlock(&ch_lock); |
|
if (current_fullhash && *current_fullhash) { |
|
root = api_add_timeval(root, "Current Block Time", &block_timeval, true); |
|
root = api_add_string(root, "Current Block Hash", current_fullhash, true); |
|
} else { |
|
struct timeval t = {0,0}; |
|
root = api_add_timeval(root, "Current Block Time", &t, true); |
|
root = api_add_const(root, "Current Block Hash", BLANK, false); |
|
} |
|
cg_runlock(&ch_lock); |
|
|
|
root = api_add_bool(root, "LP", &have_longpoll, false); |
|
root = api_add_diff(root, "Network Difficulty", ¤t_diff, true); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void debugstate(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
|
|
if (param == NULL) |
|
param = (char *)BLANK; |
|
else |
|
*param = tolower(*param); |
|
|
|
switch(*param) { |
|
case 's': |
|
opt_realquiet = true; |
|
break; |
|
case 'q': |
|
opt_quiet ^= true; |
|
break; |
|
case 'v': |
|
opt_log_output ^= true; |
|
if (opt_log_output) |
|
opt_quiet = false; |
|
break; |
|
case 'd': |
|
opt_debug ^= true; |
|
opt_log_output = opt_debug; |
|
if (opt_debug) |
|
opt_quiet = false; |
|
break; |
|
case 'r': |
|
opt_protocol ^= true; |
|
if (opt_protocol) |
|
opt_quiet = false; |
|
break; |
|
case 'p': |
|
want_per_device_stats ^= true; |
|
opt_log_output = want_per_device_stats; |
|
break; |
|
case 'n': |
|
opt_log_output = false; |
|
opt_debug = false; |
|
opt_quiet = false; |
|
opt_protocol = false; |
|
want_per_device_stats = false; |
|
opt_worktime = false; |
|
break; |
|
case 'w': |
|
opt_worktime ^= true; |
|
break; |
|
#ifdef _MEMORY_DEBUG |
|
case 'y': |
|
cgmemspeedup(); |
|
break; |
|
case 'z': |
|
cgmemrpt(); |
|
break; |
|
#endif |
|
default: |
|
// anything else just reports the settings |
|
break; |
|
} |
|
|
|
message(io_data, MSG_DEBUGSET, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_DEBUGSET : _DEBUGSET COMSTR); |
|
|
|
root = api_add_bool(root, "Silent", &opt_realquiet, false); |
|
root = api_add_bool(root, "Quiet", &opt_quiet, false); |
|
root = api_add_bool(root, "Verbose", &opt_log_output, false); |
|
root = api_add_bool(root, "Debug", &opt_debug, false); |
|
root = api_add_bool(root, "RPCProto", &opt_protocol, false); |
|
root = api_add_bool(root, "PerDevice", &want_per_device_stats, false); |
|
root = api_add_bool(root, "WorkTime", &opt_worktime, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void setconfig(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
char *comma; |
|
int value; |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_CONPAR, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
comma = strchr(param, ','); |
|
if (!comma) { |
|
message(io_data, MSG_CONVAL, 0, param, isjson); |
|
return; |
|
} |
|
|
|
*(comma++) = '\0'; |
|
value = atoi(comma); |
|
if (value < 0 || value > 9999) { |
|
message(io_data, MSG_INVNUM, value, param, isjson); |
|
return; |
|
} |
|
|
|
if (strcasecmp(param, "queue") == 0) |
|
opt_queue = value; |
|
else if (strcasecmp(param, "scantime") == 0) |
|
opt_scantime = value; |
|
else if (strcasecmp(param, "expiry") == 0) |
|
opt_expiry = value; |
|
else { |
|
message(io_data, MSG_UNKCON, 0, param, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_SETCONFIG, value, param, isjson); |
|
} |
|
|
|
static void usbstats(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
|
|
#ifdef USE_USBUTILS |
|
char buf[TMPBUFSIZ]; |
|
bool io_open = false; |
|
int count = 0; |
|
|
|
root = api_usb_stats(&count); |
|
#endif |
|
|
|
if (!root) { |
|
message(io_data, MSG_NOUSTA, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
#ifdef USE_USBUTILS |
|
message(io_data, MSG_USBSTA, 0, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_USBSTATS); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
|
|
while (42) { |
|
root = api_usb_stats(&count); |
|
if (!root) |
|
break; |
|
|
|
root = print_data(root, buf, isjson, isjson); |
|
io_add(io_data, buf); |
|
} |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
#endif |
|
} |
|
|
|
#ifdef HAVE_AN_FPGA |
|
static void pgaset(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
struct device_drv *drv; |
|
char buf[TMPBUFSIZ]; |
|
int numpga = numpgas(); |
|
|
|
if (numpga == 0) { |
|
message(io_data, MSG_PGANON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
char *opt = strchr(param, ','); |
|
if (opt) |
|
*(opt++) = '\0'; |
|
if (!opt || !*opt) { |
|
message(io_data, MSG_MISPGAOPT, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
int id = atoi(param); |
|
if (id < 0 || id >= numpga) { |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = pgadevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVPGA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
drv = cgpu->drv; |
|
|
|
char *set = strchr(opt, ','); |
|
if (set) |
|
*(set++) = '\0'; |
|
|
|
if (!drv->set_device) |
|
message(io_data, MSG_PGANOSET, id, NULL, isjson); |
|
else { |
|
char *ret = drv->set_device(cgpu, opt, set, buf); |
|
if (ret) { |
|
if (strcasecmp(opt, "help") == 0) |
|
message(io_data, MSG_PGAHELP, id, ret, isjson); |
|
else |
|
message(io_data, MSG_PGASETERR, id, ret, isjson); |
|
} else |
|
message(io_data, MSG_PGASETOK, id, NULL, isjson); |
|
} |
|
} |
|
#endif |
|
|
|
static void dozero(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_ZERMIS, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
char *sum = strchr(param, ','); |
|
if (sum) |
|
*(sum++) = '\0'; |
|
if (!sum || !*sum) { |
|
message(io_data, MSG_MISBOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
bool all = false; |
|
bool bs = false; |
|
if (strcasecmp(param, "all") == 0) |
|
all = true; |
|
else if (strcasecmp(param, "bestshare") == 0) |
|
bs = true; |
|
|
|
if (all == false && bs == false) { |
|
message(io_data, MSG_ZERINV, 0, param, isjson); |
|
return; |
|
} |
|
|
|
*sum = tolower(*sum); |
|
if (*sum != 't' && *sum != 'f') { |
|
message(io_data, MSG_INVBOOL, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
bool dosum = (*sum == 't'); |
|
if (dosum) |
|
print_summary(); |
|
|
|
if (all) |
|
zero_stats(); |
|
if (bs) |
|
zero_bestshare(); |
|
|
|
if (dosum) |
|
message(io_data, MSG_ZERSUM, 0, all ? "All" : "BestShare", isjson); |
|
else |
|
message(io_data, MSG_ZERNOSUM, 0, all ? "All" : "BestShare", isjson); |
|
} |
|
|
|
static void dohotplug(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
#ifdef USE_USBUTILS |
|
int value; |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISHPLG, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
value = atoi(param); |
|
if (value < 0 || value > 9999) { |
|
message(io_data, MSG_INVHPLG, 0, param, isjson); |
|
return; |
|
} |
|
|
|
hotplug_time = value; |
|
|
|
if (value) |
|
message(io_data, MSG_HOTPLUG, value, NULL, isjson); |
|
else |
|
message(io_data, MSG_DISHPLG, 0, NULL, isjson); |
|
#else |
|
message(io_data, MSG_NOHPLG, 0, NULL, isjson); |
|
return; |
|
#endif |
|
} |
|
|
|
#ifdef HAVE_AN_ASIC |
|
static void ascdev(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
bool io_open = false; |
|
int numasc = numascs(); |
|
int id; |
|
|
|
if (numasc == 0) { |
|
message(io_data, MSG_ASCNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numasc) { |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
message(io_data, MSG_ASCDEV, id, NULL, isjson); |
|
|
|
if (isjson) |
|
io_open = io_add(io_data, COMSTR JSON_ASC); |
|
|
|
ascstatus(io_data, id, isjson, false); |
|
|
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void ascenable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
int numasc = numascs(); |
|
struct thr_info *thr; |
|
int asc; |
|
int id; |
|
int i; |
|
|
|
if (numasc == 0) { |
|
message(io_data, MSG_ASCNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numasc) { |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = ascdevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
|
|
applog(LOG_DEBUG, "API: request to ascenable ascid %d device %d %s%u", |
|
id, dev, cgpu->drv->name, cgpu->device_id); |
|
|
|
if (cgpu->deven != DEV_DISABLED) { |
|
message(io_data, MSG_ASCLRENA, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
#if 0 /* A DISABLED device wont change status FIXME: should disabling make it WELL? */ |
|
if (cgpu->status != LIFE_WELL) { |
|
message(io_data, MSG_ASCUNW, id, NULL, isjson); |
|
return; |
|
} |
|
#endif |
|
|
|
#ifdef USE_USBUTILS |
|
if (cgpu->usbinfo.nodev) { |
|
message(io_data, MSG_ASCUSBNODEV, id, NULL, isjson); |
|
return; |
|
} |
|
#endif |
|
|
|
for (i = 0; i < mining_threads; i++) { |
|
thr = get_thread(i); |
|
asc = thr->cgpu->cgminer_id; |
|
if (asc == dev) { |
|
cgpu->deven = DEV_ENABLED; |
|
applog(LOG_DEBUG, "API: Pushing sem post to thread %d", thr->id); |
|
cgsem_post(&thr->sem); |
|
} |
|
} |
|
|
|
message(io_data, MSG_ASCENA, id, NULL, isjson); |
|
} |
|
|
|
static void ascdisable(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
int numasc = numascs(); |
|
int id; |
|
|
|
if (numasc == 0) { |
|
message(io_data, MSG_ASCNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numasc) { |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = ascdevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
|
|
applog(LOG_DEBUG, "API: request to ascdisable ascid %d device %d %s%u", |
|
id, dev, cgpu->drv->name, cgpu->device_id); |
|
|
|
if (cgpu->deven == DEV_DISABLED) { |
|
message(io_data, MSG_ASCLRDIS, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu->deven = DEV_DISABLED; |
|
|
|
message(io_data, MSG_ASCDIS, id, NULL, isjson); |
|
} |
|
|
|
static void ascidentify(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
struct device_drv *drv; |
|
int numasc = numascs(); |
|
int id; |
|
|
|
if (numasc == 0) { |
|
message(io_data, MSG_ASCNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
id = atoi(param); |
|
if (id < 0 || id >= numasc) { |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = ascdevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
drv = cgpu->drv; |
|
|
|
if (!drv->identify_device) |
|
message(io_data, MSG_ASCNOID, id, NULL, isjson); |
|
else { |
|
drv->identify_device(cgpu); |
|
message(io_data, MSG_ASCIDENT, id, NULL, isjson); |
|
} |
|
} |
|
#endif |
|
|
|
static void asccount(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
int count = 0; |
|
|
|
#ifdef HAVE_AN_ASIC |
|
count = numascs(); |
|
#endif |
|
|
|
message(io_data, MSG_NUMASC, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_ASCS : _ASCS COMSTR); |
|
|
|
root = api_add_int(root, "Count", &count, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
#ifdef HAVE_AN_ASIC |
|
static void ascset(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __maybe_unused char *param, bool isjson, __maybe_unused char group) |
|
{ |
|
struct cgpu_info *cgpu; |
|
struct device_drv *drv; |
|
char buf[TMPBUFSIZ]; |
|
int numasc = numascs(); |
|
|
|
if (numasc == 0) { |
|
message(io_data, MSG_ASCNON, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISID, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
char *opt = strchr(param, ','); |
|
if (opt) |
|
*(opt++) = '\0'; |
|
if (!opt || !*opt) { |
|
message(io_data, MSG_MISASCOPT, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
int id = atoi(param); |
|
if (id < 0 || id >= numasc) { |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
int dev = ascdevice(id); |
|
if (dev < 0) { // Should never happen |
|
message(io_data, MSG_INVASC, id, NULL, isjson); |
|
return; |
|
} |
|
|
|
cgpu = get_devices(dev); |
|
drv = cgpu->drv; |
|
|
|
char *set = strchr(opt, ','); |
|
if (set) |
|
*(set++) = '\0'; |
|
|
|
if (!drv->set_device) |
|
message(io_data, MSG_ASCNOSET, id, NULL, isjson); |
|
else { |
|
char *ret = drv->set_device(cgpu, opt, set, buf); |
|
if (ret) { |
|
if (strcasecmp(opt, "help") == 0) |
|
message(io_data, MSG_ASCHELP, id, ret, isjson); |
|
else |
|
message(io_data, MSG_ASCSETERR, id, ret, isjson); |
|
} else |
|
message(io_data, MSG_ASCSETOK, id, NULL, isjson); |
|
} |
|
} |
|
#endif |
|
|
|
static void checkcommand(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, char group); |
|
|
|
struct CMDS { |
|
char *name; |
|
void (*func)(struct io_data *, SOCKETTYPE, char *, bool, char); |
|
bool iswritemode; |
|
} cmds[] = { |
|
{ "version", apiversion, false }, |
|
{ "config", minerconfig, false }, |
|
{ "devs", devstatus, false }, |
|
{ "pools", poolstatus, false }, |
|
{ "summary", summary, false }, |
|
#ifdef HAVE_OPENCL |
|
{ "gpuenable", gpuenable, true }, |
|
{ "gpudisable", gpudisable, true }, |
|
{ "gpurestart", gpurestart, true }, |
|
{ "gpu", gpudev, false }, |
|
#endif |
|
#ifdef HAVE_AN_FPGA |
|
{ "pga", pgadev, false }, |
|
{ "pgaenable", pgaenable, true }, |
|
{ "pgadisable", pgadisable, true }, |
|
{ "pgaidentify", pgaidentify, true }, |
|
#endif |
|
{ "gpucount", gpucount, false }, |
|
{ "pgacount", pgacount, false }, |
|
{ "switchpool", switchpool, true }, |
|
{ "addpool", addpool, true }, |
|
{ "poolpriority", poolpriority, true }, |
|
{ "poolquota", poolquota, true }, |
|
{ "enablepool", enablepool, true }, |
|
{ "disablepool", disablepool, true }, |
|
{ "removepool", removepool, true }, |
|
#ifdef HAVE_OPENCL |
|
{ "gpuintensity", gpuintensity, true }, |
|
{ "gpumem", gpumem, true }, |
|
{ "gpuengine", gpuengine, true }, |
|
{ "gpufan", gpufan, true }, |
|
{ "gpuvddc", gpuvddc, true }, |
|
#endif |
|
{ "save", dosave, true }, |
|
{ "quit", doquit, true }, |
|
{ "privileged", privileged, true }, |
|
{ "notify", notify, false }, |
|
{ "devdetails", devdetails, false }, |
|
{ "restart", dorestart, true }, |
|
{ "stats", minerstats, false }, |
|
{ "check", checkcommand, false }, |
|
{ "failover-only", failoveronly, true }, |
|
{ "coin", minecoin, false }, |
|
{ "debug", debugstate, true }, |
|
{ "setconfig", setconfig, true }, |
|
{ "usbstats", usbstats, false }, |
|
#ifdef HAVE_AN_FPGA |
|
{ "pgaset", pgaset, true }, |
|
#endif |
|
{ "zero", dozero, true }, |
|
{ "hotplug", dohotplug, true }, |
|
#ifdef HAVE_AN_ASIC |
|
{ "asc", ascdev, false }, |
|
{ "ascenable", ascenable, true }, |
|
{ "ascdisable", ascdisable, true }, |
|
{ "ascidentify", ascidentify, true }, |
|
{ "ascset", ascset, true }, |
|
#endif |
|
{ "asccount", asccount, false }, |
|
{ NULL, NULL, false } |
|
}; |
|
|
|
static void checkcommand(struct io_data *io_data, __maybe_unused SOCKETTYPE c, char *param, bool isjson, char group) |
|
{ |
|
struct api_data *root = NULL; |
|
char buf[TMPBUFSIZ]; |
|
bool io_open; |
|
char cmdbuf[100]; |
|
bool found, access; |
|
int i; |
|
|
|
if (param == NULL || *param == '\0') { |
|
message(io_data, MSG_MISCHK, 0, NULL, isjson); |
|
return; |
|
} |
|
|
|
found = false; |
|
access = false; |
|
for (i = 0; cmds[i].name != NULL; i++) { |
|
if (strcmp(cmds[i].name, param) == 0) { |
|
found = true; |
|
|
|
sprintf(cmdbuf, "|%s|", param); |
|
if (ISPRIVGROUP(group) || strstr(COMMANDS(group), cmdbuf)) |
|
access = true; |
|
|
|
break; |
|
} |
|
} |
|
|
|
message(io_data, MSG_CHECK, 0, NULL, isjson); |
|
io_open = io_add(io_data, isjson ? COMSTR JSON_CHECK : _CHECK COMSTR); |
|
|
|
root = api_add_const(root, "Exists", found ? YES : NO, false); |
|
root = api_add_const(root, "Access", access ? YES : NO, false); |
|
|
|
root = print_data(root, buf, isjson, false); |
|
io_add(io_data, buf); |
|
if (isjson && io_open) |
|
io_close(io_data); |
|
} |
|
|
|
static void send_result(struct io_data *io_data, SOCKETTYPE c, bool isjson) |
|
{ |
|
char buf[SOCKBUFSIZ + sizeof(JSON_CLOSE) + sizeof(JSON_END)]; |
|
int count, res, tosend, len, n; |
|
|
|
strcpy(buf, io_data->ptr); |
|
|
|
if (io_data->close) |
|
strcat(buf, JSON_CLOSE); |
|
|
|
if (isjson) { |
|
if (io_data->full) |
|
strcat(buf, JSON_END_TRUNCATED); |
|
else |
|
strcat(buf, JSON_END); |
|
} |
|
|
|
len = strlen(buf); |
|
tosend = len+1; |
|
|
|
applog(LOG_DEBUG, "API: send reply: (%d) '%.10s%s'", tosend, buf, len > 10 ? "..." : BLANK); |
|
|
|
count = 0; |
|
while (count++ < 5 && tosend > 0) { |
|
// allow 50ms per attempt |
|
struct timeval timeout = {0, 50000}; |
|
fd_set wd; |
|
|
|
FD_ZERO(&wd); |
|
FD_SET(c, &wd); |
|
if ((res = select(c + 1, NULL, &wd, NULL, &timeout)) < 1) { |
|
applog(LOG_WARNING, "API: send select failed (%d)", res); |
|
return; |
|
} |
|
|
|
n = send(c, buf, tosend, 0); |
|
|
|
if (SOCKETFAIL(n)) { |
|
if (sock_blocks()) |
|
continue; |
|
|
|
applog(LOG_WARNING, "API: send (%d) failed: %s", tosend, SOCKERRMSG); |
|
|
|
return; |
|
} else { |
|
if (count <= 1) { |
|
if (n == tosend) |
|
applog(LOG_DEBUG, "API: sent all of %d first go", tosend); |
|
else |
|
applog(LOG_DEBUG, "API: sent %d of %d first go", n, tosend); |
|
} else { |
|
if (n == tosend) |
|
applog(LOG_DEBUG, "API: sent all of remaining %d (count=%d)", tosend, count); |
|
else |
|
applog(LOG_DEBUG, "API: sent %d of remaining %d (count=%d)", n, tosend, count); |
|
} |
|
|
|
tosend -= n; |
|
} |
|
} |
|
} |
|
|
|
static void tidyup(__maybe_unused void *arg) |
|
{ |
|
mutex_lock(&quit_restart_lock); |
|
|
|
SOCKETTYPE *apisock = (SOCKETTYPE *)arg; |
|
|
|
bye = true; |
|
|
|
if (*apisock != INVSOCK) { |
|
shutdown(*apisock, SHUT_RDWR); |
|
CLOSESOCKET(*apisock); |
|
*apisock = INVSOCK; |
|
} |
|
|
|
if (ipaccess != NULL) { |
|
free(ipaccess); |
|
ipaccess = NULL; |
|
} |
|
|
|
io_free(); |
|
|
|
mutex_unlock(&quit_restart_lock); |
|
} |
|
|
|
/* |
|
* Interpret --api-groups G:cmd1:cmd2:cmd3,P:cmd4,*,... |
|
*/ |
|
static void setup_groups() |
|
{ |
|
char *api_groups = opt_api_groups ? opt_api_groups : (char *)BLANK; |
|
char *buf, *ptr, *next, *colon; |
|
char group; |
|
char commands[TMPBUFSIZ]; |
|
char cmdbuf[100]; |
|
char *cmd; |
|
bool addstar, did; |
|
int i; |
|
|
|
buf = malloc(strlen(api_groups) + 1); |
|
if (unlikely(!buf)) |
|
quit(1, "Failed to malloc ipgroups buf"); |
|
|
|
strcpy(buf, api_groups); |
|
|
|
next = buf; |
|
// for each group defined |
|
while (next && *next) { |
|
ptr = next; |
|
next = strchr(ptr, ','); |
|
if (next) |
|
*(next++) = '\0'; |
|
|
|
// Validate the group |
|
if (*(ptr+1) != ':') { |
|
colon = strchr(ptr, ':'); |
|
if (colon) |
|
*colon = '\0'; |
|
quit(1, "API invalid group name '%s'", ptr); |
|
} |
|
|
|
group = GROUP(*ptr); |
|
if (!VALIDGROUP(group)) |
|
quit(1, "API invalid group name '%c'", *ptr); |
|
|
|
if (group == PRIVGROUP) |
|
quit(1, "API group name can't be '%c'", PRIVGROUP); |
|
|
|
if (group == NOPRIVGROUP) |
|
quit(1, "API group name can't be '%c'", NOPRIVGROUP); |
|
|
|
if (apigroups[GROUPOFFSET(group)].commands != NULL) |
|
quit(1, "API duplicate group name '%c'", *ptr); |
|
|
|
ptr += 2; |
|
|
|
// Validate the command list (and handle '*') |
|
cmd = &(commands[0]); |
|
*(cmd++) = SEPARATOR; |
|
*cmd = '\0'; |
|
addstar = false; |
|
while (ptr && *ptr) { |
|
colon = strchr(ptr, ':'); |
|
if (colon) |
|
*(colon++) = '\0'; |
|
|
|
if (strcmp(ptr, "*") == 0) |
|
addstar = true; |
|
else { |
|
did = false; |
|
for (i = 0; cmds[i].name != NULL; i++) { |
|
if (strcasecmp(ptr, cmds[i].name) == 0) { |
|
did = true; |
|
break; |
|
} |
|
} |
|
if (did) { |
|
// skip duplicates |
|
sprintf(cmdbuf, "|%s|", cmds[i].name); |
|
if (strstr(commands, cmdbuf) == NULL) { |
|
strcpy(cmd, cmds[i].name); |
|
cmd += strlen(cmds[i].name); |
|
*(cmd++) = SEPARATOR; |
|
*cmd = '\0'; |
|
} |
|
} else { |
|
quit(1, "API unknown command '%s' in group '%c'", ptr, group); |
|
} |
|
} |
|
|
|
ptr = colon; |
|
} |
|
|
|
// * = allow all non-iswritemode commands |
|
if (addstar) { |
|
for (i = 0; cmds[i].name != NULL; i++) { |
|
if (cmds[i].iswritemode == false) { |
|
// skip duplicates |
|
sprintf(cmdbuf, "|%s|", cmds[i].name); |
|
if (strstr(commands, cmdbuf) == NULL) { |
|
strcpy(cmd, cmds[i].name); |
|
cmd += strlen(cmds[i].name); |
|
*(cmd++) = SEPARATOR; |
|
*cmd = '\0'; |
|
} |
|
} |
|
} |
|
} |
|
|
|
ptr = apigroups[GROUPOFFSET(group)].commands = malloc(strlen(commands) + 1); |
|
if (unlikely(!ptr)) |
|
quit(1, "Failed to malloc group commands buf"); |
|
|
|
strcpy(ptr, commands); |
|
} |
|
|
|
// Now define R (NOPRIVGROUP) as all non-iswritemode commands |
|
cmd = &(commands[0]); |
|
*(cmd++) = SEPARATOR; |
|
*cmd = '\0'; |
|
for (i = 0; cmds[i].name != NULL; i++) { |
|
if (cmds[i].iswritemode == false) { |
|
strcpy(cmd, cmds[i].name); |
|
cmd += strlen(cmds[i].name); |
|
*(cmd++) = SEPARATOR; |
|
*cmd = '\0'; |
|
} |
|
} |
|
|
|
ptr = apigroups[GROUPOFFSET(NOPRIVGROUP)].commands = malloc(strlen(commands) + 1); |
|
if (unlikely(!ptr)) |
|
quit(1, "Failed to malloc noprivgroup commands buf"); |
|
|
|
strcpy(ptr, commands); |
|
|
|
// W (PRIVGROUP) is handled as a special case since it simply means all commands |
|
|
|
free(buf); |
|
return; |
|
} |
|
|
|
/* |
|
* Interpret [W:]IP[/Prefix][,[R|W:]IP2[/Prefix2][,...]] --api-allow option |
|
* special case of 0/0 allows /0 (means all IP addresses) |
|
*/ |
|
#define ALLIP4 "0/0" |
|
/* |
|
* N.B. IP4 addresses are by Definition 32bit big endian on all platforms |
|
*/ |
|
static void setup_ipaccess() |
|
{ |
|
char *buf, *ptr, *comma, *slash, *dot; |
|
int ipcount, mask, octet, i; |
|
char group; |
|
|
|
buf = malloc(strlen(opt_api_allow) + 1); |
|
if (unlikely(!buf)) |
|
quit(1, "Failed to malloc ipaccess buf"); |
|
|
|
strcpy(buf, opt_api_allow); |
|
|
|
ipcount = 1; |
|
ptr = buf; |
|
while (*ptr) |
|
if (*(ptr++) == ',') |
|
ipcount++; |
|
|
|
// possibly more than needed, but never less |
|
ipaccess = calloc(ipcount, sizeof(struct IP4ACCESS)); |
|
if (unlikely(!ipaccess)) |
|
quit(1, "Failed to calloc ipaccess"); |
|
|
|
ips = 0; |
|
ptr = buf; |
|
while (ptr && *ptr) { |
|
while (*ptr == ' ' || *ptr == '\t') |
|
ptr++; |
|
|
|
if (*ptr == ',') { |
|
ptr++; |
|
continue; |
|
} |
|
|
|
comma = strchr(ptr, ','); |
|
if (comma) |
|
*(comma++) = '\0'; |
|
|
|
group = NOPRIVGROUP; |
|
|
|
if (isalpha(*ptr) && *(ptr+1) == ':') { |
|
if (DEFINEDGROUP(*ptr)) |
|
group = GROUP(*ptr); |
|
|
|
ptr += 2; |
|
} |
|
|
|
ipaccess[ips].group = group; |
|
|
|
if (strcmp(ptr, ALLIP4) == 0) |
|
ipaccess[ips].ip = ipaccess[ips].mask = 0; |
|
else { |
|
slash = strchr(ptr, '/'); |
|
if (!slash) |
|
ipaccess[ips].mask = 0xffffffff; |
|
else { |
|
*(slash++) = '\0'; |
|
mask = atoi(slash); |
|
if (mask < 1 || mask > 32) |
|
goto popipo; // skip invalid/zero |
|
|
|
ipaccess[ips].mask = 0; |
|
while (mask-- >= 0) { |
|
octet = 1 << (mask % 8); |
|
ipaccess[ips].mask |= (octet << (24 - (8 * (mask >> 3)))); |
|
} |
|
} |
|
|
|
ipaccess[ips].ip = 0; // missing default to '.0' |
|
for (i = 0; ptr && (i < 4); i++) { |
|
dot = strchr(ptr, '.'); |
|
if (dot) |
|
*(dot++) = '\0'; |
|
|
|
octet = atoi(ptr); |
|
if (octet < 0 || octet > 0xff) |
|
goto popipo; // skip invalid |
|
|
|
ipaccess[ips].ip |= (octet << (24 - (i * 8))); |
|
|
|
ptr = dot; |
|
} |
|
|
|
ipaccess[ips].ip &= ipaccess[ips].mask; |
|
} |
|
|
|
ips++; |
|
popipo: |
|
ptr = comma; |
|
} |
|
|
|
free(buf); |
|
} |
|
|
|
static void *quit_thread(__maybe_unused void *userdata) |
|
{ |
|
// allow thread creator to finish whatever it's doing |
|
mutex_lock(&quit_restart_lock); |
|
mutex_unlock(&quit_restart_lock); |
|
|
|
if (opt_debug) |
|
applog(LOG_DEBUG, "API: killing cgminer"); |
|
|
|
kill_work(); |
|
|
|
return NULL; |
|
} |
|
|
|
static void *restart_thread(__maybe_unused void *userdata) |
|
{ |
|
// allow thread creator to finish whatever it's doing |
|
mutex_lock(&quit_restart_lock); |
|
mutex_unlock(&quit_restart_lock); |
|
|
|
if (opt_debug) |
|
applog(LOG_DEBUG, "API: restarting cgminer"); |
|
|
|
app_restart(); |
|
|
|
return NULL; |
|
} |
|
|
|
static bool check_connect(struct sockaddr_in *cli, char **connectaddr, char *group) |
|
{ |
|
bool addrok = false; |
|
int i; |
|
|
|
*connectaddr = inet_ntoa(cli->sin_addr); |
|
|
|
*group = NOPRIVGROUP; |
|
if (opt_api_allow) { |
|
int client_ip = htonl(cli->sin_addr.s_addr); |
|
for (i = 0; i < ips; i++) { |
|
if ((client_ip & ipaccess[i].mask) == ipaccess[i].ip) { |
|
addrok = true; |
|
*group = ipaccess[i].group; |
|
break; |
|
} |
|
} |
|
} else { |
|
if (opt_api_network) |
|
addrok = true; |
|
else |
|
addrok = (strcmp(*connectaddr, localaddr) == 0); |
|
} |
|
|
|
return addrok; |
|
} |
|
|
|
static void mcast() |
|
{ |
|
struct sockaddr_in listen; |
|
struct ip_mreq grp; |
|
struct sockaddr_in came_from; |
|
time_t bindstart; |
|
char *binderror; |
|
SOCKETTYPE mcast_sock; |
|
SOCKETTYPE reply_sock; |
|
socklen_t came_from_siz; |
|
char *connectaddr; |
|
ssize_t rep; |
|
int bound; |
|
int count; |
|
int reply_port; |
|
bool addrok; |
|
char group; |
|
|
|
char expect[] = "cgminer-"; // first 8 bytes constant |
|
char *expect_code; |
|
size_t expect_code_len; |
|
char buf[1024]; |
|
char replybuf[1024]; |
|
|
|
memset(&grp, 0, sizeof(grp)); |
|
grp.imr_multiaddr.s_addr = inet_addr(opt_api_mcast_addr); |
|
if (grp.imr_multiaddr.s_addr == INADDR_NONE) |
|
quit(1, "Invalid Multicast Address"); |
|
grp.imr_interface.s_addr = INADDR_ANY; |
|
|
|
mcast_sock = socket(AF_INET, SOCK_DGRAM, 0); |
|
|
|
int optval = 1; |
|
if (SOCKETFAIL(setsockopt(mcast_sock, SOL_SOCKET, SO_REUSEADDR, (void *)(&optval), sizeof(optval)))) { |
|
applog(LOG_ERR, "API mcast setsockopt SO_REUSEADDR failed (%s)%s", SOCKERRMSG, MUNAVAILABLE); |
|
goto die; |
|
} |
|
|
|
memset(&listen, 0, sizeof(listen)); |
|
listen.sin_family = AF_INET; |
|
listen.sin_addr.s_addr = INADDR_ANY; |
|
listen.sin_port = htons(opt_api_mcast_port); |
|
|
|
// try for more than 1 minute ... in case the old one hasn't completely gone yet |
|
bound = 0; |
|
bindstart = time(NULL); |
|
while (bound == 0) { |
|
if (SOCKETFAIL(bind(mcast_sock, (struct sockaddr *)(&listen), sizeof(listen)))) { |
|
binderror = SOCKERRMSG; |
|
if ((time(NULL) - bindstart) > 61) |
|
break; |
|
else |
|
cgsleep_ms(30000); |
|
} else |
|
bound = 1; |
|
} |
|
|
|
if (bound == 0) { |
|
applog(LOG_ERR, "API mcast bind to port %d failed (%s)%s", opt_api_port, binderror, MUNAVAILABLE); |
|
goto die; |
|
} |
|
|
|
if (SOCKETFAIL(setsockopt(mcast_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void *)(&grp), sizeof(grp)))) { |
|
applog(LOG_ERR, "API mcast join failed (%s)%s", SOCKERRMSG, MUNAVAILABLE); |
|
goto die; |
|
} |
|
|
|
expect_code_len = sizeof(expect) + strlen(opt_api_mcast_code); |
|
expect_code = malloc(expect_code_len+1); |
|
if (!expect_code) |
|
quit(1, "Failed to malloc mcast expect_code"); |
|
snprintf(expect_code, expect_code_len+1, "%s%s-", expect, opt_api_mcast_code); |
|
|
|
count = 0; |
|
while (80085) { |
|
cgsleep_ms(1000); |
|
|
|
count++; |
|
came_from_siz = sizeof(came_from); |
|
if (SOCKETFAIL(rep = recvfrom(mcast_sock, buf, sizeof(buf), |
|
0, (struct sockaddr *)(&came_from), &came_from_siz))) { |
|
applog(LOG_DEBUG, "API mcast failed count=%d (%s) (%d)", |
|
count, SOCKERRMSG, (int)mcast_sock); |
|
continue; |
|
} |
|
|
|
addrok = check_connect(&came_from, &connectaddr, &group); |
|
applog(LOG_DEBUG, "API mcast from %s - %s", |
|
connectaddr, addrok ? "Accepted" : "Ignored"); |
|
if (!addrok) |
|
continue; |
|
|
|
buf[rep] = '\0'; |
|
if (rep > 0 && buf[rep-1] == '\n') |
|
buf[--rep] = '\0'; |
|
|
|
applog(LOG_DEBUG, "API mcast request rep=%d (%s) from %s:%d", |
|
(int)rep, buf, |
|
inet_ntoa(came_from.sin_addr), |
|
ntohs(came_from.sin_port)); |
|
|
|
if ((size_t)rep > expect_code_len && memcmp(buf, expect_code, expect_code_len) == 0) { |
|
reply_port = atoi(&buf[expect_code_len]); |
|
if (reply_port < 1 || reply_port > 65535) { |
|
applog(LOG_DEBUG, "API mcast request ignored - invalid port (%s)", |
|
&buf[expect_code_len]); |
|
} else { |
|
applog(LOG_DEBUG, "API mcast request OK port %s=%d", |
|
&buf[expect_code_len], reply_port); |
|
|
|
came_from.sin_port = htons(reply_port); |
|
reply_sock = socket(AF_INET, SOCK_DGRAM, 0); |
|
|
|
snprintf(replybuf, sizeof(replybuf), |
|
"cgm-" API_MCAST_CODE "-%d-%s", |
|
opt_api_port, opt_api_mcast_des); |
|
|
|
rep = sendto(reply_sock, replybuf, strlen(replybuf)+1, |
|
0, (struct sockaddr *)(&came_from), |
|
sizeof(came_from)); |
|
if (SOCKETFAIL(rep)) { |
|
applog(LOG_DEBUG, "API mcast send reply failed (%s) (%d)", |
|
SOCKERRMSG, (int)reply_sock); |
|
} else { |
|
applog(LOG_DEBUG, "API mcast send reply (%s) succeeded (%d) (%d)", |
|
replybuf, (int)rep, (int)reply_sock); |
|
} |
|
|
|
CLOSESOCKET(reply_sock); |
|
} |
|
} else |
|
applog(LOG_DEBUG, "API mcast request was no good"); |
|
} |
|
|
|
die: |
|
|
|
CLOSESOCKET(mcast_sock); |
|
} |
|
|
|
static void *mcast_thread(void *userdata) |
|
{ |
|
struct thr_info *mythr = userdata; |
|
|
|
pthread_detach(pthread_self()); |
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); |
|
|
|
RenameThread("api_mcast"); |
|
|
|
mcast(); |
|
|
|
PTH(mythr) = 0L; |
|
|
|
return NULL; |
|
} |
|
|
|
void mcast_init() |
|
{ |
|
struct thr_info *thr; |
|
|
|
thr = calloc(1, sizeof(*thr)); |
|
if (!thr) |
|
quit(1, "Failed to calloc mcast thr"); |
|
|
|
if (thr_info_create(thr, NULL, mcast_thread, thr)) |
|
quit(1, "API mcast thread create failed"); |
|
} |
|
|
|
void api(int api_thr_id) |
|
{ |
|
struct io_data *io_data; |
|
struct thr_info bye_thr; |
|
char buf[TMPBUFSIZ]; |
|
char param_buf[TMPBUFSIZ]; |
|
SOCKETTYPE c; |
|
int n, bound; |
|
char *connectaddr; |
|
char *binderror; |
|
time_t bindstart; |
|
short int port = opt_api_port; |
|
struct sockaddr_in serv; |
|
struct sockaddr_in cli; |
|
socklen_t clisiz; |
|
char cmdbuf[100]; |
|
char *cmd; |
|
char *param; |
|
bool addrok; |
|
char group; |
|
json_error_t json_err; |
|
json_t *json_config; |
|
json_t *json_val; |
|
bool isjson; |
|
bool did; |
|
int i; |
|
|
|
SOCKETTYPE *apisock; |
|
|
|
apisock = malloc(sizeof(*apisock)); |
|
*apisock = INVSOCK; |
|
|
|
if (!opt_api_listen) { |
|
applog(LOG_DEBUG, "API not running%s", UNAVAILABLE); |
|
return; |
|
} |
|
|
|
io_data = sock_io_new(); |
|
|
|
mutex_init(&quit_restart_lock); |
|
|
|
pthread_cleanup_push(tidyup, (void *)apisock); |
|
my_thr_id = api_thr_id; |
|
|
|
setup_groups(); |
|
|
|
if (opt_api_allow) { |
|
setup_ipaccess(); |
|
|
|
if (ips == 0) { |
|
applog(LOG_WARNING, "API not running (no valid IPs specified)%s", UNAVAILABLE); |
|
return; |
|
} |
|
} |
|
|
|
/* This should be done before curl in needed |
|
* to ensure curl has already called WSAStartup() in windows */ |
|
cgsleep_ms(opt_log_interval*1000); |
|
|
|
*apisock = socket(AF_INET, SOCK_STREAM, 0); |
|
if (*apisock == INVSOCK) { |
|
applog(LOG_ERR, "API1 initialisation failed (%s)%s", SOCKERRMSG, UNAVAILABLE); |
|
return; |
|
} |
|
|
|
memset(&serv, 0, sizeof(serv)); |
|
|
|
serv.sin_family = AF_INET; |
|
|
|
if (!opt_api_allow && !opt_api_network) { |
|
serv.sin_addr.s_addr = inet_addr(localaddr); |
|
if (serv.sin_addr.s_addr == (in_addr_t)INVINETADDR) { |
|
applog(LOG_ERR, "API2 initialisation failed (%s)%s", SOCKERRMSG, UNAVAILABLE); |
|
return; |
|
} |
|
} |
|
|
|
serv.sin_port = htons(port); |
|
|
|
#ifndef WIN32 |
|
// On linux with SO_REUSEADDR, bind will get the port if the previous |
|
// socket is closed (even if it is still in TIME_WAIT) but fail if |
|
// another program has it open - which is what we want |
|
int optval = 1; |
|
// If it doesn't work, we don't really care - just show a debug message |
|
if (SOCKETFAIL(setsockopt(*apisock, SOL_SOCKET, SO_REUSEADDR, (void *)(&optval), sizeof(optval)))) |
|
applog(LOG_DEBUG, "API setsockopt SO_REUSEADDR failed (ignored): %s", SOCKERRMSG); |
|
#else |
|
// On windows a 2nd program can bind to a port>1024 already in use unless |
|
// SO_EXCLUSIVEADDRUSE is used - however then the bind to a closed port |
|
// in TIME_WAIT will fail until the timeout - so we leave the options alone |
|
#endif |
|
|
|
// try for more than 1 minute ... in case the old one hasn't completely gone yet |
|
bound = 0; |
|
bindstart = time(NULL); |
|
while (bound == 0) { |
|
if (SOCKETFAIL(bind(*apisock, (struct sockaddr *)(&serv), sizeof(serv)))) { |
|
binderror = SOCKERRMSG; |
|
if ((time(NULL) - bindstart) > 61) |
|
break; |
|
else { |
|
applog(LOG_WARNING, "API bind to port %d failed - trying again in 30sec", port); |
|
cgsleep_ms(30000); |
|
} |
|
} else |
|
bound = 1; |
|
} |
|
|
|
if (bound == 0) { |
|
applog(LOG_ERR, "API bind to port %d failed (%s)%s", port, binderror, UNAVAILABLE); |
|
return; |
|
} |
|
|
|
if (SOCKETFAIL(listen(*apisock, QUEUE))) { |
|
applog(LOG_ERR, "API3 initialisation failed (%s)%s", SOCKERRMSG, UNAVAILABLE); |
|
CLOSESOCKET(*apisock); |
|
return; |
|
} |
|
|
|
if (opt_api_allow) |
|
applog(LOG_WARNING, "API running in IP access mode on port %d (%d)", port, (int)*apisock); |
|
else { |
|
if (opt_api_network) |
|
applog(LOG_WARNING, "API running in UNRESTRICTED read access mode on port %d (%d)", port, (int)*apisock); |
|
else |
|
applog(LOG_WARNING, "API running in local read access mode on port %d (%d)", port, (int)*apisock); |
|
} |
|
|
|
if (opt_api_mcast) |
|
mcast_init(); |
|
|
|
while (!bye) { |
|
clisiz = sizeof(cli); |
|
if (SOCKETFAIL(c = accept(*apisock, (struct sockaddr *)(&cli), &clisiz))) { |
|
applog(LOG_ERR, "API failed (%s)%s (%d)", SOCKERRMSG, UNAVAILABLE, (int)*apisock); |
|
goto die; |
|
} |
|
|
|
addrok = check_connect(&cli, &connectaddr, &group); |
|
applog(LOG_DEBUG, "API: connection from %s - %s", |
|
connectaddr, addrok ? "Accepted" : "Ignored"); |
|
|
|
if (addrok) { |
|
n = recv(c, &buf[0], TMPBUFSIZ-1, 0); |
|
if (SOCKETFAIL(n)) |
|
buf[0] = '\0'; |
|
else |
|
buf[n] = '\0'; |
|
|
|
if (opt_debug) { |
|
if (SOCKETFAIL(n)) |
|
applog(LOG_DEBUG, "API: recv failed: %s", SOCKERRMSG); |
|
else |
|
applog(LOG_DEBUG, "API: recv command: (%d) '%s'", n, buf); |
|
} |
|
|
|
if (!SOCKETFAIL(n)) { |
|
// the time of the request in now |
|
when = time(NULL); |
|
io_reinit(io_data); |
|
|
|
did = false; |
|
|
|
if (*buf != ISJSON) { |
|
isjson = false; |
|
|
|
param = strchr(buf, SEPARATOR); |
|
if (param != NULL) |
|
*(param++) = '\0'; |
|
|
|
cmd = buf; |
|
} |
|
else { |
|
isjson = true; |
|
|
|
param = NULL; |
|
|
|
#if JANSSON_MAJOR_VERSION > 2 || (JANSSON_MAJOR_VERSION == 2 && JANSSON_MINOR_VERSION > 0) |
|
json_config = json_loadb(buf, n, 0, &json_err); |
|
#elif JANSSON_MAJOR_VERSION > 1 |
|
json_config = json_loads(buf, 0, &json_err); |
|
#else |
|
json_config = json_loads(buf, &json_err); |
|
#endif |
|
|
|
if (!json_is_object(json_config)) { |
|
message(io_data, MSG_INVJSON, 0, NULL, isjson); |
|
send_result(io_data, c, isjson); |
|
did = true; |
|
} |
|
else { |
|
json_val = json_object_get(json_config, JSON_COMMAND); |
|
if (json_val == NULL) { |
|
message(io_data, MSG_MISCMD, 0, NULL, isjson); |
|
send_result(io_data, c, isjson); |
|
did = true; |
|
} |
|
else { |
|
if (!json_is_string(json_val)) { |
|
message(io_data, MSG_INVCMD, 0, NULL, isjson); |
|
send_result(io_data, c, isjson); |
|
did = true; |
|
} |
|
else { |
|
cmd = (char *)json_string_value(json_val); |
|
json_val = json_object_get(json_config, JSON_PARAMETER); |
|
if (json_is_string(json_val)) |
|
param = (char *)json_string_value(json_val); |
|
else if (json_is_integer(json_val)) { |
|
sprintf(param_buf, "%d", (int)json_integer_value(json_val)); |
|
param = param_buf; |
|
} else if (json_is_real(json_val)) { |
|
sprintf(param_buf, "%f", (double)json_real_value(json_val)); |
|
param = param_buf; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (!did) |
|
for (i = 0; cmds[i].name != NULL; i++) { |
|
if (strcmp(cmd, cmds[i].name) == 0) { |
|
sprintf(cmdbuf, "|%s|", cmd); |
|
if (ISPRIVGROUP(group) || strstr(COMMANDS(group), cmdbuf)) |
|
(cmds[i].func)(io_data, c, param, isjson, group); |
|
else { |
|
message(io_data, MSG_ACCDENY, 0, cmds[i].name, isjson); |
|
applog(LOG_DEBUG, "API: access denied to '%s' for '%s' command", connectaddr, cmds[i].name); |
|
} |
|
|
|
send_result(io_data, c, isjson); |
|
did = true; |
|
break; |
|
} |
|
} |
|
|
|
if (!did) { |
|
message(io_data, MSG_INVCMD, 0, NULL, isjson); |
|
send_result(io_data, c, isjson); |
|
} |
|
} |
|
} |
|
CLOSESOCKET(c); |
|
} |
|
die: |
|
/* Blank line fix for older compilers since pthread_cleanup_pop is a |
|
* macro that gets confused by a label existing immediately before it |
|
*/ |
|
; |
|
pthread_cleanup_pop(true); |
|
|
|
if (opt_debug) |
|
applog(LOG_DEBUG, "API: terminating due to: %s", |
|
do_a_quit ? "QUIT" : (do_a_restart ? "RESTART" : (bye ? "BYE" : "UNKNOWN!"))); |
|
|
|
mutex_lock(&quit_restart_lock); |
|
|
|
if (do_a_restart) { |
|
if (thr_info_create(&bye_thr, NULL, restart_thread, &bye_thr)) { |
|
mutex_unlock(&quit_restart_lock); |
|
quit(1, "API failed to initiate a restart - aborting"); |
|
} |
|
pthread_detach(bye_thr.pth); |
|
} else if (do_a_quit) { |
|
if (thr_info_create(&bye_thr, NULL, quit_thread, &bye_thr)) { |
|
mutex_unlock(&quit_restart_lock); |
|
quit(1, "API failed to initiate a clean quit - aborting"); |
|
} |
|
pthread_detach(bye_thr.pth); |
|
} |
|
|
|
mutex_unlock(&quit_restart_lock); |
|
}
|
|
|