Show
Ignore:
Timestamp:
03/09/09 16:32:03 (6 years ago)
Author:
andy
Message:

Convert coding style in prog/sensord/ from gnu to kernel style.

Files:
1 modified

Legend:

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

    r5473 r5678  
    6868#define LOAD_AVERAGE "Load Average" 
    6969 
    70 typedef int (*FeatureFN) (void *data, const char *rawLabel, const char *label, const FeatureDescriptor *feature); 
    71  
    72 static char 
    73 rrdNextChar 
    74 (char c) { 
    75   if (c == '9') { 
    76     return 'A'; 
    77   } else if (c == 'Z') { 
    78     return 'a'; 
    79   } else if (c == 'z') { 
    80     return 0; 
    81   } else { 
    82     return c + 1; 
    83   } 
    84 } 
    85  
    86 static void 
    87 rrdCheckLabel 
    88 (const char *rawLabel, int index0) { 
    89   char *buffer = rrdLabels[index0]; 
    90   int i, j, okay; 
     70typedef int (*FeatureFN) (void *data, const char *rawLabel, const char *label, 
     71                          const FeatureDescriptor *feature); 
     72 
     73static char rrdNextChar(char c) 
     74{ 
     75        if (c == '9') { 
     76                return 'A'; 
     77        } else if (c == 'Z') { 
     78                return 'a'; 
     79        } else if (c == 'z') { 
     80                return 0; 
     81        } else { 
     82                return c + 1; 
     83        } 
     84} 
     85 
     86static void rrdCheckLabel(const char *rawLabel, int index0) 
     87{ 
     88        char *buffer = rrdLabels[index0]; 
     89        int i, j, okay; 
    9190   
    92   i = 0; 
    93   while ((i < RAW_LABEL_LENGTH) && rawLabel[i]) { /* contrain raw label to [A-Za-z0-9_] */ 
    94     char c = rawLabel[i]; 
    95     if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9')) || (c == '_')) { 
    96       buffer[i] = c; 
    97     } else { 
    98       buffer[i] = '_'; 
    99     } 
    100     ++ i; 
    101   } 
    102   buffer[i] = '\0'; 
    103  
    104   j = 0; 
    105   okay = (i > 0); 
    106   while (okay && (j < index0)) /* locate duplicates */ 
    107     okay = strcmp (rrdLabels[j ++], buffer); 
    108  
    109   while (!okay) { /* uniquify duplicate labels with _? or _?? */ 
    110     if (!buffer[i]) { 
    111       if (i > RAW_LABEL_LENGTH - 3) 
    112         i = RAW_LABEL_LENGTH - 3; 
    113       buffer[i] = '_'; 
    114       buffer[i + 1] = '0'; 
    115       buffer[i + 2] = '\0'; 
    116     } else if (!buffer[i + 2]) { 
    117       if (!(buffer[i + 1] = rrdNextChar (buffer[i + 1]))) { 
    118         buffer[i + 1] = '0'; 
    119         buffer[i + 2] = '0'; 
    120         buffer[i + 3] = '\0'; 
    121       } 
    122     } else { 
    123       if (!(buffer[i + 2] = rrdNextChar (buffer[i + 2]))) { 
    124         buffer[i + 1] = rrdNextChar (buffer[i + 1]); 
    125         buffer[i + 2] = '0'; 
    126       } 
    127     } 
    128     j = 0; 
    129     okay = 1; 
    130     while (okay && (j < index0)) 
    131       okay = strcmp (rrdLabels[j ++], buffer); 
    132   } 
    133 } 
    134  
    135 static int 
    136 applyToFeatures 
    137 (FeatureFN fn, void *data) { 
    138   const sensors_chip_name *chip; 
    139   int i, j, ret = 0, num = 0; 
    140  
    141   for (j = 0; (ret == 0) && (j < numChipNames); ++ j) { 
    142     i = 0; 
    143     while ((ret == 0) && ((chip = sensors_get_detected_chips (&chipNames[j], &i)) != NULL)) { 
    144       int index0, chipindex = -1; 
    145       for (index0 = 0; knownChips[index0].features; ++ index0) 
    146         /* Trick: we compare addresses here. We know it works because both 
    147            pointers were returned by sensors_get_detected_chips(), so they 
    148            refer to libsensors internal structures, which do not move. */ 
    149         if (knownChips[index0].name == chip) { 
    150           chipindex = index0; 
    151           break; 
    152         } 
    153       if (chipindex >= 0) { 
    154         const ChipDescriptor *descriptor = &knownChips[chipindex]; 
    155         const FeatureDescriptor *features = descriptor->features; 
    156  
    157         for (index0 = 0; (ret == 0) && (num < MAX_RRD_SENSORS) && features[index0].format; ++ index0) { 
    158           const FeatureDescriptor *feature = features + index0; 
    159           const char *rawLabel = feature->feature->name; 
    160           char *label = NULL; 
    161  
    162           if (!(label = sensors_get_label (chip, feature->feature))) { 
    163             sensorLog (LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, rawLabel); 
    164             ret = -1; 
    165           } else  { 
    166             rrdCheckLabel (rawLabel, num); 
    167             ret = fn (data, rrdLabels[num], label, feature); 
    168             ++ num; 
    169           } 
    170           if (label) 
    171             free (label); 
    172         } 
    173       } 
    174     } 
    175   } 
    176  
    177   return ret; 
     91        i = 0; 
     92        /* contrain raw label to [A-Za-z0-9_] */ 
     93        while ((i < RAW_LABEL_LENGTH) && rawLabel[i]) { 
     94                char c = rawLabel[i]; 
     95                if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) 
     96                    || ((c >= '0') && (c <= '9')) || (c == '_')) { 
     97                        buffer[i] = c; 
     98                } else { 
     99                        buffer[i] = '_'; 
     100                } 
     101                ++ i; 
     102        } 
     103        buffer[i] = '\0'; 
     104 
     105        j = 0; 
     106        okay = (i > 0); 
     107 
     108        /* locate duplicates */ 
     109        while (okay && (j < index0)) 
     110                okay = strcmp(rrdLabels[j ++], buffer); 
     111 
     112        /* uniquify duplicate labels with _? or _?? */ 
     113        while (!okay) { 
     114                if (!buffer[i]) { 
     115                        if (i > RAW_LABEL_LENGTH - 3) 
     116                                i = RAW_LABEL_LENGTH - 3; 
     117                        buffer[i] = '_'; 
     118                        buffer[i + 1] = '0'; 
     119                        buffer[i + 2] = '\0'; 
     120                } else if (!buffer[i + 2]) { 
     121                        if (!(buffer[i + 1] = rrdNextChar(buffer[i + 1]))) { 
     122                                buffer[i + 1] = '0'; 
     123                                buffer[i + 2] = '0'; 
     124                                buffer[i + 3] = '\0'; 
     125                        } 
     126                } else { 
     127                        if (!(buffer[i + 2] = rrdNextChar(buffer[i + 2]))) { 
     128                                buffer[i + 1] = rrdNextChar(buffer[i + 1]); 
     129                                buffer[i + 2] = '0'; 
     130                        } 
     131                } 
     132                j = 0; 
     133                okay = 1; 
     134                while (okay && (j < index0)) 
     135                        okay = strcmp(rrdLabels[j ++], buffer); 
     136        } 
     137} 
     138 
     139static int applyToFeatures(FeatureFN fn, void *data) 
     140{ 
     141        const sensors_chip_name *chip; 
     142        int i, j, ret = 0, num = 0; 
     143 
     144        for (j = 0; (ret == 0) && (j < numChipNames); ++ j) { 
     145                i = 0; 
     146                while ((ret == 0) && ((chip = sensors_get_detected_chips(&chipNames[j], &i)) != NULL)) { 
     147                        int index0, chipindex = -1; 
     148 
     149                        /* Trick: we compare addresses here. We know it works 
     150                         * because both pointers were returned by 
     151                         * sensors_get_detected_chips(), so they refer to 
     152                         * libsensors internal structures, which do not move. 
     153                         */ 
     154                        for (index0 = 0; knownChips[index0].features; ++index0) 
     155                                if (knownChips[index0].name == chip) { 
     156                                        chipindex = index0; 
     157                                        break; 
     158                                } 
     159                        if (chipindex >= 0) { 
     160                                const ChipDescriptor *descriptor = &knownChips[chipindex]; 
     161                                const FeatureDescriptor *features = descriptor->features; 
     162 
     163                                for (index0 = 0; (ret == 0) && (num < MAX_RRD_SENSORS) && features[index0].format; ++index0) { 
     164                                        const FeatureDescriptor *feature = features + index0; 
     165                                        const char *rawLabel = feature->feature->name; 
     166                                        char *label = NULL; 
     167 
     168                                        if (!(label = sensors_get_label(chip, feature->feature))) { 
     169                                                sensorLog(LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, rawLabel); 
     170                                                ret = -1; 
     171                                        } else  { 
     172                                                rrdCheckLabel(rawLabel, num); 
     173                                                ret = fn(data, 
     174                                                         rrdLabels[num], 
     175                                                         label, feature); 
     176                                                ++ num; 
     177                                        } 
     178                                        if (label) 
     179                                                free(label); 
     180                                } 
     181                        } 
     182                } 
     183        } 
     184        return ret; 
    178185} 
    179186 
    180187struct ds { 
    181   int num; 
    182   const char **argv; 
     188        int num; 
     189        const char **argv; 
    183190}; 
    184191 
    185 static int 
    186 rrdGetSensors_DS 
    187 (void *_data, const char *rawLabel, const char *label, const FeatureDescriptor *feature) { 
    188   (void) label; /* no warning */ 
    189   if (!feature || feature->rrd) { 
    190     struct ds *data = (struct ds *) _data; 
    191     char *ptr = rrdBuff + data->num * RRD_BUFF; 
    192     const char *min, *max; 
    193     data->argv[data->num ++] = ptr; 
    194     switch (feature ? feature->type : DataType_other) { /* arbitrary sanity limits */ 
    195       case DataType_voltage: 
    196         min="-25"; 
    197         max="25"; 
    198         break; 
    199       case DataType_rpm: 
    200         min = "0"; 
    201         max = "12000"; 
    202         break; 
    203       case DataType_temperature: 
    204         min = "-100"; 
    205         max = "250"; 
    206         break; 
    207       default: 
    208         min = max = "U"; 
    209         break; 
    210     } 
    211     sprintf (ptr, "DS:%s:GAUGE:%d:%s:%s", rawLabel, /* number of seconds downtime during which average be used instead of unknown */ 5 * rrdTime, min, max); 
    212   } 
    213   return 0; 
    214 } 
    215  
    216 static int 
    217 rrdGetSensors 
    218 (const char **argv) { 
    219   int ret = 0; 
    220   struct ds data = { 0, argv}; 
    221   ret = applyToFeatures (rrdGetSensors_DS, &data); 
    222   if (!ret && doLoad) 
    223     ret = rrdGetSensors_DS (&data, LOADAVG, LOAD_AVERAGE, NULL); 
    224   return ret ? -1 : data.num; 
    225 } 
    226  
    227 int 
    228 rrdInit 
    229 (void) { 
    230   int ret = 0; 
    231   struct stat tmp; 
     192static int rrdGetSensors_DS(void *_data, const char *rawLabel, 
     193                            const char *label, 
     194                            const FeatureDescriptor *feature) 
     195{ 
     196        (void) label; /* no warning */ 
     197        if (!feature || feature->rrd) { 
     198                struct ds *data = (struct ds *) _data; 
     199                char *ptr = rrdBuff + data->num * RRD_BUFF; 
     200                const char *min, *max; 
     201                data->argv[data->num ++] = ptr; 
     202 
     203                /* arbitrary sanity limits */ 
     204                switch (feature ? feature->type : DataType_other) { 
     205                case DataType_voltage: 
     206                        min="-25"; 
     207                        max="25"; 
     208                        break; 
     209                case DataType_rpm: 
     210                        min = "0"; 
     211                        max = "12000"; 
     212                        break; 
     213                case DataType_temperature: 
     214                        min = "-100"; 
     215                        max = "250"; 
     216                        break; 
     217                default: 
     218                        min = max = "U"; 
     219                        break; 
     220                } 
     221 
     222                /* 
     223                 * number of seconds downtime during which average be used 
     224                 * instead of unknown 
     225                 */ 
     226                sprintf(ptr, "DS:%s:GAUGE:%d:%s:%s", rawLabel, 5 * rrdTime, 
     227                        min, max); 
     228        } 
     229        return 0; 
     230} 
     231 
     232static int rrdGetSensors(const char **argv) 
     233{ 
     234        int ret = 0; 
     235        struct ds data = { 0, argv}; 
     236        ret = applyToFeatures(rrdGetSensors_DS, &data); 
     237        if (!ret && doLoad) 
     238                ret = rrdGetSensors_DS(&data, LOADAVG, LOAD_AVERAGE, NULL); 
     239        return ret ? -1 : data.num; 
     240} 
     241 
     242int rrdInit(void) 
     243{ 
     244        int ret = 0; 
     245        struct stat tmp; 
    232246   
    233   sensorLog (LOG_DEBUG, "sensor RRD init");  
    234   if (stat (rrdFile, &tmp)) { 
    235     if (errno == ENOENT) { 
    236       char stepBuff[STEP_BUFF], rraBuff[RRA_BUFF]; 
    237       int argc = 4, num; 
    238       const char *argv[6 + MAX_RRD_SENSORS] = { 
    239         "sensord", rrdFile, "-s", stepBuff 
    240       }; 
     247        sensorLog(LOG_DEBUG, "sensor RRD init"); 
     248        if (stat(rrdFile, &tmp)) { 
     249                if (errno == ENOENT) { 
     250                        char stepBuff[STEP_BUFF], rraBuff[RRA_BUFF]; 
     251                        int argc = 4, num; 
     252                        const char *argv[6 + MAX_RRD_SENSORS] = { 
     253                                "sensord", rrdFile, "-s", stepBuff 
     254                        }; 
    241255       
    242       sensorLog (LOG_INFO, "creating round robin database"); 
    243       num = rrdGetSensors (argv + argc); 
    244       if (num == 0) { 
    245         sensorLog (LOG_ERR, "Error creating RRD: %s: %s", rrdFile, "No sensors detected"); 
    246         ret = 2; 
    247       } else if (num < 0) { 
    248         ret = -num; 
    249       } else { 
    250         sprintf (stepBuff, "%d", rrdTime); 
    251         sprintf (rraBuff, "RRA:%s:%f:%d:%d", rrdNoAverage?"LAST":"AVERAGE", 0.5 /* fraction of non-unknown samples needed per entry */, 1 /* samples per entry */, 7 * 24 * 60 * 60 / rrdTime /* 1 week */); 
    252         argc += num; 
    253         argv[argc ++] = rraBuff; 
    254         argv[argc] = NULL; 
    255         if ((ret = rrd_create (argc, (char **) /* WEAK */ argv))) { 
    256           sensorLog (LOG_ERR, "Error creating RRD file: %s: %s", rrdFile, rrd_get_error ()); 
    257         } 
    258       } 
    259     } else { 
    260       sensorLog (LOG_ERR, "Error stat()ing RRD: %s: %s", rrdFile, strerror (errno)); 
    261       ret = 1; 
    262     } 
    263   } 
    264   sensorLog (LOG_DEBUG, "sensor RRD inited");  
     256                        sensorLog(LOG_INFO, "creating round robin database"); 
     257                        num = rrdGetSensors(argv + argc); 
     258                        if (num == 0) { 
     259                                sensorLog(LOG_ERR, 
     260                                          "Error creating RRD: %s: %s", 
     261                                          rrdFile, "No sensors detected"); 
     262                                ret = 2; 
     263                        } else if (num < 0) { 
     264                                ret = -num; 
     265                        } else { 
     266                                sprintf(stepBuff, "%d", rrdTime); 
     267                                sprintf(rraBuff, "RRA:%s:%f:%d:%d", 
     268                                        rrdNoAverage?"LAST":"AVERAGE", 
     269                                        0.5 /* fraction of non-unknown samples needed per entry */, 
     270                                        1 /* samples per entry */, 
     271                                        7 * 24 * 60 * 60 / rrdTime /* 1 week */); 
     272                                argc += num; 
     273                                argv[argc ++] = rraBuff; 
     274                                argv[argc] = NULL; 
     275                                if ((ret = rrd_create(argc, 
     276                                                      (char **) /* WEAK */ argv))) { 
     277                                        sensorLog(LOG_ERR, 
     278                                                  "Error creating RRD file: %s: %s", 
     279                                                  rrdFile, rrd_get_error()); 
     280                                } 
     281                        } 
     282                } else { 
     283                        sensorLog(LOG_ERR, "Error stat()ing RRD: %s: %s", 
     284                                  rrdFile, strerror(errno)); 
     285                        ret = 1; 
     286                } 
     287        } 
     288        sensorLog(LOG_DEBUG, "sensor RRD inited"); 
    265289   
    266   return ret; 
     290        return ret; 
    267291} 
    268292 
     
    271295 
    272296struct gr { 
    273   DataType type; 
    274   const char *h2; 
    275   const char *image; 
    276   const char *title; 
    277   const char *axisTitle; 
    278   const char *axisDefn; 
    279   const char *options; 
    280   int loadAvg; 
     297        DataType type; 
     298        const char *h2; 
     299        const char *image; 
     300        const char *title; 
     301        const char *axisTitle; 
     302        const char *axisDefn; 
     303        const char *options; 
     304        int loadAvg; 
    281305}; 
    282306 
    283 static int 
    284 rrdCGI_DEF 
    285 (void *_data, const char *rawLabel, const char *label, const FeatureDescriptor *feature) { 
    286   struct gr *data = (struct gr *) _data; 
    287   (void) label; /* no warning */ 
    288   if (!feature || (feature->rrd && (feature->type == data->type))) 
    289     printf ("\n\tDEF:%s=%s:%s:AVERAGE", rawLabel, rrdFile, rawLabel); 
    290   return 0; 
    291 } 
    292  
    293 /* Compute an arbitrary color based on the sensor label. This is preferred 
    294    over a random value because this guarantees that daily and weekly charts 
    295    will use the same colors. */ 
    296 static int 
    297 rrdCGI_color 
    298 (const char *label) { 
    299   unsigned long color = 0, brightness; 
    300   const char *c; 
    301  
    302   for (c = label; *c; c++) { 
    303     color = (color << 6) + (color >> (*c & 7)); 
    304     color ^= (*c) * 0x401; 
    305   } 
    306   color &= 0xffffff; 
    307   /* Adjust very light colors */ 
    308   brightness = (color & 0xff) + ((color >> 8) & 0xff) + (color >> 16); 
    309   if (brightness > 672) 
    310     color &= 0x7f7f7f; 
    311   /* Adjust very dark colors */ 
    312   else if (brightness < 96) 
    313     color |= 0x808080; 
    314   return color; 
    315 } 
    316  
    317 static int 
    318 rrdCGI_LINE 
    319 (void *_data, const char *rawLabel, const char *label, const FeatureDescriptor *feature) { 
    320   struct gr *data = (struct gr *) _data; 
    321   if (!feature || (feature->rrd && (feature->type == data->type))) 
    322     printf ("\n\tLINE2:%s#%.6x:\"%s\"", rawLabel, rrdCGI_color(label), label); 
    323   return 0; 
     307static int rrdCGI_DEF(void *_data, const char *rawLabel, const char *label, 
     308                      const FeatureDescriptor *feature) 
     309{ 
     310        struct gr *data = (struct gr *) _data; 
     311        (void) label; /* no warning */ 
     312        if (!feature || (feature->rrd && (feature->type == data->type))) 
     313                printf("\n\tDEF:%s=%s:%s:AVERAGE", rawLabel, rrdFile, 
     314                       rawLabel); 
     315        return 0; 
     316} 
     317 
     318/* 
     319 * Compute an arbitrary color based on the sensor label. This is preferred 
     320 * over a random value because this guarantees that daily and weekly charts 
     321 * will use the same colors. 
     322 */ 
     323static int rrdCGI_color(const char *label) 
     324{ 
     325        unsigned long color = 0, brightness; 
     326        const char *c; 
     327 
     328        for (c = label; *c; c++) { 
     329                color = (color << 6) + (color >> (*c & 7)); 
     330                color ^= (*c) * 0x401; 
     331        } 
     332        color &= 0xffffff; 
     333        /* Adjust very light colors */ 
     334        brightness = (color & 0xff) + ((color >> 8) & 0xff) + (color >> 16); 
     335        if (brightness > 672) 
     336                color &= 0x7f7f7f; 
     337        /* Adjust very dark colors */ 
     338        else if (brightness < 96) 
     339                color |= 0x808080; 
     340        return color; 
     341} 
     342 
     343static int rrdCGI_LINE(void *_data, const char *rawLabel, const char *label, 
     344                       const FeatureDescriptor *feature) 
     345{ 
     346        struct gr *data = (struct gr *) _data; 
     347        if (!feature || (feature->rrd && (feature->type == data->type))) 
     348                printf("\n\tLINE2:%s#%.6x:\"%s\"", rawLabel, 
     349                       rrdCGI_color(label), label); 
     350        return 0; 
    324351} 
    325352 
    326353static struct gr graphs[] = { 
    327   { 
    328     DataType_temperature, 
    329     "Daily Temperature Summary", 
    330     "daily-temperature", 
    331     "Temperature", 
    332     "Temperature (C)", 
    333     "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
    334     "-s -1d -l 0", 
    335     1 
    336   }, { 
    337     DataType_rpm, 
    338     "Daily Fan Speed Summary", 
    339     "daily-rpm", 
    340     "Fan Speed", 
    341     "Speed (RPM)", 
    342     "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
    343     "-s -1d -l 0", 
    344     0 
    345   }, { 
    346     DataType_voltage, 
    347     "Daily Voltage Summary", 
    348     "daily-voltage", 
    349     "Power Supply", 
    350     "Voltage (V)", 
    351     "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
    352     "-s -1d --alt-autoscale", 
    353     0 
    354   }, { 
    355     DataType_temperature, 
    356     "Weekly Temperature Summary", 
    357     "weekly-temperature", 
    358     "Temperature", 
    359     "Temperature (C)", 
    360     "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
    361     "-s -1w -l 0", 
    362     1 
    363   }, { 
    364     DataType_rpm, 
    365     "Weekly Fan Speed Summary", 
    366     "weekly-rpm", 
    367     "Fan Speed", 
    368     "Speed (RPM)", 
    369     "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
    370     "-s -1w -l 0", 
    371     0 
    372   }, { 
    373     DataType_voltage, 
    374     "Weekly Voltage Summary", 
    375     "weekly-voltage", 
    376     "Power Supply", 
    377     "Voltage (V)", 
    378     "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
    379     "-s -1w --alt-autoscale", 
    380     0 
    381   }, { 
    382     DataType_other, 
    383     NULL, 
    384     NULL, 
    385     NULL, 
    386     NULL, 
    387     NULL, 
    388     NULL, 
    389     0 
    390   }   
     354        { 
     355                DataType_temperature, 
     356                "Daily Temperature Summary", 
     357                "daily-temperature", 
     358                "Temperature", 
     359                "Temperature (C)", 
     360                "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
     361                "-s -1d -l 0", 
     362                1 
     363        }, { 
     364                DataType_rpm, 
     365                "Daily Fan Speed Summary", 
     366                "daily-rpm", 
     367                "Fan Speed", 
     368                "Speed (RPM)", 
     369                "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
     370                "-s -1d -l 0", 
     371                0 
     372        }, { 
     373                DataType_voltage, 
     374                "Daily Voltage Summary", 
     375                "daily-voltage", 
     376                "Power Supply", 
     377                "Voltage (V)", 
     378                "HOUR:1:HOUR:3:HOUR:3:0:%b %d %H:00", 
     379                "-s -1d --alt-autoscale", 
     380                0 
     381        }, { 
     382                DataType_temperature, 
     383                "Weekly Temperature Summary", 
     384                "weekly-temperature", 
     385                "Temperature", 
     386                "Temperature (C)", 
     387                "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
     388                "-s -1w -l 0", 
     389                1 
     390        }, { 
     391                DataType_rpm, 
     392                "Weekly Fan Speed Summary", 
     393                "weekly-rpm", 
     394                "Fan Speed", 
     395                "Speed (RPM)", 
     396                "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
     397                "-s -1w -l 0", 
     398                0 
     399        }, { 
     400                DataType_voltage, 
     401                "Weekly Voltage Summary", 
     402                "weekly-voltage", 
     403                "Power Supply", 
     404                "Voltage (V)", 
     405                "HOUR:6:DAY:1:DAY:1:86400:%a %b %d", 
     406                "-s -1w --alt-autoscale", 
     407                0 
     408        }, { 
     409                DataType_other, 
     410                NULL, 
     411                NULL, 
     412                NULL, 
     413                NULL, 
     414                NULL, 
     415                NULL, 
     416                0 
     417        } 
    391418}; 
    392419 
    393 int 
    394 rrdUpdate 
    395 (void) { 
    396   int ret = rrdChips (); 
    397   if (!ret && doLoad) { 
    398     FILE *loadavg; 
    399     if (!(loadavg = fopen ("/proc/loadavg", "r"))) { 
    400       sensorLog (LOG_ERR, "Error opening `/proc/loadavg': %s", strerror (errno)); 
    401       ret = 1; 
    402     } else { 
    403       float value; 
    404       if (fscanf (loadavg, "%f", &value) != 1) { 
    405         sensorLog (LOG_ERR, "Error reading load average"); 
    406         ret = 2; 
    407       } else { 
    408         sprintf (rrdBuff + strlen (rrdBuff), ":%f", value); 
    409       } 
    410       fclose (loadavg); 
    411     } 
    412   } 
    413   if (!ret) { 
    414     const char *argv[] = { 
    415       "sensord", rrdFile, rrdBuff, NULL 
    416     }; 
    417     if ((ret = rrd_update (3, (char **) /* WEAK */ argv))) { 
    418       sensorLog (LOG_ERR, "Error updating RRD file: %s: %s", rrdFile, rrd_get_error ()); 
    419     } 
    420   } 
    421   sensorLog (LOG_DEBUG, "sensor rrd updated");  
     420int rrdUpdate(void) 
     421{ 
     422        int ret = rrdChips (); 
     423        if (!ret && doLoad) { 
     424                FILE *loadavg; 
     425                if (!(loadavg = fopen("/proc/loadavg", "r"))) { 
     426                        sensorLog(LOG_ERR, 
     427                                  "Error opening `/proc/loadavg': %s", 
     428                                  strerror(errno)); 
     429                        ret = 1; 
     430                } else { 
     431                        float value; 
     432                        if (fscanf(loadavg, "%f", &value) != 1) { 
     433                                sensorLog(LOG_ERR, 
     434                                          "Error reading load average"); 
     435                                ret = 2; 
     436                        } else { 
     437                                sprintf(rrdBuff + strlen(rrdBuff), ":%f", 
     438                                        value); 
     439                        } 
     440                        fclose(loadavg); 
     441                } 
     442        } 
     443        if (!ret) { 
     444                const char *argv[] = { 
     445                        "sensord", rrdFile, rrdBuff, NULL 
     446                }; 
     447                if ((ret = rrd_update(3, (char **) /* WEAK */ argv))) { 
     448                        sensorLog(LOG_ERR, "Error updating RRD file: %s: %s", 
     449                                  rrdFile, rrd_get_error()); 
     450                } 
     451        } 
     452        sensorLog(LOG_DEBUG, "sensor rrd updated"); 
    422453   
    423   return ret; 
    424 } 
    425  
    426 int 
    427 rrdCGI 
    428 (void) { 
    429   int ret = 0; 
    430   struct gr *graph = graphs; 
    431  
    432   printf ("#!" RRDCGI "\n\n<HTML>\n<HEAD>\n<TITLE>sensord</TITLE>\n</HEAD>\n<BODY>\n<H1>sensord</H1>\n"); 
    433   while (graph->type != DataType_other) { 
    434     printf ("<H2>%s</H2>\n", graph->h2); 
    435     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", cgiDir, graph->image); 
    436     printf ("\t--lazy\n\t-v '%s'\n\t-t '%s'\n\t-x '%s'\n\t%s", graph->axisTitle, graph->title, graph->axisDefn, graph->options); 
    437     if (!ret) 
    438       ret = applyToFeatures (rrdCGI_DEF, graph); 
    439     if (!ret && doLoad && graph->loadAvg) 
    440       ret = rrdCGI_DEF (graph, LOADAVG, LOAD_AVERAGE, NULL); 
    441     if (!ret) 
    442       ret = applyToFeatures (rrdCGI_LINE, graph); 
    443     if (!ret && doLoad && graph->loadAvg) 
    444       ret = rrdCGI_LINE (graph, LOADAVG, LOAD_AVERAGE, NULL); 
    445     printf (">\n</P>\n"); 
    446     ++ graph; 
    447   } 
    448   printf ("<p>\n<small><b>sensord</b> by <a href=\"mailto:merlin@merlin.org\">Merlin Hughes</a>, all credit to the <a href=\"http://www.lm-sensors.org/\">lm_sensors</a> crew.</small>\n</p>\n"); 
    449   printf ("</BODY>\n</HTML>\n"); 
     454        return ret; 
     455} 
     456 
     457int rrdCGI(void) 
     458{ 
     459        int ret = 0; 
     460        struct gr *graph = graphs; 
     461 
     462        printf("#!" RRDCGI "\n\n<HTML>\n<HEAD>\n<TITLE>sensord</TITLE>\n</HEAD>\n<BODY>\n<H1>sensord</H1>\n"); 
     463        while (graph->type != DataType_other) { 
     464                printf("<H2>%s</H2>\n", graph->h2); 
     465                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); 
     467                printf("\t--lazy\n\t-v '%s'\n\t-t '%s'\n\t-x '%s'\n\t%s", 
     468                       graph->axisTitle, graph->title, graph->axisDefn, 
     469                       graph->options); 
     470                if (!ret) 
     471                        ret = applyToFeatures(rrdCGI_DEF, graph); 
     472                if (!ret && doLoad && graph->loadAvg) 
     473                        ret = rrdCGI_DEF(graph, LOADAVG, LOAD_AVERAGE, NULL); 
     474                if (!ret) 
     475                        ret = applyToFeatures(rrdCGI_LINE, graph); 
     476                if (!ret && doLoad && graph->loadAvg) 
     477                        ret = rrdCGI_LINE(graph, LOADAVG, LOAD_AVERAGE, NULL); 
     478                printf (">\n</P>\n"); 
     479                ++ graph; 
     480        } 
     481        printf("<p>\n<small><b>sensord</b> by <a href=\"mailto:merlin@merlin.org\">Merlin Hughes</a>, all credit to the <a href=\"http://www.lm-sensors.org/\">lm_sensors</a> crew.</small>\n</p>\n"); 
     482        printf("</BODY>\n</HTML>\n"); 
    450483   
    451   return ret; 
    452 } 
     484        return ret; 
     485}