lvm2/tools/lvmdiskscan.c

/*
 * Copyright (C) 2002 Sistina Software
 *
 * This file is released under the GPL.
 *
 */

/*
 * Changelog
 *
 *   05/02/2002 - First drop [HM]
 */

#include "tools.h"

int _get_max_dev_name_len(void);
void _count(struct device*, int*, int*);
void _print(struct device*, uint64_t, char*);
int _check_device(struct device*);

int disks_found = 0;
int parts_found = 0;
int pv_disks_found = 0;
int pv_parts_found = 0;
int max_len;

int lvmdiskscan(int argc, char **argv)
{
	uint64_t size;
        struct dev_iter *iter;
        struct device *dev;
	struct physical_volume *pv;

	if (arg_count(lvmpartition_ARG))
		log_print("WARNING: only considering LVM devices");

	max_len = _get_max_dev_name_len();

        if (!(iter = dev_iter_create(fid->cmd->filter))) {
                log_error("dev_iter_create failed");
                return 0;
        }

        /* Do scan */
        for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) {
		/* Try if it is a PV first */
		if((pv = fid->ops->pv_read(fid, dev_name(dev)))) {
			if(!dev_get_size(dev, &size)) {
				log_error("Couldn't get size of \"%s\"",
					  dev_name(dev));
				continue;
			}
			_print(dev, size, "LVM physical volume");
			_count(dev, &pv_disks_found, &pv_parts_found);
			continue;
		}
		/* If user just wants PVs we are done */
		if (arg_count(lvmpartition_ARG)) continue;
		
		/* What other device is it? */
		if(!_check_device(dev)) continue;
        }
        dev_iter_destroy(iter);

	/* Display totals */
	if (!arg_count(lvmpartition_ARG)) {
		log_print("%d disk%s",
			  disks_found, disks_found == 1 ? "" : "s");
		log_print("%d partition%s",
			  parts_found, parts_found == 1 ? "" : "s");
	}
	log_print("%d LVM physical volume whole disk%s",
		  pv_disks_found, pv_disks_found == 1 ? "" : "s");
	log_print("%d LVM physical volume%s",
		  pv_parts_found, pv_parts_found == 1 ? "" : "s");

	return 0;
}


int _check_device(struct device *dev) {
	char buffer;
	uint64_t size;

	if (!dev_open(dev, 0)) {
		return 0;
	}
	if (dev_read(dev, 0, 1, &buffer) != 1) {
		dev_close(dev);
		return 0;
	}
	if(!dev_get_size(dev, &size)) {
		log_error("Couldn't get size of \"%s\"",
			  dev_name(dev));
	}
	_print(dev, size, NULL);
	_count(dev, &disks_found, &parts_found);
	if (!dev_close(dev)) {
               	log_error("dev_close on \"%s\" failed", dev_name(dev));
		return 0;
	}
	return 1;
}


int _get_max_dev_name_len(void) {
	int len = 0;
	int max_len = 0;
        struct dev_iter *iter;
        struct device *dev;

        if (!(iter = dev_iter_create(fid->cmd->filter))) {
                log_error("dev_iter_create failed");
                return 0;
        }

        /* Do scan */
        for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) {
		len = strlen(dev_name(dev));
		if (len > max_len) max_len = len;
	}
        dev_iter_destroy(iter);

	return max_len;
}


void _count(struct device *dev, int *disks, int *parts) {
	int c = dev_name(dev)[strlen(dev_name(dev))-1];

	if(!isdigit(c))	(*disks)++;
	else		(*parts)++;
}

void _print(struct device *dev, uint64_t size, char *what) {
	char *dummy = display_size(size/2, SIZE_SHORT);
	const char *name = dev_name(dev);

	if(!what) {
		
		what = "";
	}

	log_print("%-*s [%15s] %s", max_len, name, dummy, what);
	dbg_free(dummy);
}