1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29__FBSDID("$FreeBSD$");
30
31#include <sys/param.h>
32#include <stdbool.h>
33#include <stdio.h>
34#include <string.h>
35#include <unistd.h>
36
37#include <be.h>
38
39#include "bectl.h"
40
41struct sort_column {
42	char *name;
43	char *val;
44	nvlist_t *nvl;
45};
46
47struct printc {
48	int	active_colsz_def;
49	int	be_colsz;
50	int	current_indent;
51	int	mount_colsz;
52	int	space_colsz;
53	bool	script_fmt;
54	bool	show_all_datasets;
55	bool	show_snaps;
56	bool	show_space;
57};
58
59static const char *get_origin_props(nvlist_t *dsprops, nvlist_t **originprops);
60static void print_padding(const char *fval, int colsz, struct printc *pc);
61static int print_snapshots(const char *dsname, struct printc *pc);
62static void print_info(const char *name, nvlist_t *dsprops, struct printc *pc);
63static void print_headers(nvlist_t *props, struct printc *pc);
64static unsigned long long dataset_space(const char *oname);
65
66#define	HEADER_BE	"BE"
67#define	HEADER_BEPLUS	"BE/Dataset/Snapshot"
68#define	HEADER_ACTIVE	"Active"
69#define	HEADER_MOUNT	"Mountpoint"
70#define	HEADER_SPACE	"Space"
71#define	HEADER_CREATED	"Created"
72
73/* Spaces */
74#define	INDENT_INCREMENT	2
75
76/*
77 * Given a set of dataset properties (for a BE dataset), populate originprops
78 * with the origin's properties.
79 */
80static const char *
81get_origin_props(nvlist_t *dsprops, nvlist_t **originprops)
82{
83	char *propstr;
84
85	if (nvlist_lookup_string(dsprops, "origin", &propstr) == 0) {
86		if (be_prop_list_alloc(originprops) != 0) {
87			fprintf(stderr,
88			    "bectl list: failed to allocate origin prop nvlist\n");
89			return (NULL);
90		}
91		if (be_get_dataset_props(be, propstr, *originprops) != 0) {
92			/* XXX TODO: Real errors */
93			fprintf(stderr,
94			    "bectl list: failed to fetch origin properties\n");
95			return (NULL);
96		}
97
98		return (propstr);
99	}
100	return (NULL);
101}
102
103static void
104print_padding(const char *fval, int colsz, struct printc *pc)
105{
106
107	/* -H flag handling; all delimiters/padding are a single tab */
108	if (pc->script_fmt) {
109		printf("\t");
110		return;
111	}
112
113	if (fval != NULL)
114		colsz -= strlen(fval);
115	printf("%*s ", colsz, "");
116}
117
118static unsigned long long
119dataset_space(const char *oname)
120{
121	unsigned long long space;
122	char *dsname, *propstr, *sep;
123	nvlist_t *dsprops;
124
125	space = 0;
126	dsname = strdup(oname);
127	if (dsname == NULL)
128		return (0);
129
130	/* Truncate snapshot to dataset name, as needed */
131	if ((sep = strchr(dsname, '@')) != NULL)
132		*sep = '\0';
133
134	if (be_prop_list_alloc(&dsprops) != 0) {
135		free(dsname);
136		return (0);
137	}
138
139	if (be_get_dataset_props(be, dsname, dsprops) != 0) {
140		nvlist_free(dsprops);
141		free(dsname);
142		return (0);
143	}
144
145	if (nvlist_lookup_string(dsprops, "used", &propstr) == 0)
146		space = strtoull(propstr, NULL, 10);
147
148	nvlist_free(dsprops);
149	free(dsname);
150	return (space);
151}
152
153static int
154print_snapshots(const char *dsname, struct printc *pc)
155{
156	nvpair_t *cur;
157	nvlist_t *props, *sprops;
158
159	if (be_prop_list_alloc(&props) != 0) {
160		fprintf(stderr, "bectl list: failed to allocate snapshot nvlist\n");
161		return (1);
162	}
163	if (be_get_dataset_snapshots(be, dsname, props) != 0) {
164		fprintf(stderr, "bectl list: failed to fetch boot ds snapshots\n");
165		return (1);
166	}
167	for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
168	    cur = nvlist_next_nvpair(props, cur)) {
169		nvpair_value_nvlist(cur, &sprops);
170		print_info(nvpair_name(cur), sprops, pc);
171	}
172	return (0);
173}
174
175static void
176print_info(const char *name, nvlist_t *dsprops, struct printc *pc)
177{
178#define	BUFSZ	64
179	char buf[BUFSZ];
180	unsigned long long ctimenum, space;
181	nvlist_t *originprops;
182	const char *oname;
183	char *dsname, *propstr;
184	int active_colsz;
185	boolean_t active_now, active_reboot, bootonce;
186
187	dsname = NULL;
188	originprops = NULL;
189	printf("%*s%s", pc->current_indent, "", name);
190	nvlist_lookup_string(dsprops, "dataset", &dsname);
191
192	/* Recurse at the base level if we're breaking info down */
193	if (pc->current_indent == 0 && (pc->show_all_datasets ||
194	    pc->show_snaps)) {
195		printf("\n");
196		if (dsname == NULL)
197			/* XXX TODO: Error? */
198			return;
199		/*
200		 * Whether we're dealing with -a or -s, we'll always print the
201		 * dataset name/information followed by its origin. For -s, we
202		 * additionally iterate through all snapshots of this boot
203		 * environment and also print their information.
204		 */
205		pc->current_indent += INDENT_INCREMENT;
206		print_info(dsname, dsprops, pc);
207		pc->current_indent += INDENT_INCREMENT;
208		if ((oname = get_origin_props(dsprops, &originprops)) != NULL) {
209			print_info(oname, originprops, pc);
210			nvlist_free(originprops);
211		}
212
213		/* Back up a level; snapshots at the same level as dataset */
214		pc->current_indent -= INDENT_INCREMENT;
215		if (pc->show_snaps)
216			print_snapshots(dsname, pc);
217		pc->current_indent = 0;
218		return;
219	} else
220		print_padding(name, pc->be_colsz - pc->current_indent, pc);
221
222	active_colsz = pc->active_colsz_def;
223	if (nvlist_lookup_boolean_value(dsprops, "active",
224	    &active_now) == 0 && active_now) {
225		printf("N");
226		active_colsz--;
227	}
228	if (nvlist_lookup_boolean_value(dsprops, "nextboot",
229	    &active_reboot) == 0 && active_reboot) {
230		printf("R");
231		active_colsz--;
232	}
233	if (nvlist_lookup_boolean_value(dsprops, "bootonce",
234	    &bootonce) == 0 && bootonce) {
235		printf("T");
236		active_colsz--;
237	}
238	if (active_colsz == pc->active_colsz_def) {
239		printf("-");
240		active_colsz--;
241	}
242	print_padding(NULL, active_colsz, pc);
243	if (nvlist_lookup_string(dsprops, "mounted", &propstr) == 0) {
244		printf("%s", propstr);
245		print_padding(propstr, pc->mount_colsz, pc);
246	} else {
247		printf("%s", "-");
248		print_padding("-", pc->mount_colsz, pc);
249	}
250
251	oname = get_origin_props(dsprops, &originprops);
252	if (nvlist_lookup_string(dsprops, "used", &propstr) == 0) {
253		/*
254		 * The space used column is some composition of:
255		 * - The "used" property of the dataset
256		 * - The "used" property of the origin snapshot (not -a or -s)
257		 * - The "used" property of the origin dataset (-D flag only)
258		 *
259		 * The -D flag is ignored if -a or -s are specified.
260		 */
261		space = strtoull(propstr, NULL, 10);
262
263		if (!pc->show_all_datasets && !pc->show_snaps &&
264		    originprops != NULL &&
265		    nvlist_lookup_string(originprops, "used", &propstr) == 0)
266			space += strtoull(propstr, NULL, 10);
267
268		if (pc->show_space && oname != NULL)
269			space += dataset_space(oname);
270
271		/* Alas, there's more to it,. */
272		be_nicenum(space, buf, 6);
273		printf("%s", buf);
274		print_padding(buf, pc->space_colsz, pc);
275	} else {
276		printf("-");
277		print_padding("-", pc->space_colsz, pc);
278	}
279
280	if (nvlist_lookup_string(dsprops, "creation", &propstr) == 0) {
281		ctimenum = strtoull(propstr, NULL, 10);
282		strftime(buf, BUFSZ, "%Y-%m-%d %H:%M",
283		    localtime((time_t *)&ctimenum));
284		printf("%s", buf);
285	}
286
287	printf("\n");
288	if (originprops != NULL)
289		be_prop_list_free(originprops);
290#undef BUFSZ
291}
292
293static void
294print_headers(nvlist_t *props, struct printc *pc)
295{
296	const char *chosen_be_header;
297	nvpair_t *cur;
298	nvlist_t *dsprops;
299	char *propstr;
300	size_t be_maxcol, mount_colsz;
301
302	if (pc->show_all_datasets || pc->show_snaps)
303		chosen_be_header = HEADER_BEPLUS;
304	else
305		chosen_be_header = HEADER_BE;
306	be_maxcol = strlen(chosen_be_header);
307	mount_colsz = strlen(HEADER_MOUNT);
308	for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
309	    cur = nvlist_next_nvpair(props, cur)) {
310		be_maxcol = MAX(be_maxcol, strlen(nvpair_name(cur)));
311		nvpair_value_nvlist(cur, &dsprops);
312
313		if (nvlist_lookup_string(dsprops, "mounted", &propstr) == 0)
314			mount_colsz = MAX(mount_colsz, strlen(propstr));
315		if (!pc->show_all_datasets && !pc->show_snaps)
316			continue;
317		if (nvlist_lookup_string(dsprops, "dataset", &propstr) != 0)
318			continue;
319		be_maxcol = MAX(be_maxcol, strlen(propstr) + INDENT_INCREMENT);
320		if (nvlist_lookup_string(dsprops, "origin", &propstr) != 0)
321			continue;
322		be_maxcol = MAX(be_maxcol,
323		    strlen(propstr) + INDENT_INCREMENT * 2);
324	}
325
326	pc->be_colsz = be_maxcol;
327	pc->active_colsz_def = strlen(HEADER_ACTIVE);
328	pc->mount_colsz = mount_colsz;
329	pc->space_colsz = strlen(HEADER_SPACE);
330	printf("%*s %s %*s %s %s\n", -pc->be_colsz, chosen_be_header,
331	    HEADER_ACTIVE, -pc->mount_colsz, HEADER_MOUNT, HEADER_SPACE, HEADER_CREATED);
332
333	/*
334	 * All other invocations in which we aren't using the default header
335	 * will produce quite a bit of input.  Throw an extra blank line after
336	 * the header to make it look nicer.
337	 */
338	if (strcmp(chosen_be_header, HEADER_BE) != 0)
339		printf("\n");
340}
341
342/*
343 * Sort the given nvlist of boot environments by property.
344 */
345static int
346prop_list_sort(nvlist_t *props, char *property, bool reverse)
347{
348	nvpair_t *nvp;
349	nvlist_t *nvl;
350	int i, nvp_count;
351	uint64_t lval, rval;
352	struct sort_column sc_prev, sc_next;
353
354	/* a temporary list to work with */
355	nvlist_dup(props, &nvl, 0);
356
357	nvp_count = fnvlist_num_pairs(nvl);
358	for (i = 0; i < nvp_count; i++) {
359
360		nvp = nvlist_next_nvpair(nvl, NULL);
361		nvpair_value_nvlist(nvp, &sc_prev.nvl);
362		nvlist_lookup_string(sc_prev.nvl, "name", &sc_prev.name);
363		nvlist_lookup_string(sc_prev.nvl, property, &sc_prev.val);
364
365		while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
366
367			nvpair_value_nvlist(nvp, &sc_next.nvl);
368			nvlist_lookup_string(sc_next.nvl, "name", &sc_next.name);
369			nvlist_lookup_string(sc_next.nvl, property, &sc_next.val);
370
371			/* properties that use numerical comparison */
372			if (strcmp(property, "creation") == 0 ||
373			    strcmp(property, "used") == 0 ||
374			    strcmp(property, "usedds") == 0 ||
375			    strcmp(property, "usedsnap") == 0 ||
376			    strcmp(property, "usedrefreserv") == 0) {
377
378				lval = strtoull(sc_prev.val, NULL, 10);
379				rval = strtoull(sc_next.val, NULL, 10);
380
381				if ((lval < rval && reverse) ||
382				    (lval > rval && !reverse))
383					sc_prev = sc_next;
384			}
385
386			/* properties that use string comparison */
387			else if (strcmp(property, "name") == 0 ||
388				 strcmp(property, "origin") == 0) {
389				if ((strcmp(sc_prev.val, sc_next.val) < 0 && reverse) ||
390				    (strcmp(sc_prev.val, sc_next.val) > 0 && !reverse))
391					sc_prev = sc_next;
392			}
393		}
394
395		/*
396		 * The 'props' nvlist has been created to only have unique names.
397		 * When a name is added, any existing nvlist's with the same name
398		 * will be removed. Eventually, all existing nvlist's are replaced
399		 * in sorted order.
400		 */
401		nvlist_add_nvlist(props, sc_prev.name, sc_prev.nvl);
402		nvlist_remove_all(nvl, sc_prev.name);
403	}
404
405	be_prop_list_free(nvl);
406
407	return 0;
408}
409
410int
411bectl_cmd_list(int argc, char *argv[])
412{
413	struct printc pc;
414	nvpair_t *cur;
415	nvlist_t *dsprops, *props;
416	int opt, printed;
417	char *column;
418	bool reverse;
419
420	column = NULL;
421	props = NULL;
422	printed = 0;
423	bzero(&pc, sizeof(pc));
424	reverse = false;
425	while ((opt = getopt(argc, argv, "aDHsc:C:")) != -1) {
426		switch (opt) {
427		case 'a':
428			pc.show_all_datasets = true;
429			break;
430		case 'D':
431			pc.show_space = true;
432			break;
433		case 'H':
434			pc.script_fmt = true;
435			break;
436		case 's':
437			pc.show_snaps = true;
438			break;
439		case 'c':
440			if (column != NULL)
441				free(column);
442			column = strdup(optarg);
443			reverse = false;
444			break;
445		case 'C':
446			if (column != NULL)
447				free(column);
448			column = strdup(optarg);
449			reverse = true;
450			break;
451		default:
452			fprintf(stderr, "bectl list: unknown option '-%c'\n",
453			    optopt);
454			return (usage(false));
455		}
456	}
457
458	argc -= optind;
459
460	if (argc != 0) {
461		fprintf(stderr, "bectl list: extra argument provided\n");
462		return (usage(false));
463	}
464
465	if (be_prop_list_alloc(&props) != 0) {
466		fprintf(stderr, "bectl list: failed to allocate prop nvlist\n");
467		return (1);
468	}
469	if (be_get_bootenv_props(be, props) != 0) {
470		/* XXX TODO: Real errors */
471		fprintf(stderr, "bectl list: failed to fetch boot environments\n");
472		return (1);
473	}
474
475	/* List boot environments in alphabetical order by default */
476	if (column == NULL)
477		column = strdup("name");
478
479	prop_list_sort(props, column, reverse);
480
481	/* Force -D off if either -a or -s are specified */
482	if (pc.show_all_datasets || pc.show_snaps)
483		pc.show_space = false;
484	if (!pc.script_fmt)
485		print_headers(props, &pc);
486
487	/* Print boot environments */
488	for (cur = nvlist_next_nvpair(props, NULL); cur != NULL;
489	    cur = nvlist_next_nvpair(props, cur)) {
490		nvpair_value_nvlist(cur, &dsprops);
491
492		if (printed > 0 && (pc.show_all_datasets || pc.show_snaps))
493			printf("\n");
494
495		print_info(nvpair_name(cur), dsprops, &pc);
496		printed++;
497	}
498
499	free(column);
500	be_prop_list_free(props);
501
502	return (0);
503}
504
505