raid_io.c.ia64

create raid tool at linux

/*
 * raid_io.c : Utility for the Linux Multiple Devices driver
 *             Copyright (C) 1997 Ingo Molnar, Miguel de Icaza, Gadi Oxman
 *	       Copyright (C) 1998 Erik Troan
 *
 * RAID IO operations.
 *
 * This source is covered by the GNU GPL, the same as all Linux kernel
 * sources.
 *
 * 97-09-23: >4GB limit fix, Rob Hagopian <[e-mail]>
 */

#include <sys/mount.h>		/* for BLKGETSIZE */
#ifndef BLKGETSIZE
#include <linux/fs.h>          /* for BLKGETSIZE */
#endif
#include <sys/sysmacros.h>

#ifndef BLOCK_SIZE
#define BLOCK_SIZE      1024
#endif

#ifndef BLKGETSIZE
#define BLKGETSIZE _IO(0x12, 96) /* Return device size.  */
#endif


#include "common.h"
#include "config.h"
#include "parser.h"
#include "raidlib.h"

md_cfg_entry_t *p;
mdp_super_t *sb;


#define TIME long long

static unsigned long T (void)
{
	struct timeval t;
	t.tv_usec = 1;
	t.tv_sec = 1;
	gettimeofday(&t,0);

	return (t.tv_usec+t.tv_sec*1000000);
}


#define F float
void progress (unsigned long blocks, unsigned long current)
{
	static TIME begin_t = 0, last_status_t = 0;
	TIME left_t, elapsed_t;
	TIME now_t;

	if (!begin_t)
		begin_t = last_status_t = T();

	now_t = T();
	/*
	 * do max one status update per second
	 */
	if ((current != blocks) && (now_t-last_status_t < (TIME)1e6))
		return;

	elapsed_t = (now_t-begin_t)/(TIME)1e6;
	left_t = (TIME) ((F)(elapsed_t) * ((F)blocks/(F)current-1.0));

	OUT("(%2ld%% done; ~%d:%02d left %d:%02d elapsed [%.1f KB/sec])",
		(current / (blocks/100)),
		(int) left_t/60, (int) left_t%60,
		(int) elapsed_t/60, (int) elapsed_t%60,
		((F)current)/(F)elapsed_t
	);
	fflush(stderr);
	putc('\r', stderr);

	last_status_t=now_t;
}
#undef F

#if !(defined(__alpha__) || defined(__sparc_v9__))
# ifndef __NR__llseek
#  ifdef __sparc__
#   define __NR__llseek		236
#  else
#   define __NR__llseek		140
#  endif
# endif

static int _llseek (unsigned int, unsigned long,
		unsigned long, long long *, unsigned int);

static _syscall5( int, _llseek, unsigned int, fd, unsigned long, offset_high,
		unsigned long, offset_low, long long *, result,
		unsigned int, origin)
#endif

long long raidseek (unsigned int fd, unsigned long blk)
{
	unsigned long long offset = (unsigned long long)blk *
					(unsigned long long) MD_BLK_SIZ;
	long long result;
	int retval;

#if defined(__alpha__) || defined(__sparc_v9__)
	return lseek(fd, offset, SEEK_SET);
#else
	retval = _llseek (fd, ((unsigned long long) offset) >> 32,
			((unsigned long long) offset) & 0xffffffff,
			&result, SEEK_SET);
	return (retval == -1 ? (long long) retval : result);
#endif
}

int upgrade_sb (int fd, mdp_super_t *sb, md_cfg_entry_t * cfg, int verbose)
{
	struct stat stat_buf;
	mdp_disk_t *disk;
	int i;

	if (
		 (sb->major_version == MKRAID_MAJOR_VERSION) &&
		 (sb->minor_version == MKRAID_MINOR_VERSION) &&
		 (sb->patch_version == MKRAID_PATCHLEVEL_VERSION)) {
		fprintf(stderr, "array needs no upgrade\n");
		return 1;
	}

	if (
		 (sb->major_version > MKRAID_MAJOR_VERSION) ||
		 ((sb->major_version == MKRAID_MAJOR_VERSION) &&
		 (sb->minor_version > MKRAID_MINOR_VERSION)) ||
		 ((sb->major_version == MKRAID_MAJOR_VERSION) &&
		 (sb->minor_version == MKRAID_MINOR_VERSION) &&
		 (sb->patch_version > MKRAID_PATCHLEVEL_VERSION))) {
		fprintf(stderr, "cannot downgrade array ... \n");
		return 1;
	}

	if (verbose) {
		printf("MD ID:                   %x\n", sb->md_magic);
		printf("Changing MD version from %d.%d.%d to %d.%d.%d.\n",
			 sb->major_version, sb->minor_version,sb->patch_version,
		 	MKRAID_MAJOR_VERSION, MKRAID_MINOR_VERSION,
			MKRAID_PATCHLEVEL_VERSION);
	}

	sb->major_version = MKRAID_MAJOR_VERSION;
	sb->minor_version = MKRAID_MINOR_VERSION;
	sb->patch_version = MKRAID_PATCHLEVEL_VERSION;

	if (verbose)
		if ((sb->major_version > 0) || (sb->minor_version >= 50))
		printf("preferred minor %d (md%d)\n", sb->md_minor, sb->md_minor);
        if (stat(cfg->md_name,&stat_buf)) {
                fprintf(stderr, "%s: file doesn't exist!\n", cfg->md_name);
                return 1;
        }
	sb->md_minor = minor(stat_buf.st_rdev);
	cfg->array.param.md_minor = sb->md_minor;

	printf("changed preferred minor to %d (md%d)\n", sb->md_minor, sb->md_minor);

	if (fstat(fd, &stat_buf) == -1) {
		fprintf(stderr, "couldn't call stat() disk\n");
		return 1;
	}
	/*
	 * check wether the major/minor number of devices has
	 * changed since the array has been created ...
	 */
	for (i = 0; i < sb->nr_disks; i++) {

		if (sb->this_disk.number == cfg->array.disks[i].number)
			break;
	}
	if (i == sb->nr_disks) {
		fprintf(stderr, "weird superblock ...\n");
		return 1;
	}

	if ( (cfg->array.disks[i].major != major(stat_buf.st_rdev))
		|| (cfg->array.disks[i].minor != minor(stat_buf.st_rdev)))
	{
		fprintf(stderr, "strange superblock, order of disks mixed up?...\n");
		return 1;
	}
	sb->this_disk.major = cfg->array.disks[i].major;
	sb->this_disk.minor = cfg->array.disks[i].minor;

	for (i = 0; i < sb->nr_disks; i++) {
		disk = sb->disks + i;
		
		if (verbose) 
			fprintf(stderr, "upgrading RAID disk %d: major %d, minor %d, raid_disk %d\n", disk->number, disk->major, disk->minor, disk->raid_disk);
		disk->major = cfg->array.disks[i].major;
		disk->minor = cfg->array.disks[i].minor;
		if (verbose) 
			fprintf(stderr, "    => to major %d, minor %d, raid_disk %d\n", disk->major, disk->minor, disk->raid_disk);
	}

	if (!sb->chunk_size) {
		sb->chunk_size = cfg->array.param.chunk_size;
		printf("changed chunksize to %d\n", sb->chunk_size);
	}

	return 0;
}

void print_sb (mdp_super_t *sb)
{
	time_t t;
	mdp_disk_t *disk;
	int i;

	printf("MD ID:                   %x\n", sb->md_magic);
	printf("Conforms to MD version:  %d.%d.%d\n", sb->major_version,
					 sb->minor_version, sb->patch_version);
	if ((sb->major_version > 0) || (sb->minor_version >= 50))
		printf("preferred minor           %d (md%d)\n", sb->md_minor,
						 sb->md_minor);

	printf("gvalid_words:            %d\n", sb->gvalid_words);
	printf("Raid set ID:             %x\n", sb->set_uuid0);
	t = (time_t) sb->ctime;
	printf("Creation time:           %s", ctime(&t));
	t = (time_t) sb->utime;
	printf("Update time:             %s", ctime(&t));
	printf("State:                   %d%s\n", sb->state, sb->state &
					 (1 << MD_SB_CLEAN) ? " (clean)" : "");
	printf("Raid level:              %d\n", sb->level);
	printf("Individual disk size:    %uMB (%ukB)\n", sb->size /
					 MD_BLK_SIZ, sb->size);
	if (sb->level == 4 || sb->level == 5)
		printf("Chunk size:              %dkB\n", sb->chunk_size / MD_BLK_SIZ);
	i = sb->layout;
	if (sb->level == 5)
		printf("Parity algorithm:        %d (%s)\n", i, i < 4 ? parity_algorithm_table[i] : "unknown");
	printf("Total number of disks:   %d\n", sb->nr_disks);
	printf("Number of raid disks:    %d\n", sb->raid_disks);
	printf("Number of active disks:  %d\n", sb->active_disks);
	printf("Number of working disks: %d\n", sb->working_disks);
	printf("Number of failed disks:  %d\n", sb->failed_disks);
	printf("Number of spare disks:   %d\n", sb->spare_disks);
	printf("\n");

	for (i = 0; i < sb->nr_disks; i++) {
		disk = sb->disks + i;
#if 1
		printf("Disk %d: major %d, minor %d, raid_disk %d, ", disk->number
			, disk->major, disk->minor, disk->raid_disk);
#else
		printf("Disk %d: raid_disk %d, ", disk->number, disk->raid_disk);
#endif
		printf("state: %d (%s, %s, %s)\n", disk->state,
		disk->state & (1 << MD_DISK_FAULTY) ? "faulty" : "operational",
		disk->state & (1 << MD_DISK_ACTIVE) ? "active" : "not active",
		disk->state & (1 << MD_DISK_SYNC) ? "sync" : "not in sync");
	}
}

static int sanity_checks (char *name, int fd, int sb_offset,
	 int forceSanity, int upgradeArray, md_cfg_entry_t * cfg, int dowrite)
{
	FILE *fp;
	unsigned char tmp[MAX_LINE_LENGTH];
	unsigned char buffer[MD_SB_BYTES];
	mdp_super_t *phys_sb;