src/libudev/libudev-device.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
   5   Copyright 2015 Tom Gundersen <teg@jklm.no>
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stddef.h>
  24 #include <unistd.h>
  25 #include <stdbool.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <ctype.h>
  31 #include <net/if.h>
  32 #include <sys/stat.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/socket.h>
  35 #include <linux/sockios.h>
  36
  37 #include "sd-device.h"
  38 #include "device-util.h"
  39 #include "device-private.h"
  40
  41 #include "libudev.h"
  42 #include "libudev-private.h"
  43 #include "libudev-device-internal.h"
  44
  45 /**
  46  * SECTION:libudev-device
  47  * @short_description: kernel sys devices
  48  *
  49  * Representation of kernel sys devices. Devices are uniquely identified
  50  * by their syspath, every device has exactly one path in the kernel sys
  51  * filesystem. Devices usually belong to a kernel subsystem, and have
  52  * a unique name inside that subsystem.
  53  */
  54
  55 /**
  56  * udev_device_get_seqnum:
  57  * @udev_device: udev device
  58  *
  59  * This is only valid if the device was received through a monitor. Devices read from
  60  * sys do not have a sequence number.
  61  *
  62  * Returns: the kernel event sequence number, or 0 if there is no sequence number available.
  63  **/
  64 _public_ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
  65 {
  66         const char *seqnum;
  67         unsigned long long ret;
  68         int r;
  69
  70         assert_return_errno(udev_device, 0, EINVAL);
  71
  72         r = sd_device_get_property_value(udev_device->device, "SEQNUM", &seqnum);
  73         if (r == -ENOENT)
  74                 return 0;
  75         else if (r < 0) {
  76                 errno = -r;
  77                 return 0;
  78         }
  79
  80         r = safe_atollu(seqnum, &ret);
  81         if (r < 0) {
  82                 errno = -r;
  83                 return 0;
  84         }
  85
  86         return ret;
  87 }
  88
  89 /**
  90  * udev_device_get_devnum:
  91  * @udev_device: udev device
  92  *
  93  * Get the device major/minor number.
  94  *
  95  * Returns: the dev_t number.
  96  **/
  97 _public_ dev_t udev_device_get_devnum(struct udev_device *udev_device)
  98 {
  99         dev_t devnum;
 100         int r;
 101
 102         assert_return_errno(udev_device, makedev(0, 0), EINVAL);
 103
 104         r = sd_device_get_devnum(udev_device->device, &devnum);
 105         if (r < 0) {
 106                 errno = -r;
 107                 return makedev(0, 0);
 108         }
 109
 110         return devnum;
 111 }
 112
 113 /**
 114  * udev_device_get_driver:
 115  * @udev_device: udev device
 116  *
 117  * Get the kernel driver name.
 118  *
 119  * Returns: the driver name string, or #NULL if there is no driver attached.
 120  **/
 121 _public_ const char *udev_device_get_driver(struct udev_device *udev_device)
 122 {
 123         const char *driver;
 124         int r;
 125
 126         assert_return_errno(udev_device, NULL, EINVAL);
 127
 128         r = sd_device_get_driver(udev_device->device, &driver);
 129         if (r < 0) {
 130                 errno = -r;
 131                 return NULL;
 132         }
 133
 134         return driver;
 135 }
 136
 137 /**
 138  * udev_device_get_devtype:
 139  * @udev_device: udev device
 140  *
 141  * Retrieve the devtype string of the udev device.
 142  *
 143  * Returns: the devtype name of the udev device, or #NULL if it can not be determined
 144  **/
 145 _public_ const char *udev_device_get_devtype(struct udev_device *udev_device)
 146 {
 147         const char *devtype;
 148         int r;
 149
 150         assert_return_errno(udev_device, NULL, EINVAL);
 151
 152         r = sd_device_get_devtype(udev_device->device, &devtype);
 153         if (r < 0) {
 154                 errno = -r;
 155                 return NULL;
 156         }
 157
 158         return devtype;
 159 }
 160
 161 /**
 162  * udev_device_get_subsystem:
 163  * @udev_device: udev device
 164  *
 165  * Retrieve the subsystem string of the udev device. The string does not
 166  * contain any "/".
 167  *
 168  * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
 169  **/
 170 _public_ const char *udev_device_get_subsystem(struct udev_device *udev_device)
 171 {
 172         const char *subsystem;
 173         int r;
 174
 175         assert_return_errno(udev_device, NULL, EINVAL);
 176
 177         r = sd_device_get_subsystem(udev_device->device, &subsystem);
 178         if (r < 0) {
 179                 errno = -r;
 180                 return NULL;
 181         }
 182
 183         return subsystem;
 184 }
 185
 186 /**
 187  * udev_device_get_property_value:
 188  * @udev_device: udev device
 189  * @key: property name
 190  *
 191  * Get the value of a given property.
 192  *
 193  * Returns: the property string, or #NULL if there is no such property.
 194  **/
 195 _public_ const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
 196 {
 197         const char *value = NULL;
 198         int r;
 199
 200         assert_return_errno(udev_device && key, NULL, EINVAL);
 201
 202         r = sd_device_get_property_value(udev_device->device, key, &value);
 203         if (r < 0) {
 204                 errno = -r;
 205                 return NULL;
 206         }
 207
 208         return value;
 209 }
 210
 211 struct udev_device *udev_device_new(struct udev *udev) {
 212         struct udev_device *udev_device;
 213
 214         assert_return_errno(udev, NULL, EINVAL);
 215
 216         udev_device = new0(struct udev_device, 1);
 217         if (!udev_device) {
 218                 errno = ENOMEM;
 219                 return NULL;
 220         }
 221         udev_device->refcount = 1;
 222         udev_device->udev = udev;
 223         udev_list_init(udev, &udev_device->properties, true);
 224         udev_list_init(udev, &udev_device->tags, true);
 225         udev_list_init(udev, &udev_device->sysattrs, true);
 226         udev_list_init(udev, &udev_device->devlinks, true);
 227
 228         return udev_device;
 229 }
 230
 231 /**
 232  * udev_device_new_from_syspath:
 233  * @udev: udev library context
 234  * @syspath: sys device path including sys directory
 235  *
 236  * Create new udev device, and fill in information from the sys
 237  * device and the udev database entry. The syspath is the absolute
 238  * path to the device, including the sys mount point.
 239  *
 240  * The initial refcount is 1, and needs to be decremented to
 241  * release the resources of the udev device.
 242  *
 243  * Returns: a new udev device, or #NULL, if it does not exist
 244  **/
 245 _public_ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath) {
 246         struct udev_device *udev_device;
 247         int r;
 248
 249         udev_device = udev_device_new(udev);
 250         if (!udev_device)
 251                 return NULL;
 252
 253         r = sd_device_new_from_syspath(&udev_device->device, syspath);
 254         if (r < 0) {
 255                 errno = -r;
 256                 udev_device_unref(udev_device);
 257                 return NULL;
 258         }
 259
 260         return udev_device;
 261 }
 262
 263 /**
 264  * udev_device_new_from_devnum:
 265  * @udev: udev library context
 266  * @type: char or block device
 267  * @devnum: device major/minor number
 268  *
 269  * Create new udev device, and fill in information from the sys
 270  * device and the udev database entry. The device is looked-up
 271  * by its major/minor number and type. Character and block device
 272  * numbers are not unique across the two types.
 273  *
 274  * The initial refcount is 1, and needs to be decremented to
 275  * release the resources of the udev device.
 276  *
 277  * Returns: a new udev device, or #NULL, if it does not exist
 278  **/
 279 _public_ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
 280 {
 281         struct udev_device *udev_device;
 282         int r;
 283
 284         udev_device = udev_device_new(udev);
 285         if (!udev_device)
 286                 return NULL;
 287
 288         r = sd_device_new_from_devnum(&udev_device->device, type, devnum);
 289         if (r < 0) {
 290                 errno = -r;
 291                 udev_device_unref(udev_device);
 292                 return NULL;
 293         }
 294
 295         return udev_device;
 296 }
 297
 298 /**
 299  * udev_device_new_from_device_id:
 300  * @udev: udev library context
 301  * @id: text string identifying a kernel device
 302  *
 303  * Create new udev device, and fill in information from the sys
 304  * device and the udev database entry. The device is looked-up
 305  * by a special string:
 306  *   b8:2          - block device major:minor
 307  *   c128:1        - char device major:minor
 308  *   n3            - network device ifindex
 309  *   +sound:card29 - kernel driver core subsystem:device name
 310  *
 311  * The initial refcount is 1, and needs to be decremented to
 312  * release the resources of the udev device.
 313  *
 314  * Returns: a new udev device, or #NULL, if it does not exist
 315  **/
 316 _public_ struct udev_device *udev_device_new_from_device_id(struct udev *udev, const char *id)
 317 {
 318         struct udev_device *udev_device;
 319         int r;
 320
 321         udev_device = udev_device_new(udev);
 322         if (!udev_device)
 323                 return NULL;
 324
 325         r = sd_device_new_from_device_id(&udev_device->device, id);
 326         if (r < 0) {
 327                 errno = -r;
 328                 udev_device_unref(udev_device);
 329                 return NULL;
 330         }
 331
 332         return udev_device;
 333 }
 334
 335 /**
 336  * udev_device_new_from_subsystem_sysname:
 337  * @udev: udev library context
 338  * @subsystem: the subsystem of the device
 339  * @sysname: the name of the device
 340  *
 341  * Create new udev device, and fill in information from the sys device
 342  * and the udev database entry. The device is looked up by the subsystem
 343  * and name string of the device, like "mem" / "zero", or "block" / "sda".
 344  *
 345  * The initial refcount is 1, and needs to be decremented to
 346  * release the resources of the udev device.
 347  *
 348  * Returns: a new udev device, or #NULL, if it does not exist
 349  **/
 350 _public_ struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
 351 {
 352         struct udev_device *udev_device;
 353         int r;
 354
 355         udev_device = udev_device_new(udev);
 356         if (!udev_device)
 357                 return NULL;
 358
 359         r = sd_device_new_from_subsystem_sysname(&udev_device->device, subsystem, sysname);
 360         if (r < 0) {
 361                 errno = -r;
 362                 udev_device_unref(udev_device);
 363                 return NULL;
 364         }
 365
 366         return udev_device;
 367 }
 368
 369 /**
 370  * udev_device_new_from_environment
 371  * @udev: udev library context
 372  *
 373  * Create new udev device, and fill in information from the
 374  * current process environment. This only works reliable if
 375  * the process is called from a udev rule. It is usually used
 376  * for tools executed from IMPORT= rules.
 377  *
 378  * The initial refcount is 1, and needs to be decremented to
 379  * release the resources of the udev device.
 380  *
 381  * Returns: a new udev device, or #NULL, if it does not exist
 382  **/
 383 _public_ struct udev_device *udev_device_new_from_environment(struct udev *udev)
 384 {
 385         struct udev_device *udev_device;
 386         int r;
 387
 388         udev_device = udev_device_new(udev);
 389         if (!udev_device)
 390                 return NULL;
 391
 392         r = device_new_from_strv(&udev_device->device, environ);
 393         if (r < 0) {
 394                 errno = -r;
 395                 udev_device_unref(udev_device);
 396                 return NULL;
 397         }
 398
 399         return udev_device;
 400 }
 401
 402 static struct udev_device *device_new_from_parent(struct udev_device *child)
 403 {
 404         struct udev_device *parent;
 405         int r;
 406
 407         assert_return_errno(child, NULL, EINVAL);
 408
 409         parent = udev_device_new(child->udev);
 410         if (!parent)
 411                 return NULL;
 412
 413         r = sd_device_get_parent(child->device, &parent->device);
 414         if (r < 0) {
 415                 errno = -r;
 416                 udev_device_unref(parent);
 417                 return NULL;
 418         }
 419
 420         /* the parent is unref'ed with the child, so take a ref from libudev as well */
 421         sd_device_ref(parent->device);
 422
 423         return parent;
 424 }
 425
 426 /**
 427  * udev_device_get_parent:
 428  * @udev_device: the device to start searching from
 429  *
 430  * Find the next parent device, and fill in information from the sys
 431  * device and the udev database entry.
 432  *
 433  * Returned device is not referenced. It is attached to the child
 434  * device, and will be cleaned up when the child device is cleaned up.
 435  *
 436  * It is not necessarily just the upper level directory, empty or not
 437  * recognized sys directories are ignored.
 438  *
 439  * It can be called as many times as needed, without caring about
 440  * references.
 441  *
 442  * Returns: a new udev device, or #NULL, if it no parent exist.
 443  **/
 444 _public_ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 445 {
 446         assert_return_errno(udev_device, NULL, EINVAL);
 447
 448         if (!udev_device->parent_set) {
 449                 udev_device->parent_set = true;
 450                 udev_device->parent = device_new_from_parent(udev_device);
 451         }
 452
 453         /* TODO: errno will differ here in case parent == NULL */
 454         return udev_device->parent;
 455 }
 456
 457 /**
 458  * udev_device_get_parent_with_subsystem_devtype:
 459  * @udev_device: udev device to start searching from
 460  * @subsystem: the subsystem of the device
 461  * @devtype: the type (DEVTYPE) of the device
 462  *
 463  * Find the next parent device, with a matching subsystem and devtype
 464  * value, and fill in information from the sys device and the udev
 465  * database entry.
 466  *
 467  * If devtype is #NULL, only subsystem is checked, and any devtype will
 468  * match.
 469  *
 470  * Returned device is not referenced. It is attached to the child
 471  * device, and will be cleaned up when the child device is cleaned up.
 472  *
 473  * It can be called as many times as needed, without caring about
 474  * references.
 475  *
 476  * Returns: a new udev device, or #NULL if no matching parent exists.
 477  **/
 478 _public_ struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 479 {
 480         sd_device *parent;
 481         int r;
 482
 483         assert_return_errno(udev_device, NULL, EINVAL);
 484
 485         /* this relies on the fact that finding the subdevice of a parent or the
 486            parent of a subdevice commute */
 487
 488         /* first find the correct sd_device */
 489         r = sd_device_get_parent_with_subsystem_devtype(udev_device->device, subsystem, devtype, &parent);
 490         if (r < 0) {
 491                 errno = -r;
 492                 return NULL;
 493         }
 494
 495         /* then walk the chain of udev_device parents until the correspanding
 496            one is found */
 497         while ((udev_device = udev_device_get_parent(udev_device))) {
 498                 if (udev_device->device == parent)
 499                         return udev_device;
 500         }
 501
 502         errno = ENOENT;
 503         return NULL;
 504 }
 505
 506 /**
 507  * udev_device_get_udev:
 508  * @udev_device: udev device
 509  *
 510  * Retrieve the udev library context the device was created with.
 511  *
 512  * Returns: the udev library context
 513  **/
 514 _public_ struct udev *udev_device_get_udev(struct udev_device *udev_device)
 515 {
 516         assert_return_errno(udev_device, NULL, EINVAL);
 517
 518         return udev_device->udev;
 519 }
 520
 521 /**
 522  * udev_device_ref:
 523  * @udev_device: udev device
 524  *
 525  * Take a reference of a udev device.
 526  *
 527  * Returns: the passed udev device
 528  **/
 529 _public_ struct udev_device *udev_device_ref(struct udev_device *udev_device)
 530 {
 531         if (udev_device)
 532                 udev_device->refcount++;
 533
 534         return udev_device;
 535 }
 536
 537 /**
 538  * udev_device_unref:
 539  * @udev_device: udev device
 540  *
 541  * Drop a reference of a udev device. If the refcount reaches zero,
 542  * the resources of the device will be released.
 543  *
 544  * Returns: #NULL
 545  **/
 546 _public_ struct udev_device *udev_device_unref(struct udev_device *udev_device)
 547 {
 548         if (udev_device && (-- udev_device->refcount) == 0) {
 549                 sd_device_unref(udev_device->device);
 550                 udev_device_unref(udev_device->parent);
 551
 552                 udev_list_cleanup(&udev_device->properties);
 553                 udev_list_cleanup(&udev_device->sysattrs);
 554                 udev_list_cleanup(&udev_device->tags);
 555                 udev_list_cleanup(&udev_device->devlinks);
 556
 557                 free(udev_device);
 558         }
 559
 560         return NULL;
 561 }
 562
 563 /**
 564  * udev_device_get_devpath:
 565  * @udev_device: udev device
 566  *
 567  * Retrieve the kernel devpath value of the udev device. The path
 568  * does not contain the sys mount point, and starts with a '/'.
 569  *
 570  * Returns: the devpath of the udev device
 571  **/
 572 _public_ const char *udev_device_get_devpath(struct udev_device *udev_device)
 573 {
 574         const char *devpath;
 575         int r;
 576
 577         assert_return_errno(udev_device, NULL, EINVAL);
 578
 579         r = sd_device_get_devpath(udev_device->device, &devpath);
 580         if (r < 0) {
 581                 errno = -r;
 582                 return NULL;
 583         }
 584
 585         return devpath;
 586 }
 587
 588 /**
 589  * udev_device_get_syspath:
 590  * @udev_device: udev device
 591  *
 592  * Retrieve the sys path of the udev device. The path is an
 593  * absolute path and starts with the sys mount point.
 594  *
 595  * Returns: the sys path of the udev device
 596  **/
 597 _public_ const char *udev_device_get_syspath(struct udev_device *udev_device)
 598 {
 599         const char *syspath;
 600         int r;
 601
 602         assert_return_errno(udev_device, NULL, EINVAL);
 603
 604         r = sd_device_get_syspath(udev_device->device, &syspath);
 605         if (r < 0) {
 606                 errno = -r;
 607                 return NULL;
 608         }
 609
 610         return syspath;
 611 }
 612
 613 /**
 614  * udev_device_get_sysname:
 615  * @udev_device: udev device
 616  *
 617  * Get the kernel device name in /sys.
 618  *
 619  * Returns: the name string of the device device
 620  **/
 621 _public_ const char *udev_device_get_sysname(struct udev_device *udev_device)
 622 {
 623         const char *sysname;
 624         int r;
 625
 626         assert_return_errno(udev_device, NULL, EINVAL);
 627
 628         r = sd_device_get_sysname(udev_device->device, &sysname);
 629         if (r < 0) {
 630                 errno = -r;
 631                 return NULL;
 632         }
 633
 634         return sysname;
 635 }
 636
 637 /**
 638  * udev_device_get_sysnum:
 639  * @udev_device: udev device
 640  *
 641  * Get the instance number of the device.
 642  *
 643  * Returns: the trailing number string of the device name
 644  **/
 645 _public_ const char *udev_device_get_sysnum(struct udev_device *udev_device)
 646 {
 647         const char *sysnum;
 648         int r;
 649
 650         assert_return_errno(udev_device, NULL, EINVAL);
 651
 652         r = sd_device_get_sysnum(udev_device->device, &sysnum);
 653         if (r < 0) {
 654                 errno = -r;
 655                 return NULL;
 656         }
 657
 658         return sysnum;
 659 }
 660
 661 /**
 662  * udev_device_get_devnode:
 663  * @udev_device: udev device
 664  *
 665  * Retrieve the device node file name belonging to the udev device.
 666  * The path is an absolute path, and starts with the device directory.
 667  *
 668  * Returns: the device node file name of the udev device, or #NULL if no device node exists
 669  **/
 670 _public_ const char *udev_device_get_devnode(struct udev_device *udev_device)
 671 {
 672         const char *devnode;
 673         int r;
 674
 675         assert_return_errno(udev_device, NULL, EINVAL);
 676
 677         r = sd_device_get_devname(udev_device->device, &devnode);
 678         if (r < 0) {
 679                 errno = -r;
 680                 return NULL;
 681         }
 682
 683         return devnode;
 684 }
 685
 686 /**
 687  * udev_device_get_devlinks_list_entry:
 688  * @udev_device: udev device
 689  *
 690  * Retrieve the list of device links pointing to the device file of
 691  * the udev device. The next list entry can be retrieved with
 692  * udev_list_entry_get_next(), which returns #NULL if no more entries exist.
 693  * The devlink path can be retrieved from the list entry by
 694  * udev_list_entry_get_name(). The path is an absolute path, and starts with
 695  * the device directory.
 696  *
 697  * Returns: the first entry of the device node link list
 698  **/
 699 _public_ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
 700 {
 701         assert_return_errno(udev_device, NULL, EINVAL);
 702
 703         if (device_get_devlinks_generation(udev_device->device) != udev_device->devlinks_generation) {
 704                 const char *devlink;
 705
 706                 udev_list_cleanup(&udev_device->devlinks);
 707
 708                 FOREACH_DEVICE_DEVLINK(udev_device->device, devlink)
 709                         udev_list_entry_add(&udev_device->devlinks, devlink, NULL);
 710
 711                 udev_device->devlinks_generation = device_get_devlinks_generation(udev_device->device);
 712         }
 713
 714         return udev_list_get_entry(&udev_device->devlinks);
 715 }
 716
 717 /**
 718  * udev_device_get_event_properties_entry:
 719  * @udev_device: udev device
 720  *
 721  * Retrieve the list of key/value device properties of the udev
 722  * device. The next list entry can be retrieved with udev_list_entry_get_next(),
 723  * which returns #NULL if no more entries exist. The property name
 724  * can be retrieved from the list entry by udev_list_entry_get_name(),
 725  * the property value by udev_list_entry_get_value().
 726  *
 727  * Returns: the first entry of the property list
 728  **/
 729 _public_ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
 730 {
 731         assert_return_errno(udev_device, NULL, EINVAL);
 732
 733         if (device_get_properties_generation(udev_device->device) != udev_device->properties_generation) {
 734                 const char *key, *value;
 735
 736                 udev_list_cleanup(&udev_device->properties);
 737
 738                 FOREACH_DEVICE_PROPERTY(udev_device->device, key, value)
 739                         udev_list_entry_add(&udev_device->properties, key, value);
 740
 741                 udev_device->properties_generation = device_get_properties_generation(udev_device->device);
 742         }
 743
 744         return udev_list_get_entry(&udev_device->properties);
 745 }
 746
 747 /**
 748  * udev_device_get_action:
 749  * @udev_device: udev device
 750  *
 751  * This is only valid if the device was received through a monitor. Devices read from
 752  * sys do not have an action string. Usual actions are: add, remove, change, online,
 753  * offline.
 754  *
 755  * Returns: the kernel action value, or #NULL if there is no action value available.
 756  **/
 757 _public_ const char *udev_device_get_action(struct udev_device *udev_device) {
 758         const char *action = NULL;
 759         int r;
 760
 761         assert_return_errno(udev_device, NULL, EINVAL);
 762
 763         r = sd_device_get_property_value(udev_device->device, "ACTION", &action);
 764         if (r < 0 && r != -ENOENT) {
 765                 errno = -r;
 766                 return NULL;
 767         }
 768
 769         return action;
 770 }
 771
 772 /**
 773  * udev_device_get_usec_since_initialized:
 774  * @udev_device: udev device
 775  *
 776  * Return the number of microseconds passed since udev set up the
 777  * device for the first time.
 778  *
 779  * This is only implemented for devices with need to store properties
 780  * in the udev database. All other devices return 0 here.
 781  *
 782  * Returns: the number of microseconds since the device was first seen.
 783  **/
 784 _public_ unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
 785 {
 786         usec_t ts;
 787         int r;
 788
 789         assert_return(udev_device, -EINVAL);
 790
 791         r = sd_device_get_usec_since_initialized(udev_device->device, &ts);
 792         if (r < 0) {
 793                 errno = EINVAL;
 794                 return 0;
 795         }
 796
 797         return ts;
 798 }
 799
 800 /**
 801  * udev_device_get_sysattr_value:
 802  * @udev_device: udev device
 803  * @sysattr: attribute name
 804  *
 805  * The retrieved value is cached in the device. Repeated calls will return the same
 806  * value and not open the attribute again.
 807  *
 808  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
 809  **/
 810 _public_ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
 811 {
 812         const char *value;
 813         int r;
 814
 815         assert_return_errno(udev_device, NULL, EINVAL);
 816
 817         r = sd_device_get_sysattr_value(udev_device->device, sysattr, &value);
 818         if (r < 0) {
 819                 errno = -r;
 820                 return NULL;
 821         }
 822
 823         return value;
 824 }
 825
 826 /**
 827  * udev_device_set_sysattr_value:
 828  * @udev_device: udev device
 829  * @sysattr: attribute name
 830  * @value: new value to be set
 831  *
 832  * Update the contents of the sys attribute and the cached value of the device.
 833  *
 834  * Returns: Negative error code on failure or 0 on success.
 835  **/
 836 _public_ int udev_device_set_sysattr_value(struct udev_device *udev_device, const char *sysattr, char *value)
 837 {
 838         int r;
 839
 840         assert_return(udev_device, -EINVAL);
 841
 842         r = sd_device_set_sysattr_value(udev_device->device, sysattr, value);
 843         if (r < 0)
 844                 return r;
 845
 846         return 0;
 847 }
 848
 849 /**
 850  * udev_device_get_sysattr_list_entry:
 851  * @udev_device: udev device
 852  *
 853  * Retrieve the list of available sysattrs, with value being empty;
 854  * This just return all available sysfs attributes for a particular
 855  * device without reading their values.
 856  *
 857  * Returns: the first entry of the property list
 858  **/
 859 _public_ struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
 860 {
 861         assert_return_errno(udev_device, NULL, EINVAL);
 862
 863         if (!udev_device->sysattrs_read) {
 864                 const char *sysattr;
 865
 866                 udev_list_cleanup(&udev_device->sysattrs);
 867
 868                 FOREACH_DEVICE_SYSATTR(udev_device->device, sysattr)
 869                         udev_list_entry_add(&udev_device->properties, sysattr, NULL);
 870
 871                 udev_device->sysattrs_read = true;
 872         }
 873
 874         return udev_list_get_entry(&udev_device->sysattrs);
 875 }
 876
 877 /**
 878  * udev_device_get_is_initialized:
 879  * @udev_device: udev device
 880  *
 881  * Check if udev has already handled the device and has set up
 882  * device node permissions and context, or has renamed a network
 883  * device.
 884  *
 885  * This is only implemented for devices with a device node
 886  * or network interfaces. All other devices return 1 here.
 887  *
 888  * Returns: 1 if the device is set up. 0 otherwise.
 889  **/
 890 _public_ int udev_device_get_is_initialized(struct udev_device *udev_device)
 891 {
 892         int r, initialized;
 893
 894         assert_return(udev_device, -EINVAL);
 895
 896         r = sd_device_get_is_initialized(udev_device->device, &initialized);
 897         if (r < 0) {
 898                 errno = -r;
 899
 900                 return 0;
 901         }
 902
 903         return initialized;
 904 }
 905
 906 /**
 907  * udev_device_get_tags_list_entry:
 908  * @udev_device: udev device
 909  *
 910  * Retrieve the list of tags attached to the udev device. The next
 911  * list entry can be retrieved with udev_list_entry_get_next(),
 912  * which returns #NULL if no more entries exist. The tag string
 913  * can be retrieved from the list entry by udev_list_entry_get_name().
 914  *
 915  * Returns: the first entry of the tag list
 916  **/
 917 _public_ struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
 918 {
 919         assert_return_errno(udev_device, NULL, EINVAL);
 920
 921         if (device_get_tags_generation(udev_device->device) != udev_device->tags_generation) {
 922                 const char *tag;
 923
 924                 udev_list_cleanup(&udev_device->tags);
 925
 926                 FOREACH_DEVICE_TAG(udev_device->device, tag)
 927                         udev_list_entry_add(&udev_device->tags, tag, NULL);
 928
 929                 udev_device->tags_generation = device_get_tags_generation(udev_device->device);
 930         }
 931
 932         return udev_list_get_entry(&udev_device->tags);
 933 }
 934
 935 /**
 936  * udev_device_has_tag:
 937  * @udev_device: udev device
 938  * @tag: tag name
 939  *
 940  * Check if a given device has a certain tag associated.
 941  *
 942  * Returns: 1 if the tag is found. 0 otherwise.
 943  **/
 944 _public_ int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
 945 {
 946         assert_return(udev_device, 0);
 947
 948         return sd_device_has_tag(udev_device->device, tag);
 949 }