dm snapshot: rework writing to origin

	struct bio_list origin_bios;

	struct bio_list snapshot_bios;

	/*

	 * Short-term queue of pending exceptions prior to submission.

	 */

	struct list_head list;

	/*

	 * The primary pending_exception is the one that holds

	 * the ref_count and the list of origin_bios for a

	 * group of pending_exceptions.  It is always last to get freed.

	 * These fields get set up when writing to the origin.

	 */

	struct dm_snap_pending_exception *primary_pe;

	/*

	 * Number of pending_exceptions processing this chunk.

	 * When this drops to zero we must complete the origin bios.

	 * If incrementing or decrementing this, hold pe->snap->lock for

	 * the sibling concerned and not pe->primary_pe->snap->lock unless

	 * they are the same.

	 */

	atomic_t ref_count;

	/* Pointer back to snapshot context */

	struct dm_snapshot *snap;

	flush_bios(queued_bios);

}

static int do_origin(struct dm_dev *origin, struct bio *bio);

/*

 * Flush a list of buffers.

 */

static void retry_origin_bios(struct dm_snapshot *s, struct bio *bio)

{

	struct bio *n;

	int r;

	while (bio) {

		n = bio->bi_next;

		bio->bi_next = NULL;

		r = do_origin(s->origin, bio);

		if (r == DM_MAPIO_REMAPPED)

			generic_make_request(bio);

		bio = n;

	}

}

/*

 * Error a list of buffers.

 */

	dm_table_event(s->ti->table);

}

static void get_pending_exception(struct dm_snap_pending_exception *pe)

{

	atomic_inc(&pe->ref_count);

}

static struct bio *put_pending_exception(struct dm_snap_pending_exception *pe)

{

	struct dm_snap_pending_exception *primary_pe;

	struct bio *origin_bios = NULL;

	primary_pe = pe->primary_pe;

	/*

	 * If this pe is involved in a write to the origin and

	 * it is the last sibling to complete then release

	 * the bios for the original write to the origin.

	 */

	if (primary_pe &&

	    atomic_dec_and_test(&primary_pe->ref_count)) {

		origin_bios = bio_list_get(&primary_pe->origin_bios);

		free_pending_exception(primary_pe);

	}

	/*

	 * Free the pe if it's not linked to an origin write or if

	 * it's not itself a primary pe.

	 */

	if (!primary_pe || primary_pe != pe)

		free_pending_exception(pe);

	return origin_bios;

}

static void pending_complete(struct dm_snap_pending_exception *pe, int success)

{

	struct dm_exception *e;

 out:

	dm_remove_exception(&pe->e);

	snapshot_bios = bio_list_get(&pe->snapshot_bios);

	origin_bios = put_pending_exception(pe);

	origin_bios = bio_list_get(&pe->origin_bios);

	free_pending_exception(pe);

	up_write(&s->lock);

	else

		flush_bios(snapshot_bios);

	flush_bios(origin_bios);

	retry_origin_bios(s, origin_bios);

}

static void commit_callback(void *context, int success)

	pe->e.old_chunk = chunk;

	bio_list_init(&pe->origin_bios);

	bio_list_init(&pe->snapshot_bios);

	pe->primary_pe = NULL;

	atomic_set(&pe->ref_count, 0);

	pe->started = 0;

	if (s->store->type->prepare_exception(s->store, &pe->e)) {

		return NULL;

	}

	get_pending_exception(pe);

	dm_insert_exception(&s->pending, &pe->e);

	return pe;

static int __origin_write(struct list_head *snapshots, sector_t sector,

			  struct bio *bio)

{

	int r = DM_MAPIO_REMAPPED, first = 0;

	int r = DM_MAPIO_REMAPPED;

	struct dm_snapshot *snap;

	struct dm_exception *e;

	struct dm_snap_pending_exception *pe, *next_pe, *primary_pe = NULL;

	struct dm_snap_pending_exception *pe;

	struct dm_snap_pending_exception *pe_to_start_now = NULL;

	struct dm_snap_pending_exception *pe_to_start_last = NULL;

	chunk_t chunk;

	LIST_HEAD(pe_queue);

	/* Do all the snapshots on this origin */

	list_for_each_entry (snap, snapshots, list) {

		down_write(&snap->lock);

		/* Only deal with valid and active snapshots */

		 * Check exception table to see if block

		 * is already remapped in this snapshot

		 * and trigger an exception if not.

		 *

		 * ref_count is initialised to 1 so pending_complete()

		 * won't destroy the primary_pe while we're inside this loop.

		 */

		e = dm_lookup_exception(&snap->complete, chunk);

		if (e)

			}

		}

		if (!primary_pe) {

		r = DM_MAPIO_SUBMITTED;

		/*

			 * Either every pe here has same

			 * primary_pe or none has one yet.

		 * If an origin bio was supplied, queue it to wait for the

		 * completion of this exception, and start this one last,

		 * at the end of the function.

		 */

			if (pe->primary_pe)

				primary_pe = pe->primary_pe;

			else {

				primary_pe = pe;

				first = 1;

			}

		if (bio) {

			bio_list_add(&pe->origin_bios, bio);

			bio = NULL;

			if (bio)

				bio_list_add(&primary_pe->origin_bios, bio);

			r = DM_MAPIO_SUBMITTED;

			if (!pe->started) {

				pe->started = 1;

				pe_to_start_last = pe;

			}

		if (!pe->primary_pe) {

			pe->primary_pe = primary_pe;

			get_pending_exception(primary_pe);

		}

		if (!pe->started) {

			pe->started = 1;

			list_add_tail(&pe->list, &pe_queue);

			pe_to_start_now = pe;

		}

 next_snapshot:

		up_write(&snap->lock);

	}

	if (!primary_pe)

		return r;

	/*

	 * If this is the first time we're processing this chunk and

	 * ref_count is now 1 it means all the pending exceptions

	 * got completed while we were in the loop above, so it falls to

	 * us here to remove the primary_pe and submit any origin_bios.

	 */

	if (first && atomic_dec_and_test(&primary_pe->ref_count)) {

		flush_bios(bio_list_get(&primary_pe->origin_bios));

		free_pending_exception(primary_pe);

		/* If we got here, pe_queue is necessarily empty. */

		return r;

		if (pe_to_start_now) {

			start_copy(pe_to_start_now);

			pe_to_start_now = NULL;

		}

	}

	/*

	 * Now that we have a complete pe list we can start the copying.

	 * Submit the exception against which the bio is queued last,

	 * to give the other exceptions a head start.

	 */

	list_for_each_entry_safe(pe, next_pe, &pe_queue, list)

		start_copy(pe);

	if (pe_to_start_last)

		start_copy(pe_to_start_last);

	return r;

}