dm snapshot: use mutex instead of rw_semaphore

};

struct dm_snapshot {

	struct rw_semaphore lock;

	struct mutex lock;

	struct dm_dev *origin;

	struct dm_dev *cow;

		if (!bdev_equal(s->cow->bdev, snap->cow->bdev))

			continue;

		down_read(&s->lock);

		mutex_lock(&s->lock);

		active = s->active;

		up_read(&s->lock);

		mutex_unlock(&s->lock);

		if (active) {

			if (snap_src)

	int r;

	chunk_t old_chunk = s->first_merging_chunk + s->num_merging_chunks - 1;

	down_write(&s->lock);

	mutex_lock(&s->lock);

	/*

	 * Process chunks (and associated exceptions) in reverse order

	b = __release_queued_bios_after_merge(s);

out:

	up_write(&s->lock);

	mutex_unlock(&s->lock);

	if (b)

		flush_bios(b);

		if (linear_chunks < 0) {

			DMERR("Read error in exception store: "

			      "shutting down merge");

			down_write(&s->lock);

			mutex_lock(&s->lock);

			s->merge_failed = 1;

			up_write(&s->lock);

			mutex_unlock(&s->lock);

		}

		goto shut;

	}

		previous_count = read_pending_exceptions_done_count();

	}

	down_write(&s->lock);

	mutex_lock(&s->lock);

	s->first_merging_chunk = old_chunk;

	s->num_merging_chunks = linear_chunks;

	up_write(&s->lock);

	mutex_unlock(&s->lock);

	/* Wait until writes to all 'linear_chunks' drain */

	for (i = 0; i < linear_chunks; i++)

	return;

shut:

	down_write(&s->lock);

	mutex_lock(&s->lock);

	s->merge_failed = 1;

	b = __release_queued_bios_after_merge(s);

	up_write(&s->lock);

	mutex_unlock(&s->lock);

	error_bios(b);

	merge_shutdown(s);

	s->exception_start_sequence = 0;

	s->exception_complete_sequence = 0;

	INIT_LIST_HEAD(&s->out_of_order_list);

	init_rwsem(&s->lock);

	mutex_init(&s->lock);

	INIT_LIST_HEAD(&s->list);

	spin_lock_init(&s->pe_lock);

	s->state_bits = 0;

	/* Check whether exception handover must be cancelled */

	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);

	if (snap_src && snap_dest && (s == snap_src)) {

		down_write(&snap_dest->lock);

		mutex_lock(&snap_dest->lock);

		snap_dest->valid = 0;

		up_write(&snap_dest->lock);

		mutex_unlock(&snap_dest->lock);

		DMERR("Cancelling snapshot handover.");

	}

	up_read(&_origins_lock);

	dm_exception_store_destroy(s->store);

	mutex_destroy(&s->lock);

	dm_put_device(ti, s->cow);

	dm_put_device(ti, s->origin);

	if (!success) {

		/* Read/write error - snapshot is unusable */

		down_write(&s->lock);

		mutex_lock(&s->lock);

		__invalidate_snapshot(s, -EIO);

		error = 1;

		goto out;

	e = alloc_completed_exception(GFP_NOIO);

	if (!e) {

		down_write(&s->lock);

		mutex_lock(&s->lock);

		__invalidate_snapshot(s, -ENOMEM);

		error = 1;

		goto out;

	}

	*e = pe->e;

	down_write(&s->lock);

	mutex_lock(&s->lock);

	if (!s->valid) {

		free_completed_exception(e);

		error = 1;

		full_bio->bi_end_io = pe->full_bio_end_io;

	increment_pending_exceptions_done_count();

	up_write(&s->lock);

	mutex_unlock(&s->lock);

	/* Submit any pending write bios */

	if (error) {

	/* FIXME: should only take write lock if we need

	 * to copy an exception */

	down_write(&s->lock);

	mutex_lock(&s->lock);

	if (!s->valid || (unlikely(s->snapshot_overflowed) &&

	    bio_data_dir(bio) == WRITE)) {

	if (bio_data_dir(bio) == WRITE) {

		pe = __lookup_pending_exception(s, chunk);

		if (!pe) {

			up_write(&s->lock);

			mutex_unlock(&s->lock);

			pe = alloc_pending_exception(s);

			down_write(&s->lock);

			mutex_lock(&s->lock);

			if (!s->valid || s->snapshot_overflowed) {

				free_pending_exception(pe);

		    bio->bi_iter.bi_size ==

		    (s->store->chunk_size << SECTOR_SHIFT)) {

			pe->started = 1;

			up_write(&s->lock);

			mutex_unlock(&s->lock);

			start_full_bio(pe, bio);

			goto out;

		}

		if (!pe->started) {

			/* this is protected by snap->lock */

			pe->started = 1;

			up_write(&s->lock);

			mutex_unlock(&s->lock);

			start_copy(pe);

			goto out;

		}

	}

out_unlock:

	up_write(&s->lock);

	mutex_unlock(&s->lock);

out:

	return r;

}

	chunk = sector_to_chunk(s->store, bio->bi_iter.bi_sector);

	down_write(&s->lock);

	mutex_lock(&s->lock);

	/* Full merging snapshots are redirected to the origin */

	if (!s->valid)

	bio_set_dev(bio, s->origin->bdev);

	if (bio_data_dir(bio) == WRITE) {

		up_write(&s->lock);

		mutex_unlock(&s->lock);

		return do_origin(s->origin, bio);

	}

out_unlock:

	up_write(&s->lock);

	mutex_unlock(&s->lock);

	return r;

}

	down_read(&_origins_lock);

	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);

	if (snap_src && snap_dest) {

		down_read(&snap_src->lock);

		mutex_lock(&snap_src->lock);

		if (s == snap_src) {

			DMERR("Unable to resume snapshot source until "

			      "handover completes.");

			      "source is suspended.");

			r = -EINVAL;

		}

		up_read(&snap_src->lock);

		mutex_unlock(&snap_src->lock);

	}

	up_read(&_origins_lock);

	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);

	if (snap_src && snap_dest) {

		down_write(&snap_src->lock);

		down_write_nested(&snap_dest->lock, SINGLE_DEPTH_NESTING);

		mutex_lock(&snap_src->lock);

		mutex_lock_nested(&snap_dest->lock, SINGLE_DEPTH_NESTING);

		__handover_exceptions(snap_src, snap_dest);

		up_write(&snap_dest->lock);

		up_write(&snap_src->lock);

		mutex_unlock(&snap_dest->lock);

		mutex_unlock(&snap_src->lock);

	}

	up_read(&_origins_lock);

	/* Now we have correct chunk size, reregister */

	reregister_snapshot(s);

	down_write(&s->lock);

	mutex_lock(&s->lock);

	s->active = 1;

	up_write(&s->lock);

	mutex_unlock(&s->lock);

}

static uint32_t get_origin_minimum_chunksize(struct block_device *bdev)

	switch (type) {

	case STATUSTYPE_INFO:

		down_write(&snap->lock);

		mutex_lock(&snap->lock);

		if (!snap->valid)

			DMEMIT("Invalid");

				DMEMIT("Unknown");

		}

		up_write(&snap->lock);

		mutex_unlock(&snap->lock);

		break;

		if (dm_target_is_snapshot_merge(snap->ti))

			continue;

		down_write(&snap->lock);

		mutex_lock(&snap->lock);

		/* Only deal with valid and active snapshots */

		if (!snap->valid || !snap->active)

		pe = __lookup_pending_exception(snap, chunk);

		if (!pe) {

			up_write(&snap->lock);

			mutex_unlock(&snap->lock);

			pe = alloc_pending_exception(snap);

			down_write(&snap->lock);

			mutex_lock(&snap->lock);

			if (!snap->valid) {

				free_pending_exception(pe);

		}

next_snapshot:

		up_write(&snap->lock);

		mutex_unlock(&snap->lock);

		if (pe_to_start_now) {

			start_copy(pe_to_start_now);