tools/pvscan.c

   1 /*
   2  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   3  * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
   4  *
   5  * This file is part of LVM2.
   6  *
   7  * This copyrighted material is made available to anyone wishing to use,
   8  * modify, copy, or redistribute it subject to the terms and conditions
   9  * of the GNU General Public License v.2.
  10  *
  11  * You should have received a copy of the GNU General Public License
  12  * along with this program; if not, write to the Free Software Foundation,
  13  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14  */
  15
  16 #include "tools.h"
  17
  18 int pv_max_name_len = 0;
  19 int vg_max_name_len = 0;
  20
  21 static void _pvscan_display_single(struct cmd_context *cmd,
  22                                    struct physical_volume *pv,
  23                                    void *handle __attribute((unused)))
  24 {
  25         char uuid[64] __attribute((aligned(8)));
  26         unsigned vg_name_len = 0;
  27
  28         char pv_tmp_name[NAME_LEN] = { 0, };
  29         char vg_tmp_name[NAME_LEN] = { 0, };
  30         char vg_name_this[NAME_LEN] = { 0, };
  31
  32         /* short listing? */
  33         if (arg_count(cmd, short_ARG) > 0) {
  34                 log_print("%s", dev_name(get_pv_dev(pv)));
  35                 return;
  36         }
  37
  38         if (arg_count(cmd, verbose_ARG) > 1) {
  39                 /* FIXME As per pv_display! Drop through for now. */
  40                 /* pv_show(pv); */
  41
  42                 /* FIXME - Moved to Volume Group structure */
  43                 /* log_print("System Id             %s", pv->vg->system_id); */
  44
  45                 /* log_print(" "); */
  46                 /* return; */
  47         }
  48
  49         memset(pv_tmp_name, 0, sizeof(pv_tmp_name));
  50
  51         vg_name_len = strlen(pv->vg_name) + 1;
  52
  53         if (arg_count(cmd, uuid_ARG)) {
  54                 if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
  55                         stack;
  56                         return;
  57                 }
  58
  59                 sprintf(pv_tmp_name, "%-*s with UUID %s",
  60                         pv_max_name_len - 2, dev_name(get_pv_dev(pv)), uuid);
  61         } else {
  62                 sprintf(pv_tmp_name, "%s", dev_name(get_pv_dev(pv)));
  63         }
  64
  65         if (!*pv->vg_name) {
  66                 log_print("PV %-*s    %-*s %s [%s]",
  67                           pv_max_name_len, pv_tmp_name,
  68                           vg_max_name_len, " ",
  69                           pv->fmt ? pv->fmt->name : "    ",
  70                           display_size(cmd, get_pv_size(pv)));
  71                 return;
  72         }
  73
  74         if (get_pv_status(pv) & EXPORTED_VG) {
  75                 strncpy(vg_name_this, pv->vg_name, vg_name_len);
  76                 log_print("PV %-*s  is in exported VG %s "
  77                           "[%s / %s free]",
  78                           pv_max_name_len, pv_tmp_name,
  79                           vg_name_this,
  80                           display_size(cmd, (uint64_t) get_pv_pe_count(pv) *
  81                                        get_pv_pe_size(pv)),
  82                           display_size(cmd, (uint64_t) (get_pv_pe_count(pv) -
  83                                                 get_pv_pe_alloc_count(pv))
  84                                        * get_pv_pe_size(pv)));
  85                 return;
  86         }
  87
  88         sprintf(vg_tmp_name, "%s", pv->vg_name);
  89         log_print("PV %-*s VG %-*s %s [%s / %s free]", pv_max_name_len,
  90                   pv_tmp_name, vg_max_name_len, vg_tmp_name,
  91                   pv->fmt ? pv->fmt->name : "    ",
  92                   display_size(cmd, (uint64_t) get_pv_pe_count(pv) *
  93                                                get_pv_pe_size(pv)),
  94                   display_size(cmd, (uint64_t) (get_pv_pe_count(pv) -
  95                                                 get_pv_pe_alloc_count(pv)) *
  96                                            get_pv_pe_size(pv)));
  97         return;
  98 }
  99
 100 int pvscan(struct cmd_context *cmd, int argc __attribute((unused)),
 101            char **argv __attribute((unused)))
 102 {
 103         int new_pvs_found = 0;
 104         int pvs_found = 0;
 105
 106         struct list *pvslist;
 107         struct pv_list *pvl;
 108         struct physical_volume *pv;
 109
 110         uint64_t size_total = 0;
 111         uint64_t size_new = 0;
 112
 113         int len = 0;
 114         pv_max_name_len = 0;
 115         vg_max_name_len = 0;
 116
 117         if (arg_count(cmd, novolumegroup_ARG) && arg_count(cmd, exported_ARG)) {
 118                 log_error("Options -e and -n are incompatible");
 119                 return EINVALID_CMD_LINE;
 120         }
 121
 122         if (arg_count(cmd, exported_ARG) || arg_count(cmd, novolumegroup_ARG))
 123                 log_print("WARNING: only considering physical volumes %s",
 124                           arg_count(cmd, exported_ARG) ?
 125                           "of exported volume group(s)" : "in no volume group");
 126
 127         persistent_filter_wipe(cmd->filter);
 128         lvmcache_destroy();
 129
 130         log_verbose("Walking through all physical volumes");
 131         if (!(pvslist = get_pvs(cmd)))
 132                 return ECMD_FAILED;
 133
 134         /* eliminate exported/new if required */
 135         list_iterate_items(pvl, pvslist) {
 136                 pv = pvl->pv;
 137
 138                 if ((arg_count(cmd, exported_ARG)
 139                      && !(get_pv_status(pv) & EXPORTED_VG))
 140                     || (arg_count(cmd, novolumegroup_ARG) && (*pv->vg_name))) {
 141                         list_del(&pvl->list);
 142                         continue;
 143                 }
 144
 145                 /* Also check for MD use? */
 146 /*******
 147                 if (MAJOR(pv_create_kdev_t(pv[p]->pv_name)) != MD_MAJOR) {
 148                         log_print
 149                             ("WARNING: physical volume \"%s\" belongs to a meta device",
 150                              pv[p]->pv_name);
 151                 }
 152                 if (MAJOR(pv[p]->pv_dev) != MD_MAJOR)
 153                         continue;
 154 ********/
 155                 pvs_found++;
 156
 157                 if (!*pv->vg_name) {
 158                         new_pvs_found++;
 159                         size_new += get_pv_size(pv);
 160                         size_total += get_pv_size(pv);
 161                 } else
 162                         size_total += get_pv_pe_count(pv) * get_pv_pe_size(pv);
 163         }
 164
 165         /* find maximum pv name length */
 166         pv_max_name_len = vg_max_name_len = 0;
 167         list_iterate_items(pvl, pvslist) {
 168                 pv = pvl->pv;
 169                 len = strlen(dev_name(get_pv_dev(pv)));
 170                 if (pv_max_name_len < len)
 171                         pv_max_name_len = len;
 172                 len = strlen(pv->vg_name);
 173                 if (vg_max_name_len < len)
 174                         vg_max_name_len = len;
 175         }
 176         pv_max_name_len += 2;
 177         vg_max_name_len += 2;
 178
 179         list_iterate_items(pvl, pvslist)
 180             _pvscan_display_single(cmd, pvl->pv, NULL);
 181
 182         if (!pvs_found) {
 183                 log_print("No matching physical volumes found");
 184                 return ECMD_PROCESSED;
 185         }
 186
 187         log_print("Total: %d [%s] / in use: %d [%s] / in no VG: %d [%s]",
 188                   pvs_found,
 189                   display_size(cmd, size_total),
 190                   pvs_found - new_pvs_found,
 191                   display_size(cmd, (size_total - size_new)),
 192                   new_pvs_found, display_size(cmd, size_new));
 193
 194         return ECMD_PROCESSED;
 195 }