src/core/unit.h

   1 #pragma once
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdbool.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 typedef struct Unit Unit;
  27 typedef struct UnitVTable UnitVTable;
  28 typedef struct UnitRef UnitRef;
  29 typedef struct UnitStatusMessageFormats UnitStatusMessageFormats;
  30
  31 #include "condition.h"
  32 #include "failure-action.h"
  33 #include "install.h"
  34 #include "list.h"
  35 #include "unit-name.h"
  36
  37 typedef enum KillOperation {
  38         KILL_TERMINATE,
  39         KILL_TERMINATE_AND_LOG,
  40         KILL_KILL,
  41         KILL_ABORT,
  42         _KILL_OPERATION_MAX,
  43         _KILL_OPERATION_INVALID = -1
  44 } KillOperation;
  45
  46 static inline bool UNIT_IS_ACTIVE_OR_RELOADING(UnitActiveState t) {
  47         return t == UNIT_ACTIVE || t == UNIT_RELOADING;
  48 }
  49
  50 static inline bool UNIT_IS_ACTIVE_OR_ACTIVATING(UnitActiveState t) {
  51         return t == UNIT_ACTIVE || t == UNIT_ACTIVATING || t == UNIT_RELOADING;
  52 }
  53
  54 static inline bool UNIT_IS_INACTIVE_OR_DEACTIVATING(UnitActiveState t) {
  55         return t == UNIT_INACTIVE || t == UNIT_FAILED || t == UNIT_DEACTIVATING;
  56 }
  57
  58 static inline bool UNIT_IS_INACTIVE_OR_FAILED(UnitActiveState t) {
  59         return t == UNIT_INACTIVE || t == UNIT_FAILED;
  60 }
  61
  62 #include "job.h"
  63
  64 struct UnitRef {
  65         /* Keeps tracks of references to a unit. This is useful so
  66          * that we can merge two units if necessary and correct all
  67          * references to them */
  68
  69         Unit* unit;
  70         LIST_FIELDS(UnitRef, refs);
  71 };
  72
  73 struct Unit {
  74         Manager *manager;
  75
  76         UnitType type;
  77         UnitLoadState load_state;
  78         Unit *merged_into;
  79
  80         char *id; /* One name is special because we use it for identification. Points to an entry in the names set */
  81         char *instance;
  82
  83         Set *names;
  84         Set *dependencies[_UNIT_DEPENDENCY_MAX];
  85
  86         char **requires_mounts_for;
  87
  88         char *description;
  89         char **documentation;
  90
  91         char *fragment_path; /* if loaded from a config file this is the primary path to it */
  92         char *source_path; /* if converted, the source file */
  93         char **dropin_paths;
  94
  95         usec_t fragment_mtime;
  96         usec_t source_mtime;
  97         usec_t dropin_mtime;
  98
  99         /* If this is a transient unit we are currently writing, this is where we are writing it to */
 100         FILE *transient_file;
 101
 102         /* If there is something to do with this unit, then this is the installed job for it */
 103         Job *job;
 104
 105         /* JOB_NOP jobs are special and can be installed without disturbing the real job. */
 106         Job *nop_job;
 107
 108         /* The slot used for watching NameOwnerChanged signals */
 109         sd_bus_slot *match_bus_slot;
 110
 111         /* Job timeout and action to take */
 112         usec_t job_timeout;
 113         FailureAction job_timeout_action;
 114         char *job_timeout_reboot_arg;
 115
 116         /* References to this */
 117         LIST_HEAD(UnitRef, refs);
 118
 119         /* Conditions to check */
 120         LIST_HEAD(Condition, conditions);
 121         LIST_HEAD(Condition, asserts);
 122
 123         dual_timestamp condition_timestamp;
 124         dual_timestamp assert_timestamp;
 125
 126         /* Updated whenever the low-level state changes */
 127         dual_timestamp state_change_timestamp;
 128
 129         /* Updated whenever the (high-level) active state enters or leaves the active or inactive states */
 130         dual_timestamp inactive_exit_timestamp;
 131         dual_timestamp active_enter_timestamp;
 132         dual_timestamp active_exit_timestamp;
 133         dual_timestamp inactive_enter_timestamp;
 134
 135         UnitRef slice;
 136
 137         /* Per type list */
 138         LIST_FIELDS(Unit, units_by_type);
 139
 140         /* All units which have requires_mounts_for set */
 141         LIST_FIELDS(Unit, has_requires_mounts_for);
 142
 143         /* Load queue */
 144         LIST_FIELDS(Unit, load_queue);
 145
 146         /* D-Bus queue */
 147         LIST_FIELDS(Unit, dbus_queue);
 148
 149         /* Cleanup queue */
 150         LIST_FIELDS(Unit, cleanup_queue);
 151
 152         /* GC queue */
 153         LIST_FIELDS(Unit, gc_queue);
 154
 155         /* CGroup realize members queue */
 156         LIST_FIELDS(Unit, cgroup_queue);
 157
 158         /* Units with the same CGroup netclass */
 159         LIST_FIELDS(Unit, cgroup_netclass);
 160
 161         /* PIDs we keep an eye on. Note that a unit might have many
 162          * more, but these are the ones we care enough about to
 163          * process SIGCHLD for */
 164         Set *pids;
 165
 166         /* Used in sigchld event invocation to avoid repeat events being invoked */
 167         uint64_t sigchldgen;
 168
 169         /* Used during GC sweeps */
 170         unsigned gc_marker;
 171
 172         /* Error code when we didn't manage to load the unit (negative) */
 173         int load_error;
 174
 175         /* Put a ratelimit on unit starting */
 176         RateLimit start_limit;
 177         FailureAction start_limit_action;
 178         char *reboot_arg;
 179
 180         /* Make sure we never enter endless loops with the check unneeded logic, or the BindsTo= logic */
 181         RateLimit auto_stop_ratelimit;
 182
 183         /* Cached unit file state and preset */
 184         UnitFileState unit_file_state;
 185         int unit_file_preset;
 186
 187         /* Where the cpu.stat or cpuacct.usage was at the time the unit was started */
 188         nsec_t cpu_usage_base;
 189
 190         /* Counterparts in the cgroup filesystem */
 191         char *cgroup_path;
 192         CGroupMask cgroup_realized_mask;
 193         CGroupMask cgroup_enabled_mask;
 194         CGroupMask cgroup_subtree_mask;
 195         CGroupMask cgroup_members_mask;
 196         int cgroup_inotify_wd;
 197
 198         uint32_t cgroup_netclass_id;
 199
 200         /* How to start OnFailure units */
 201         JobMode on_failure_job_mode;
 202
 203         /* Garbage collect us we nobody wants or requires us anymore */
 204         bool stop_when_unneeded;
 205
 206         /* Create default dependencies */
 207         bool default_dependencies;
 208
 209         /* Refuse manual starting, allow starting only indirectly via dependency. */
 210         bool refuse_manual_start;
 211
 212         /* Don't allow the user to stop this unit manually, allow stopping only indirectly via dependency. */
 213         bool refuse_manual_stop;
 214
 215         /* Allow isolation requests */
 216         bool allow_isolate;
 217
 218         /* Ignore this unit when isolating */
 219         bool ignore_on_isolate;
 220
 221         /* Did the last condition check succeed? */
 222         bool condition_result;
 223         bool assert_result;
 224
 225         /* Is this a transient unit? */
 226         bool transient;
 227
 228         bool in_load_queue:1;
 229         bool in_dbus_queue:1;
 230         bool in_cleanup_queue:1;
 231         bool in_gc_queue:1;
 232         bool in_cgroup_queue:1;
 233
 234         bool sent_dbus_new_signal:1;
 235
 236         bool no_gc:1;
 237
 238         bool in_audit:1;
 239
 240         bool cgroup_realized:1;
 241         bool cgroup_members_mask_valid:1;
 242         bool cgroup_subtree_mask_valid:1;
 243
 244         bool start_limit_hit:1;
 245
 246         /* Did we already invoke unit_coldplug() for this unit? */
 247         bool coldplugged:1;
 248 };
 249
 250 struct UnitStatusMessageFormats {
 251         const char *starting_stopping[2];
 252         const char *finished_start_job[_JOB_RESULT_MAX];
 253         const char *finished_stop_job[_JOB_RESULT_MAX];
 254 };
 255
 256 typedef enum UnitSetPropertiesMode {
 257         UNIT_CHECK = 0,
 258         UNIT_RUNTIME = 1,
 259         UNIT_PERSISTENT = 2,
 260 } UnitSetPropertiesMode;
 261
 262 #include "automount.h"
 263 #include "busname.h"
 264 #include "device.h"
 265 #include "path.h"
 266 #include "scope.h"
 267 #include "slice.h"
 268 #include "socket.h"
 269 #include "swap.h"
 270 #include "target.h"
 271 #include "timer.h"
 272
 273 struct UnitVTable {
 274         /* How much memory does an object of this unit type need */
 275         size_t object_size;
 276
 277         /* If greater than 0, the offset into the object where
 278          * ExecContext is found, if the unit type has that */
 279         size_t exec_context_offset;
 280
 281         /* If greater than 0, the offset into the object where
 282          * CGroupContext is found, if the unit type has that */
 283         size_t cgroup_context_offset;
 284
 285         /* If greater than 0, the offset into the object where
 286          * KillContext is found, if the unit type has that */
 287         size_t kill_context_offset;
 288
 289         /* If greater than 0, the offset into the object where the
 290          * pointer to ExecRuntime is found, if the unit type has
 291          * that */
 292         size_t exec_runtime_offset;
 293
 294         /* If greater than 0, the offset into the object where the pointer to DynamicCreds is found, if the unit type
 295          * has that. */
 296         size_t dynamic_creds_offset;
 297
 298         /* The name of the configuration file section with the private settings of this unit */
 299         const char *private_section;
 300
 301         /* Config file sections this unit type understands, separated
 302          * by NUL chars */
 303         const char *sections;
 304
 305         /* This should reset all type-specific variables. This should
 306          * not allocate memory, and is called with zero-initialized
 307          * data. It should hence only initialize variables that need
 308          * to be set != 0. */
 309         void (*init)(Unit *u);
 310
 311         /* This should free all type-specific variables. It should be
 312          * idempotent. */
 313         void (*done)(Unit *u);
 314
 315         /* Actually load data from disk. This may fail, and should set
 316          * load_state to UNIT_LOADED, UNIT_MERGED or leave it at
 317          * UNIT_STUB if no configuration could be found. */
 318         int (*load)(Unit *u);
 319
 320         /* If a lot of units got created via enumerate(), this is
 321          * where to actually set the state and call unit_notify(). */
 322         int (*coldplug)(Unit *u);
 323
 324         void (*dump)(Unit *u, FILE *f, const char *prefix);
 325
 326         int (*start)(Unit *u);
 327         int (*stop)(Unit *u);
 328         int (*reload)(Unit *u);
 329
 330         int (*kill)(Unit *u, KillWho w, int signo, sd_bus_error *error);
 331
 332         bool (*can_reload)(Unit *u);
 333
 334         /* Write all data that cannot be restored from other sources
 335          * away using unit_serialize_item() */
 336         int (*serialize)(Unit *u, FILE *f, FDSet *fds);
 337
 338         /* Restore one item from the serialization */
 339         int (*deserialize_item)(Unit *u, const char *key, const char *data, FDSet *fds);
 340
 341         /* Try to match up fds with what we need for this unit */
 342         void (*distribute_fds)(Unit *u, FDSet *fds);
 343
 344         /* Boils down the more complex internal state of this unit to
 345          * a simpler one that the engine can understand */
 346         UnitActiveState (*active_state)(Unit *u);
 347
 348         /* Returns the substate specific to this unit type as
 349          * string. This is purely information so that we can give the
 350          * user a more fine grained explanation in which actual state a
 351          * unit is in. */
 352         const char* (*sub_state_to_string)(Unit *u);
 353
 354         /* Return true when there is reason to keep this entry around
 355          * even nothing references it and it isn't active in any
 356          * way */
 357         bool (*check_gc)(Unit *u);
 358
 359         /* When the unit is not running and no job for it queued we
 360          * shall release its runtime resources */
 361         void (*release_resources)(Unit *u);
 362
 363         /* Invoked on every child that died */
 364         void (*sigchld_event)(Unit *u, pid_t pid, int code, int status);
 365
 366         /* Reset failed state if we are in failed state */
 367         void (*reset_failed)(Unit *u);
 368
 369         /* Called whenever any of the cgroups this unit watches for
 370          * ran empty */
 371         void (*notify_cgroup_empty)(Unit *u);
 372
 373         /* Called whenever a process of this unit sends us a message */
 374         void (*notify_message)(Unit *u, pid_t pid, char **tags, FDSet *fds);
 375
 376         /* Called whenever a name this Unit registered for comes or
 377          * goes away. */
 378         void (*bus_name_owner_change)(Unit *u, const char *name, const char *old_owner, const char *new_owner);
 379
 380         /* Called for each property that is being set */
 381         int (*bus_set_property)(Unit *u, const char *name, sd_bus_message *message, UnitSetPropertiesMode mode, sd_bus_error *error);
 382
 383         /* Called after at least one property got changed to apply the necessary change */
 384         int (*bus_commit_properties)(Unit *u);
 385
 386         /* Return the unit this unit is following */
 387         Unit *(*following)(Unit *u);
 388
 389         /* Return the set of units that are following each other */
 390         int (*following_set)(Unit *u, Set **s);
 391
 392         /* Invoked each time a unit this unit is triggering changes
 393          * state or gains/loses a job */
 394         void (*trigger_notify)(Unit *u, Unit *trigger);
 395
 396         /* Called whenever CLOCK_REALTIME made a jump */
 397         void (*time_change)(Unit *u);
 398
 399         /* Returns the next timeout of a unit */
 400         int (*get_timeout)(Unit *u, usec_t *timeout);
 401
 402         /* Returns the main PID if there is any defined, or 0. */
 403         pid_t (*main_pid)(Unit *u);
 404
 405         /* Returns the main PID if there is any defined, or 0. */
 406         pid_t (*control_pid)(Unit *u);
 407
 408         /* This is called for each unit type and should be used to
 409          * enumerate existing devices and load them. However,
 410          * everything that is loaded here should still stay in
 411          * inactive state. It is the job of the coldplug() call above
 412          * to put the units into the initial state.  */
 413         void (*enumerate)(Manager *m);
 414
 415         /* Type specific cleanups. */
 416         void (*shutdown)(Manager *m);
 417
 418         /* If this function is set and return false all jobs for units
 419          * of this type will immediately fail. */
 420         bool (*supported)(void);
 421
 422         /* The bus vtable */
 423         const sd_bus_vtable *bus_vtable;
 424
 425         /* The strings to print in status messages */
 426         UnitStatusMessageFormats status_message_formats;
 427
 428         /* True if transient units of this type are OK */
 429         bool can_transient:1;
 430 };
 431
 432 extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];
 433
 434 #define UNIT_VTABLE(u) unit_vtable[(u)->type]
 435
 436 /* For casting a unit into the various unit types */
 437 #define DEFINE_CAST(UPPERCASE, MixedCase)                               \
 438         static inline MixedCase* UPPERCASE(Unit *u) {                   \
 439                 if (_unlikely_(!u || u->type != UNIT_##UPPERCASE))      \
 440                         return NULL;                                    \
 441                                                                         \
 442                 return (MixedCase*) u;                                  \
 443         }
 444
 445 /* For casting the various unit types into a unit */
 446 #define UNIT(u) (&(u)->meta)
 447
 448 #define UNIT_HAS_EXEC_CONTEXT(u) (UNIT_VTABLE(u)->exec_context_offset > 0)
 449 #define UNIT_HAS_CGROUP_CONTEXT(u) (UNIT_VTABLE(u)->cgroup_context_offset > 0)
 450 #define UNIT_HAS_KILL_CONTEXT(u) (UNIT_VTABLE(u)->kill_context_offset > 0)
 451
 452 #define UNIT_TRIGGER(u) ((Unit*) set_first((u)->dependencies[UNIT_TRIGGERS]))
 453
 454 DEFINE_CAST(SERVICE, Service);
 455 DEFINE_CAST(SOCKET, Socket);
 456 DEFINE_CAST(BUSNAME, BusName);
 457 DEFINE_CAST(TARGET, Target);
 458 DEFINE_CAST(DEVICE, Device);
 459 DEFINE_CAST(MOUNT, Mount);
 460 DEFINE_CAST(AUTOMOUNT, Automount);
 461 DEFINE_CAST(SWAP, Swap);
 462 DEFINE_CAST(TIMER, Timer);
 463 DEFINE_CAST(PATH, Path);
 464 DEFINE_CAST(SLICE, Slice);
 465 DEFINE_CAST(SCOPE, Scope);
 466
 467 Unit *unit_new(Manager *m, size_t size);
 468 void unit_free(Unit *u);
 469
 470 int unit_add_name(Unit *u, const char *name);
 471
 472 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference);
 473 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference);
 474
 475 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *filename, bool add_reference);
 476 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference);
 477
 478 int unit_add_exec_dependencies(Unit *u, ExecContext *c);
 479
 480 int unit_choose_id(Unit *u, const char *name);
 481 int unit_set_description(Unit *u, const char *description);
 482
 483 bool unit_check_gc(Unit *u);
 484
 485 void unit_add_to_load_queue(Unit *u);
 486 void unit_add_to_dbus_queue(Unit *u);
 487 void unit_add_to_cleanup_queue(Unit *u);
 488 void unit_add_to_gc_queue(Unit *u);
 489
 490 int unit_merge(Unit *u, Unit *other);
 491 int unit_merge_by_name(Unit *u, const char *other);
 492
 493 Unit *unit_follow_merge(Unit *u) _pure_;
 494
 495 int unit_load_fragment_and_dropin(Unit *u);
 496 int unit_load_fragment_and_dropin_optional(Unit *u);
 497 int unit_load(Unit *unit);
 498
 499 int unit_set_slice(Unit *u, Unit *slice);
 500 int unit_set_default_slice(Unit *u);
 501
 502 const char *unit_description(Unit *u) _pure_;
 503
 504 bool unit_has_name(Unit *u, const char *name);
 505
 506 UnitActiveState unit_active_state(Unit *u);
 507
 508 const char* unit_sub_state_to_string(Unit *u);
 509
 510 void unit_dump(Unit *u, FILE *f, const char *prefix);
 511
 512 bool unit_can_reload(Unit *u) _pure_;
 513 bool unit_can_start(Unit *u) _pure_;
 514 bool unit_can_isolate(Unit *u) _pure_;
 515
 516 int unit_start(Unit *u);
 517 int unit_stop(Unit *u);
 518 int unit_reload(Unit *u);
 519
 520 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error);
 521 int unit_kill_common(Unit *u, KillWho who, int signo, pid_t main_pid, pid_t control_pid, sd_bus_error *error);
 522
 523 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success);
 524
 525 int unit_watch_pid(Unit *u, pid_t pid);
 526 void unit_unwatch_pid(Unit *u, pid_t pid);
 527 void unit_unwatch_all_pids(Unit *u);
 528
 529 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2);
 530
 531 int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name);
 532 int unit_watch_bus_name(Unit *u, const char *name);
 533 void unit_unwatch_bus_name(Unit *u, const char *name);
 534
 535 bool unit_job_is_applicable(Unit *u, JobType j);
 536
 537 int set_unit_path(const char *p);
 538
 539 char *unit_dbus_path(Unit *u);
 540
 541 int unit_load_related_unit(Unit *u, const char *type, Unit **_found);
 542
 543 bool unit_can_serialize(Unit *u) _pure_;
 544
 545 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs);
 546 int unit_deserialize(Unit *u, FILE *f, FDSet *fds);
 547
 548 int unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value);
 549 int unit_serialize_item_escaped(Unit *u, FILE *f, const char *key, const char *value);
 550 int unit_serialize_item_fd(Unit *u, FILE *f, FDSet *fds, const char *key, int fd);
 551 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *value, ...) _printf_(4,5);
 552
 553 int unit_add_node_link(Unit *u, const char *what, bool wants, UnitDependency d);
 554
 555 int unit_coldplug(Unit *u);
 556
 557 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) _printf_(3, 0);
 558 void unit_status_emit_starting_stopping_reloading(Unit *u, JobType t);
 559
 560 bool unit_need_daemon_reload(Unit *u);
 561
 562 void unit_reset_failed(Unit *u);
 563
 564 Unit *unit_following(Unit *u);
 565 int unit_following_set(Unit *u, Set **s);
 566
 567 const char *unit_slice_name(Unit *u);
 568
 569 bool unit_stop_pending(Unit *u) _pure_;
 570 bool unit_inactive_or_pending(Unit *u) _pure_;
 571 bool unit_active_or_pending(Unit *u);
 572
 573 int unit_add_default_target_dependency(Unit *u, Unit *target);
 574
 575 void unit_start_on_failure(Unit *u);
 576 void unit_trigger_notify(Unit *u);
 577
 578 UnitFileState unit_get_unit_file_state(Unit *u);
 579 int unit_get_unit_file_preset(Unit *u);
 580
 581 Unit* unit_ref_set(UnitRef *ref, Unit *u);
 582 void unit_ref_unset(UnitRef *ref);
 583
 584 #define UNIT_DEREF(ref) ((ref).unit)
 585 #define UNIT_ISSET(ref) (!!(ref).unit)
 586
 587 int unit_patch_contexts(Unit *u);
 588
 589 ExecContext *unit_get_exec_context(Unit *u) _pure_;
 590 KillContext *unit_get_kill_context(Unit *u) _pure_;
 591 CGroupContext *unit_get_cgroup_context(Unit *u) _pure_;
 592
 593 ExecRuntime *unit_get_exec_runtime(Unit *u) _pure_;
 594
 595 int unit_setup_exec_runtime(Unit *u);
 596 int unit_setup_dynamic_creds(Unit *u);
 597
 598 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data);
 599 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) _printf_(4,5);
 600
 601 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data);
 602 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) _printf_(4,5);
 603
 604 int unit_kill_context(Unit *u, KillContext *c, KillOperation k, pid_t main_pid, pid_t control_pid, bool main_pid_alien);
 605
 606 int unit_make_transient(Unit *u);
 607
 608 int unit_require_mounts_for(Unit *u, const char *path);
 609
 610 bool unit_type_supported(UnitType t);
 611
 612 bool unit_is_pristine(Unit *u);
 613
 614 pid_t unit_control_pid(Unit *u);
 615 pid_t unit_main_pid(Unit *u);
 616
 617 static inline bool unit_supported(Unit *u) {
 618         return unit_type_supported(u->type);
 619 }
 620
 621 void unit_warn_if_dir_nonempty(Unit *u, const char* where);
 622 int unit_fail_if_symlink(Unit *u, const char* where);
 623
 624 int unit_start_limit_test(Unit *u);
 625
 626 /* Macros which append UNIT= or USER_UNIT= to the message */
 627
 628 #define log_unit_full(unit, level, error, ...)                          \
 629         ({                                                              \
 630                 Unit *_u = (unit);                                      \
 631                 _u ? log_object_internal(level, error, __FILE__, __LINE__, __func__, _u->manager->unit_log_field, _u->id, ##__VA_ARGS__) : \
 632                         log_internal(level, error, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
 633         })
 634
 635 #define log_unit_debug(unit, ...)   log_unit_full(unit, LOG_DEBUG, 0, ##__VA_ARGS__)
 636 #define log_unit_info(unit, ...)    log_unit_full(unit, LOG_INFO, 0, ##__VA_ARGS__)
 637 #define log_unit_notice(unit, ...)  log_unit_full(unit, LOG_NOTICE, 0, ##__VA_ARGS__)
 638 #define log_unit_warning(unit, ...) log_unit_full(unit, LOG_WARNING, 0, ##__VA_ARGS__)
 639 #define log_unit_error(unit, ...)   log_unit_full(unit, LOG_ERR, 0, ##__VA_ARGS__)
 640
 641 #define log_unit_debug_errno(unit, error, ...)   log_unit_full(unit, LOG_DEBUG, error, ##__VA_ARGS__)
 642 #define log_unit_info_errno(unit, error, ...)    log_unit_full(unit, LOG_INFO, error, ##__VA_ARGS__)
 643 #define log_unit_notice_errno(unit, error, ...)  log_unit_full(unit, LOG_NOTICE, error, ##__VA_ARGS__)
 644 #define log_unit_warning_errno(unit, error, ...) log_unit_full(unit, LOG_WARNING, error, ##__VA_ARGS__)
 645 #define log_unit_error_errno(unit, error, ...)   log_unit_full(unit, LOG_ERR, error, ##__VA_ARGS__)
 646
 647 #define LOG_UNIT_MESSAGE(unit, fmt, ...) "MESSAGE=%s: " fmt, (unit)->id, ##__VA_ARGS__
 648 #define LOG_UNIT_ID(unit) (unit)->manager->unit_log_format_string, (unit)->id