udev/lib/libudev-queue.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <stddef.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <dirent.h>
  19 #include <fcntl.h>
  20 #include <sys/stat.h>
  21
  22 #include "libudev.h"
  23 #include "libudev-private.h"
  24
  25 struct udev_queue {
  26         struct udev *udev;
  27         int refcount;
  28         unsigned long long int last_seen_udev_seqnum;
  29         struct udev_list_node queue_list;
  30         struct udev_list_node failed_list;
  31 };
  32
  33 struct udev_queue *udev_queue_new(struct udev *udev)
  34 {
  35         struct udev_queue *udev_queue;
  36
  37         if (udev == NULL)
  38                 return NULL;
  39
  40         udev_queue = calloc(1, sizeof(struct udev_queue));
  41         if (udev_queue == NULL)
  42                 return NULL;
  43         udev_queue->refcount = 1;
  44         udev_queue->udev = udev;
  45         udev_list_init(&udev_queue->queue_list);
  46         udev_list_init(&udev_queue->failed_list);
  47         return udev_queue;
  48 }
  49
  50 struct udev_queue *udev_queue_ref(struct udev_queue *udev_queue)
  51 {
  52         if (udev_queue == NULL)
  53                 return NULL;
  54         udev_queue->refcount++;
  55         return udev_queue;
  56 }
  57
  58 void udev_queue_unref(struct udev_queue *udev_queue)
  59 {
  60         if (udev_queue == NULL)
  61                 return;
  62         udev_queue->refcount--;
  63         if (udev_queue->refcount > 0)
  64                 return;
  65         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->queue_list);
  66         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->failed_list);
  67         free(udev_queue);
  68 }
  69
  70 struct udev *udev_queue_get_udev(struct udev_queue *udev_queue)
  71 {
  72         if (udev_queue == NULL)
  73                 return NULL;
  74         return udev_queue->udev;
  75 }
  76
  77 unsigned long long int udev_queue_get_kernel_seqnum(struct udev_queue *udev_queue)
  78 {
  79         char filename[UTIL_PATH_SIZE];
  80         unsigned long long int seqnum;
  81         int fd;
  82         char buf[32];
  83         ssize_t len;
  84
  85         if (udev_queue == NULL)
  86                 return -EINVAL;
  87         util_strlcpy(filename, udev_get_sys_path(udev_queue->udev), sizeof(filename));
  88         util_strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
  89         fd = open(filename, O_RDONLY);
  90         if (fd < 0)
  91                 return 0;
  92         len = read(fd, buf, sizeof(buf));
  93         close(fd);
  94         if (len <= 2)
  95                 return 0;
  96         buf[len-1] = '\0';
  97         seqnum = strtoull(buf, NULL, 10);
  98         dbg(udev_queue->udev, "seqnum=%llu\n", seqnum);
  99         return seqnum;
 100 }
 101
 102 unsigned long long int udev_queue_get_udev_seqnum(struct udev_queue *udev_queue)
 103 {
 104         char filename[UTIL_PATH_SIZE];
 105         unsigned long long int seqnum;
 106         int fd;
 107         char buf[32];
 108         ssize_t len;
 109
 110         if (udev_queue == NULL)
 111                 return -EINVAL;
 112         util_strlcpy(filename, udev_get_dev_path(udev_queue->udev), sizeof(filename));
 113         util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
 114         fd = open(filename, O_RDONLY);
 115         if (fd < 0)
 116                 return 0;
 117         len = read(fd, buf, sizeof(buf));
 118         close(fd);
 119         if (len <= 2)
 120                 return 0;
 121         buf[len-1] = '\0';
 122         seqnum = strtoull(buf, NULL, 10);
 123         dbg(udev_queue->udev, "seqnum=%llu\n", seqnum);
 124         udev_queue->last_seen_udev_seqnum = seqnum;
 125         return seqnum;
 126 }
 127
 128 int udev_queue_get_udev_is_active(struct udev_queue *udev_queue)
 129 {
 130         char filename[UTIL_PATH_SIZE];
 131         struct stat statbuf;
 132
 133         if (udev_queue == NULL)
 134                 return 0;
 135         util_strlcpy(filename, udev_get_dev_path(udev_queue->udev), sizeof(filename));
 136         util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
 137         if (stat(filename, &statbuf) == 0)
 138                 return 1;
 139         return 0;
 140 }
 141
 142 int udev_queue_get_queue_is_empty(struct udev_queue *udev_queue)
 143 {
 144         char queuename[UTIL_PATH_SIZE];
 145         struct stat statbuf;
 146         unsigned long long int seqnum_kernel;
 147
 148         if (udev_queue == NULL)
 149                 return -EINVAL;
 150         util_strlcpy(queuename, udev_get_dev_path(udev_queue->udev), sizeof(queuename));
 151         util_strlcat(queuename, "/.udev/queue", sizeof(queuename));
 152         if (stat(queuename, &statbuf) == 0) {
 153                 dbg(udev_queue->udev, "queue is not empty\n");
 154                 return 0;
 155         }
 156         seqnum_kernel = udev_queue_get_kernel_seqnum(udev_queue);
 157         if (seqnum_kernel <= udev_queue->last_seen_udev_seqnum) {
 158                 dbg(udev_queue->udev, "queue is empty\n");
 159                 return 1;
 160         }
 161         /* update udev seqnum, and check if udev is still running */
 162         if (udev_queue_get_udev_seqnum(udev_queue) == 0)
 163                 if (!udev_queue_get_udev_is_active(udev_queue))
 164                         return 1;
 165         if (seqnum_kernel <= udev_queue->last_seen_udev_seqnum) {
 166                 dbg(udev_queue->udev, "queue is empty\n");
 167                 return 1;
 168         }
 169         dbg(udev_queue->udev, "queue is empty, but kernel events still pending [%llu]<->[%llu]\n",
 170              seqnum_kernel, udev_queue->last_seen_udev_seqnum);
 171         return 0;
 172 }
 173
 174 int udev_queue_get_seqnum_is_finished(struct udev_queue *udev_queue, unsigned long long int seqnum)
 175 {
 176         char filename[UTIL_PATH_SIZE];
 177         struct stat statbuf;
 178
 179         if (udev_queue == NULL)
 180                 return -EINVAL;
 181         /* if we have not seen this seqnum, check if it is/was already queued */
 182         if (seqnum < udev_queue->last_seen_udev_seqnum) {
 183                 udev_queue_get_udev_seqnum(udev_queue);
 184                 if (seqnum < udev_queue->last_seen_udev_seqnum)
 185                         return 0;
 186         }
 187         snprintf(filename, sizeof(filename), "%s/.udev/queue/%llu",
 188                  udev_get_dev_path(udev_queue->udev), seqnum);
 189         if (lstat(filename, &statbuf) == 0)
 190                 return 0;
 191         dbg(udev_queue->udev, "seqnum: %llu finished\n", seqnum);
 192         return 1;
 193 }
 194
 195 struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev_queue)
 196 {
 197         char path[UTIL_PATH_SIZE];
 198         DIR *dir;
 199         struct dirent *dent;
 200
 201         if (udev_queue == NULL)
 202                 return NULL;
 203         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->queue_list);
 204         util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
 205         util_strlcat(path, "/.udev/queue", sizeof(path));
 206         dir = opendir(path);
 207         if (dir == NULL)
 208                 return NULL;
 209         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 210                 char filename[UTIL_PATH_SIZE];
 211                 char syspath[UTIL_PATH_SIZE];
 212                 size_t syslen;
 213                 ssize_t len;
 214
 215                 if (dent->d_name[0] == '.')
 216                         continue;
 217                 util_strlcpy(filename, path, sizeof(filename));
 218                 util_strlcat(filename, "/", sizeof(filename));
 219                 util_strlcat(filename, dent->d_name, sizeof(filename));
 220
 221                 syslen = util_strlcpy(syspath, udev_get_sys_path(udev_queue->udev), sizeof(syspath));
 222                 len = readlink(filename, &syspath[syslen], sizeof(syspath)-syslen);
 223                 if (len < 0 || len >= (ssize_t)(sizeof(syspath)-syslen))
 224                         continue;
 225                 syspath[syslen + len] = '\0';
 226                 dbg(udev_queue->udev, "found '%s' [%s]\n", syspath, dent->d_name);
 227                 udev_list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, dent->d_name, 0, 0);
 228         }
 229         closedir(dir);
 230         return udev_list_get_entry(&udev_queue->queue_list);
 231 }
 232
 233 struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev_queue)
 234 {
 235         char path[UTIL_PATH_SIZE];
 236         DIR *dir;
 237         struct dirent *dent;
 238
 239         if (udev_queue == NULL)
 240                 return NULL;
 241         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->failed_list);
 242         util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
 243         util_strlcat(path, "/.udev/failed", sizeof(path));
 244         dir = opendir(path);
 245         if (dir == NULL)
 246                 return NULL;
 247         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 248                 char filename[UTIL_PATH_SIZE];
 249                 char syspath[UTIL_PATH_SIZE];
 250                 struct stat statbuf;
 251                 size_t syslen;
 252                 ssize_t len;
 253
 254                 if (dent->d_name[0] == '.')
 255                         continue;
 256                 util_strlcpy(filename, path, sizeof(filename));
 257                 util_strlcat(filename, "/", sizeof(filename));
 258                 util_strlcat(filename, dent->d_name, sizeof(filename));
 259
 260                 syslen = util_strlcpy(syspath, udev_get_sys_path(udev_queue->udev), sizeof(syspath));
 261                 len = readlink(filename, &syspath[syslen], sizeof(syspath)-syslen);
 262                 if (len < 0 || len >= (ssize_t)(sizeof(syspath)-syslen))
 263                         continue;
 264                 syspath[syslen + len] = '\0';
 265                 dbg(udev_queue->udev, "found '%s' [%s]\n", syspath, dent->d_name);
 266                 util_strlcpy(filename, syspath, sizeof(filename));
 267                 util_strlcat(filename, "/uevent", sizeof(filename));
 268                 if (stat(filename, &statbuf) != 0)
 269                         continue;
 270                 udev_list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0, 0);
 271         }
 272         closedir(dir);
 273         return udev_list_get_entry(&udev_queue->failed_list);
 274 }
 275
 276 int udev_queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum)
 277 {
 278         return -1;
 279 }
 280
 281 extern int udev_queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device)
 282 {
 283         return -1;
 284 }
 285
 286 extern int udev_queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device)
 287 {
 288         return -1;
 289 }
 290
 291 extern int udev_queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device)
 292 {
 293         return -1;
 294 }