Changeset 5719

Show
Ignore:
Timestamp:
05/13/09 18:04:51 (5 years ago)
Author:
andy
Message:

sensord: Introduce struct sensord_args.

This structure encapsulate all the variables holding the commandline
arguments. So we get rid of plenty of extern variables. This reduces
namespace collisions and unifies access.

Location:
lm-sensors/trunk/prog/sensord
Files:
5 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/trunk/prog/sensord/args.c

    r5718 r5719  
    2828#include <syslog.h> 
    2929 
     30#include "args.h" 
    3031#include "sensord.h" 
    3132#include "lib/error.h" 
    3233#include "version.h" 
    3334 
    34 #define MAX_CHIP_NAMES 32 
    35  
    36 int isDaemon = 0; 
    37 const char *sensorsCfgFile = NULL; 
    38 const char *pidFile = "/var/run/sensord.pid"; 
    39 const char *rrdFile = NULL; 
    40 const char *cgiDir = NULL; 
    41 int scanTime = 60; 
    42 int logTime = 30 * 60; 
    43 int rrdTime = 5 * 60; 
    44 int rrdNoAverage = 0; 
    45 int syslogFacility = LOG_LOCAL4; 
    46 int doCGI = 0; 
    47 int doLoad = 0; 
    48 int debug = 0; 
    49 sensors_chip_name chipNames[MAX_CHIP_NAMES]; 
    50 int numChipNames = 0; 
     35struct sensord_arguments sensord_args = { 
     36        .pidFile = "/var/run/sensord.pid", 
     37        .scanTime = 60, 
     38        .logTime = 30 * 60, 
     39        .rrdTime = 5 * 60, 
     40        .syslogFacility = LOG_LOCAL4, 
     41}; 
    5142 
    5243static int parseTime(char *arg) 
     
    149140        int c; 
    150141 
    151         isDaemon = (argv[0][strlen (argv[0]) - 1] == 'd'); 
    152         if (!isDaemon) { 
     142        sensord_args.isDaemon = (argv[0][strlen (argv[0]) - 1] == 'd'); 
     143        if (!sensord_args.isDaemon) { 
    153144                fprintf(stderr, "Sensord no longer runs as an commandline" 
    154145                        " application.\n"); 
    155146                return -1; 
    156         } 
     147        } 
    157148 
    158149        while ((c = getopt_long(argc, argv, shortOptions, longOptions, NULL)) 
     
    160151                switch(c) { 
    161152                case 'i': 
    162                         if ((scanTime = parseTime(optarg)) < 0) 
     153                        if ((sensord_args.scanTime = parseTime(optarg)) < 0) 
    163154                                return -1; 
    164155                        break; 
    165156                case 'l': 
    166                         if ((logTime = parseTime(optarg)) < 0) 
     157                        if ((sensord_args.logTime = parseTime(optarg)) < 0) 
    167158                                return -1; 
    168159                        break; 
    169160                case 't': 
    170                         if ((rrdTime = parseTime(optarg)) < 0) 
     161                        if ((sensord_args.rrdTime = parseTime(optarg)) < 0) 
    171162                                return -1; 
    172163                        break; 
    173164                case 'T': 
    174                         rrdNoAverage = 1; 
     165                        sensord_args.rrdNoAverage = 1; 
    175166                        break; 
    176167                case 'f': 
    177                         if ((syslogFacility = parseFacility(optarg)) < 0) 
     168                        sensord_args.syslogFacility = parseFacility(optarg); 
     169                        if (sensord_args.syslogFacility < 0) 
    178170                                return -1; 
    179171                        break; 
    180172                case 'a': 
    181                         doLoad = 1; 
     173                        sensord_args.doLoad = 1; 
    182174                        break; 
    183175                case 'c': 
    184                         sensorsCfgFile = optarg; 
     176                        sensord_args.cfgFile = optarg; 
    185177                        break; 
    186178                case 'p': 
    187                         pidFile = optarg; 
     179                        sensord_args.pidFile = optarg; 
    188180                        break; 
    189181                case 'r': 
    190                         rrdFile = optarg; 
     182                        sensord_args.rrdFile = optarg; 
    191183                        break; 
    192184                case 'd': 
    193                         debug = 1; 
     185                        sensord_args.debug = 1; 
    194186                        break; 
    195187                case 'g': 
    196                         doCGI = 1; 
    197                         cgiDir = optarg; 
     188                        sensord_args.doCGI = 1; 
     189                        sensord_args.cgiDir = optarg; 
    198190                        break; 
    199191                case 'v': 
     
    220212        } 
    221213 
    222         if (doCGI && !rrdFile) { 
     214        if (sensord_args.doCGI && !sensord_args.rrdFile) { 
    223215                fprintf(stderr, 
    224216                        "Error: Incompatible --rrd-cgi without --rrd-file.\n"); 
     
    226218        } 
    227219 
    228         if (rrdFile && !rrdTime) { 
     220        if (sensord_args.rrdFile && !sensord_args.rrdTime) { 
    229221                fprintf(stderr, 
    230222                        "Error: Incompatible --rrd-file without --rrd-interval.\n"); 
     
    232224        } 
    233225 
    234         if (!logTime && !scanTime && !rrdFile) { 
     226        if (!sensord_args.logTime && !sensord_args.scanTime && 
     227            !sensord_args.rrdFile) { 
    235228                fprintf(stderr, 
    236229                        "Error: No logging, alarm or RRD scanning.\n"); 
     
    244237{ 
    245238        if (optind == argc) { 
    246                 chipNames[0].prefix = SENSORS_CHIP_NAME_PREFIX_ANY; 
    247                 chipNames[0].bus.type = SENSORS_BUS_TYPE_ANY; 
    248                 chipNames[0].bus.nr = SENSORS_BUS_NR_ANY; 
    249                 chipNames[0].addr = SENSORS_CHIP_NAME_ADDR_ANY; 
    250                 numChipNames = 1; 
     239                sensord_args.chipNames[0].prefix = 
     240                        SENSORS_CHIP_NAME_PREFIX_ANY; 
     241                sensord_args.chipNames[0].bus.type = SENSORS_BUS_TYPE_ANY; 
     242                sensord_args.chipNames[0].bus.nr = SENSORS_BUS_NR_ANY; 
     243                sensord_args.chipNames[0].addr = SENSORS_CHIP_NAME_ADDR_ANY; 
     244                sensord_args.numChipNames = 1; 
    251245        } else { 
    252246                int i, n = argc - optind, err; 
     
    257251                for (i = 0; i < n; ++ i) { 
    258252                        char *arg = argv[optind + i]; 
    259                         if ((err = sensors_parse_chip_name(arg, 
    260                                                            chipNames + i))) { 
     253 
     254                        err = sensors_parse_chip_name(arg, 
     255                                                      sensord_args.chipNames + 
     256                                                      i); 
     257                        if (err) { 
    261258                                fprintf(stderr, 
    262259                                        "Invalid chip name `%s': %s\n", arg, 
     
    265262                        } 
    266263                } 
    267                 numChipNames = n; 
     264                sensord_args.numChipNames = n; 
    268265        } 
    269266        return 0; 
  • lm-sensors/trunk/prog/sensord/rrd.c

    r5679 r5719  
    4444#include <rrd.h> 
    4545 
     46#include "args.h" 
    4647#include "sensord.h" 
    4748 
     
    142143        int i, j, ret = 0, num = 0; 
    143144 
    144         for (j = 0; (ret == 0) && (j < numChipNames); ++ j) { 
     145        for (j = 0; (ret == 0) && (j < sensord_args.numChipNames); ++ j) { 
    145146                i = 0; 
    146                 while ((ret == 0) && ((chip = sensors_get_detected_chips(&chipNames[j], &i)) != NULL)) { 
     147                while ((ret == 0) && ((chip = sensors_get_detected_chips(&sensord_args.chipNames[j], &i)) != NULL)) { 
    147148                        int index0, chipindex = -1; 
    148149 
     
    224225                 * instead of unknown 
    225226                 */ 
    226                 sprintf(ptr, "DS:%s:GAUGE:%d:%s:%s", rawLabel, 5 * rrdTime, 
    227                         min, max); 
     227                sprintf(ptr, "DS:%s:GAUGE:%d:%s:%s", rawLabel, 5 * 
     228                        sensord_args.rrdTime, min, max); 
    228229        } 
    229230        return 0; 
     
    235236        struct ds data = { 0, argv}; 
    236237        ret = applyToFeatures(rrdGetSensors_DS, &data); 
    237         if (!ret && doLoad) 
     238        if (!ret && sensord_args.doLoad) 
    238239                ret = rrdGetSensors_DS(&data, LOADAVG, LOAD_AVERAGE, NULL); 
    239240        return ret ? -1 : data.num; 
     
    246247 
    247248        sensorLog(LOG_DEBUG, "sensor RRD init"); 
    248         if (stat(rrdFile, &tmp)) { 
     249        if (stat(sensord_args.rrdFile, &tmp)) { 
    249250                if (errno == ENOENT) { 
    250251                        char stepBuff[STEP_BUFF], rraBuff[RRA_BUFF]; 
    251252                        int argc = 4, num; 
    252253                        const char *argv[6 + MAX_RRD_SENSORS] = { 
    253                                 "sensord", rrdFile, "-s", stepBuff 
     254                                "sensord", sensord_args.rrdFile, "-s", stepBuff 
    254255                        }; 
    255256 
     
    259260                                sensorLog(LOG_ERR, 
    260261                                          "Error creating RRD: %s: %s", 
    261                                           rrdFile, "No sensors detected"); 
     262                                          sensord_args.rrdFile, 
     263                                          "No sensors detected"); 
    262264                                ret = 2; 
    263265                        } else if (num < 0) { 
    264266                                ret = -num; 
    265267                        } else { 
    266                                 sprintf(stepBuff, "%d", rrdTime); 
     268                                sprintf(stepBuff, "%d", sensord_args.rrdTime); 
    267269                                sprintf(rraBuff, "RRA:%s:%f:%d:%d", 
    268                                         rrdNoAverage?"LAST":"AVERAGE", 
     270                                        sensord_args.rrdNoAverage ? "LAST" : 
     271                                        "AVERAGE", 
    269272                                        0.5 /* fraction of non-unknown samples needed per entry */, 
    270273                                        1 /* samples per entry */, 
    271                                         7 * 24 * 60 * 60 / rrdTime /* 1 week */); 
     274                                        7 * 24 * 60 * 60 / 
     275                                        sensord_args.rrdTime /* 1 week */); 
     276 
    272277                                argc += num; 
    273278                                argv[argc ++] = rraBuff; 
     
    277282                                        sensorLog(LOG_ERR, 
    278283                                                  "Error creating RRD file: %s: %s", 
    279                                                   rrdFile, rrd_get_error()); 
     284                                                  sensord_args.rrdFile, 
     285                                                  rrd_get_error()); 
    280286                                } 
    281287                        } 
    282288                } else { 
    283289                        sensorLog(LOG_ERR, "Error stat()ing RRD: %s: %s", 
    284                                   rrdFile, strerror(errno)); 
     290                                  sensord_args.rrdFile, strerror(errno)); 
    285291                        ret = 1; 
    286292                } 
     
    311317        (void) label; /* no warning */ 
    312318        if (!feature || (feature->rrd && (feature->type == data->type))) 
    313                 printf("\n\tDEF:%s=%s:%s:AVERAGE", rawLabel, rrdFile, 
    314                        rawLabel); 
     319                printf("\n\tDEF:%s=%s:%s:AVERAGE", rawLabel, 
     320                       sensord_args.rrdFile, rawLabel); 
    315321        return 0; 
    316322} 
     
    421427{ 
    422428        int ret = rrdChips (); 
    423         if (!ret && doLoad) { 
     429 
     430        if (!ret && sensord_args.doLoad) { 
    424431                FILE *loadavg; 
    425432                if (!(loadavg = fopen("/proc/loadavg", "r"))) { 
     
    443450        if (!ret) { 
    444451                const char *argv[] = { 
    445                         "sensord", rrdFile, rrdBuff, NULL 
     452                        "sensord", sensord_args.rrdFile, rrdBuff, NULL 
    446453                }; 
    447454                if ((ret = rrd_update(3, (char **) /* WEAK */ argv))) { 
    448455                        sensorLog(LOG_ERR, "Error updating RRD file: %s: %s", 
    449                                   rrdFile, rrd_get_error()); 
     456                                  sensord_args.rrdFile, rrd_get_error()); 
    450457                } 
    451458        } 
     
    464471                printf("<H2>%s</H2>\n", graph->h2); 
    465472                printf("<P>\n<RRD::GRAPH %s/%s.png\n\t--imginfo '<IMG SRC=" WWWDIR "/%%s WIDTH=%%lu HEIGHT=%%lu>'\n\t-a PNG\n\t-h 200 -w 800\n", 
    466                        cgiDir, graph->image); 
     473                       sensord_args.cgiDir, graph->image); 
    467474                printf("\t--lazy\n\t-v '%s'\n\t-t '%s'\n\t-x '%s'\n\t%s", 
    468475                       graph->axisTitle, graph->title, graph->axisDefn, 
     
    470477                if (!ret) 
    471478                        ret = applyToFeatures(rrdCGI_DEF, graph); 
    472                 if (!ret && doLoad && graph->loadAvg) 
     479                if (!ret && sensord_args.doLoad && graph->loadAvg) 
    473480                        ret = rrdCGI_DEF(graph, LOADAVG, LOAD_AVERAGE, NULL); 
    474481                if (!ret) 
    475482                        ret = applyToFeatures(rrdCGI_LINE, graph); 
    476                 if (!ret && doLoad && graph->loadAvg) 
     483                if (!ret && sensord_args.doLoad && graph->loadAvg) 
    477484                        ret = rrdCGI_LINE(graph, LOADAVG, LOAD_AVERAGE, NULL); 
    478485                printf (">\n</P>\n"); 
  • lm-sensors/trunk/prog/sensord/sense.c

    r5678 r5719  
    2727#include <syslog.h> 
    2828 
     29#include "args.h" 
    2930#include "sensord.h" 
    3031#include "lib/error.h" 
     
    190191        int i, j, ret = 0; 
    191192 
    192         for (j = 0; (ret == 0) && (j < numChipNames); ++ j) { 
     193        for (j = 0; (ret == 0) && (j < sensord_args.numChipNames); ++ j) { 
    193194                i = 0; 
    194195                while ((ret == 0) && 
    195                        ((chip = sensors_get_detected_chips(&chipNames[j], &i)) 
    196                         != NULL)) { 
     196                       ((chip = sensors_get_detected_chips(&sensord_args.chipNames[j], &i)) != NULL)) { 
    197197                        ret = doChip(chip, action); 
    198198                } 
  • lm-sensors/trunk/prog/sensord/sensord.c

    r5718 r5719  
    3434#include <sys/stat.h> 
    3535 
     36#include "args.h" 
    3637#include "sensord.h" 
    3738 
     
    5354        buffer[LOG_BUFFER] = '\0'; 
    5455        va_end(ap); 
    55         if (debug || (priority < LOG_DEBUG)) { 
     56        if (sensord_args.debug || (priority < LOG_DEBUG)) { 
    5657                if (logOpened) { 
    5758                        syslog(priority, "%s", buffer); 
     
    8485         * one timeslot updated twice on restart for example. 
    8586         */ 
    86         int rrdValue = rrdTime - time(NULL) % rrdTime; 
     87        int rrdValue = sensord_args.rrdTime - time(NULL) % 
     88                sensord_args.rrdTime; 
    8789 
    8890        sensorLog(LOG_INFO, "sensord started"); 
     
    9092        while (!done) { 
    9193                if (reload) { 
    92                         ret = reloadLib(sensorsCfgFile); 
     94                        ret = reloadLib(sensord_args.cfgFile); 
    9395                        if (ret) 
    9496                                sensorLog(LOG_NOTICE, 
     
    9698                        reload = 0; 
    9799                } 
    98                 if (scanTime && (scanValue <= 0)) { 
     100                if (sensord_args.scanTime && (scanValue <= 0)) { 
    99101                        if ((ret = scanChips())) 
    100102                                sensorLog(LOG_NOTICE, 
    101103                                          "sensor scan error (%d)", ret); 
    102                         scanValue += scanTime; 
    103                 } 
    104                 if (logTime && (logValue <= 0)) { 
     104                        scanValue += sensord_args.scanTime; 
     105                } 
     106                if (sensord_args.logTime && (logValue <= 0)) { 
    105107                        if ((ret = readChips())) 
    106108                                sensorLog(LOG_NOTICE, 
    107109                                          "sensor read error (%d)", ret); 
    108                         logValue += logTime; 
    109                 } 
    110                 if (rrdTime && rrdFile && (rrdValue <= 0)) { 
     110                        logValue += sensord_args.logTime; 
     111                } 
     112                if (sensord_args.rrdTime && sensord_args.rrdFile && 
     113                    (rrdValue <= 0)) { 
    111114                        if ((ret = rrdUpdate())) 
    112115                                sensorLog(LOG_NOTICE, 
     
    117120                         * interval. 
    118121                         */ 
    119                         rrdValue = rrdTime - time(NULL) % rrdTime; 
     122                        rrdValue = sensord_args.rrdTime - time(NULL) % 
     123                                sensord_args.rrdTime; 
    120124                } 
    121125                if (!done) { 
    122                         int a = logTime ? logValue : INT_MAX; 
    123                         int b = scanTime ? scanValue : INT_MAX; 
    124                         int c = (rrdTime && rrdFile) ? rrdValue : INT_MAX; 
     126                        int a = sensord_args.logTime ? logValue : INT_MAX; 
     127                        int b = sensord_args.scanTime ? scanValue : INT_MAX; 
     128                        int c = (sensord_args.rrdTime && sensord_args.rrdFile) 
     129                                ? rrdValue : INT_MAX; 
    125130                        int sleepTime = (a < b) ? ((a < c) ? a : c) : 
    126131                                ((b < c) ? b : c); 
     
    139144static void openLog(void) 
    140145{ 
    141         openlog("sensord", 0, syslogFacility); 
     146        openlog("sensord", 0, sensord_args.syslogFacility); 
    142147        logOpened = 1; 
    143148} 
     
    154159        } 
    155160 
    156         if (!(stat(pidFile, &fileStat)) && 
     161        if (!(stat(sensord_args.pidFile, &fileStat)) && 
    157162            ((!S_ISREG(fileStat.st_mode)) || (fileStat.st_size > 11))) { 
    158163                fprintf(stderr, 
    159164                        "Error: PID file `%s' already exists and looks suspicious.\n", 
    160                         pidFile); 
    161                 exit(EXIT_FAILURE); 
    162         } 
    163  
    164         if (!(file = fopen(pidFile, "w"))) { 
    165                 fprintf(stderr, "fopen(\"%s\"): %s\n", pidFile, 
     165                        sensord_args.pidFile); 
     166                exit(EXIT_FAILURE); 
     167        } 
     168 
     169        if (!(file = fopen(sensord_args.pidFile, "w"))) { 
     170                fprintf(stderr, "fopen(\"%s\"): %s\n", sensord_args.pidFile, 
    166171                        strerror(errno)); 
    167172                exit(EXIT_FAILURE); 
     
    198203static void undaemonize(void) 
    199204{ 
    200         unlink(pidFile); 
     205        unlink(sensord_args.pidFile); 
    201206        closelog(); 
    202207} 
     
    210215                exit(EXIT_FAILURE); 
    211216 
    212         if (loadLib(sensorsCfgFile)) 
     217        if (loadLib(sensord_args.cfgFile)) 
    213218                exit(EXIT_FAILURE); 
    214219 
    215220        openLog(); 
    216221 
    217         if (rrdFile) { 
     222        if (sensord_args.rrdFile) { 
    218223                ret = rrdInit(); 
    219224                if (ret) 
     
    221226        } 
    222227 
    223         if (doCGI) { 
     228        if (sensord_args.doCGI) { 
    224229                ret = rrdCGI(); 
    225230        } else { 
  • lm-sensors/trunk/prog/sensord/sensord.h

    r5718 r5719  
    2727 
    2828/* from args.c */ 
    29  
    30 extern int isDaemon; 
    31 extern const char *sensorsCfgFile; 
    32 extern const char *pidFile; 
    33 extern const char *rrdFile; 
    34 extern const char *cgiDir; 
    35 extern int scanTime; 
    36 extern int logTime; 
    37 extern int rrdTime; 
    38 extern int rrdNoAverage; 
    39 extern int syslogFacility; 
    40 extern int doCGI; 
    41 extern int doLoad; 
    42 extern int debug; 
    43 extern sensors_chip_name chipNames[]; 
    44 extern int numChipNames; 
    4529 
    4630extern int parseArgs(int argc, char **argv);