cleanup

diff --git a/src/lib/nvidia.c b/src/lib/nvidia.c
index 2791df0..a5b8128 100644 (file)
--- a/src/lib/nvidia.c
+++ b/src/lib/nvidia.c
@@ -20,6 +20,8 @@
 #include <libintl.h>
 #define _(str) gettext(str)
 
+#include <limits.h>
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -96,7 +98,7 @@ static double get_ambient_temp(int id)
                return UNKNOWN_DBL_VALUE;
 }
 
-static double get_usage_att(char *atts, char *att)
+static double get_usage_att(char *atts, const char *att)
 {
        char *c, *key, *strv, *s;
        size_t n;
@@ -146,21 +148,34 @@ static double get_usage_att(char *atts, char *att)
        return v;
 }
 
-static double get_usage(int id, int type)
+static const char *get_nvidia_type_str(int type)
 {
-       char *stype, *atts;
-       double v;
-       Bool res;
-
        if (type & SENSOR_TYPE_GRAPHICS)
-               stype = "graphics";
+               return "graphics";
        else if (type & SENSOR_TYPE_VIDEO)
-               stype = "video";
+               return "video";
        else if (type & SENSOR_TYPE_MEMORY)
-               stype = "memory";
+               return "memory";
        else if (type & SENSOR_TYPE_PCIE)
-               stype = "PCIe";
+               return "PCIe";
+       else if (type & SENSOR_TYPE_AMBIENT)
+               return "ambient";
+       else if (type & SENSOR_TYPE_TEMP)
+               return "temp";
        else
+               return "unknown";
+}
+
+static double get_usage(int id, int type)
+{
+       const char *stype;
+       char *atts;
+       double v;
+       Bool res;
+
+       stype = get_nvidia_type_str(type);
+
+       if (!stype)
                return UNKNOWN_DBL_VALUE;
 
        res = XNVCTRLQueryTargetStringAttribute(display,
@@ -180,18 +195,23 @@ static double get_usage(int id, int type)
        return v;
 }
 
-static void update(struct psensor *sensor)
+static double get_value(int id, int type)
 {
-       double v;
-
-       if (sensor->type & SENSOR_TYPE_TEMP) {
-               if (sensor->type & SENSOR_TYPE_AMBIENT)
-                       v = get_ambient_temp(sensor->nvidia_id);
+       if (type & SENSOR_TYPE_TEMP) {
+               if (type & SENSOR_TYPE_AMBIENT)
+                       return get_ambient_temp(id);
                else
-                       v = get_temp(sensor->nvidia_id);
+                       return get_temp(id);
        } else { /* SENSOR_TYPE_USAGE */
-               v = get_usage(sensor->nvidia_id, sensor->type);
+               return get_usage(id, type);
        }
+}
+
+static void update(struct psensor *sensor)
+{
+       double v;
+
+       v = get_value(sensor->nvidia_id, sensor->type);
 
        if (v == UNKNOWN_DBL_VALUE)
                log_err(_("Failed to retrieve measure of type %x "
@@ -201,69 +221,56 @@ static void update(struct psensor *sensor)
        psensor_set_current_value(sensor, v);
 }
 
-static struct psensor *create_temp_sensor(int id, int subtype, int values_len)
+static int check_sensor(int id, int type)
 {
-       char name[200];
-       char *sid, *pname;
-       struct psensor *s;
-       int t;
-
-       pname = get_product_name(id);
-
-       if (subtype & SENSOR_TYPE_AMBIENT)
-               sprintf(name, "%s %d ambient", pname, id);
-       else
-               sprintf(name, "%s %d", pname, id);
-       free(pname);
-
-       sid = malloc(strlen("NVIDIA") + 1 + strlen(name) + 1);
-       sprintf(sid, "NVIDIA %s", name);
+       return get_value(id, type) != UNKNOWN_DBL_VALUE;
+}
 
-       t = SENSOR_TYPE_NVCTRL | SENSOR_TYPE_GPU | SENSOR_TYPE_TEMP | subtype;
+static char *i2str(int i)
+{
+       char *str;
+       size_t n;
 
-       s = psensor_create(sid,
-                          strdup(name),
-                          strdup(_("NVIDIA GPU")),
-                          t,
-                          values_len);
+       /* second +1 to avoid issue about the conversion of a double
+        * to a lower int */
+       n = 1 + (ceil(log10(INT_MAX)) + 1) + 1;
 
-       s->nvidia_id = id;
+       str = malloc(n);
+       snprintf(str, n, "%d", i);
 
-       return s;
+       return str;
 }
 
-static struct psensor *create_usage_sensor(int id,
-                                          int subtype,
-                                          int values_len)
+static struct psensor *create_nvidia_sensor(int id, int subtype, int value_len)
 {
-       char name[200];
-       char *sid;
+       char *pname, *name, *strnid, *sid;
+       const char *stype;
+       int type;
+       size_t n;
        struct psensor *s;
-       int t;
 
-       if (subtype & SENSOR_TYPE_GRAPHICS)
-               sprintf(name, "GPU%d graphics", id);
-       else if (subtype & SENSOR_TYPE_MEMORY)
-               sprintf(name, "GPU%d memory", id);
-       else if (subtype & SENSOR_TYPE_VIDEO)
-               sprintf(name, "GPU%d video", id);
-       else /* if (subtype & SENSOR_TYPE_PCIE) */
-               sprintf(name, "GPU%d PCIe", id);
+       type = SENSOR_TYPE_NVCTRL | SENSOR_TYPE_GPU | subtype;
 
+       if (!check_sensor(id, type))
+               return NULL;
 
-       sid = malloc(strlen("NVIDIA") + 1 + strlen(name) + 1);
-       sprintf(sid, "NVIDIA %s", name);
+       pname = get_product_name(id);
+       strnid = i2str(id);
+       stype = get_nvidia_type_str(type);
+
+       n = strlen(pname) + 1 + strlen(strnid) + 1 + strlen(stype) + 1;
 
-       t = SENSOR_TYPE_NVCTRL | SENSOR_TYPE_GPU | SENSOR_TYPE_USAGE | subtype;
+       name = malloc(n);
+       sprintf(name, "%s %s %s", pname, strnid, stype);
 
-       s = psensor_create(sid,
-                          strdup(name),
-                          strdup(_("NVIDIA GPU")),
-                          t,
-                          values_len);
+       sid = malloc(strlen("nvidia") + 1 + strlen(name) + 1);
+       sprintf(sid, "nvidia %s", name);
 
+       s = psensor_create(sid, name, pname, type, value_len);
        s->nvidia_id = id;
 
+       free(strnid);
+
        return s;
 }
 
@@ -308,6 +315,11 @@ void nvidia_psensor_list_update(struct psensor **sensors)
        }
 }
 
+/* static struct psensor ** */
+/* sensor_add(struct psensor **sensors, int subtype, int values_len) */
+/* { */
+/* } */
+
 struct psensor **nvidia_psensor_list_add(struct psensor **sensors,
                                         int values_len)
 {
@@ -318,37 +330,52 @@ struct psensor **nvidia_psensor_list_add(struct psensor **sensors,
 
        ss = sensors;
        for (i = 0; i < n; i++) {
-               s = create_temp_sensor(i, 0, values_len);
+               s = create_nvidia_sensor(i, SENSOR_TYPE_TEMP, values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);
 
                ss = tmp;
-               s = create_temp_sensor(i, SENSOR_TYPE_AMBIENT, values_len);
+               s = create_nvidia_sensor
+                       (i,
+                        SENSOR_TYPE_USAGE | SENSOR_TYPE_AMBIENT,
+                        values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);
 
                ss = tmp;
-               s = create_usage_sensor(i, SENSOR_TYPE_GRAPHICS, values_len);
+               s = create_nvidia_sensor
+                       (i,
+                        SENSOR_TYPE_USAGE | SENSOR_TYPE_GRAPHICS,
+                        values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);
 
                ss = tmp;
-               s = create_usage_sensor(i, SENSOR_TYPE_VIDEO, values_len);
+               s = create_nvidia_sensor
+                       (i,
+                        SENSOR_TYPE_USAGE | SENSOR_TYPE_VIDEO,
+                        values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);
 
                ss = tmp;
-               s = create_usage_sensor(i, SENSOR_TYPE_MEMORY, values_len);
+               s = create_nvidia_sensor
+                       (i,
+                        SENSOR_TYPE_USAGE | SENSOR_TYPE_MEMORY,
+                        values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);
 
                ss = tmp;
-               s = create_usage_sensor(i, SENSOR_TYPE_PCIE, values_len);
+               s = create_nvidia_sensor
+                       (i,
+                        SENSOR_TYPE_USAGE | SENSOR_TYPE_PCIE,
+                        values_len);
                tmp = psensor_list_add(ss, s);
                if (ss != tmp)
                        free(ss);