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         /* did it reach the queue? */
 182         if (seqnum > udev_queue->last_seen_udev_seqnum)
 183                 if (seqnum > udev_queue_get_udev_seqnum(udev_queue))
 184                         return 0;
 185         /* is it still in the queue? */
 186         snprintf(filename, sizeof(filename), "%s/.udev/queue/%llu",
 187                  udev_get_dev_path(udev_queue->udev), seqnum);
 188         if (lstat(filename, &statbuf) == 0)
 189                 return 0;
 190         dbg(udev_queue->udev, "seqnum: %llu finished\n", seqnum);
 191         return 1;
 192 }
 193
 194 struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev_queue)
 195 {
 196         char path[UTIL_PATH_SIZE];
 197         DIR *dir;
 198         struct dirent *dent;
 199
 200         if (udev_queue == NULL)
 201                 return NULL;
 202         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->queue_list);
 203         util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
 204         util_strlcat(path, "/.udev/queue", sizeof(path));
 205         dir = opendir(path);
 206         if (dir == NULL)
 207                 return NULL;
 208         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 209                 char filename[UTIL_PATH_SIZE];
 210                 char syspath[UTIL_PATH_SIZE];
 211                 size_t syslen;
 212                 ssize_t len;
 213
 214                 if (dent->d_name[0] == '.')
 215                         continue;
 216                 util_strlcpy(filename, path, sizeof(filename));
 217                 util_strlcat(filename, "/", sizeof(filename));
 218                 util_strlcat(filename, dent->d_name, sizeof(filename));
 219
 220                 syslen = util_strlcpy(syspath, udev_get_sys_path(udev_queue->udev), sizeof(syspath));
 221                 len = readlink(filename, &syspath[syslen], sizeof(syspath)-syslen);
 222                 if (len < 0 || len >= (ssize_t)(sizeof(syspath)-syslen))
 223                         continue;
 224                 syspath[syslen + len] = '\0';
 225                 dbg(udev_queue->udev, "found '%s' [%s]\n", syspath, dent->d_name);
 226                 udev_list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, dent->d_name, 0, 0);
 227         }
 228         closedir(dir);
 229         return udev_list_get_entry(&udev_queue->queue_list);
 230 }
 231
 232 struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev_queue)
 233 {
 234         char path[UTIL_PATH_SIZE];
 235         DIR *dir;
 236         struct dirent *dent;
 237
 238         if (udev_queue == NULL)
 239                 return NULL;
 240         udev_list_cleanup_entries(udev_queue->udev, &udev_queue->failed_list);
 241         util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
 242         util_strlcat(path, "/.udev/failed", sizeof(path));
 243         dir = opendir(path);
 244         if (dir == NULL)
 245                 return NULL;
 246         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 247                 char filename[UTIL_PATH_SIZE];
 248                 char syspath[UTIL_PATH_SIZE];
 249                 struct stat statbuf;
 250                 size_t syslen;
 251                 ssize_t len;
 252
 253                 if (dent->d_name[0] == '.')
 254                         continue;
 255                 util_strlcpy(filename, path, sizeof(filename));
 256                 util_strlcat(filename, "/", sizeof(filename));
 257                 util_strlcat(filename, dent->d_name, sizeof(filename));
 258
 259                 syslen = util_strlcpy(syspath, udev_get_sys_path(udev_queue->udev), sizeof(syspath));
 260                 len = readlink(filename, &syspath[syslen], sizeof(syspath)-syslen);
 261                 if (len < 0 || len >= (ssize_t)(sizeof(syspath)-syslen))
 262                         continue;
 263                 syspath[syslen + len] = '\0';
 264                 dbg(udev_queue->udev, "found '%s' [%s]\n", syspath, dent->d_name);
 265                 util_strlcpy(filename, syspath, sizeof(filename));
 266                 util_strlcat(filename, "/uevent", sizeof(filename));
 267                 if (stat(filename, &statbuf) != 0)
 268                         continue;
 269                 udev_list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0, 0);
 270         }
 271         closedir(dir);
 272         return udev_list_get_entry(&udev_queue->failed_list);
 273 }
 274
 275 int udev_queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum)
 276 {
 277         return -1;
 278 }
 279
 280 extern int udev_queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device)
 281 {
 282         return -1;
 283 }
 284
 285 extern int udev_queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device)
 286 {
 287         return -1;
 288 }
 289
 290 extern int udev_queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device)
 291 {
 292         return -1;
 293 }