开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lvm-fs.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

lvm-fs.c：源码内容
  1. /*
  2.  * kernel/lvm-fs.c
  3.  *
  4.  * Copyright (C) 2001-2002 Sistina Software
  5.  *
  6.  * January-May,December 2001
  7.  * May 2002
  8.  *
  9.  * LVM driver is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2, or (at your option)
  12.  * any later version.
  13.  *
  14.  * LVM driver is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with GNU CC; see the file COPYING.  If not, write to
  21.  * the Free Software Foundation, 59 Temple Place - Suite 330,
  22.  * Boston, MA 02111-1307, USA.
  23.  *
  24.  */
  26. /*
  27.  * Changelog
  28.  *
  29.  *    11/01/2001 - First version (Joe Thornber)
  30.  *    21/03/2001 - added display of stripes and stripe size (HM)
  31.  *    04/10/2001 - corrected devfs_register() call in lvm_init_fs()
  32.  *    11/04/2001 - don't devfs_register("lvm") as user-space always does it
  33.  *    10/05/2001 - show more of PV name in /proc/lvm/global
  34.  *    16/12/2001 - fix devfs unregister order and prevent duplicate unreg (REG)
  35.  *
  36.  */
  38. #include <linux/config.h>
  39. #include <linux/version.h>
  41. #include <linux/kernel.h>
  42. #include <linux/vmalloc.h>
  43. #include <linux/smp_lock.h>
  45. #include <linux/devfs_fs_kernel.h>
  46. #include <linux/proc_fs.h>
  47. #include <linux/init.h>
  48. #include <linux/lvm.h>
  50. #include "lvm-internal.h"
  53. static int _proc_read_vg(char *page, char **start, off_t off,
  54.  int count, int *eof, void *data);
  55. static int _proc_read_lv(char *page, char **start, off_t off,
  56.  int count, int *eof, void *data);
  57. static int _proc_read_pv(char *page, char **start, off_t off,
  58.  int count, int *eof, void *data);
  59. static int _proc_read_global(char *page, char **start, off_t off,
  60.      int count, int *eof, void *data);
  62. static int _vg_info(vg_t *vg_ptr, char *buf);
  63. static int _lv_info(vg_t *vg_ptr, lv_t *lv_ptr, char *buf);
  64. static int _pv_info(pv_t *pv_ptr, char *buf);
  66. static void _show_uuid(const char *src, char *b, char *e);
  68. #if 0
  69. static devfs_handle_t lvm_devfs_handle;
  70. #endif
  71. static devfs_handle_t vg_devfs_handle[MAX_VG];
  72. static devfs_handle_t ch_devfs_handle[MAX_VG];
  73. static devfs_handle_t lv_devfs_handle[MAX_LV];
  75. static struct proc_dir_entry *lvm_proc_dir = NULL;
  76. static struct proc_dir_entry *lvm_proc_vg_subdir = NULL;
  78. /* inline functions */
  80. /* public interface */
  81. void __init lvm_init_fs() {
  82. struct proc_dir_entry *pde;
  84. /* User-space has already registered this */
  85. #if 0
  86. lvm_devfs_handle = devfs_register(
  87. 0 , "lvm", 0, LVM_CHAR_MAJOR, 0,
  88. S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
  89. &lvm_chr_fops, NULL);
  90. #endif
  91. lvm_proc_dir = create_proc_entry(LVM_DIR, S_IFDIR, &proc_root);
  92. if (lvm_proc_dir) {
  93. lvm_proc_vg_subdir = create_proc_entry(LVM_VG_SUBDIR, S_IFDIR,
  94.        lvm_proc_dir);
  95. pde = create_proc_entry(LVM_GLOBAL, S_IFREG, lvm_proc_dir);
  96. if ( pde != NULL) pde->read_proc = _proc_read_global;
  97. }
  98. }
  100. void lvm_fin_fs() {
  101. #if 0
  102. devfs_unregister (lvm_devfs_handle);
  103. #endif
  104. remove_proc_entry(LVM_GLOBAL, lvm_proc_dir);
  105. remove_proc_entry(LVM_VG_SUBDIR, lvm_proc_dir);
  106. remove_proc_entry(LVM_DIR, &proc_root);
  107. }
  109. void lvm_fs_create_vg(vg_t *vg_ptr) {
  110. struct proc_dir_entry *pde;
  112. if (!vg_ptr)
  113. return;
  115. vg_devfs_handle[vg_ptr->vg_number] =
  116. devfs_mk_dir(0, vg_ptr->vg_name, NULL);
  118. ch_devfs_handle[vg_ptr->vg_number] = devfs_register(
  119. vg_devfs_handle[vg_ptr->vg_number] , "group",
  120. DEVFS_FL_DEFAULT, LVM_CHAR_MAJOR, vg_ptr->vg_number,
  121. S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
  122. &lvm_chr_fops, NULL);
  124. vg_ptr->vg_dir_pde = create_proc_entry(vg_ptr->vg_name, S_IFDIR,
  125.        lvm_proc_vg_subdir);
  127. if((pde = create_proc_entry("group", S_IFREG, vg_ptr->vg_dir_pde))) {
  128. pde->read_proc = _proc_read_vg;
  129. pde->data = vg_ptr;
  130. }
  132. vg_ptr->lv_subdir_pde =
  133. create_proc_entry(LVM_LV_SUBDIR, S_IFDIR, vg_ptr->vg_dir_pde);
  135. vg_ptr->pv_subdir_pde =
  136. create_proc_entry(LVM_PV_SUBDIR, S_IFDIR, vg_ptr->vg_dir_pde);
  137. }
  139. void lvm_fs_remove_vg(vg_t *vg_ptr) {
  140. int i;
  142. if (!vg_ptr)
  143. return;
  145. devfs_unregister(ch_devfs_handle[vg_ptr->vg_number]);
  146. ch_devfs_handle[vg_ptr->vg_number] = NULL;
  148. /* remove lv's */
  149. for(i = 0; i < vg_ptr->lv_max; i++)
  150. if(vg_ptr->lv[i]) lvm_fs_remove_lv(vg_ptr, vg_ptr->lv[i]);
  152. /* must not remove directory before leaf nodes */
  153. devfs_unregister(vg_devfs_handle[vg_ptr->vg_number]);
  154. vg_devfs_handle[vg_ptr->vg_number] = NULL;
  156. /* remove pv's */
  157. for(i = 0; i < vg_ptr->pv_max; i++)
  158. if(vg_ptr->pv[i]) lvm_fs_remove_pv(vg_ptr, vg_ptr->pv[i]);
  160. if(vg_ptr->vg_dir_pde) {
  161. remove_proc_entry(LVM_LV_SUBDIR, vg_ptr->vg_dir_pde);
  162. vg_ptr->lv_subdir_pde = NULL;
  164. remove_proc_entry(LVM_PV_SUBDIR, vg_ptr->vg_dir_pde);
  165. vg_ptr->pv_subdir_pde = NULL;
  167. remove_proc_entry("group", vg_ptr->vg_dir_pde);
  168. vg_ptr->vg_dir_pde = NULL;
  170. remove_proc_entry(vg_ptr->vg_name, lvm_proc_vg_subdir);
  171. }
  172. }
  175. static inline const char *_basename(const char *str) {
  176. const char *name = strrchr(str, '/');
  177. name = name ? name + 1 : str;
  178. return name;
  179. }
  181. devfs_handle_t lvm_fs_create_lv(vg_t *vg_ptr, lv_t *lv) {
  182. struct proc_dir_entry *pde;
  183. const char *name;
  185. if (!vg_ptr || !lv)
  186. return NULL;
  188. name = _basename(lv->lv_name);
  190. lv_devfs_handle[MINOR(lv->lv_dev)] = devfs_register(
  191. vg_devfs_handle[vg_ptr->vg_number], name,
  192. DEVFS_FL_DEFAULT, LVM_BLK_MAJOR, MINOR(lv->lv_dev),
  193. S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP,
  194. &lvm_blk_dops, NULL);
  196. if(vg_ptr->lv_subdir_pde &&
  197.    (pde = create_proc_entry(name, S_IFREG, vg_ptr->lv_subdir_pde))) {
  198. pde->read_proc = _proc_read_lv;
  199. pde->data = lv;
  200. }
  201. return lv_devfs_handle[MINOR(lv->lv_dev)];
  202. }
  204. void lvm_fs_remove_lv(vg_t *vg_ptr, lv_t *lv) {
  206. if (!vg_ptr || !lv)
  207. return;
  209. devfs_unregister(lv_devfs_handle[MINOR(lv->lv_dev)]);
  210. lv_devfs_handle[MINOR(lv->lv_dev)] = NULL;
  212. if(vg_ptr->lv_subdir_pde) {
  213. const char *name = _basename(lv->lv_name);
  214. remove_proc_entry(name, vg_ptr->lv_subdir_pde);
  215. }
  216. }
  219. static inline void _make_pv_name(const char *src, char *b, char *e) {
  220. int offset = strlen(LVM_DIR_PREFIX);
  221. if(strncmp(src, LVM_DIR_PREFIX, offset))
  222. offset = 0;
  224. e--;
  225. src += offset;
  226. while(*src && (b != e)) {
  227. *b++ = (*src == '/') ? '_' : *src;
  228. src++;
  229. }
  230. *b = '';
  231. }
  233. void lvm_fs_create_pv(vg_t *vg_ptr, pv_t *pv) {
  234. struct proc_dir_entry *pde;
  235. char name[NAME_LEN];
  237. if (!vg_ptr || !pv)
  238. return;
  240. if(!vg_ptr->pv_subdir_pde)
  241. return;
  243. _make_pv_name(pv->pv_name, name, name + sizeof(name));
  244. if((pde = create_proc_entry(name, S_IFREG, vg_ptr->pv_subdir_pde))) {
  245. pde->read_proc = _proc_read_pv;
  246. pde->data = pv;
  247. }
  248. }
  250. void lvm_fs_remove_pv(vg_t *vg_ptr, pv_t *pv) {
  251. char name[NAME_LEN];
  253. if (!vg_ptr || !pv)
  254. return;
  256. if(!vg_ptr->pv_subdir_pde)
  257. return;
  259. _make_pv_name(pv->pv_name, name, name + sizeof(name));
  260. remove_proc_entry(name, vg_ptr->pv_subdir_pde);
  261. }
  264. static int _proc_read_vg(char *page, char **start, off_t off,
  265.   int count, int *eof, void *data) {
  266. int sz = 0;
  267. vg_t *vg_ptr = data;
  268. char uuid[NAME_LEN];
  270. sz += sprintf(page + sz, "name:         %sn", vg_ptr->vg_name);
  271. sz += sprintf(page + sz, "size:         %un",
  272.       vg_ptr->pe_total * vg_ptr->pe_size / 2);
  273. sz += sprintf(page + sz, "access:       %un", vg_ptr->vg_access);
  274. sz += sprintf(page + sz, "status:       %un", vg_ptr->vg_status);
  275. sz += sprintf(page + sz, "number:       %un", vg_ptr->vg_number);
  276. sz += sprintf(page + sz, "LV max:       %un", vg_ptr->lv_max);
  277. sz += sprintf(page + sz, "LV current:   %un", vg_ptr->lv_cur);
  278. sz += sprintf(page + sz, "LV open:      %un", vg_ptr->lv_open);
  279. sz += sprintf(page + sz, "PV max:       %un", vg_ptr->pv_max);
  280. sz += sprintf(page + sz, "PV current:   %un", vg_ptr->pv_cur);
  281. sz += sprintf(page + sz, "PV active:    %un", vg_ptr->pv_act);
  282. sz += sprintf(page + sz, "PE size:      %un", vg_ptr->pe_size / 2);
  283. sz += sprintf(page + sz, "PE total:     %un", vg_ptr->pe_total);
  284. sz += sprintf(page + sz, "PE allocated: %un", vg_ptr->pe_allocated);
  286. _show_uuid(vg_ptr->vg_uuid, uuid, uuid + sizeof(uuid));
  287. sz += sprintf(page + sz, "uuid:         %sn", uuid);
  289. return sz;
  290. }
  292. static int _proc_read_lv(char *page, char **start, off_t off,
  293.   int count, int *eof, void *data) {
  294. int sz = 0;
  295. lv_t *lv = data;
  297. sz += sprintf(page + sz, "name:         %sn", lv->lv_name);
  298. sz += sprintf(page + sz, "size:         %un", lv->lv_size);
  299. sz += sprintf(page + sz, "access:       %un", lv->lv_access);
  300. sz += sprintf(page + sz, "status:       %un", lv->lv_status);
  301. sz += sprintf(page + sz, "number:       %un", lv->lv_number);
  302. sz += sprintf(page + sz, "open:         %un", lv->lv_open);
  303. sz += sprintf(page + sz, "allocation:   %un", lv->lv_allocation);
  304. if(lv->lv_stripes > 1) {
  305. sz += sprintf(page + sz, "stripes:      %un",
  306.       lv->lv_stripes);
  307. sz += sprintf(page + sz, "stripesize:   %un",
  308.       lv->lv_stripesize);
  309. }
  310. sz += sprintf(page + sz, "device:       %02u:%02un",
  311.       MAJOR(lv->lv_dev), MINOR(lv->lv_dev));
  313. return sz;
  314. }
  316. static int _proc_read_pv(char *page, char **start, off_t off,
  317.  int count, int *eof, void *data) {
  318. int sz = 0;
  319. pv_t *pv = data;
  320. char uuid[NAME_LEN];
  322. sz += sprintf(page + sz, "name:         %sn", pv->pv_name);
  323. sz += sprintf(page + sz, "size:         %un", pv->pv_size);
  324. sz += sprintf(page + sz, "status:       %un", pv->pv_status);
  325. sz += sprintf(page + sz, "number:       %un", pv->pv_number);
  326. sz += sprintf(page + sz, "allocatable:  %un", pv->pv_allocatable);
  327. sz += sprintf(page + sz, "LV current:   %un", pv->lv_cur);
  328. sz += sprintf(page + sz, "PE size:      %un", pv->pe_size / 2);
  329. sz += sprintf(page + sz, "PE total:     %un", pv->pe_total);
  330. sz += sprintf(page + sz, "PE allocated: %un", pv->pe_allocated);
  331. sz += sprintf(page + sz, "device:       %02u:%02un",
  332.                       MAJOR(pv->pv_dev), MINOR(pv->pv_dev));
  334. _show_uuid(pv->pv_uuid, uuid, uuid + sizeof(uuid));
  335. sz += sprintf(page + sz, "uuid:         %sn", uuid);
  337. return sz;
  338. }
  340. static int _proc_read_global(char *page, char **start, off_t pos, int count,
  341.      int *eof, void *data) {
  343. #define  LVM_PROC_BUF   ( i == 0 ? dummy_buf : &buf[sz])
  345. int c, i, l, p, v, vg_counter, pv_counter, lv_counter, lv_open_counter,
  346. lv_open_total, pe_t_bytes, hash_table_bytes, lv_block_exception_t_bytes, seconds;
  347. static off_t sz;
  348. off_t sz_last;
  349. static char *buf = NULL;
  350. static char dummy_buf[160]; /* sized for 2 lines */
  351. vg_t *vg_ptr;
  352. lv_t *lv_ptr;
  353. pv_t *pv_ptr;
  356. #ifdef DEBUG_LVM_PROC_GET_INFO
  357. printk(KERN_DEBUG
  358.        "%s - lvm_proc_get_global_info CALLED  pos: %lu  count: %dn",
  359.        lvm_name, pos, count);
  360. #endif
  362. if(pos != 0 && buf != NULL)
  363. goto out;
  365. sz_last = vg_counter = pv_counter = lv_counter = lv_open_counter = 
  366. lv_open_total = pe_t_bytes = hash_table_bytes = 
  367. lv_block_exception_t_bytes = 0;
  369. /* get some statistics */
  370. for (v = 0; v < ABS_MAX_VG; v++) {
  371. if ((vg_ptr = vg[v]) != NULL) {
  372. vg_counter++;
  373. pv_counter += vg_ptr->pv_cur;
  374. lv_counter += vg_ptr->lv_cur;
  375. if (vg_ptr->lv_cur > 0) {
  376. for (l = 0; l < vg[v]->lv_max; l++) {
  377. if ((lv_ptr = vg_ptr->lv[l]) != NULL) {
  378. pe_t_bytes += lv_ptr->lv_allocated_le;
  379. hash_table_bytes += lv_ptr->lv_snapshot_hash_table_size;
  380. if (lv_ptr->lv_block_exception != NULL)
  381. lv_block_exception_t_bytes += lv_ptr->lv_remap_end;
  382. if (lv_ptr->lv_open > 0) {
  383. lv_open_counter++;
  384. lv_open_total += lv_ptr->lv_open;
  385. }
  386. }
  387. }
  388. }
  389. }
  390. }
  392. pe_t_bytes *= sizeof(pe_t);
  393. lv_block_exception_t_bytes *= sizeof(lv_block_exception_t);
  395. if (buf != NULL) {
  396. P_KFREE("%s -- vfree %dn", lvm_name, __LINE__);
  397. lock_kernel();
  398. vfree(buf);
  399. unlock_kernel();
  400. buf = NULL;
  401. }
  402. /* 2 times: first to get size to allocate buffer,
  403.    2nd to fill the malloced buffer */
  404. for (i = 0; i < 2; i++) {
  405. sz = 0;
  406. sz += sprintf(LVM_PROC_BUF,
  407.       "LVM "
  408. #ifdef MODULE
  409.       "module"
  410. #else
  411.       "driver"
  412. #endif
  413.       " %snn"
  414.       "Total:  %d VG%s  %d PV%s  %d LV%s ",
  415.       lvm_version,
  416.       vg_counter, vg_counter == 1 ? "" : "s",
  417.       pv_counter, pv_counter == 1 ? "" : "s",
  418.       lv_counter, lv_counter == 1 ? "" : "s");
  419. sz += sprintf(LVM_PROC_BUF,
  420.       "(%d LV%s open",
  421.       lv_open_counter,
  422.       lv_open_counter == 1 ? "" : "s");
  423. if (lv_open_total > 0)
  424. sz += sprintf(LVM_PROC_BUF,
  425.       " %d times)n",
  426.       lv_open_total);
  427. else
  428. sz += sprintf(LVM_PROC_BUF, ")");
  429. sz += sprintf(LVM_PROC_BUF,
  430.       "nGlobal: %lu bytes malloced   IOP version: %d   ",
  431.       vg_counter * sizeof(vg_t) +
  432.       pv_counter * sizeof(pv_t) +
  433.       lv_counter * sizeof(lv_t) +
  434.       pe_t_bytes + hash_table_bytes + lv_block_exception_t_bytes + sz_last,
  435.       lvm_iop_version);
  437. seconds = CURRENT_TIME - loadtime;
  438. if (seconds < 0)
  439. loadtime = CURRENT_TIME + seconds;
  440. if (seconds / 86400 > 0) {
  441. sz += sprintf(LVM_PROC_BUF, "%d day%s ",
  442.       seconds / 86400,
  443.       seconds / 86400 == 0 ||
  444.       seconds / 86400 > 1 ? "s" : "");
  445. }
  446. sz += sprintf(LVM_PROC_BUF, "%d:%02d:%02d activen",
  447.       (seconds % 86400) / 3600,
  448.       (seconds % 3600) / 60,
  449.       seconds % 60);
  451. if (vg_counter > 0) {
  452. for (v = 0; v < ABS_MAX_VG; v++) {
  453. /* volume group */
  454. if ((vg_ptr = vg[v]) != NULL) {
  455. sz += _vg_info(vg_ptr, LVM_PROC_BUF);
  457. /* physical volumes */
  458. sz += sprintf(LVM_PROC_BUF,
  459.       "n  PV%s ",
  460.       vg_ptr->pv_cur == 1 ? ": " : "s:");
  461. c = 0;
  462. for (p = 0; p < vg_ptr->pv_max; p++) {
  463. if ((pv_ptr = vg_ptr->pv[p]) != NULL) {
  464. sz += _pv_info(pv_ptr, LVM_PROC_BUF);
  466. c++;
  467. if (c < vg_ptr->pv_cur)
  468. sz += sprintf(LVM_PROC_BUF,
  469.       "n       ");
  470. }
  471. }
  473. /* logical volumes */
  474. sz += sprintf(LVM_PROC_BUF,
  475.       "n    LV%s ",
  476.       vg_ptr->lv_cur == 1 ? ": " : "s:");
  477. c = 0;
  478. for (l = 0; l < vg_ptr->lv_max; l++) {
  479. if ((lv_ptr = vg_ptr->lv[l]) != NULL) {
  480. sz += _lv_info(vg_ptr, lv_ptr, LVM_PROC_BUF);
  481. c++;
  482. if (c < vg_ptr->lv_cur)
  483. sz += sprintf(LVM_PROC_BUF,
  484.       "n         ");
  485. }
  486. }
  487. if (vg_ptr->lv_cur == 0) sz += sprintf(LVM_PROC_BUF, "none");
  488. sz += sprintf(LVM_PROC_BUF, "n");
  489. }
  490. }
  491. }
  492. if (buf == NULL) {
  493. lock_kernel();
  494. buf = vmalloc(sz);
  495. unlock_kernel();
  496. if (buf == NULL) {
  497. sz = 0;
  498. return sprintf(page, "%s - vmalloc error at line %dn",
  499.        lvm_name, __LINE__);
  500. }
  501. }
  502. sz_last = sz;
  503. }
  505.  out:
  506. if (pos > sz - 1) {
  507. lock_kernel();
  508. vfree(buf);
  509. unlock_kernel();
  510. buf = NULL;
  511. return 0;
  512. }
  513. *start = &buf[pos];
  514. if (sz - pos < count)
  515. return sz - pos;
  516. else
  517. return count;
  519. #undef LVM_PROC_BUF
  520. }
  522. /*
  523.  * provide VG info for proc filesystem use (global)
  524.  */
  525. static int _vg_info(vg_t *vg_ptr, char *buf) {
  526. int sz = 0;
  527. char inactive_flag = ' ';
  529. if (!(vg_ptr->vg_status & VG_ACTIVE)) inactive_flag = 'I';
  530. sz = sprintf(buf,
  531.      "nVG: %c%s  [%d PV, %d LV/%d open] "
  532.      " PE Size: %d KBn"
  533.      "  Usage [KB/PE]: %d /%d total  "
  534.      "%d /%d used  %d /%d free",
  535.      inactive_flag,
  536.      vg_ptr->vg_name,
  537.      vg_ptr->pv_cur,
  538.      vg_ptr->lv_cur,
  539.      vg_ptr->lv_open,
  540.            vg_ptr->pe_size >> 1,
  541.      vg_ptr->pe_size * vg_ptr->pe_total >> 1,
  542.      vg_ptr->pe_total,
  543.      vg_ptr->pe_allocated * vg_ptr->pe_size >> 1,
  544.            vg_ptr->pe_allocated,
  545.      (vg_ptr->pe_total - vg_ptr->pe_allocated) *
  546.            vg_ptr->pe_size >> 1,
  547.      vg_ptr->pe_total - vg_ptr->pe_allocated);
  548. return sz;
  549. }
  552. /*
  553.  * provide LV info for proc filesystem use (global)
  554.  */
  555. static int _lv_info(vg_t *vg_ptr, lv_t *lv_ptr, char *buf) {
  556. int sz = 0;
  557. char inactive_flag = 'A', allocation_flag = ' ',
  558. stripes_flag = ' ', rw_flag = ' ', *basename;
  560. if (!(lv_ptr->lv_status & LV_ACTIVE))
  561. inactive_flag = 'I';
  562. rw_flag = 'R';
  563. if (lv_ptr->lv_access & LV_WRITE)
  564. rw_flag = 'W';
  565. allocation_flag = 'D';
  566. if (lv_ptr->lv_allocation & LV_CONTIGUOUS)
  567. allocation_flag = 'C';
  568. stripes_flag = 'L';
  569. if (lv_ptr->lv_stripes > 1)
  570. stripes_flag = 'S';
  571. sz += sprintf(buf+sz,
  572.       "[%c%c%c%c",
  573.       inactive_flag,
  574.  rw_flag,
  575.       allocation_flag,
  576.       stripes_flag);
  577. if (lv_ptr->lv_stripes > 1)
  578. sz += sprintf(buf+sz, "%-2d",
  579.       lv_ptr->lv_stripes);
  580. else
  581. sz += sprintf(buf+sz, "  ");
  583. /* FIXME: use _basename */
  584. basename = strrchr(lv_ptr->lv_name, '/');
  585. if ( basename == 0) basename = lv_ptr->lv_name;
  586. else                basename++;
  587. sz += sprintf(buf+sz, "] %-25s", basename);
  588. if (strlen(basename) > 25)
  589. sz += sprintf(buf+sz,
  590.       "n                              ");
  591. sz += sprintf(buf+sz, "%9d /%-6d   ",
  592.       lv_ptr->lv_size >> 1,
  593.       lv_ptr->lv_size / vg_ptr->pe_size);
  595. if (lv_ptr->lv_open == 0)
  596. sz += sprintf(buf+sz, "close");
  597. else
  598. sz += sprintf(buf+sz, "%dx open",
  599.       lv_ptr->lv_open);
  601. return sz;
  602. }
  605. /*
  606.  * provide PV info for proc filesystem use (global)
  607.  */
  608. static int _pv_info(pv_t *pv, char *buf) {
  609. int sz = 0;
  610. char inactive_flag = 'A', allocation_flag = ' ';
  611. char *pv_name = NULL;
  613. if (!(pv->pv_status & PV_ACTIVE))
  614. inactive_flag = 'I';
  615. allocation_flag = 'A';
  616. if (!(pv->pv_allocatable & PV_ALLOCATABLE))
  617. allocation_flag = 'N';
  618. pv_name = strchr(pv->pv_name+1,'/');
  619. if ( pv_name == 0) pv_name = pv->pv_name;
  620. else               pv_name++;
  621. sz = sprintf(buf,
  622.      "[%c%c] %-21s %8d /%-6d  "
  623.      "%8d /%-6d  %8d /%-6d",
  624.      inactive_flag,
  625.      allocation_flag,
  626.      pv_name,
  627.      pv->pe_total * pv->pe_size >> 1,
  628.      pv->pe_total,
  629.      pv->pe_allocated * pv->pe_size >> 1,
  630.      pv->pe_allocated,
  631.      (pv->pe_total - pv->pe_allocated) *
  632.      pv->pe_size >> 1,
  633.      pv->pe_total - pv->pe_allocated);
  634. return sz;
  635. }
  637. static void _show_uuid(const char *src, char *b, char *e) {
  638. int i;
  640. e--;
  641. for(i = 0; *src && (b != e); i++) {
  642. if(i && !(i & 0x3))
  643. *b++ = '-';
  644. *b++ = *src++;
  645. }
  646. *b = '';
  647. }