src/hwdb/hwdb.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2012 Kay Sievers <kay@vrfy.org>
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <ctype.h>
  21 #include <getopt.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "alloc-util.h"
  26 #include "conf-files.h"
  27 #include "fd-util.h"
  28 #include "fileio.h"
  29 #include "fs-util.h"
  30 #include "hwdb-internal.h"
  31 #include "hwdb-util.h"
  32 #include "label.h"
  33 #include "mkdir.h"
  34 #include "selinux-util.h"
  35 #include "strbuf.h"
  36 #include "string-util.h"
  37 #include "strv.h"
  38 #include "util.h"
  39 #include "verbs.h"
  40
  41 /*
  42  * Generic udev properties, key/value database based on modalias strings.
  43  * Uses a Patricia/radix trie to index all matches for efficient lookup.
  44  */
  45
  46 static const char *arg_hwdb_bin_dir = "/etc/udev";
  47 static const char *arg_root = "";
  48
  49 static const char * const conf_file_dirs[] = {
  50         "/etc/udev/hwdb.d",
  51         UDEVLIBEXECDIR "/hwdb.d",
  52         NULL
  53 };
  54
  55 /* in-memory trie objects */
  56 struct trie {
  57         struct trie_node *root;
  58         struct strbuf *strings;
  59
  60         size_t nodes_count;
  61         size_t children_count;
  62         size_t values_count;
  63 };
  64
  65 struct trie_node {
  66         /* prefix, common part for all children of this node */
  67         size_t prefix_off;
  68
  69         /* sorted array of pointers to children nodes */
  70         struct trie_child_entry *children;
  71         uint8_t children_count;
  72
  73         /* sorted array of key/value pairs */
  74         struct trie_value_entry *values;
  75         size_t values_count;
  76 };
  77
  78 /* children array item with char (0-255) index */
  79 struct trie_child_entry {
  80         uint8_t c;
  81         struct trie_node *child;
  82 };
  83
  84 /* value array item with key/value pairs */
  85 struct trie_value_entry {
  86         size_t key_off;
  87         size_t value_off;
  88 };
  89
  90 static int trie_children_cmp(const void *v1, const void *v2) {
  91         const struct trie_child_entry *n1 = v1;
  92         const struct trie_child_entry *n2 = v2;
  93
  94         return n1->c - n2->c;
  95 }
  96
  97 static int node_add_child(struct trie *trie, struct trie_node *node, struct trie_node *node_child, uint8_t c) {
  98         struct trie_child_entry *child;
  99
 100         /* extend array, add new entry, sort for bisection */
 101         child = realloc(node->children, (node->children_count + 1) * sizeof(struct trie_child_entry));
 102         if (!child)
 103                 return -ENOMEM;
 104
 105         node->children = child;
 106         trie->children_count++;
 107         node->children[node->children_count].c = c;
 108         node->children[node->children_count].child = node_child;
 109         node->children_count++;
 110         qsort(node->children, node->children_count, sizeof(struct trie_child_entry), trie_children_cmp);
 111         trie->nodes_count++;
 112
 113         return 0;
 114 }
 115
 116 static struct trie_node *node_lookup(const struct trie_node *node, uint8_t c) {
 117         struct trie_child_entry *child;
 118         struct trie_child_entry search;
 119
 120         search.c = c;
 121         child = bsearch(&search, node->children, node->children_count, sizeof(struct trie_child_entry), trie_children_cmp);
 122         if (child)
 123                 return child->child;
 124         return NULL;
 125 }
 126
 127 static void trie_node_cleanup(struct trie_node *node) {
 128         size_t i;
 129
 130         for (i = 0; i < node->children_count; i++)
 131                 trie_node_cleanup(node->children[i].child);
 132         free(node->children);
 133         free(node->values);
 134         free(node);
 135 }
 136
 137 static void trie_free(struct trie *trie) {
 138         if (!trie)
 139                 return;
 140
 141         if (trie->root)
 142                 trie_node_cleanup(trie->root);
 143
 144         strbuf_cleanup(trie->strings);
 145         free(trie);
 146 }
 147
 148 DEFINE_TRIVIAL_CLEANUP_FUNC(struct trie*, trie_free);
 149
 150 static int trie_values_cmp(const void *v1, const void *v2, void *arg) {
 151         const struct trie_value_entry *val1 = v1;
 152         const struct trie_value_entry *val2 = v2;
 153         struct trie *trie = arg;
 154
 155         return strcmp(trie->strings->buf + val1->key_off,
 156                       trie->strings->buf + val2->key_off);
 157 }
 158
 159 static int trie_node_add_value(struct trie *trie, struct trie_node *node,
 160                           const char *key, const char *value) {
 161         ssize_t k, v;
 162         struct trie_value_entry *val;
 163
 164         k = strbuf_add_string(trie->strings, key, strlen(key));
 165         if (k < 0)
 166                 return k;
 167         v = strbuf_add_string(trie->strings, value, strlen(value));
 168         if (v < 0)
 169                 return v;
 170
 171         if (node->values_count) {
 172                 struct trie_value_entry search = {
 173                         .key_off = k,
 174                         .value_off = v,
 175                 };
 176
 177                 val = xbsearch_r(&search, node->values, node->values_count, sizeof(struct trie_value_entry), trie_values_cmp, trie);
 178                 if (val) {
 179                         /* replace existing earlier key with new value */
 180                         val->value_off = v;
 181                         return 0;
 182                 }
 183         }
 184
 185         /* extend array, add new entry, sort for bisection */
 186         val = realloc(node->values, (node->values_count + 1) * sizeof(struct trie_value_entry));
 187         if (!val)
 188                 return -ENOMEM;
 189         trie->values_count++;
 190         node->values = val;
 191         node->values[node->values_count].key_off = k;
 192         node->values[node->values_count].value_off = v;
 193         node->values_count++;
 194         qsort_r(node->values, node->values_count, sizeof(struct trie_value_entry), trie_values_cmp, trie);
 195         return 0;
 196 }
 197
 198 static int trie_insert(struct trie *trie, struct trie_node *node, const char *search,
 199                        const char *key, const char *value) {
 200         size_t i = 0;
 201         int err = 0;
 202
 203         for (;;) {
 204                 size_t p;
 205                 uint8_t c;
 206                 struct trie_node *child;
 207
 208                 for (p = 0; (c = trie->strings->buf[node->prefix_off + p]); p++) {
 209                         _cleanup_free_ char *s = NULL;
 210                         ssize_t off;
 211                         _cleanup_free_ struct trie_node *new_child = NULL;
 212
 213                         if (c == search[i + p])
 214                                 continue;
 215
 216                         /* split node */
 217                         new_child = new0(struct trie_node, 1);
 218                         if (!new_child)
 219                                 return -ENOMEM;
 220
 221                         /* move values from parent to child */
 222                         new_child->prefix_off = node->prefix_off + p+1;
 223                         new_child->children = node->children;
 224                         new_child->children_count = node->children_count;
 225                         new_child->values = node->values;
 226                         new_child->values_count = node->values_count;
 227
 228                         /* update parent; use strdup() because the source gets realloc()d */
 229                         s = strndup(trie->strings->buf + node->prefix_off, p);
 230                         if (!s)
 231                                 return -ENOMEM;
 232
 233                         off = strbuf_add_string(trie->strings, s, p);
 234                         if (off < 0)
 235                                 return off;
 236
 237                         node->prefix_off = off;
 238                         node->children = NULL;
 239                         node->children_count = 0;
 240                         node->values = NULL;
 241                         node->values_count = 0;
 242                         err = node_add_child(trie, node, new_child, c);
 243                         if (err < 0)
 244                                 return err;
 245
 246                         new_child = NULL; /* avoid cleanup */
 247                         break;
 248                 }
 249                 i += p;
 250
 251                 c = search[i];
 252                 if (c == '\0')
 253                         return trie_node_add_value(trie, node, key, value);
 254
 255                 child = node_lookup(node, c);
 256                 if (!child) {
 257                         ssize_t off;
 258
 259                         /* new child */
 260                         child = new0(struct trie_node, 1);
 261                         if (!child)
 262                                 return -ENOMEM;
 263
 264                         off = strbuf_add_string(trie->strings, search + i+1, strlen(search + i+1));
 265                         if (off < 0) {
 266                                 free(child);
 267                                 return off;
 268                         }
 269
 270                         child->prefix_off = off;
 271                         err = node_add_child(trie, node, child, c);
 272                         if (err < 0) {
 273                                 free(child);
 274                                 return err;
 275                         }
 276
 277                         return trie_node_add_value(trie, child, key, value);
 278                 }
 279
 280                 node = child;
 281                 i++;
 282         }
 283 }
 284
 285 struct trie_f {
 286         FILE *f;
 287         struct trie *trie;
 288         uint64_t strings_off;
 289
 290         uint64_t nodes_count;
 291         uint64_t children_count;
 292         uint64_t values_count;
 293 };
 294
 295 /* calculate the storage space for the nodes, children arrays, value arrays */
 296 static void trie_store_nodes_size(struct trie_f *trie, struct trie_node *node) {
 297         uint64_t i;
 298
 299         for (i = 0; i < node->children_count; i++)
 300                 trie_store_nodes_size(trie, node->children[i].child);
 301
 302         trie->strings_off += sizeof(struct trie_node_f);
 303         for (i = 0; i < node->children_count; i++)
 304                 trie->strings_off += sizeof(struct trie_child_entry_f);
 305         for (i = 0; i < node->values_count; i++)
 306                 trie->strings_off += sizeof(struct trie_value_entry_f);
 307 }
 308
 309 static int64_t trie_store_nodes(struct trie_f *trie, struct trie_node *node) {
 310         uint64_t i;
 311         struct trie_node_f n = {
 312                 .prefix_off = htole64(trie->strings_off + node->prefix_off),
 313                 .children_count = node->children_count,
 314                 .values_count = htole64(node->values_count),
 315         };
 316         struct trie_child_entry_f *children = NULL;
 317         int64_t node_off;
 318
 319         if (node->children_count) {
 320                 children = new0(struct trie_child_entry_f, node->children_count);
 321                 if (!children)
 322                         return -ENOMEM;
 323         }
 324
 325         /* post-order recursion */
 326         for (i = 0; i < node->children_count; i++) {
 327                 int64_t child_off;
 328
 329                 child_off = trie_store_nodes(trie, node->children[i].child);
 330                 if (child_off < 0) {
 331                         free(children);
 332                         return child_off;
 333                 }
 334                 children[i].c = node->children[i].c;
 335                 children[i].child_off = htole64(child_off);
 336         }
 337
 338         /* write node */
 339         node_off = ftello(trie->f);
 340         fwrite(&n, sizeof(struct trie_node_f), 1, trie->f);
 341         trie->nodes_count++;
 342
 343         /* append children array */
 344         if (node->children_count) {
 345                 fwrite(children, sizeof(struct trie_child_entry_f), node->children_count, trie->f);
 346                 trie->children_count += node->children_count;
 347                 free(children);
 348         }
 349
 350         /* append values array */
 351         for (i = 0; i < node->values_count; i++) {
 352                 struct trie_value_entry_f v = {
 353                         .key_off = htole64(trie->strings_off + node->values[i].key_off),
 354                         .value_off = htole64(trie->strings_off + node->values[i].value_off),
 355                 };
 356
 357                 fwrite(&v, sizeof(struct trie_value_entry_f), 1, trie->f);
 358                 trie->values_count++;
 359         }
 360
 361         return node_off;
 362 }
 363
 364 static int trie_store(struct trie *trie, const char *filename) {
 365         struct trie_f t = {
 366                 .trie = trie,
 367         };
 368         _cleanup_free_ char *filename_tmp = NULL;
 369         int64_t pos;
 370         int64_t root_off;
 371         int64_t size;
 372         struct trie_header_f h = {
 373                 .signature = HWDB_SIG,
 374                 .tool_version = htole64(atoi(VERSION)),
 375                 .header_size = htole64(sizeof(struct trie_header_f)),
 376                 .node_size = htole64(sizeof(struct trie_node_f)),
 377                 .child_entry_size = htole64(sizeof(struct trie_child_entry_f)),
 378                 .value_entry_size = htole64(sizeof(struct trie_value_entry_f)),
 379         };
 380         int err;
 381
 382         /* calculate size of header, nodes, children entries, value entries */
 383         t.strings_off = sizeof(struct trie_header_f);
 384         trie_store_nodes_size(&t, trie->root);
 385
 386         err = fopen_temporary(filename , &t.f, &filename_tmp);
 387         if (err < 0)
 388                 return err;
 389         fchmod(fileno(t.f), 0444);
 390
 391         /* write nodes */
 392         err = fseeko(t.f, sizeof(struct trie_header_f), SEEK_SET);
 393         if (err < 0) {
 394                 fclose(t.f);
 395                 unlink_noerrno(filename_tmp);
 396                 return -errno;
 397         }
 398         root_off = trie_store_nodes(&t, trie->root);
 399         h.nodes_root_off = htole64(root_off);
 400         pos = ftello(t.f);
 401         h.nodes_len = htole64(pos - sizeof(struct trie_header_f));
 402
 403         /* write string buffer */
 404         fwrite(trie->strings->buf, trie->strings->len, 1, t.f);
 405         h.strings_len = htole64(trie->strings->len);
 406
 407         /* write header */
 408         size = ftello(t.f);
 409         h.file_size = htole64(size);
 410         err = fseeko(t.f, 0, SEEK_SET);
 411         if (err < 0) {
 412                 fclose(t.f);
 413                 unlink_noerrno(filename_tmp);
 414                 return -errno;
 415         }
 416         fwrite(&h, sizeof(struct trie_header_f), 1, t.f);
 417         err = ferror(t.f);
 418         if (err)
 419                 err = -errno;
 420         fclose(t.f);
 421         if (err < 0 || rename(filename_tmp, filename) < 0) {
 422                 unlink_noerrno(filename_tmp);
 423                 return err < 0 ? err : -errno;
 424         }
 425
 426         log_debug("=== trie on-disk ===");
 427         log_debug("size:             %8"PRIi64" bytes", size);
 428         log_debug("header:           %8zu bytes", sizeof(struct trie_header_f));
 429         log_debug("nodes:            %8"PRIu64" bytes (%8"PRIu64")",
 430                   t.nodes_count * sizeof(struct trie_node_f), t.nodes_count);
 431         log_debug("child pointers:   %8"PRIu64" bytes (%8"PRIu64")",
 432                   t.children_count * sizeof(struct trie_child_entry_f), t.children_count);
 433         log_debug("value pointers:   %8"PRIu64" bytes (%8"PRIu64")",
 434                   t.values_count * sizeof(struct trie_value_entry_f), t.values_count);
 435         log_debug("string store:     %8zu bytes", trie->strings->len);
 436         log_debug("strings start:    %8"PRIu64, t.strings_off);
 437
 438         return 0;
 439 }
 440
 441 static int insert_data(struct trie *trie, char **match_list, char *line, const char *filename) {
 442         char *value, **entry;
 443
 444         value = strchr(line, '=');
 445         if (!value) {
 446                 log_error("Error, key/value pair expected but got '%s' in '%s':", line, filename);
 447                 return -EINVAL;
 448         }
 449
 450         value[0] = '\0';
 451         value++;
 452
 453         /* libudev requires properties to start with a space */
 454         while (isblank(line[0]) && isblank(line[1]))
 455                 line++;
 456
 457         if (line[0] == '\0' || value[0] == '\0') {
 458                 log_error("Error, empty key or value '%s' in '%s':", line, filename);
 459                 return -EINVAL;
 460         }
 461
 462         STRV_FOREACH(entry, match_list)
 463                 trie_insert(trie, trie->root, *entry, line, value);
 464
 465         return 0;
 466 }
 467
 468 static int import_file(struct trie *trie, const char *filename) {
 469         enum {
 470                 HW_NONE,
 471                 HW_MATCH,
 472                 HW_DATA,
 473         } state = HW_NONE;
 474         _cleanup_fclose_ FILE *f = NULL;
 475         char line[LINE_MAX];
 476         _cleanup_strv_free_ char **match_list = NULL;
 477         char *match = NULL;
 478         int r;
 479
 480         f = fopen(filename, "re");
 481         if (!f)
 482                 return -errno;
 483
 484         while (fgets(line, sizeof(line), f)) {
 485                 size_t len;
 486                 char *pos;
 487
 488                 /* comment line */
 489                 if (line[0] == '#')
 490                         continue;
 491
 492                 /* strip trailing comment */
 493                 pos = strchr(line, '#');
 494                 if (pos)
 495                         pos[0] = '\0';
 496
 497                 /* strip trailing whitespace */
 498                 len = strlen(line);
 499                 while (len > 0 && isspace(line[len-1]))
 500                         len--;
 501                 line[len] = '\0';
 502
 503                 switch (state) {
 504                 case HW_NONE:
 505                         if (len == 0)
 506                                 break;
 507
 508                         if (line[0] == ' ') {
 509                                 log_error("Error, MATCH expected but got '%s' in '%s':", line, filename);
 510                                 break;
 511                         }
 512
 513                         /* start of record, first match */
 514                         state = HW_MATCH;
 515
 516                         match = strdup(line);
 517                         if (!match)
 518                                 return -ENOMEM;
 519
 520                         r = strv_consume(&match_list, match);
 521                         if (r < 0)
 522                                 return r;
 523
 524                         break;
 525
 526                 case HW_MATCH:
 527                         if (len == 0) {
 528                                 log_error("Error, DATA expected but got empty line in '%s':", filename);
 529                                 state = HW_NONE;
 530                                 strv_clear(match_list);
 531                                 break;
 532                         }
 533
 534                         /* another match */
 535                         if (line[0] != ' ') {
 536                                 match = strdup(line);
 537                                 if (!match)
 538                                         return -ENOMEM;
 539
 540                                 r = strv_consume(&match_list, match);
 541                                 if (r < 0)
 542                                         return r;
 543
 544                                 break;
 545                         }
 546
 547                         /* first data */
 548                         state = HW_DATA;
 549                         insert_data(trie, match_list, line, filename);
 550                         break;
 551
 552                 case HW_DATA:
 553                         /* end of record */
 554                         if (len == 0) {
 555                                 state = HW_NONE;
 556                                 strv_clear(match_list);
 557                                 break;
 558                         }
 559
 560                         if (line[0] != ' ') {
 561                                 log_error("Error, DATA expected but got '%s' in '%s':", line, filename);
 562                                 state = HW_NONE;
 563                                 strv_clear(match_list);
 564                                 break;
 565                         }
 566
 567                         insert_data(trie, match_list, line, filename);
 568                         break;
 569                 };
 570         }
 571
 572         return 0;
 573 }
 574
 575 static int hwdb_query(int argc, char *argv[], void *userdata) {
 576         _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
 577         const char *key, *value;
 578         const char *modalias;
 579         int r;
 580
 581         assert(argc >= 2);
 582         assert(argv);
 583
 584         modalias = argv[1];
 585
 586         r = sd_hwdb_new(&hwdb);
 587         if (r < 0)
 588                 return r;
 589
 590         SD_HWDB_FOREACH_PROPERTY(hwdb, modalias, key, value)
 591                 printf("%s=%s\n", key, value);
 592
 593         return 0;
 594 }
 595
 596 static int hwdb_update(int argc, char *argv[], void *userdata) {
 597         _cleanup_free_ char *hwdb_bin = NULL;
 598         _cleanup_(trie_freep) struct trie *trie = NULL;
 599         char **files, **f;
 600         int r;
 601
 602         trie = new0(struct trie, 1);
 603         if (!trie)
 604                 return -ENOMEM;
 605
 606         /* string store */
 607         trie->strings = strbuf_new();
 608         if (!trie->strings)
 609                 return -ENOMEM;
 610
 611         /* index */
 612         trie->root = new0(struct trie_node, 1);
 613         if (!trie->root)
 614                 return -ENOMEM;
 615
 616         trie->nodes_count++;
 617
 618         r = conf_files_list_strv(&files, ".hwdb", arg_root, conf_file_dirs);
 619         if (r < 0)
 620                 return log_error_errno(r, "failed to enumerate hwdb files: %m");
 621
 622         STRV_FOREACH(f, files) {
 623                 log_debug("reading file '%s'", *f);
 624                 import_file(trie, *f);
 625         }
 626         strv_free(files);
 627
 628         strbuf_complete(trie->strings);
 629
 630         log_debug("=== trie in-memory ===");
 631         log_debug("nodes:            %8zu bytes (%8zu)",
 632                   trie->nodes_count * sizeof(struct trie_node), trie->nodes_count);
 633         log_debug("children arrays:  %8zu bytes (%8zu)",
 634                   trie->children_count * sizeof(struct trie_child_entry), trie->children_count);
 635         log_debug("values arrays:    %8zu bytes (%8zu)",
 636                   trie->values_count * sizeof(struct trie_value_entry), trie->values_count);
 637         log_debug("strings:          %8zu bytes",
 638                   trie->strings->len);
 639         log_debug("strings incoming: %8zu bytes (%8zu)",
 640                   trie->strings->in_len, trie->strings->in_count);
 641         log_debug("strings dedup'ed: %8zu bytes (%8zu)",
 642                   trie->strings->dedup_len, trie->strings->dedup_count);
 643
 644         hwdb_bin = strjoin(arg_root, "/", arg_hwdb_bin_dir, "/hwdb.bin", NULL);
 645         if (!hwdb_bin)
 646                 return -ENOMEM;
 647
 648         mkdir_parents_label(hwdb_bin, 0755);
 649         r = trie_store(trie, hwdb_bin);
 650         if (r < 0)
 651                 return log_error_errno(r, "Failure writing database %s: %m", hwdb_bin);
 652
 653         return label_fix(hwdb_bin, false, false);
 654 }
 655
 656 static void help(void) {
 657         printf("Usage: %s OPTIONS COMMAND\n\n"
 658                "Update or query the hardware database.\n\n"
 659                "  -h --help            Show this help\n"
 660                "     --version         Show package version\n"
 661                "     --usr             Generate in " UDEVLIBEXECDIR " instead of /etc/udev\n"
 662                "  -r --root=PATH       Alternative root path in the filesystem\n\n"
 663                "Commands:\n"
 664                "  update               Update the hwdb database\n"
 665                "  query MODALIAS       Query database and print result\n",
 666                program_invocation_short_name);
 667 }
 668
 669 static int parse_argv(int argc, char *argv[]) {
 670         enum {
 671                 ARG_VERSION = 0x100,
 672                 ARG_USR,
 673         };
 674
 675         static const struct option options[] = {
 676                 { "help",     no_argument,       NULL, 'h'         },
 677                 { "version",  no_argument,       NULL, ARG_VERSION },
 678                 { "usr",      no_argument,       NULL, ARG_USR     },
 679                 { "root",     required_argument, NULL, 'r'         },
 680                 {}
 681         };
 682
 683         int c;
 684
 685         assert(argc >= 0);
 686         assert(argv);
 687
 688         while ((c = getopt_long(argc, argv, "ut:r:h", options, NULL)) >= 0) {
 689                 switch(c) {
 690
 691                 case 'h':
 692                         help();
 693                         return 0;
 694
 695                 case ARG_VERSION:
 696                         return version();
 697
 698                 case ARG_USR:
 699                         arg_hwdb_bin_dir = UDEVLIBEXECDIR;
 700                         break;
 701
 702                 case 'r':
 703                         arg_root = optarg;
 704                         break;
 705
 706                 case '?':
 707                         return -EINVAL;
 708
 709                 default:
 710                         assert_not_reached("Unknown option");
 711                 }
 712         }
 713
 714         return 1;
 715 }
 716
 717 static int hwdb_main(int argc, char *argv[]) {
 718         const Verb verbs[] = {
 719                 { "update", 1, 1, 0, hwdb_update },
 720                 { "query",  2, 2, 0, hwdb_query  },
 721                 {},
 722         };
 723
 724         return dispatch_verb(argc, argv, verbs, NULL);
 725 }
 726
 727 int main (int argc, char *argv[]) {
 728         int r;
 729
 730         log_parse_environment();
 731         log_open();
 732
 733         r = parse_argv(argc, argv);
 734         if (r <= 0)
 735                 goto finish;
 736
 737         mac_selinux_init();
 738
 739         r = hwdb_main(argc, argv);
 740
 741 finish:
 742         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 743 }