src/libudev/libudev-queue.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
   6   Copyright 2009 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   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 License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <stddef.h>
  24 #include <stdlib.h>
  25 #include <sys/inotify.h>
  26 #include <unistd.h>
  27
  28 #include "alloc-util.h"
  29 #include "fd-util.h"
  30 #include "io-util.h"
  31 #include "libudev-private.h"
  32
  33 /**
  34  * SECTION:libudev-queue
  35  * @short_description: access to currently active events
  36  *
  37  * This exports the current state of the udev processing queue.
  38  */
  39
  40 /**
  41  * udev_queue:
  42  *
  43  * Opaque object representing the current event queue in the udev daemon.
  44  */
  45 struct udev_queue {
  46         struct udev *udev;
  47         int refcount;
  48         int fd;
  49 };
  50
  51 /**
  52  * udev_queue_new:
  53  * @udev: udev library context
  54  *
  55  * The initial refcount is 1, and needs to be decremented to
  56  * release the resources of the udev queue context.
  57  *
  58  * Returns: the udev queue context, or #NULL on error.
  59  **/
  60 _public_ struct udev_queue *udev_queue_new(struct udev *udev)
  61 {
  62         struct udev_queue *udev_queue;
  63
  64         if (udev == NULL) {
  65                 errno = EINVAL;
  66                 return NULL;
  67         }
  68
  69         udev_queue = new0(struct udev_queue, 1);
  70         if (udev_queue == NULL) {
  71                 errno = ENOMEM;
  72                 return NULL;
  73         }
  74
  75         udev_queue->refcount = 1;
  76         udev_queue->udev = udev;
  77         udev_queue->fd = -1;
  78         return udev_queue;
  79 }
  80
  81 /**
  82  * udev_queue_ref:
  83  * @udev_queue: udev queue context
  84  *
  85  * Take a reference of a udev queue context.
  86  *
  87  * Returns: the same udev queue context.
  88  **/
  89 _public_ struct udev_queue *udev_queue_ref(struct udev_queue *udev_queue)
  90 {
  91         if (udev_queue == NULL)
  92                 return NULL;
  93
  94         udev_queue->refcount++;
  95         return udev_queue;
  96 }
  97
  98 /**
  99  * udev_queue_unref:
 100  * @udev_queue: udev queue context
 101  *
 102  * Drop a reference of a udev queue context. If the refcount reaches zero,
 103  * the resources of the queue context will be released.
 104  *
 105  * Returns: #NULL
 106  **/
 107 _public_ struct udev_queue *udev_queue_unref(struct udev_queue *udev_queue)
 108 {
 109         if (udev_queue == NULL)
 110                 return NULL;
 111
 112         udev_queue->refcount--;
 113         if (udev_queue->refcount > 0)
 114                 return NULL;
 115
 116         safe_close(udev_queue->fd);
 117
 118         free(udev_queue);
 119         return NULL;
 120 }
 121
 122 /**
 123  * udev_queue_get_udev:
 124  * @udev_queue: udev queue context
 125  *
 126  * Retrieve the udev library context the queue context was created with.
 127  *
 128  * Returns: the udev library context.
 129  **/
 130 _public_ struct udev *udev_queue_get_udev(struct udev_queue *udev_queue)
 131 {
 132         if (udev_queue == NULL) {
 133                 errno = EINVAL;
 134                 return NULL;
 135         }
 136         return udev_queue->udev;
 137 }
 138
 139 /**
 140  * udev_queue_get_kernel_seqnum:
 141  * @udev_queue: udev queue context
 142  *
 143  * This function is deprecated.
 144  *
 145  * Returns: 0.
 146  **/
 147 _public_ unsigned long long int udev_queue_get_kernel_seqnum(struct udev_queue *udev_queue)
 148 {
 149         return 0;
 150 }
 151
 152 /**
 153  * udev_queue_get_udev_seqnum:
 154  * @udev_queue: udev queue context
 155  *
 156  * This function is deprecated.
 157  *
 158  * Returns: 0.
 159  **/
 160 _public_ unsigned long long int udev_queue_get_udev_seqnum(struct udev_queue *udev_queue)
 161 {
 162         return 0;
 163 }
 164
 165 /**
 166  * udev_queue_get_udev_is_active:
 167  * @udev_queue: udev queue context
 168  *
 169  * Check if udev is active on the system.
 170  *
 171  * Returns: a flag indicating if udev is active.
 172  **/
 173 _public_ int udev_queue_get_udev_is_active(struct udev_queue *udev_queue)
 174 {
 175         return access("/run/udev/control", F_OK) >= 0;
 176 }
 177
 178 /**
 179  * udev_queue_get_queue_is_empty:
 180  * @udev_queue: udev queue context
 181  *
 182  * Check if udev is currently processing any events.
 183  *
 184  * Returns: a flag indicating if udev is currently handling events.
 185  **/
 186 _public_ int udev_queue_get_queue_is_empty(struct udev_queue *udev_queue)
 187 {
 188         return access("/run/udev/queue", F_OK) < 0;
 189 }
 190
 191 /**
 192  * udev_queue_get_seqnum_sequence_is_finished:
 193  * @udev_queue: udev queue context
 194  * @start: first event sequence number
 195  * @end: last event sequence number
 196  *
 197  * This function is deprecated, it just returns the result of
 198  * udev_queue_get_queue_is_empty().
 199  *
 200  * Returns: a flag indicating if udev is currently handling events.
 201  **/
 202 _public_ int udev_queue_get_seqnum_sequence_is_finished(struct udev_queue *udev_queue,
 203                                                unsigned long long int start, unsigned long long int end)
 204 {
 205         return udev_queue_get_queue_is_empty(udev_queue);
 206 }
 207
 208 /**
 209  * udev_queue_get_seqnum_is_finished:
 210  * @udev_queue: udev queue context
 211  * @seqnum: sequence number
 212  *
 213  * This function is deprecated, it just returns the result of
 214  * udev_queue_get_queue_is_empty().
 215  *
 216  * Returns: a flag indicating if udev is currently handling events.
 217  **/
 218 _public_ int udev_queue_get_seqnum_is_finished(struct udev_queue *udev_queue, unsigned long long int seqnum)
 219 {
 220         return udev_queue_get_queue_is_empty(udev_queue);
 221 }
 222
 223 /**
 224  * udev_queue_get_queued_list_entry:
 225  * @udev_queue: udev queue context
 226  *
 227  * This function is deprecated.
 228  *
 229  * Returns: NULL.
 230  **/
 231 _public_ struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev_queue)
 232 {
 233         errno = ENODATA;
 234         return NULL;
 235 }
 236
 237 /**
 238  * udev_queue_get_fd:
 239  * @udev_queue: udev queue context
 240  *
 241  * Returns: a file descriptor to watch for a queue to become empty.
 242  */
 243 _public_ int udev_queue_get_fd(struct udev_queue *udev_queue) {
 244         int fd;
 245         int r;
 246
 247         if (udev_queue->fd >= 0)
 248                 return udev_queue->fd;
 249
 250         fd = inotify_init1(IN_CLOEXEC);
 251         if (fd < 0)
 252                 return -errno;
 253
 254         r = inotify_add_watch(fd, "/run/udev" , IN_DELETE);
 255         if (r < 0) {
 256                 r = -errno;
 257                 close(fd);
 258                 return r;
 259         }
 260
 261         udev_queue->fd = fd;
 262         return fd;
 263 }
 264
 265 /**
 266  * udev_queue_flush:
 267  * @udev_queue: udev queue context
 268  *
 269  * Returns: the result of clearing the watch for queue changes.
 270  */
 271 _public_ int udev_queue_flush(struct udev_queue *udev_queue) {
 272         if (udev_queue->fd < 0)
 273                 return -EINVAL;
 274
 275         return flush_fd(udev_queue->fd);
 276 }