libsysfs/sysfs_class.c

   1 /*
   2  * sysfs_class.c
   3  *
   4  * Generic class utility functions for libsysfs
   5  *
   6  * Copyright (C) IBM Corp. 2003
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21  *
  22  */
  23 #include "sysfs/libsysfs.h"
  24 #include "sysfs.h"
  25
  26 static void sysfs_close_cls_dev(void *dev)
  27 {
  28         sysfs_close_class_device((struct sysfs_class_device *)dev);
  29 }
  30
  31 /**
  32  * class_name_equal: compares class_devices' name
  33  * @a: class_name looking for
  34  * @b: sysfs_class_device being compared
  35  */
  36 static int class_name_equal(void *a, void *b)
  37 {
  38         if (a == NULL || b == NULL)
  39                 return 0;
  40
  41         if (strcmp(((char *)a), ((struct sysfs_class_device *)b)->name) == 0)
  42                 return 1;
  43
  44         return 0;
  45 }
  46
  47 /**
  48  * sysfs_close_class_device: closes a single class device.
  49  * @dev: class device to close.
  50  */
  51 void sysfs_close_class_device(struct sysfs_class_device *dev)
  52 {
  53         if (dev != NULL) {
  54                 if (dev->directory != NULL)
  55                         sysfs_close_directory(dev->directory);
  56                 if (dev->sysdevice != NULL)
  57                         sysfs_close_device(dev->sysdevice);
  58                 if (dev->driver != NULL)
  59                         sysfs_close_driver(dev->driver);
  60                 if (dev->parent != NULL)
  61                         sysfs_close_class_device(dev->parent);
  62                 free(dev);
  63         }
  64 }
  65
  66 /**
  67  * sysfs_close_class: close single class
  68  * @cls: class structure
  69  */
  70 void sysfs_close_class(struct sysfs_class *cls)
  71 {
  72         if (cls != NULL) {
  73                 if (cls->directory != NULL)
  74                         sysfs_close_directory(cls->directory);
  75                 if (cls->devices != NULL)
  76                         dlist_destroy(cls->devices);
  77                 free(cls);
  78         }
  79 }
  80
  81 /**
  82  * alloc_class_device: mallocs and initializes new class device struct.
  83  * returns sysfs_class_device or NULL.
  84  */
  85 static struct sysfs_class_device *alloc_class_device(void)
  86 {
  87         return (struct sysfs_class_device *)
  88                                 calloc(1, sizeof(struct sysfs_class_device));
  89 }
  90
  91 /**
  92  * alloc_class: mallocs new class structure
  93  * returns sysfs_class struct or NULL
  94  */
  95 static struct sysfs_class *alloc_class(void)
  96 {
  97         return (struct sysfs_class *)calloc(1, sizeof(struct sysfs_class));
  98 }
  99
 100 /**
 101  * set_classdev_classname: Grabs classname from path
 102  * @cdev: class device to set
 103  * Returns nothing
 104  */
 105 static void set_classdev_classname(struct sysfs_class_device *cdev)
 106 {
 107         char *c = NULL, *e = NULL;
 108         int count = 0;
 109
 110         c = strstr(cdev->path, SYSFS_CLASS_NAME);
 111         if (c == NULL) {
 112                 c = strstr(cdev->path, SYSFS_BLOCK_NAME);
 113         } else {
 114                 c = strstr(c, "/");
 115         }
 116
 117         if (c == NULL)
 118                 safestrcpy(cdev->classname, SYSFS_UNKNOWN);
 119         else {
 120                 if (*c == '/')
 121                         c++;
 122                 e = c;
 123                 while (e != NULL && *e != '/' && *e != '\0') {
 124                         e++;
 125                         count++;
 126                 }
 127                 strncpy(cdev->classname, c, count);
 128         }
 129 }
 130
 131 /**
 132  * sysfs_open_class_device_path: Opens and populates class device
 133  * @path: path to class device.
 134  * returns struct sysfs_class_device with success and NULL with error.
 135  */
 136 struct sysfs_class_device *sysfs_open_class_device_path(const char *path)
 137 {
 138         struct sysfs_class_device *cdev = NULL;
 139
 140         if (path == NULL) {
 141                 errno = EINVAL;
 142                 return NULL;
 143         }
 144         if ((sysfs_path_is_dir(path)) != 0) {
 145                 dprintf("%s is not a valid path to a class device\n", path);
 146                 return NULL;
 147         }
 148         cdev = alloc_class_device();
 149         if (cdev == NULL) {
 150                 dprintf("calloc failed\n");
 151                 return NULL;
 152         }
 153         if ((sysfs_get_name_from_path(path, cdev->name, SYSFS_NAME_LEN)) != 0) {
 154                 errno = EINVAL;
 155                 dprintf("Error getting class device name\n");
 156                 sysfs_close_class_device(cdev);
 157                 return NULL;
 158         }
 159
 160         safestrcpy(cdev->path, path);
 161         if ((sysfs_remove_trailing_slash(cdev->path)) != 0) {
 162                 dprintf("Invalid path to class device %s\n", cdev->path);
 163                 sysfs_close_class_device(cdev);
 164                 return NULL;
 165         }
 166         set_classdev_classname(cdev);
 167
 168         return cdev;
 169 }
 170
 171 /**
 172  * sysfs_get_class_devices: gets all devices for class
 173  * @cls: class to get devices for
 174  * returns dlist of class_devices with success and NULL with error
 175  */
 176 struct dlist *sysfs_get_class_devices(struct sysfs_class *cls)
 177 {
 178         struct sysfs_class_device *dev = NULL;
 179         struct sysfs_directory *cur = NULL;
 180
 181         if (cls == NULL) {
 182                 errno = EINVAL;
 183                 return NULL;
 184         }
 185
 186         if (cls->devices != NULL)
 187                 return cls->devices;
 188
 189         if (cls->directory == NULL) {
 190                 cls->directory = sysfs_open_directory(cls->path);
 191                 if (cls->directory == NULL)
 192                         return NULL;
 193         }
 194
 195         if ((sysfs_read_dir_subdirs(cls->directory)) != 0)
 196                 return NULL;
 197
 198         if (cls->directory->subdirs != NULL) {
 199                 dlist_for_each_data(cls->directory->subdirs, cur,
 200                                                 struct sysfs_directory) {
 201                         dev = sysfs_open_class_device_path(cur->path);
 202                         if (dev == NULL) {
 203                                 dprintf("Error opening device at %s\n",
 204                                                                 cur->path);
 205                                 continue;
 206                         }
 207                         if (cls->devices == NULL)
 208                                 cls->devices = dlist_new_with_delete
 209                                         (sizeof(struct sysfs_class_device),
 210                                                         sysfs_close_cls_dev);
 211                         dlist_unshift_sorted(cls->devices, dev, sort_list);
 212                 }
 213         }
 214         return cls->devices;
 215 }
 216
 217 /**
 218  * sysfs_open_class: opens specific class and all its devices on system
 219  * returns sysfs_class structure with success or NULL with error.
 220  */
 221 struct sysfs_class *sysfs_open_class(const char *name)
 222 {
 223         struct sysfs_class *cls = NULL;
 224         char classpath[SYSFS_PATH_MAX];
 225
 226         if (name == NULL) {
 227                 errno = EINVAL;
 228                 return NULL;
 229         }
 230
 231         memset(classpath, 0, SYSFS_PATH_MAX);
 232         if ((sysfs_get_mnt_path(classpath, SYSFS_PATH_MAX)) != 0) {
 233                 dprintf("Sysfs not supported on this system\n");
 234                 return NULL;
 235         }
 236
 237         /*
 238          * We shall now treat "block" also as a class. Hence, check here
 239          * if "name" is "block" and proceed accordingly
 240          */
 241         if (strcmp(name, SYSFS_BLOCK_NAME) == 0) {
 242                 safestrcat(classpath, "/");
 243                 safestrcat(classpath, SYSFS_BLOCK_NAME);
 244         } else {
 245                 safestrcat(classpath, "/");
 246                 safestrcat(classpath, SYSFS_CLASS_NAME);
 247                 safestrcat(classpath, "/");
 248                 safestrcat(classpath, name);
 249         }
 250         if ((sysfs_path_is_dir(classpath)) != 0) {
 251                 dprintf("Class %s not found on the system\n", name);
 252                 return NULL;
 253         }
 254
 255         cls = alloc_class();
 256         if (cls == NULL) {
 257                 dprintf("calloc failed\n");
 258                 return NULL;
 259         }
 260         safestrcpy(cls->name, name);
 261         safestrcpy(cls->path, classpath);
 262         if ((sysfs_remove_trailing_slash(cls->path)) != 0) {
 263                 dprintf("Invalid path to class device %s\n", cls->path);
 264                 sysfs_close_class(cls);
 265                 return NULL;
 266         }
 267
 268         return cls;
 269 }
 270
 271 /**
 272  * sysfs_get_class_device: Get specific class device using the device's id
 273  * @class: class to find device on
 274  * @name: class name of the device
 275  */
 276 struct sysfs_class_device *sysfs_get_class_device(struct sysfs_class *cls,
 277                                         char *name)
 278 {
 279         if (cls == NULL || name == NULL) {
 280                 errno = EINVAL;
 281                 return NULL;
 282         }
 283
 284         if (cls->devices == NULL) {
 285                 cls->devices = sysfs_get_class_devices(cls);
 286                 if (cls->devices == NULL)
 287                         return NULL;
 288         }
 289         return (struct sysfs_class_device *)dlist_find_custom(cls->devices,
 290                         name, class_name_equal);
 291 }
 292
 293 /**
 294  * sysfs_get_classdev_device: returns the sysfs_device corresponding to
 295  *              sysfs_class_device, if present
 296  * @clsdev: class device whose sysfs_device is required
 297  * Returns sysfs_device on success, NULL on error or if device is not
 298  * implemented
 299  */
 300 struct sysfs_device *sysfs_get_classdev_device
 301                         (struct sysfs_class_device *clsdev)
 302 {
 303         struct sysfs_link *devlink = NULL;
 304         char devpath[SYSFS_PATH_MAX];
 305
 306         if (clsdev == NULL) {
 307                 errno = EINVAL;
 308                 return NULL;
 309         }
 310         safestrcpy(devpath, clsdev->path);
 311         safestrcat(devpath, "/device");
 312         if ((sysfs_path_is_link(devpath)) != 0) {
 313                 if (clsdev->sysdevice != NULL) {
 314                         sysfs_close_device(clsdev->sysdevice);
 315                         clsdev->sysdevice = NULL;
 316                 }
 317                 return NULL;
 318         }
 319
 320         if (clsdev->directory == NULL) {
 321                 clsdev->directory = sysfs_open_directory(clsdev->path);
 322                 if (clsdev->directory == NULL)
 323                         return NULL;
 324         }
 325         devlink = sysfs_get_directory_link(clsdev->directory, "device");
 326         if (devlink == NULL) {
 327                 if (clsdev->sysdevice != NULL) {
 328                         dprintf("Device link no longer exists\n");
 329                         sysfs_close_device(clsdev->sysdevice);
 330                         clsdev->sysdevice = NULL;
 331                 }
 332                 return NULL;
 333         }
 334
 335         if (clsdev->sysdevice != NULL) {
 336                 if (!strncmp(devlink->target, clsdev->sysdevice->path,
 337                                                 SYSFS_PATH_MAX))
 338                         /* sysdevice hasn't changed */
 339                         return (clsdev->sysdevice);
 340                 else
 341                         /* come here only if the device link for has changed */
 342                         sysfs_close_device(clsdev->sysdevice);
 343         }
 344
 345         clsdev->sysdevice = sysfs_open_device_path(devlink->target);
 346         if (clsdev->sysdevice == NULL)
 347                 return NULL;
 348
 349         return (clsdev->sysdevice);
 350 }
 351
 352 /**
 353  * sysfs_get_classdev_driver: returns the sysfs_driver corresponding to
 354  *              sysfs_class_device, if present
 355  * @clsdev: class device whose sysfs_device is required
 356  * Returns sysfs_driver on success, NULL on error or if driver is not
 357  * implemented
 358  */
 359 struct sysfs_driver *sysfs_get_classdev_driver
 360                         (struct sysfs_class_device *clsdev)
 361 {
 362         struct sysfs_link *drvlink = NULL;
 363         char drvpath[SYSFS_PATH_MAX];
 364
 365         if (clsdev == NULL) {
 366                 errno = EINVAL;
 367                 return NULL;
 368         }
 369         safestrcpy(drvpath, clsdev->path);
 370         safestrcat(drvpath, "/driver");
 371         if ((sysfs_path_is_link(drvpath)) != 0) {
 372                 if (clsdev->driver != NULL) {
 373                         sysfs_close_driver(clsdev->driver);
 374                         clsdev->driver = NULL;
 375                 }
 376                 return NULL;
 377         }
 378
 379         if (clsdev->directory == NULL) {
 380                 clsdev->directory = sysfs_open_directory(clsdev->path);
 381                 if (clsdev->directory == NULL)
 382                         return NULL;
 383         }
 384         drvlink = sysfs_get_directory_link(clsdev->directory, "driver");
 385         if (drvlink == NULL) {
 386                 if (clsdev->driver != NULL) {
 387                         dprintf("Driver link no longer exists\n");
 388                         sysfs_close_driver(clsdev->driver);
 389                         clsdev->driver = NULL;
 390                 }
 391                 return NULL;
 392         }
 393         if (clsdev->driver != NULL) {
 394                 if (!strncmp(drvlink->target, clsdev->driver->path,
 395                                                         SYSFS_PATH_MAX))
 396                         /* driver hasn't changed */
 397                         return (clsdev->driver);
 398                 else
 399                         /* come here only if the device link for has changed */
 400                         sysfs_close_driver(clsdev->driver);
 401         }
 402
 403         clsdev->driver = sysfs_open_driver_path(drvlink->target);
 404         if (clsdev->driver == NULL)
 405                 return NULL;
 406
 407         return (clsdev->driver);
 408 }
 409
 410 /**
 411  * get_blockdev_parent: Get the parent class device for a "block" subsystem
 412  *              device if present
 413  * @clsdev: block subsystem class device whose parent needs to be found
 414  * Returns 0 on success and 1 on error
 415  */
 416 static int get_blockdev_parent(struct sysfs_class_device *clsdev)
 417 {
 418         char parent_path[SYSFS_PATH_MAX], *c = NULL;
 419
 420         safestrcpy(parent_path, clsdev->path);
 421         c = strstr(parent_path, SYSFS_BLOCK_NAME);
 422         if (c == NULL) {
 423                 dprintf("Class device %s does not belong to BLOCK subsystem\n",
 424                                 clsdev->name);
 425                 return 1;
 426         }
 427         c += strlen(SYSFS_BLOCK_NAME);
 428         if (*c == '/')
 429                 c++;
 430         else
 431                 goto errout;
 432
 433        /* validate whether the given class device is a partition or not */
 434         if ((strncmp(c, clsdev->name, strlen(clsdev->name))) == 0) {
 435                 dprintf("%s not a partition\n", clsdev->name);
 436                 return 1;
 437         }
 438
 439         c = strchr(c, '/');
 440         if (c == NULL)
 441                 goto errout;
 442
 443         *c = '\0';
 444
 445         clsdev->parent = sysfs_open_class_device_path(parent_path);
 446         if (clsdev->parent == NULL) {
 447                 dprintf("Error opening the parent class device at %s\n",
 448                                                                 parent_path);
 449                 return 1;
 450         }
 451         return 0;
 452
 453 errout:
 454         dprintf("Invalid path %s\n", clsdev->path);
 455         return 1;
 456 }
 457
 458 /**
 459  * sysfs_get_classdev_parent: Retrieves the parent of a class device.
 460  *      eg., when working with hda1, this function can be used to retrieve the
 461  *              sysfs_class_device for hda
 462  *
 463  * @clsdev: class device whose parent details are required.
 464  * Returns sysfs_class_device of the parent on success, NULL on failure
 465  */
 466 struct sysfs_class_device *sysfs_get_classdev_parent
 467                                 (struct sysfs_class_device *clsdev)
 468 {
 469         if (clsdev == NULL) {
 470                 errno = EINVAL;
 471                 return NULL;
 472         }
 473         if (clsdev->parent != NULL)
 474                 return (clsdev->parent);
 475
 476         /*
 477          * As of now, only block devices have a parent child heirarchy in sysfs
 478          * We do not know, if, in the future, more classes will have a similar
 479          * structure. Hence, we now call a specialized function for block and
 480          * later we can add support functions for other subsystems as required.
 481          */
 482         if (!(strncmp(clsdev->classname, SYSFS_BLOCK_NAME,
 483                                         sizeof(SYSFS_BLOCK_NAME)))) {
 484                 if ((get_blockdev_parent(clsdev)) == 0)
 485                         return (clsdev->parent);
 486         }
 487         return NULL;
 488 }
 489
 490 /**
 491  * get_classdev_path: given the class and a device in the class, return the
 492  *              absolute path to the device
 493  * @classname: name of the class
 494  * @clsdev: the class device
 495  * @path: buffer to return path
 496  * @psize: size of "path"
 497  * Returns 0 on SUCCESS or -1 on error
 498  */
 499 static int get_classdev_path(const char *classname, const char *clsdev,
 500                 char *path, size_t len)
 501 {
 502         if (classname == NULL || clsdev == NULL || path == NULL) {
 503                 errno = EINVAL;
 504                 return -1;
 505         }
 506         if (sysfs_get_mnt_path(path, len) != 0) {
 507                 dprintf("Error getting sysfs mount path\n");
 508                 return -1;
 509         }
 510         if (strncmp(classname, SYSFS_BLOCK_NAME,
 511                                 sizeof(SYSFS_BLOCK_NAME)) == 0) {
 512                 safestrcatmax(path, "/", len);
 513                 safestrcatmax(path, SYSFS_BLOCK_NAME, len);
 514         } else {
 515                 safestrcatmax(path, "/", len);
 516                 safestrcatmax(path, SYSFS_CLASS_NAME, len);
 517                 safestrcatmax(path, "/", len);
 518                 safestrcatmax(path, classname, len);
 519         }
 520         safestrcatmax(path, "/", len);
 521         safestrcatmax(path, clsdev, len);
 522         return 0;
 523 }
 524
 525 /**
 526  * sysfs_open_class_device: Locates a specific class_device and returns it.
 527  * Class_device must be closed using sysfs_close_class_device
 528  * @classname: Class to search
 529  * @name: name of the class_device
 530  *
 531  * NOTE:
 532  *      Call sysfs_close_class_device() to close the class device
 533  */
 534 struct sysfs_class_device *sysfs_open_class_device
 535                 (const char *classname, const char *name)
 536 {
 537         char devpath[SYSFS_PATH_MAX];
 538         struct sysfs_class_device *cdev = NULL;
 539
 540         if (classname == NULL || name == NULL) {
 541                 errno = EINVAL;
 542                 return NULL;
 543         }
 544
 545         memset(devpath, 0, SYSFS_PATH_MAX);
 546         if ((get_classdev_path(classname, name, devpath,
 547                                         SYSFS_PATH_MAX)) != 0) {
 548                 dprintf("Error getting to device %s on class %s\n",
 549                                                         name, classname);
 550                 return NULL;
 551         }
 552
 553         cdev = sysfs_open_class_device_path(devpath);
 554         if (cdev == NULL) {
 555                 dprintf("Error getting class device %s from class %s\n",
 556                                 name, classname);
 557                 return NULL;
 558         }
 559         return cdev;
 560 }
 561
 562 /**
 563  * sysfs_get_classdev_attributes: returns a dlist of attributes for
 564  *      the requested class_device
 565  * @cdev: sysfs_class_dev for which attributes are needed
 566  * returns a dlist of attributes if exists, NULL otherwise
 567  */
 568 struct dlist *sysfs_get_classdev_attributes(struct sysfs_class_device *cdev)
 569 {
 570         if (cdev == NULL)
 571                 return NULL;
 572
 573         if (cdev->directory == NULL) {
 574                 cdev->directory = sysfs_open_directory(cdev->path);
 575                 if (cdev->directory == NULL)
 576                         return NULL;
 577         }
 578         if (cdev->directory->attributes == NULL) {
 579                 if ((sysfs_read_dir_attributes(cdev->directory)) != 0)
 580                         return NULL;
 581         }
 582         return (cdev->directory->attributes);
 583 }
 584
 585 /**
 586  * sysfs_refresh_clsassdev_attributes: refreshes the driver's list of attributes
 587  * @clsdev: sysfs_class_device whose attributes to refresh
 588  *
 589  * NOTE: Upon return, prior references to sysfs_attributes for this classdev
 590  *              _may_ not be valid
 591  *
 592  * Returns list of attributes on success and NULL on failure
 593  */
 594 struct dlist *sysfs_refresh_classdev_attributes
 595                         (struct sysfs_class_device *clsdev)
 596 {
 597         if (clsdev == NULL) {
 598                 errno = EINVAL;
 599                 return NULL;
 600         }
 601
 602         if (clsdev->directory == NULL)
 603                 return (sysfs_get_classdev_attributes(clsdev));
 604
 605         if ((sysfs_refresh_dir_attributes(clsdev->directory)) != 0) {
 606                 dprintf("Error refreshing class_device attributes\n");
 607                 return NULL;
 608         }
 609
 610         return (clsdev->directory->attributes);
 611 }
 612
 613 /**
 614  * sysfs_get_classdev_attr: searches class device's attributes by name
 615  * @clsdev: class device to look through
 616  * @name: attribute name to get
 617  * returns sysfs_attribute reference with success or NULL with error
 618  */
 619 struct sysfs_attribute *sysfs_get_classdev_attr
 620                 (struct sysfs_class_device *clsdev, const char *name)
 621 {
 622         struct sysfs_attribute *cur = NULL;
 623         struct sysfs_directory *sdir = NULL;
 624         struct dlist *attrlist = NULL;
 625
 626         if (clsdev == NULL || name == NULL) {
 627                 errno = EINVAL;
 628                 return NULL;
 629         }
 630
 631         /*
 632          * First, see if it's in the current directory. Then look at
 633          * subdirs since class devices can have subdirs of attributes.
 634          */
 635         attrlist = sysfs_get_classdev_attributes(clsdev);
 636         if (attrlist != NULL) {
 637                 cur = sysfs_get_directory_attribute(clsdev->directory,
 638                                                 (char *)name);
 639                 if (cur != NULL)
 640                         return cur;
 641         }
 642
 643         if (clsdev->directory->subdirs == NULL)
 644                 if ((sysfs_read_dir_subdirs(clsdev->directory)) != 0 ||
 645                     clsdev->directory->subdirs == NULL)
 646                         return NULL;
 647
 648         if (clsdev->directory->subdirs != NULL) {
 649                 dlist_for_each_data(clsdev->directory->subdirs, sdir,
 650                                                 struct sysfs_directory) {
 651                         if ((sysfs_path_is_dir(sdir->path)) != 0)
 652                                 continue;
 653                         cur = sysfs_get_directory_attribute(sdir,
 654                                                         (char *)name);
 655                         if (cur == NULL)
 656                                 continue;
 657                 }
 658         }
 659         return cur;
 660 }
 661
 662 /**
 663  * sysfs_open_classdev_attr: read an attribute for a given class device
 664  * @classname: name of the class on which to look
 665  * @dev: class device name for which the attribute has to be read
 666  * @attrib: attribute to read
 667  * Returns sysfs_attribute * on SUCCESS and NULL on error
 668  *
 669  * NOTE:
 670  *      A call to sysfs_close_attribute() is required to close the
 671  *      attribute returned and to free memory
 672  */
 673 struct sysfs_attribute *sysfs_open_classdev_attr(const char *classname,
 674                 const char *dev, const char *attrib)
 675 {
 676         struct sysfs_attribute *attribute = NULL;
 677         char path[SYSFS_PATH_MAX];
 678
 679         if (classname == NULL || dev == NULL || attrib == NULL) {
 680                 errno = EINVAL;
 681                 return NULL;
 682         }
 683         memset(path, 0, SYSFS_PATH_MAX);
 684         if ((get_classdev_path(classname, dev, path, SYSFS_PATH_MAX)) != 0) {
 685                 dprintf("Error getting to device %s on class %s\n",
 686                                                 dev, classname);
 687                 return NULL;
 688         }
 689         safestrcat(path, "/");
 690         safestrcat(path, attrib);
 691         attribute = sysfs_open_attribute(path);
 692         if (attribute == NULL) {
 693                 dprintf("Error opening attribute %s on class device %s\n",
 694                                 attrib, dev);
 695                 return NULL;
 696         }
 697         if ((sysfs_read_attribute(attribute)) != 0) {
 698                 dprintf("Error reading attribute %s for class device %s\n",
 699                                 attrib, dev);
 700                 sysfs_close_attribute(attribute);
 701                 return NULL;
 702         }
 703         return attribute;
 704 }
 705