1/* $NetBSD: lvm2app.h,v 1.1.1.1 2009/12/02 00:26:15 haad Exp $ */ 2 3/* 4 * Copyright (C) 2008,2009 Red Hat, Inc. All rights reserved. 5 * 6 * This file is part of LVM2. 7 * 8 * This copyrighted material is made available to anyone wishing to use, 9 * modify, copy, or redistribute it subject to the terms and conditions 10 * of the GNU Lesser General Public License v.2.1. 11 * 12 * You should have received a copy of the GNU Lesser General Public License 13 * along with this program; if not, write to the Free Software Foundation, 14 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 */ 16#ifndef _LIB_LVM2APP_H 17#define _LIB_LVM2APP_H 18 19#include "libdevmapper.h" 20 21#include <stdint.h> 22 23 24/******************************** WARNING *********************************** 25 * 26 * NOTE: This API is under development and subject to change at any time. 27 * 28 * Please send feedback to lvm-devel@redhat.com 29 * 30 *********************************** WARNING ********************************/ 31 32/*************************** Design Overview ********************************/ 33 34/** 35 * \mainpage LVM library API 36 * 37 * The API is designed around the following basic LVM objects: 38 * 1) Physical Volume (PV) 2) Volume Group (VG) 3) Logical Volume (LV). 39 * 40 * The library provides functions to list the objects in a system, 41 * get and set object properties (such as names, UUIDs, and sizes), as well 42 * as create/remove objects and perform more complex operations and 43 * transformations. Each object instance is represented by a handle, and 44 * handles are passed to and from the functions to perform the operations. 45 * 46 * A central object in the library is the Volume Group, represented by the 47 * VG handle, vg_t. Performing an operation on a PV or LV object first 48 * requires obtaining a VG handle. Once the vg_t has been obtained, it can 49 * be used to enumerate the pv_t's and lv_t's within that vg_t. Attributes 50 * of these objects can then be queried. 51 * 52 * A volume group handle may be obtained with read or write permission. 53 * Any attempt to change a property of a pv_t, vg_t, or lv_t without 54 * obtaining write permission on the vg_t will fail with EPERM. 55 * 56 * An application first opening a VG read-only, then later wanting to change 57 * a property of an object must first close the VG and re-open with write 58 * permission. Currently liblvm provides no mechanism to determine whether 59 * the VG has changed on-disk in between these operations - this is the 60 * application's responsiblity. One way the application can ensure the VG 61 * has not changed is to save the "vg_seqno" field after opening the VG with 62 * READ permission. If the application later needs to modify the VG, it can 63 * close the VG and re-open with WRITE permission. It should then check 64 * whether the original "vg_seqno" obtained with READ permission matches 65 * the new one obtained with WRITE permission. 66 */ 67 68/** 69 * Retrieve the library version. 70 * 71 * The library version is the same format as the full LVM version. 72 * The format is as follows: 73 * LVM_MAJOR.LVM_MINOR.LVM_PATCHLEVEL(LVM_LIBAPI)[-LVM_RELEASE] 74 * An application wishing to determine compatibility with a particular version 75 * of the library should check at least the LVM_MAJOR, LVM_MINOR, and 76 * LVM_LIBAPI numbers. For example, assume the full LVM version is 77 * 2.02.50(1)-1. The application should verify the "2.02" and the "(1)". 78 * 79 * \return A string describing the library version. 80 */ 81const char *lvm_library_get_version(void); 82 83/******************************** structures ********************************/ 84 85/** 86 * Opaque structures - do not use directly. Internal structures may change 87 * without notice between releases, whereas this API will be changed much less 88 * frequently. Backwards compatibility will normally be preserved in future 89 * releases. On any occasion when the developers do decide to break backwards 90 * compatibility in any significant way, the LVM_LIBAPI number (included in 91 * the library's soname) will be incremented. 92 */ 93struct lvm; 94struct physical_volume; 95struct volume_group; 96struct logical_volume; 97 98/** 99 * lvm handle. 100 * 101 * This is the base handle that is needed to open and create objects such as 102 * volume groups and logical volumes. In addition, this handle provides a 103 * context for error handling information, saving any error number (see 104 * lvm_errno) and error message (see lvm_errmsg) that any function may 105 * generate. 106 */ 107typedef struct lvm *lvm_t; 108 109/** 110 * Volume group object. 111 * 112 * This object can be either a read-only object or a read-write object 113 * depending on the mode it was returned by a function. Create functions 114 * return a read-write object, but open functions have the argument mode to 115 * define if the object can be modified or not. 116 */ 117typedef struct volume_group *vg_t; 118 119/** 120 * Logical Volume object. 121 * 122 * This object is bound to a volume group and has the same mode of the volume 123 * group. Changes will be written to disk when the volume group gets 124 * committed to disk. 125 */ 126typedef struct logical_volume *lv_t; 127 128/** 129 * Physical volume object. 130 * 131 * This object is bound to a volume group and has the same mode of the volume 132 * group. Changes will be written to disk when the volume group gets 133 * committed to disk. 134 */ 135typedef struct physical_volume *pv_t; 136 137/** 138 * Logical Volume object list. 139 * 140 * Lists of these structures are returned by lvm_vg_list_pvs. 141 */ 142typedef struct lvm_lv_list { 143 struct dm_list list; 144 lv_t lv; 145} lv_list_t; 146 147/** 148 * Physical volume object list. 149 * 150 * Lists of these structures are returned by lvm_vg_list_pvs. 151 */ 152typedef struct lvm_pv_list { 153 struct dm_list list; 154 pv_t pv; 155} pv_list_t; 156 157/** 158 * String list. 159 * 160 * This string list contains read-only strings. 161 * Lists of these structures are returned by lvm_list_vg_names and 162 * lvm_list_vg_uuids. 163 */ 164struct lvm_str_list { 165 struct dm_list list; 166 const char *str; 167}; 168 169/*************************** generic lvm handling ***************************/ 170/** 171 * Create a LVM handle. 172 * 173 * Once all LVM operations have been completed, use lvm_quit to release 174 * the handle and any associated resources. 175 * 176 * \param system_dir 177 * Set an alternative LVM system directory. Use NULL to use the 178 * default value. If the environment variable LVM_SYSTEM_DIR is set, 179 * it will override any system_dir setting. 180 * 181 * \return 182 * A valid LVM handle is returned or NULL if there has been a 183 * memory allocation problem. You have to check if an error occured 184 * with the lvm_error function. 185 */ 186lvm_t lvm_init(const char *system_dir); 187 188/** 189 * Destroy a LVM handle allocated with lvm_init. 190 * 191 * This function should be used after all LVM operations are complete or after 192 * an unrecoverable error. Destroying the LVM handle frees the memory and 193 * other resources associated with the handle. Once destroyed, the handle 194 * cannot be used subsequently. 195 * 196 * \param libh 197 * Handle obtained from lvm_init. 198 */ 199void lvm_quit(lvm_t libh); 200 201/** 202 * Reload the original configuration from the system directory. 203 * 204 * This function should be used when any LVM configuration changes in the LVM 205 * system_dir or by another lvm_config* function, and the change is needed by 206 * the application. 207 * 208 * \param libh 209 * Handle obtained from lvm_init. 210 * 211 * \return 212 * 0 (success) or -1 (failure). 213 */ 214int lvm_config_reload(lvm_t libh); 215 216/** 217 * Override the LVM configuration with a configuration string. 218 * 219 * This function is equivalent to the --config option on lvm commands. 220 * Once this API has been used to over-ride the configuration, 221 * use lvm_config_reload to apply the new settings. 222 * 223 * \param libh 224 * Handle obtained from lvm_init. 225 * 226 * \param config_string 227 * LVM configuration string to apply. See the lvm.conf file man page 228 * for the format of the config string. 229 * 230 * \return 231 * 0 (success) or -1 (failure). 232 */ 233int lvm_config_override(lvm_t libh, const char *config_string); 234 235/** 236 * Return stored error no describing last LVM API error. 237 * 238 * Users of liblvm should use lvm_errno to determine the details of a any 239 * failure of the last call. A basic success or fail is always returned by 240 * every function, either by returning a 0 or -1, or a non-NULL / NULL. 241 * If a function has failed, lvm_errno may be used to get a more specific 242 * error code describing the failure. In this way, lvm_errno may be used 243 * after every function call, even after a 'get' function call that simply 244 * returns a value. 245 * 246 * \param libh 247 * Handle obtained from lvm_init. 248 * 249 * \return 250 * An errno value describing the last LVM error. 251 */ 252int lvm_errno(lvm_t libh); 253 254/** 255 * Return stored error message describing last LVM error. 256 * 257 * This function may be used in conjunction with lvm_errno to obtain more 258 * specific error information for a function that is known to have failed. 259 * 260 * \param libh 261 * Handle obtained from lvm_init. 262 * 263 * \return 264 * An error string describing the last LVM error. 265 */ 266const char *lvm_errmsg(lvm_t libh); 267 268/** 269 * Scan all devices on the system for VGs and LVM metadata. 270 * 271 * \return 272 * 0 (success) or -1 (failure). 273 */ 274int lvm_scan(lvm_t libh); 275 276/*************************** volume group handling **************************/ 277 278/** 279 * Return the list of volume group names. 280 * 281 * The memory allocated for the list is tied to the lvm_t handle and will be 282 * released when lvm_quit is called. 283 * 284 * NOTE: This function normally does not scan devices in the system for LVM 285 * metadata. To scan the system, use lvm_scan. 286 * NOTE: This function currently returns hidden VG names. These names always 287 * begin with a "#" and should be filtered out and not used. 288 * 289 * To process the list, use the dm_list iterator functions. For example: 290 * vg_t vg; 291 * struct dm_list *vgnames; 292 * struct lvm_str_list *strl; 293 * 294 * vgnames = lvm_list_vg_names(libh); 295 * dm_list_iterate_items(strl, vgnames) { 296 * vgname = strl->str; 297 * vg = lvm_vg_open(libh, vgname, "r"); 298 * // do something with vg 299 * lvm_vg_close(vg); 300 * } 301 * 302 * 303 * \return 304 * A list with entries of type struct lvm_str_list, containing the 305 * VG name strings of the Volume Groups known to the system. 306 * NULL is returned if unable to allocate memory. 307 * An empty list (verify with dm_list_empty) is returned if no VGs 308 * exist on the system. 309 */ 310struct dm_list *lvm_list_vg_names(lvm_t libh); 311 312/** 313 * Return the list of volume group uuids. 314 * 315 * The memory allocated for the list is tied to the lvm_t handle and will be 316 * released when lvm_quit is called. 317 * 318 * NOTE: This function normally does not scan devices in the system for LVM 319 * metadata. To scan the system, use lvm_scan. 320 * NOTE: This function currently returns hidden VG names. These names always 321 * begin with a "#" and should be filtered out and not used. 322 * 323 * \param libh 324 * Handle obtained from lvm_init. 325 * 326 * \return 327 * A list with entries of type struct lvm_str_list, containing the 328 * VG UUID strings of the Volume Groups known to the system. 329 * NULL is returned if unable to allocate memory. 330 * An empty list (verify with dm_list_empty) is returned if no VGs 331 * exist on the system. 332 */ 333struct dm_list *lvm_list_vg_uuids(lvm_t libh); 334 335/** 336 * Open an existing VG. 337 * 338 * Open a VG for reading or writing. 339 * 340 * \param libh 341 * Handle obtained from lvm_init. 342 * 343 * \param vgname 344 * Name of the VG to open. 345 * 346 * \param mode 347 * Open mode - either "r" (read) or "w" (read/write). 348 * Any other character results in an error with EINVAL set. 349 * 350 * \param flags 351 * Open flags - currently ignored. 352 * 353 * \return non-NULL VG handle (success) or NULL (failure). 354 */ 355vg_t lvm_vg_open(lvm_t libh, const char *vgname, const char *mode, 356 uint32_t flags); 357 358/** 359 * Create a VG with default parameters. 360 * 361 * This function creates a Volume Group object in memory. 362 * Upon success, other APIs may be used to set non-default parameters. 363 * For example, to set a non-default extent size, use lvm_vg_set_extent_size. 364 * Next, to add physical storage devices to the volume group, use 365 * lvm_vg_extend for each device. 366 * Once all parameters are set appropriately and all devices are added to the 367 * VG, use lvm_vg_write to commit the new VG to disk, and lvm_vg_close to 368 * release the VG handle. 369 * 370 * \param libh 371 * Handle obtained from lvm_init. 372 * 373 * \param vg_name 374 * Name of the VG to open. 375 * 376 * \return 377 * non-NULL vg handle (success) or NULL (failure) 378 */ 379vg_t lvm_vg_create(lvm_t libh, const char *vg_name); 380 381 /** 382 * Write a VG to disk. 383 * 384 * This function commits the Volume Group object referenced by the VG handle 385 * to disk. Upon failure, retry the operation and/or release the VG handle 386 * with lvm_vg_close. 387 * 388 * \param vg 389 * VG handle obtained from lvm_vg_create or lvm_vg_open. 390 * 391 * \return 392 * 0 (success) or -1 (failure). 393 */ 394int lvm_vg_write(vg_t vg); 395 396/** 397 * Remove a VG from the system. 398 * 399 * This function removes a Volume Group object in memory, and requires 400 * calling lvm_vg_write to commit the removal to disk. 401 * 402 * \param vg 403 * VG handle obtained from lvm_vg_create or lvm_vg_open. 404 * 405 * \return 406 * 0 (success) or -1 (failure). 407 */ 408int lvm_vg_remove(vg_t vg); 409 410/** 411 * Close a VG opened with lvm_vg_create or lvm_vg_open. 412 * 413 * This function releases a VG handle and any resources associated with the 414 * handle. 415 * 416 * \param vg 417 * VG handle obtained from lvm_vg_create or lvm_vg_open. 418 * 419 * \return 420 * 0 (success) or -1 (failure). 421 */ 422int lvm_vg_close(vg_t vg); 423 424/** 425 * Extend a VG by adding a device. 426 * 427 * This function requires calling lvm_vg_write to commit the change to disk. 428 * After successfully adding a device, use lvm_vg_write to commit the new VG 429 * to disk. Upon failure, retry the operation or release the VG handle with 430 * lvm_vg_close. 431 * If the device is not initialized for LVM use, it will be initialized 432 * before adding to the VG. Although some internal checks are done, 433 * the caller should be sure the device is not in use by other subsystems 434 * before calling lvm_vg_extend. 435 * 436 * \param vg 437 * VG handle obtained from lvm_vg_create or lvm_vg_open. 438 * 439 * \param device 440 * Absolute pathname of device to add to VG. 441 * 442 * \return 443 * 0 (success) or -1 (failure). 444 */ 445int lvm_vg_extend(vg_t vg, const char *device); 446 447/** 448 * Reduce a VG by removing an unused device. 449 * 450 * This function requires calling lvm_vg_write to commit the change to disk. 451 * After successfully removing a device, use lvm_vg_write to commit the new VG 452 * to disk. Upon failure, retry the operation or release the VG handle with 453 * lvm_vg_close. 454 * 455 * \param vg 456 * VG handle obtained from lvm_vg_create or lvm_vg_open. 457 * 458 * \param device 459 * Name of device to remove from VG. 460 * 461 * \return 462 * 0 (success) or -1 (failure). 463 */ 464int lvm_vg_reduce(vg_t vg, const char *device); 465 466/** 467 * Set the extent size of a VG. 468 * 469 * This function requires calling lvm_vg_write to commit the change to disk. 470 * After successfully setting a new extent size, use lvm_vg_write to commit 471 * the new VG to disk. Upon failure, retry the operation or release the VG 472 * handle with lvm_vg_close. 473 * 474 * \param vg 475 * VG handle obtained from lvm_vg_create or lvm_vg_open. 476 * 477 * \param new_size 478 * New extent size in bytes. 479 * 480 * \return 481 * 0 (success) or -1 (failure). 482 */ 483int lvm_vg_set_extent_size(vg_t vg, uint32_t new_size); 484 485/** 486 * Get whether or not a volume group is clustered. 487 * 488 * \param vg 489 * VG handle obtained from lvm_vg_create or lvm_vg_open. 490 * 491 * \return 492 * 1 if the VG is clustered, 0 if not 493 */ 494uint64_t lvm_vg_is_clustered(vg_t vg); 495 496/** 497 * Get whether or not a volume group is exported. 498 * 499 * \param vg 500 * VG handle obtained from lvm_vg_create or lvm_vg_open. 501 * 502 * \return 503 * 1 if the VG is exported, 0 if not 504 */ 505uint64_t lvm_vg_is_exported(vg_t vg); 506 507/** 508 * Get whether or not a volume group is a partial volume group. 509 * 510 * When one or more physical volumes belonging to the volume group 511 * are missing from the system the volume group is a partial volume 512 * group. 513 * 514 * \param vg 515 * VG handle obtained from lvm_vg_create or lvm_vg_open. 516 * 517 * \return 518 * 1 if the VG is PVs, 0 if not 519 */ 520uint64_t lvm_vg_is_partial(vg_t vg); 521 522/** 523 * Get the current metadata sequence number of a volume group. 524 * 525 * The metadata sequence number is incrented for each metadata change. 526 * Applications may use the sequence number to determine if any LVM objects 527 * have changed from a prior query. 528 * 529 * \param vg 530 * VG handle obtained from lvm_vg_create or lvm_vg_open. 531 * 532 * \return 533 * Metadata sequence number. 534 */ 535uint64_t lvm_vg_get_seqno(const vg_t vg); 536 537/** 538 * Get the current name of a volume group. 539 * 540 * Memory is allocated using dm_malloc() and caller must free the memory 541 * using dm_free(). 542 * 543 * \param vg 544 * VG handle obtained from lvm_vg_create or lvm_vg_open. 545 * 546 * \return 547 * Copy of the uuid string. 548 */ 549char *lvm_vg_get_uuid(const vg_t vg); 550 551/** 552 * Get the current uuid of a volume group. 553 * 554 * Memory is allocated using dm_malloc() and caller must free the memory 555 * using dm_free(). 556 * 557 * \param vg 558 * VG handle obtained from lvm_vg_create or lvm_vg_open. 559 * 560 * \return 561 * Copy of the name. 562 */ 563char *lvm_vg_get_name(const vg_t vg); 564 565/** 566 * Get the current size in bytes of a volume group. 567 * 568 * \param vg 569 * VG handle obtained from lvm_vg_create or lvm_vg_open. 570 * 571 * \return 572 * Size in bytes. 573 */ 574uint64_t lvm_vg_get_size(const vg_t vg); 575 576/** 577 * Get the current unallocated space in bytes of a volume group. 578 * 579 * \param vg 580 * VG handle obtained from lvm_vg_create or lvm_vg_open. 581 * 582 * \return 583 * Free size in bytes. 584 */ 585uint64_t lvm_vg_get_free_size(const vg_t vg); 586 587/** 588 * Get the current extent size in bytes of a volume group. 589 * 590 * \param vg 591 * VG handle obtained from lvm_vg_create or lvm_vg_open. 592 * 593 * \return 594 * Extent size in bytes. 595 */ 596uint64_t lvm_vg_get_extent_size(const vg_t vg); 597 598/** 599 * Get the current number of total extents of a volume group. 600 * 601 * \param vg 602 * VG handle obtained from lvm_vg_create or lvm_vg_open. 603 * 604 * \return 605 * Extent count. 606 */ 607uint64_t lvm_vg_get_extent_count(const vg_t vg); 608 609/** 610 * Get the current number of free extents of a volume group. 611 * 612 * \param vg 613 * VG handle obtained from lvm_vg_create or lvm_vg_open. 614 * 615 * \return 616 * Free extent count. 617 */ 618uint64_t lvm_vg_get_free_extent_count(const vg_t vg); 619 620/** 621 * Get the current number of physical volumes of a volume group. 622 * 623 * \param vg 624 * VG handle obtained from lvm_vg_create or lvm_vg_open. 625 * 626 * \return 627 * Physical volume count. 628 */ 629uint64_t lvm_vg_get_pv_count(const vg_t vg); 630 631/** 632 * Get the maximum number of physical volumes allowed in a volume group. 633 * 634 * \param vg 635 * VG handle obtained from lvm_vg_create or lvm_vg_open. 636 * 637 * \return 638 * Maximum number of physical volumes allowed in a volume group. 639 */ 640uint64_t lvm_vg_get_max_pv(const vg_t vg); 641 642/** 643 * Get the maximum number of logical volumes allowed in a volume group. 644 * 645 * \param vg 646 * VG handle obtained from lvm_vg_create or lvm_vg_open. 647 * 648 * \return 649 * Maximum number of logical volumes allowed in a volume group. 650 */ 651uint64_t lvm_vg_get_max_lv(const vg_t vg); 652 653/************************** logical volume handling *************************/ 654 655/** 656 * Return a list of LV handles for a given VG handle. 657 * 658 * \param vg 659 * VG handle obtained from lvm_vg_create or lvm_vg_open. 660 * 661 * \return 662 * A list of lv_list_t structures containing lv handles for this vg. 663 * If no LVs exist on the given VG, NULL is returned. 664 */ 665struct dm_list *lvm_vg_list_lvs(vg_t vg); 666 667/** 668 * Create a linear logical volume. 669 * This function commits the change to disk and does _not_ require calling 670 * lvm_vg_write. 671 * NOTE: The commit behavior of this function is subject to change 672 * as the API is developed. 673 * 674 * \param vg 675 * VG handle obtained from lvm_vg_create or lvm_vg_open. 676 * 677 * \param name 678 * Name of logical volume to create. 679 * 680 * \param size 681 * Size of logical volume in extents. 682 * 683 * \return 684 * non-NULL handle to an LV object created, or NULL if creation fails. 685 * 686 */ 687lv_t lvm_vg_create_lv_linear(vg_t vg, const char *name, uint64_t size); 688 689/** 690 * Activate a logical volume. 691 * 692 * This function is the equivalent of the lvm command "lvchange -ay". 693 * 694 * NOTE: This function cannot currently handle LVs with an in-progress pvmove or 695 * lvconvert. 696 * 697 * \param lv 698 * Logical volume handle. 699 * 700 * \return 701 * 0 (success) or -1 (failure). 702 */ 703int lvm_lv_activate(lv_t lv); 704 705/** 706 * Deactivate a logical volume. 707 * 708 * This function is the equivalent of the lvm command "lvchange -an". 709 * 710 * \param lv 711 * Logical volume handle. 712 * 713 * \return 714 * 0 (success) or -1 (failure). 715 */ 716int lvm_lv_deactivate(lv_t lv); 717 718/** 719 * Remove a logical volume from a volume group. 720 * 721 * This function commits the change to disk and does _not_ require calling 722 * lvm_vg_write. 723 * NOTE: The commit behavior of this function is subject to change 724 * as the API is developed. 725 * Currently only removing linear LVs are possible. 726 * 727 * \param lv 728 * Logical volume handle. 729 * 730 * \return 731 * 0 (success) or -1 (failure). 732 */ 733int lvm_vg_remove_lv(lv_t lv); 734 735/** 736 * Get the current name of a logical volume. 737 * 738 * Memory is allocated using dm_malloc() and caller must free the memory 739 * using dm_free(). 740 * 741 * \param lv 742 * Logical volume handle. 743 * 744 * \return 745 * Copy of the uuid string. 746 */ 747char *lvm_lv_get_uuid(const lv_t lv); 748 749/** 750 * Get the current uuid of a logical volume. 751 * 752 * Memory is allocated using dm_malloc() and caller must free the memory 753 * using dm_free(). 754 * 755 * \param lv 756 * Logical volume handle. 757 * 758 * \return 759 * Copy of the name. 760 */ 761char *lvm_lv_get_name(const lv_t lv); 762 763/** 764 * Get the current size in bytes of a logical volume. 765 * 766 * \param lv 767 * Logical volume handle. 768 * 769 * \return 770 * Size in bytes. 771 */ 772uint64_t lvm_lv_get_size(const lv_t lv); 773 774/** 775 * Get the current activation state of a logical volume. 776 * 777 * \param lv 778 * Logical volume handle. 779 * 780 * \return 781 * 1 if the LV is active in the kernel, 0 if not 782 */ 783uint64_t lvm_lv_is_active(const lv_t lv); 784 785/** 786 * Get the current suspended state of a logical volume. 787 * 788 * \param lv 789 * Logical volume handle. 790 * 791 * \return 792 * 1 if the LV is suspended in the kernel, 0 if not 793 */ 794uint64_t lvm_lv_is_suspended(const lv_t lv); 795 796/** 797 * Resize logical volume to new_size bytes. 798 * 799 * NOTE: This function is currently not implemented. 800 * 801 * \param lv 802 * Logical volume handle. 803 * 804 * \param new_size 805 * New size in bytes. 806 * 807 * \return 808 * 0 (success) or -1 (failure). 809 * 810 */ 811int lvm_lv_resize(const lv_t lv, uint64_t new_size); 812 813/************************** physical volume handling ************************/ 814 815/** 816 * Physical volume handling should not be needed anymore. Only physical volumes 817 * bound to a vg contain useful information. Therefore the creation, 818 * modification and the removal of orphan physical volumes is not suported. 819 */ 820 821/** 822 * Return a list of PV handles for a given VG handle. 823 * 824 * \param vg 825 * VG handle obtained from lvm_vg_create or lvm_vg_open. 826 * 827 * \return 828 * A list of pv_list_t structures containing pv handles for this vg. 829 * If no PVs exist on the given VG, NULL is returned. 830 */ 831struct dm_list *lvm_vg_list_pvs(vg_t vg); 832 833/** 834 * Get the current uuid of a logical volume. 835 * 836 * Memory is allocated using dm_malloc() and caller must free the memory 837 * using dm_free(). 838 * 839 * \param pv 840 * Physical volume handle. 841 * 842 * \return 843 * Copy of the uuid string. 844 */ 845char *lvm_pv_get_uuid(const pv_t pv); 846 847/** 848 * Get the current name of a logical volume. 849 * 850 * Memory is allocated using dm_malloc() and caller must free the memory 851 * using dm_free(). 852 * 853 * \param pv 854 * Physical volume handle. 855 * 856 * \return 857 * Copy of the name. 858 */ 859char *lvm_pv_get_name(const pv_t pv); 860 861/** 862 * Get the current number of metadata areas in the physical volume. 863 * 864 * \param pv 865 * Physical volume handle. 866 * 867 * \return 868 * Number of metadata areas in the PV. 869 */ 870uint64_t lvm_pv_get_mda_count(const pv_t pv); 871 872/** 873 * Resize physical volume to new_size bytes. 874 * 875 * NOTE: This function is currently not implemented. 876 * 877 * \param pv 878 * Physical volume handle. 879 * 880 * \param new_size 881 * New size in bytes. 882 * 883 * \return 884 * 0 (success) or -1 (failure). 885 */ 886int lvm_pv_resize(const pv_t pv, uint64_t new_size); 887 888#endif /* _LIB_LVM2APP_H */ 889