Changeset 6006

Show
Ignore:
Timestamp:
01/09/12 18:21:08 (3 years ago)
Author:
groeck
Message:

sensors: Use defines for array sizes

Use defines for array sizes. For alarm attributes, take into account that both
the generic alarm flag as well as individual alarm attributes may be provided
by a driver (even though that should not be the case).

Remove overflow checks from get_sensor_limit_data(), as overflows should
no longer happen.

Files:
1 modified

Legend:

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

    r5944 r6006  
    202202                                  const struct sensor_subfeature_list *sfl, 
    203203                                  struct sensor_subfeature_data *limits, 
    204                                   int max_limits, 
    205204                                  int *num_limits, 
    206205                                  struct sensor_subfeature_data *alarms, 
    207                                   int max_alarms, 
    208206                                  int *num_alarms) 
    209207{ 
     
    220218                                 */ 
    221219                                if (get_value(name, sf)) { 
    222                                         if (*num_alarms >= max_alarms) { 
    223                                                 fprintf(stderr, 
    224                                                         "Not enough %s buffers (%d)\n", 
    225                                                         "alarm", max_alarms); 
    226                                         } else { 
    227                                                 alarms[*num_alarms].name = sfl->name; 
    228                                                 (*num_alarms)++; 
    229                                         } 
     220                                        alarms[*num_alarms].name = sfl->name; 
     221                                        (*num_alarms)++; 
    230222                                } 
    231223                        } else { 
     
    233225                                 * Always queue limit subfeatures with their value. 
    234226                                 */ 
    235                                 if (*num_limits >= max_limits) { 
    236                                         fprintf(stderr, 
    237                                                 "Not enough %s buffers (%d)\n", 
    238                                                 "limit", max_limits); 
    239                                 } else { 
    240                                         limits[*num_limits].value = get_value(name, sf); 
    241                                         limits[*num_limits].name = sfl->name; 
    242                                         (*num_limits)++; 
    243                                 } 
     227                                limits[*num_limits].value = get_value(name, sf); 
     228                                limits[*num_limits].name = sfl->name; 
     229                                (*num_limits)++; 
    244230                        } 
    245231                        if (sfl->exists) { 
    246232                                get_sensor_limit_data(name, feature, sfl->exists, 
    247                                                       limits, max_limits, num_limits, 
    248                                                       alarms, max_alarms, num_alarms); 
     233                                                      limits, num_limits, 
     234                                                      alarms, num_alarms); 
    249235                        } 
    250236                } 
     
    284270}; 
    285271 
     272#define NUM_TEMP_ALARMS         6 
     273#define NUM_TEMP_SENSORS        (ARRAY_SIZE(temp_sensors) \ 
     274                                 + ARRAY_SIZE(temp_max_sensors) \ 
     275                                 + ARRAY_SIZE(temp_crit_sensors) \ 
     276                                 + ARRAY_SIZE(temp_emergency_sensors) \ 
     277                                 - NUM_TEMP_ALARMS - 4) 
     278 
    286279static void print_chip_temp(const sensors_chip_name *name, 
    287280                            const sensors_feature *feature, 
    288281                            int label_size) 
    289282{ 
    290         struct sensor_subfeature_data sensors[8]; 
    291         struct sensor_subfeature_data alarms[5]; 
     283        struct sensor_subfeature_data sensors[NUM_TEMP_SENSORS]; 
     284        struct sensor_subfeature_data alarms[NUM_TEMP_ALARMS]; 
    292285        int sensor_count, alarm_count; 
    293286        const sensors_subfeature *sf; 
     
    322315        sensor_count = alarm_count = 0; 
    323316        get_sensor_limit_data(name, feature, temp_sensors, 
    324                               sensors, ARRAY_SIZE(sensors), &sensor_count, 
    325                               alarms, ARRAY_SIZE(alarms), &alarm_count); 
     317                              sensors, &sensor_count, alarms, &alarm_count); 
    326318 
    327319        for (i = 0; i < sensor_count; i++) { 
     
    369361}; 
    370362 
     363#define NUM_IN_ALARMS   5 
     364#define NUM_IN_SENSORS  (ARRAY_SIZE(voltage_sensors) - NUM_IN_ALARMS - 1) 
     365 
    371366static void print_chip_in(const sensors_chip_name *name, 
    372367                          const sensors_feature *feature, 
     
    375370        const sensors_subfeature *sf; 
    376371        char *label; 
    377         struct sensor_subfeature_data sensors[4]; 
    378         struct sensor_subfeature_data alarms[4]; 
     372        struct sensor_subfeature_data sensors[NUM_IN_SENSORS]; 
     373        struct sensor_subfeature_data alarms[NUM_IN_ALARMS]; 
    379374        int sensor_count, alarm_count; 
    380375        double val; 
     
    397392        sensor_count = alarm_count = 0; 
    398393        get_sensor_limit_data(name, feature, voltage_sensors, 
    399                               sensors, ARRAY_SIZE(sensors), &sensor_count, 
    400                               alarms, ARRAY_SIZE(alarms), &alarm_count); 
     394                              sensors, &sensor_count, alarms, &alarm_count); 
    401395 
    402396        print_limits(sensors, sensor_count, alarms, alarm_count, label_size, 
     
    518512}; 
    519513 
     514#define MAX(a, b) ((a) > (b) ? (a) : (b)) 
     515#define NUM_POWER_ALARMS        4 
     516#define NUM_POWER_SENSORS       (ARRAY_SIZE(power_common_sensors) \ 
     517                                 + MAX(ARRAY_SIZE(power_inst_sensors), \ 
     518                                       ARRAY_SIZE(power_avg_sensors)) \ 
     519                                 - NUM_POWER_ALARMS - 2) 
     520 
    520521static void print_chip_power(const sensors_chip_name *name, 
    521522                             const sensors_feature *feature, 
     
    524525        double val; 
    525526        const sensors_subfeature *sf; 
    526         struct sensor_subfeature_data sensors[6]; 
    527         struct sensor_subfeature_data alarms[3]; 
     527        struct sensor_subfeature_data sensors[NUM_POWER_SENSORS]; 
     528        struct sensor_subfeature_data alarms[NUM_POWER_ALARMS]; 
    528529        int sensor_count, alarm_count; 
    529530        char *label; 
     
    548549        get_sensor_limit_data(name, feature, 
    549550                              sf ? power_inst_sensors : power_avg_sensors, 
    550                               sensors, ARRAY_SIZE(sensors), &sensor_count, 
    551                               alarms, ARRAY_SIZE(alarms), &alarm_count); 
     551                              sensors, &sensor_count, alarms, &alarm_count); 
    552552        /* Add sensors common to both flavors. */ 
    553         get_sensor_limit_data(name, feature, 
    554                               power_common_sensors, 
    555                               sensors, ARRAY_SIZE(sensors), &sensor_count, 
    556                               alarms, ARRAY_SIZE(alarms), &alarm_count); 
     553        get_sensor_limit_data(name, feature, power_common_sensors, 
     554                              sensors, &sensor_count, alarms, &alarm_count); 
    557555        if (!sf) 
    558556                sf = sensors_get_subfeature(name, feature, 
     
    657655}; 
    658656 
     657#define NUM_CURR_ALARMS         5 
     658#define NUM_CURR_SENSORS        (ARRAY_SIZE(current_sensors) - NUM_CURR_ALARMS - 1) 
     659 
    659660static void print_chip_curr(const sensors_chip_name *name, 
    660661                            const sensors_feature *feature, 
     
    664665        double val; 
    665666        char *label; 
    666         struct sensor_subfeature_data sensors[4]; 
    667         struct sensor_subfeature_data alarms[4]; 
     667        struct sensor_subfeature_data sensors[NUM_CURR_SENSORS]; 
     668        struct sensor_subfeature_data alarms[NUM_CURR_ALARMS]; 
    668669        int sensor_count, alarm_count; 
    669670 
     
    685686        sensor_count = alarm_count = 0; 
    686687        get_sensor_limit_data(name, feature, current_sensors, 
    687                               sensors, ARRAY_SIZE(sensors), &sensor_count, 
    688                               alarms, ARRAY_SIZE(alarms), &alarm_count); 
     688                              sensors, &sensor_count, alarms, &alarm_count); 
    689689 
    690690        print_limits(sensors, sensor_count, alarms, alarm_count, label_size,