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 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #ifndef _STARTD_H 27 #define _STARTD_H 28 29 #pragma ident "%Z%%M% %I% %E% SMI" 30 31 #include <sys/time.h> 32 #include <librestart.h> 33 #include <librestart_priv.h> 34 #include <libscf.h> 35 #include <libsysevent.h> 36 #include <libuutil.h> 37 #include <pthread.h> 38 #include <stdio.h> 39 #include <syslog.h> 40 #include <umem.h> 41 42 #ifdef __cplusplus 43 extern "C" { 44 #endif 45 46 /* 47 * We want MUTEX_HELD, but we also want pthreads. So we're stuck with this. 48 */ 49 #define PTHREAD_MUTEX_HELD(m) _mutex_held((struct _lwp_mutex *)(m)) 50 51 #ifndef NDEBUG 52 53 #define MUTEX_LOCK(mp) { \ 54 int err; \ 55 if ((err = pthread_mutex_lock((mp))) != 0) { \ 56 (void) fprintf(stderr, \ 57 "pthread_mutex_lock() failed on %s:%d: %s\n", \ 58 __FILE__, __LINE__, strerror(err)); \ 59 abort(); \ 60 } \ 61 } 62 63 #define MUTEX_UNLOCK(mp) { \ 64 int err; \ 65 if ((err = pthread_mutex_unlock((mp))) != 0) { \ 66 (void) fprintf(stderr, \ 67 "pthread_mutex_unlock() failed on %s:%d: %s\n", \ 68 __FILE__, __LINE__, strerror(err)); \ 69 abort(); \ 70 } \ 71 } 72 73 #else 74 75 #define MUTEX_LOCK(mp) (void) pthread_mutex_lock((mp)) 76 #define MUTEX_UNLOCK(mp) (void) pthread_mutex_unlock((mp)) 77 78 #endif 79 80 #ifndef NDEBUG 81 #define bad_error(func, err) { \ 82 (void) fprintf(stderr, "%s:%d: %s() failed with unexpected " \ 83 "error %d. Aborting.\n", __FILE__, __LINE__, (func), (err)); \ 84 abort(); \ 85 } 86 #else 87 #define bad_error(func, err) abort() 88 #endif 89 90 91 #define min(a, b) (((a) < (b)) ? (a) : (b)) 92 93 #define FAULT_COUNT_INCR 0 94 #define FAULT_COUNT_RESET 1 95 96 #define FAULT_THRESHOLD 3 97 98 #define MAX_CONFIGD_RETRIES 5 99 #define MAX_MOUNT_RETRIES 5 100 #define MAX_SULOGIN_RETRIES 5 101 102 #define RETURN_SUCCESS 0 103 #define RETURN_RETRY -1 104 #define RETURN_FATAL -2 105 106 #define LIBSCF_SUCCESS 0 107 #define LIBSCF_PROPERTY_ABSENT -1 108 #define LIBSCF_PGROUP_ABSENT -2 109 #define LIBSCF_PROPERTY_ERROR -3 110 111 #define METHOD_START 0 112 #define METHOD_STOP 1 113 #define METHOD_REFRESH 2 114 115 #define METHOD_TIMEOUT_INFINITE 0 116 117 /* 118 * Contract cookies used by startd. 119 */ 120 #define CONFIGD_COOKIE 0x10 121 #define SULOGIN_COOKIE 0x11 122 #define METHOD_START_COOKIE 0x20 123 #define METHOD_OTHER_COOKIE 0x21 124 #define MONITOR_COOKIE 0x30 125 126 127 #define ALLOC_RETRY 3 128 #define ALLOC_DELAY 10 129 #define ALLOC_DELAY_MULT 10 130 131 #define safe_scf_scope_create(h) \ 132 libscf_object_create((void *(*)(scf_handle_t *))scf_scope_create, (h)) 133 #define safe_scf_service_create(h) \ 134 libscf_object_create((void *(*)(scf_handle_t *))scf_service_create, (h)) 135 #define safe_scf_instance_create(h) libscf_object_create( \ 136 (void *(*)(scf_handle_t *))scf_instance_create, (h)) 137 #define safe_scf_snapshot_create(h) libscf_object_create( \ 138 (void *(*)(scf_handle_t *))scf_snapshot_create, (h)) 139 #define safe_scf_snaplevel_create(h) libscf_object_create( \ 140 (void *(*)(scf_handle_t *))scf_snaplevel_create, (h)) 141 #define safe_scf_pg_create(h) \ 142 libscf_object_create((void *(*)(scf_handle_t *))scf_pg_create, (h)) 143 #define safe_scf_property_create(h) libscf_object_create( \ 144 (void *(*)(scf_handle_t *))scf_property_create, (h)) 145 #define safe_scf_value_create(h) \ 146 libscf_object_create((void *(*)(scf_handle_t *))scf_value_create, (h)) 147 #define safe_scf_iter_create(h) \ 148 libscf_object_create((void *(*)(scf_handle_t *))scf_iter_create, (h)) 149 #define safe_scf_transaction_create(h) libscf_object_create( \ 150 (void *(*)(scf_handle_t *)) scf_transaction_create, (h)) 151 #define safe_scf_entry_create(h) \ 152 libscf_object_create((void *(*)(scf_handle_t *))scf_entry_create, (h)) 153 154 #define startd_alloc(sz) \ 155 startd_alloc_retry((void *(*)(size_t, int))umem_alloc, (sz)) 156 #define startd_zalloc(sz) \ 157 startd_alloc_retry((void *(*)(size_t, int))umem_zalloc, (sz)) 158 159 160 extern pthread_mutexattr_t mutex_attrs; 161 162 /* 163 * Definitions for administrative actions. 164 * Note that the ordering in admin_action_t, admin_actions, and admin_events 165 * must match. admin_actions and admin_events are defined in startd.c. 166 */ 167 #define NACTIONS 6 168 169 typedef enum { 170 ADMIN_EVENT_DEGRADED = 0x0, 171 ADMIN_EVENT_MAINT_OFF, 172 ADMIN_EVENT_MAINT_ON, 173 ADMIN_EVENT_MAINT_ON_IMMEDIATE, 174 ADMIN_EVENT_REFRESH, 175 ADMIN_EVENT_RESTART 176 } admin_action_t; 177 178 extern const char * const admin_actions[NACTIONS]; 179 extern const int admin_events[NACTIONS]; 180 181 #define LOG_DATE_SIZE 32 /* Max size of timestamp in log output */ 182 183 extern ssize_t max_scf_name_size; 184 extern ssize_t max_scf_value_size; 185 extern ssize_t max_scf_fmri_size; 186 187 extern mode_t fmask; 188 extern mode_t dmask; 189 190 #define LOG_PREFIX_EARLY "/etc/svc/volatile/" 191 #define LOG_PREFIX_NORMAL "/var/svc/log/" 192 193 #define LOG_SUFFIX ".log" 194 195 #define STARTD_DEFAULT_LOG "svc.startd.log" 196 197 extern const char *log_directory; /* Current log directory path */ 198 199 #define FS_TIMEZONE_DIR "/usr/share/lib/zoneinfo" 200 #define FS_LOCALE_DIR "/usr/lib/locale" 201 202 /* 203 * Simple dictionary representation. 204 */ 205 typedef struct dictionary { 206 uu_list_t *dict_list; 207 int dict_new_id; 208 pthread_mutex_t dict_lock; 209 } dictionary_t; 210 211 typedef struct dict_entry { 212 int de_id; 213 const char *de_name; 214 uu_list_node_t de_link; 215 } dict_entry_t; 216 217 extern dictionary_t *dictionary; 218 219 typedef struct timeout_queue { 220 uu_list_t *tq_list; 221 pthread_mutex_t tq_lock; 222 } timeout_queue_t; 223 224 typedef struct timeout_entry { 225 hrtime_t te_timeout; /* timeout expiration time */ 226 ctid_t te_ctid; 227 char *te_fmri; 228 char *te_logstem; 229 volatile int te_fired; 230 uu_list_node_t te_link; 231 } timeout_entry_t; 232 233 extern timeout_queue_t *timeouts; 234 235 /* 236 * State definitions. 237 */ 238 typedef enum { 239 STATE_NONE = 0x0, 240 STATE_UNINIT, 241 STATE_MAINT, 242 STATE_OFFLINE, 243 STATE_DISABLED, 244 STATE_ONLINE, 245 STATE_DEGRADED 246 } instance_state_t; 247 248 #define STATE_MAX (STATE_DEGRADED + 1) 249 250 extern const char * const instance_state_str[STATE_MAX]; 251 252 typedef enum { 253 GVT_UNSUPPORTED = -1, 254 GVT_UNKNOWN = 0, 255 GVT_SVC, /* service */ 256 GVT_INST, /* instance */ 257 GVT_FILE, /* file: */ 258 GVT_GROUP /* dependency group */ 259 } gv_type_t; 260 261 typedef enum { 262 DEPGRP_UNSUPPORTED = -1, 263 DEPGRP_REQUIRE_ANY = 1, 264 DEPGRP_REQUIRE_ALL, 265 DEPGRP_EXCLUDE_ALL, 266 DEPGRP_OPTIONAL_ALL 267 } depgroup_type_t; 268 269 typedef enum { 270 METHOD_RESTART_UNKNOWN = -1, 271 METHOD_RESTART_ALL = 0, 272 METHOD_RESTART_EXTERNAL_FAULT, 273 METHOD_RESTART_ANY_FAULT, 274 METHOD_RESTART_OTHER 275 } method_restart_t; 276 277 typedef enum { 278 PROPAGATE_START, 279 PROPAGATE_STOP, 280 PROPAGATE_SAT 281 } propagate_event_t; 282 283 /* 284 * Graph representation. 285 */ 286 #define GV_CONFIGURED 0x01 /* Service exists in repository, ready */ 287 #define GV_ENABLED 0x02 /* Service should be online */ 288 #define GV_ENBLD_NOOVR 0x04 /* GV_ENABLED, ignoring override */ 289 #define GV_INSUBGRAPH 0x08 /* Current milestone depends on service */ 290 291 /* ID must come first to support search */ 292 typedef struct graph_vertex { 293 int gv_id; 294 char *gv_name; 295 uu_list_node_t gv_link; 296 297 uint_t gv_flags; 298 restarter_instance_state_t gv_state; 299 300 gv_type_t gv_type; 301 302 depgroup_type_t gv_depgroup; 303 restarter_error_t gv_restart; 304 305 void (*gv_start_f)(struct graph_vertex *); 306 void (*gv_post_online_f)(void); 307 void (*gv_post_disable_f)(void); 308 309 int gv_restarter_id; 310 evchan_t *gv_restarter_channel; 311 312 int gv_delegate_initialized; 313 evchan_t *gv_delegate_channel; 314 315 uu_list_t *gv_dependencies; 316 uu_list_t *gv_dependents; 317 318 /* 319 * gv_refs represents the number of references besides dependencies. 320 * The vertex cannot be removed when gv_refs > 0. 321 * 322 * Currently, only relevant for GVT_SVC and GVT_INST type vertices. 323 */ 324 int gv_refs; 325 } graph_vertex_t; 326 327 typedef struct graph_edge { 328 graph_vertex_t *ge_vertex; 329 uu_list_node_t ge_link; 330 graph_vertex_t *ge_parent; 331 } graph_edge_t; 332 333 /* 334 * Restarter transition outcomes 335 */ 336 typedef enum { 337 MAINT_REQUESTED, 338 START_REQUESTED, 339 START_FAILED_REPEATEDLY, 340 START_FAILED_CONFIGURATION, 341 START_FAILED_FATAL, 342 START_FAILED_TIMEOUT_FATAL, 343 START_FAILED_OTHER 344 } start_outcome_t; 345 346 typedef void (*instance_hook_t)(void); 347 348 typedef struct service_hook_assn { 349 char *sh_fmri; 350 instance_hook_t sh_pre_online_hook; 351 instance_hook_t sh_post_online_hook; 352 instance_hook_t sh_post_offline_hook; 353 } service_hook_assn_t; 354 355 /* 356 * Restarter instance stop reasons. 357 */ 358 typedef enum { 359 RSTOP_EXIT = 0x0, /* exited or empty */ 360 RSTOP_CORE, /* core dumped */ 361 RSTOP_SIGNAL, /* external fatal signal received */ 362 RSTOP_HWERR, /* uncorrectable hardware error */ 363 RSTOP_DEPENDENCY, /* dependency activity caused stop */ 364 RSTOP_DISABLE, /* disabled */ 365 RSTOP_RESTART /* restart requested */ 366 } stop_cause_t; 367 368 /* 369 * Restarter instance maintenance clear reasons. 370 */ 371 typedef enum { 372 RUNMAINT_CLEAR = 0x0, 373 RUNMAINT_DISABLE 374 } unmaint_cause_t; 375 376 /* 377 * Restarter instance flags 378 */ 379 #define RINST_CONTRACT 0x00000000 /* progeny constitute inst */ 380 #define RINST_TRANSIENT 0x10000000 /* inst operates momentarily */ 381 #define RINST_WAIT 0x20000000 /* child constitutes inst */ 382 #define RINST_STYLE_MASK 0xf0000000 383 384 #define RINST_RETAKE_RUNNING 0x01000000 /* pending running snapshot */ 385 #define RINST_RETAKE_START 0x02000000 /* pending start snapshot */ 386 387 #define RINST_RETAKE_MASK 0x0f000000 388 389 #define RINST_START_TIMES 10 /* failures to consider */ 390 #define RINST_FAILURE_RATE_NS 1000000000LL /* 1 failure/second */ 391 392 /* Number of events in the queue when we start dropping ADMIN events. */ 393 #define RINST_QUEUE_THRESHOLD 100 394 395 typedef struct restarter_inst { 396 int ri_id; 397 instance_data_t ri_i; 398 char *ri_common_name; /* template localized name */ 399 char *ri_C_common_name; /* C locale name */ 400 401 char *ri_logstem; /* logfile name */ 402 char *ri_utmpx_prefix; 403 uint_t ri_flags; 404 instance_hook_t ri_pre_online_hook; 405 instance_hook_t ri_post_online_hook; 406 instance_hook_t ri_post_offline_hook; 407 408 hrtime_t ri_start_time[RINST_START_TIMES]; 409 uint_t ri_start_index; /* times started */ 410 411 uu_list_node_t ri_link; 412 pthread_mutex_t ri_lock; 413 414 /* 415 * When we start a thread to we execute a method for this instance, we 416 * put the thread id in ri_method_thread. Threads with ids other than 417 * this which acquire ri_lock while ri_method_thread is nonzero should 418 * wait on ri_method_cv. ri_method_waiters should be incremented while 419 * waiting so the instance won't be deleted. 420 */ 421 pthread_t ri_method_thread; 422 pthread_cond_t ri_method_cv; 423 uint_t ri_method_waiters; 424 425 /* 426 * These fields are provided so functions can operate on this structure 427 * and the repository without worrying about whether the instance has 428 * been deleted from the repository (this is possible because 429 * ri_i.i_fmri names the instance this structure represents -- see 430 * libscf_reget_inst()). ri_m_inst is the scf_instance_t for the 431 * instance, and ri_mi_deleted is true if the instance has been deleted. 432 */ 433 scf_instance_t *ri_m_inst; 434 boolean_t ri_mi_deleted; 435 436 /* 437 * We maintain a pointer to any pending timeout for this instance 438 * for quick reference/deletion. 439 */ 440 timeout_entry_t *ri_timeout; 441 442 /* 443 * Instance event queue. Graph events are queued here as a list 444 * of restarter_instance_qentry_t's, and the lock is held separately. 445 * If both ri_lock and ri_queue_lock are grabbed, ri_lock must be 446 * grabbed first. ri_queue_lock protects all ri_queue_* structure 447 * members. 448 */ 449 pthread_mutex_t ri_queue_lock; 450 pthread_cond_t ri_queue_cv; 451 uu_list_t *ri_queue; 452 int ri_queue_thread; 453 454 } restarter_inst_t; 455 456 typedef struct restarter_instance_list { 457 uu_list_t *ril_instance_list; 458 pthread_mutex_t ril_lock; 459 } restarter_instance_list_t; 460 461 typedef struct restarter_instance_qentry { 462 restarter_event_type_t riq_type; 463 uu_list_node_t riq_link; 464 } restarter_instance_qentry_t; 465 466 typedef struct fork_info { 467 int sf_id; 468 int sf_method_type; 469 restarter_error_t sf_event_type; 470 } fork_info_t; 471 472 typedef struct wait_info { 473 uu_list_node_t wi_link; 474 475 int wi_fd; /* psinfo file descriptor */ 476 id_t wi_pid; /* process ID */ 477 const char *wi_fmri; /* instance FMRI */ 478 int wi_parent; /* startd is parent */ 479 } wait_info_t; 480 481 #define STARTD_LOG_FILE 0x1 482 #define STARTD_LOG_TERMINAL 0x2 483 #define STARTD_LOG_SYSLOG 0x4 484 485 #define STARTD_BOOT_QUIET 0x1 486 #define STARTD_BOOT_VERBOSE 0x2 487 488 typedef struct startd_state { 489 /* Logging configuration */ 490 char *st_log_prefix; /* directory prefix */ 491 char *st_log_file; /* startd file in above dir */ 492 uint_t st_log_flags; /* message destination */ 493 int st_log_level_min; /* minimum required to log */ 494 int st_log_timezone_known; /* timezone is available */ 495 int st_log_locale_known; /* locale is available */ 496 int st_log_login_reached; /* login service reached */ 497 498 /* Boot configuration */ 499 uint_t st_boot_flags; /* serial boot, etc. */ 500 uint_t st_initial; /* first startd on system */ 501 502 /* System configuration */ 503 char *st_subgraph; /* milestone subgraph request */ 504 505 uint_t st_load_complete; /* graph load completed */ 506 uint_t st_load_instances; /* restarter instances to load */ 507 pthread_mutex_t st_load_lock; 508 pthread_cond_t st_load_cv; 509 510 /* Repository configuration */ 511 pid_t st_configd_pid; /* PID of our svc.configd */ 512 /* instance */ 513 int st_configd_lives; /* configd started */ 514 pthread_mutex_t st_configd_live_lock; 515 pthread_cond_t st_configd_live_cv; 516 517 char *st_door_path; 518 519 /* General information */ 520 uint_t st_flags; 521 struct timeval st_start_time; /* effective system start time */ 522 char *st_locale; 523 } startd_state_t; 524 525 extern startd_state_t *st; 526 527 extern boolean_t booting_to_single_user; 528 529 extern const char *event_names[]; 530 531 /* 532 * Structures for contract to instance hash table, implemented in 533 * contract.c and used by restarter.c and method.c 534 */ 535 typedef struct contract_entry { 536 ctid_t ce_ctid; 537 int ce_instid; 538 539 uu_list_node_t ce_link; 540 } contract_entry_t; 541 542 uu_list_pool_t *contract_list_pool; 543 544 /* contract.c */ 545 ctid_t contract_init(void); 546 void contract_abandon(ctid_t); 547 int contract_kill(ctid_t, int, const char *); 548 int contract_is_empty(ctid_t); 549 void contract_hash_init(); 550 void contract_hash_store(ctid_t, int); 551 void contract_hash_remove(ctid_t); 552 int lookup_inst_by_contract(ctid_t); 553 554 /* dict.c */ 555 void dict_init(void); 556 int dict_lookup_byname(const char *); 557 int dict_insert(const char *); 558 559 /* expand.c */ 560 int expand_method_tokens(const char *, scf_instance_t *, 561 scf_snapshot_t *, int, char **); 562 563 /* env.c */ 564 void init_env(void); 565 char **set_smf_env(char **, size_t, const char *, 566 const restarter_inst_t *, const char *); 567 568 /* file.c */ 569 int file_ready(graph_vertex_t *); 570 571 /* fork.c */ 572 int fork_mount(char *, char *); 573 void fork_sulogin(boolean_t, const char *, ...); 574 void fork_rc_script(char, const char *, boolean_t); 575 576 void *fork_configd_thread(void *); 577 578 pid_t startd_fork1(int *); 579 580 /* graph.c */ 581 void graph_init(void); 582 void *single_user_thread(void *); 583 void *graph_thread(void *); 584 void *graph_event_thread(void *); 585 void *repository_event_thread(void *); 586 int dgraph_add_instance(const char *, scf_instance_t *, boolean_t); 587 void graph_engine_start(void); 588 void graph_enable_by_vertex(graph_vertex_t *, int, int); 589 int refresh_vertex(graph_vertex_t *, scf_instance_t *); 590 void vertex_send_event(graph_vertex_t *, restarter_event_type_t); 591 void graph_start_if_satisfied(graph_vertex_t *); 592 int vertex_subgraph_dependencies_shutdown(scf_handle_t *, graph_vertex_t *, 593 restarter_instance_state_t); 594 void graph_transition_sulogin(restarter_instance_state_t, 595 restarter_instance_state_t); 596 void graph_transition_propagate(graph_vertex_t *, propagate_event_t, 597 restarter_error_t); 598 599 /* libscf.c - common */ 600 char *inst_fmri_to_svc_fmri(const char *); 601 void *libscf_object_create(void *(*)(scf_handle_t *), scf_handle_t *); 602 int libscf_instance_get_fmri(scf_instance_t *, char **); 603 int libscf_fmri_get_instance(scf_handle_t *, const char *, scf_instance_t **); 604 int libscf_lookup_instance(const char *, scf_instance_t *); 605 int libscf_set_reconfig(int); 606 scf_snapshot_t *libscf_get_or_make_running_snapshot(scf_instance_t *, 607 const char *, boolean_t); 608 int libscf_inst_set_count_prop(scf_instance_t *, const char *, 609 const char *pgtype, uint32_t, const char *, uint64_t); 610 611 /* libscf.c - used by graph.c */ 612 int libscf_get_basic_instance_data(scf_handle_t *, scf_instance_t *, 613 const char *, int *, int *, char **); 614 int libscf_inst_get_or_add_pg(scf_instance_t *, const char *, const char *, 615 uint32_t, scf_propertygroup_t *); 616 int libscf_read_states(const scf_propertygroup_t *, 617 restarter_instance_state_t *, restarter_instance_state_t *); 618 int depgroup_empty(scf_handle_t *, scf_propertygroup_t *); 619 gv_type_t depgroup_read_scheme(scf_handle_t *, scf_propertygroup_t *); 620 depgroup_type_t depgroup_read_grouping(scf_handle_t *, scf_propertygroup_t *); 621 restarter_error_t depgroup_read_restart(scf_handle_t *, scf_propertygroup_t *); 622 int libscf_set_enable_ovr(scf_instance_t *, int); 623 int libscf_inst_delete_prop(scf_instance_t *, const char *, const char *); 624 int libscf_delete_enable_ovr(scf_instance_t *); 625 int libscf_get_milestone(scf_instance_t *, scf_property_t *, scf_value_t *, 626 char *, size_t); 627 int libscf_extract_runlevel(scf_property_t *, char *); 628 int libscf_clear_runlevel(scf_propertygroup_t *, const char *milestone); 629 630 typedef int (*callback_t)(void *, void *); 631 632 int walk_dependency_pgs(scf_instance_t *, callback_t, void *); 633 int walk_property_astrings(scf_property_t *, callback_t, void *); 634 635 /* libscf.c - used by restarter.c/method.c/expand.c */ 636 char *libscf_get_method(scf_handle_t *, int, restarter_inst_t *, 637 scf_snapshot_t *, method_restart_t *, uint_t *, uint8_t *, uint64_t *, 638 uint8_t *); 639 void libscf_populate_graph(scf_handle_t *h); 640 int update_fault_count(restarter_inst_t *, int); 641 int libscf_unset_action(scf_handle_t *, scf_propertygroup_t *, admin_action_t, 642 int64_t); 643 int libscf_get_startd_properties(scf_instance_t *, scf_snapshot_t *, uint_t *, 644 char **); 645 int libscf_get_template_values(scf_instance_t *, scf_snapshot_t *, char **, 646 char **); 647 648 int libscf_read_method_ids(scf_handle_t *, scf_instance_t *, const char *, 649 ctid_t *, ctid_t *, pid_t *); 650 int libscf_write_start_pid(scf_instance_t *, pid_t); 651 int libscf_write_method_status(scf_instance_t *, const char *, int); 652 int libscf_note_method_log(scf_instance_t *, const char *, const char *); 653 654 scf_handle_t *libscf_handle_create_bound(scf_version_t); 655 void libscf_handle_rebind(scf_handle_t *); 656 scf_handle_t *libscf_handle_create_bound_loop(void); 657 658 scf_snapshot_t *libscf_get_running_snapshot(scf_instance_t *); 659 int libscf_snapshots_poststart(scf_handle_t *, const char *, boolean_t); 660 int libscf_snapshots_refresh(scf_instance_t *, const char *); 661 662 int instance_is_transient_style(restarter_inst_t *); 663 int instance_is_wait_style(restarter_inst_t *); 664 665 int libscf_create_self(scf_handle_t *); 666 667 void libscf_reget_instance(restarter_inst_t *); 668 669 /* log.c */ 670 void log_init(); 671 void log_error(int, const char *, ...); 672 void log_framework(int, const char *, ...); 673 void log_console(int, const char *, ...); 674 void log_preexec(void); 675 void setlog(const char *); 676 void log_transition(const restarter_inst_t *, start_outcome_t); 677 void log_instance(const restarter_inst_t *, boolean_t, const char *, ...); 678 void log_instance_fmri(const char *, const char *, boolean_t, 679 const char *, ...); 680 681 /* method.c */ 682 void *method_thread(void *); 683 void method_remove_contract(restarter_inst_t *, boolean_t, boolean_t); 684 685 /* misc.c */ 686 void startd_close(int); 687 void startd_fclose(FILE *); 688 int fmri_canonify(const char *, char **, boolean_t); 689 int fs_is_read_only(char *, ulong_t *); 690 int fs_remount(char *); 691 void xstr_sanitize(char *); 692 693 /* restarter.c */ 694 void restarter_init(void); 695 void restarter_start(void); 696 int instance_in_transition(restarter_inst_t *); 697 int restarter_instance_update_states(scf_handle_t *, restarter_inst_t *, 698 restarter_instance_state_t, restarter_instance_state_t, restarter_error_t, 699 char *); 700 int stop_instance_fmri(scf_handle_t *, const char *, uint_t); 701 restarter_inst_t *inst_lookup_by_id(int); 702 void restarter_mark_pending_snapshot(const char *, uint_t); 703 void *restarter_post_fsminimal_thread(void *); 704 void timeout_insert(restarter_inst_t *, ctid_t, uint64_t); 705 void timeout_remove(restarter_inst_t *, ctid_t); 706 void timeout_init(void); 707 int is_timeout_ovr(restarter_inst_t *); 708 709 /* startd.c */ 710 void *safe_realloc(void *, size_t); 711 char *safe_strdup(const char *s); 712 void *startd_alloc_retry(void *(*)(size_t, int), size_t); 713 void startd_free(void *, size_t); 714 uu_list_pool_t *startd_list_pool_create(const char *, size_t, size_t, 715 uu_compare_fn_t *, uint32_t); 716 uu_list_t *startd_list_create(uu_list_pool_t *, void *, uint32_t); 717 pthread_t startd_thread_create(void *(*)(void *), void *); 718 719 /* special.c */ 720 void special_null_transition(void); 721 void special_online_hooks_get(const char *, instance_hook_t *, 722 instance_hook_t *, instance_hook_t *); 723 724 /* transition.c */ 725 int gt_transition(scf_handle_t *, graph_vertex_t *, restarter_error_t, 726 restarter_instance_state_t); 727 728 /* utmpx.c */ 729 void utmpx_init(void); 730 void utmpx_clear_old(void); 731 int utmpx_mark_init(pid_t, char *); 732 void utmpx_mark_dead(pid_t, int, boolean_t); 733 char utmpx_get_runlevel(void); 734 void utmpx_set_runlevel(char, char, boolean_t); 735 void utmpx_write_boottime(void); 736 737 /* wait.c */ 738 void wait_init(void); 739 void wait_prefork(void); 740 void wait_postfork(pid_t); 741 int wait_register(pid_t, const char *, int, int); 742 void *wait_thread(void *); 743 744 /* proc.c */ 745 ctid_t proc_get_ctid(); 746 747 #ifdef __cplusplus 748 } 749 #endif 750 751 #endif /* _STARTD_H */ 752