[PATCH] md: optimised resync using Bitmap based intent logging

dm-multipath-objs := dm-hw-handler.o dm-path-selector.o dm-mpath.o

dm-snapshot-objs := dm-snap.o dm-exception-store.o

dm-mirror-objs	:= dm-log.o dm-raid1.o

md-mod-objs     := md.o bitmap.o

raid6-objs	:= raid6main.o raid6algos.o raid6recov.o raid6tables.o \

		   raid6int1.o raid6int2.o raid6int4.o \

		   raid6int8.o raid6int16.o raid6int32.o \

obj-$(CONFIG_MD_RAID6)		+= raid6.o xor.o

obj-$(CONFIG_MD_MULTIPATH)	+= multipath.o

obj-$(CONFIG_MD_FAULTY)		+= faulty.o

obj-$(CONFIG_BLK_DEV_MD)	+= md.o

obj-$(CONFIG_BLK_DEV_MD)	+= md-mod.o

obj-$(CONFIG_BLK_DEV_DM)	+= dm-mod.o

obj-$(CONFIG_DM_CRYPT)		+= dm-crypt.o

obj-$(CONFIG_DM_MULTIPATH)	+= dm-multipath.o dm-round-robin.o

     Neil Brown <neilb@cse.unsw.edu.au>.

   - persistent bitmap code

     Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.

   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)

#include <linux/config.h>

#include <linux/linkage.h>

#include <linux/raid/md.h>

#include <linux/raid/bitmap.h>

#include <linux/sysctl.h>

#include <linux/devfs_fs_kernel.h>

#include <linux/buffer_head.h> /* for invalidate_bdev */

#include <linux/init.h>

#include <linux/file.h>

#ifdef CONFIG_KMOD

#include <linux/kmod.h>

#endif

	printk("md:	* <COMPLETE RAID STATE PRINTOUT> *\n");

	printk("md:	**********************************\n");

	ITERATE_MDDEV(mddev,tmp) {

		printk("%s: ", mdname(mddev));

		if (mddev->bitmap)

			bitmap_print_sb(mddev->bitmap);

		else

			printk("%s: ", mdname(mddev));

		ITERATE_RDEV(mddev,rdev,tmp2)

			printk("<%s>", bdevname(rdev->bdev,b));

		printk("\n");

		"md: updating %s RAID superblock on device (in sync %d)\n",

		mdname(mddev),mddev->in_sync);

	err = 0;

	err = bitmap_update_sb(mddev->bitmap);

	ITERATE_RDEV(mddev,rdev,tmp) {

		char b[BDEVNAME_SIZE];

		dprintk(KERN_INFO "md: ");

	mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */

	/* before we start the array running, initialise the bitmap */

	err = bitmap_create(mddev);

	if (err)

		printk(KERN_ERR "%s: failed to create bitmap (%d)\n",

			mdname(mddev), err);

	else

		err = mddev->pers->run(mddev);

	if (err) {

		printk(KERN_ERR "md: pers->run() failed ...\n");

		module_put(mddev->pers->owner);

		mddev->pers = NULL;

		return -EINVAL;

		bitmap_destroy(mddev);

		return err;

	}

 	atomic_set(&mddev->writes_pending,0);

	mddev->safemode = 0;

		if (ro)

			set_disk_ro(disk, 1);

	}

	bitmap_destroy(mddev);

	if (mddev->bitmap_file) {

		atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);

		fput(mddev->bitmap_file);

		mddev->bitmap_file = NULL;

	}

	/*

	 * Free resources if final stop

	 */

	return 0;

}

static int get_bitmap_file(mddev_t * mddev, void * arg)

{

	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */

	char *ptr, *buf = NULL;

	int err = -ENOMEM;

	file = kmalloc(sizeof(*file), GFP_KERNEL);

	if (!file)

		goto out;

	/* bitmap disabled, zero the first byte and copy out */

	if (!mddev->bitmap || !mddev->bitmap->file) {

		file->pathname[0] = '\0';

		goto copy_out;

	}

	buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);

	if (!buf)

		goto out;

	ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));

	if (!ptr)

		goto out;

	strcpy(file->pathname, ptr);

copy_out:

	err = 0;

	if (copy_to_user(arg, file, sizeof(*file)))

		err = -EFAULT;

out:

	kfree(buf);

	kfree(file);

	return err;

}

static int get_disk_info(mddev_t * mddev, void __user * arg)

{

	mdu_disk_info_t info;

	return err;

}

/* similar to deny_write_access, but accounts for our holding a reference

 * to the file ourselves */

static int deny_bitmap_write_access(struct file * file)

{

	struct inode *inode = file->f_mapping->host;

	spin_lock(&inode->i_lock);

	if (atomic_read(&inode->i_writecount) > 1) {

		spin_unlock(&inode->i_lock);

		return -ETXTBSY;

	}

	atomic_set(&inode->i_writecount, -1);

	spin_unlock(&inode->i_lock);

	return 0;

}

static int set_bitmap_file(mddev_t *mddev, int fd)

{

	int err;

	if (mddev->pers)

		return -EBUSY;

	mddev->bitmap_file = fget(fd);

	if (mddev->bitmap_file == NULL) {

		printk(KERN_ERR "%s: error: failed to get bitmap file\n",

			mdname(mddev));

		return -EBADF;

	}

	err = deny_bitmap_write_access(mddev->bitmap_file);

	if (err) {

		printk(KERN_ERR "%s: error: bitmap file is already in use\n",

			mdname(mddev));

		fput(mddev->bitmap_file);

		mddev->bitmap_file = NULL;

	}

	return err;

}

/*

 * set_array_info is used two different ways

 * The original usage is when creating a new array.

	/*

	 * Commands querying/configuring an existing array:

	 */

	/* if we are initialised yet, only ADD_NEW_DISK or STOP_ARRAY is allowed */

	if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY && cmd != RUN_ARRAY) {

	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,

	 * RUN_ARRAY, and SET_BITMAP_FILE are allowed */

	if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY

			&& cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {

		err = -ENODEV;

		goto abort_unlock;

	}

			err = get_array_info(mddev, argp);

			goto done_unlock;

		case GET_BITMAP_FILE:

			err = get_bitmap_file(mddev, (void *)arg);

			goto done_unlock;

		case GET_DISK_INFO:

			err = get_disk_info(mddev, argp);

			goto done_unlock;

			err = do_md_run (mddev);

			goto done_unlock;

		case SET_BITMAP_FILE:

			err = set_bitmap_file(mddev, (int)arg);

			goto done_unlock;

		default:

			if (_IOC_TYPE(cmd) == MD_MAJOR)

				printk(KERN_WARNING "md: %s(pid %d) used"

	while (thread->run) {

		void (*run)(mddev_t *);

		wait_event_interruptible(thread->wqueue,

					 test_bit(THREAD_WAKEUP, &thread->flags));

		wait_event_interruptible_timeout(thread->wqueue,

						 test_bit(THREAD_WAKEUP, &thread->flags),

						 thread->timeout);

		if (current->flags & PF_FREEZE)

			refrigerator(PF_FREEZE);

	thread->run = run;

	thread->mddev = mddev;

	thread->name = name;

	thread->timeout = MAX_SCHEDULE_TIMEOUT;

	ret = kernel_thread(md_thread, thread, 0);

	if (ret < 0) {

		kfree(thread);

	if (!rdev || rdev->faulty)

		return;

/*

	dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",

		mdname(mddev),

		MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),

		__builtin_return_address(0),__builtin_return_address(1),

		__builtin_return_address(2),__builtin_return_address(3));

*/

	if (!mddev->pers->error_handler)

		return;

	mddev->pers->error_handler(mddev,rdev);

	struct list_head *tmp2;

	mdk_rdev_t *rdev;

	int i;

	struct bitmap *bitmap;

	if (v == (void*)1) {

		seq_printf(seq, "Personalities : ");

		if (mddev->pers) {

			mddev->pers->status (seq, mddev);

	 		seq_printf(seq, "\n      ");

			if (mddev->curr_resync > 2)

			if (mddev->curr_resync > 2) {

				status_resync (seq, mddev);

			else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)

				seq_printf(seq, "	resync=DELAYED");

				seq_printf(seq, "\n      ");

			} else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)

				seq_printf(seq, "	resync=DELAYED\n      ");

		} else

			seq_printf(seq, "\n       ");

		if ((bitmap = mddev->bitmap)) {

			char *buf, *path;

			unsigned long chunk_kb;

			unsigned long flags;

			buf = kmalloc(PAGE_SIZE, GFP_KERNEL);

			spin_lock_irqsave(&bitmap->lock, flags);

			chunk_kb = bitmap->chunksize >> 10;

			seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "

				"%lu%s chunk",

				bitmap->pages - bitmap->missing_pages,

				bitmap->pages,

				(bitmap->pages - bitmap->missing_pages)

					<< (PAGE_SHIFT - 10),

				chunk_kb ? chunk_kb : bitmap->chunksize,

				chunk_kb ? "KB" : "B");

			if (bitmap->file && buf) {

				path = file_path(bitmap->file, buf, PAGE_SIZE);

				seq_printf(seq, ", file: %s", path ? path : "");

			}

			seq_printf(seq, "\n");

			spin_unlock_irqrestore(&bitmap->lock, flags);

			kfree(buf);

		}

		seq_printf(seq, "\n");

	       sysctl_speed_limit_max);

	is_mddev_idle(mddev); /* this also initializes IO event counters */

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))

	/* we don't use the checkpoint if there's a bitmap */

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !mddev->bitmap)

		j = mddev->recovery_cp;

	else

		j = 0;

			" MD_SB_DISKS=%d\n",

			MD_MAJOR_VERSION, MD_MINOR_VERSION,

			MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);

	printk(KERN_INFO "md: bitmap version %d.%d\n", BITMAP_MAJOR,

			BITMAP_MINOR);

	if (register_blkdev(MAJOR_NR, "md"))

		return -1;

/*

 * bitmap.h: Copyright (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003

 *

 * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.

 */

#ifndef BITMAP_H

#define BITMAP_H 1

#define BITMAP_MAJOR 3

#define BITMAP_MINOR 38

/*

 * in-memory bitmap:

 *

 * Use 16 bit block counters to track pending writes to each "chunk".

 * The 2 high order bits are special-purpose, the first is a flag indicating

 * whether a resync is needed.  The second is a flag indicating whether a

 * resync is active.

 * This means that the counter is actually 14 bits:

 *

 * +--------+--------+------------------------------------------------+

 * | resync | resync |               counter                          |

 * | needed | active |                                                |

 * |  (0-1) |  (0-1) |              (0-16383)                         |

 * +--------+--------+------------------------------------------------+

 *

 * The "resync needed" bit is set when:

 *    a '1' bit is read from storage at startup.

 *    a write request fails on some drives

 *    a resync is aborted on a chunk with 'resync active' set

 * It is cleared (and resync-active set) when a resync starts across all drives

 * of the chunk.

 *

 *

 * The "resync active" bit is set when:

 *    a resync is started on all drives, and resync_needed is set.

 *       resync_needed will be cleared (as long as resync_active wasn't already set).

 * It is cleared when a resync completes.

 *

 * The counter counts pending write requests, plus the on-disk bit.

 * When the counter is '1' and the resync bits are clear, the on-disk

 * bit can be cleared aswell, thus setting the counter to 0.

 * When we set a bit, or in the counter (to start a write), if the fields is

 * 0, we first set the disk bit and set the counter to 1.

 *

 * If the counter is 0, the on-disk bit is clear and the stipe is clean

 * Anything that dirties the stipe pushes the counter to 2 (at least)

 * and sets the on-disk bit (lazily).

 * If a periodic sweep find the counter at 2, it is decremented to 1.

 * If the sweep find the counter at 1, the on-disk bit is cleared and the

 * counter goes to zero.

 *

 * Also, we'll hijack the "map" pointer itself and use it as two 16 bit block

 * counters as a fallback when "page" memory cannot be allocated:

 *

 * Normal case (page memory allocated):

 *

 *     page pointer (32-bit)

 *

 *     [ ] ------+

 *               |

 *               +-------> [   ][   ]..[   ] (4096 byte page == 2048 counters)

 *                          c1   c2    c2048

 *

 * Hijacked case (page memory allocation failed):

 *

 *     hijacked page pointer (32-bit)

 *

 *     [		  ][		  ] (no page memory allocated)

 *      counter #1 (16-bit) counter #2 (16-bit)

 *

 */

#ifdef __KERNEL__

#define PAGE_BITS (PAGE_SIZE << 3)

#define PAGE_BIT_SHIFT (PAGE_SHIFT + 3)

typedef __u16 bitmap_counter_t;

#define COUNTER_BITS 16

#define COUNTER_BIT_SHIFT 4

#define COUNTER_BYTE_RATIO (COUNTER_BITS / 8)

#define COUNTER_BYTE_SHIFT (COUNTER_BIT_SHIFT - 3)

#define NEEDED_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 1)))

#define RESYNC_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 2)))

#define COUNTER_MAX ((bitmap_counter_t) RESYNC_MASK - 1)

#define NEEDED(x) (((bitmap_counter_t) x) & NEEDED_MASK)

#define RESYNC(x) (((bitmap_counter_t) x) & RESYNC_MASK)

#define COUNTER(x) (((bitmap_counter_t) x) & COUNTER_MAX)

/* how many counters per page? */

#define PAGE_COUNTER_RATIO (PAGE_BITS / COUNTER_BITS)

/* same, except a shift value for more efficient bitops */

#define PAGE_COUNTER_SHIFT (PAGE_BIT_SHIFT - COUNTER_BIT_SHIFT)

/* same, except a mask value for more efficient bitops */

#define PAGE_COUNTER_MASK  (PAGE_COUNTER_RATIO - 1)

#define BITMAP_BLOCK_SIZE 512

#define BITMAP_BLOCK_SHIFT 9

/* how many blocks per chunk? (this is variable) */

#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->chunksize >> BITMAP_BLOCK_SHIFT)

#define CHUNK_BLOCK_SHIFT(bitmap) ((bitmap)->chunkshift - BITMAP_BLOCK_SHIFT)

#define CHUNK_BLOCK_MASK(bitmap) (CHUNK_BLOCK_RATIO(bitmap) - 1)

/* when hijacked, the counters and bits represent even larger "chunks" */

/* there will be 1024 chunks represented by each counter in the page pointers */

#define PAGEPTR_BLOCK_RATIO(bitmap) \

			(CHUNK_BLOCK_RATIO(bitmap) << PAGE_COUNTER_SHIFT >> 1)

#define PAGEPTR_BLOCK_SHIFT(bitmap) \

			(CHUNK_BLOCK_SHIFT(bitmap) + PAGE_COUNTER_SHIFT - 1)

#define PAGEPTR_BLOCK_MASK(bitmap) (PAGEPTR_BLOCK_RATIO(bitmap) - 1)

/*

 * on-disk bitmap:

 *

 * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap

 * file a page at a time. There's a superblock at the start of the file.

 */

/* map chunks (bits) to file pages - offset by the size of the superblock */

#define CHUNK_BIT_OFFSET(chunk) ((chunk) + (sizeof(bitmap_super_t) << 3))

#endif

/*

 * bitmap structures:

 */

#define BITMAP_MAGIC 0x6d746962

/* use these for bitmap->flags and bitmap->sb->state bit-fields */

enum bitmap_state {

	BITMAP_ACTIVE = 0x001, /* the bitmap is in use */

	BITMAP_STALE  = 0x002  /* the bitmap file is out of date or had -EIO */

};

/* the superblock at the front of the bitmap file -- little endian */

typedef struct bitmap_super_s {

	__u32 magic;        /*  0  BITMAP_MAGIC */

	__u32 version;      /*  4  the bitmap major for now, could change... */

	__u8  uuid[16];     /*  8  128 bit uuid - must match md device uuid */

	__u64 events;       /* 24  event counter for the bitmap (1)*/

	__u64 events_cleared;/*32  event counter when last bit cleared (2) */

	__u64 sync_size;    /* 40  the size of the md device's sync range(3) */

	__u32 state;        /* 48  bitmap state information */

	__u32 chunksize;    /* 52  the bitmap chunk size in bytes */

	__u32 daemon_sleep; /* 56  seconds between disk flushes */

	__u8  pad[256 - 60]; /* set to zero */

} bitmap_super_t;

/* notes:

 * (1) This event counter is updated before the eventcounter in the md superblock

 *    When a bitmap is loaded, it is only accepted if this event counter is equal

 *    to, or one greater than, the event counter in the superblock.

 * (2) This event counter is updated when the other one is *if*and*only*if* the

 *    array is not degraded.  As bits are not cleared when the array is degraded,

 *    this represents the last time that any bits were cleared.

 *    If a device is being added that has an event count with this value or

 *    higher, it is accepted as conforming to the bitmap.

 * (3)This is the number of sectors represented by the bitmap, and is the range that

 *    resync happens across.  For raid1 and raid5/6 it is the size of individual

 *    devices.  For raid10 it is the size of the array.

 */

#ifdef __KERNEL__

/* the in-memory bitmap is represented by bitmap_pages */

struct bitmap_page {

	/*

	 * map points to the actual memory page

	 */

	char *map;

	/*

	 * in emergencies (when map cannot be alloced), hijack the map

	 * pointer and use it as two counters itself

	 */

	unsigned int hijacked:1;

	/*

	 * count of dirty bits on the page

	 */

	unsigned int  count:31;

};

/* keep track of bitmap file pages that have pending writes on them */

struct page_list {

	struct list_head list;

	struct page *page;

};

/* the main bitmap structure - one per mddev */

struct bitmap {

	struct bitmap_page *bp;

	unsigned long pages; /* total number of pages in the bitmap */

	unsigned long missing_pages; /* number of pages not yet allocated */

	mddev_t *mddev; /* the md device that the bitmap is for */

	int counter_bits; /* how many bits per block counter */

	/* bitmap chunksize -- how much data does each bit represent? */

	unsigned long chunksize;

	unsigned long chunkshift; /* chunksize = 2^chunkshift (for bitops) */

	unsigned long chunks; /* total number of data chunks for the array */

	/* We hold a count on the chunk currently being synced, and drop

	 * it when the last block is started.  If the resync is aborted

	 * midway, we need to be able to drop that count, so we remember

	 * the counted chunk..

	 */

	unsigned long syncchunk;

	__u64	events_cleared;

	/* bitmap spinlock */

	spinlock_t lock;

	struct file *file; /* backing disk file */

	struct page *sb_page; /* cached copy of the bitmap file superblock */

	struct page **filemap; /* list of cache pages for the file */

	unsigned long *filemap_attr; /* attributes associated w/ filemap pages */

	unsigned long file_pages; /* number of pages in the file */

	unsigned long flags;

	/*

	 * the bitmap daemon - periodically wakes up and sweeps the bitmap

	 * file, cleaning up bits and flushing out pages to disk as necessary

	 */

	unsigned long daemon_lastrun; /* jiffies of last run */

	unsigned long daemon_sleep; /* how many seconds between updates? */

	/*

	 * bitmap write daemon - this daemon performs writes to the bitmap file

	 * this thread is only needed because of a limitation in ext3 (jbd)

	 * that does not allow a task to have two journal transactions ongoing

	 * simultaneously (even if the transactions are for two different

	 * filesystems) -- in the case of bitmap, that would be the filesystem

	 * that the bitmap file resides on and the filesystem that is mounted

	 * on the md device -- see current->journal_info in jbd/transaction.c

	 */

	mdk_thread_t *writeback_daemon;

	spinlock_t write_lock;

	struct semaphore write_ready;

	struct semaphore write_done;

	unsigned long writes_pending;

	wait_queue_head_t write_wait;

	struct list_head write_pages;

	struct list_head complete_pages;

	mempool_t *write_pool;

};

/* the bitmap API */

/* these are used only by md/bitmap */

int  bitmap_create(mddev_t *mddev);

void bitmap_destroy(mddev_t *mddev);

int  bitmap_active(struct bitmap *bitmap);

char *file_path(struct file *file, char *buf, int count);

void bitmap_print_sb(struct bitmap *bitmap);

int bitmap_update_sb(struct bitmap *bitmap);

int  bitmap_setallbits(struct bitmap *bitmap);

/* these are exported */

int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors);

void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,

		     int success);

int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks);

void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);

void bitmap_close_sync(struct bitmap *bitmap);

int bitmap_unplug(struct bitmap *bitmap);

int bitmap_daemon_work(struct bitmap *bitmap);

#endif

#endif

	atomic_t			writes_pending; 

	request_queue_t			*queue;	/* for plugging ... */

	struct bitmap                   *bitmap; /* the bitmap for the device */

	struct file			*bitmap_file; /* the bitmap file */

	struct list_head		all_mddevs;

};

	unsigned long           flags;

	struct completion	*event;

	struct task_struct	*tsk;

	unsigned long		timeout;

	const char		*name;

} mdk_thread_t;