name.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <string.h>
   6 #include <sys/epoll.h>
   7
   8 #include "set.h"
   9 #include "name.h"
  10 #include "macro.h"
  11 #include "strv.h"
  12 #include "load-fragment.h"
  13 #include "load-dropin.h"
  14
  15 const NameVTable * const name_vtable[_NAME_TYPE_MAX] = {
  16         [NAME_SERVICE] = &service_vtable,
  17         [NAME_TIMER] = &timer_vtable,
  18         [NAME_SOCKET] = &socket_vtable,
  19         [NAME_MILESTONE] = &milestone_vtable,
  20         [NAME_DEVICE] = &device_vtable,
  21         [NAME_MOUNT] = &mount_vtable,
  22         [NAME_AUTOMOUNT] = &automount_vtable,
  23         [NAME_SNAPSHOT] = &snapshot_vtable
  24 };
  25
  26 NameType name_type_from_string(const char *n) {
  27         NameType t;
  28
  29         assert(n);
  30
  31         for (t = 0; t < _NAME_TYPE_MAX; t++)
  32                 if (endswith(n, name_vtable[t]->suffix))
  33                         return t;
  34
  35         return _NAME_TYPE_INVALID;
  36 }
  37
  38 #define VALID_CHARS                             \
  39         "0123456789"                            \
  40         "abcdefghijklmnopqrstuvwxyz"            \
  41         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
  42         "-_"
  43
  44 bool name_is_valid(const char *n) {
  45         NameType t;
  46         const char *e, *i;
  47
  48         assert(n);
  49
  50         if (strlen(n) >= NAME_MAX)
  51                 return false;
  52
  53         t = name_type_from_string(n);
  54         if (t < 0 || t >= _NAME_TYPE_MAX)
  55                 return false;
  56
  57         if (!(e = strrchr(n, '.')))
  58                 return false;
  59
  60         for (i = n; i < e; i++)
  61                 if (!strchr(VALID_CHARS, *i))
  62                         return false;
  63
  64         return true;
  65 }
  66
  67 Name *name_new(Manager *m) {
  68         Name *n;
  69
  70         assert(m);
  71
  72         if (!(n = new0(Name, 1)))
  73                 return NULL;
  74
  75         if (!(n->meta.names = set_new(string_hash_func, string_compare_func))) {
  76                 free(n);
  77                 return NULL;
  78         }
  79
  80         /* Not much initialization happening here at this time */
  81         n->meta.manager = m;
  82         n->meta.type = _NAME_TYPE_INVALID;
  83
  84         /* We don't link the name here, that is left for name_link() */
  85
  86         return n;
  87 }
  88
  89 /* FIXME: Does not rollback on failure! */
  90 int name_link_names(Name *n, bool replace) {
  91         char *t;
  92         void *state;
  93         int r;
  94
  95         assert(n);
  96
  97         if (!n->meta.linked)
  98                 return 0;
  99
 100         /* Link all names that aren't linked yet. */
 101
 102         SET_FOREACH(t, n->meta.names, state)
 103                 if (replace) {
 104                         if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
 105                                 return r;
 106                 } else {
 107                         if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
 108                                 return r;
 109                 }
 110
 111         return 0;
 112 }
 113
 114 int name_link(Name *n) {
 115         int r;
 116
 117         assert(n);
 118         assert(!set_isempty(n->meta.names));
 119         assert(!n->meta.linked);
 120
 121         if ((r = name_sanitize(n)) < 0)
 122                 return r;
 123
 124         n->meta.linked = true;
 125
 126         if ((r = name_link_names(n, false)) < 0) {
 127                 char *t;
 128                 void *state;
 129
 130                 /* Rollback the registered names */
 131                 SET_FOREACH(t, n->meta.names, state)
 132                         hashmap_remove_value(n->meta.manager->names, t, n);
 133
 134                 n->meta.linked = false;
 135                 return r;
 136         }
 137
 138         if (n->meta.load_state == NAME_STUB)
 139                 LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
 140
 141         return 0;
 142 }
 143
 144 static void bidi_set_free(Name *name, Set *s) {
 145         void *state;
 146         Name *other;
 147
 148         assert(name);
 149
 150         /* Frees the set and makes sure we are dropped from the
 151          * inverse pointers */
 152
 153         SET_FOREACH(other, s, state) {
 154                 NameDependency d;
 155
 156                 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 157                         set_remove(other->meta.dependencies[d], name);
 158         }
 159
 160         set_free(s);
 161 }
 162
 163 void name_free(Name *name) {
 164         NameDependency d;
 165         char *t;
 166
 167         assert(name);
 168
 169         /* Detach from next 'bigger' objects */
 170         if (name->meta.linked) {
 171                 char *t;
 172                 void *state;
 173
 174                 SET_FOREACH(t, name->meta.names, state)
 175                         hashmap_remove_value(name->meta.manager->names, t, name);
 176
 177                 if (name->meta.load_state == NAME_STUB)
 178                         LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta);
 179         }
 180
 181         /* Free data and next 'smaller' objects */
 182         if (name->meta.job)
 183                 job_free(name->meta.job);
 184
 185         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 186                 bidi_set_free(name, name->meta.dependencies[d]);
 187
 188         if (NAME_VTABLE(name)->free_hook)
 189                 NAME_VTABLE(name)->free_hook(name);
 190
 191         free(name->meta.description);
 192
 193         while ((t = set_steal_first(name->meta.names)))
 194                 free(t);
 195         set_free(name->meta.names);
 196
 197         free(name);
 198 }
 199
 200 NameActiveState name_active_state(Name *name) {
 201         assert(name);
 202
 203         if (name->meta.load_state != NAME_LOADED)
 204                 return NAME_INACTIVE;
 205
 206         return NAME_VTABLE(name)->active_state(name);
 207 }
 208
 209 static int ensure_in_set(Set **s, void *data) {
 210         int r;
 211
 212         assert(s);
 213         assert(data);
 214
 215         if (!*s)
 216                 if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
 217                         return -ENOMEM;
 218
 219         if ((r = set_put(*s, data)) < 0)
 220                 if (r != -EEXIST)
 221                         return r;
 222
 223         return 0;
 224 }
 225
 226 static int ensure_merge(Set **s, Set *other) {
 227
 228         if (!other)
 229                 return 0;
 230
 231         if (*s)
 232                 return set_merge(*s, other);
 233
 234         if (!(*s = set_copy(other)))
 235                 return -ENOMEM;
 236
 237         return 0;
 238 }
 239
 240 /* FIXME: Does not rollback on failure! */
 241 int name_merge(Name *name, Name *other) {
 242         int r;
 243         NameDependency d;
 244
 245         assert(name);
 246         assert(other);
 247         assert(name->meta.manager == other->meta.manager);
 248
 249         /* This merges 'other' into 'name'. FIXME: This does not
 250          * rollback on failure. */
 251
 252         if (name->meta.type != other->meta.type)
 253                 return -EINVAL;
 254
 255         if (other->meta.load_state != NAME_STUB)
 256                 return -EINVAL;
 257
 258         /* Merge names */
 259         if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
 260                 return r;
 261
 262         /* Merge dependencies */
 263         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 264                 if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
 265                         return r;
 266
 267         /* Hookup new deps and names */
 268         if (name->meta.linked) {
 269                 if ((r = name_sanitize(name)) < 0)
 270                         return r;
 271
 272                 if ((r = name_link_names(name, true)) < 0)
 273                         return r;
 274         }
 275
 276         return 0;
 277 }
 278
 279 /* FIXME: Does not rollback on failure! */
 280 static int augment(Name *n) {
 281         int r;
 282         void* state;
 283         Name *other;
 284
 285         assert(n);
 286
 287         /* Adds in the missing links to make all dependencies
 288          * bidirectional. */
 289
 290         SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
 291                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n)) < 0)
 292                         return r;
 293         SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state)
 294                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n)) < 0)
 295                         return r;
 296
 297         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
 298                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n)) < 0)
 299                         return r;
 300
 301         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
 302                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 303                         return r;
 304         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
 305                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 306                         return r;
 307
 308         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
 309                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_SOFT_REQUIRED_BY], n)) < 0)
 310                         return r;
 311
 312         SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
 313                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
 314                         return r;
 315
 316         return 0;
 317 }
 318
 319 int name_sanitize(Name *n) {
 320         NameDependency d;
 321
 322         assert(n);
 323
 324         /* Remove loops */
 325         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 326                 set_remove(n->meta.dependencies[d], n);
 327
 328         return augment(n);
 329 }
 330
 331 const char* name_id(Name *n) {
 332         assert(n);
 333
 334         return set_first(n->meta.names);
 335 }
 336
 337 const char *name_description(Name *n) {
 338         assert(n);
 339
 340         if (n->meta.description)
 341                 return n->meta.description;
 342
 343         return name_id(n);
 344 }
 345
 346 void name_dump(Name *n, FILE *f, const char *prefix) {
 347
 348         static const char* const load_state_table[_NAME_LOAD_STATE_MAX] = {
 349                 [NAME_STUB] = "stub",
 350                 [NAME_LOADED] = "loaded",
 351                 [NAME_FAILED] = "failed"
 352         };
 353
 354         static const char* const active_state_table[_NAME_ACTIVE_STATE_MAX] = {
 355                 [NAME_ACTIVE] = "active",
 356                 [NAME_INACTIVE] = "inactive",
 357                 [NAME_ACTIVATING] = "activating",
 358                 [NAME_DEACTIVATING] = "deactivating"
 359         };
 360
 361         static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = {
 362                 [NAME_REQUIRES] = "Requires",
 363                 [NAME_SOFT_REQUIRES] = "SoftRequires",
 364                 [NAME_WANTS] = "Wants",
 365                 [NAME_REQUISITE] = "Requisite",
 366                 [NAME_SOFT_REQUISITE] = "SoftRequisite",
 367                 [NAME_REQUIRED_BY] = "RequiredBy",
 368                 [NAME_SOFT_REQUIRED_BY] = "SoftRequiredBy",
 369                 [NAME_WANTED_BY] = "WantedBy",
 370                 [NAME_CONFLICTS] = "Conflicts",
 371                 [NAME_BEFORE] = "Before",
 372                 [NAME_AFTER] = "After",
 373         };
 374
 375         void *state;
 376         char *t;
 377         NameDependency d;
 378
 379         assert(n);
 380
 381         if (!prefix)
 382                 prefix = "";
 383
 384         fprintf(f,
 385                 "%sName %s:\n"
 386                 "%s\tDescription: %s\n"
 387                 "%s\tName Load State: %s\n"
 388                 "%s\tName Active State: %s\n",
 389                 prefix, name_id(n),
 390                 prefix, name_description(n),
 391                 prefix, load_state_table[n->meta.load_state],
 392                 prefix, active_state_table[name_active_state(n)]);
 393
 394         SET_FOREACH(t, n->meta.names, state)
 395                 fprintf(f, "%s\tName: %s\n", prefix, t);
 396
 397         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
 398                 void *state;
 399                 Name *other;
 400
 401                 if (set_isempty(n->meta.dependencies[d]))
 402                         continue;
 403
 404                 SET_FOREACH(other, n->meta.dependencies[d], state)
 405                         fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other));
 406         }
 407
 408         if (NAME_VTABLE(n)->dump)
 409                 NAME_VTABLE(n)->dump(n, f, prefix);
 410
 411         if (n->meta.job) {
 412                 char *p;
 413
 414                 if (asprintf(&p, "%s\t", prefix) >= 0)
 415                         prefix = p;
 416                 else
 417                         p = NULL;
 418
 419                 job_dump(n->meta.job, f, prefix);
 420                 free(p);
 421         }
 422 }
 423
 424 static int verify_type(Name *name) {
 425         char *n;
 426         void *state;
 427
 428         assert(name);
 429
 430         /* Checks that all aliases of this name have the same and valid type */
 431
 432         SET_FOREACH(n, name->meta.names, state) {
 433                 NameType t;
 434
 435                 if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
 436                         return -EINVAL;
 437
 438                 if (name->meta.type == _NAME_TYPE_INVALID) {
 439                         name->meta.type = t;
 440                         continue;
 441                 }
 442
 443                 if (name->meta.type != t)
 444                         return -EINVAL;
 445         }
 446
 447         if (name->meta.type == _NAME_TYPE_INVALID)
 448                 return -EINVAL;
 449
 450         return 0;
 451 }
 452
 453 /* Common implementation for multiple backends */
 454 int name_load_fragment_and_dropin(Name *n) {
 455         int r;
 456
 457         assert(n);
 458
 459         /* Load a .socket file */
 460         if ((r = name_load_fragment(n)) < 0)
 461                 return r;
 462
 463         /* Load drop-in directory data */
 464         if ((r = name_load_dropin(n)) < 0)
 465                 return r;
 466
 467         return 0;
 468 }
 469
 470 int name_load(Name *name) {
 471         int r;
 472
 473         assert(name);
 474
 475         if (name->meta.load_state != NAME_STUB)
 476                 return 0;
 477
 478         if ((r = verify_type(name)) < 0)
 479                 return r;
 480
 481         if (NAME_VTABLE(name)->load)
 482                 if ((r = NAME_VTABLE(name)->load(name)) < 0)
 483                         goto fail;
 484
 485         if ((r = name_sanitize(name)) < 0)
 486                 goto fail;
 487
 488         if ((r = name_link_names(name, false)) < 0)
 489                 goto fail;
 490
 491         name->meta.load_state = NAME_LOADED;
 492         return 0;
 493
 494 fail:
 495         name->meta.load_state = NAME_FAILED;
 496         return r;
 497 }
 498
 499 /* Errors:
 500  *         -EBADR:    This name type does not support starting.
 501  *         -EALREADY: Name is already started.
 502  *         -EAGAIN:   An operation is already in progress. Retry later.
 503  */
 504 int name_start(Name *n) {
 505         NameActiveState state;
 506
 507         assert(n);
 508
 509         if (!NAME_VTABLE(n)->start)
 510                 return -EBADR;
 511
 512         state = name_active_state(n);
 513         if (NAME_IS_ACTIVE_OR_RELOADING(state))
 514                 return -EALREADY;
 515
 516         if (state == NAME_ACTIVATING)
 517                 return 0;
 518
 519         return NAME_VTABLE(n)->start(n);
 520 }
 521
 522 bool name_type_can_start(NameType t) {
 523         assert(t >= 0 && t < _NAME_TYPE_MAX);
 524
 525         return !!name_vtable[t]->start;
 526 }
 527
 528 /* Errors:
 529  *         -EBADR:    This name type does not support stopping.
 530  *         -EALREADY: Name is already stopped.
 531  *         -EAGAIN:   An operation is already in progress. Retry later.
 532  */
 533 int name_stop(Name *n) {
 534         NameActiveState state;
 535
 536         assert(n);
 537
 538         if (!NAME_VTABLE(n)->stop)
 539                 return -EBADR;
 540
 541         state = name_active_state(n);
 542         if (state == NAME_INACTIVE)
 543                 return -EALREADY;
 544
 545         if (state == NAME_DEACTIVATING)
 546                 return 0;
 547
 548         return NAME_VTABLE(n)->stop(n);
 549 }
 550
 551 /* Errors:
 552  *         -EBADR:    This name type does not support reloading.
 553  *         -ENOEXEC:  Name is not started.
 554  *         -EAGAIN:   An operation is already in progress. Retry later.
 555  */
 556 int name_reload(Name *n) {
 557         NameActiveState state;
 558
 559         assert(n);
 560
 561         if (!NAME_VTABLE(n)->reload)
 562                 return -EBADR;
 563
 564         state = name_active_state(n);
 565         if (name_active_state(n) == NAME_ACTIVE_RELOADING)
 566                 return -EALREADY;
 567
 568         if (name_active_state(n) != NAME_ACTIVE)
 569                 return -ENOEXEC;
 570
 571         return NAME_VTABLE(n)->reload(n);
 572 }
 573
 574 bool name_type_can_reload(NameType t) {
 575         assert(t >= 0 && t < _NAME_TYPE_MAX);
 576         return !!name_vtable[t]->reload;
 577 }
 578
 579 static void retroactively_start_dependencies(Name *n) {
 580         void *state;
 581         Name *other;
 582
 583         assert(n);
 584         assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n)));
 585
 586         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
 587                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 588                         manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
 589
 590         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
 591                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 592                         manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
 593
 594         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
 595                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 596                         manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
 597
 598         SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
 599                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 600                         manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
 601
 602         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
 603                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 604                         manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
 605 }
 606
 607 static void retroactively_stop_dependencies(Name *n) {
 608         void *state;
 609         Name *other;
 610
 611         assert(n);
 612         assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n)));
 613
 614         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], state)
 615                 if (!NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(other)))
 616                         manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
 617 }
 618
 619 void name_notify(Name *n, NameActiveState os, NameActiveState ns) {
 620         assert(n);
 621         assert(os < _NAME_ACTIVE_STATE_MAX);
 622         assert(ns < _NAME_ACTIVE_STATE_MAX);
 623         assert(!(os == NAME_ACTIVE && ns == NAME_ACTIVATING));
 624         assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING));
 625
 626         if (os == ns)
 627                 return;
 628
 629         if (n->meta.job) {
 630
 631                 if (n->meta.job->state == JOB_WAITING)
 632
 633                         /* So we reached a different state for this
 634                          * job. Let's see if we can run it now if it
 635                          * failed previously due to EAGAIN. */
 636                         job_run_and_invalidate(n->meta.job);
 637
 638                 else {
 639                         assert(n->meta.job->state == JOB_RUNNING);
 640
 641                         /* Let's check of this state change
 642                          * constitutes a finished job, or maybe
 643                          * cotradicts a running job and hence needs to
 644                          * invalidate jobs. */
 645
 646                         switch (n->meta.job->type) {
 647
 648                                 case JOB_START:
 649                                 case JOB_VERIFY_ACTIVE:
 650
 651                                         if (NAME_IS_ACTIVE_OR_RELOADING(ns)) {
 652                                                 job_finish_and_invalidate(n->meta.job, true);
 653                                                 return;
 654                                         } else if (ns == NAME_ACTIVATING)
 655                                                 return;
 656                                         else
 657                                                 job_finish_and_invalidate(n->meta.job, false);
 658
 659                                         break;
 660
 661                                 case JOB_RELOAD:
 662                                 case JOB_RELOAD_OR_START:
 663
 664                                         if (ns == NAME_ACTIVE) {
 665                                                 job_finish_and_invalidate(n->meta.job, true);
 666                                                 return;
 667                                         } else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING)
 668                                                 return;
 669                                         else
 670                                                 job_finish_and_invalidate(n->meta.job, false);
 671
 672                                         break;
 673
 674                                 case JOB_STOP:
 675                                 case JOB_RESTART:
 676                                 case JOB_TRY_RESTART:
 677
 678                                         if (ns == NAME_INACTIVE) {
 679                                                 job_finish_and_invalidate(n->meta.job, true);
 680                                                 return;
 681                                         } else if (ns == NAME_DEACTIVATING)
 682                                                 return;
 683                                         else
 684                                                 job_finish_and_invalidate(n->meta.job, false);
 685
 686                                         break;
 687
 688                                 default:
 689                                         assert_not_reached("Job type unknown");
 690                         }
 691                 }
 692         }
 693
 694         /* If this state change happened without being requested by a
 695          * job, then let's retroactively start or stop dependencies */
 696
 697         if (NAME_IS_INACTIVE_OR_DEACTIVATING(os) && NAME_IS_ACTIVE_OR_ACTIVATING(ns))
 698                 retroactively_start_dependencies(n);
 699         else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns))
 700                 retroactively_stop_dependencies(n);
 701 }
 702
 703 int name_watch_fd(Name *n, int fd, uint32_t events) {
 704         struct epoll_event ev;
 705
 706         assert(n);
 707         assert(fd >= 0);
 708
 709         zero(ev);
 710         ev.data.fd = fd;
 711         ev.data.ptr = n;
 712         ev.events = events;
 713
 714         if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
 715                 return -errno;
 716
 717         return 0;
 718 }
 719
 720 void name_unwatch_fd(Name *n, int fd) {
 721         assert(n);
 722         assert(fd >= 0);
 723
 724         assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, fd, NULL) >= 0 || errno == ENOENT);
 725 }
 726
 727 int name_watch_pid(Name *n, pid_t pid) {
 728         assert(n);
 729         assert(pid >= 1);
 730
 731         return hashmap_put(n->meta.manager->watch_pids, UINT32_TO_PTR(pid), n);
 732 }
 733
 734 void name_unwatch_pid(Name *n, pid_t pid) {
 735         assert(n);
 736         assert(pid >= 1);
 737
 738         hashmap_remove(n->meta.manager->watch_pids, UINT32_TO_PTR(pid));
 739 }