/*      $NetBSD: reporter.c,v 1.1.1.3 2009/12/02 00:25:55 haad Exp $    */

/*
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
* Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "tools.h"
#include "report.h"

static int _vgs_single(struct cmd_context *cmd __attribute((unused)),
                      const char *vg_name, struct volume_group *vg,
                      void *handle)
{
       if (!report_object(handle, vg, NULL, NULL, NULL, NULL)) {
               stack;
               return ECMD_FAILED;
       }

       check_current_backup(vg);

       return ECMD_PROCESSED;
}

static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv,
                      void *handle)
{
       if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv))
               return ECMD_PROCESSED;

       if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL)) {
               stack;
               return ECMD_FAILED;
       }

       return ECMD_PROCESSED;
}

static int _segs_single(struct cmd_context *cmd __attribute((unused)),
                       struct lv_segment *seg, void *handle)
{
       if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL)) {
               stack;
               return ECMD_FAILED;
       }

       return ECMD_PROCESSED;
}

static int _pvsegs_sub_single(struct cmd_context *cmd,
                             struct volume_group *vg,
                             struct pv_segment *pvseg, void *handle)
{
       int ret = ECMD_PROCESSED;
       struct lv_segment *seg = pvseg->lvseg;

       struct volume_group _free_vg = {
               .cmd = cmd,
               .name = (char *)"",
       };

       struct logical_volume _free_logical_volume = {
               .vg = vg ?: &_free_vg,
               .name = (char *) "",
               .snapshot = NULL,
               .status = VISIBLE_LV,
               .major = -1,
               .minor = -1,
       };

       struct lv_segment _free_lv_segment = {
               .lv = &_free_logical_volume,
               .le = 0,
               .status = 0,
               .stripe_size = 0,
               .area_count = 0,
               .area_len = 0,
               .origin = NULL,
               .cow = NULL,
               .chunk_size = 0,
               .region_size = 0,
               .extents_copied = 0,
               .log_lv = NULL,
               .areas = NULL,
       };

       _free_lv_segment.segtype = get_segtype_from_string(cmd, "free");
       _free_lv_segment.len = pvseg->len;
       dm_list_init(&_free_vg.pvs);
       dm_list_init(&_free_vg.lvs);
       dm_list_init(&_free_vg.tags);
       dm_list_init(&_free_lv_segment.tags);
       dm_list_init(&_free_lv_segment.origin_list);
       dm_list_init(&_free_logical_volume.tags);
       dm_list_init(&_free_logical_volume.segments);
       dm_list_init(&_free_logical_volume.segs_using_this_lv);
       dm_list_init(&_free_logical_volume.snapshot_segs);

       if (!report_object(handle, vg, seg ? seg->lv : &_free_logical_volume, pvseg->pv,
                          seg ? : &_free_lv_segment, pvseg)) {
               stack;
               ret = ECMD_FAILED;
       }

       return ret;
}

static int _lvsegs_single(struct cmd_context *cmd, struct logical_volume *lv,
                         void *handle)
{
       if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv))
               return ECMD_PROCESSED;

       return process_each_segment_in_lv(cmd, lv, handle, _segs_single);
}

static int _pvsegs_single(struct cmd_context *cmd, struct volume_group *vg,
                         struct physical_volume *pv, void *handle)
{
       return process_each_segment_in_pv(cmd, vg, pv, handle,
                                         _pvsegs_sub_single);
}

static int _pvs_single(struct cmd_context *cmd, struct volume_group *vg,
                      struct physical_volume *pv, void *handle)
{
       struct pv_list *pvl;
       int ret = ECMD_PROCESSED;
       const char *vg_name = NULL;
       struct volume_group *old_vg = vg;

       if (is_pv(pv) && !is_orphan(pv) && !vg) {
               vg_name = pv_vg_name(pv);

               vg = vg_read(cmd, vg_name, (char *)&pv->vgid, 0);
               if (vg_read_error(vg)) {
                       log_error("Skipping volume group %s", vg_name);
                       vg_release(vg);
                       return ECMD_FAILED;
               }

               /*
                * Replace possibly incomplete PV structure with new one
                * allocated in vg_read_internal() path.
               */
               if (!(pvl = find_pv_in_vg(vg, pv_dev_name(pv)))) {
                       log_error("Unable to find \"%s\" in volume group \"%s\"",
                                 pv_dev_name(pv), vg->name);
                       ret = ECMD_FAILED;
                       goto out;
               }

                pv = pvl->pv;
       }

       if (!report_object(handle, vg, NULL, pv, NULL, NULL)) {
               stack;
               ret = ECMD_FAILED;
       }

out:
       if (vg_name)
               unlock_vg(cmd, vg_name);

       if (!old_vg)
               vg_release(vg);

       return ret;
}

static int _label_single(struct cmd_context *cmd, struct volume_group *vg,
                      struct physical_volume *pv, void *handle)
{
       if (!report_object(handle, vg, NULL, pv, NULL, NULL)) {
               stack;
               return ECMD_FAILED;
       }

       return ECMD_PROCESSED;
}

static int _pvs_in_vg(struct cmd_context *cmd, const char *vg_name,
                     struct volume_group *vg,
                     void *handle)
{
       if (vg_read_error(vg)) {
               stack;
               return ECMD_FAILED;
       }

       return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvs_single);
}

static int _pvsegs_in_vg(struct cmd_context *cmd, const char *vg_name,
                        struct volume_group *vg,
                        void *handle)
{
       if (vg_read_error(vg)) {
               stack;
               return ECMD_FAILED;
       }

       return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvsegs_single);
}

static int _report(struct cmd_context *cmd, int argc, char **argv,
                  report_type_t report_type)
{
       void *report_handle;
       const char *opts;
       char *str;
       const char *keys = NULL, *options = NULL, *separator;
       int r = ECMD_PROCESSED;
       int aligned, buffered, headings, field_prefixes, quoted;
       int columns_as_rows;
       unsigned args_are_pvs;

       aligned = find_config_tree_int(cmd, "report/aligned",
                                 DEFAULT_REP_ALIGNED);
       buffered = find_config_tree_int(cmd, "report/buffered",
                                  DEFAULT_REP_BUFFERED);
       headings = find_config_tree_int(cmd, "report/headings",
                                  DEFAULT_REP_HEADINGS);
       separator = find_config_tree_str(cmd, "report/separator",
                                   DEFAULT_REP_SEPARATOR);
       field_prefixes = find_config_tree_int(cmd, "report/prefixes",
                                             DEFAULT_REP_PREFIXES);
       quoted = find_config_tree_int(cmd, "report/quoted",
                                    DEFAULT_REP_QUOTED);
       columns_as_rows = find_config_tree_int(cmd, "report/columns_as_rows",
                                              DEFAULT_REP_COLUMNS_AS_ROWS);

       args_are_pvs = (report_type == PVS ||
                       report_type == LABEL ||
                       report_type == PVSEGS) ? 1 : 0;

       switch (report_type) {
       case LVS:
               keys = find_config_tree_str(cmd, "report/lvs_sort",
                                      DEFAULT_LVS_SORT);
               if (!arg_count(cmd, verbose_ARG))
                       options = find_config_tree_str(cmd,
                                                 "report/lvs_cols",
                                                 DEFAULT_LVS_COLS);
               else
                       options = find_config_tree_str(cmd,
                                                 "report/lvs_cols_verbose",
                                                 DEFAULT_LVS_COLS_VERB);
               break;
       case VGS:
               keys = find_config_tree_str(cmd, "report/vgs_sort",
                                      DEFAULT_VGS_SORT);
               if (!arg_count(cmd, verbose_ARG))
                       options = find_config_tree_str(cmd,
                                                 "report/vgs_cols",
                                                 DEFAULT_VGS_COLS);
               else
                       options = find_config_tree_str(cmd,
                                                 "report/vgs_cols_verbose",
                                                 DEFAULT_VGS_COLS_VERB);
               break;
       case LABEL:
       case PVS:
               keys = find_config_tree_str(cmd, "report/pvs_sort",
                                      DEFAULT_PVS_SORT);
               if (!arg_count(cmd, verbose_ARG))
                       options = find_config_tree_str(cmd,
                                                 "report/pvs_cols",
                                                 DEFAULT_PVS_COLS);
               else
                       options = find_config_tree_str(cmd,
                                                 "report/pvs_cols_verbose",
                                                 DEFAULT_PVS_COLS_VERB);
               break;
       case SEGS:
               keys = find_config_tree_str(cmd, "report/segs_sort",
                                      DEFAULT_SEGS_SORT);
               if (!arg_count(cmd, verbose_ARG))
                       options = find_config_tree_str(cmd,
                                                 "report/segs_cols",
                                                 DEFAULT_SEGS_COLS);
               else
                       options = find_config_tree_str(cmd,
                                                 "report/segs_cols_verbose",
                                                 DEFAULT_SEGS_COLS_VERB);
               break;
       case PVSEGS:
               keys = find_config_tree_str(cmd, "report/pvsegs_sort",
                                      DEFAULT_PVSEGS_SORT);
               if (!arg_count(cmd, verbose_ARG))
                       options = find_config_tree_str(cmd,
                                                 "report/pvsegs_cols",
                                                 DEFAULT_PVSEGS_COLS);
               else
                       options = find_config_tree_str(cmd,
                                                 "report/pvsegs_cols_verbose",
                                                 DEFAULT_PVSEGS_COLS_VERB);
               break;
       }

       /* If -o supplied use it, else use default for report_type */
       if (arg_count(cmd, options_ARG)) {
               opts = arg_str_value(cmd, options_ARG, "");
               if (!opts || !*opts) {
                       log_error("Invalid options string: %s", opts);
                       return EINVALID_CMD_LINE;
               }
               if (*opts == '+') {
                       if (!(str = dm_pool_alloc(cmd->mem,
                                        strlen(options) + strlen(opts) + 1))) {
                               log_error("options string allocation failed");
                               return ECMD_FAILED;
                       }
                       strcpy(str, options);
                       strcat(str, ",");
                       strcat(str, opts + 1);
                       options = str;
               } else
                       options = opts;
       }

       /* -O overrides default sort settings */
       keys = arg_str_value(cmd, sort_ARG, keys);

       separator = arg_str_value(cmd, separator_ARG, separator);
       if (arg_count(cmd, separator_ARG))
               aligned = 0;
       if (arg_count(cmd, aligned_ARG))
               aligned = 1;
       if (arg_count(cmd, unbuffered_ARG) && !arg_count(cmd, sort_ARG))
               buffered = 0;
       if (arg_count(cmd, noheadings_ARG))
               headings = 0;
       if (arg_count(cmd, nameprefixes_ARG)) {
               aligned = 0;
               field_prefixes = 1;
       }
       if (arg_count(cmd, unquoted_ARG))
               quoted = 0;
       if (arg_count(cmd, rows_ARG))
               columns_as_rows = 1;

       if (!(report_handle = report_init(cmd, options, keys, &report_type,
                                         separator, aligned, buffered,
                                         headings, field_prefixes, quoted,
                                         columns_as_rows))) {
               stack;
               return ECMD_FAILED;
       }

       /* Ensure options selected are compatible */
       if (report_type & SEGS)
               report_type |= LVS;
       if (report_type & PVSEGS)
               report_type |= PVS;
       if ((report_type & LVS) && (report_type & (PVS | LABEL)) && !args_are_pvs) {
               log_error("Can't report LV and PV fields at the same time");
               dm_report_free(report_handle);
               return ECMD_FAILED;
       }

       /* Change report type if fields specified makes this necessary */
       if ((report_type & PVSEGS) ||
           ((report_type & (PVS | LABEL)) && (report_type & LVS)))
               report_type = PVSEGS;
       else if ((report_type & LABEL) && (report_type & VGS))
               report_type = PVS;
       else if (report_type & PVS)
               report_type = PVS;
       else if (report_type & SEGS)
               report_type = SEGS;
       else if (report_type & LVS)
               report_type = LVS;

       switch (report_type) {
       case LVS:
               r = process_each_lv(cmd, argc, argv, 0, report_handle,
                                   &_lvs_single);
               break;
       case VGS:
               r = process_each_vg(cmd, argc, argv, 0,
                                   report_handle, &_vgs_single);
               break;
       case LABEL:
               r = process_each_pv(cmd, argc, argv, NULL, READ_WITHOUT_LOCK,
                                   1, report_handle, &_label_single);
               break;
       case PVS:
               if (args_are_pvs)
                       r = process_each_pv(cmd, argc, argv, NULL, 0,
                                           0, report_handle, &_pvs_single);
               else
                       r = process_each_vg(cmd, argc, argv, 0,
                                           report_handle, &_pvs_in_vg);
               break;
       case SEGS:
               r = process_each_lv(cmd, argc, argv, 0, report_handle,
                                   &_lvsegs_single);
               break;
       case PVSEGS:
               if (args_are_pvs)
                       r = process_each_pv(cmd, argc, argv, NULL, 0,
                                           0, report_handle, &_pvsegs_single);
               else
                       r = process_each_vg(cmd, argc, argv, 0,
                                           report_handle, &_pvsegs_in_vg);
               break;
       }

       dm_report_output(report_handle);

       dm_report_free(report_handle);
       return r;
}

int lvs(struct cmd_context *cmd, int argc, char **argv)
{
       report_type_t type;

       if (arg_count(cmd, segments_ARG))
               type = SEGS;
       else
               type = LVS;

       return _report(cmd, argc, argv, type);
}

int vgs(struct cmd_context *cmd, int argc, char **argv)
{
       return _report(cmd, argc, argv, VGS);
}

int pvs(struct cmd_context *cmd, int argc, char **argv)
{
       report_type_t type;

       if (arg_count(cmd, segments_ARG))
               type = PVSEGS;
       else
               type = LABEL;

       return _report(cmd, argc, argv, type);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.