Merge branch 'for-jens' of git://git.drbd.org/linux-2.6-drbd into for-2.6.37/drivers (53c2eb24) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/block/drbd/drbd_actlog.c

+23 −19

Original line number	Diff line number	Diff line
		@@ -78,11 +78,10 @@ static int _drbd_md_sync_page_io(struct drbd_conf *mdev,
		init_completion(&md_io.event);
		md_io.error = 0;

		if ((rw & WRITE) && !test_bit(MD_NO_BARRIER, &mdev->flags))
		rw \|= REQ_HARDBARRIER;
		if ((rw & WRITE) && !test_bit(MD_NO_FUA, &mdev->flags))
		rw \|= REQ_FUA;
		rw \|= REQ_UNPLUG \| REQ_SYNC;

		retry:
		bio = bio_alloc(GFP_NOIO, 1);
		bio->bi_bdev = bdev->md_bdev;
		bio->bi_sector = sector;
		@@ -100,17 +99,6 @@ static int _drbd_md_sync_page_io(struct drbd_conf *mdev,
		wait_for_completion(&md_io.event);
		ok = bio_flagged(bio, BIO_UPTODATE) && md_io.error == 0;

		/* check for unsupported barrier op.
		* would rather check on EOPNOTSUPP, but that is not reliable.
		* don't try again for ANY return value != 0 */
		if (unlikely((bio->bi_rw & REQ_HARDBARRIER) && !ok)) {
		/* Try again with no barrier */
		dev_warn(DEV, "Barriers not supported on meta data device - disabling\n");
		set_bit(MD_NO_BARRIER, &mdev->flags);
		rw &= ~REQ_HARDBARRIER;
		bio_put(bio);
		goto retry;
		}
		out:
		bio_put(bio);
		return ok;
		@@ -284,18 +272,32 @@ w_al_write_transaction(struct drbd_conf mdev, struct drbd_work w, int unused)
		u32 xor_sum = 0;

		if (!get_ldev(mdev)) {
		dev_err(DEV, "get_ldev() failed in w_al_write_transaction\n");
		dev_err(DEV,
		"disk is %s, cannot start al transaction (-%d +%d)\n",
		drbd_disk_str(mdev->state.disk), evicted, new_enr);
		complete(&((struct update_al_work *)w)->event);
		return 1;
		}
		/* do we have to do a bitmap write, first?
		* TODO reduce maximum latency:
		* submit both bios, then wait for both,
		* instead of doing two synchronous sector writes. */
		* instead of doing two synchronous sector writes.
		* For now, we must not write the transaction,
		* if we cannot write out the bitmap of the evicted extent. */
		if (mdev->state.conn < C_CONNECTED && evicted != LC_FREE)
		drbd_bm_write_sect(mdev, evicted/AL_EXT_PER_BM_SECT);

		mutex_lock(&mdev->md_io_mutex); /* protects md_io_page, al_tr_cycle, ... */
		/* The bitmap write may have failed, causing a state change. */
		if (mdev->state.disk < D_INCONSISTENT) {
		dev_err(DEV,
		"disk is %s, cannot write al transaction (-%d +%d)\n",
		drbd_disk_str(mdev->state.disk), evicted, new_enr);
		complete(&((struct update_al_work *)w)->event);
		put_ldev(mdev);
		return 1;
		}

		mutex_lock(&mdev->md_io_mutex); /* protects md_io_buffer, al_tr_cycle, ... */
		buffer = (struct al_transaction *)page_address(mdev->md_io_page);

		buffer->magic = __constant_cpu_to_be32(DRBD_MAGIC);
		@@ -739,7 +741,7 @@ void drbd_al_apply_to_bm(struct drbd_conf *mdev)
		unsigned int enr;
		unsigned long add = 0;
		char ppb[10];
		int i;
		int i, tmp;

		wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));

		@@ -747,7 +749,9 @@ void drbd_al_apply_to_bm(struct drbd_conf *mdev)
		enr = lc_element_by_index(mdev->act_log, i)->lc_number;
		if (enr == LC_FREE)
		continue;
		add += drbd_bm_ALe_set_all(mdev, enr);
		tmp = drbd_bm_ALe_set_all(mdev, enr);
		dynamic_dev_dbg(DEV, "AL: set %d bits in extent %u\n", tmp, enr);
		add += tmp;
		}

		lc_unlock(mdev->act_log);

drivers/block/drbd/drbd_int.h

+23 −27

Original line number	Diff line number	Diff line
		@@ -116,7 +116,7 @@ struct drbd_conf;

		#define ERR_IF(exp) if (({ \
		int _b = (exp) != 0; \
		if (_b) dev_err(DEV, "%s: (%s) in %s:%d\n", \
		if (_b) dev_err(DEV, "ASSERT FAILED: %s: (%s) in %s:%d\n", \
		__func__, #exp, __FILE__, __LINE__); \
		_b; \
		}))
		@@ -749,17 +749,12 @@ struct drbd_epoch {

		/* drbd_epoch flag bits */
		enum {
		DE_BARRIER_IN_NEXT_EPOCH_ISSUED,
		DE_BARRIER_IN_NEXT_EPOCH_DONE,
		DE_CONTAINS_A_BARRIER,
		DE_HAVE_BARRIER_NUMBER,
		DE_IS_FINISHING,
		};

		enum epoch_event {
		EV_PUT,
		EV_GOT_BARRIER_NR,
		EV_BARRIER_DONE,
		EV_BECAME_LAST,
		EV_CLEANUP = 32, /* used as flag */
		};
		@@ -801,11 +796,6 @@ enum {
		__EE_CALL_AL_COMPLETE_IO,
		__EE_MAY_SET_IN_SYNC,

		/* This epoch entry closes an epoch using a barrier.
		* On sucessful completion, the epoch is released,
		* and the P_BARRIER_ACK send. */
		__EE_IS_BARRIER,

		/* In case a barrier failed,
		* we need to resubmit without the barrier flag. */
		__EE_RESUBMITTED,
		@@ -820,7 +810,6 @@ enum {
		};
		#define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO)
		#define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC)
		#define EE_IS_BARRIER (1<<__EE_IS_BARRIER)
		#define EE_RESUBMITTED (1<<__EE_RESUBMITTED)
		#define EE_WAS_ERROR (1<<__EE_WAS_ERROR)
		#define EE_HAS_DIGEST (1<<__EE_HAS_DIGEST)
		@@ -843,16 +832,15 @@ enum {
		* Gets cleared when the state.conn
		* goes into C_CONNECTED state. */
		WRITE_BM_AFTER_RESYNC, /* A kmalloc() during resync failed */
		NO_BARRIER_SUPP, /* underlying block device doesn't implement barriers */
		CONSIDER_RESYNC,

		MD_NO_BARRIER, /* meta data device does not support barriers,
		so don't even try */
		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 */
		GO_DISKLESS, /* Disk failed, local_cnt reached zero, we are going diskless */
		GO_DISKLESS, /* Disk is being detached, on io-error or admin request. */
		WAS_IO_ERROR, /* Local disk failed returned IO error */
		RESYNC_AFTER_NEG, /* Resync after online grow after the attach&negotiate finished. */
		NET_CONGESTED, /* The data socket is congested */

		@@ -947,7 +935,6 @@ enum write_ordering_e {
		WO_none,
		WO_drain_io,
		WO_bdev_flush,
		WO_bio_barrier
		};

		struct fifo_buffer {
		@@ -1281,6 +1268,7 @@ extern int drbd_bmio_set_n_write(struct drbd_conf *mdev);
		extern int drbd_bmio_clear_n_write(struct drbd_conf *mdev);
		extern int drbd_bitmap_io(struct drbd_conf mdev, int (io_fn)(struct drbd_conf ), char why);
		extern void drbd_go_diskless(struct drbd_conf *mdev);
		extern void drbd_ldev_destroy(struct drbd_conf *mdev);


		/* Meta data layout
		@@ -1798,17 +1786,17 @@ static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach,
		case EP_PASS_ON:
		if (!forcedetach) {
		if (__ratelimit(&drbd_ratelimit_state))
		dev_err(DEV, "Local IO failed in %s."
		"Passing error on...\n", where);
		dev_err(DEV, "Local IO failed in %s.\n", where);
		break;
		}
		/* NOTE fall through to detach case if forcedetach set */
		case EP_DETACH:
		case EP_CALL_HELPER:
		set_bit(WAS_IO_ERROR, &mdev->flags);
		if (mdev->state.disk > D_FAILED) {
		_drbd_set_state(_NS(mdev, disk, D_FAILED), CS_HARD, NULL);
		dev_err(DEV, "Local IO failed in %s."
		"Detaching...\n", where);
		dev_err(DEV,
		"Local IO failed in %s. Detaching...\n", where);
		}
		break;
		}
		@@ -2127,7 +2115,11 @@ static inline void put_ldev(struct drbd_conf *mdev)
		__release(local);
		D_ASSERT(i >= 0);
		if (i == 0) {
		if (mdev->state.disk == D_DISKLESS)
		/* even internal references gone, safe to destroy */
		drbd_ldev_destroy(mdev);
		if (mdev->state.disk == D_FAILED)
		/* all application IO references gone. */
		drbd_go_diskless(mdev);
		wake_up(&mdev->misc_wait);
		}
		@@ -2138,6 +2130,10 @@ static inline int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_stat
		{
		int io_allowed;

		/* never get a reference while D_DISKLESS */
		if (mdev->state.disk == D_DISKLESS)
		return 0;

		atomic_inc(&mdev->local_cnt);
		io_allowed = (mdev->state.disk >= mins);
		if (!io_allowed)
		@@ -2406,12 +2402,12 @@ static inline void drbd_md_flush(struct drbd_conf *mdev)
		{
		int r;

		if (test_bit(MD_NO_BARRIER, &mdev->flags))
		if (test_bit(MD_NO_FUA, &mdev->flags))
		return;

		r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL);
		if (r) {
		set_bit(MD_NO_BARRIER, &mdev->flags);
		set_bit(MD_NO_FUA, &mdev->flags);
		dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r);
		}
		}

drivers/block/drbd/drbd_main.c

+85 −63

Original line number	Diff line number	Diff line
		@@ -835,6 +835,15 @@ static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state
		ns.conn != C_UNCONNECTED && ns.conn != C_DISCONNECTING && ns.conn <= C_TEAR_DOWN)
		ns.conn = os.conn;

		/* we cannot fail (again) if we already detached */
		if (ns.disk == D_FAILED && os.disk == D_DISKLESS)
		ns.disk = D_DISKLESS;

		/* if we are only D_ATTACHING yet,
		* we can (and should) go directly to D_DISKLESS. */
		if (ns.disk == D_FAILED && os.disk == D_ATTACHING)
		ns.disk = D_DISKLESS;

		/* After C_DISCONNECTING only C_STANDALONE may follow */
		if (os.conn == C_DISCONNECTING && ns.conn != C_STANDALONE)
		ns.conn = os.conn;
		@@ -1056,7 +1065,15 @@ int __drbd_set_state(struct drbd_conf *mdev,
		!test_and_set_bit(CONFIG_PENDING, &mdev->flags))
		set_bit(DEVICE_DYING, &mdev->flags);

		mdev->state.i = ns.i;
		/* if we are going -> D_FAILED or D_DISKLESS, grab one extra reference
		* on the ldev here, to be sure the transition -> D_DISKLESS resp.
		* drbd_ldev_destroy() won't happen before our corresponding
		* after_state_ch works run, where we put_ldev again. */
		if ((os.disk != D_FAILED && ns.disk == D_FAILED) \|\|
		(os.disk != D_DISKLESS && ns.disk == D_DISKLESS))
		atomic_inc(&mdev->local_cnt);

		mdev->state = ns;
		wake_up(&mdev->misc_wait);
		wake_up(&mdev->state_wait);

		@@ -1268,7 +1285,6 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
		if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
		drbd_uuid_new_current(mdev);
		clear_bit(NEW_CUR_UUID, &mdev->flags);
		drbd_md_sync(mdev);
		}
		spin_lock_irq(&mdev->req_lock);
		_drbd_set_state(_NS(mdev, susp_fen, 0), CS_VERBOSE, NULL);
		@@ -1365,35 +1381,46 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
		os.disk > D_INCONSISTENT && ns.disk == D_INCONSISTENT)
		drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL, "set_n_write from invalidate");

		/* first half of local IO error */
		if (os.disk > D_FAILED && ns.disk == D_FAILED) {
		enum drbd_io_error_p eh = EP_PASS_ON;
		/* first half of local IO error, failure to attach,
		* or administrative detach */
		if (os.disk != D_FAILED && ns.disk == D_FAILED) {
		enum drbd_io_error_p eh;
		int was_io_error;
		/* corresponding get_ldev was in __drbd_set_state, to serialize
		* our cleanup here with the transition to D_DISKLESS,
		* so it is safe to dreference ldev here. */
		eh = mdev->ldev->dc.on_io_error;
		was_io_error = test_and_clear_bit(WAS_IO_ERROR, &mdev->flags);

		/* current state still has to be D_FAILED,
		* there is only one way out: to D_DISKLESS,
		* and that may only happen after our put_ldev below. */
		if (mdev->state.disk != D_FAILED)
		dev_err(DEV,
		"ASSERT FAILED: disk is %s during detach\n",
		drbd_disk_str(mdev->state.disk));

		if (drbd_send_state(mdev))
		dev_warn(DEV, "Notified peer that my disk is broken.\n");
		dev_warn(DEV, "Notified peer that I am detaching my disk\n");
		else
		dev_err(DEV, "Sending state for drbd_io_error() failed\n");
		dev_err(DEV, "Sending state for detaching disk failed\n");

		drbd_rs_cancel_all(mdev);

		if (get_ldev_if_state(mdev, D_FAILED)) {
		eh = mdev->ldev->dc.on_io_error;
		/* In case we want to get something to stable storage still,
		* this may be the last chance.
		* Following put_ldev may transition to D_DISKLESS. */
		drbd_md_sync(mdev);
		put_ldev(mdev);
		}
		if (eh == EP_CALL_HELPER)
		drbd_khelper(mdev, "local-io-error");
		}


		/* second half of local IO error handling,
		* after local_cnt references have reached zero: */
		if (os.disk == D_FAILED && ns.disk == D_DISKLESS) {
		mdev->rs_total = 0;
		mdev->rs_failed = 0;
		atomic_set(&mdev->rs_pending_cnt, 0);
		if (was_io_error && eh == EP_CALL_HELPER)
		drbd_khelper(mdev, "local-io-error");
		}

		if (os.disk > D_DISKLESS && ns.disk == D_DISKLESS) {
		/* second half of local IO error, failure to attach,
		* or administrative detach,
		* after local_cnt references have reached zero again */
		if (os.disk != D_DISKLESS && ns.disk == D_DISKLESS) {
		/* We must still be diskless,
		* re-attach has to be serialized with this! */
		if (mdev->state.disk != D_DISKLESS)
		@@ -1401,27 +1428,17 @@ static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
		"ASSERT FAILED: disk is %s while going diskless\n",
		drbd_disk_str(mdev->state.disk));

		/* we cannot assert local_cnt == 0 here, as get_ldev_if_state
		* will inc/dec it frequently. Since we became D_DISKLESS, no
		* one has touched the protected members anymore, though, so we
		* are safe to free them here. */
		mdev->rs_total = 0;
		mdev->rs_failed = 0;
		atomic_set(&mdev->rs_pending_cnt, 0);

		if (drbd_send_state(mdev))
		dev_warn(DEV, "Notified peer that I detached my disk.\n");
		dev_warn(DEV, "Notified peer that I'm now diskless.\n");
		else
		dev_err(DEV, "Sending state for detach failed\n");

		lc_destroy(mdev->resync);
		mdev->resync = NULL;
		lc_destroy(mdev->act_log);
		mdev->act_log = NULL;
		__no_warn(local,
		drbd_free_bc(mdev->ldev);
		mdev->ldev = NULL;);

		if (mdev->md_io_tmpp) {
		__free_page(mdev->md_io_tmpp);
		mdev->md_io_tmpp = NULL;
		}
		dev_err(DEV, "Sending state for being diskless failed\n");
		/* corresponding get_ldev in __drbd_set_state
		* this may finaly trigger drbd_ldev_destroy. */
		put_ldev(mdev);
		}

		/* Disks got bigger while they were detached */
		@@ -2772,11 +2789,6 @@ void drbd_init_set_defaults(struct drbd_conf *mdev)

		drbd_set_defaults(mdev);

		/* for now, we do NOT yet support it,
		* even though we start some framework
		* to eventually support barriers */
		set_bit(NO_BARRIER_SUPP, &mdev->flags);

		atomic_set(&mdev->ap_bio_cnt, 0);
		atomic_set(&mdev->ap_pending_cnt, 0);
		atomic_set(&mdev->rs_pending_cnt, 0);
		@@ -2842,7 +2854,7 @@ void drbd_init_set_defaults(struct drbd_conf *mdev)
		drbd_thread_init(mdev, &mdev->asender, drbd_asender);

		mdev->agreed_pro_version = PRO_VERSION_MAX;
		mdev->write_ordering = WO_bio_barrier;
		mdev->write_ordering = WO_bdev_flush;
		mdev->resync_wenr = LC_FREE;
		}

		@@ -2899,7 +2911,6 @@ void drbd_mdev_cleanup(struct drbd_conf *mdev)
		D_ASSERT(list_empty(&mdev->resync_work.list));
		D_ASSERT(list_empty(&mdev->unplug_work.list));
		D_ASSERT(list_empty(&mdev->go_diskless.list));

		}


		@@ -3660,6 +3671,8 @@ void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)

		get_random_bytes(&val, sizeof(u64));
		_drbd_uuid_set(mdev, UI_CURRENT, val);
		/* get it to stable storage _now_ */
		drbd_md_sync(mdev);
		}

		void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
		@@ -3756,19 +3769,31 @@ static int w_bitmap_io(struct drbd_conf mdev, struct drbd_work w, int unused)
		return 1;
		}

		void drbd_ldev_destroy(struct drbd_conf *mdev)
		{
		lc_destroy(mdev->resync);
		mdev->resync = NULL;
		lc_destroy(mdev->act_log);
		mdev->act_log = NULL;
		__no_warn(local,
		drbd_free_bc(mdev->ldev);
		mdev->ldev = NULL;);

		if (mdev->md_io_tmpp) {
		__free_page(mdev->md_io_tmpp);
		mdev->md_io_tmpp = NULL;
		}
		clear_bit(GO_DISKLESS, &mdev->flags);
		}

		static int w_go_diskless(struct drbd_conf mdev, struct drbd_work w, int unused)
		{
		D_ASSERT(mdev->state.disk == D_FAILED);
		/* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
		* inc/dec it frequently. Once we are D_DISKLESS, no one will touch
		* the protected members anymore, though, so in the after_state_ch work
		* it will be safe to free them. */
		* the protected members anymore, though, so once put_ldev reaches zero
		* again, it will be safe to free them. */
		drbd_force_state(mdev, NS(disk, D_DISKLESS));
		/* We need to wait for return of references checked out while we still
		* have been D_FAILED, though (drbd_md_sync, bitmap io). */
		wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));

		clear_bit(GO_DISKLESS, &mdev->flags);
		return 1;
		}

		@@ -3777,9 +3802,6 @@ void drbd_go_diskless(struct drbd_conf *mdev)
		D_ASSERT(mdev->state.disk == D_FAILED);
		if (!test_and_set_bit(GO_DISKLESS, &mdev->flags))
		drbd_queue_work(&mdev->data.work, &mdev->go_diskless);
		/* don't drbd_queue_work_front,
		* we need to serialize with the after_state_ch work
		* of the -> D_FAILED transition. */
		}

		/**

drivers/block/drbd/drbd_nl.c

+19 −6

Original line number	Diff line number	Diff line
		@@ -870,6 +870,11 @@ static int drbd_nl_disk_conf(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		retcode = ERR_DISK_CONFIGURED;
		goto fail;
		}
		/* It may just now have detached because of IO error. Make sure
		* drbd_ldev_destroy is done already, we may end up here very fast,
		* e.g. if someone calls attach from the on-io-error handler,
		* to realize a "hot spare" feature (not that I'd recommend that) */
		wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));

		/* allocation not in the IO path, cqueue thread context */
		nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
		@@ -1098,9 +1103,9 @@ static int drbd_nl_disk_conf(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		/* Reset the "barriers don't work" bits here, then force meta data to
		* be written, to ensure we determine if barriers are supported. */
		if (nbc->dc.no_md_flush)
		set_bit(MD_NO_BARRIER, &mdev->flags);
		set_bit(MD_NO_FUA, &mdev->flags);
		else
		clear_bit(MD_NO_BARRIER, &mdev->flags);
		clear_bit(MD_NO_FUA, &mdev->flags);

		/* Point of no return reached.
		* Devices and memory are no longer released by error cleanup below.
		@@ -1112,8 +1117,8 @@ static int drbd_nl_disk_conf(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		nbc = NULL;
		resync_lru = NULL;

		mdev->write_ordering = WO_bio_barrier;
		drbd_bump_write_ordering(mdev, WO_bio_barrier);
		mdev->write_ordering = WO_bdev_flush;
		drbd_bump_write_ordering(mdev, WO_bdev_flush);

		if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
		set_bit(CRASHED_PRIMARY, &mdev->flags);
		@@ -1262,7 +1267,7 @@ static int drbd_nl_disk_conf(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		force_diskless_dec:
		put_ldev(mdev);
		force_diskless:
		drbd_force_state(mdev, NS(disk, D_DISKLESS));
		drbd_force_state(mdev, NS(disk, D_FAILED));
		drbd_md_sync(mdev);
		release_bdev2_fail:
		if (nbc)
		@@ -1285,10 +1290,19 @@ static int drbd_nl_disk_conf(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		return 0;
		}

		/* Detaching the disk is a process in multiple stages. First we need to lock
		* out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
		* Then we transition to D_DISKLESS, and wait for put_ldev() to return all
		* internal references as well.
		* Only then we have finally detached. */
		static int drbd_nl_detach(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp,
		struct drbd_nl_cfg_reply *reply)
		{
		drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
		reply->ret_code = drbd_request_state(mdev, NS(disk, D_DISKLESS));
		if (mdev->state.disk == D_DISKLESS)
		wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
		drbd_resume_io(mdev);
		return 0;
		}

		@@ -1953,7 +1967,6 @@ static int drbd_nl_resume_io(struct drbd_conf mdev, struct drbd_nl_cfg_req nlp
		if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
		drbd_uuid_new_current(mdev);
		clear_bit(NEW_CUR_UUID, &mdev->flags);
		drbd_md_sync(mdev);
		}
		drbd_suspend_io(mdev);
		reply->ret_code = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));

drivers/block/drbd/drbd_proc.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -158,7 +158,6 @@ static int drbd_seq_show(struct seq_file seq, void v)
		[WO_none] = 'n',
		[WO_drain_io] = 'd',
		[WO_bdev_flush] = 'f',
		[WO_bio_barrier] = 'b',
		};

		seq_printf(seq, "version: " REL_VERSION " (api:%d/proto:%d-%d)\n%s\n",