usr/src/cmd/svc/configd/configd.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Copyright (c) 2015, Joyent, Inc. All rights reserved.
  29  */
  30
  31 #ifndef _CONFIGD_H
  32 #define _CONFIGD_H
  33
  34 #include <bsm/adt.h>
  35 #include <door.h>
  36 #include <pthread.h>
  37 #include <synch.h>
  38 #include <string.h>
  39 #include <sys/types.h>
  40
  41 #include <libscf.h>
  42 #include <repcache_protocol.h>
  43 #include <libuutil.h>
  44
  45 #include <configd_exit.h>
  46
  47 #ifdef  __cplusplus
  48 extern "C" {
  49 #endif
  50
  51 /*
  52  * Lock order:
  53  *
  54  *      client lock
  55  *              iter locks, in ID order
  56  *              entity locks, in ID order
  57  *
  58  *              (any iter/entity locks)
  59  *                      backend locks (NORMAL, then NONPERSIST)
  60  *                              rc_node lock
  61  *                                      children's rc_node lock
  62  *                              cache bucket lock
  63  *                                      rc_node lock[*]
  64  *
  65  *      * only one node may be grabbed while holding a bucket lock
  66  *
  67  *      leaf locks:  (no other locks may be aquired while holding one)
  68  *              rc_pg_notify_lock
  69  *              rc_annotate_lock
  70  */
  71
  72 /*
  73  * Returns the minimum size for a structure of type 't' such
  74  * that it is safe to access field 'f'.
  75  */
  76 #define offsetofend(t, f)       (offsetof(t, f) + sizeof (((t *)0)->f))
  77
  78 /*
  79  * We want MUTEX_HELD, but we also want pthreads.  So we're stuck with this
  80  * for the native build, at least until the build machines can catch up
  81  * with the latest version of MUTEX_HELD() in <synch.h>.
  82  */
  83 #if defined(NATIVE_BUILD)
  84 #undef  MUTEX_HELD
  85 #define MUTEX_HELD(m)           _mutex_held((mutex_t *)(m))
  86 #endif
  87
  88 /*
  89  * Maximum levels of composition.
  90  */
  91 #define COMPOSITION_DEPTH       2
  92
  93 #define CONFIGD_CORE    "core.%f.%t.%p"
  94
  95 #define bad_error(f, e)                                                 \
  96         uu_panic("%s:%d: %s() returned bad error %d.  Aborting.\n",     \
  97             __FILE__, __LINE__, f, e);
  98
  99 typedef enum backend_type {
 100         BACKEND_TYPE_NORMAL             = 0,
 101         BACKEND_TYPE_NONPERSIST,
 102         BACKEND_TYPE_TOTAL                      /* backend use only */
 103 } backend_type_t;
 104
 105 /*
 106  * pre-declare rc_* types
 107  */
 108 typedef struct rc_node rc_node_t;
 109 typedef struct rc_snapshot rc_snapshot_t;
 110 typedef struct rc_snaplevel rc_snaplevel_t;
 111
 112 /*
 113  * notification layer -- protected by rc_pg_notify_lock
 114  */
 115 typedef struct rc_notify_info rc_notify_info_t;
 116 typedef struct rc_notify_delete rc_notify_delete_t;
 117
 118 #define RC_NOTIFY_MAX_NAMES     4       /* enough for now */
 119
 120 typedef struct rc_notify {
 121         uu_list_node_t  rcn_list_node;
 122         rc_node_t       *rcn_node;
 123         rc_notify_info_t *rcn_info;
 124         rc_notify_delete_t *rcn_delete;
 125 } rc_notify_t;
 126
 127 struct rc_notify_delete {
 128         rc_notify_t rnd_notify;
 129         char rnd_fmri[REP_PROTOCOL_FMRI_LEN];
 130 };
 131
 132 struct rc_notify_info {
 133         uu_list_node_t  rni_list_node;
 134         rc_notify_t     rni_notify;
 135         const char      *rni_namelist[RC_NOTIFY_MAX_NAMES];
 136         const char      *rni_typelist[RC_NOTIFY_MAX_NAMES];
 137
 138         int             rni_flags;
 139         int             rni_waiters;
 140         pthread_cond_t  rni_cv;
 141 };
 142 #define RC_NOTIFY_ACTIVE        0x00000001
 143 #define RC_NOTIFY_DRAIN         0x00000002
 144 #define RC_NOTIFY_EMPTYING      0x00000004
 145
 146 typedef struct rc_node_pg_notify {
 147         uu_list_node_t  rnpn_node;
 148         int             rnpn_fd;
 149         rc_node_t       *rnpn_pg;
 150 } rc_node_pg_notify_t;
 151
 152 /*
 153  * cache layer
 154  */
 155
 156 /*
 157  * The 'key' for the main object hash.  main_id is the main object
 158  * identifier.  The rl_ids array contains:
 159  *
 160  *      TYPE            RL_IDS
 161  *      scope           unused
 162  *      service         unused
 163  *      instance        {service_id}
 164  *      snapshot        {service_id, instance_id}
 165  *      snaplevel       {service_id, instance_id, name_id, snapshot_id}
 166  *      propertygroup   {service_id, (instance_id or 0), (name_id or 0),
 167  *                          (snapshot_id or 0), (l_id or 0)}
 168  *      property        {service_id, (instance_id or 0), (name_id or 0),
 169  *                          (snapshot_id or 0), (l_id or 0), pg_id, gen_id}
 170  */
 171 #define ID_SERVICE      0
 172 #define ID_INSTANCE     1
 173 #define ID_NAME         2
 174 #define ID_SNAPSHOT     3
 175 #define ID_LEVEL        4
 176 #define ID_PG           5
 177 #define ID_GEN          6
 178 #define MAX_IDS 7
 179 typedef struct rc_node_lookup {
 180         uint16_t        rl_type;                /* REP_PROTOCOL_ENTITY_* */
 181         uint16_t        rl_backend;             /* BACKEND_TYPE_* */
 182         uint32_t        rl_main_id;             /* primary identifier */
 183         uint32_t        rl_ids[MAX_IDS];        /* context */
 184 } rc_node_lookup_t;
 185
 186 struct rc_node {
 187         /*
 188          * read-only data
 189          */
 190         rc_node_lookup_t rn_id;                 /* must be first */
 191         uint32_t        rn_hash;
 192         const char      *rn_name;
 193
 194         /*
 195          * type-specific state
 196          * (if space becomes an issue, these can become a union)
 197          */
 198
 199         /*
 200          * Used by instances, snapshots, and "composed property groups" only.
 201          * These are the entities whose properties should appear composed when
 202          * this entity is traversed by a composed iterator.  0 is the top-most
 203          * entity, down to COMPOSITION_DEPTH - 1.
 204          */
 205         rc_node_t       *rn_cchain[COMPOSITION_DEPTH];
 206
 207         /*
 208          * used by property groups only
 209          */
 210         const char      *rn_type;
 211         uint32_t        rn_pgflags;
 212         uint32_t        rn_gen_id;
 213         uu_list_t       *rn_pg_notify_list;     /* prot by rc_pg_notify_lock */
 214         rc_notify_t     rn_notify;              /* prot by rc_pg_notify_lock */
 215
 216         /*
 217          * used by properties only
 218          */
 219         rep_protocol_value_type_t rn_valtype;
 220         const char      *rn_values;             /* protected by rn_lock */
 221         size_t          rn_values_count;        /* protected by rn_lock */
 222         size_t          rn_values_size;         /* protected by rn_lock */
 223
 224         /*
 225          * used by snapshots only
 226          */
 227         uint32_t        rn_snapshot_id;
 228         rc_snapshot_t   *rn_snapshot;           /* protected by rn_lock */
 229
 230         /*
 231          * used by snaplevels only
 232          */
 233         rc_snaplevel_t  *rn_snaplevel;
 234
 235         /*
 236          * mutable state
 237          */
 238         pthread_mutex_t rn_lock;
 239         pthread_cond_t  rn_cv;
 240         uint32_t        rn_flags;
 241         uint32_t        rn_refs;                /* client reference count */
 242         uint32_t        rn_erefs;               /* ephemeral ref count */
 243         uint32_t        rn_other_refs;          /* atomic refcount */
 244         uint32_t        rn_other_refs_held;     /* for 1->0 transitions */
 245
 246         uu_list_t       *rn_children;
 247         uu_list_node_t  rn_sibling_node;
 248
 249         rc_node_t       *rn_parent;             /* set if on child list */
 250         rc_node_t       *rn_former;             /* next former node */
 251         rc_node_t       *rn_parent_ref;         /* reference count target */
 252         const char      *rn_fmri;
 253
 254         /*
 255          * external state (protected by hash chain lock)
 256          */
 257         rc_node_t       *rn_hash_next;
 258 };
 259
 260 /*
 261  * flag ordering:
 262  *      RC_DYING
 263  *              RC_NODE_CHILDREN_CHANGING
 264  *              RC_NODE_CREATING_CHILD
 265  *              RC_NODE_USING_PARENT
 266  *                      RC_NODE_IN_TX
 267  *
 268  * RC_NODE_USING_PARENT is special, because it lets you proceed up the tree,
 269  * in the reverse of the usual locking order.  Because of this, there are
 270  * limitations on what you can do while holding it.  While holding
 271  * RC_NODE_USING_PARENT, you may:
 272  *      bump or release your parent's reference count
 273  *      access fields in your parent
 274  *      hold RC_NODE_USING_PARENT in the parent, proceeding recursively.
 275  *
 276  * If you are only holding *one* node's RC_NODE_USING_PARENT, and:
 277  *      you are *not* proceeding recursively, you can hold your
 278  *          immediate parent's RC_NODE_CHILDREN_CHANGING flag.
 279  *      you hold your parent's RC_NODE_CHILDREN_CHANGING flag, you can add
 280  *          RC_NODE_IN_TX to your flags.
 281  *      you want to grab a flag in your parent, you must lock your parent,
 282  *          lock yourself, drop RC_NODE_USING_PARENT, unlock yourself,
 283  *          then proceed to manipulate the parent.
 284  */
 285 #define RC_NODE_CHILDREN_CHANGING       0x00000001 /* child list in flux */
 286 #define RC_NODE_HAS_CHILDREN            0x00000002 /* child list is accurate */
 287
 288 #define RC_NODE_IN_PARENT               0x00000004 /* I'm in my parent's list */
 289 #define RC_NODE_USING_PARENT            0x00000008 /* parent ptr in use */
 290 #define RC_NODE_CREATING_CHILD          0x00000010 /* a create is in progress */
 291 #define RC_NODE_IN_TX                   0x00000020 /* a tx is in progess */
 292
 293 #define RC_NODE_OLD                     0x00000400 /* out-of-date object */
 294 #define RC_NODE_ON_FORMER               0x00000800 /* on an rn_former list */
 295
 296 #define RC_NODE_PARENT_REF              0x00001000 /* parent_ref in use */
 297 #define RC_NODE_UNREFED                 0x00002000 /* unref processing active */
 298 #define RC_NODE_DYING                   0x00004000 /* node is being deleted */
 299 #define RC_NODE_DEAD                    0x00008000 /* node has been deleted */
 300
 301 /*
 302  * RC_NODE_DEAD means that the node no longer represents data in the
 303  * backend, and we should return _DELETED errors to clients who try to use
 304  * it.  Very much like a zombie process.
 305  *
 306  * RC_NODE_OLD also means that the node no longer represents data in the
 307  * backend, but it's ok for clients to access it because we've loaded all of
 308  * the children.  (This only happens for transactional objects such as
 309  * property groups and snapshots, where we guarantee a stable view once
 310  * a reference is obtained.)  When all client references are destroyed,
 311  * however, the node should be destroyed.
 312  *
 313  * Though RC_NODE_DEAD is set by the rc_node_delete() code, it is also set
 314  * by rc_node_no_client_refs() for RC_NODE_OLD nodes not long before
 315  * they're destroyed.
 316  */
 317
 318 #define RC_NODE_DYING_FLAGS                                             \
 319         (RC_NODE_CHILDREN_CHANGING | RC_NODE_IN_TX | RC_NODE_DYING |    \
 320             RC_NODE_CREATING_CHILD)
 321
 322 #define RC_NODE_WAITING_FLAGS                                           \
 323         (RC_NODE_DYING_FLAGS | RC_NODE_USING_PARENT)
 324
 325
 326 #define NODE_LOCK(n)    (void) pthread_mutex_lock(&(n)->rn_lock)
 327 #define NODE_UNLOCK(n)  (void) pthread_mutex_unlock(&(n)->rn_lock)
 328
 329
 330 typedef enum rc_auth_state {
 331         RC_AUTH_UNKNOWN = 0,            /* No checks done yet. */
 332         RC_AUTH_FAILED,                 /* Authorization checked & failed. */
 333         RC_AUTH_PASSED                  /* Authorization succeeded. */
 334 } rc_auth_state_t;
 335
 336 /*
 337  * Some authorization checks are performed in rc_node_setup_tx() in
 338  * response to the REP_PROTOCOL_PROPERTYGRP_TX_START message.  Other checks
 339  * must wait until the actual transaction operations are received in the
 340  * REP_PROTOCOL_PROPERTYGRP_TX_COMMIT message.  This second set of checks
 341  * is performed in rc_tx_commit().  rnp_auth_string and rnp_authorized in
 342  * the following structure are used to hold the results of the
 343  * authorization checking done in rc_node_setup_tx() for later use by
 344  * rc_tx_commit().
 345  *
 346  * In client.c transactions are represented by rc_node_ptr structures which
 347  * point to a property group rc_node_t.  Thus, this is an appropriate place
 348  * to hold authorization state.
 349  */
 350 typedef struct rc_node_ptr {
 351         rc_node_t       *rnp_node;
 352         const char      *rnp_auth_string;       /* authorization string */
 353         rc_auth_state_t rnp_authorized;         /* transaction pre-auth rslt. */
 354         char            rnp_deleted;            /* object was deleted */
 355 } rc_node_ptr_t;
 356
 357 #define NODE_PTR_NOT_HELD(npp) \
 358             ((npp)->rnp_node == NULL || !MUTEX_HELD(&(npp)->rnp_node->rn_lock))
 359
 360 typedef int rc_iter_filter_func(rc_node_t *, void *);
 361
 362 typedef struct rc_node_iter {
 363         rc_node_t       *rni_parent;
 364         int             rni_clevel;     /* index into rni_parent->rn_cchain[] */
 365         rc_node_t       *rni_iter_node;
 366         uu_list_walk_t  *rni_iter;
 367         uint32_t        rni_type;
 368
 369         /*
 370          * for normal walks
 371          */
 372         rc_iter_filter_func *rni_filter;
 373         void            *rni_filter_arg;
 374
 375         /*
 376          * for value walks
 377          */
 378         uint32_t        rni_offset;             /* next value offset */
 379         uint32_t        rni_last_offset;        /* previous value offset */
 380 } rc_node_iter_t;
 381
 382 typedef struct rc_node_tx {
 383         rc_node_ptr_t   rnt_ptr;
 384         int             rnt_authorized;         /* No need to check anymore. */
 385 } rc_node_tx_t;
 386
 387
 388 typedef struct cache_bucket {
 389         pthread_mutex_t cb_lock;
 390         rc_node_t       *cb_head;
 391
 392         char            cb_pad[64 - sizeof (pthread_mutex_t) -
 393                             2 * sizeof (rc_node_t *)];
 394 } cache_bucket_t;
 395
 396 /*
 397  * tx_commit_data_tx is an opaque structure which is defined in object.c.
 398  * It contains the data of the transaction that is to be committed.
 399  * Accessor functions in object.c allow other modules to retrieve
 400  * information.
 401  */
 402 typedef struct tx_commit_data tx_commit_data_t;
 403
 404 /*
 405  * Snapshots
 406  */
 407 struct rc_snapshot {
 408         uint32_t        rs_snap_id;
 409
 410         pthread_mutex_t rs_lock;
 411         pthread_cond_t  rs_cv;
 412
 413         uint32_t        rs_flags;
 414         uint32_t        rs_refcnt;      /* references from rc_nodes */
 415         uint32_t        rs_childref;    /* references to children */
 416
 417         rc_snaplevel_t  *rs_levels;     /* list of levels */
 418         rc_snapshot_t   *rs_hash_next;
 419 };
 420 #define RC_SNAPSHOT_FILLING     0x00000001      /* rs_levels changing */
 421 #define RC_SNAPSHOT_READY       0x00000002
 422 #define RC_SNAPSHOT_DEAD        0x00000004      /* no resources */
 423
 424 typedef struct rc_snaplevel_pgs {
 425         uint32_t        rsp_pg_id;
 426         uint32_t        rsp_gen_id;
 427 } rc_snaplevel_pgs_t;
 428
 429 struct rc_snaplevel {
 430         rc_snapshot_t   *rsl_parent;
 431         uint32_t        rsl_level_num;
 432         uint32_t        rsl_level_id;
 433
 434         uint32_t        rsl_service_id;
 435         uint32_t        rsl_instance_id;
 436
 437         const char      *rsl_scope;
 438         const char      *rsl_service;
 439         const char      *rsl_instance;
 440
 441         rc_snaplevel_t  *rsl_next;
 442 };
 443
 444 /*
 445  * Client layer -- the IDs fields must be first, in order for the search
 446  * routines to work correctly.
 447  */
 448 enum repcache_txstate {
 449         REPCACHE_TX_INIT,
 450         REPCACHE_TX_SETUP,
 451         REPCACHE_TX_COMMITTED
 452 };
 453
 454 typedef struct repcache_entity {
 455         uint32_t        re_id;
 456         uu_avl_node_t   re_link;
 457         uint32_t        re_changeid;
 458
 459         pthread_mutex_t re_lock;
 460         uint32_t        re_type;
 461         rc_node_ptr_t   re_node;
 462         enum repcache_txstate re_txstate;       /* property groups only */
 463 } repcache_entity_t;
 464
 465 typedef struct repcache_iter {
 466         uint32_t        ri_id;
 467         uu_avl_node_t   ri_link;
 468
 469         uint32_t        ri_type;        /* result type */
 470
 471         pthread_mutex_t ri_lock;
 472         uint32_t        ri_sequence;
 473         rc_node_iter_t  *ri_iter;
 474 } repcache_iter_t;
 475
 476 typedef struct repcache_client {
 477         /*
 478          * constants
 479          */
 480         uint32_t        rc_id;          /* must be first */
 481         int             rc_all_auths;   /* bypass auth checks */
 482         uint32_t        rc_debug;       /* debug flags */
 483         pid_t           rc_pid;         /* pid of opening process */
 484         door_id_t       rc_doorid;      /* a globally unique identifier */
 485         int             rc_doorfd;      /* our door's FD */
 486
 487         /*
 488          * Constants used for security auditing
 489          *
 490          * rc_adt_session points to the audit session data that is used for
 491          * the life of the client.  rc_adt_sessionid is the session ID that
 492          * is initially assigned when the audit session is started.  See
 493          * start_audit_session() in client.c.  This session id is used for
 494          * audit events except when we are processing a set of annotated
 495          * events.  Annotated events use a separate session id so that they
 496          * can be grouped.  See set_annotation() in client.c.
 497          */
 498         adt_session_data_t *rc_adt_session;     /* Session data. */
 499         au_asid_t       rc_adt_sessionid;       /* Main session ID for */
 500                                                 /* auditing */
 501
 502         /*
 503          * client list linkage, protected by hash chain lock
 504          */
 505         uu_list_node_t  rc_link;
 506
 507         /*
 508          * notification information, protected by rc_node layer
 509          */
 510         rc_node_pg_notify_t     rc_pg_notify;
 511         rc_notify_info_t        rc_notify_info;
 512
 513         /*
 514          * client_wait output, only usable by rc_notify_thr
 515          */
 516         rc_node_ptr_t   rc_notify_ptr;
 517
 518         /*
 519          * register sets, protected by rc_lock
 520          */
 521         uu_avl_t        *rc_entities;
 522         uu_avl_t        *rc_iters;
 523
 524         /*
 525          * Variables, protected by rc_lock
 526          */
 527         int             rc_refcnt;      /* in-progress door calls */
 528         int             rc_flags;       /* see RC_CLIENT_* symbols below */
 529         uint32_t        rc_changeid;    /* used to make backups idempotent */
 530         pthread_t       rc_insert_thr;  /* single thread trying to insert */
 531         pthread_t       rc_notify_thr;  /* single thread waiting for notify */
 532         pthread_cond_t  rc_cv;
 533         pthread_mutex_t rc_lock;
 534
 535         /*
 536          * Per-client audit information.  These fields must be protected by
 537          * rc_annotate_lock separately from rc_lock because they may need
 538          * to be accessed from rc_node.c with an entity or iterator lock
 539          * held, and those must be taken after rc_lock.
 540          */
 541         int             rc_annotate;    /* generate annotation event if set */
 542         const char      *rc_operation;  /* operation for audit annotation */
 543         const char      *rc_file;       /* file name for audit annotation */
 544         pthread_mutex_t rc_annotate_lock;
 545 } repcache_client_t;
 546
 547 /* Bit definitions for rc_flags. */
 548 #define RC_CLIENT_DEAD                  0x00000001
 549
 550 typedef struct client_bucket {
 551         pthread_mutex_t cb_lock;
 552         uu_list_t       *cb_list;
 553         char ch_pad[64 - sizeof (pthread_mutex_t) - sizeof (uu_list_t *)];
 554 } client_bucket_t;
 555
 556 enum rc_ptr_type {
 557         RC_PTR_TYPE_ENTITY = 1,
 558         RC_PTR_TYPE_ITER
 559 };
 560
 561 typedef struct request_log_ptr {
 562         enum rc_ptr_type        rlp_type;
 563         uint32_t                rlp_id;
 564         void                    *rlp_ptr; /* repcache_{entity,iter}_t */
 565         void                    *rlp_data;      /* rc_node, for ENTITY only */
 566 } request_log_ptr_t;
 567
 568 #define MAX_PTRS        3
 569
 570 /*
 571  * rl_start through rl_client cannot move without changing start_log()
 572  */
 573 typedef struct request_log_entry {
 574         hrtime_t                rl_start;
 575         hrtime_t                rl_end;
 576         pthread_t               rl_tid;
 577         uint32_t                rl_clientid;
 578         repcache_client_t       *rl_client;
 579         enum rep_protocol_requestid rl_request;
 580         rep_protocol_responseid_t rl_response;
 581         int                     rl_num_ptrs;
 582         request_log_ptr_t       rl_ptrs[MAX_PTRS];
 583 } request_log_entry_t;
 584
 585 /*
 586  * thread information
 587  */
 588 typedef enum thread_state {
 589         TI_CREATED,
 590         TI_DOOR_RETURN,
 591         TI_SIGNAL_WAIT,
 592         TI_MAIN_DOOR_CALL,
 593         TI_CLIENT_CALL
 594 } thread_state_t;
 595
 596 typedef struct thread_info {
 597         pthread_t       ti_thread;
 598         uu_list_node_t  ti_node;                /* for list of all thread */
 599
 600         /*
 601          * per-thread globals
 602          */
 603         ucred_t         *ti_ucred;              /* for credential lookups */
 604         int             ti_ucred_read;          /* ucred holds current creds */
 605
 606         /*
 607          * per-thread state information, for debuggers
 608          */
 609         hrtime_t        ti_lastchange;
 610
 611         thread_state_t  ti_state;
 612         thread_state_t  ti_prev_state;
 613
 614         repcache_client_t *ti_active_client;
 615         request_log_entry_t     ti_log;
 616
 617         struct rep_protocol_request *ti_client_request;
 618         repository_door_request_t *ti_main_door_request;
 619
 620 } thread_info_t;
 621
 622 /*
 623  * Backend layer
 624  */
 625 typedef struct backend_query backend_query_t;
 626 typedef struct backend_tx backend_tx_t;
 627
 628 /*
 629  * configd.c
 630  */
 631 int create_connection(ucred_t *cred, repository_door_request_t *rp,
 632     size_t rp_size, int *out_fd);
 633
 634 thread_info_t *thread_self(void);
 635 void thread_newstate(thread_info_t *, thread_state_t);
 636 ucred_t *get_ucred(void);
 637 int ucred_is_privileged(ucred_t *);
 638
 639 adt_session_data_t *get_audit_session(void);
 640
 641 void configd_critical(const char *, ...);
 642 void configd_vcritical(const char *, va_list);
 643 void configd_info(const char *, ...);
 644
 645 extern int is_main_repository;
 646 extern int max_repository_backups;
 647
 648 /*
 649  * maindoor.c
 650  */
 651 int setup_main_door(const char *);
 652
 653 /*
 654  * client.c
 655  */
 656 int client_annotation_needed(char *, size_t, char *, size_t);
 657 void client_annotation_finished(void);
 658 int create_client(pid_t, uint32_t, int, int *);
 659 int client_init(void);
 660 int client_is_privileged(void);
 661 void log_enter(request_log_entry_t *);
 662
 663 /*
 664  * rc_node.c, backend/cache interfaces (rc_node_t)
 665  */
 666 int rc_node_init();
 667 int rc_check_type_name(uint32_t, const char *);
 668
 669 void rc_node_ptr_free_mem(rc_node_ptr_t *);
 670 void rc_node_rele(rc_node_t *);
 671 rc_node_t *rc_node_setup(rc_node_t *, rc_node_lookup_t *,
 672     const char *, rc_node_t *);
 673 rc_node_t *rc_node_setup_pg(rc_node_t *, rc_node_lookup_t *, const char *,
 674     const char *, uint32_t, uint32_t, rc_node_t *);
 675 rc_node_t *rc_node_setup_snapshot(rc_node_t *, rc_node_lookup_t *, const char *,
 676     uint32_t, rc_node_t *);
 677 rc_node_t *rc_node_setup_snaplevel(rc_node_t *, rc_node_lookup_t *,
 678     rc_snaplevel_t *, rc_node_t *);
 679 int rc_node_create_property(rc_node_t *, rc_node_lookup_t *,
 680     const char *, rep_protocol_value_type_t, const char *, size_t, size_t);
 681
 682 rc_node_t *rc_node_alloc(void);
 683 void rc_node_destroy(rc_node_t *);
 684
 685 /*
 686  * rc_node.c, client interface (rc_node_ptr_t, rc_node_iter_t)
 687  */
 688 void rc_node_ptr_init(rc_node_ptr_t *);
 689 int rc_local_scope(uint32_t, rc_node_ptr_t *);
 690
 691 void rc_node_clear(rc_node_ptr_t *, int);
 692 void rc_node_ptr_assign(rc_node_ptr_t *, const rc_node_ptr_t *);
 693 int rc_node_name(rc_node_ptr_t *, char *, size_t, uint32_t, size_t *);
 694 int rc_node_fmri(rc_node_ptr_t *, char *, size_t, size_t *);
 695 int rc_node_parent_type(rc_node_ptr_t *, uint32_t *);
 696 int rc_node_get_child(rc_node_ptr_t *, const char *, uint32_t, rc_node_ptr_t *);
 697 int rc_node_get_parent(rc_node_ptr_t *, uint32_t, rc_node_ptr_t *);
 698 int rc_node_get_property_type(rc_node_ptr_t *, rep_protocol_value_type_t *);
 699 int rc_node_get_property_value(rc_node_ptr_t *,
 700     struct rep_protocol_value_response *, size_t *);
 701 int rc_node_create_child(rc_node_ptr_t *, uint32_t, const char *,
 702     rc_node_ptr_t *);
 703 int rc_node_create_child_pg(rc_node_ptr_t *, uint32_t, const char *,
 704     const char *, uint32_t, rc_node_ptr_t *);
 705 int rc_node_update(rc_node_ptr_t *);
 706 int rc_node_delete(rc_node_ptr_t *);
 707 int rc_node_next_snaplevel(rc_node_ptr_t *, rc_node_ptr_t *);
 708
 709 int rc_node_setup_iter(rc_node_ptr_t *, rc_node_iter_t **, uint32_t,
 710     size_t, const char *);
 711
 712 int rc_iter_next(rc_node_iter_t *, rc_node_ptr_t *, uint32_t);
 713 int rc_iter_next_value(rc_node_iter_t *, struct rep_protocol_value_response *,
 714     size_t *, int);
 715 void rc_iter_destroy(rc_node_iter_t **);
 716
 717 int rc_node_setup_tx(rc_node_ptr_t *, rc_node_ptr_t *);
 718 int rc_tx_commit(rc_node_ptr_t *, const void *, size_t);
 719
 720 void rc_pg_notify_init(rc_node_pg_notify_t *);
 721 int rc_pg_notify_setup(rc_node_pg_notify_t *, rc_node_ptr_t *, int);
 722 void rc_pg_notify_fini(rc_node_pg_notify_t *);
 723
 724 void rc_notify_info_init(rc_notify_info_t *);
 725 int rc_notify_info_add_name(rc_notify_info_t *, const char *);
 726 int rc_notify_info_add_type(rc_notify_info_t *, const char *);
 727 int rc_notify_info_wait(rc_notify_info_t *, rc_node_ptr_t *, char *, size_t);
 728 void rc_notify_info_fini(rc_notify_info_t *);
 729
 730 int rc_snapshot_take_new(rc_node_ptr_t *, const char *,
 731     const char *, const char *, rc_node_ptr_t *);
 732 int rc_snapshot_take_attach(rc_node_ptr_t *, rc_node_ptr_t *);
 733 int rc_snapshot_attach(rc_node_ptr_t *, rc_node_ptr_t *);
 734
 735 /*
 736  * file_object.c
 737  */
 738 int object_fill_children(rc_node_t *);
 739 int object_create(rc_node_t *, uint32_t, const char *, rc_node_t **);
 740 int object_create_pg(rc_node_t *, uint32_t, const char *, const char *,
 741     uint32_t, rc_node_t **);
 742
 743 int object_delete(rc_node_t *);
 744 void object_free_values(const char *, uint32_t, size_t, size_t);
 745
 746 int object_fill_snapshot(rc_snapshot_t *);
 747
 748 int object_snapshot_take_new(rc_node_t *, const char *, const char *,
 749     const char *, rc_node_t **);
 750 int object_snapshot_attach(rc_node_lookup_t *, uint32_t *, int);
 751
 752 /*
 753  * object.c
 754  */
 755 int object_tx_commit(rc_node_lookup_t *, tx_commit_data_t *, uint32_t *);
 756
 757 /* Functions to access transaction commands. */
 758 int tx_cmd_action(tx_commit_data_t *, size_t,
 759     enum rep_protocol_transaction_action *);
 760 size_t tx_cmd_count(tx_commit_data_t *);
 761 int tx_cmd_nvalues(tx_commit_data_t *, size_t, uint32_t *);
 762 int tx_cmd_prop(tx_commit_data_t *, size_t, const char **);
 763 int tx_cmd_prop_type(tx_commit_data_t *, size_t, uint32_t *);
 764 int tx_cmd_value(tx_commit_data_t *, size_t, uint32_t, const char **);
 765 void tx_commit_data_free(tx_commit_data_t *);
 766 int tx_commit_data_new(const void *, size_t, tx_commit_data_t **);
 767
 768 /*
 769  * snapshot.c
 770  */
 771 int rc_snapshot_get(uint32_t, rc_snapshot_t **);
 772 void rc_snapshot_rele(rc_snapshot_t *);
 773 void rc_snaplevel_hold(rc_snaplevel_t *);
 774 void rc_snaplevel_rele(rc_snaplevel_t *);
 775
 776 /*
 777  * backend.c
 778  */
 779 int backend_init(const char *, const char *, int);
 780 boolean_t backend_is_upgraded(backend_tx_t *);
 781 void backend_fini(void);
 782
 783 rep_protocol_responseid_t backend_create_backup(const char *);
 784 rep_protocol_responseid_t backend_switch(int);
 785
 786 /*
 787  * call on any database inconsistency -- cleans up state as best it can,
 788  * and exits with a "Database Bad" error code.
 789  */
 790 void backend_panic(const char *, ...) __NORETURN;
 791 #pragma rarely_called(backend_panic)
 792
 793 backend_query_t *backend_query_alloc(void);
 794 void backend_query_append(backend_query_t *, const char *);
 795 void backend_query_add(backend_query_t *, const char *, ...);
 796 void backend_query_free(backend_query_t *);
 797
 798 typedef int backend_run_callback_f(void *data, int columns, char **vals,
 799     char **names);
 800 #define BACKEND_CALLBACK_CONTINUE       0
 801 #define BACKEND_CALLBACK_ABORT          1
 802
 803 backend_run_callback_f backend_fail_if_seen;    /* aborts TX if called */
 804
 805 int backend_run(backend_type_t, backend_query_t *,
 806     backend_run_callback_f *, void *);
 807
 808 int backend_tx_begin(backend_type_t, backend_tx_t **);
 809 int backend_tx_begin_ro(backend_type_t, backend_tx_t **);
 810 void backend_tx_end_ro(backend_tx_t *);
 811
 812 enum id_space {
 813         BACKEND_ID_SERVICE_INSTANCE,
 814         BACKEND_ID_PROPERTYGRP,
 815         BACKEND_ID_GENERATION,
 816         BACKEND_ID_PROPERTY,
 817         BACKEND_ID_VALUE,
 818         BACKEND_ID_SNAPNAME,
 819         BACKEND_ID_SNAPSHOT,
 820         BACKEND_ID_SNAPLEVEL,
 821         BACKEND_ID_INVALID      /* always illegal */
 822 };
 823
 824 uint32_t backend_new_id(backend_tx_t *, enum id_space);
 825 int backend_tx_run_update(backend_tx_t *, const char *, ...);
 826 int backend_tx_run_update_changed(backend_tx_t *, const char *, ...);
 827 int backend_tx_run_single_int(backend_tx_t *tx, backend_query_t *q,
 828     uint32_t *buf);
 829 int backend_tx_run(backend_tx_t *, backend_query_t *,
 830     backend_run_callback_f *, void *);
 831
 832 int backend_tx_commit(backend_tx_t *);
 833 void backend_tx_rollback(backend_tx_t *);
 834
 835 #ifdef  __cplusplus
 836 }
 837 #endif
 838
 839 #endif  /* _CONFIGD_H */