tools/reporter.c

   1 /*
   2  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   3  * Copyright (C) 2004-2009 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 Lesser General Public License v.2.1.
  10  *
  11  * You should have received a copy of the GNU Lesser 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 #include "report.h"
  18
  19 static int _vgs_single(struct cmd_context *cmd __attribute__((unused)),
  20                        const char *vg_name, struct volume_group *vg,
  21                        void *handle)
  22 {
  23         if (!report_object(handle, vg, NULL, NULL, NULL, NULL)) {
  24                 stack;
  25                 return ECMD_FAILED;
  26         }
  27
  28         check_current_backup(vg);
  29
  30         return ECMD_PROCESSED;
  31 }
  32
  33 static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv,
  34                        void *handle)
  35 {
  36         if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL)) {
  37                 stack;
  38                 return ECMD_FAILED;
  39         }
  40
  41         return ECMD_PROCESSED;
  42 }
  43
  44 static int _segs_single(struct cmd_context *cmd __attribute__((unused)),
  45                         struct lv_segment *seg, void *handle)
  46 {
  47         if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL)) {
  48                 stack;
  49                 return ECMD_FAILED;
  50         }
  51
  52         return ECMD_PROCESSED;
  53 }
  54 static int _pvsegs_sub_single(struct cmd_context *cmd,
  55                               struct volume_group *vg,
  56                               struct pv_segment *pvseg, void *handle)
  57 {
  58         int ret = ECMD_PROCESSED;
  59         struct lv_segment *seg = pvseg->lvseg;
  60
  61         struct volume_group _free_vg = {
  62                 .cmd = cmd,
  63                 .name = "",
  64                 .vgmem = NULL,
  65         };
  66
  67         struct logical_volume _free_logical_volume = {
  68                 .vg = vg ?: &_free_vg,
  69                 .name = "",
  70                 .snapshot = NULL,
  71                 .status = VISIBLE_LV,
  72                 .major = -1,
  73                 .minor = -1,
  74         };
  75
  76         struct lv_segment _free_lv_segment = {
  77                 .lv = &_free_logical_volume,
  78                 .le = 0,
  79                 .status = 0,
  80                 .stripe_size = 0,
  81                 .area_count = 0,
  82                 .area_len = 0,
  83                 .origin = NULL,
  84                 .cow = NULL,
  85                 .chunk_size = 0,
  86                 .region_size = 0,
  87                 .extents_copied = 0,
  88                 .log_lv = NULL,
  89                 .areas = NULL,
  90         };
  91
  92         _free_lv_segment.segtype = get_segtype_from_string(cmd, "free");
  93         _free_lv_segment.len = pvseg->len;
  94         dm_list_init(&_free_vg.pvs);
  95         dm_list_init(&_free_vg.lvs);
  96         dm_list_init(&_free_vg.tags);
  97         dm_list_init(&_free_lv_segment.tags);
  98         dm_list_init(&_free_lv_segment.origin_list);
  99         dm_list_init(&_free_logical_volume.tags);
 100         dm_list_init(&_free_logical_volume.segments);
 101         dm_list_init(&_free_logical_volume.segs_using_this_lv);
 102         dm_list_init(&_free_logical_volume.snapshot_segs);
 103
 104         if (!report_object(handle, vg, seg ? seg->lv : &_free_logical_volume, pvseg->pv,
 105                            seg ? : &_free_lv_segment, pvseg)) {
 106                 ret = ECMD_FAILED;
 107                 goto_out;
 108         }
 109
 110  out:
 111         return ret;
 112 }
 113
 114 static int _lvsegs_single(struct cmd_context *cmd, struct logical_volume *lv,
 115                           void *handle)
 116 {
 117         if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv))
 118                 return ECMD_PROCESSED;
 119
 120         return process_each_segment_in_lv(cmd, lv, handle, _segs_single);
 121 }
 122
 123 static int _pvsegs_single(struct cmd_context *cmd, struct volume_group *vg,
 124                           struct physical_volume *pv, void *handle)
 125 {
 126         return process_each_segment_in_pv(cmd, vg, pv, handle,
 127                                           _pvsegs_sub_single);
 128 }
 129
 130 static int _pvs_single(struct cmd_context *cmd, struct volume_group *vg,
 131                        struct physical_volume *pv, void *handle)
 132 {
 133         struct pv_list *pvl;
 134         int ret = ECMD_PROCESSED;
 135         const char *vg_name = NULL;
 136         struct volume_group *old_vg = vg;
 137         char uuid[64] __attribute__((aligned(8)));
 138
 139         if (is_pv(pv) && !is_orphan(pv) && !vg) {
 140                 vg_name = pv_vg_name(pv);
 141
 142                 vg = vg_read(cmd, vg_name, (char *)&pv->vgid, 0);
 143                 if (vg_read_error(vg)) {
 144                         log_error("Skipping volume group %s", vg_name);
 145                         release_vg(vg);
 146                         return ECMD_FAILED;
 147                 }
 148
 149                 /*
 150                  * Replace possibly incomplete PV structure with new one
 151                  * allocated in vg_read.
 152                 */
 153                 if (!is_missing_pv(pv)) {
 154                         if (!(pvl = find_pv_in_vg(vg, pv_dev_name(pv)))) {
 155                                 log_error("Unable to find \"%s\" in volume group \"%s\"",
 156                                           pv_dev_name(pv), vg->name);
 157                                 ret = ECMD_FAILED;
 158                                 goto out;
 159                         }
 160                 } else if (!(pvl = find_pv_in_vg_by_uuid(vg, &pv->id))) {
 161                         if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
 162                                 stack;
 163                                 uuid[0] = '\0';
 164                         }
 165
 166                         log_error("Unable to find missing PV %s in volume group %s",
 167                                   uuid, vg->name);
 168                         ret = ECMD_FAILED;
 169                         goto out;
 170                 }
 171
 172                 pv = pvl->pv;
 173         }
 174
 175         if (!report_object(handle, vg, NULL, pv, NULL, NULL)) {
 176                 stack;
 177                 ret = ECMD_FAILED;
 178         }
 179
 180 out:
 181         if (vg_name)
 182                 unlock_vg(cmd, vg_name);
 183
 184         if (!old_vg)
 185                 release_vg(vg);
 186
 187         return ret;
 188 }
 189
 190 static int _label_single(struct cmd_context *cmd, struct volume_group *vg,
 191                        struct physical_volume *pv, void *handle)
 192 {
 193         if (!report_object(handle, vg, NULL, pv, NULL, NULL)) {
 194                 stack;
 195                 return ECMD_FAILED;
 196         }
 197
 198         return ECMD_PROCESSED;
 199 }
 200
 201 static int _pvs_in_vg(struct cmd_context *cmd, const char *vg_name,
 202                       struct volume_group *vg,
 203                       void *handle)
 204 {
 205         if (vg_read_error(vg)) {
 206                 stack;
 207                 return ECMD_FAILED;
 208         }
 209
 210         return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvs_single);
 211 }
 212
 213 static int _pvsegs_in_vg(struct cmd_context *cmd, const char *vg_name,
 214                          struct volume_group *vg,
 215                          void *handle)
 216 {
 217         if (vg_read_error(vg)) {
 218                 stack;
 219                 return ECMD_FAILED;
 220         }
 221
 222         return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvsegs_single);
 223 }
 224
 225 static int _report(struct cmd_context *cmd, int argc, char **argv,
 226                    report_type_t report_type)
 227 {
 228         void *report_handle;
 229         const char *opts;
 230         char *str;
 231         const char *keys = NULL, *options = NULL, *separator;
 232         int r = ECMD_PROCESSED;
 233         int aligned, buffered, headings, field_prefixes, quoted;
 234         int columns_as_rows;
 235         unsigned args_are_pvs;
 236
 237         aligned = find_config_tree_int(cmd, "report/aligned",
 238                                   DEFAULT_REP_ALIGNED);
 239         buffered = find_config_tree_int(cmd, "report/buffered",
 240                                    DEFAULT_REP_BUFFERED);
 241         headings = find_config_tree_int(cmd, "report/headings",
 242                                    DEFAULT_REP_HEADINGS);
 243         separator = find_config_tree_str(cmd, "report/separator",
 244                                     DEFAULT_REP_SEPARATOR);
 245         field_prefixes = find_config_tree_int(cmd, "report/prefixes",
 246                                               DEFAULT_REP_PREFIXES);
 247         quoted = find_config_tree_int(cmd, "report/quoted",
 248                                      DEFAULT_REP_QUOTED);
 249         columns_as_rows = find_config_tree_int(cmd, "report/columns_as_rows",
 250                                                DEFAULT_REP_COLUMNS_AS_ROWS);
 251
 252         args_are_pvs = (report_type == PVS ||
 253                         report_type == LABEL ||
 254                         report_type == PVSEGS) ? 1 : 0;
 255
 256         switch (report_type) {
 257         case LVS:
 258                 keys = find_config_tree_str(cmd, "report/lvs_sort",
 259                                        DEFAULT_LVS_SORT);
 260                 if (!arg_count(cmd, verbose_ARG))
 261                         options = find_config_tree_str(cmd,
 262                                                   "report/lvs_cols",
 263                                                   DEFAULT_LVS_COLS);
 264                 else
 265                         options = find_config_tree_str(cmd,
 266                                                   "report/lvs_cols_verbose",
 267                                                   DEFAULT_LVS_COLS_VERB);
 268                 break;
 269         case VGS:
 270                 keys = find_config_tree_str(cmd, "report/vgs_sort",
 271                                        DEFAULT_VGS_SORT);
 272                 if (!arg_count(cmd, verbose_ARG))
 273                         options = find_config_tree_str(cmd,
 274                                                   "report/vgs_cols",
 275                                                   DEFAULT_VGS_COLS);
 276                 else
 277                         options = find_config_tree_str(cmd,
 278                                                   "report/vgs_cols_verbose",
 279                                                   DEFAULT_VGS_COLS_VERB);
 280                 break;
 281         case LABEL:
 282         case PVS:
 283                 keys = find_config_tree_str(cmd, "report/pvs_sort",
 284                                        DEFAULT_PVS_SORT);
 285                 if (!arg_count(cmd, verbose_ARG))
 286                         options = find_config_tree_str(cmd,
 287                                                   "report/pvs_cols",
 288                                                   DEFAULT_PVS_COLS);
 289                 else
 290                         options = find_config_tree_str(cmd,
 291                                                   "report/pvs_cols_verbose",
 292                                                   DEFAULT_PVS_COLS_VERB);
 293                 break;
 294         case SEGS:
 295                 keys = find_config_tree_str(cmd, "report/segs_sort",
 296                                        DEFAULT_SEGS_SORT);
 297                 if (!arg_count(cmd, verbose_ARG))
 298                         options = find_config_tree_str(cmd,
 299                                                   "report/segs_cols",
 300                                                   DEFAULT_SEGS_COLS);
 301                 else
 302                         options = find_config_tree_str(cmd,
 303                                                   "report/segs_cols_verbose",
 304                                                   DEFAULT_SEGS_COLS_VERB);
 305                 break;
 306         case PVSEGS:
 307                 keys = find_config_tree_str(cmd, "report/pvsegs_sort",
 308                                        DEFAULT_PVSEGS_SORT);
 309                 if (!arg_count(cmd, verbose_ARG))
 310                         options = find_config_tree_str(cmd,
 311                                                   "report/pvsegs_cols",
 312                                                   DEFAULT_PVSEGS_COLS);
 313                 else
 314                         options = find_config_tree_str(cmd,
 315                                                   "report/pvsegs_cols_verbose",
 316                                                   DEFAULT_PVSEGS_COLS_VERB);
 317                 break;
 318         default:
 319                 log_error(INTERNAL_ERROR "Unknown report type.");
 320                 return ECMD_FAILED;
 321         }
 322
 323         /* If -o supplied use it, else use default for report_type */
 324         if (arg_count(cmd, options_ARG)) {
 325                 opts = arg_str_value(cmd, options_ARG, "");
 326                 if (!opts || !*opts) {
 327                         log_error("Invalid options string: %s", opts);
 328                         return EINVALID_CMD_LINE;
 329                 }
 330                 if (*opts == '+') {
 331                         if (!(str = dm_pool_alloc(cmd->mem,
 332                                          strlen(options) + strlen(opts) + 1))) {
 333                                 log_error("options string allocation failed");
 334                                 return ECMD_FAILED;
 335                         }
 336                         strcpy(str, options);
 337                         strcat(str, ",");
 338                         strcat(str, opts + 1);
 339                         options = str;
 340                 } else
 341                         options = opts;
 342         }
 343
 344         /* -O overrides default sort settings */
 345         keys = arg_str_value(cmd, sort_ARG, keys);
 346
 347         separator = arg_str_value(cmd, separator_ARG, separator);
 348         if (arg_count(cmd, separator_ARG))
 349                 aligned = 0;
 350         if (arg_count(cmd, aligned_ARG))
 351                 aligned = 1;
 352         if (arg_count(cmd, unbuffered_ARG) && !arg_count(cmd, sort_ARG))
 353                 buffered = 0;
 354         if (arg_count(cmd, noheadings_ARG))
 355                 headings = 0;
 356         if (arg_count(cmd, nameprefixes_ARG)) {
 357                 aligned = 0;
 358                 field_prefixes = 1;
 359         }
 360         if (arg_count(cmd, unquoted_ARG))
 361                 quoted = 0;
 362         if (arg_count(cmd, rows_ARG))
 363                 columns_as_rows = 1;
 364
 365         if (!(report_handle = report_init(cmd, options, keys, &report_type,
 366                                           separator, aligned, buffered,
 367                                           headings, field_prefixes, quoted,
 368                                           columns_as_rows))) {
 369                 if (!strcasecmp(options, "help") || !strcmp(options, "?"))
 370                         return r;
 371                 stack;
 372                 return ECMD_FAILED;
 373         }
 374
 375         /* Ensure options selected are compatible */
 376         if (report_type & SEGS)
 377                 report_type |= LVS;
 378         if (report_type & PVSEGS)
 379                 report_type |= PVS;
 380         if ((report_type & LVS) && (report_type & (PVS | LABEL)) && !args_are_pvs) {
 381                 log_error("Can't report LV and PV fields at the same time");
 382                 dm_report_free(report_handle);
 383                 return ECMD_FAILED;
 384         }
 385
 386         /* Change report type if fields specified makes this necessary */
 387         if ((report_type & PVSEGS) ||
 388             ((report_type & (PVS | LABEL)) && (report_type & LVS)))
 389                 report_type = PVSEGS;
 390         else if ((report_type & LABEL) && (report_type & VGS))
 391                 report_type = PVS;
 392         else if (report_type & PVS)
 393                 report_type = PVS;
 394         else if (report_type & SEGS)
 395                 report_type = SEGS;
 396         else if (report_type & LVS)
 397                 report_type = LVS;
 398
 399         switch (report_type) {
 400         case LVS:
 401                 r = process_each_lv(cmd, argc, argv, 0, report_handle,
 402                                     &_lvs_single);
 403                 break;
 404         case VGS:
 405                 r = process_each_vg(cmd, argc, argv, 0,
 406                                     report_handle, &_vgs_single);
 407                 break;
 408         case LABEL:
 409                 r = process_each_pv(cmd, argc, argv, NULL, READ_WITHOUT_LOCK,
 410                                     1, report_handle, &_label_single);
 411                 break;
 412         case PVS:
 413                 if (args_are_pvs)
 414                         r = process_each_pv(cmd, argc, argv, NULL, 0,
 415                                             0, report_handle, &_pvs_single);
 416                 else
 417                         r = process_each_vg(cmd, argc, argv, 0,
 418                                             report_handle, &_pvs_in_vg);
 419                 break;
 420         case SEGS:
 421                 r = process_each_lv(cmd, argc, argv, 0, report_handle,
 422                                     &_lvsegs_single);
 423                 break;
 424         case PVSEGS:
 425                 if (args_are_pvs)
 426                         r = process_each_pv(cmd, argc, argv, NULL, 0,
 427                                             0, report_handle, &_pvsegs_single);
 428                 else
 429                         r = process_each_vg(cmd, argc, argv, 0,
 430                                             report_handle, &_pvsegs_in_vg);
 431                 break;
 432         }
 433
 434         dm_report_output(report_handle);
 435
 436         dm_report_free(report_handle);
 437         return r;
 438 }
 439
 440 int lvs(struct cmd_context *cmd, int argc, char **argv)
 441 {
 442         report_type_t type;
 443
 444         if (arg_count(cmd, segments_ARG))
 445                 type = SEGS;
 446         else
 447                 type = LVS;
 448
 449         return _report(cmd, argc, argv, type);
 450 }
 451
 452 int vgs(struct cmd_context *cmd, int argc, char **argv)
 453 {
 454         return _report(cmd, argc, argv, VGS);
 455 }
 456
 457 int pvs(struct cmd_context *cmd, int argc, char **argv)
 458 {
 459         report_type_t type;
 460
 461         if (arg_count(cmd, segments_ARG))
 462                 type = PVSEGS;
 463         else
 464                 type = LABEL;
 465
 466         return _report(cmd, argc, argv, type);
 467 }