1 /*	$NetBSD: export.c,v 1.2 2011/05/24 15:51:00 joerg Exp $	*/
2 
3 /*
4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5  * Copyright (C) 2004-2009 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 "import-export.h"
20 #include "metadata.h"
21 #include "display.h"
22 #include "lvm-string.h"
23 #include "segtype.h"
24 #include "text_export.h"
25 #include "lvm-version.h"
26 
27 #include <stdarg.h>
28 #include <time.h>
29 #include <sys/utsname.h>
30 
31 struct formatter;
32 typedef int (*out_with_comment_fn) (struct formatter * f, const char *comment,
33 				    const char *fmt, va_list ap);
34 typedef int (*nl_fn) (struct formatter * f);
35 
36 /*
37  * Macro for formatted output.
38  * out_with_comment_fn returns -1 if data didn't fit and buffer was expanded.
39  * Then argument list is reset and out_with_comment_fn is called again.
40  */
41 #define _out_with_comment(f, buffer, fmt, ap) \
42 	do { \
43 		va_start(ap, fmt); \
44 		r = f->out_with_comment(f, buffer, fmt, ap); \
45 		va_end(ap); \
46 	} while (r == -1)
47 
48 /*
49  * The first half of this file deals with
50  * exporting the vg, ie. writing it to a file.
51  */
52 struct formatter {
53 	struct dm_pool *mem;	/* pv names allocated from here */
54 	struct dm_hash_table *pv_names;	/* dev_name -> pv_name (eg, pv1) */
55 
56 	union {
57 		FILE *fp;	/* where we're writing to */
58 		struct {
59 			char *start;
60 			uint32_t size;
61 			uint32_t used;
62 		} buf;
63 	} data;
64 
65 	out_with_comment_fn out_with_comment;
66 	nl_fn nl;
67 
68 	int indent;		/* current level of indentation */
69 	int error;
70 	int header;		/* 1 => comments at start; 0 => end */
71 };
72 
73 static struct utsname _utsname;
74 
_init(void)75 static void _init(void)
76 {
77 	static int _initialised = 0;
78 
79 	if (_initialised)
80 		return;
81 
82 	if (uname(&_utsname)) {
83 		log_error("uname failed: %s", strerror(errno));
84 		memset(&_utsname, 0, sizeof(_utsname));
85 	}
86 
87 	_initialised = 1;
88 }
89 
90 /*
91  * Formatting functions.
92  */
93 
94 #define MAX_INDENT 5
_inc_indent(struct formatter * f)95 static void _inc_indent(struct formatter *f)
96 {
97 	if (++f->indent > MAX_INDENT)
98 		f->indent = MAX_INDENT;
99 }
100 
_dec_indent(struct formatter * f)101 static void _dec_indent(struct formatter *f)
102 {
103 	if (!f->indent--) {
104 		log_error("Internal error tracking indentation");
105 		f->indent = 0;
106 	}
107 }
108 
109 /*
110  * Newline function for prettier layout.
111  */
_nl_file(struct formatter * f)112 static int _nl_file(struct formatter *f)
113 {
114 	fprintf(f->data.fp, "\n");
115 
116 	return 1;
117 }
118 
_extend_buffer(struct formatter * f)119 static int _extend_buffer(struct formatter *f)
120 {
121 	char *newbuf;
122 
123 	log_debug("Doubling metadata output buffer to %" PRIu32,
124 		  f->data.buf.size * 2);
125 	if (!(newbuf = dm_realloc(f->data.buf.start,
126 				   f->data.buf.size * 2))) {
127 		log_error("Buffer reallocation failed.");
128 		return 0;
129 	}
130 	f->data.buf.start = newbuf;
131 	f->data.buf.size *= 2;
132 
133 	return 1;
134 }
135 
_nl_raw(struct formatter * f)136 static int _nl_raw(struct formatter *f)
137 {
138 	/* If metadata doesn't fit, extend buffer */
139 	if ((f->data.buf.used + 2 > f->data.buf.size) &&
140 	    (!_extend_buffer(f)))
141 		return_0;
142 
143 	*(f->data.buf.start + f->data.buf.used) = '\n';
144 	f->data.buf.used += 1;
145 
146 	*(f->data.buf.start + f->data.buf.used) = '\0';
147 
148 	return 1;
149 }
150 
151 #define COMMENT_TAB 6
_out_with_comment_file(struct formatter * f,const char * comment,const char * fmt,va_list ap)152 static int _out_with_comment_file(struct formatter *f, const char *comment,
153 				  const char *fmt, va_list ap)
154 {
155 	int i;
156 	char white_space[MAX_INDENT + 1];
157 
158 	if (ferror(f->data.fp))
159 		return 0;
160 
161 	for (i = 0; i < f->indent; i++)
162 		white_space[i] = '\t';
163 	white_space[i] = '\0';
164 	fputs(white_space, f->data.fp);
165 	i = vfprintf(f->data.fp, fmt, ap);
166 
167 	if (comment) {
168 		/*
169 		 * line comments up if possible.
170 		 */
171 		i += 8 * f->indent;
172 		i /= 8;
173 		i++;
174 
175 		do
176 			fputc('\t', f->data.fp);
177 
178 		while (++i < COMMENT_TAB);
179 
180 		fputs(comment, f->data.fp);
181 	}
182 	fputc('\n', f->data.fp);
183 
184 	return 1;
185 }
186 
_out_with_comment_raw(struct formatter * f,const char * comment __attribute ((unused)),const char * fmt,va_list ap)187 static int _out_with_comment_raw(struct formatter *f,
188 				 const char *comment __attribute((unused)),
189 				 const char *fmt, va_list ap)
190 {
191 	int n;
192 
193 	n = vsnprintf(f->data.buf.start + f->data.buf.used,
194 		      f->data.buf.size - f->data.buf.used, fmt, ap);
195 
196 	/* If metadata doesn't fit, extend buffer */
197 	if (n < 0 || (n + f->data.buf.used + 2 > f->data.buf.size)) {
198 		if (!_extend_buffer(f))
199 			return_0;
200 		return -1; /* Retry */
201 	}
202 
203 	f->data.buf.used += n;
204 
205 	outnl(f);
206 
207 	return 1;
208 }
209 
210 /*
211  * Formats a string, converting a size specified
212  * in 512-byte sectors to a more human readable
213  * form (eg, megabytes).  We may want to lift this
214  * for other code to use.
215  */
_sectors_to_units(uint64_t sectors,char * buffer,size_t s)216 static int _sectors_to_units(uint64_t sectors, char *buffer, size_t s)
217 {
218 	static const char *_units[] = {
219 		"Kilobytes",
220 		"Megabytes",
221 		"Gigabytes",
222 		"Terabytes",
223 		"Petabytes",
224 		"Exabytes",
225 		NULL
226 	};
227 
228 	int i;
229 	double d = (double) sectors;
230 
231 	/* to convert to K */
232 	d /= 2.0;
233 
234 	for (i = 0; (d > 1024.0) && _units[i]; i++)
235 		d /= 1024.0;
236 
237 	return dm_snprintf(buffer, s, "# %g %s", d, _units[i]) > 0;
238 }
239 
240 /* increment indention level */
out_inc_indent(struct formatter * f)241 void out_inc_indent(struct formatter *f)
242 {
243 	_inc_indent(f);
244 }
245 
246 /* decrement indention level */
out_dec_indent(struct formatter * f)247 void out_dec_indent(struct formatter *f)
248 {
249 	_dec_indent(f);
250 }
251 
252 /* insert new line */
out_newline(struct formatter * f)253 int out_newline(struct formatter *f)
254 {
255 	return f->nl(f);
256 }
257 
258 /*
259  * Appends a comment giving a size in more easily
260  * readable form (eg, 4M instead of 8096).
261  */
out_size(struct formatter * f,uint64_t size,const char * fmt,...)262 int out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
263 {
264 	char buffer[64];
265 	va_list ap;
266 	int r;
267 
268 	if (!_sectors_to_units(size, buffer, sizeof(buffer)))
269 		return 0;
270 
271 	_out_with_comment(f, buffer, fmt, ap);
272 
273 	return r;
274 }
275 
276 /*
277  * Appends a comment indicating that the line is
278  * only a hint.
279  */
out_hint(struct formatter * f,const char * fmt,...)280 int out_hint(struct formatter *f, const char *fmt, ...)
281 {
282 	va_list ap;
283 	int r;
284 
285 	_out_with_comment(f, "# Hint only", fmt, ap);
286 
287 	return r;
288 }
289 
290 /*
291  * Appends a comment
292  */
_out_comment(struct formatter * f,const char * comment,const char * fmt,...)293 static int _out_comment(struct formatter *f, const char *comment, const char *fmt, ...)
294 {
295 	va_list ap;
296 	int r;
297 
298 	_out_with_comment(f, comment, fmt, ap);
299 
300 	return r;
301 }
302 
303 /*
304  * The normal output function.
305  */
out_text(struct formatter * f,const char * fmt,...)306 int out_text(struct formatter *f, const char *fmt, ...)
307 {
308 	va_list ap;
309 	int r;
310 
311 	_out_with_comment(f, NULL, fmt, ap);
312 
313 	return r;
314 }
315 
_out_line(const char * line,void * _f)316 static int _out_line(const char *line, void *_f) {
317 	struct formatter *f = (struct formatter *) _f;
318 	return out_text(f, "%s", line);
319 }
320 
out_config_node(struct formatter * f,const struct config_node * cn)321 int out_config_node(struct formatter *f, const struct config_node *cn)
322 {
323 	return write_config_node(cn, _out_line, f);
324 }
325 
_print_header(struct formatter * f,const char * desc)326 static int _print_header(struct formatter *f,
327 			 const char *desc)
328 {
329 	char *buf;
330 	time_t t;
331 
332 	t = time(NULL);
333 
334 	outf(f, "# Generated by LVM2 version %s: %s", LVM_VERSION, ctime(&t));
335 	outf(f, CONTENTS_FIELD " = \"" CONTENTS_VALUE "\"");
336 	outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE);
337 	outnl(f);
338 
339 	if (!(buf = alloca(escaped_len(desc)))) {
340 		log_error("temporary stack allocation for description"
341 			  "string failed");
342 		return 0;
343 	}
344 	outf(f, "description = \"%s\"", escape_double_quotes(buf, desc));
345 	outnl(f);
346 	outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename,
347 	     _utsname.sysname, _utsname.nodename, _utsname.release,
348 	     _utsname.version, _utsname.machine);
349 	outf(f, "creation_time = %jd\t# %s", (intmax_t)t, ctime(&t));
350 
351 	return 1;
352 }
353 
_print_flag_config(struct formatter * f,int status,int type)354 static int _print_flag_config(struct formatter *f, int status, int type)
355 {
356 	char buffer[4096];
357 	if (!print_flags(status, type | STATUS_FLAG, buffer, sizeof(buffer)))
358 		return_0;
359 	outf(f, "status = %s", buffer);
360 
361 	if (!print_flags(status, type, buffer, sizeof(buffer)))
362 		return_0;
363 	outf(f, "flags = %s", buffer);
364 
365 	return 1;
366 }
367 
_print_vg(struct formatter * f,struct volume_group * vg)368 static int _print_vg(struct formatter *f, struct volume_group *vg)
369 {
370 	char buffer[4096];
371 
372 	if (!id_write_format(&vg->id, buffer, sizeof(buffer)))
373 		return_0;
374 
375 	outf(f, "id = \"%s\"", buffer);
376 
377 	outf(f, "seqno = %u", vg->seqno);
378 
379 	if (!_print_flag_config(f, vg->status, VG_FLAGS))
380 		return_0;
381 
382 	if (!dm_list_empty(&vg->tags)) {
383 		if (!print_tags(&vg->tags, buffer, sizeof(buffer)))
384 			return_0;
385 		outf(f, "tags = %s", buffer);
386 	}
387 
388 	if (vg->system_id && *vg->system_id)
389 		outf(f, "system_id = \"%s\"", vg->system_id);
390 
391 	if (!out_size(f, (uint64_t) vg->extent_size, "extent_size = %u",
392 		      vg->extent_size))
393 		return_0;
394 	outf(f, "max_lv = %u", vg->max_lv);
395 	outf(f, "max_pv = %u", vg->max_pv);
396 
397 	/* Default policy is NORMAL; INHERIT is meaningless */
398 	if (vg->alloc != ALLOC_NORMAL && vg->alloc != ALLOC_INHERIT) {
399 		outnl(f);
400 		outf(f, "allocation_policy = \"%s\"",
401 		     get_alloc_string(vg->alloc));
402 	}
403 
404 	return 1;
405 }
406 
407 /*
408  * Get the pv%d name from the formatters hash
409  * table.
410  */
_get_pv_name_from_uuid(struct formatter * f,char * uuid)411 static const char *_get_pv_name_from_uuid(struct formatter *f, char *uuid)
412 {
413 	return dm_hash_lookup(f->pv_names, uuid);
414 }
415 
_get_pv_name(struct formatter * f,struct physical_volume * pv)416 static const char *_get_pv_name(struct formatter *f, struct physical_volume *pv)
417 {
418 	char uuid[64] __attribute((aligned(8)));
419 
420 	if (!pv || !id_write_format(&pv->id, uuid, sizeof(uuid)))
421 		return_NULL;
422 
423 	return _get_pv_name_from_uuid(f, uuid);
424 }
425 
_print_pvs(struct formatter * f,struct volume_group * vg)426 static int _print_pvs(struct formatter *f, struct volume_group *vg)
427 {
428 	struct pv_list *pvl;
429 	struct physical_volume *pv;
430 	char buffer[4096];
431 	char *buf;
432 	const char *name;
433 
434 	outf(f, "physical_volumes {");
435 	_inc_indent(f);
436 
437 	dm_list_iterate_items(pvl, &vg->pvs) {
438 		pv = pvl->pv;
439 
440 		if (!id_write_format(&pv->id, buffer, sizeof(buffer)))
441 			return_0;
442 
443 		if (!(name = _get_pv_name_from_uuid(f, buffer)))
444 			return_0;
445 
446 		outnl(f);
447 		outf(f, "%s {", name);
448 		_inc_indent(f);
449 
450 		outf(f, "id = \"%s\"", buffer);
451 
452 		if (!(buf = alloca(escaped_len(pv_dev_name(pv))))) {
453 			log_error("temporary stack allocation for device name"
454 				  "string failed");
455 			return 0;
456 		}
457 
458 		if (!out_hint(f, "device = \"%s\"",
459 			      escape_double_quotes(buf, pv_dev_name(pv))))
460 			return_0;
461 		outnl(f);
462 
463 		if (!_print_flag_config(f, pv->status, PV_FLAGS))
464 			return_0;
465 
466 		if (!dm_list_empty(&pv->tags)) {
467 			if (!print_tags(&pv->tags, buffer, sizeof(buffer)))
468 				return_0;
469 			outf(f, "tags = %s", buffer);
470 		}
471 
472 		if (!out_size(f, pv->size, "dev_size = %" PRIu64, pv->size))
473 			return_0;
474 
475 		outf(f, "pe_start = %" PRIu64, pv->pe_start);
476 		if (!out_size(f, vg->extent_size * (uint64_t) pv->pe_count,
477 			      "pe_count = %u", pv->pe_count))
478 			return_0;
479 
480 		_dec_indent(f);
481 		outf(f, "}");
482 	}
483 
484 	_dec_indent(f);
485 	outf(f, "}");
486 	return 1;
487 }
488 
_print_segment(struct formatter * f,struct volume_group * vg,int count,struct lv_segment * seg)489 static int _print_segment(struct formatter *f, struct volume_group *vg,
490 			  int count, struct lv_segment *seg)
491 {
492 	char buffer[4096];
493 
494 	outf(f, "segment%u {", count);
495 	_inc_indent(f);
496 
497 	outf(f, "start_extent = %u", seg->le);
498 	if (!out_size(f, (uint64_t) seg->len * vg->extent_size,
499 		      "extent_count = %u", seg->len))
500 		return_0;
501 
502 	outnl(f);
503 	outf(f, "type = \"%s\"", seg->segtype->name);
504 
505 	if (!dm_list_empty(&seg->tags)) {
506 		if (!print_tags(&seg->tags, buffer, sizeof(buffer)))
507 			return_0;
508 		outf(f, "tags = %s", buffer);
509 	}
510 
511 	if (seg->segtype->ops->text_export &&
512 	    !seg->segtype->ops->text_export(seg, f))
513 		return_0;
514 
515 	_dec_indent(f);
516 	outf(f, "}");
517 
518 	return 1;
519 }
520 
out_areas(struct formatter * f,const struct lv_segment * seg,const char * type)521 int out_areas(struct formatter *f, const struct lv_segment *seg,
522 	      const char *type)
523 {
524 	const char *name;
525 	unsigned int s;
526 
527 	outnl(f);
528 
529 	outf(f, "%ss = [", type);
530 	_inc_indent(f);
531 
532 	for (s = 0; s < seg->area_count; s++) {
533 		switch (seg_type(seg, s)) {
534 		case AREA_PV:
535 			if (!(name = _get_pv_name(f, seg_pv(seg, s))))
536 				return_0;
537 
538 			outf(f, "\"%s\", %u%s", name,
539 			     seg_pe(seg, s),
540 			     (s == seg->area_count - 1) ? "" : ",");
541 			break;
542 		case AREA_LV:
543 			outf(f, "\"%s\", %u%s",
544 			     seg_lv(seg, s)->name,
545 			     seg_le(seg, s),
546 			     (s == seg->area_count - 1) ? "" : ",");
547 			break;
548 		case AREA_UNASSIGNED:
549 			return 0;
550 		}
551 	}
552 
553 	_dec_indent(f);
554 	outf(f, "]");
555 	return 1;
556 }
557 
_print_lv(struct formatter * f,struct logical_volume * lv)558 static int _print_lv(struct formatter *f, struct logical_volume *lv)
559 {
560 	struct lv_segment *seg;
561 	char buffer[4096];
562 	int seg_count;
563 
564 	outnl(f);
565 	outf(f, "%s {", lv->name);
566 	_inc_indent(f);
567 
568 	/* FIXME: Write full lvid */
569 	if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer)))
570 		return_0;
571 
572 	outf(f, "id = \"%s\"", buffer);
573 
574 	if (!_print_flag_config(f, lv->status, LV_FLAGS))
575 		return_0;
576 
577 	if (!dm_list_empty(&lv->tags)) {
578 		if (!print_tags(&lv->tags, buffer, sizeof(buffer)))
579 			return_0;
580 		outf(f, "tags = %s", buffer);
581 	}
582 
583 	if (lv->alloc != ALLOC_INHERIT)
584 		outf(f, "allocation_policy = \"%s\"",
585 		     get_alloc_string(lv->alloc));
586 
587 	switch (lv->read_ahead) {
588 	case DM_READ_AHEAD_NONE:
589 		_out_comment(f, "# None", "read_ahead = -1");
590 		break;
591 	case DM_READ_AHEAD_AUTO:
592 		/* No output - use default */
593 		break;
594 	default:
595 		outf(f, "read_ahead = %u", lv->read_ahead);
596 	}
597 
598 	if (lv->major >= 0)
599 		outf(f, "major = %d", lv->major);
600 	if (lv->minor >= 0)
601 		outf(f, "minor = %d", lv->minor);
602 	outf(f, "segment_count = %u", dm_list_size(&lv->segments));
603 	outnl(f);
604 
605 	seg_count = 1;
606 	dm_list_iterate_items(seg, &lv->segments) {
607 		if (!_print_segment(f, lv->vg, seg_count++, seg))
608 			return_0;
609 	}
610 
611 	_dec_indent(f);
612 	outf(f, "}");
613 
614 	return 1;
615 }
616 
_print_lvs(struct formatter * f,struct volume_group * vg)617 static int _print_lvs(struct formatter *f, struct volume_group *vg)
618 {
619 	struct lv_list *lvl;
620 
621 	/*
622 	 * Don't bother with an lv section if there are no lvs.
623 	 */
624 	if (dm_list_empty(&vg->lvs))
625 		return 1;
626 
627 	outf(f, "logical_volumes {");
628 	_inc_indent(f);
629 
630 	/*
631 	 * Write visible LVs first
632 	 */
633 	dm_list_iterate_items(lvl, &vg->lvs) {
634 		if (!(lv_is_visible(lvl->lv)))
635 			continue;
636 		if (!_print_lv(f, lvl->lv))
637 			return_0;
638 	}
639 
640 	dm_list_iterate_items(lvl, &vg->lvs) {
641 		if ((lv_is_visible(lvl->lv)))
642 			continue;
643 		if (!_print_lv(f, lvl->lv))
644 			return_0;
645 	}
646 
647 	_dec_indent(f);
648 	outf(f, "}");
649 
650 	return 1;
651 }
652 
653 /*
654  * In the text format we refer to pv's as 'pv1',
655  * 'pv2' etc.  This function builds a hash table
656  * to enable a quick lookup from device -> name.
657  */
_build_pv_names(struct formatter * f,struct volume_group * vg)658 static int _build_pv_names(struct formatter *f, struct volume_group *vg)
659 {
660 	int count = 0;
661 	struct pv_list *pvl;
662 	struct physical_volume *pv;
663 	char buffer[32], *uuid, *name;
664 
665 	if (!(f->mem = dm_pool_create("text pv_names", 512)))
666 		return_0;
667 
668 	if (!(f->pv_names = dm_hash_create(128)))
669 		return_0;
670 
671 	dm_list_iterate_items(pvl, &vg->pvs) {
672 		pv = pvl->pv;
673 
674 		/* FIXME But skip if there's already an LV called pv%d ! */
675 		if (dm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0)
676 			return_0;
677 
678 		if (!(name = dm_pool_strdup(f->mem, buffer)))
679 			return_0;
680 
681 		if (!(uuid = dm_pool_zalloc(f->mem, 64)) ||
682 		   !id_write_format(&pv->id, uuid, 64))
683 			return_0;
684 
685 		if (!dm_hash_insert(f->pv_names, uuid, name))
686 			return_0;
687 	}
688 
689 	return 1;
690 }
691 
_text_vg_export(struct formatter * f,struct volume_group * vg,const char * desc)692 static int _text_vg_export(struct formatter *f,
693 			   struct volume_group *vg, const char *desc)
694 {
695 	int r = 0;
696 
697 	if (!_build_pv_names(f, vg))
698 		goto_out;
699 
700 	if (f->header && !_print_header(f, desc))
701 		goto_out;
702 
703 	if (!out_text(f, "%s {", vg->name))
704 		goto_out;
705 
706 	_inc_indent(f);
707 
708 	if (!_print_vg(f, vg))
709 		goto_out;
710 
711 	outnl(f);
712 	if (!_print_pvs(f, vg))
713 		goto_out;
714 
715 	outnl(f);
716 	if (!_print_lvs(f, vg))
717 		goto_out;
718 
719 	_dec_indent(f);
720 	if (!out_text(f, "}"))
721 		goto_out;
722 
723 	if (!f->header && !_print_header(f, desc))
724 		goto_out;
725 
726 	r = 1;
727 
728       out:
729 	if (f->mem)
730 		dm_pool_destroy(f->mem);
731 
732 	if (f->pv_names)
733 		dm_hash_destroy(f->pv_names);
734 
735 	return r;
736 }
737 
text_vg_export_file(struct volume_group * vg,const char * desc,FILE * fp)738 int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
739 {
740 	struct formatter *f;
741 	int r;
742 
743 	_init();
744 
745 	if (!(f = dm_malloc(sizeof(*f))))
746 		return_0;
747 
748 	memset(f, 0, sizeof(*f));
749 	f->data.fp = fp;
750 	f->indent = 0;
751 	f->header = 1;
752 	f->out_with_comment = &_out_with_comment_file;
753 	f->nl = &_nl_file;
754 
755 	r = _text_vg_export(f, vg, desc);
756 	if (r)
757 		r = !ferror(f->data.fp);
758 	dm_free(f);
759 	return r;
760 }
761 
762 /* Returns amount of buffer used incl. terminating NUL */
text_vg_export_raw(struct volume_group * vg,const char * desc,char ** buf)763 int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf)
764 {
765 	struct formatter *f;
766 	int r = 0;
767 
768 	_init();
769 
770 	if (!(f = dm_malloc(sizeof(*f))))
771 		return_0;
772 
773 	memset(f, 0, sizeof(*f));
774 
775 	f->data.buf.size = 65536;	/* Initial metadata limit */
776 	if (!(f->data.buf.start = dm_malloc(f->data.buf.size))) {
777 		log_error("text_export buffer allocation failed");
778 		goto out;
779 	}
780 
781 	f->indent = 0;
782 	f->header = 0;
783 	f->out_with_comment = &_out_with_comment_raw;
784 	f->nl = &_nl_raw;
785 
786 	if (!_text_vg_export(f, vg, desc)) {
787 		dm_free(f->data.buf.start);
788 		goto_out;
789 	}
790 
791 	r = f->data.buf.used + 1;
792 	*buf = f->data.buf.start;
793 
794       out:
795 	dm_free(f);
796 	return r;
797 }
798 
export_vg_to_buffer(struct volume_group * vg,char ** buf)799 int export_vg_to_buffer(struct volume_group *vg, char **buf)
800 {
801 	return text_vg_export_raw(vg, "", buf);
802 }
803 
804 #undef outf
805 #undef outnl
806