libudev/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 failed_count;       /* number of failed events exported */
  60         int queued_count;       /* number of unfinished events exported in queue file */
  61         FILE *queue_file;
  62         unsigned long long int seqnum_max;      /* earliest sequence number in queue file */
  63         unsigned long long int seqnum_min;      /* latest sequence number in queue file */
  64         int waste_bytes;                        /* queue file bytes wasted on finished events */
  65 };
  66
  67 struct udev_queue_export *udev_queue_export_new(struct udev *udev)
  68 {
  69         struct udev_queue_export *udev_queue_export;
  70         unsigned long long int initial_seqnum;
  71
  72         if (udev == NULL)
  73                 return NULL;
  74
  75         udev_queue_export = calloc(1, sizeof(struct udev_queue_export));
  76         if (udev_queue_export == NULL)
  77                 return NULL;
  78         udev_queue_export->udev = udev;
  79
  80         initial_seqnum = udev_get_kernel_seqnum(udev);
  81         udev_queue_export->seqnum_min = initial_seqnum;
  82         udev_queue_export->seqnum_max = initial_seqnum;
  83
  84         udev_queue_export_cleanup(udev_queue_export);
  85         if (rebuild_queue_file(udev_queue_export) != 0) {
  86                 free(udev_queue_export);
  87                 return NULL;
  88         }
  89
  90         return udev_queue_export;
  91 }
  92
  93 struct udev_queue_export *udev_queue_export_unref(struct udev_queue_export *udev_queue_export)
  94 {
  95         if (udev_queue_export == NULL)
  96                 return NULL;
  97         if (udev_queue_export->queue_file != NULL)
  98                 fclose(udev_queue_export->queue_file);
  99         free(udev_queue_export);
 100         return NULL;
 101 }
 102
 103 void udev_queue_export_cleanup(struct udev_queue_export *udev_queue_export)
 104 {
 105         char filename[UTIL_PATH_SIZE];
 106
 107         if (udev_queue_export == NULL)
 108                 return;
 109         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.tmp", NULL);
 110         unlink(filename);
 111         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.bin", NULL);
 112         unlink(filename);
 113 }
 114
 115 static int skip_to(FILE *file, long offset)
 116 {
 117         long old_offset;
 118
 119         /* fseek may drop buffered data, avoid it for small seeks */
 120         old_offset = ftell(file);
 121         if (offset > old_offset && offset - old_offset <= BUFSIZ) {
 122                 size_t skip_bytes = offset - old_offset;
 123                 char buf[skip_bytes];
 124
 125                 if (fread(buf, skip_bytes, 1, file) != skip_bytes)
 126                         return -1;
 127         }
 128
 129         return fseek(file, offset, SEEK_SET);
 130 }
 131
 132 struct queue_devpaths {
 133         unsigned int devpaths_first;    /* index of first queued event */
 134         unsigned int devpaths_size;
 135         long devpaths[];                /* seqnum -> offset of devpath in queue file (or 0) */
 136 };
 137
 138 /*
 139  * Returns a table mapping seqnum to devpath file offset for currently queued events.
 140  * devpaths[i] represents the event with seqnum = i + udev_queue_export->seqnum_min.
 141  */
 142 static struct queue_devpaths *build_index(struct udev_queue_export *udev_queue_export)
 143 {
 144         struct queue_devpaths *devpaths;
 145         unsigned long long int range;
 146         long devpath_offset;
 147         ssize_t devpath_len;
 148         unsigned long long int seqnum;
 149         unsigned long long int n;
 150         unsigned int i;
 151
 152         /* seek to the first event in the file */
 153         rewind(udev_queue_export->queue_file);
 154         udev_queue_read_seqnum(udev_queue_export->queue_file, &seqnum);
 155
 156         /* allocate the table */
 157         range = udev_queue_export->seqnum_min - udev_queue_export->seqnum_max;
 158         if (range - 1 > INT_MAX) {
 159                 err(udev_queue_export->udev, "queue file overflow\n");
 160                 return NULL;
 161         }
 162         devpaths = calloc(1, sizeof(struct queue_devpaths) + (range + 1) * sizeof(long));
 163         if (devpaths == NULL)
 164                 return NULL;
 165         devpaths->devpaths_size = range + 1;
 166
 167         /* read all records and populate the table */
 168         for (;;) {
 169                 if (udev_queue_read_seqnum(udev_queue_export->queue_file, &seqnum) < 0)
 170                         break;
 171                 n = seqnum - udev_queue_export->seqnum_max;
 172                 if (n >= devpaths->devpaths_size)
 173                         goto read_error;
 174
 175                 devpath_offset = ftell(udev_queue_export->queue_file);
 176                 devpath_len = udev_queue_skip_devpath(udev_queue_export->queue_file);
 177                 if (devpath_len < 0)
 178                         goto read_error;
 179
 180                 if (devpath_len > 0)
 181                         devpaths->devpaths[n] = devpath_offset;
 182                 else
 183                         devpaths->devpaths[n] = 0;
 184         }
 185
 186         /* find first queued event */
 187         for (i = 0; i < devpaths->devpaths_size; i++) {
 188                 if (devpaths->devpaths[i] != 0)
 189                         break;
 190         }
 191         devpaths->devpaths_first = i;
 192
 193         return devpaths;
 194
 195 read_error:
 196         err(udev_queue_export->udev, "queue file corrupted\n");
 197         free(devpaths);
 198         return NULL;
 199 }
 200
 201 static int rebuild_queue_file(struct udev_queue_export *udev_queue_export)
 202 {
 203         unsigned long long int seqnum;
 204         struct queue_devpaths *devpaths = NULL;
 205         char filename[UTIL_PATH_SIZE];
 206         char filename_tmp[UTIL_PATH_SIZE];
 207         FILE *new_queue_file = NULL;
 208         unsigned int i;
 209
 210         /* read old queue file */
 211         if (udev_queue_export->queue_file != NULL) {
 212                 dbg(udev_queue_export->udev, "compacting queue file, freeing %d bytes\n",
 213                                                 udev_queue_export->waste_bytes);
 214
 215                 devpaths = build_index(udev_queue_export);
 216                 if (devpaths != NULL)
 217                         udev_queue_export->seqnum_max += devpaths->devpaths_first;
 218         }
 219         if (devpaths == NULL) {
 220                 dbg(udev_queue_export->udev, "creating empty queue file\n");
 221                 udev_queue_export->queued_count = 0;
 222                 udev_queue_export->seqnum_max = udev_queue_export->seqnum_min;
 223         }
 224
 225         /* create new queue file */
 226         util_strscpyl(filename_tmp, sizeof(filename_tmp), udev_get_run_path(udev_queue_export->udev), "/queue.tmp", NULL);
 227         new_queue_file = fopen(filename_tmp, "w+");
 228         if (new_queue_file == NULL)
 229                 goto error;
 230         seqnum = udev_queue_export->seqnum_max;
 231         fwrite(&seqnum, 1, sizeof(unsigned long long int), new_queue_file);
 232
 233         /* copy unfinished events only to the new file */
 234         if (devpaths != NULL) {
 235                 for (i = devpaths->devpaths_first; i < devpaths->devpaths_size; i++) {
 236                         char devpath[UTIL_PATH_SIZE];
 237                         int err;
 238                         unsigned short devpath_len;
 239
 240                         if (devpaths->devpaths[i] != 0)
 241                         {
 242                                 skip_to(udev_queue_export->queue_file, devpaths->devpaths[i]);
 243                                 err = udev_queue_read_devpath(udev_queue_export->queue_file, devpath, sizeof(devpath));
 244                                 devpath_len = err;
 245
 246                                 fwrite(&seqnum, sizeof(unsigned long long int), 1, new_queue_file);
 247                                 fwrite(&devpath_len, sizeof(unsigned short), 1, new_queue_file);
 248                                 fwrite(devpath, 1, devpath_len, new_queue_file);
 249                         }
 250                         seqnum++;
 251                 }
 252                 free(devpaths);
 253                 devpaths = NULL;
 254         }
 255         fflush(new_queue_file);
 256         if (ferror(new_queue_file))
 257                 goto error;
 258
 259         /* rename the new file on top of the old one */
 260         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_queue_export->udev), "/queue.bin", NULL);
 261         if (rename(filename_tmp, filename) != 0)
 262                 goto error;
 263
 264         if (udev_queue_export->queue_file != NULL)
 265                 fclose(udev_queue_export->queue_file);
 266         udev_queue_export->queue_file = new_queue_file;
 267         udev_queue_export->waste_bytes = 0;
 268
 269         return 0;
 270
 271 error:
 272         err(udev_queue_export->udev, "failed to create queue file: %m\n");
 273         udev_queue_export_cleanup(udev_queue_export);
 274
 275         if (udev_queue_export->queue_file != NULL) {
 276                 fclose(udev_queue_export->queue_file);
 277                 udev_queue_export->queue_file = NULL;
 278         }
 279         if (new_queue_file != NULL)
 280                 fclose(new_queue_file);
 281
 282         if (devpaths != NULL)
 283                 free(devpaths);
 284         udev_queue_export->queued_count = 0;
 285         udev_queue_export->waste_bytes = 0;
 286         udev_queue_export->seqnum_max = udev_queue_export->seqnum_min;
 287
 288         return -1;
 289 }
 290
 291 static int write_queue_record(struct udev_queue_export *udev_queue_export,
 292                               unsigned long long int seqnum, const char *devpath, size_t devpath_len)
 293 {
 294         unsigned short len;
 295
 296         if (udev_queue_export->queue_file == NULL) {
 297                 dbg(udev_queue_export->udev, "can't record event: queue file not available\n");
 298                 return -1;
 299         }
 300
 301         if (fwrite(&seqnum, sizeof(unsigned long long int), 1, udev_queue_export->queue_file) != 1)
 302                 goto write_error;
 303
 304         len = (devpath_len < USHRT_MAX) ? devpath_len : USHRT_MAX;
 305         if (fwrite(&len, sizeof(unsigned short), 1, udev_queue_export->queue_file) != 1)
 306                 goto write_error;
 307         if (len > 0) {
 308                 if (fwrite(devpath, 1, len, udev_queue_export->queue_file) != len)
 309                         goto write_error;
 310         }
 311
 312         /* *must* flush output; caller may fork */
 313         if (fflush(udev_queue_export->queue_file) != 0)
 314                 goto write_error;
 315
 316         return 0;
 317
 318 write_error:
 319         /* if we failed half way through writing a record to a file,
 320            we should not try to write any further records to it. */
 321         err(udev_queue_export->udev, "error writing to queue file: %m\n");
 322         fclose(udev_queue_export->queue_file);
 323         udev_queue_export->queue_file = NULL;
 324
 325         return -1;
 326 }
 327
 328 enum device_state {
 329         DEVICE_QUEUED,
 330         DEVICE_FINISHED,
 331         DEVICE_FAILED,
 332 };
 333
 334 static inline size_t queue_record_size(size_t devpath_len)
 335 {
 336         return sizeof(unsigned long long int) + sizeof(unsigned short int) + devpath_len;
 337 }
 338
 339 static int update_queue(struct udev_queue_export *udev_queue_export,
 340                          struct udev_device *udev_device, enum device_state state)
 341 {
 342         unsigned long long int seqnum = udev_device_get_seqnum(udev_device);
 343         const char *devpath = NULL;
 344         size_t devpath_len = 0;
 345         int bytes;
 346         int err;
 347
 348         /* FINISHED records have a zero length devpath */
 349         if (state == DEVICE_QUEUED) {
 350                 devpath = udev_device_get_devpath(udev_device);
 351                 devpath_len = strlen(devpath);
 352         }
 353
 354         /* recover from an earlier failed rebuild */
 355         if (udev_queue_export->queue_file == NULL) {
 356                 if (rebuild_queue_file(udev_queue_export) != 0)
 357                         return -1;
 358         }
 359
 360         /* if we're removing the last event from the queue, that's the best time to rebuild it */
 361         if (state != DEVICE_QUEUED && udev_queue_export->queued_count == 1) {
 362                 /* we don't need to read the old queue file */
 363                 fclose(udev_queue_export->queue_file);
 364                 udev_queue_export->queue_file = NULL;
 365                 rebuild_queue_file(udev_queue_export);
 366                 return 0;
 367         }
 368
 369         /* try to rebuild the queue files before they grow larger than one page. */
 370         bytes = ftell(udev_queue_export->queue_file) + queue_record_size(devpath_len);
 371         if ((udev_queue_export->waste_bytes > bytes / 2) && bytes > 4096)
 372                 rebuild_queue_file(udev_queue_export);
 373
 374         /* don't record a finished event, if we already dropped the event in a failed rebuild */
 375         if (seqnum < udev_queue_export->seqnum_max)
 376                 return 0;
 377
 378         /* now write to the queue */
 379         if (state == DEVICE_QUEUED) {
 380                 udev_queue_export->queued_count++;
 381                 udev_queue_export->seqnum_min = seqnum;
 382         } else {
 383                 udev_queue_export->waste_bytes += queue_record_size(devpath_len) + queue_record_size(0);
 384                 udev_queue_export->queued_count--;
 385         }
 386         err = write_queue_record(udev_queue_export, seqnum, devpath, devpath_len);
 387
 388         /* try to handle ENOSPC */
 389         if (err != 0 && udev_queue_export->queued_count == 0) {
 390                 udev_queue_export_cleanup(udev_queue_export);
 391                 err = rebuild_queue_file(udev_queue_export);
 392         }
 393
 394         return err;
 395 }
 396
 397 static void update_failed(struct udev_queue_export *udev_queue_export,
 398                           struct udev_device *udev_device, enum device_state state)
 399 {
 400         struct udev *udev = udev_device_get_udev(udev_device);
 401         char filename[UTIL_PATH_SIZE];
 402
 403         if (state != DEVICE_FAILED && udev_queue_export->failed_count == 0)
 404                 return;
 405
 406         /* location of failed file */
 407         util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev), "/failed/",
 408                       udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);
 409
 410         switch (state) {
 411         case DEVICE_FAILED:
 412                 /* record event in the failed directory */
 413                 udev_queue_export->failed_count++;
 414                 util_create_path(udev, filename);
 415                 symlink(udev_device_get_devpath(udev_device), filename);
 416                 break;
 417
 418         case DEVICE_QUEUED:
 419                 /* delete failed file */
 420                 if (unlink(filename) == 0) {
 421                         util_delete_path(udev, filename);
 422                         udev_queue_export->failed_count--;
 423                 }
 424                 break;
 425
 426         case DEVICE_FINISHED:
 427                 break;
 428         }
 429
 430         return;
 431 }
 432
 433 static int update(struct udev_queue_export *udev_queue_export,
 434                   struct udev_device *udev_device, enum device_state state)
 435 {
 436         update_failed(udev_queue_export, udev_device, state);
 437
 438         if (update_queue(udev_queue_export, udev_device, state) != 0)
 439                 return -1;
 440
 441         return 0;
 442 }
 443
 444 int udev_queue_export_device_queued(struct udev_queue_export *udev_queue_export, struct udev_device *udev_device)
 445 {
 446         return update(udev_queue_export, udev_device, DEVICE_QUEUED);
 447 }
 448
 449 int udev_queue_export_device_finished(struct udev_queue_export *udev_queue_export, struct udev_device *udev_device)
 450 {
 451         return update(udev_queue_export, udev_device, DEVICE_FINISHED);
 452 }
 453
 454 int udev_queue_export_device_failed(struct udev_queue_export *udev_queue_export, struct udev_device *udev_device)
 455 {
 456         return update(udev_queue_export, udev_device, DEVICE_FAILED);
 457 }