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