1 /*	$NetBSD: display.c,v 1.1.1.3 2009/12/02 00:26:43 haad Exp $	*/
2 
3 /*
4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6  *
7  * This file is part of LVM2.
8  *
9  * This copyrighted material is made available to anyone wishing to use,
10  * modify, copy, or redistribute it subject to the terms and conditions
11  * of the GNU Lesser General Public License v.2.1.
12  *
13  * You should have received a copy of the GNU Lesser General Public License
14  * along with this program; if not, write to the Free Software Foundation,
15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16  */
17 
18 #include "lib.h"
19 #include "metadata.h"
20 #include "display.h"
21 #include "activate.h"
22 #include "toolcontext.h"
23 #include "segtype.h"
24 
25 #define SIZE_BUF 128
26 
27 typedef enum { SIZE_LONG = 0, SIZE_SHORT = 1, SIZE_UNIT = 2 } size_len_t;
28 
29 static const struct {
30 	alloc_policy_t alloc;
31 	const char str[12]; /* must be changed when size extends 11 chars */
32 } _policies[] = {
33 	{
34 	ALLOC_CONTIGUOUS, "contiguous"}, {
35 	ALLOC_CLING, "cling"}, {
36 	ALLOC_NORMAL, "normal"}, {
37 	ALLOC_ANYWHERE, "anywhere"}, {
38 	ALLOC_INHERIT, "inherit"}
39 };
40 
41 static const int _num_policies = sizeof(_policies) / sizeof(*_policies);
42 
units_to_bytes(const char * units,char * unit_type)43 uint64_t units_to_bytes(const char *units, char *unit_type)
44 {
45 	char *ptr = NULL;
46 	uint64_t v;
47 
48 	if (isdigit(*units)) {
49 		v = (uint64_t) strtod(units, &ptr);
50 		if (ptr == units)
51 			return 0;
52 		units = ptr;
53 	} else
54 		v = 1;
55 
56 	if (v == 1)
57 		*unit_type = *units;
58 	else
59 		*unit_type = 'U';
60 
61 	switch (*units) {
62 	case 'h':
63 	case 'H':
64 		v = UINT64_C(1);
65 		*unit_type = *units;
66 		break;
67 	case 'b':
68 	case 'B':
69 		v *= UINT64_C(1);
70 		break;
71 #define KILO UINT64_C(1024)
72 	case 's':
73 	case 'S':
74 		v *= (KILO/2);
75 		break;
76 	case 'k':
77 		v *= KILO;
78 		break;
79 	case 'm':
80 		v *= KILO * KILO;
81 		break;
82 	case 'g':
83 		v *= KILO * KILO * KILO;
84 		break;
85 	case 't':
86 		v *= KILO * KILO * KILO * KILO;
87 		break;
88 	case 'p':
89 		v *= KILO * KILO * KILO * KILO * KILO;
90 		break;
91 	case 'e':
92 		v *= KILO * KILO * KILO * KILO * KILO * KILO;
93 		break;
94 #undef KILO
95 #define KILO UINT64_C(1000)
96 	case 'K':
97 		v *= KILO;
98 		break;
99 	case 'M':
100 		v *= KILO * KILO;
101 		break;
102 	case 'G':
103 		v *= KILO * KILO * KILO;
104 		break;
105 	case 'T':
106 		v *= KILO * KILO * KILO * KILO;
107 		break;
108 	case 'P':
109 		v *= KILO * KILO * KILO * KILO * KILO;
110 		break;
111 	case 'E':
112 		v *= KILO * KILO * KILO * KILO * KILO * KILO;
113 		break;
114 #undef KILO
115 	default:
116 		return 0;
117 	}
118 
119 	if (*(units + 1))
120 		return 0;
121 
122 	return v;
123 }
124 
get_alloc_string(alloc_policy_t alloc)125 const char *get_alloc_string(alloc_policy_t alloc)
126 {
127 	int i;
128 
129 	for (i = 0; i < _num_policies; i++)
130 		if (_policies[i].alloc == alloc)
131 			return _policies[i].str;
132 
133 	return NULL;
134 }
135 
get_alloc_from_string(const char * str)136 alloc_policy_t get_alloc_from_string(const char *str)
137 {
138 	int i;
139 
140 	for (i = 0; i < _num_policies; i++)
141 		if (!strcmp(_policies[i].str, str))
142 			return _policies[i].alloc;
143 
144 	/* Special case for old metadata */
145 	if(!strcmp("next free", str))
146 		return ALLOC_NORMAL;
147 
148 	log_error("Unrecognised allocation policy %s", str);
149 	return ALLOC_INVALID;
150 }
151 
152 #define BASE_UNKNOWN 0
153 #define BASE_SHARED 1
154 #define BASE_1024 7
155 #define BASE_1000 13
156 #define BASE_SPECIAL 19
157 #define NUM_UNIT_PREFIXES 6
158 #define NUM_SPECIAL 3
159 
160 /* Size supplied in sectors */
_display_size(const struct cmd_context * cmd,uint64_t size,size_len_t sl)161 static const char *_display_size(const struct cmd_context *cmd,
162 				 uint64_t size, size_len_t sl)
163 {
164 	unsigned base = BASE_UNKNOWN;
165 	unsigned s;
166 	int suffix = 1, precision;
167 	uint64_t byte = UINT64_C(0);
168 	uint64_t units = UINT64_C(1024);
169 	char *size_buf = NULL;
170 	const char * const size_str[][3] = {
171 		/* BASE_UNKNOWN */
172 		{"         ", "   ", " "},	/* [0] */
173 
174 		/* BASE_SHARED - Used if cmd->si_unit_consistency = 0 */
175 		{" Exabyte", " EB", "E"},	/* [1] */
176 		{" Petabyte", " PB", "P"},	/* [2] */
177 		{" Terabyte", " TB", "T"},	/* [3] */
178 		{" Gigabyte", " GB", "G"},	/* [4] */
179 		{" Megabyte", " MB", "M"},	/* [5] */
180 		{" Kilobyte", " KB", "K"},	/* [6] */
181 
182 		/* BASE_1024 - Used if cmd->si_unit_consistency = 1 */
183 		{" Exbibyte", " EiB", "e"},	/* [7] */
184 		{" Pebibyte", " PiB", "p"},	/* [8] */
185 		{" Tebibyte", " TiB", "t"},	/* [9] */
186 		{" Gibibyte", " GiB", "g"},	/* [10] */
187 		{" Mebibyte", " MiB", "m"},	/* [11] */
188 		{" Kibibyte", " KiB", "k"},	/* [12] */
189 
190 		/* BASE_1000 - Used if cmd->si_unit_consistency = 1 */
191 		{" Exabyte",  " EB", "E"},	/* [13] */
192 		{" Petabyte", " PB", "P"},	/* [14] */
193 		{" Terabyte", " TB", "T"},	/* [15] */
194 		{" Gigabyte", " GB", "G"},	/* [16] */
195 		{" Megabyte", " MB", "M"},	/* [17] */
196 		{" Kilobyte", " kB", "K"},	/* [18] */
197 
198 		/* BASE_SPECIAL */
199 		{" Byte    ", " B ", "B"},	/* [19] */
200 		{" Units   ", " Un", "U"},	/* [20] */
201 		{" Sectors ", " Se", "S"},	/* [21] */
202 	};
203 
204 	if (!(size_buf = dm_pool_alloc(cmd->mem, SIZE_BUF))) {
205 		log_error("no memory for size display buffer");
206 		return "";
207 	}
208 
209 	suffix = cmd->current_settings.suffix;
210 
211 	if (!cmd->si_unit_consistency) {
212 		/* Case-independent match */
213 		for (s = 0; s < NUM_UNIT_PREFIXES; s++)
214 			if (toupper((int) cmd->current_settings.unit_type) ==
215 			    *size_str[BASE_SHARED + s][2]) {
216 				base = BASE_SHARED;
217 				break;
218 			}
219 	} else {
220 		/* Case-dependent match for powers of 1000 */
221 		for (s = 0; s < NUM_UNIT_PREFIXES; s++)
222 			if (cmd->current_settings.unit_type ==
223 			    *size_str[BASE_1000 + s][2]) {
224 				base = BASE_1000;
225 				break;
226 			}
227 
228 		/* Case-dependent match for powers of 1024 */
229 		if (base == BASE_UNKNOWN)
230 			for (s = 0; s < NUM_UNIT_PREFIXES; s++)
231 			if (cmd->current_settings.unit_type ==
232 			    *size_str[BASE_1024 + s][2]) {
233 				base = BASE_1024;
234 				break;
235 			}
236 	}
237 
238 	if (base == BASE_UNKNOWN)
239 		/* Check for special units - s, b or u */
240 		for (s = 0; s < NUM_SPECIAL; s++)
241 			if (toupper((int) cmd->current_settings.unit_type) ==
242 			    *size_str[BASE_SPECIAL + s][2]) {
243 				base = BASE_SPECIAL;
244 				break;
245 			}
246 
247 	if (size == UINT64_C(0)) {
248 		if (base == BASE_UNKNOWN)
249 			s = 0;
250 		sprintf(size_buf, "0%s", suffix ? size_str[base + s][sl] : "");
251 		return size_buf;
252 	}
253 
254 	size *= UINT64_C(512);
255 
256 	if (base != BASE_UNKNOWN)
257 		byte = cmd->current_settings.unit_factor;
258 	else {
259 		/* Human-readable style */
260 		if (cmd->current_settings.unit_type == 'H') {
261 			units = UINT64_C(1000);
262 			base = BASE_1000;
263 		} else {
264 			units = UINT64_C(1024);
265 			base = BASE_1024;
266 		}
267 
268 		if (!cmd->si_unit_consistency)
269 			base = BASE_SHARED;
270 
271 		byte = units * units * units * units * units * units;
272 
273 		for (s = 0; s < NUM_UNIT_PREFIXES && size < byte; s++)
274 			byte /= units;
275 
276 		suffix = 1;
277 	}
278 
279 	/* FIXME Make precision configurable */
280 	switch(toupper((int) cmd->current_settings.unit_type)) {
281 	case 'B':
282 	case 'S':
283 		precision = 0;
284 		break;
285 	default:
286 		precision = 2;
287 	}
288 
289 	snprintf(size_buf, SIZE_BUF - 1, "%.*f%s", precision,
290 		 (double) size / byte, suffix ? size_str[base + s][sl] : "");
291 
292 	return size_buf;
293 }
294 
display_size_long(const struct cmd_context * cmd,uint64_t size)295 const char *display_size_long(const struct cmd_context *cmd, uint64_t size)
296 {
297 	return _display_size(cmd, size, SIZE_LONG);
298 }
299 
display_size_units(const struct cmd_context * cmd,uint64_t size)300 const char *display_size_units(const struct cmd_context *cmd, uint64_t size)
301 {
302 	return _display_size(cmd, size, SIZE_UNIT);
303 }
304 
display_size(const struct cmd_context * cmd,uint64_t size)305 const char *display_size(const struct cmd_context *cmd, uint64_t size)
306 {
307 	return _display_size(cmd, size, SIZE_SHORT);
308 }
309 
pvdisplay_colons(const struct physical_volume * pv)310 void pvdisplay_colons(const struct physical_volume *pv)
311 {
312 	char uuid[64] __attribute((aligned(8)));
313 
314 	if (!pv)
315 		return;
316 
317 	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
318 		stack;
319 		return;
320 	}
321 
322 	log_print("%s:%s:%" PRIu64 ":-1:%u:%u:-1:%" PRIu32 ":%u:%u:%u:%s",
323 		  pv_dev_name(pv), pv->vg_name, pv->size,
324 		  /* FIXME pv->pv_number, Derive or remove? */
325 		  pv->status,	/* FIXME Support old or new format here? */
326 		  pv->status & ALLOCATABLE_PV,	/* FIXME remove? */
327 		  /* FIXME pv->lv_cur, Remove? */
328 		  pv->pe_size / 2,
329 		  pv->pe_count,
330 		  pv->pe_count - pv->pe_alloc_count,
331 		  pv->pe_alloc_count, *uuid ? uuid : "none");
332 
333 	return;
334 }
335 
pvdisplay_segments(const struct physical_volume * pv)336 void pvdisplay_segments(const struct physical_volume *pv)
337 {
338 	const struct pv_segment *pvseg;
339 
340 	if (pv->pe_size)
341 		log_print("--- Physical Segments ---");
342 
343 	dm_list_iterate_items(pvseg, &pv->segments) {
344 		log_print("Physical extent %u to %u:",
345 			  pvseg->pe, pvseg->pe + pvseg->len - 1);
346 
347 		if (pvseg_is_allocated(pvseg)) {
348 			log_print("  Logical volume\t%s%s/%s",
349 				  pvseg->lvseg->lv->vg->cmd->dev_dir,
350 				  pvseg->lvseg->lv->vg->name,
351 				  pvseg->lvseg->lv->name);
352 			log_print("  Logical extents\t%d to %d",
353 				  pvseg->lvseg->le, pvseg->lvseg->le +
354 				  pvseg->lvseg->len - 1);
355 		} else
356 			log_print("  FREE");
357 	}
358 
359 	log_print(" ");
360 	return;
361 }
362 
363 /* FIXME Include label fields */
pvdisplay_full(const struct cmd_context * cmd,const struct physical_volume * pv,void * handle __attribute ((unused)))364 void pvdisplay_full(const struct cmd_context *cmd,
365 		    const struct physical_volume *pv,
366 		    void *handle __attribute((unused)))
367 {
368 	char uuid[64] __attribute((aligned(8)));
369 	const char *size;
370 
371 	uint32_t pe_free;
372 	uint64_t data_size, pvsize, unusable;
373 
374 	if (!pv)
375 		return;
376 
377 	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
378 		stack;
379 		return;
380 	}
381 
382 	log_print("--- %sPhysical volume ---", pv->pe_size ? "" : "NEW ");
383 	log_print("PV Name               %s", pv_dev_name(pv));
384 	log_print("VG Name               %s%s",
385 		  is_orphan(pv) ? "" : pv->vg_name,
386 		  pv->status & EXPORTED_VG ? " (exported)" : "");
387 
388 	data_size = (uint64_t) pv->pe_count * pv->pe_size;
389 	if (pv->size > data_size + pv->pe_start) {
390 		pvsize = pv->size;
391 		unusable = pvsize - data_size;
392 	} else {
393 		pvsize = data_size + pv->pe_start;
394 		unusable = pvsize - pv->size;
395 	}
396 
397 	size = display_size(cmd, pvsize);
398 	if (data_size)
399 		log_print("PV Size               %s / not usable %s",	/*  [LVM: %s]", */
400 			  size, display_size(cmd, unusable));
401 	else
402 		log_print("PV Size               %s", size);
403 
404 	/* PV number not part of LVM2 design
405 	   log_print("PV#                   %u", pv->pv_number);
406 	 */
407 
408 	pe_free = pv->pe_count - pv->pe_alloc_count;
409 	if (pv->pe_count && (pv->status & ALLOCATABLE_PV))
410 		log_print("Allocatable           yes %s",
411 			  (!pe_free && pv->pe_count) ? "(but full)" : "");
412 	else
413 		log_print("Allocatable           NO");
414 
415 	/* LV count is no longer available when displaying PV
416 	   log_print("Cur LV                %u", vg->lv_count);
417 	 */
418 
419 	if (cmd->si_unit_consistency)
420 		log_print("PE Size               %s", display_size(cmd, (uint64_t) pv->pe_size));
421 	else
422 		log_print("PE Size (KByte)       %" PRIu32, pv->pe_size / 2);
423 
424 	log_print("Total PE              %u", pv->pe_count);
425 	log_print("Free PE               %" PRIu32, pe_free);
426 	log_print("Allocated PE          %u", pv->pe_alloc_count);
427 	log_print("PV UUID               %s", *uuid ? uuid : "none");
428 	log_print(" ");
429 
430 	return;
431 }
432 
pvdisplay_short(const struct cmd_context * cmd __attribute ((unused)),const struct volume_group * vg __attribute ((unused)),const struct physical_volume * pv,void * handle __attribute ((unused)))433 int pvdisplay_short(const struct cmd_context *cmd __attribute((unused)),
434 		    const struct volume_group *vg __attribute((unused)),
435 		    const struct physical_volume *pv,
436 		    void *handle __attribute((unused)))
437 {
438 	char uuid[64] __attribute((aligned(8)));
439 
440 	if (!pv)
441 		return 0;
442 
443 	if (!id_write_format(&pv->id, uuid, sizeof(uuid)))
444 		return_0;
445 
446 	log_print("PV Name               %s     ", pv_dev_name(pv));
447 	/* FIXME  pv->pv_number); */
448 	log_print("PV UUID               %s", *uuid ? uuid : "none");
449 	log_print("PV Status             %sallocatable",
450 		  (pv->status & ALLOCATABLE_PV) ? "" : "NOT ");
451 	log_print("Total PE / Free PE    %u / %u",
452 		  pv->pe_count, pv->pe_count - pv->pe_alloc_count);
453 
454 	log_print(" ");
455 	return 0;
456 }
457 
lvdisplay_colons(const struct logical_volume * lv)458 void lvdisplay_colons(const struct logical_volume *lv)
459 {
460 	int inkernel;
461 	struct lvinfo info;
462 	inkernel = lv_info(lv->vg->cmd, lv, &info, 1, 0) && info.exists;
463 
464 	log_print("%s%s/%s:%s:%d:%d:-1:%d:%" PRIu64 ":%d:-1:%d:%d:%d:%d",
465 		  lv->vg->cmd->dev_dir,
466 		  lv->vg->name,
467 		  lv->name,
468 		  lv->vg->name,
469 		  (lv->status & (LVM_READ | LVM_WRITE)) >> 8, inkernel ? 1 : 0,
470 		  /* FIXME lv->lv_number,  */
471 		  inkernel ? info.open_count : 0, lv->size, lv->le_count,
472 		  /* FIXME Add num allocated to struct! lv->lv_allocated_le, */
473 		  (lv->alloc == ALLOC_CONTIGUOUS ? 2 : 0), lv->read_ahead,
474 		  inkernel ? info.major : -1, inkernel ? info.minor : -1);
475 	return;
476 }
477 
lvdisplay_full(struct cmd_context * cmd,const struct logical_volume * lv,void * handle __attribute ((unused)))478 int lvdisplay_full(struct cmd_context *cmd,
479 		   const struct logical_volume *lv,
480 		   void *handle __attribute((unused)))
481 {
482 	struct lvinfo info;
483 	int inkernel, snap_active = 0;
484 	char uuid[64] __attribute((aligned(8)));
485 	struct lv_segment *snap_seg = NULL, *mirror_seg = NULL;
486 	float snap_percent;	/* fused, fsize; */
487 	percent_range_t percent_range;
488 
489 	if (!id_write_format(&lv->lvid.id[1], uuid, sizeof(uuid)))
490 		return_0;
491 
492 	inkernel = lv_info(cmd, lv, &info, 1, 1) && info.exists;
493 
494 	log_print("--- Logical volume ---");
495 
496 	log_print("LV Name                %s%s/%s", lv->vg->cmd->dev_dir,
497 		  lv->vg->name, lv->name);
498 	log_print("VG Name                %s", lv->vg->name);
499 
500 	log_print("LV UUID                %s", uuid);
501 
502 	log_print("LV Write Access        %s",
503 		  (lv->status & LVM_WRITE) ? "read/write" : "read only");
504 
505 	if (lv_is_origin(lv)) {
506 		log_print("LV snapshot status     source of");
507 
508 		dm_list_iterate_items_gen(snap_seg, &lv->snapshot_segs,
509 				       origin_list) {
510 			if (inkernel &&
511 			    (snap_active = lv_snapshot_percent(snap_seg->cow,
512 							       &snap_percent,
513 							       &percent_range)))
514 				if (percent_range == PERCENT_INVALID)
515 					snap_active = 0;
516 			log_print("                       %s%s/%s [%s]",
517 				  lv->vg->cmd->dev_dir, lv->vg->name,
518 				  snap_seg->cow->name,
519 				  snap_active ? "active" : "INACTIVE");
520 		}
521 		snap_seg = NULL;
522 	} else if ((snap_seg = find_cow(lv))) {
523 		if (inkernel &&
524 		    (snap_active = lv_snapshot_percent(snap_seg->cow,
525 						       &snap_percent,
526 						       &percent_range)))
527 			if (percent_range == PERCENT_INVALID)
528 				snap_active = 0;
529 
530 		log_print("LV snapshot status     %s destination for %s%s/%s",
531 			  snap_active ? "active" : "INACTIVE",
532 			  lv->vg->cmd->dev_dir, lv->vg->name,
533 			  snap_seg->origin->name);
534 	}
535 
536 	if (inkernel && info.suspended)
537 		log_print("LV Status              suspended");
538 	else
539 		log_print("LV Status              %savailable",
540 			  inkernel ? "" : "NOT ");
541 
542 /********* FIXME lv_number
543     log_print("LV #                   %u", lv->lv_number + 1);
544 ************/
545 
546 	if (inkernel)
547 		log_print("# open                 %u", info.open_count);
548 
549 	log_print("LV Size                %s",
550 		  display_size(cmd,
551 			       snap_seg ? snap_seg->origin->size : lv->size));
552 
553 	log_print("Current LE             %u",
554 		  snap_seg ? snap_seg->origin->le_count : lv->le_count);
555 
556 	if (snap_seg) {
557 		log_print("COW-table size         %s",
558 			  display_size(cmd, (uint64_t) lv->size));
559 		log_print("COW-table LE           %u", lv->le_count);
560 
561 		if (snap_active)
562 			log_print("Allocated to snapshot  %.2f%% ", snap_percent);
563 
564 		log_print("Snapshot chunk size    %s",
565 			  display_size(cmd, (uint64_t) snap_seg->chunk_size));
566 	}
567 
568 	if (lv->status & MIRRORED) {
569  		mirror_seg = first_seg(lv);
570 		log_print("Mirrored volumes       %" PRIu32, mirror_seg->area_count);
571 		if (lv->status & CONVERTING)
572 			log_print("LV type        Mirror undergoing conversion");
573 	}
574 
575 	log_print("Segments               %u", dm_list_size(&lv->segments));
576 
577 /********* FIXME Stripes & stripesize for each segment
578 	log_print("Stripe size            %s", display_size(cmd, (uint64_t) lv->stripesize));
579 ***********/
580 
581 	log_print("Allocation             %s", get_alloc_string(lv->alloc));
582 	if (lv->read_ahead == DM_READ_AHEAD_AUTO)
583 		log_print("Read ahead sectors     auto");
584 	else if (lv->read_ahead == DM_READ_AHEAD_NONE)
585 		log_print("Read ahead sectors     0");
586 	else
587 		log_print("Read ahead sectors     %u", lv->read_ahead);
588 
589 	if (inkernel && lv->read_ahead != info.read_ahead)
590 		log_print("- currently set to     %u", info.read_ahead);
591 
592 	if (lv->status & FIXED_MINOR) {
593 		if (lv->major >= 0)
594 			log_print("Persistent major       %d", lv->major);
595 		log_print("Persistent minor       %d", lv->minor);
596 	}
597 
598 	if (inkernel)
599 		log_print("Block device           %d:%d", info.major,
600 			  info.minor);
601 
602 	log_print(" ");
603 
604 	return 0;
605 }
606 
display_stripe(const struct lv_segment * seg,uint32_t s,const char * pre)607 void display_stripe(const struct lv_segment *seg, uint32_t s, const char *pre)
608 {
609 	switch (seg_type(seg, s)) {
610 	case AREA_PV:
611 		/* FIXME Re-check the conditions for 'Missing' */
612 		log_print("%sPhysical volume\t%s", pre,
613 			  seg_pv(seg, s) ?
614 			  pv_dev_name(seg_pv(seg, s)) :
615 			    "Missing");
616 
617 		if (seg_pv(seg, s))
618 			log_print("%sPhysical extents\t%d to %d", pre,
619 				  seg_pe(seg, s),
620 				  seg_pe(seg, s) + seg->area_len - 1);
621 		break;
622 	case AREA_LV:
623 		log_print("%sLogical volume\t%s", pre,
624 			  seg_lv(seg, s) ?
625 			  seg_lv(seg, s)->name : "Missing");
626 
627 		if (seg_lv(seg, s))
628 			log_print("%sLogical extents\t%d to %d", pre,
629 				  seg_le(seg, s),
630 				  seg_le(seg, s) + seg->area_len - 1);
631 		break;
632 	case AREA_UNASSIGNED:
633 		log_print("%sUnassigned area", pre);
634 	}
635 }
636 
lvdisplay_segments(const struct logical_volume * lv)637 int lvdisplay_segments(const struct logical_volume *lv)
638 {
639 	const struct lv_segment *seg;
640 
641 	log_print("--- Segments ---");
642 
643 	dm_list_iterate_items(seg, &lv->segments) {
644 		log_print("Logical extent %u to %u:",
645 			  seg->le, seg->le + seg->len - 1);
646 
647 		log_print("  Type\t\t%s", seg->segtype->ops->name(seg));
648 
649 		if (seg->segtype->ops->display)
650 			seg->segtype->ops->display(seg);
651 	}
652 
653 	log_print(" ");
654 	return 1;
655 }
656 
vgdisplay_extents(const struct volume_group * vg __attribute ((unused)))657 void vgdisplay_extents(const struct volume_group *vg __attribute((unused)))
658 {
659 	return;
660 }
661 
vgdisplay_full(const struct volume_group * vg)662 void vgdisplay_full(const struct volume_group *vg)
663 {
664 	uint32_t access_str;
665 	uint32_t active_pvs;
666 	char uuid[64] __attribute((aligned(8)));
667 
668 	active_pvs = vg->pv_count - vg_missing_pv_count(vg);
669 
670 	log_print("--- Volume group ---");
671 	log_print("VG Name               %s", vg->name);
672 	log_print("System ID             %s", vg->system_id);
673 	log_print("Format                %s", vg->fid->fmt->name);
674 	if (vg->fid->fmt->features & FMT_MDAS) {
675 		log_print("Metadata Areas        %d",
676 			  dm_list_size(&vg->fid->metadata_areas));
677 		log_print("Metadata Sequence No  %d", vg->seqno);
678 	}
679 	access_str = vg->status & (LVM_READ | LVM_WRITE);
680 	log_print("VG Access             %s%s%s%s",
681 		  access_str == (LVM_READ | LVM_WRITE) ? "read/write" : "",
682 		  access_str == LVM_READ ? "read" : "",
683 		  access_str == LVM_WRITE ? "write" : "",
684 		  access_str == 0 ? "error" : "");
685 	log_print("VG Status             %s%sresizable",
686 		  vg_is_exported(vg) ? "exported/" : "",
687 		  vg_is_resizeable(vg) ? "" : "NOT ");
688 	/* vg number not part of LVM2 design
689 	   log_print ("VG #                  %u\n", vg->vg_number);
690 	 */
691 	if (vg_is_clustered(vg)) {
692 		log_print("Clustered             yes");
693 		log_print("Shared                %s",
694 			  vg->status & SHARED ? "yes" : "no");
695 	}
696 
697 	log_print("MAX LV                %u", vg->max_lv);
698 	log_print("Cur LV                %u", vg_visible_lvs(vg));
699 	log_print("Open LV               %u", lvs_in_vg_opened(vg));
700 /****** FIXME Max LV Size
701       log_print ( "MAX LV Size           %s",
702                ( s1 = display_size ( LVM_LV_SIZE_MAX(vg))));
703       free ( s1);
704 *********/
705 	log_print("Max PV                %u", vg->max_pv);
706 	log_print("Cur PV                %u", vg->pv_count);
707 	log_print("Act PV                %u", active_pvs);
708 
709 	log_print("VG Size               %s",
710 		  display_size(vg->cmd,
711 			       (uint64_t) vg->extent_count * vg->extent_size));
712 
713 	log_print("PE Size               %s",
714 		  display_size(vg->cmd, (uint64_t) vg->extent_size));
715 
716 	log_print("Total PE              %u", vg->extent_count);
717 
718 	log_print("Alloc PE / Size       %u / %s",
719 		  vg->extent_count - vg->free_count,
720 		  display_size(vg->cmd,
721 			       ((uint64_t) vg->extent_count - vg->free_count) *
722 			       vg->extent_size));
723 
724 	log_print("Free  PE / Size       %u / %s", vg->free_count,
725 		  display_size(vg->cmd, vg_free(vg)));
726 
727 	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
728 		stack;
729 		return;
730 	}
731 
732 	log_print("VG UUID               %s", uuid);
733 	log_print(" ");
734 
735 	return;
736 }
737 
vgdisplay_colons(const struct volume_group * vg)738 void vgdisplay_colons(const struct volume_group *vg)
739 {
740 	uint32_t active_pvs;
741 	const char *access_str;
742 	char uuid[64] __attribute((aligned(8)));
743 
744 	active_pvs = vg->pv_count - vg_missing_pv_count(vg);
745 
746 	switch (vg->status & (LVM_READ | LVM_WRITE)) {
747 		case LVM_READ | LVM_WRITE:
748 			access_str = "r/w";
749 			break;
750 		case LVM_READ:
751 			access_str = "r";
752 			break;
753 		case LVM_WRITE:
754 			access_str = "w";
755 			break;
756 		default:
757 			access_str = "";
758 	}
759 
760 	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
761 		stack;
762 		return;
763 	}
764 
765 	log_print("%s:%s:%d:-1:%u:%u:%u:-1:%u:%u:%u:%" PRIu64 ":%" PRIu32
766 		  ":%u:%u:%u:%s",
767 		vg->name,
768 		access_str,
769 		vg->status,
770 		/* internal volume group number; obsolete */
771 		vg->max_lv,
772 		vg_visible_lvs(vg),
773 		lvs_in_vg_opened(vg),
774 		/* FIXME: maximum logical volume size */
775 		vg->max_pv,
776 		vg->pv_count,
777 		active_pvs,
778 		(uint64_t) vg->extent_count * (vg->extent_size / 2),
779 		vg->extent_size / 2,
780 		vg->extent_count,
781 		vg->extent_count - vg->free_count,
782 		vg->free_count,
783 		uuid[0] ? uuid : "none");
784 	return;
785 }
786 
vgdisplay_short(const struct volume_group * vg)787 void vgdisplay_short(const struct volume_group *vg)
788 {
789 	log_print("\"%s\" %-9s [%-9s used / %s free]", vg->name,
790 /********* FIXME if "open" print "/used" else print "/idle"???  ******/
791 		  display_size(vg->cmd,
792 			       (uint64_t) vg->extent_count * vg->extent_size),
793 		  display_size(vg->cmd,
794 			       ((uint64_t) vg->extent_count -
795 				vg->free_count) * vg->extent_size),
796 		  display_size(vg->cmd, vg_free(vg)));
797 	return;
798 }
799 
display_formats(const struct cmd_context * cmd)800 void display_formats(const struct cmd_context *cmd)
801 {
802 	const struct format_type *fmt;
803 
804 	dm_list_iterate_items(fmt, &cmd->formats) {
805 		log_print("%s", fmt->name);
806 	}
807 }
808 
display_segtypes(const struct cmd_context * cmd)809 void display_segtypes(const struct cmd_context *cmd)
810 {
811 	const struct segment_type *segtype;
812 
813 	dm_list_iterate_items(segtype, &cmd->segtypes) {
814 		log_print("%s", segtype->name);
815 	}
816 }
817 
yes_no_prompt(const char * prompt,...)818 char yes_no_prompt(const char *prompt, ...)
819 {
820 	int c = 0, ret = 0;
821 	va_list ap;
822 
823 	sigint_allow();
824 	do {
825 		if (c == '\n' || !c) {
826 			va_start(ap, prompt);
827 			vprintf(prompt, ap);
828 			va_end(ap);
829 			fflush(stdout);
830 		}
831 
832 		if ((c = getchar()) == EOF) {
833 			ret = 'n';
834 			break;
835 		}
836 
837 		c = tolower(c);
838 		if ((c == 'y') || (c == 'n'))
839 			ret = c;
840 	} while (!ret || c != '\n');
841 
842 	sigint_restore();
843 
844 	if (c != '\n')
845 		printf("\n");
846 
847 	return ret;
848 }
849 
850