src/libudev-queue-private.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
   5  * Copyright (C) 2009 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  */
  12
  13 /*
  14  * DISCLAIMER - The file format mentioned here is private to udev/libudev,
  15  *              and may be changed without notice.
  16  *
  17  * The udev event queue is exported as a binary log file.
  18  * Each log record consists of a sequence number followed by the device path.
  19  *
  20  * When a new event is queued, its details are appended to the log.
  21  * When the event finishes, a second record is appended to the log
  22  * with the same sequence number but a devpath len of 0.
  23  *
  24  * Example:
  25  *        { 0x0000000000000001 }
  26  *        { 0x0000000000000001, 0x0019, "/devices/virtual/mem/null" },
  27  *        { 0x0000000000000002, 0x001b, "/devices/virtual/mem/random" },
  28  *        { 0x0000000000000001, 0x0000 },
  29  *        { 0x0000000000000003, 0x0019, "/devices/virtual/mem/zero" },
  30  *
  31  * Events 2 and 3 are still queued, but event 1 has finished.
  32  *
  33  * The queue does not grow indefinitely. It is periodically re-created
  34  * to remove finished events. Atomic rename() makes this transparent to readers.
  35  *
  36  * The queue file starts with a single sequence number which specifies the
  37  * minimum sequence number in the log that follows. Any events prior to this
  38  * sequence number have already finished.
  39  */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <fcntl.h>
  46 #include <dirent.h>
  47 #include <limits.h>
  48 #include <errno.h>
  49 #include <sys/stat.h>
  50 #include <sys/types.h>
  51
  52 #include "libudev.h"
  53 #include "libudev-private.h"
  54
  55 static int rebuild_queue_file(struct udev_queue_export *udev_queue_export);
  56
  57 struct udev_queue_export {
  58         struct udev *udev;
  59         int queued_count;        /* number of unfinished events exported in queue file */
  60         FILE *queue_file;
  61         unsigned long long int seqnum_max;        /* earliest sequence number in queue file */
  62         unsigned long long int seqnum_min;        /* latest sequence number in queue file */
  63         int waste_bytes;                        /* queue file bytes wasted on finished events */
  64 };
  65
  66 struct udev_queue_export *udev_queue_export_new(struct udev *udev)
  67 {
  68         struct udev_queue_export *udev_queue_export;
  69         unsigned long long int initial_seqnum;
  70
  71         if (udev == NULL)
  72                 return NULL;
  73
  74         udev_queue_export = calloc(1, sizeof(struct udev_queue_export));
  75         if (udev_queue_export == NULL)
  76                 return NULL;
  77         udev_queue_export->udev = udev;
  78
  79         initial_seqnum = udev_get_kernel_seqnum(udev);
  80         udev_queue_export->seqnum_min = initial_seqnum;
  81         udev_queue_export->seqnum_max = initial_seqnum;
  82
  83         udev_queue_export_cleanup(udev_queue_export);
  84         if (rebuild_queue_file(udev_queue_export) != 0) {
  85                 free(udev_queue_export);
  86                 return NULL;
  87         }
  88
  89         return udev_queue_export;
  90 }
  91
  92 struct udev_queue_export *udev_queue_export_unref(struct udev_queue_export *udev_queue_export)
  93 {
  94         if (udev_queue_export == NULL)
  95                 return NULL;
  96         if (udev_queue_export->queue_file != NULL)
  97                 fclose(udev_queue_export->queue_file);
  98         free(udev_queue_export);
  99         return NULL;
 100 }
 101
 102 void udev_queue_export_cleanup(struct udev_queue_export *udev_queue_export)
 103 {
 104         char filename[UTIL_PATH_SIZE];
 105
 106         if (udev_queue_export == NULL)
 107                 return;
 108         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.tmp", NULL);
 109         unlink(filename);
 110         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.bin", NULL);
 111         unlink(filename);
 112 }
 113
 114 static int skip_to(FILE *file, long offset)
 115 {
 116         long old_offset;
 117
 118         /* fseek may drop buffered data, avoid it for small seeks */
 119         old_offset = ftell(file);
 120         if (offset > old_offset && offset - old_offset <= BUFSIZ) {
 121                 size_t skip_bytes = offset - old_offset;
 122                 char buf[skip_bytes];
 123
 124                 if (fread(buf, skip_bytes, 1, file) != skip_bytes)
 125                         return -1;
 126         }
 127
 128         return fseek(file, offset, SEEK_SET);
 129 }
 130
 131 struct queue_devpaths {
 132         unsigned int devpaths_first;        /* index of first queued event */
 133         unsigned int devpaths_size;
 134         long devpaths[];                /* seqnum -> offset of devpath in queue file (or 0) */
 135 };
 136
 137 /*
 138  * Returns a table mapping seqnum to devpath file offset for currently queued events.
 139  * devpaths[i] represents the event with seqnum = i + udev_queue_export->seqnum_min.
 140  */
 141 static struct queue_devpaths *build_index(struct udev_queue_export *udev_queue_export)
 142 {
 143         struct queue_devpaths *devpaths;
 144         unsigned long long int range;
 145         long devpath_offset;
 146         ssize_t devpath_len;
 147         unsigned long long int seqnum;
 148         unsigned long long int n;
 149         unsigned int i;
 150
 151         /* seek to the first event in the file */
 152         rewind(udev_queue_export->queue_file);
 153         udev_queue_read_seqnum(udev_queue_export->queue_file, &seqnum);
 154
 155         /* allocate the table */
 156         range = udev_queue_export->seqnum_min - udev_queue_export->seqnum_max;
 157         if (range - 1 > INT_MAX) {
 158                 err(udev_queue_export->udev, "queue file overflow\n");
 159                 return NULL;
 160         }
 161         devpaths = calloc(1, sizeof(struct queue_devpaths) + (range + 1) * sizeof(long));
 162         if (devpaths == NULL)
 163                 return NULL;
 164         devpaths->devpaths_size = range + 1;
 165
 166         /* read all records and populate the table */
 167         for (;;) {
 168                 if (udev_queue_read_seqnum(udev_queue_export->queue_file, &seqnum) < 0)
 169                         break;
 170                 n = seqnum - udev_queue_export->seqnum_max;
 171                 if (n >= devpaths->devpaths_size)
 172                         goto read_error;
 173
 174                 devpath_offset = ftell(udev_queue_export->queue_file);
 175                 devpath_len = udev_queue_skip_devpath(udev_queue_export->queue_file);
 176                 if (devpath_len < 0)
 177                         goto read_error;
 178
 179                 if (devpath_len > 0)
 180                         devpaths->devpaths[n] = devpath_offset;
 181                 else
 182                         devpaths->devpaths[n] = 0;
 183         }
 184
 185         /* find first queued event */
 186         for (i = 0; i < devpaths->devpaths_size; i++) {
 187                 if (devpaths->devpaths[i] != 0)
 188                         break;
 189         }
 190         devpaths->devpaths_first = i;
 191
 192         return devpaths;
 193
 194 read_error:
 195         err(udev_queue_export->udev, "queue file corrupted\n");
 196         free(devpaths);
 197         return NULL;
 198 }
 199
 200 static int rebuild_queue_file(struct udev_queue_export *udev_queue_export)
 201 {
 202         unsigned long long int seqnum;
 203         struct queue_devpaths *devpaths = NULL;
 204         char filename[UTIL_PATH_SIZE];
 205         char filename_tmp[UTIL_PATH_SIZE];
 206         FILE *new_queue_file = NULL;
 207         unsigned int i;
 208
 209         /* read old queue file */
 210         if (udev_queue_export->queue_file != NULL) {
 211                 dbg(udev_queue_export->udev, "compacting queue file, freeing %d bytes\n",
 212                                                 udev_queue_export->waste_bytes);
 213
 214                 devpaths = build_index(udev_queue_export);
 215                 if (devpaths != NULL)
 216                         udev_queue_export->seqnum_max += devpaths->devpaths_first;
 217         }
 218         if (devpaths == NULL) {
 219                 dbg(udev_queue_export->udev, "creating empty queue file\n");
 220                 udev_queue_export->queued_count = 0;
 221                 udev_queue_export->seqnum_max = udev_queue_export->seqnum_min;
 222         }
 223
 224         /* create new queue file */
 225         util_strscpyl(filename_tmp, sizeof(filename_tmp), udev_get_run_path(udev_queue_export->udev), "/queue.tmp", NULL);
 226         new_queue_file = fopen(filename_tmp, "w+");
 227         if (new_queue_file == NULL)
 228                 goto error;
 229         seqnum = udev_queue_export->seqnum_max;
 230         fwrite(&seqnum, 1, sizeof(unsigned long long int), new_queue_file);
 231
 232         /* copy unfinished events only to the new file */
 233         if (devpaths != NULL) {
 234                 for (i = devpaths->devpaths_first; i < devpaths->devpaths_size; i++) {
 235                         char devpath[UTIL_PATH_SIZE];
 236                         int err;
 237                         unsigned short devpath_len;
 238
 239                         if (devpaths->devpaths[i] != 0)
 240                         {
 241                                 skip_to(udev_queue_export->queue_file, devpaths->devpaths[i]);
 242                                 err = udev_queue_read_devpath(udev_queue_export->queue_file, devpath, sizeof(devpath));
 243                                 devpath_len = err;
 244
 245                                 fwrite(&seqnum, sizeof(unsigned long long int), 1, new_queue_file);
 246                                 fwrite(&devpath_len, sizeof(unsigned short), 1, new_queue_file);
 247                                 fwrite(devpath, 1, devpath_len, new_queue_file);
 248                         }
 249                         seqnum++;
 250                 }
 251                 free(devpaths);
 252                 devpaths = NULL;
 253         }
 254         fflush(new_queue_file);
 255         if (ferror(new_queue_file))
 256                 goto error;
 257
 258         /* rename the new file on top of the old one */
 259         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.bin", NULL);
 260         if (rename(filename_tmp, filename) != 0)
 261                 goto error;
 262
 263         if (udev_queue_export->queue_file != NULL)
 264                 fclose(udev_queue_export->queue_file);
 265         udev_queue_export->queue_file = new_queue_file;
 266         udev_queue_export->waste_bytes = 0;
 267
 268         return 0;
 269
 270 error:
 271         err(udev_queue_export->udev, "failed to create queue file: %m\n");
 272         udev_queue_export_cleanup(udev_queue_export);
 273
 274         if (udev_queue_export->queue_file != NULL) {
 275                 fclose(udev_queue_export->queue_file);
 276                 udev_queue_export->queue_file = NULL;
 277         }
 278         if (new_queue_file != NULL)
 279                 fclose(new_queue_file);
 280
 281         if (devpaths != NULL)
 282                 free(devpaths);
 283         udev_queue_export->queued_count = 0;
 284         udev_queue_export->waste_bytes = 0;
 285         udev_queue_export->seqnum_max = udev_queue_export->seqnum_min;
 286
 287         return -1;
 288 }
 289
 290 static int write_queue_record(struct udev_queue_export *udev_queue_export,
 291                               unsigned long long int seqnum, const char *devpath, size_t devpath_len)
 292 {
 293         unsigned short len;
 294
 295         if (udev_queue_export->queue_file == NULL) {
 296                 dbg(udev_queue_export->udev, "can't record event: queue file not available\n");
 297                 return -1;
 298         }
 299
 300         if (fwrite(&seqnum, sizeof(unsigned long long int), 1, udev_queue_export->queue_file) != 1)
 301                 goto write_error;
 302
 303         len = (devpath_len < USHRT_MAX) ? devpath_len : USHRT_MAX;
 304         if (fwrite(&len, sizeof(unsigned short), 1, udev_queue_export->queue_file) != 1)
 305                 goto write_error;
 306         if (len > 0) {
 307                 if (fwrite(devpath, 1, len, udev_queue_export->queue_file) != len)
 308                         goto write_error;
 309         }
 310
 311         /* *must* flush output; caller may fork */
 312         if (fflush(udev_queue_export->queue_file) != 0)
 313                 goto write_error;
 314
 315         return 0;
 316
 317 write_error:
 318         /* if we failed half way through writing a record to a file,
 319            we should not try to write any further records to it. */
 320         err(udev_queue_export->udev, "error writing to queue file: %m\n");
 321         fclose(udev_queue_export->queue_file);
 322         udev_queue_export->queue_file = NULL;
 323
 324         return -1;
 325 }
 326
 327 enum device_state {
 328         DEVICE_QUEUED,
 329         DEVICE_FINISHED,
 330 };
 331
 332 static inline size_t queue_record_size(size_t devpath_len)
 333 {
 334         return sizeof(unsigned long long int) + sizeof(unsigned short int) + devpath_len;
 335 }
 336
 337 static int update_queue(struct udev_queue_export *udev_queue_export,
 338                          struct udev_device *udev_device, enum device_state state)
 339 {
 340         unsigned long long int seqnum = udev_device_get_seqnum(udev_device);
 341         const char *devpath = NULL;
 342         size_t devpath_len = 0;
 343         int bytes;
 344         int err;
 345
 346         /* FINISHED records have a zero length devpath */
 347         if (state == DEVICE_QUEUED) {
 348                 devpath = udev_device_get_devpath(udev_device);
 349                 devpath_len = strlen(devpath);
 350         }
 351
 352         /* recover from an earlier failed rebuild */
 353         if (udev_queue_export->queue_file == NULL) {
 354                 if (rebuild_queue_file(udev_queue_export) != 0)
 355                         return -1;
 356         }
 357
 358         /* if we're removing the last event from the queue, that's the best time to rebuild it */
 359         if (state != DEVICE_QUEUED && udev_queue_export->queued_count == 1) {
 360                 /* we don't need to read the old queue file */
 361                 fclose(udev_queue_export->queue_file);
 362                 udev_queue_export->queue_file = NULL;
 363                 rebuild_queue_file(udev_queue_export);
 364                 return 0;
 365         }
 366
 367         /* try to rebuild the queue files before they grow larger than one page. */
 368         bytes = ftell(udev_queue_export->queue_file) + queue_record_size(devpath_len);
 369         if ((udev_queue_export->waste_bytes > bytes / 2) && bytes > 4096)
 370                 rebuild_queue_file(udev_queue_export);
 371
 372         /* don't record a finished event, if we already dropped the event in a failed rebuild */
 373         if (seqnum < udev_queue_export->seqnum_max)
 374                 return 0;
 375
 376         /* now write to the queue */
 377         if (state == DEVICE_QUEUED) {
 378                 udev_queue_export->queued_count++;
 379                 udev_queue_export->seqnum_min = seqnum;
 380         } else {
 381                 udev_queue_export->waste_bytes += queue_record_size(devpath_len) + queue_record_size(0);
 382                 udev_queue_export->queued_count--;
 383         }
 384         err = write_queue_record(udev_queue_export, seqnum, devpath, devpath_len);
 385
 386         /* try to handle ENOSPC */
 387         if (err != 0 && udev_queue_export->queued_count == 0) {
 388                 udev_queue_export_cleanup(udev_queue_export);
 389                 err = rebuild_queue_file(udev_queue_export);
 390         }
 391
 392         return err;
 393 }
 394
 395 static int update(struct udev_queue_export *udev_queue_export,
 396                   struct udev_device *udev_device, enum device_state state)
 397 {
 398         if (update_queue(udev_queue_export, udev_device, state) != 0)
 399                 return -1;
 400
 401         return 0;
 402 }
 403
 404 int udev_queue_export_device_queued(struct udev_queue_export *udev_queue_export, struct udev_device *udev_device)
 405 {
 406         return update(udev_queue_export, udev_device, DEVICE_QUEUED);
 407 }
 408
 409 int udev_queue_export_device_finished(struct udev_queue_export *udev_queue_export, struct udev_device *udev_device)
 410 {
 411         return update(udev_queue_export, udev_device, DEVICE_FINISHED);
 412 }