/*
   raid0.c : Multiple Devices driver for Linux
             Copyright (C) 1994-96 Marc ZYNGIER
	     <zyngier@ufr-info-p7.ibp.fr> or
	     <maz@gloups.fdn.fr>
             Copyright (C) 1999, 2000 Ingo Molnar, Red Hat


   RAID-0 management functions.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
   
   You should have received a copy of the GNU General Public License
   (for example /usr/src/linux/COPYING); if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
*/

#include <linux/module.h>
#include <linux/evms/evms_raid0.h>

#define MAJOR_NR MD_MAJOR
#define MD_DRIVER
#define MD_PERSONALITY

#define LOG_PREFIX "md raid0: "

static int create_strip_zones (mddev_t *mddev)
{
	int i, c, j, j1, j2;
	unsigned long current_offset, curr_zone_offset, rdev_size_in_sects;
	raid0_conf_t *conf = mddev_to_conf(mddev);
	mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev;
 
	/*
	 * The number of 'same size groups'
	 */
	conf->nr_strip_zones = 0;
 
	ITERATE_RDEV_ORDERED(mddev,rdev1,j1) {
		LOG_DEBUG(" looking at %s\n", evms_md_partition_name(rdev1->node));
		c = 0;
		ITERATE_RDEV_ORDERED(mddev,rdev2,j2) {
			LOG_DEBUG("   comparing %s(%ld sectors) with %s(%ld sectors)\n",
				   evms_md_partition_name(rdev1->node), rdev1->size << 1, 
				   evms_md_partition_name(rdev2->node), rdev2->size << 1);
			if (rdev2 == rdev1) {
				LOG_DEBUG("   END\n");
				break;
			}
			if (rdev2->size == rdev1->size)
			{
				/*
				 * Not unique, dont count it as a new
				 * group
				 */
				LOG_DEBUG("   EQUAL\n");
				c = 1;
				break;
			}
			LOG_DEBUG("   NOT EQUAL\n");
		}
		if (!c) {
			LOG_DEBUG("   ==> UNIQUE\n");
			conf->nr_strip_zones++;
			LOG_DEBUG(" %d zones\n",conf->nr_strip_zones);
		}
	}
	LOG_DEBUG(" FINAL %d zones\n",conf->nr_strip_zones);

	conf->strip_zone = vmalloc(sizeof(struct strip_zone)*
				conf->nr_strip_zones);
	if (!conf->strip_zone)
		return 1;


	conf->smallest = NULL;
	current_offset = 0;
	curr_zone_offset = 0;

	for (i = 0; i < conf->nr_strip_zones; i++)
	{
		struct strip_zone *zone = conf->strip_zone + i;

		LOG_DEBUG(" zone %d\n", i);
		zone->dev_offset = current_offset;
		smallest = NULL;
		c = 0;

		ITERATE_RDEV_ORDERED(mddev,rdev,j) {

			LOG_DEBUG(" checking %s ...",evms_md_partition_name(rdev->node));
			rdev_size_in_sects = rdev->size << 1;
			if (rdev_size_in_sects > current_offset)
			{
				LOG_DEBUG(" contained as device %d\n", c);
				zone->node[c] = rdev->node;
				c++;
				if (!smallest || (rdev_size_in_sects < (smallest->size <<1) )) {
					smallest = rdev;
					LOG_DEBUG("  (%ld) is smallest!.\n", rdev_size_in_sects);
				}
			} else
				LOG_DEBUG(" nope.\n");
		}

		zone->nb_dev = c;
		zone->size_in_sects = ((smallest->size <<1) - current_offset) * c;
		LOG_DEBUG(" zone->nb_dev: %d, size: %ld\n",
			zone->nb_dev,zone->size_in_sects);

		if (!conf->smallest || (zone->size_in_sects < conf->smallest->size_in_sects))
			conf->smallest = zone;

		zone->zone_offset = curr_zone_offset;
		curr_zone_offset += zone->size_in_sects;

		current_offset = smallest->size << 1;
		LOG_DEBUG(" current zone offset: %ld\n",current_offset);
	}
	LOG_DEBUG(" done.\n");
	return 0;
}

static int raid0_run (mddev_t *mddev)
{
	unsigned long cur=0, i=0, size, zone0_size, nb_zone;
	unsigned long mddev_size_in_sects = evms_md_size[mdidx(mddev)] << 1;
	raid0_conf_t *conf;

	MOD_INC_USE_COUNT;

	conf = vmalloc(sizeof (raid0_conf_t));
	if (!conf)
		goto out;
	mddev->private = (void *)conf;
 
	if (evms_md_check_ordering(mddev)) {
		LOG_ERROR("disks are not ordered, aborting!\n");
		goto out_free_conf;
	}

	if (create_strip_zones (mddev)) 
		goto out_free_conf;

	LOG_DETAILS("evms_md_size is %ld sectors.\n", mddev_size_in_sects);
	LOG_DETAILS("conf->smallest->size_in_sects is %ld sectors.\n", conf->smallest->size_in_sects);
	nb_zone = mddev_size_in_sects / conf->smallest->size_in_sects +
			(mddev_size_in_sects % conf->smallest->size_in_sects ? 1 : 0);
	LOG_DETAILS("nb_zone is %ld.\n", nb_zone);
	conf->nr_zones = nb_zone;

	LOG_DEBUG("Allocating %ld bytes for hash.\n", nb_zone*sizeof(struct raid0_hash));

	conf->hash_table = vmalloc (sizeof (struct raid0_hash)*nb_zone);
	if (!conf->hash_table)
		goto out_free_zone_conf;
	size = conf->strip_zone[cur].size_in_sects;

	i = 0;
	while (cur < conf->nr_strip_zones) {
		conf->hash_table[i].zone0 = conf->strip_zone + cur;

		/*
		 * If we completely fill the slot
		 */
		if (size >= conf->smallest->size_in_sects) {
			conf->hash_table[i++].zone1 = NULL;
			size -= conf->smallest->size_in_sects;

			if (!size) {
				if (++cur == conf->nr_strip_zones)
					continue;
				size = conf->strip_zone[cur].size_in_sects;
			}
			continue;
		}
		if (++cur == conf->nr_strip_zones) {
			/*
			 * Last dev, set unit1 as NULL
			 */
			conf->hash_table[i].zone1=NULL;
			continue;
		}

		/*
		 * Here we use a 2nd dev to fill the slot
		 */
		zone0_size = size;
		size = conf->strip_zone[cur].size_in_sects;
		conf->hash_table[i++].zone1 = conf->strip_zone + cur;
		size -= (conf->smallest->size_in_sects - zone0_size);
	}
	return 0;

out_free_zone_conf:
	vfree(conf->strip_zone);
	conf->strip_zone = NULL;

out_free_conf:
	vfree(conf);
	mddev->private = NULL;
out:
	MOD_DEC_USE_COUNT;
	return 1;
}

static int raid0_stop (mddev_t *mddev)
{
	raid0_conf_t *conf = mddev_to_conf(mddev);

	vfree (conf->hash_table);
	conf->hash_table = NULL;
	vfree (conf->strip_zone);
	conf->strip_zone = NULL;
	vfree (conf);
	mddev->private = NULL;

	MOD_DEC_USE_COUNT;
	return 0;
}


/*
 * Function: raid0_map
 *
 *	Return 0 for success, else error
 *
 */

static inline int raid0_map(
	mddev_t *mddev, 
	unsigned long lsn,
	unsigned long size,
	struct evms_logical_node **node, 
	unsigned long *new_lsn,
	unsigned long *new_size)
{
	unsigned int sect_in_chunk, chunksize_bits, chunk_size_in_sects;
	raid0_conf_t *conf = mddev_to_conf(mddev);
	struct raid0_hash *hash;
	struct strip_zone *zone;
	unsigned long chunk;

	chunk_size_in_sects = mddev->chunk_size >> EVMS_VSECTOR_SIZE_SHIFT;
	chunksize_bits = ffz(~chunk_size_in_sects);
	hash = conf->hash_table + (lsn / conf->smallest->size_in_sects);

	/* Sanity check */
	if (!hash)
		goto bad_hash;

	if (!hash->zone0)
		goto bad_zone0;
 
	if (lsn >= (hash->zone0->size_in_sects + hash->zone0->zone_offset)) {
		if (!hash->zone1)
			goto bad_zone1;
		zone = hash->zone1;
	} else
		zone = hash->zone0;
    
	sect_in_chunk = lsn & (chunk_size_in_sects - 1);
	chunk = (lsn - zone->zone_offset) / (zone->nb_dev << chunksize_bits);
	*node = zone->node[(lsn >> chunksize_bits) % zone->nb_dev];

	*new_lsn = ((chunk << chunksize_bits) + zone->dev_offset) + sect_in_chunk;

	*new_size = (size <= chunk_size_in_sects - sect_in_chunk) ? 
		size : chunk_size_in_sects - sect_in_chunk;

	return 0;

bad_hash:
	LOG_ERROR("%s: bug: hash==NULL for lsn %lu\n", __FUNCTION__, lsn);
	goto outerr;
bad_zone0:
	LOG_ERROR("%s: bug: hash->zone0==NULL for lsn %lu\n", __FUNCTION__, lsn);
	goto outerr;
bad_zone1:
	LOG_ERROR("%s: bug: hash->zone1==NULL for lsn %lu\n", __FUNCTION__, lsn);
outerr:
	return -EINVAL;
}

void raid0_error(int rw, struct evms_logical_node *node, struct buffer_head *bh)
{
	LOG_ERROR(" %s FAILED on node(%s) rsector(%lu) size(%d)\n",
		(rw == READ) ? "READ" : "WRITE",
		node->name,
		bh->b_rsector,
		bh->b_size);

	bh->b_end_io(bh, 0);
}

static inline void raid0_rw (
	struct evms_logical_node *md_node,
	struct buffer_head *bh,
	int rw)
{
	mddev_t *mddev = EVMS_MD_NODE_TO_MDDEV(md_node);
	struct evms_logical_node *node;
	unsigned long new_lsn, size_in_sects, new_size;

	if (evms_md_check_boundary(md_node, bh)) return;
	size_in_sects = bh->b_size >> EVMS_VSECTOR_SIZE_SHIFT;
	if (!raid0_map(mddev, bh->b_rsector, size_in_sects, &node, &new_lsn, &new_size)) {
		if (new_size == size_in_sects) {
			/*
			 * This is the normal case:
			 * the request is entirely within the stripe boundary
			 */
			bh->b_rsector = new_lsn;
			if (rw == READ) {
				R_IO(node, bh);
			} else {
				W_IO(node, bh);
			}
			return;
		} else {
			/*
			 * BUGBUG!
			 * Need more processing here (ie. break up the request)
			 */
			LOG_ERROR("This version of EVMS RAID0 does not support I/O requests that are:\n");
			LOG_ERROR(" - larger than the stripe size\n");
			LOG_ERROR(" - cross the stripe boundary\n");
		}
	}
	raid0_error(rw, node, bh);
}

static void raid0_read(
	struct evms_logical_node *md_node,
	struct buffer_head *bh)
{
	raid0_rw(md_node, bh, READ);
}

static void raid0_write(
	struct evms_logical_node *md_node,
	struct buffer_head *bh)
{
	raid0_rw(md_node, bh, WRITE);
}
			   
static int raid0_status (char *page, mddev_t *mddev)
{
	int sz = 0;
#undef MD_DEBUG
#ifdef MD_DEBUG
	int j, k;
	raid0_conf_t *conf = mddev_to_conf(mddev);
  
	sz += sprintf(page + sz, "      ");
	for (j = 0; j < conf->nr_zones; j++) {
		sz += sprintf(page + sz, "[z%d",
				conf->hash_table[j].zone0 - conf->strip_zone);
		if (conf->hash_table[j].zone1)
			sz += sprintf(page+sz, "/z%d] ",
				conf->hash_table[j].zone1 - conf->strip_zone);
		else
			sz += sprintf(page+sz, "] ");
	}
  
	sz += sprintf(page + sz, "\n");
  
	for (j = 0; j < conf->nr_strip_zones; j++) {
		sz += sprintf(page + sz, "      z%d=[", j);
		for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
			sz += sprintf (page+sz, "%s/", conf->strip_zone[j].node[k]->name);
		sz--;
		sz += sprintf (page+sz, "] zo=%d do=%d s=%d\n",
				conf->strip_zone[j].zone_offset,
				conf->strip_zone[j].dev_offset,
				conf->strip_zone[j].size_in_sects);
	}
#endif
	sz += sprintf(page + sz, " %dk chunks", mddev->chunk_size/1024);
	return sz;
}

static int raid0_evms_ioctl (
	mddev_t 	* mddev,
	struct inode 	* inode,
	struct file 	* file, 
	unsigned int 	cmd,
	unsigned long 	arg)
{
	int rc = 0;
	struct evms_logical_node *node;

	switch (cmd) {
		case EVMS_GET_BMAP:
		{
			struct evms_get_bmap_pkt *bmap = (struct evms_get_bmap_pkt *)arg;
			unsigned long new_lsn, new_size;
			unsigned long size = mddev->node->block_size >> EVMS_VSECTOR_SIZE_SHIFT;
			rc = raid0_map(mddev,
				       (unsigned long)bmap->rsector,
				       size,
				       &node,
				       &new_lsn,
				       &new_size);
			if (!rc) {
				if (node) {
					bmap->rsector = (u64)new_lsn;
					rc = IOCTL(node, inode, file, cmd, arg);
				} else
					rc = -ENODEV;
			}
			break;
		}

		default:
			rc = -EINVAL;
	}
	return rc;
}

static mdk_personality_t raid0_personality = {
	.name		= "evms_raid0",
	.read		= raid0_read,
	.write		= raid0_write,
	.run		= raid0_run,
	.stop		= raid0_stop,
	.status		= raid0_status,
	.evms_ioctl	= raid0_evms_ioctl
};

static int md__init raid0_init (void)
{
	return evms_register_md_personality (RAID0, &raid0_personality);
}

static void raid0_exit (void)
{
	evms_unregister_md_personality (RAID0);
}

module_init(raid0_init);
module_exit(raid0_exit);
#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
