raid_io.c.ia64

create raid tool at linux

	/*
	 * Check if the device is mounted
	 */
	fp = fopen("/etc/mtab", "r");
	if (fp != NULL) {
		while (1) {
			if ((fgets(tmp, MAX_LINE_LENGTH, fp)) == NULL)
				break;
			if (strstr(tmp, name)) {
				fprintf(stderr, "%s is mounted\n", name);
				fclose(fp);
				return 1;
			}
		}
	}
	fclose(fp);

	if (!upgradeArray) {
		if (forceSanity)
			return 0;
		if (cfg->array.param.not_persistent)
			/*
			 * We have no business analyzing the contents
			 * of a superblock-less array.
			 */
			return 0;
		/*
		 * Check if the device contains an ext2 filesystem
		 */
		if ((raidseek(fd, 1)) == -1)
			return 1;
		if ((read(fd, buffer, MD_BLK_SIZ)) != MD_BLK_SIZ)
			return 1;
		if (buffer[56] == 0x53 && buffer[57] == 0xef && buffer[33] == 0x20 && buffer[37] == 0x20) {
			fprintf(stderr, "%s appears to contain an ext2 filesystem -- use -f to override\n", name);
			return 1;
		}
		if (raidseek(fd, sb_offset) == -1)
			return 1;
		if ((read(fd, buffer, MD_SB_BYTES)) != MD_SB_BYTES)
			return 1;
		phys_sb = (mdp_super_t *) buffer;
		if (phys_sb->md_magic == MD_SB_MAGIC) {
			fprintf(stderr, "%s appears to be already part of a raid array -- use -f to\nforce the destruction of the old superblock\n", name);
			return 1;
		}
		return 0;
	}

	/*
	 * Check if we can convert the array to a new version
	 */

	if (raidseek(fd, sb_offset) == -1)
		return 1;
	if ((read(fd, buffer, MD_SB_BYTES)) != MD_SB_BYTES)
		return 1;
	phys_sb = (mdp_super_t *) buffer;
	if (phys_sb->md_magic == MD_SB_MAGIC) {
		if (dowrite) {
			fprintf(stderr, "upgrading superblock on %s ...\n",
					 name);
			fprintf(stderr, "old superblock:\n");
			print_sb(phys_sb);
		}
		if (upgrade_sb(fd, phys_sb, cfg, dowrite))
			return 1;
		if (dowrite) {
			fprintf(stderr, "new superblock:\n");
			print_sb(phys_sb);
			if (raidseek(fd, sb_offset) == -1)
				return 1;
			if ((write(fd, buffer, MD_SB_BYTES)) != MD_SB_BYTES) {
				fprintf(stderr, "could not write new superblock!\n");
				return 1;
			}
			printf("sb->minor after write: %d\n", phys_sb->minor_version);
			fsync(fd);
		}
		return 0;
	}
	fprintf(stderr, "cannot upgrade magic-less superblock on %s ...\n",
									 name);
	return 1;
}

int analyze_sb (mdu_version_t * ver, enum mkraidFunc func,
		md_cfg_entry_t * cfg, int forceSanity,
		int upgradeArray, int Resync)
{
	int fd, i, j;
	md_raid_info_t *array;
	mdu_disk_info_t *disk;
	struct stat stat_buf;
	md_u32 nr_blocks;

	if (!cfg)
		return 1;

	if (stat(cfg->md_name,&stat_buf)) {
		fprintf(stderr, "%s: file doesn't exist!\n", cfg->md_name);
		return 1;
	}

	if (major(stat_buf.st_rdev) != MD_MAJOR) {
		fprintf(stderr, "%s: not an MD device!\n", cfg->md_name);
		return 1;
	}

	printf("handling MD device %s\n", cfg->md_name);
	printf("analyzing super-block\n");
	array = &cfg->array;

	array->param.major_version = MKRAID_MAJOR_VERSION;
	array->param.minor_version = MKRAID_MINOR_VERSION;
	array->param.patch_version = MKRAID_PATCHLEVEL_VERSION;

	cfg->array.param.md_minor = minor(stat_buf.st_rdev);

	array->param.ctime = array->param.utime = (md_u32) time(NULL);
	if (Resync)
		array->param.state = 0;
	else
		array->param.state = 1 << MD_SB_CLEAN;

	array->param.working_disks = array->param.nr_disks-array->param.failed_disks;
	array->param.active_disks = array->param.raid_disks-array->param.failed_disks;
	if (array->param.raid_disks + array->param.spare_disks
						!= array->param.nr_disks) {
		fprintf(stderr, "raid_disks + spare_disks != nr_disks\n");
		return 1;
	}
	if ((array->param.level==4 || array->param.level==5) && array->param.failed_disks > 1) {
		fprintf(stderr, "raid level %d can't have more than 1 failed disk\n",array->param.level);
		return 1;
	}
	for (i = 0; i < array->param.nr_disks; i++) {
		disk = array->disks + i;
		disk->number = i;

		if ((disk->state & (1 << MD_DISK_FAULTY))==0) {
			if (stat(cfg->device_name[i], &stat_buf) == -1) {
				fprintf(stderr, "couldn't call stat() on device %s -- %s\n", cfg->device_name[i], strerror(errno));
				return 1;
			}
			disk->major = major(stat_buf.st_rdev);
			disk->minor = minor(stat_buf.st_rdev);
		} else {
			disk->major = 0;
			disk->minor = 0;
		}
		if (disk->raid_disk >= array->param.nr_disks) {
			fprintf(stderr, "raid_disk for %s (%d) > nr_disks (%d)\n", cfg->device_name[i], disk->raid_disk, array->param.nr_disks);
			return 1;
		}
		for (j = 0; j < i; j++)
			if (array->disks[j].raid_disk == disk->raid_disk) {
				fprintf(stderr, "raid_disk conflict on %s and %s (%d)\n", cfg->device_name[j], cfg->device_name[i], disk->raid_disk);
				return 1;
			}
		if ((disk->raid_disk < array->param.raid_disks) && !(disk->state & (1<<MD_DISK_FAULTY)))
			disk->state = (1 << MD_DISK_ACTIVE | 1 << MD_DISK_SYNC);
		if ((array->param.level == 0 || array->param.level == 1 || array->param.level == 4 || array->param.level == 5) && (!array->param.chunk_size || array->param.chunk_size % 4)) {
			fprintf(stderr, "invalid chunk-size (%dkB)\n", array->param.chunk_size);
			return 1;
		}
	}
	/*
	 * first pass, check them all
	 */
	for (i = 0; i < array->param.nr_disks; i++) {
		disk = array->disks + i;
		if ((disk->state & (1 << MD_DISK_FAULTY))==0) {
			fd = open(cfg->device_name[i], O_RDWR);
			if (fd == -1) {
				fprintf(stderr, "couldn't open device %s -- %s\n", cfg->device_name[i], strerror(errno));
				return 1;
			}
			if (ioctl(fd, BLKGETSIZE, (unsigned long)&nr_blocks) == -1) {
				fprintf(stderr, "couldn't get device size for %s -- %s\n", cfg->device_name[i], strerror(errno));
				close(fd);
				return 1;
			}
			nr_blocks >>= 1;
			if (nr_blocks < MD_RESERVED_BLOCKS * 2) {
				fprintf(stderr, "%s: device too small (%dkB)\n", cfg->device_name[i], nr_blocks);
				close(fd);
				return 1;
			}

                	cfg->sb_block_offset[i] = MD_NEW_SIZE_BLOCKS(nr_blocks);
			if (!cfg->array.param.not_persistent) {
                		printf("disk %d: %s, %ukB, raid superblock at %dkB\n", i, cfg->device_name[i], nr_blocks, cfg->sb_block_offset[i]);
	                	if (sanity_checks(cfg->device_name[i], fd,
					 	cfg->sb_block_offset[i], forceSanity,
					 	upgradeArray, cfg, 0)) {
					close(fd);
					return 1;
				}
			}
			close(fd);
		} else {
			printf("disk %d: %s, failed\n", i, cfg->device_name[i]);
		}
	}
	/*	
	 * second pass, write stuff out ...
	 */
	for (i = 0; i < array->param.nr_disks; i++) {
		disk = array->disks + i;
		if ((disk->state & (1 << MD_DISK_FAULTY))==0) {
			if (upgradeArray)
				fd = open(cfg->device_name[i], O_RDWR);
			else
				fd = open(cfg->device_name[i], O_RDONLY);
			if (fd == -1) {
				fprintf(stderr, "couldn't open device %s -- %s\n", cfg->device_name[i], strerror(errno));
				return 1;
			}
			if (ioctl(fd, BLKGETSIZE, (unsigned long)&nr_blocks) == -1) {
				fprintf(stderr, "couldn't get device size for %s -- %s\n", cfg->device_name[i], strerror(errno));
				close(fd);
				return 1;
			}
			nr_blocks >>= 1;
			if (nr_blocks < MD_RESERVED_BLOCKS * 2) {
				fprintf(stderr, "%s: device too small (%dkB)\n", cfg->device_name[i], nr_blocks);
				close(fd);
				return 1;
			}

                	cfg->sb_block_offset[i] = MD_NEW_SIZE_BLOCKS(nr_blocks);
                	if (sanity_checks(cfg->device_name[i], fd,
				 	cfg->sb_block_offset[i], forceSanity,
				 	upgradeArray, cfg, 1)) {
				close(fd);
				return 1;
			}
			close(fd);
		}
	}

	return 0;
}


int check_active (md_cfg_entry_t *p)
{
	char buffer[MAX_LINE_LENGTH], line[MAX_LINE_LENGTH], *ch;
	FILE *fp;

	if ((ch = strstr(p->md_name, "/md")) == NULL)
		return 0;
	strcpy(buffer, ch+1);
	if ((fp = fopen("/proc/mdstat", "r")) == NULL)
		return 0;
	while (1) {
		if ((fgets(line, MAX_LINE_LENGTH, fp)) == NULL)
			break;
		if (strstr(line, buffer) && !strstr(line, "inactive")) {
			fprintf(stderr, "%s: active -- run raidstop\n", p->md_name);
			fclose(fp);
			return 1;
		}
	}
	fclose(fp);
	return 0;
}