Changeset 6006

Timestamp:

01/09/12 18:21:08 (17 months 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:

• lm-sensors/trunk/prog/sensors/chips.c (modified) (14 diffs)

lm-sensors/trunk/prog/sensors/chips.c

@@ -202 +202 @@
                                   const struct sensor_subfeature_list *sfl,
                                   struct sensor_subfeature_data *limits,
-                                  int max_limits,
                                   int *num_limits,
                                   struct sensor_subfeature_data *alarms,
-                                  int max_alarms,
                                   int *num_alarms)
 {
@@ -220 +218 @@
                                  */
                                 if (get_value(name, sf)) {
-                                        if (*num_alarms >= max_alarms) {
-                                                fprintf(stderr,
-                                                        "Not enough %s buffers (%d)\n",
-                                                        "alarm", max_alarms);
-                                        } else {
-                                                alarms[*num_alarms].name = sfl->name;
-                                                (*num_alarms)++;
-                                        }
+                                        alarms[*num_alarms].name = sfl->name;
+                                        (*num_alarms)++;
                                 }
                         } else {
@@ -233 +225 @@
                                  * Always queue limit subfeatures with their value.
                                  */
-                                if (*num_limits >= max_limits) {
-                                        fprintf(stderr,
-                                                "Not enough %s buffers (%d)\n",
-                                                "limit", max_limits);
-                                } else {
-                                        limits[*num_limits].value = get_value(name, sf);
-                                        limits[*num_limits].name = sfl->name;
-                                        (*num_limits)++;
-                                }
+                                limits[*num_limits].value = get_value(name, sf);
+                                limits[*num_limits].name = sfl->name;
+                                (*num_limits)++;
                         }
                         if (sfl->exists) {
                                 get_sensor_limit_data(name, feature, sfl->exists,
-                                                      limits, max_limits, num_limits,
-                                                      alarms, max_alarms, num_alarms);
+                                                      limits, num_limits,
+                                                      alarms, num_alarms);
                         }
                 }
@@ -284 +270 @@
 };
 
+#define NUM_TEMP_ALARMS         6
+#define NUM_TEMP_SENSORS        (ARRAY_SIZE(temp_sensors) \
+                                 + ARRAY_SIZE(temp_max_sensors) \
+                                 + ARRAY_SIZE(temp_crit_sensors) \
+                                 + ARRAY_SIZE(temp_emergency_sensors) \
+                                 - NUM_TEMP_ALARMS - 4)
+
 static void print_chip_temp(const sensors_chip_name *name,
                             const sensors_feature *feature,
                             int label_size)
 {
-        struct sensor_subfeature_data sensors[8];
-        struct sensor_subfeature_data alarms[5];
+        struct sensor_subfeature_data sensors[NUM_TEMP_SENSORS];
+        struct sensor_subfeature_data alarms[NUM_TEMP_ALARMS];
         int sensor_count, alarm_count;
         const sensors_subfeature *sf;
@@ -322 +315 @@
         sensor_count = alarm_count = 0;
         get_sensor_limit_data(name, feature, temp_sensors,
-                              sensors, ARRAY_SIZE(sensors), &sensor_count,
-                              alarms, ARRAY_SIZE(alarms), &alarm_count);
+                              sensors, &sensor_count, alarms, &alarm_count);
 
         for (i = 0; i < sensor_count; i++) {
@@ -369 +361 @@
 };
 
+#define NUM_IN_ALARMS   5
+#define NUM_IN_SENSORS  (ARRAY_SIZE(voltage_sensors) - NUM_IN_ALARMS - 1)
+
 static void print_chip_in(const sensors_chip_name *name,
                           const sensors_feature *feature,
@@ -375 +370 @@
         const sensors_subfeature *sf;
         char *label;
-        struct sensor_subfeature_data sensors[4];
-        struct sensor_subfeature_data alarms[4];
+        struct sensor_subfeature_data sensors[NUM_IN_SENSORS];
+        struct sensor_subfeature_data alarms[NUM_IN_ALARMS];
         int sensor_count, alarm_count;
         double val;
@@ -397 +392 @@
         sensor_count = alarm_count = 0;
         get_sensor_limit_data(name, feature, voltage_sensors,
-                              sensors, ARRAY_SIZE(sensors), &sensor_count,
-                              alarms, ARRAY_SIZE(alarms), &alarm_count);
+                              sensors, &sensor_count, alarms, &alarm_count);
 
         print_limits(sensors, sensor_count, alarms, alarm_count, label_size,
@@ -518 +512 @@
 };
 
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define NUM_POWER_ALARMS        4
+#define NUM_POWER_SENSORS       (ARRAY_SIZE(power_common_sensors) \
+                                 + MAX(ARRAY_SIZE(power_inst_sensors), \
+                                       ARRAY_SIZE(power_avg_sensors)) \
+                                 - NUM_POWER_ALARMS - 2)
+
 static void print_chip_power(const sensors_chip_name *name,
                              const sensors_feature *feature,
@@ -524 +525 @@
         double val;
         const sensors_subfeature *sf;
-        struct sensor_subfeature_data sensors[6];
-        struct sensor_subfeature_data alarms[3];
+        struct sensor_subfeature_data sensors[NUM_POWER_SENSORS];
+        struct sensor_subfeature_data alarms[NUM_POWER_ALARMS];
         int sensor_count, alarm_count;
         char *label;
@@ -548 +549 @@
         get_sensor_limit_data(name, feature,
                               sf ? power_inst_sensors : power_avg_sensors,
-                              sensors, ARRAY_SIZE(sensors), &sensor_count,
-                              alarms, ARRAY_SIZE(alarms), &alarm_count);
+                              sensors, &sensor_count, alarms, &alarm_count);
         /* Add sensors common to both flavors. */
-        get_sensor_limit_data(name, feature,
-                              power_common_sensors,
-                              sensors, ARRAY_SIZE(sensors), &sensor_count,
-                              alarms, ARRAY_SIZE(alarms), &alarm_count);
+        get_sensor_limit_data(name, feature, power_common_sensors,
+                              sensors, &sensor_count, alarms, &alarm_count);
         if (!sf)
                 sf = sensors_get_subfeature(name, feature,
@@ -657 +655 @@
 };
 
+#define NUM_CURR_ALARMS         5
+#define NUM_CURR_SENSORS        (ARRAY_SIZE(current_sensors) - NUM_CURR_ALARMS - 1)
+
 static void print_chip_curr(const sensors_chip_name *name,
                             const sensors_feature *feature,
@@ -664 +665 @@
         double val;
         char *label;
-        struct sensor_subfeature_data sensors[4];
-        struct sensor_subfeature_data alarms[4];
+        struct sensor_subfeature_data sensors[NUM_CURR_SENSORS];
+        struct sensor_subfeature_data alarms[NUM_CURR_ALARMS];
         int sensor_count, alarm_count;
 
@@ -685 +686 @@
         sensor_count = alarm_count = 0;
         get_sensor_limit_data(name, feature, current_sensors,
-                              sensors, ARRAY_SIZE(sensors), &sensor_count,
-                              alarms, ARRAY_SIZE(alarms), &alarm_count);
+                              sensors, &sensor_count, alarms, &alarm_count);
 
         print_limits(sensors, sensor_count, alarms, alarm_count, label_size,