Commit 64120354 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-4.5/drivers' of git://git.kernel.dk/linux-block 

Pull block driver updates from Jens Axboe:
 "This is the block driver pull request for 4.5, with the exception of
  NVMe, which is in a separate branch and will be posted after this one.

  This pull request contains:

   - A set of bcache stability fixes, which have been acked by Kent.
     These have been used and tested for more than a year by the
     community, so it's about time that they got in.

   - A set of drbd updates from the drbd team (Andreas, Lars, Philipp)
     and Markus Elfring, Oleg Drokin.

   - A set of fixes for xen blkback/front from the usual suspects, (Bob,
     Konrad) as well as community based fixes from Kiri, Julien, and
     Peng.

   - A 2038 time fix for sx8 from Shraddha, with a fix from me.

   - A small mtip32xx cleanup from Zhu Yanjun.

   - A null_blk division fix from Arnd"

* 'for-4.5/drivers' of git://git.kernel.dk/linux-block: (71 commits)
  null_blk: use sector_div instead of do_div
  mtip32xx: restrict variables visible in current code module
  xen/blkfront: Fix crash if backend doesn't follow the right states.
  xen/blkback: Fix two memory leaks.
  xen/blkback: make st_ statistics per ring
  xen/blkfront: Handle non-indirect grant with 64KB pages
  xen-blkfront: Introduce blkif_ring_get_request
  xen-blkback: clear PF_NOFREEZE for xen_blkif_schedule()
  xen/blkback: Free resources if connect_ring failed.
  xen/blocks: Return -EXX instead of -1
  xen/blkback: make pool of persistent grants and free pages per-queue
  xen/blkback: get the number of hardware queues/rings from blkfront
  xen/blkback: pseudo support for multi hardware queues/rings
  xen/blkback: separate ring information out of struct xen_blkif
  xen/blkfront: correct setting for xen_blkif_max_ring_order
  xen/blkfront: make persistent grants pool per-queue
  xen/blkfront: Remove duplicate setting of ->xbdev.
  xen/blkfront: Cleanup of comments, fix unaligned variables, and syntax errors.
  xen/blkfront: negotiate number of queues/rings to be used with backend
  xen/blkfront: split per device io_lock
  ...
parents 404a4741 e93d12ae

MAINTAINERS

+5 −6
Original line number Diff line number Diff line
@@ -3665,13 +3665,12 @@ F: drivers/scsi/dpt* 
F:	drivers/scsi/dpt/



DRBD DRIVER

P:	Philipp Reisner

P:	Lars Ellenberg

M:	drbd-dev@lists.linbit.com

L:	drbd-user@lists.linbit.com

M:	Philipp Reisner <philipp.reisner@linbit.com>

M:	Lars Ellenberg <lars.ellenberg@linbit.com>

L:	drbd-dev@lists.linbit.com

W:	http://www.drbd.org

T:	git git://git.drbd.org/linux-2.6-drbd.git drbd

T:	git git://git.drbd.org/drbd-8.3.git

T:	git git://git.linbit.com/linux-drbd.git

T:	git git://git.linbit.com/drbd-8.4.git

S:	Supported

F:	drivers/block/drbd/

F:	lib/lru_cache.c

drivers/block/drbd/drbd_actlog.c

+167 −156
Original line number Diff line number Diff line
@@ -288,7 +288,162 @@ bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval * 
	return need_transaction;

}



static int al_write_transaction(struct drbd_device *device);

#if (PAGE_SHIFT + 3) < (AL_EXTENT_SHIFT - BM_BLOCK_SHIFT)

/* Currently BM_BLOCK_SHIFT, BM_EXT_SHIFT and AL_EXTENT_SHIFT

 * are still coupled, or assume too much about their relation.

 * Code below will not work if this is violated.

 * Will be cleaned up with some followup patch.

 */

# error FIXME

#endif



static unsigned int al_extent_to_bm_page(unsigned int al_enr)

{

	return al_enr >>

		/* bit to page */

		((PAGE_SHIFT + 3) -

		/* al extent number to bit */

		 (AL_EXTENT_SHIFT - BM_BLOCK_SHIFT));

}



static sector_t al_tr_number_to_on_disk_sector(struct drbd_device *device)

{

	const unsigned int stripes = device->ldev->md.al_stripes;

	const unsigned int stripe_size_4kB = device->ldev->md.al_stripe_size_4k;



	/* transaction number, modulo on-disk ring buffer wrap around */

	unsigned int t = device->al_tr_number % (device->ldev->md.al_size_4k);



	/* ... to aligned 4k on disk block */

	t = ((t % stripes) * stripe_size_4kB) + t/stripes;



	/* ... to 512 byte sector in activity log */

	t *= 8;



	/* ... plus offset to the on disk position */

	return device->ldev->md.md_offset + device->ldev->md.al_offset + t;

}



static int __al_write_transaction(struct drbd_device *device, struct al_transaction_on_disk *buffer)

{

	struct lc_element *e;

	sector_t sector;

	int i, mx;

	unsigned extent_nr;

	unsigned crc = 0;

	int err = 0;



	memset(buffer, 0, sizeof(*buffer));

	buffer->magic = cpu_to_be32(DRBD_AL_MAGIC);

	buffer->tr_number = cpu_to_be32(device->al_tr_number);



	i = 0;



	/* Even though no one can start to change this list

	 * once we set the LC_LOCKED -- from drbd_al_begin_io(),

	 * lc_try_lock_for_transaction() --, someone may still

	 * be in the process of changing it. */

	spin_lock_irq(&device->al_lock);

	list_for_each_entry(e, &device->act_log->to_be_changed, list) {

		if (i == AL_UPDATES_PER_TRANSACTION) {

			i++;

			break;

		}

		buffer->update_slot_nr[i] = cpu_to_be16(e->lc_index);

		buffer->update_extent_nr[i] = cpu_to_be32(e->lc_new_number);

		if (e->lc_number != LC_FREE)

			drbd_bm_mark_for_writeout(device,

					al_extent_to_bm_page(e->lc_number));

		i++;

	}

	spin_unlock_irq(&device->al_lock);

	BUG_ON(i > AL_UPDATES_PER_TRANSACTION);



	buffer->n_updates = cpu_to_be16(i);

	for ( ; i < AL_UPDATES_PER_TRANSACTION; i++) {

		buffer->update_slot_nr[i] = cpu_to_be16(-1);

		buffer->update_extent_nr[i] = cpu_to_be32(LC_FREE);

	}



	buffer->context_size = cpu_to_be16(device->act_log->nr_elements);

	buffer->context_start_slot_nr = cpu_to_be16(device->al_tr_cycle);



	mx = min_t(int, AL_CONTEXT_PER_TRANSACTION,

		   device->act_log->nr_elements - device->al_tr_cycle);

	for (i = 0; i < mx; i++) {

		unsigned idx = device->al_tr_cycle + i;

		extent_nr = lc_element_by_index(device->act_log, idx)->lc_number;

		buffer->context[i] = cpu_to_be32(extent_nr);

	}

	for (; i < AL_CONTEXT_PER_TRANSACTION; i++)

		buffer->context[i] = cpu_to_be32(LC_FREE);



	device->al_tr_cycle += AL_CONTEXT_PER_TRANSACTION;

	if (device->al_tr_cycle >= device->act_log->nr_elements)

		device->al_tr_cycle = 0;



	sector = al_tr_number_to_on_disk_sector(device);



	crc = crc32c(0, buffer, 4096);

	buffer->crc32c = cpu_to_be32(crc);



	if (drbd_bm_write_hinted(device))

		err = -EIO;

	else {

		bool write_al_updates;

		rcu_read_lock();

		write_al_updates = rcu_dereference(device->ldev->disk_conf)->al_updates;

		rcu_read_unlock();

		if (write_al_updates) {

			if (drbd_md_sync_page_io(device, device->ldev, sector, WRITE)) {

				err = -EIO;

				drbd_chk_io_error(device, 1, DRBD_META_IO_ERROR);

			} else {

				device->al_tr_number++;

				device->al_writ_cnt++;

			}

		}

	}



	return err;

}



static int al_write_transaction(struct drbd_device *device)

{

	struct al_transaction_on_disk *buffer;

	int err;



	if (!get_ldev(device)) {

		drbd_err(device, "disk is %s, cannot start al transaction\n",

			drbd_disk_str(device->state.disk));

		return -EIO;

	}



	/* The bitmap write may have failed, causing a state change. */

	if (device->state.disk < D_INCONSISTENT) {

		drbd_err(device,

			"disk is %s, cannot write al transaction\n",

			drbd_disk_str(device->state.disk));

		put_ldev(device);

		return -EIO;

	}



	/* protects md_io_buffer, al_tr_cycle, ... */

	buffer = drbd_md_get_buffer(device, __func__);

	if (!buffer) {

		drbd_err(device, "disk failed while waiting for md_io buffer\n");

		put_ldev(device);

		return -ENODEV;

	}



	err = __al_write_transaction(device, buffer);



	drbd_md_put_buffer(device);

	put_ldev(device);



	return err;

}





void drbd_al_begin_io_commit(struct drbd_device *device)

{
@@ -420,153 +575,6 @@ void drbd_al_complete_io(struct drbd_device *device, struct drbd_interval *i) 
	wake_up(&device->al_wait);

}



#if (PAGE_SHIFT + 3) < (AL_EXTENT_SHIFT - BM_BLOCK_SHIFT)

/* Currently BM_BLOCK_SHIFT, BM_EXT_SHIFT and AL_EXTENT_SHIFT

 * are still coupled, or assume too much about their relation.

 * Code below will not work if this is violated.

 * Will be cleaned up with some followup patch.

 */

# error FIXME

#endif



static unsigned int al_extent_to_bm_page(unsigned int al_enr)

{

	return al_enr >>

		/* bit to page */

		((PAGE_SHIFT + 3) -

		/* al extent number to bit */

		 (AL_EXTENT_SHIFT - BM_BLOCK_SHIFT));

}



static sector_t al_tr_number_to_on_disk_sector(struct drbd_device *device)

{

	const unsigned int stripes = device->ldev->md.al_stripes;

	const unsigned int stripe_size_4kB = device->ldev->md.al_stripe_size_4k;



	/* transaction number, modulo on-disk ring buffer wrap around */

	unsigned int t = device->al_tr_number % (device->ldev->md.al_size_4k);



	/* ... to aligned 4k on disk block */

	t = ((t % stripes) * stripe_size_4kB) + t/stripes;



	/* ... to 512 byte sector in activity log */

	t *= 8;



	/* ... plus offset to the on disk position */

	return device->ldev->md.md_offset + device->ldev->md.al_offset + t;

}



int al_write_transaction(struct drbd_device *device)

{

	struct al_transaction_on_disk *buffer;

	struct lc_element *e;

	sector_t sector;

	int i, mx;

	unsigned extent_nr;

	unsigned crc = 0;

	int err = 0;



	if (!get_ldev(device)) {

		drbd_err(device, "disk is %s, cannot start al transaction\n",

			drbd_disk_str(device->state.disk));

		return -EIO;

	}



	/* The bitmap write may have failed, causing a state change. */

	if (device->state.disk < D_INCONSISTENT) {

		drbd_err(device,

			"disk is %s, cannot write al transaction\n",

			drbd_disk_str(device->state.disk));

		put_ldev(device);

		return -EIO;

	}



	/* protects md_io_buffer, al_tr_cycle, ... */

	buffer = drbd_md_get_buffer(device, __func__);

	if (!buffer) {

		drbd_err(device, "disk failed while waiting for md_io buffer\n");

		put_ldev(device);

		return -ENODEV;

	}



	memset(buffer, 0, sizeof(*buffer));

	buffer->magic = cpu_to_be32(DRBD_AL_MAGIC);

	buffer->tr_number = cpu_to_be32(device->al_tr_number);



	i = 0;



	/* Even though no one can start to change this list

	 * once we set the LC_LOCKED -- from drbd_al_begin_io(),

	 * lc_try_lock_for_transaction() --, someone may still

	 * be in the process of changing it. */

	spin_lock_irq(&device->al_lock);

	list_for_each_entry(e, &device->act_log->to_be_changed, list) {

		if (i == AL_UPDATES_PER_TRANSACTION) {

			i++;

			break;

		}

		buffer->update_slot_nr[i] = cpu_to_be16(e->lc_index);

		buffer->update_extent_nr[i] = cpu_to_be32(e->lc_new_number);

		if (e->lc_number != LC_FREE)

			drbd_bm_mark_for_writeout(device,

					al_extent_to_bm_page(e->lc_number));

		i++;

	}

	spin_unlock_irq(&device->al_lock);

	BUG_ON(i > AL_UPDATES_PER_TRANSACTION);



	buffer->n_updates = cpu_to_be16(i);

	for ( ; i < AL_UPDATES_PER_TRANSACTION; i++) {

		buffer->update_slot_nr[i] = cpu_to_be16(-1);

		buffer->update_extent_nr[i] = cpu_to_be32(LC_FREE);

	}



	buffer->context_size = cpu_to_be16(device->act_log->nr_elements);

	buffer->context_start_slot_nr = cpu_to_be16(device->al_tr_cycle);



	mx = min_t(int, AL_CONTEXT_PER_TRANSACTION,

		   device->act_log->nr_elements - device->al_tr_cycle);

	for (i = 0; i < mx; i++) {

		unsigned idx = device->al_tr_cycle + i;

		extent_nr = lc_element_by_index(device->act_log, idx)->lc_number;

		buffer->context[i] = cpu_to_be32(extent_nr);

	}

	for (; i < AL_CONTEXT_PER_TRANSACTION; i++)

		buffer->context[i] = cpu_to_be32(LC_FREE);



	device->al_tr_cycle += AL_CONTEXT_PER_TRANSACTION;

	if (device->al_tr_cycle >= device->act_log->nr_elements)

		device->al_tr_cycle = 0;



	sector = al_tr_number_to_on_disk_sector(device);



	crc = crc32c(0, buffer, 4096);

	buffer->crc32c = cpu_to_be32(crc);



	if (drbd_bm_write_hinted(device))

		err = -EIO;

	else {

		bool write_al_updates;

		rcu_read_lock();

		write_al_updates = rcu_dereference(device->ldev->disk_conf)->al_updates;

		rcu_read_unlock();

		if (write_al_updates) {

			if (drbd_md_sync_page_io(device, device->ldev, sector, WRITE)) {

				err = -EIO;

				drbd_chk_io_error(device, 1, DRBD_META_IO_ERROR);

			} else {

				device->al_tr_number++;

				device->al_writ_cnt++;

			}

		}

	}



	drbd_md_put_buffer(device);

	put_ldev(device);



	return err;

}



static int _try_lc_del(struct drbd_device *device, struct lc_element *al_ext)

{

	int rv;
@@ -606,21 +614,24 @@ void drbd_al_shrink(struct drbd_device *device) 
	wake_up(&device->al_wait);

}



int drbd_initialize_al(struct drbd_device *device, void *buffer)

int drbd_al_initialize(struct drbd_device *device, void *buffer)

{

	struct al_transaction_on_disk *al = buffer;

	struct drbd_md *md = &device->ldev->md;

	sector_t al_base = md->md_offset + md->al_offset;

	int al_size_4k = md->al_stripes * md->al_stripe_size_4k;

	int i;



	memset(al, 0, 4096);

	al->magic = cpu_to_be32(DRBD_AL_MAGIC);

	al->transaction_type = cpu_to_be16(AL_TR_INITIALIZED);

	al->crc32c = cpu_to_be32(crc32c(0, al, 4096));

	__al_write_transaction(device, al);

	/* There may or may not have been a pending transaction. */

	spin_lock_irq(&device->al_lock);

	lc_committed(device->act_log);

	spin_unlock_irq(&device->al_lock);



	for (i = 0; i < al_size_4k; i++) {

		int err = drbd_md_sync_page_io(device, device->ldev, al_base + i * 8, WRITE);

	/* The rest of the transactions will have an empty "updates" list, and

	 * are written out only to provide the context, and to initialize the

	 * on-disk ring buffer. */

	for (i = 1; i < al_size_4k; i++) {

		int err = __al_write_transaction(device, al);

		if (err)

			return err;

	}

drivers/block/drbd/drbd_bitmap.c

+14 −8
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 


#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt



#include <linux/bitops.h>

#include <linux/bitmap.h>

#include <linux/vmalloc.h>

#include <linux/string.h>

#include <linux/drbd.h>
@@ -479,8 +479,14 @@ void drbd_bm_cleanup(struct drbd_device *device) 
 * this masks out the remaining bits.

 * Returns the number of bits cleared.

 */

#ifndef BITS_PER_PAGE

#define BITS_PER_PAGE		(1UL << (PAGE_SHIFT + 3))

#define BITS_PER_PAGE_MASK	(BITS_PER_PAGE - 1)

#else

# if BITS_PER_PAGE != (1UL << (PAGE_SHIFT + 3))

#  error "ambiguous BITS_PER_PAGE"

# endif

#endif

#define BITS_PER_LONG_MASK	(BITS_PER_LONG - 1)

static int bm_clear_surplus(struct drbd_bitmap *b)

{
@@ -559,21 +565,19 @@ static unsigned long bm_count_bits(struct drbd_bitmap *b) 
	unsigned long *p_addr;

	unsigned long bits = 0;

	unsigned long mask = (1UL << (b->bm_bits & BITS_PER_LONG_MASK)) -1;

	int idx, i, last_word;

	int idx, last_word;



	/* all but last page */

	for (idx = 0; idx < b->bm_number_of_pages - 1; idx++) {

		p_addr = __bm_map_pidx(b, idx);

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

			bits += hweight_long(p_addr[i]);

		bits += bitmap_weight(p_addr, BITS_PER_PAGE);

		__bm_unmap(p_addr);

		cond_resched();

	}

	/* last (or only) page */

	last_word = ((b->bm_bits - 1) & BITS_PER_PAGE_MASK) >> LN2_BPL;

	p_addr = __bm_map_pidx(b, idx);

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

		bits += hweight_long(p_addr[i]);

	bits += bitmap_weight(p_addr, last_word * BITS_PER_LONG);

	p_addr[last_word] &= cpu_to_lel(mask);

	bits += hweight_long(p_addr[last_word]);

	/* 32bit arch, may have an unused padding long */
@@ -1419,6 +1423,9 @@ static inline void bm_set_full_words_within_one_page(struct drbd_bitmap *b, 
	int bits;

	int changed = 0;

	unsigned long *paddr = kmap_atomic(b->bm_pages[page_nr]);



	/* I think it is more cache line friendly to hweight_long then set to ~0UL,

	 * than to first bitmap_weight() all words, then bitmap_fill() all words */

	for (i = first_word; i < last_word; i++) {

		bits = hweight_long(paddr[i]);

		paddr[i] = ~0UL;
@@ -1628,8 +1635,7 @@ int drbd_bm_e_weight(struct drbd_device *device, unsigned long enr) 
		int n = e-s;

		p_addr = bm_map_pidx(b, bm_word_to_page_idx(b, s));

		bm = p_addr + MLPP(s);

		while (n--)

			count += hweight_long(*bm++);

		count += bitmap_weight(bm, n * BITS_PER_LONG);

		bm_unmap(p_addr);

	} else {

		drbd_err(device, "start offset (%d) too large in drbd_bm_e_weight\n", s);

drivers/block/drbd/drbd_debugfs.c

+10 −0
Original line number Diff line number Diff line
@@ -771,6 +771,13 @@ static int device_data_gen_id_show(struct seq_file *m, void *ignored) 
	return 0;

}



static int device_ed_gen_id_show(struct seq_file *m, void *ignored)

{

	struct drbd_device *device = m->private;

	seq_printf(m, "0x%016llX\n", (unsigned long long)device->ed_uuid);

	return 0;

}



#define drbd_debugfs_device_attr(name)						\

static int device_ ## name ## _open(struct inode *inode, struct file *file)	\

{										\
@@ -796,6 +803,7 @@ drbd_debugfs_device_attr(oldest_requests) 
drbd_debugfs_device_attr(act_log_extents)

drbd_debugfs_device_attr(resync_extents)

drbd_debugfs_device_attr(data_gen_id)

drbd_debugfs_device_attr(ed_gen_id)



void drbd_debugfs_device_add(struct drbd_device *device)

{
@@ -839,6 +847,7 @@ void drbd_debugfs_device_add(struct drbd_device *device) 
	DCF(act_log_extents);

	DCF(resync_extents);

	DCF(data_gen_id);

	DCF(ed_gen_id);

#undef DCF

	return;
@@ -854,6 +863,7 @@ void drbd_debugfs_device_cleanup(struct drbd_device *device) 
	drbd_debugfs_remove(&device->debugfs_vol_act_log_extents);

	drbd_debugfs_remove(&device->debugfs_vol_resync_extents);

	drbd_debugfs_remove(&device->debugfs_vol_data_gen_id);

	drbd_debugfs_remove(&device->debugfs_vol_ed_gen_id);

	drbd_debugfs_remove(&device->debugfs_vol);

}

drivers/block/drbd/drbd_int.h

+72 −39
Original line number Diff line number Diff line
@@ -77,13 +77,6 @@ extern int fault_devs; 
extern char usermode_helper[];





/* I don't remember why XCPU ...

 * This is used to wake the asender,

 * and to interrupt sending the sending task

 * on disconnect.

 */

#define DRBD_SIG SIGXCPU



/* This is used to stop/restart our threads.

 * Cannot use SIGTERM nor SIGKILL, since these

 * are sent out by init on runlevel changes
@@ -292,6 +285,9 @@ struct drbd_device_work { 


extern int drbd_wait_misc(struct drbd_device *, struct drbd_interval *);



extern void lock_all_resources(void);

extern void unlock_all_resources(void);



struct drbd_request {

	struct drbd_work w;

	struct drbd_device *device;
@@ -504,7 +500,6 @@ enum { 


	MD_NO_FUA,		/* Users wants us to not use FUA/FLUSH on meta data dev */



	SUSPEND_IO,		/* suspend application io */

	BITMAP_IO,		/* suspend application io;

				   once no more io in flight, start bitmap io */

	BITMAP_IO_QUEUED,       /* Started bitmap IO */
@@ -632,12 +627,6 @@ struct bm_io_work { 
	void (*done)(struct drbd_device *device, int rv);

};



enum write_ordering_e {

	WO_none,

	WO_drain_io,

	WO_bdev_flush,

};



struct fifo_buffer {

	unsigned int head_index;

	unsigned int size;
@@ -650,8 +639,7 @@ extern struct fifo_buffer *fifo_alloc(int fifo_size); 
enum {

	NET_CONGESTED,		/* The data socket is congested */

	RESOLVE_CONFLICTS,	/* Set on one node, cleared on the peer! */

	SEND_PING,		/* whether asender should send a ping asap */

	SIGNAL_ASENDER,		/* whether asender wants to be interrupted */

	SEND_PING,

	GOT_PING_ACK,		/* set when we receive a ping_ack packet, ping_wait gets woken */

	CONN_WD_ST_CHG_REQ,	/* A cluster wide state change on the connection is active */

	CONN_WD_ST_CHG_OKAY,
@@ -670,6 +658,8 @@ enum { 
	DEVICE_WORK_PENDING,	/* tell worker that some device has pending work */

};



enum which_state { NOW, OLD = NOW, NEW };



struct drbd_resource {

	char *name;

#ifdef CONFIG_DEBUG_FS
@@ -755,7 +745,8 @@ struct drbd_connection { 
	unsigned long last_reconnect_jif;

	struct drbd_thread receiver;

	struct drbd_thread worker;

	struct drbd_thread asender;

	struct drbd_thread ack_receiver;

	struct workqueue_struct *ack_sender;



	/* cached pointers,

	 * so we can look up the oldest pending requests more quickly.
@@ -774,6 +765,8 @@ struct drbd_connection { 
	struct drbd_thread_timing_details r_timing_details[DRBD_THREAD_DETAILS_HIST];



	struct {

		unsigned long last_sent_barrier_jif;



		/* whether this sender thread

		 * has processed a single write yet. */

		bool seen_any_write_yet;
@@ -788,6 +781,17 @@ struct drbd_connection { 
	} send;

};



static inline bool has_net_conf(struct drbd_connection *connection)

{

	bool has_net_conf;



	rcu_read_lock();

	has_net_conf = rcu_dereference(connection->net_conf);

	rcu_read_unlock();



	return has_net_conf;

}



void __update_timing_details(

		struct drbd_thread_timing_details *tdp,

		unsigned int *cb_nr,
@@ -811,6 +815,7 @@ struct drbd_peer_device { 
	struct list_head peer_devices;

	struct drbd_device *device;

	struct drbd_connection *connection;

	struct work_struct send_acks_work;

#ifdef CONFIG_DEBUG_FS

	struct dentry *debugfs_peer_dev;

#endif
@@ -829,6 +834,7 @@ struct drbd_device { 
	struct dentry *debugfs_vol_act_log_extents;

	struct dentry *debugfs_vol_resync_extents;

	struct dentry *debugfs_vol_data_gen_id;

	struct dentry *debugfs_vol_ed_gen_id;

#endif



	unsigned int vnr;	/* volume number within the connection */
@@ -873,6 +879,7 @@ struct drbd_device { 
	atomic_t rs_pending_cnt; /* RS request/data packets on the wire */

	atomic_t unacked_cnt;	 /* Need to send replies for */

	atomic_t local_cnt;	 /* Waiting for local completion */

	atomic_t suspend_cnt;



	/* Interval tree of pending local requests */

	struct rb_root read_requests;
@@ -1020,6 +1027,12 @@ static inline struct drbd_peer_device *first_peer_device(struct drbd_device *dev 
	return list_first_entry_or_null(&device->peer_devices, struct drbd_peer_device, peer_devices);

}



static inline struct drbd_peer_device *

conn_peer_device(struct drbd_connection *connection, int volume_number)

{

	return idr_find(&connection->peer_devices, volume_number);

}



#define for_each_resource(resource, _resources) \

	list_for_each_entry(resource, _resources, resources)
@@ -1113,7 +1126,7 @@ extern int drbd_send_ov_request(struct drbd_peer_device *, sector_t sector, int 
extern int drbd_send_bitmap(struct drbd_device *device);

extern void drbd_send_sr_reply(struct drbd_peer_device *, enum drbd_state_rv retcode);

extern void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode);

extern void drbd_free_ldev(struct drbd_backing_dev *ldev);

extern void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev);

extern void drbd_device_cleanup(struct drbd_device *device);

void drbd_print_uuids(struct drbd_device *device, const char *text);
@@ -1424,7 +1437,7 @@ extern struct bio_set *drbd_md_io_bio_set; 
/* to allocate from that set */

extern struct bio *bio_alloc_drbd(gfp_t gfp_mask);



extern rwlock_t global_state_lock;

extern struct mutex resources_mutex;



extern int conn_lowest_minor(struct drbd_connection *connection);

extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor);
@@ -1454,6 +1467,9 @@ extern int is_valid_ar_handle(struct drbd_request *, sector_t); 




/* drbd_nl.c */



extern struct mutex notification_mutex;



extern void drbd_suspend_io(struct drbd_device *device);

extern void drbd_resume_io(struct drbd_device *device);

extern char *ppsize(char *buf, unsigned long long size);
@@ -1536,7 +1552,9 @@ extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req); 


/* drbd_receiver.c */

extern int drbd_receiver(struct drbd_thread *thi);

extern int drbd_asender(struct drbd_thread *thi);

extern int drbd_ack_receiver(struct drbd_thread *thi);

extern void drbd_send_ping_wf(struct work_struct *ws);

extern void drbd_send_acks_wf(struct work_struct *ws);

extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);

extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,

		bool throttle_if_app_is_waiting);
@@ -1649,7 +1667,7 @@ extern int __drbd_change_sync(struct drbd_device *device, sector_t sector, int s 
#define drbd_rs_failed_io(device, sector, size) \

	__drbd_change_sync(device, sector, size, RECORD_RS_FAILED)

extern void drbd_al_shrink(struct drbd_device *device);

extern int drbd_initialize_al(struct drbd_device *, void *);

extern int drbd_al_initialize(struct drbd_device *, void *);



/* drbd_nl.c */

/* state info broadcast */
@@ -1668,6 +1686,29 @@ struct sib_info { 
};

void drbd_bcast_event(struct drbd_device *device, const struct sib_info *sib);



extern void notify_resource_state(struct sk_buff *,

				  unsigned int,

				  struct drbd_resource *,

				  struct resource_info *,

				  enum drbd_notification_type);

extern void notify_device_state(struct sk_buff *,

				unsigned int,

				struct drbd_device *,

				struct device_info *,

				enum drbd_notification_type);

extern void notify_connection_state(struct sk_buff *,

				    unsigned int,

				    struct drbd_connection *,

				    struct connection_info *,

				    enum drbd_notification_type);

extern void notify_peer_device_state(struct sk_buff *,

				     unsigned int,

				     struct drbd_peer_device *,

				     struct peer_device_info *,

				     enum drbd_notification_type);

extern void notify_helper(enum drbd_notification_type, struct drbd_device *,

			  struct drbd_connection *, const char *, int);



/*

 * inline helper functions

 *************************/
@@ -1694,19 +1735,6 @@ static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_r 
	return 0;

}



static inline enum drbd_state_rv

_drbd_set_state(struct drbd_device *device, union drbd_state ns,

		enum chg_state_flags flags, struct completion *done)

{

	enum drbd_state_rv rv;



	read_lock(&global_state_lock);

	rv = __drbd_set_state(device, ns, flags, done);

	read_unlock(&global_state_lock);



	return rv;

}



static inline union drbd_state drbd_read_state(struct drbd_device *device)

{

	struct drbd_resource *resource = device->resource;
@@ -1937,16 +1965,21 @@ drbd_device_post_work(struct drbd_device *device, int work_bit) 


extern void drbd_flush_workqueue(struct drbd_work_queue *work_queue);



static inline void wake_asender(struct drbd_connection *connection)

/* To get the ack_receiver out of the blocking network stack,

 * so it can change its sk_rcvtimeo from idle- to ping-timeout,

 * and send a ping, we need to send a signal.

 * Which signal we send is irrelevant. */

static inline void wake_ack_receiver(struct drbd_connection *connection)

{

	if (test_bit(SIGNAL_ASENDER, &connection->flags))

		force_sig(DRBD_SIG, connection->asender.task);

	struct task_struct *task = connection->ack_receiver.task;

	if (task && get_t_state(&connection->ack_receiver) == RUNNING)

		force_sig(SIGXCPU, task);

}



static inline void request_ping(struct drbd_connection *connection)

{

	set_bit(SEND_PING, &connection->flags);

	wake_asender(connection);

	wake_ack_receiver(connection);

}



extern void *conn_prepare_command(struct drbd_connection *, struct drbd_socket *);
@@ -2230,7 +2263,7 @@ static inline bool may_inc_ap_bio(struct drbd_device *device) 


	if (drbd_suspended(device))

		return false;

	if (test_bit(SUSPEND_IO, &device->flags))

	if (atomic_read(&device->suspend_cnt))

		return false;



	/* to avoid potential deadlock or bitmap corruption,

CRA Git | Maintained and supported by SUSTech CRA and CCSE