xref: /illumos-gate/usr/src/cmd/svc/configd/configd.h (revision 54d02241ceb89d90c765e528622d88f84f65dab3)
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 */
840