xref: /illumos-gate/usr/src/cmd/svc/svcadm/synch.c (revision 2a8bcb4efb45d99ac41c94a75c396b362c414f7f)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * synchronous svcadm logic
29  */
30 
31 #include <locale.h>
32 #include <libintl.h>
33 #include <libscf.h>
34 #include <libscf_priv.h>
35 #include <libuutil.h>
36 #include <stddef.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41 #include <assert.h>
42 #include <errno.h>
43 #include <sys/stat.h>
44 
45 
46 /*
47  * Definitions from svcadm.c.
48  */
49 extern scf_handle_t *h;
50 extern ssize_t max_scf_fmri_sz;
51 
52 extern void do_scfdie(int) __NORETURN;
53 extern int inst_get_state(scf_instance_t *, char *, const char *,
54     scf_propertygroup_t **);
55 extern ssize_t get_astring_prop(const scf_propertygroup_t *, const char *,
56     scf_property_t *, scf_value_t *, char *, size_t);
57 extern int get_bool_prop(scf_propertygroup_t *, const char *, uint8_t *);
58 
59 #define	scfdie()	do_scfdie(__LINE__)
60 
61 int has_potential(scf_instance_t *, int);
62 
63 /*
64  * Determines if the specified instance is enabled, composing the
65  * general and general_ovr property groups.  For simplicity, we map
66  * most errors to "not enabled".
67  */
68 int
is_enabled(scf_instance_t * inst)69 is_enabled(scf_instance_t *inst)
70 {
71 	scf_propertygroup_t *pg;
72 	uint8_t bp;
73 
74 	if ((pg = scf_pg_create(h)) == NULL)
75 		scfdie();
76 
77 	if (scf_instance_get_pg(inst, SCF_PG_GENERAL_OVR, pg) == 0 &&
78 	    get_bool_prop(pg, SCF_PROPERTY_ENABLED, &bp) == 0) {
79 		scf_pg_destroy(pg);
80 		return (bp);
81 	}
82 
83 	if (scf_instance_get_pg(inst, SCF_PG_GENERAL, pg) == 0 &&
84 	    get_bool_prop(pg, SCF_PROPERTY_ENABLED, &bp) == 0) {
85 		scf_pg_destroy(pg);
86 		return (bp);
87 	}
88 
89 	scf_pg_destroy(pg);
90 	return (B_FALSE);
91 }
92 
93 /*
94  * Reads an astring property from a property group.  If the named
95  * property doesn't exist, returns NULL.  The result of a successful
96  * call should be freed.
97  */
98 static char *
read_astring_prop(scf_propertygroup_t * pg,scf_value_t * val,scf_property_t * prop,const char * name)99 read_astring_prop(scf_propertygroup_t *pg, scf_value_t *val,
100     scf_property_t *prop, const char *name)
101 {
102 	char *value;
103 	size_t value_sz;
104 
105 	if (scf_pg_get_property(pg, name, prop) == -1) {
106 		switch (scf_error()) {
107 		case SCF_ERROR_NOT_FOUND:
108 		case SCF_ERROR_DELETED:
109 			return (NULL);
110 		default:
111 			scfdie();
112 		}
113 	}
114 
115 	if (scf_property_get_value(prop, val) != 0) {
116 		switch (scf_error()) {
117 		case SCF_ERROR_DELETED:
118 		case SCF_ERROR_NOT_FOUND:
119 		case SCF_ERROR_CONSTRAINT_VIOLATED:
120 			return (NULL);
121 		default:
122 			scfdie();
123 		}
124 	}
125 
126 	value_sz = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
127 	if ((value = malloc(value_sz)) == NULL)
128 		scfdie();
129 
130 	if (scf_value_get_astring(val, value, value_sz) <= 0) {
131 		free(value);
132 		return (NULL);
133 	}
134 
135 	return (value);
136 }
137 
138 /*
139  * Creates and returns an scf_iter for the values of the named
140  * multi-value property.  Returns NULL on failure.
141  */
142 static scf_iter_t *
prop_walk_init(scf_propertygroup_t * pg,const char * name)143 prop_walk_init(scf_propertygroup_t *pg, const char *name)
144 {
145 	scf_iter_t *iter;
146 	scf_property_t *prop;
147 
148 	if ((iter = scf_iter_create(h)) == NULL ||
149 	    (prop = scf_property_create(h)) == NULL)
150 		scfdie();
151 
152 	if (scf_pg_get_property(pg, name, prop) != 0) {
153 		switch (scf_error()) {
154 		case SCF_ERROR_NOT_FOUND:
155 		case SCF_ERROR_DELETED:
156 			goto error;
157 		default:
158 			scfdie();
159 		}
160 	}
161 
162 	if (scf_iter_property_values(iter, prop) != 0) {
163 		if (scf_error() != SCF_ERROR_DELETED)
164 			scfdie();
165 		goto error;
166 	}
167 
168 	scf_property_destroy(prop);
169 	return (iter);
170 error:
171 	scf_property_destroy(prop);
172 	scf_iter_destroy(iter);
173 	return (NULL);
174 }
175 
176 /*
177  * Reads the next value from the multi-value property using the
178  * scf_iter obtained by prop_walk_init, and places it in the buffer
179  * pointed to by fmri.  Returns -1 on failure, 0 when done, and non-0
180  * when returning a value.
181  */
182 static int
prop_walk_step(scf_iter_t * iter,char * fmri,size_t len)183 prop_walk_step(scf_iter_t *iter, char *fmri, size_t len)
184 {
185 	int r;
186 	scf_value_t *val;
187 
188 	if ((val = scf_value_create(h)) == NULL)
189 		scfdie();
190 
191 	r = scf_iter_next_value(iter, val);
192 	if (r == 0)
193 		goto out;
194 	if (r == -1) {
195 		if (scf_error() != SCF_ERROR_DELETED)
196 			scfdie();
197 		goto out;
198 	}
199 	if (scf_value_get_astring(val, fmri, len) <= 0) {
200 		r = -1;
201 		goto out;
202 	}
203 
204 out:
205 	scf_value_destroy(val);
206 	return (r);
207 }
208 
209 /*
210  * Determines if a file dependency is satisfied, taking into account
211  * whether it is an exclusion dependency or not.  If we can't access
212  * the file, we err on the side of caution and assume the dependency
213  * isn't satisfied.
214  */
215 static int
file_has_potential(char * fmri,int exclude)216 file_has_potential(char *fmri, int exclude)
217 {
218 	const char *path;
219 	struct stat st;
220 
221 	int good = exclude ? B_FALSE : B_TRUE;
222 
223 	if (scf_parse_file_fmri(fmri, NULL, &path) != 0)
224 		return (good);
225 
226 	if (stat(path, &st) == 0)
227 		return (good);
228 
229 	if (errno == EACCES) {
230 		uu_warn(gettext("Unable to access \"%s\".\n"), path);
231 		return (B_FALSE);
232 	}
233 
234 	return (!good);
235 }
236 
237 /*
238  * Determines if a dependency on a service instance is satisfiable.
239  * Returns 0 if not, 1 if it is, or 2 if it is an optional or exclude
240  * dependency and the service only "weakly" satisfies (i.e. is disabled
241  * or is in maintenance state).
242  */
243 static int
inst_has_potential(scf_instance_t * inst,int enabled,int optional,int exclude)244 inst_has_potential(scf_instance_t *inst, int enabled, int optional, int exclude)
245 {
246 	char state[MAX_SCF_STATE_STRING_SZ];
247 
248 	if (!enabled)
249 		return ((optional || exclude) ? 2 : 0);
250 
251 	/*
252 	 * Normally we would return a positive value on failure;
253 	 * relying on startd to place the service in maintenance.  But
254 	 * if we can't read a service's state, we have to assume it is
255 	 * out to lunch.
256 	 */
257 	if (inst_get_state(inst, state, NULL, NULL) != 0)
258 		return (0);
259 
260 	/*
261 	 * Optional dependencies which are offline always have a possibility of
262 	 * coming online.
263 	 */
264 	if (optional && strcmp(state, SCF_STATE_STRING_OFFLINE) == 0)
265 		return (2);
266 
267 	if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
268 		/*
269 		 * Enabled services in maintenance state satisfy
270 		 * optional-all dependencies.
271 		 */
272 		return ((optional || exclude) ? 2 : 0);
273 	}
274 
275 	/*
276 	 * We're enabled and not in maintenance.
277 	 */
278 	if (exclude)
279 		return (0);
280 
281 	if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0 ||
282 	    strcmp(state, SCF_STATE_STRING_DEGRADED) == 0)
283 		return (1);
284 
285 	return (has_potential(inst, B_FALSE));
286 }
287 
288 /*
289  * Determines if a dependency on an fmri is satisfiable, handling the
290  * separate cases for file, service, and instance fmris.  Returns false
291  * if not, or true if it is.  Takes into account if the dependency is
292  * an optional or exclusive one.
293  */
294 static int
fmri_has_potential(char * fmri,int isfile,int optional,int exclude,int restarter)295 fmri_has_potential(char *fmri, int isfile, int optional, int exclude,
296     int restarter)
297 {
298 	scf_instance_t *inst;
299 	scf_service_t *svc;
300 	scf_iter_t *iter;
301 	int good = exclude ? B_FALSE : B_TRUE;
302 	int enabled;
303 	int r, result;
304 	int optbad;
305 
306 	assert(!optional || !exclude);
307 
308 	if (isfile)
309 		return (file_has_potential(fmri, exclude));
310 
311 	if ((inst = scf_instance_create(h)) == NULL ||
312 	    (svc = scf_service_create(h)) == NULL ||
313 	    (iter = scf_iter_create(h)) == NULL)
314 		scfdie();
315 
316 	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, NULL,
317 	    SCF_DECODE_FMRI_EXACT) == 0) {
318 		enabled = is_enabled(inst);
319 		result =
320 		    (inst_has_potential(inst, enabled, optional, exclude) != 0);
321 		goto out;
322 	}
323 
324 	if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
325 	    SCF_DECODE_FMRI_EXACT) != 0) {
326 		/*
327 		 * If we are checking a restarter dependency, a bad
328 		 * or nonexistent service will never be noticed.
329 		 */
330 		result = restarter ? B_FALSE : good;
331 		goto out;
332 	}
333 
334 	if (scf_iter_service_instances(iter, svc) != 0) {
335 		if (scf_error() != SCF_ERROR_DELETED)
336 			scfdie();
337 		result = good;
338 		goto out;
339 	}
340 
341 	optbad = 0;
342 	for (;;) {
343 		r = scf_iter_next_instance(iter, inst);
344 		if (r == 0) {
345 			result = exclude || (optional && !optbad);
346 			goto out;
347 		}
348 		if (r == -1) {
349 			if (scf_error() != SCF_ERROR_DELETED)
350 				scfdie();
351 			result = good;
352 			goto out;
353 		}
354 
355 		enabled = is_enabled(inst);
356 		r = inst_has_potential(inst, enabled, optional, exclude);
357 
358 		/*
359 		 * Exclusion dependencies over services map to
360 		 * require-none for its instances.
361 		 */
362 		if (exclude)
363 			r = (r == 0);
364 
365 		if (r == 1) {
366 			/*
367 			 * Remember, if this is an exclusion dependency
368 			 * (which means we are here because there
369 			 * exists an instance which wasn't satisfiable
370 			 * in that regard), good means bad.
371 			 */
372 			result = good;
373 			goto out;
374 		}
375 
376 		if (optional && r == 0)
377 			optbad = 1;
378 	}
379 
380 out:
381 	scf_instance_destroy(inst);
382 	scf_service_destroy(svc);
383 	scf_iter_destroy(iter);
384 	return (result);
385 }
386 
387 static int
eval_require_any(scf_iter_t * iter,char * value,size_t value_sz,int isfile)388 eval_require_any(scf_iter_t *iter, char *value, size_t value_sz, int isfile)
389 {
390 	int r, empty = B_TRUE;
391 
392 	for (;;) {
393 		/*
394 		 * For reasons unknown, an empty require_any dependency
395 		 * group is considered by startd to be satisfied.
396 		 * This insanity fortunately doesn't extend to
397 		 * dependencies on services with no instances.
398 		 */
399 		if ((r = prop_walk_step(iter, value, value_sz)) <= 0)
400 			return ((r == 0 && empty) ? B_TRUE : r);
401 		if (fmri_has_potential(value, isfile, B_FALSE, B_FALSE,
402 		    B_FALSE))
403 			return (1);
404 		empty = B_FALSE;
405 	}
406 }
407 
408 static int
eval_all(scf_iter_t * iter,char * value,size_t value_sz,int isfile,int optional,int exclude)409 eval_all(scf_iter_t *iter, char *value, size_t value_sz,
410     int isfile, int optional, int exclude)
411 {
412 	int r;
413 
414 	for (;;) {
415 		if ((r = prop_walk_step(iter, value, value_sz)) <= 0)
416 			return ((r == 0) ? 1 : r);
417 		if (!fmri_has_potential(value, isfile, optional, exclude,
418 		    B_FALSE))
419 			return (0);
420 	}
421 }
422 
423 static int
eval_require_all(scf_iter_t * iter,char * value,size_t value_sz,int isfile)424 eval_require_all(scf_iter_t *iter, char *value, size_t value_sz, int isfile)
425 {
426 	return (eval_all(iter, value, value_sz, isfile, B_FALSE, B_FALSE));
427 }
428 
429 static int
eval_optional_all(scf_iter_t * iter,char * value,size_t value_sz,int isfile)430 eval_optional_all(scf_iter_t *iter, char *value, size_t value_sz, int isfile)
431 {
432 	return (eval_all(iter, value, value_sz, isfile, B_TRUE, B_FALSE));
433 }
434 
435 static int
eval_exclude_all(scf_iter_t * iter,char * value,size_t value_sz,int isfile)436 eval_exclude_all(scf_iter_t *iter, char *value, size_t value_sz, int isfile)
437 {
438 	return (eval_all(iter, value, value_sz, isfile, B_FALSE, B_TRUE));
439 }
440 
441 /*
442  * Examines the state and health of an instance's restarter and
443  * dependencies, and determines the impact of both on the instance's
444  * ability to be brought on line.  A true return value indicates that
445  * instance appears to be a likely candidate for the online club.
446  * False indicates that there is no hope for the instance.
447  */
448 int
has_potential(scf_instance_t * inst,int restarter_only)449 has_potential(scf_instance_t *inst, int restarter_only)
450 {
451 	scf_snapshot_t *snap;
452 	scf_iter_t *iter, *viter = NULL;
453 	scf_propertygroup_t *pg;
454 	scf_property_t *prop;
455 	scf_value_t *val;
456 	char *type = NULL, *grouping = NULL;
457 	char *value;
458 	size_t value_sz;
459 	int result = B_TRUE, r;
460 	int isfile;
461 
462 	value_sz = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
463 	if ((iter = scf_iter_create(h)) == NULL ||
464 	    (snap = scf_snapshot_create(h)) == NULL ||
465 	    (pg = scf_pg_create(h)) == NULL ||
466 	    (val = scf_value_create(h)) == NULL ||
467 	    (prop = scf_property_create(h)) == NULL ||
468 	    (value = malloc(value_sz)) == NULL)
469 		scfdie();
470 
471 	/*
472 	 * First we check our restarter as an implicit dependency.
473 	 */
474 	if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL, pg) != 0)
475 		scfdie();
476 
477 	r = get_astring_prop(pg, SCF_PROPERTY_RESTARTER, prop, val, value,
478 	    value_sz);
479 	if (r == -ENOENT) {
480 		(void) strlcpy(value, SCF_SERVICE_STARTD, value_sz);
481 	} else if (r < 0 || r > max_scf_fmri_sz) {
482 		/*
483 		 * Normally we would return true and let the restarter
484 		 * tell our caller there is a problem by changing the
485 		 * instance's state, but that's not going to happen if
486 		 * the restarter is invalid.
487 		 */
488 		result = B_FALSE;
489 		goto out;
490 	}
491 
492 	if (!fmri_has_potential(value, B_FALSE, B_FALSE, B_FALSE, B_TRUE)) {
493 		result = B_FALSE;
494 		goto out;
495 	}
496 
497 	if (restarter_only)
498 		goto out;
499 
500 	/*
501 	 * Now we check explicit dependencies.
502 	 */
503 	if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
504 		if (scf_error() != SCF_ERROR_NOT_FOUND)
505 			scfdie();
506 		scf_snapshot_destroy(snap);
507 		snap = NULL;
508 	}
509 
510 	if (scf_iter_instance_pgs_typed_composed(iter, inst, snap,
511 	    SCF_GROUP_DEPENDENCY) != 0) {
512 		if (scf_error() != SCF_ERROR_DELETED)
513 			scfdie();
514 		goto out;
515 	}
516 
517 	for (;;) {
518 		r = scf_iter_next_pg(iter, pg);
519 		if (r == 0)
520 			break;
521 		if (r == -1) {
522 			if (scf_error() != SCF_ERROR_DELETED)
523 				scfdie();
524 			goto out;
525 		}
526 
527 		if ((grouping = read_astring_prop(pg, val, prop,
528 		    SCF_PROPERTY_GROUPING)) == NULL)
529 			goto out;
530 
531 		if ((type = read_astring_prop(pg, val, prop,
532 		    SCF_PROPERTY_TYPE)) == NULL)
533 			goto out;
534 
535 		if (strcmp(type, "path") == 0) {
536 			isfile = B_TRUE;
537 		} else if (strcmp(type, "service") == 0) {
538 			isfile = B_FALSE;
539 		} else {
540 			free(type);
541 			goto out;
542 		}
543 		free(type);
544 
545 		if ((viter = prop_walk_init(pg, SCF_PROPERTY_ENTITIES)) == NULL)
546 			goto out;
547 
548 		if (strcmp(grouping, SCF_DEP_REQUIRE_ALL) == 0) {
549 			r = eval_require_all(viter, value, value_sz, isfile);
550 		} else if (strcmp(grouping, SCF_DEP_REQUIRE_ANY) == 0) {
551 			r = eval_require_any(viter, value, value_sz, isfile);
552 		} else if (strcmp(grouping, SCF_DEP_EXCLUDE_ALL) == 0) {
553 			r = eval_exclude_all(viter, value, value_sz, isfile);
554 		} else if (strcmp(grouping, SCF_DEP_OPTIONAL_ALL) == 0) {
555 			r = eval_optional_all(viter, value, value_sz, isfile);
556 		} else {
557 			scf_iter_destroy(viter);
558 			free(grouping);
559 			grouping = NULL;
560 			goto out;
561 		}
562 
563 		scf_iter_destroy(viter);
564 		free(grouping);
565 		grouping = NULL;
566 
567 		if (r == 0) {
568 			result = B_FALSE;
569 			goto out;
570 		} else if (r == -1) {
571 			goto out;
572 		}
573 	}
574 
575 out:
576 	free(value);
577 	scf_property_destroy(prop);
578 	scf_value_destroy(val);
579 	scf_pg_destroy(pg);
580 	if (snap != NULL)
581 		scf_snapshot_destroy(snap);
582 	if (grouping != NULL)
583 		free(grouping);
584 	scf_iter_destroy(iter);
585 	return (result);
586 }
587