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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
lvm-fs.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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