lael-labs/linux

block/bio.c+4−0

  */
 void bio_clone_blkg_association(struct bio *dst, struct bio *src)
 {
+	rcu_read_lock();
 	if (src->bi_blkg)
 		__bio_associate_blkg(dst, src->bi_blkg);
+	rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(bio_clone_blkg_association);
 #endif /* CONFIG_BLK_CGROUP */

block/blk-cgroup.c+0−23

@@ -438,29 +438,6 @@ static void blkg_destroy_all(struct request_queue *q) · 437 unmodified lines
438	spin_unlock_irq(&q->queue_lock);	438	spin_unlock_irq(&q->queue_lock);
439	}	439	}
440		440
441	/*
442	* A group is RCU protected, but having an rcu lock does not mean that one
443	* can access all the fields of blkg and assume these are valid. For
444	* example, don't try to follow throtl_data and request queue links.
445	*
446	* Having a reference to blkg under an rcu allows accesses to only values
447	* local to groups like group stats and group rate limits.
448	*/
449	void __blkg_release_rcu(struct rcu_head *rcu_head)
450	{
451	struct blkcg_gq *blkg = container_of(rcu_head, struct blkcg_gq, rcu_head);
452
453	/* release the blkcg and parent blkg refs this blkg has been holding */
454	css_put(&blkg->blkcg->css);
455	if (blkg->parent)
456	blkg_put(blkg->parent);
457
458	wb_congested_put(blkg->wb_congested);
459
460	blkg_free(blkg);
461	}
462	EXPORT_SYMBOL_GPL(__blkg_release_rcu);
463
464	static int blkcg_reset_stats(struct cgroup_subsys_state *css,	441	static int blkcg_reset_stats(struct cgroup_subsys_state *css,
465	struct cftype *cftype, u64 val)	442	struct cftype *cftype, u64 val)
466	{	443	{

block/bsg.c+4−0

 			goto out;
 		}
+		pr_warn_once(
+			"BIDI support in bsg has been deprecated and might be removed. "
+			"Please report your use case to linux-scsi@vger.kernel.org\n");
 		next_rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
 		if (IS_ERR(next_rq)) {
 			ret = PTR_ERR(next_rq);

drivers/block/amiflop.c+0−2

 			return p->type->read_size;
 #endif
 	default:
-		printk(KERN_DEBUG "fd_ioctl: unknown cmd %d for drive %d.",
-		       cmd, drive);
 		return -ENOSYS;
 	}
 	return 0;

drivers/block/drbd/drbd_debugfs.c+2−0

 	seq_print_rq_state_bit(m, f & EE_CALL_AL_COMPLETE_IO, &sep, "in-AL");
 	seq_print_rq_state_bit(m, f & EE_SEND_WRITE_ACK, &sep, "C");
 	seq_print_rq_state_bit(m, f & EE_MAY_SET_IN_SYNC, &sep, "set-in-sync");
+	seq_print_rq_state_bit(m, f & EE_TRIM, &sep, "trim");
+	seq_print_rq_state_bit(m, f & EE_ZEROOUT, &sep, "zero-out");
 	seq_print_rq_state_bit(m, f & EE_WRITE_SAME, &sep, "write-same");
 	seq_putc(m, '\n');
 }

drivers/block/drbd/drbd_int.h+10−9

 	__EE_MAY_SET_IN_SYNC,
 	/* is this a TRIM aka REQ_OP_DISCARD? */
-	__EE_IS_TRIM,
+	__EE_TRIM,
+	/* explicit zero-out requested, or
+	 * our lower level cannot handle trim,
+	 * and we want to fall back to zeroout instead */
+	__EE_ZEROOUT,
 	/* In case a barrier failed,
 	 * we need to resubmit without the barrier flag. */
 };
 #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_TRIM             (1<<__EE_IS_TRIM)
+#define EE_TRIM                (1<<__EE_TRIM)
+#define EE_ZEROOUT             (1<<__EE_ZEROOUT)
 #define EE_RESUBMITTED         (1<<__EE_RESUBMITTED)
 #define EE_WAS_ERROR           (1<<__EE_WAS_ERROR)
 #define EE_HAS_DIGEST          (1<<__EE_HAS_DIGEST)
 extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req);
 /* drbd_receiver.c */
+extern int drbd_issue_discard_or_zero_out(struct drbd_device *device,
+		sector_t start, unsigned int nr_sectors, int flags);
 extern int drbd_receiver(struct drbd_thread *thi);
 extern int drbd_ack_receiver(struct drbd_thread *thi);
 extern void drbd_send_ping_wf(struct work_struct *ws);
 }
 /* sets the number of 512 byte sectors of our virtual device */
-static inline void drbd_set_my_capacity(struct drbd_device *device,
+void drbd_set_my_capacity(struct drbd_device *device, sector_t size);
-					sector_t size)
-{
-	/* set_capacity(device->this_bdev->bd_disk, size); */
-	set_capacity(device->vdisk, size);
-	device->this_bdev->bd_inode->i_size = (loff_t)size << 9;
-}
 /*
  * used to submit our private bio

drivers/block/drbd/drbd_main.c+24−4

 			(bio->bi_opf & REQ_PREFLUSH ? DP_FLUSH : 0) |
 			(bio_op(bio) == REQ_OP_WRITE_SAME ? DP_WSAME : 0) |
 			(bio_op(bio) == REQ_OP_DISCARD ? DP_DISCARD : 0) |
-			(bio_op(bio) == REQ_OP_WRITE_ZEROES ? DP_DISCARD : 0);
+			(bio_op(bio) == REQ_OP_WRITE_ZEROES ?
+			  ((connection->agreed_features & DRBD_FF_WZEROES) ?
+			   (DP_ZEROES |(!(bio->bi_opf & REQ_NOUNMAP) ? DP_DISCARD : 0))
+			   : DP_DISCARD)
+			: 0);
 	else
 		return bio->bi_opf & REQ_SYNC ? DP_RW_SYNC : 0;
 }
 	}
 	p->dp_flags = cpu_to_be32(dp_flags);
-	if (dp_flags & DP_DISCARD) {
+	if (dp_flags & (DP_DISCARD|DP_ZEROES)) {
+		enum drbd_packet cmd = (dp_flags & DP_ZEROES) ? P_ZEROES : P_TRIM;
 		struct p_trim *t = (struct p_trim*)p;
 		t->size = cpu_to_be32(req->i.size);
-		err = __send_command(peer_device->connection, device->vnr, sock, P_TRIM, sizeof(*t), NULL, 0);
+		err = __send_command(peer_device->connection, device->vnr, sock, cmd, sizeof(*t), NULL, 0);
 		goto out;
 	}
 	if (dp_flags & DP_WSAME) {
 	device->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
 }
+static void _drbd_set_my_capacity(struct drbd_device *device, sector_t size)
+{
+	/* set_capacity(device->this_bdev->bd_disk, size); */
+	set_capacity(device->vdisk, size);
+	device->this_bdev->bd_inode->i_size = (loff_t)size << 9;
+}
+void drbd_set_my_capacity(struct drbd_device *device, sector_t size)
+{
+	char ppb[10];
+	_drbd_set_my_capacity(device, size);
+	drbd_info(device, "size = %s (%llu KB)\n",
+		ppsize(ppb, size>>1), (unsigned long long)size>>1);
+}
 void drbd_device_cleanup(struct drbd_device *device)
 {
 	int i;
 	}
 	D_ASSERT(device, first_peer_device(device)->connection->net_conf == NULL);
-	drbd_set_my_capacity(device, 0);
+	_drbd_set_my_capacity(device, 0);
 	if (device->bitmap) {
 		/* maybe never allocated. */
 		drbd_bm_resize(device, 0, 1);

drivers/block/drbd/drbd_nl.c+107−26

 	return 0;
 }
+__printf(2, 3)
+static int drbd_msg_sprintf_info(struct sk_buff *skb, const char *fmt, ...)
+{
+	va_list args;
+	struct nlattr *nla, *txt;
+	int err = -EMSGSIZE;
+	int len;
+	nla = nla_nest_start(skb, DRBD_NLA_CFG_REPLY);
+	if (!nla)
+		return err;
+	txt = nla_reserve(skb, T_info_text, 256);
+	if (!txt) {
+		nla_nest_cancel(skb, nla);
+		return err;
+	}
+	va_start(args, fmt);
+	len = vscnprintf(nla_data(txt), 256, fmt, args);
+	va_end(args);
+	/* maybe: retry with larger reserve, if truncated */
+	txt->nla_len = nla_attr_size(len+1);
+	nlmsg_trim(skb, (char*)txt + NLA_ALIGN(txt->nla_len));
+	nla_nest_end(skb, nla);
+	return 0;
+}
 /* This would be a good candidate for a "pre_doit" hook,
  * and per-family private info->pointers.
  * But we need to stay compatible with older kernels.
 		if (rv == SS_TWO_PRIMARIES) {
 			/* Maybe the peer is detected as dead very soon...
 			   retry at most once more in this case. */
-			int timeo;
+			if (try < max_tries) {
-			rcu_read_lock();
+				int timeo;
-			nc = rcu_dereference(connection->net_conf);
-			timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
-			rcu_read_unlock();
-			schedule_timeout_interruptible(timeo);
-			if (try < max_tries)
 				try = max_tries - 1;
+				rcu_read_lock();
+				nc = rcu_dereference(connection->net_conf);
+				timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
+				rcu_read_unlock();
+				schedule_timeout_interruptible(timeo);
+			}
 			continue;
 		}
 		if (rv < SS_SUCCESS) {
 	} prev;
 	sector_t u_size, size;
 	struct drbd_md *md = &device->ldev->md;
-	char ppb[10];
 	void *buffer;
 	int md_moved, la_size_changed;
 		/* racy, see comments above. */
 		drbd_set_my_capacity(device, size);
 		md->la_size_sect = size;
-		drbd_info(device, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
-		     (unsigned long long)size>>1);
 	}
 	if (rv <= DS_ERROR)
 		goto err_out;
 	}
 }
+static void fixup_write_zeroes(struct drbd_device *device, struct request_queue *q)
+{
+	/* Fixup max_write_zeroes_sectors after blk_queue_stack_limits():
+	 * if we can handle "zeroes" efficiently on the protocol,
+	 * we want to do that, even if our backend does not announce
+	 * max_write_zeroes_sectors itself. */
+	struct drbd_connection *connection = first_peer_device(device)->connection;
+	/* If the peer announces WZEROES support, use it.  Otherwise, rather
+	 * send explicit zeroes than rely on some discard-zeroes-data magic. */
+	if (connection->agreed_features & DRBD_FF_WZEROES)
+		q->limits.max_write_zeroes_sectors = DRBD_MAX_BBIO_SECTORS;
+	else
+		q->limits.max_write_zeroes_sectors = 0;
+}
 static void decide_on_write_same_support(struct drbd_device *device,
 			struct request_queue *q,
 			struct request_queue *b, struct o_qlim *o,
 		}
 	}
 	fixup_discard_if_not_supported(q);
+	fixup_write_zeroes(device, q);
 }
 void drbd_reconsider_queue_parameters(struct drbd_device *device, struct drbd_backing_dev *bdev, struct o_qlim *o)
 	}
 }
+static int disk_opts_check_al_size(struct drbd_device *device, struct disk_conf *dc)
+{
+	int err = -EBUSY;
+	if (device->act_log &&
+	    device->act_log->nr_elements == dc->al_extents)
+		return 0;
+	drbd_suspend_io(device);
+	/* If IO completion is currently blocked, we would likely wait
+	 * "forever" for the activity log to become unused. So we don't. */
+	if (atomic_read(&device->ap_bio_cnt))
+		goto out;
+	wait_event(device->al_wait, lc_try_lock(device->act_log));
+	drbd_al_shrink(device);
+	err = drbd_check_al_size(device, dc);
+	lc_unlock(device->act_log);
+	wake_up(&device->al_wait);
+out:
+	drbd_resume_io(device);
+	return err;
+}
 int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
 {
 	struct drbd_config_context adm_ctx;
 		}
 	}
-	drbd_suspend_io(device);
+	err = disk_opts_check_al_size(device, new_disk_conf);
-	wait_event(device->al_wait, lc_try_lock(device->act_log));
-	drbd_al_shrink(device);
-	err = drbd_check_al_size(device, new_disk_conf);
-	lc_unlock(device->act_log);
-	wake_up(&device->al_wait);
-	drbd_resume_io(device);
 	if (err) {
+		/* Could be just "busy". Ignore?
+		 * Introduce dedicated error code? */
+		drbd_msg_put_info(adm_ctx.reply_skb,
+			"Try again without changing current al-extents setting");
 		retcode = ERR_NOMEM;
 		goto fail_unlock;
 	}
 		}
 	}
-	if (device->state.conn < C_CONNECTED &&
+	if (device->state.pdsk != D_UP_TO_DATE && device->ed_uuid &&
-	    device->state.role == R_PRIMARY && device->ed_uuid &&
+	    (device->state.role == R_PRIMARY || device->state.peer == R_PRIMARY) &&
-	    (device->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
+            (device->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
 		drbd_err(device, "Can only attach to data with current UUID=%016llX\n",
 		    (unsigned long long)device->ed_uuid);
 		retcode = ERR_DATA_NOT_CURRENT;
 	}
 	/* Prevent shrinking of consistent devices ! */
-	if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
+	{
-	    drbd_new_dev_size(device, nbc, nbc->disk_conf->disk_size, 0) < nbc->md.la_size_sect) {
+	unsigned long long nsz = drbd_new_dev_size(device, nbc, nbc->disk_conf->disk_size, 0);
-		drbd_warn(device, "refusing to truncate a consistent device\n");
+	unsigned long long eff = nbc->md.la_size_sect;
-		retcode = ERR_DISK_TOO_SMALL;
+	if (drbd_md_test_flag(nbc, MDF_CONSISTENT) && nsz < eff) {
-		goto force_diskless_dec;
+		if (nsz == nbc->disk_conf->disk_size) {
+			drbd_warn(device, "truncating a consistent device during attach (%llu < %llu)\n", nsz, eff);
+		} else {
+			drbd_warn(device, "refusing to truncate a consistent device (%llu < %llu)\n", nsz, eff);
+			drbd_msg_sprintf_info(adm_ctx.reply_skb,
+				"To-be-attached device has last effective > current size, and is consistent\n"
+				"(%llu > %llu sectors). Refusing to attach.", eff, nsz);
+			retcode = ERR_IMPLICIT_SHRINK;
+			goto force_diskless_dec;
+		}
+	}
 	}
 	lock_all_resources();
 static enum drbd_state_rv conn_try_disconnect(struct drbd_connection *connection, bool force)
 {
+	enum drbd_conns cstate;
 	enum drbd_state_rv rv;
+repeat:
 	rv = conn_request_state(connection, NS(conn, C_DISCONNECTING),
 			force ? CS_HARD : 0);
 		break;
 	case SS_CW_FAILED_BY_PEER:
+		spin_lock_irq(&connection->resource->req_lock);
+		cstate = connection->cstate;
+		spin_unlock_irq(&connection->resource->req_lock);
+		if (cstate <= C_WF_CONNECTION)
+			goto repeat;
 		/* The peer probably wants to see us outdated. */
 		rv = conn_request_state(connection, NS2(conn, C_DISCONNECTING,
 							disk, D_OUTDATED), 0);

drivers/block/drbd/drbd_protocol.h+47−0

@@ -70,6 +70,11 @@ enum drbd_packet { · 69 unmodified lines
70	* we may fall back to an opencoded loop instead. */	70	* we may fall back to an opencoded loop instead. */
71	P_WSAME = 0x34,	71	P_WSAME = 0x34,
72		72
		73	/* 0x35 already claimed in DRBD 9 */
		74	P_ZEROES = 0x36, /* data sock: zero-out, WRITE_ZEROES */
		75
		76	/* 0x40 .. 0x48 already claimed in DRBD 9 */
		77
73	P_MAY_IGNORE = 0x100, /* Flag to test if (cmd > P_MAY_IGNORE) ... */	78	P_MAY_IGNORE = 0x100, /* Flag to test if (cmd > P_MAY_IGNORE) ... */
74	P_MAX_OPT_CMD = 0x101,	79	P_MAX_OPT_CMD = 0x101,
75		80
@@ -130,6 +135,12 @@ struct p_header100 { · 54 unmodified lines
130	#define DP_SEND_RECEIVE_ACK 128 /* This is a proto B write request */	135	#define DP_SEND_RECEIVE_ACK 128 /* This is a proto B write request */
131	#define DP_SEND_WRITE_ACK 256 /* This is a proto C write request */	136	#define DP_SEND_WRITE_ACK 256 /* This is a proto C write request */
132	#define DP_WSAME 512 /* equiv. REQ_WRITE_SAME */	137	#define DP_WSAME 512 /* equiv. REQ_WRITE_SAME */
		138	#define DP_ZEROES 1024 /* equiv. REQ_OP_WRITE_ZEROES */
		139
		140	/* possible combinations:
		141	* REQ_OP_WRITE_ZEROES: DP_DISCARD \| DP_ZEROES
		142	* REQ_OP_WRITE_ZEROES + REQ_NOUNMAP: DP_ZEROES
		143	*/
133		144
134	struct p_data {	145	struct p_data {
135	u64 sector; /* 64 bits sector number */	146	u64 sector; /* 64 bits sector number */
@@ -197,6 +208,42 @@ struct p_block_req { · 61 unmodified lines
197	*/	208	*/
198	#define DRBD_FF_WSAME 4	209	#define DRBD_FF_WSAME 4
199		210
		211	/* supports REQ_OP_WRITE_ZEROES on the "wire" protocol.
		212	*
		213	* We used to map that to "discard" on the sending side, and if we cannot
		214	* guarantee that discard zeroes data, the receiving side would map discard
		215	* back to zero-out.
		216	*
		217	* With the introduction of REQ_OP_WRITE_ZEROES,
		218	* we started to use that for both WRITE_ZEROES and DISCARDS,
		219	* hoping that WRITE_ZEROES would "do what we want",
		220	* UNMAP if possible, zero-out the rest.
		221	*
		222	* The example scenario is some LVM "thin" backend.
		223	*
		224	* While an un-allocated block on dm-thin reads as zeroes, on a dm-thin
		225	* with "skip_block_zeroing=true", after a partial block write allocated
		226	* that block, that same block may well map "undefined old garbage" from
		227	* the backends on LBAs that have not yet been written to.
		228	*
		229	* If we cannot distinguish between zero-out and discard on the receiving
		230	* side, to avoid "undefined old garbage" to pop up randomly at later times
		231	* on supposedly zero-initialized blocks, we'd need to map all discards to
		232	* zero-out on the receiving side. But that would potentially do a full
		233	* alloc on thinly provisioned backends, even when the expectation was to
		234	* unmap/trim/discard/de-allocate.
		235	*
		236	* We need to distinguish on the protocol level, whether we need to guarantee
		237	* zeroes (and thus use zero-out, potentially doing the mentioned full-alloc),
		238	* or if we want to put the emphasis on discard, and only do a "best effort
		239	* zeroing" (by "discarding" blocks aligned to discard-granularity, and zeroing
		240	* only potential unaligned head and tail clippings), to at least try to
		241	* avoid "false positives" in an online-verify later, hoping that someone
		242	* set skip_block_zeroing=false.
		243	*/
		244	#define DRBD_FF_WZEROES 8
		245
		246
200	struct p_connection_features {	247	struct p_connection_features {
201	u32 protocol_min;	248	u32 protocol_min;
202	u32 feature_flags;	249	u32 feature_flags;

drivers/block/drbd/drbd_receiver.c+220−31

@@ -50,7 +50,7 @@ · 49 unmodified lines
50	#include "drbd_req.h"	50	#include "drbd_req.h"
51	#include "drbd_vli.h"	51	#include "drbd_vli.h"
52		52
53	#define PRO_FEATURES (DRBD_FF_TRIM\|DRBD_FF_THIN_RESYNC\|DRBD_FF_WSAME)	53	#define PRO_FEATURES (DRBD_FF_TRIM\|DRBD_FF_THIN_RESYNC\|DRBD_FF_WSAME\|DRBD_FF_WZEROES)
54		54
55	struct packet_info {	55	struct packet_info {
56	enum drbd_packet cmd;	56	enum drbd_packet cmd;
@@ -1490,14 +1490,129 @@ void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backin · 1433 unmodified lines
1490	drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]);	1490	drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]);
1491	}	1491	}
1492		1492
1493	static void drbd_issue_peer_discard(struct drbd_device device, struct drbd_peer_request peer_req)	1493	/*
		1494	* Mapping "discard" to ZEROOUT with UNMAP does not work for us:
		1495	* Drivers have to "announce" q->limits.max_write_zeroes_sectors, or it
		1496	* will directly go to fallback mode, submitting normal writes, and
		1497	* never even try to UNMAP.
		1498	*
		1499	* And dm-thin does not do this (yet), mostly because in general it has
		1500	* to assume that "skip_block_zeroing" is set. See also:
		1501	* https://www.mail-archive.com/dm-devel%40redhat.com/msg07965.html
		1502	* https://www.redhat.com/archives/dm-devel/2018-January/msg00271.html
		1503	*
		1504	* We may ignore the discard-zeroes-data setting, if so configured.
		1505	*
		1506	* Assumption is that this "discard_zeroes_data=0" is only because the backend
		1507	* may ignore partial unaligned discards.
		1508	*
		1509	* LVM/DM thin as of at least
		1510	* LVM version: 2.02.115(2)-RHEL7 (2015-01-28)
		1511	* Library version: 1.02.93-RHEL7 (2015-01-28)
		1512	* Driver version: 4.29.0
		1513	* still behaves this way.
		1514	*
		1515	* For unaligned (wrt. alignment and granularity) or too small discards,
		1516	* we zero-out the initial (and/or) trailing unaligned partial chunks,
		1517	* but discard all the aligned full chunks.
		1518	*
		1519	* At least for LVM/DM thin, with skip_block_zeroing=false,
		1520	* the result is effectively "discard_zeroes_data=1".
		1521	*/
		1522	/* flags: EE_TRIM\|EE_ZEROOUT */
		1523	int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, unsigned int nr_sectors, int flags)
1494	{	1524	{
1495	struct block_device *bdev = device->ldev->backing_bdev;	1525	struct block_device *bdev = device->ldev->backing_bdev;
		1526	struct request_queue *q = bdev_get_queue(bdev);
		1527	sector_t tmp, nr;
		1528	unsigned int max_discard_sectors, granularity;
		1529	int alignment;
		1530	int err = 0;
1496		1531
1497	if (blkdev_issue_zeroout(bdev, peer_req->i.sector, peer_req->i.size >> 9,	1532	if ((flags & EE_ZEROOUT) \|\| !(flags & EE_TRIM))
1498	GFP_NOIO, 0))	1533	goto zero_out;
1499	peer_req->flags \|= EE_WAS_ERROR;	1534
		1535	/* Zero-sector (unknown) and one-sector granularities are the same. */
		1536	granularity = max(q->limits.discard_granularity >> 9, 1U);
		1537	alignment = (bdev_discard_alignment(bdev) >> 9) % granularity;
		1538
		1539	max_discard_sectors = min(q->limits.max_discard_sectors, (1U << 22));
		1540	max_discard_sectors -= max_discard_sectors % granularity;
		1541	if (unlikely(!max_discard_sectors))
		1542	goto zero_out;
		1543
		1544	if (nr_sectors < granularity)
		1545	goto zero_out;
		1546
		1547	tmp = start;
		1548	if (sector_div(tmp, granularity) != alignment) {
		1549	if (nr_sectors < 2*granularity)
		1550	goto zero_out;
		1551	/* start + gran - (start + gran - align) % gran */
		1552	tmp = start + granularity - alignment;
		1553	tmp = start + granularity - sector_div(tmp, granularity);
		1554
		1555	nr = tmp - start;
		1556	/* don't flag BLKDEV_ZERO_NOUNMAP, we don't know how many
		1557	* layers are below us, some may have smaller granularity */
		1558	err \|= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIO, 0);
		1559	nr_sectors -= nr;
		1560	start = tmp;
		1561	}
		1562	while (nr_sectors >= max_discard_sectors) {
		1563	err \|= blkdev_issue_discard(bdev, start, max_discard_sectors, GFP_NOIO, 0);
		1564	nr_sectors -= max_discard_sectors;
		1565	start += max_discard_sectors;
		1566	}
		1567	if (nr_sectors) {
		1568	/* max_discard_sectors is unsigned int (and a multiple of
		1569	* granularity, we made sure of that above already);
		1570	* nr is < max_discard_sectors;
		1571	* I don't need sector_div here, even though nr is sector_t */
		1572	nr = nr_sectors;
		1573	nr -= (unsigned int)nr % granularity;
		1574	if (nr) {
		1575	err \|= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, 0);
		1576	nr_sectors -= nr;
		1577	start += nr;
		1578	}
		1579	}
		1580	zero_out:
		1581	if (nr_sectors) {
		1582	err \|= blkdev_issue_zeroout(bdev, start, nr_sectors, GFP_NOIO,
		1583	(flags & EE_TRIM) ? 0 : BLKDEV_ZERO_NOUNMAP);
		1584	}
		1585	return err != 0;
		1586	}
1500		1587
		1588	static bool can_do_reliable_discards(struct drbd_device *device)
		1589	{
		1590	struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev);
		1591	struct disk_conf *dc;
		1592	bool can_do;
		1593
		1594	if (!blk_queue_discard(q))
		1595	return false;
		1596
		1597	rcu_read_lock();
		1598	dc = rcu_dereference(device->ldev->disk_conf);
		1599	can_do = dc->discard_zeroes_if_aligned;
		1600	rcu_read_unlock();
		1601	return can_do;
		1602	}
		1603
		1604	static void drbd_issue_peer_discard_or_zero_out(struct drbd_device device, struct drbd_peer_request peer_req)
		1605	{
		1606	/* If the backend cannot discard, or does not guarantee
		1607	* read-back zeroes in discarded ranges, we fall back to
		1608	* zero-out. Unless configuration specifically requested
		1609	* otherwise. */
		1610	if (!can_do_reliable_discards(device))
		1611	peer_req->flags \|= EE_ZEROOUT;
		1612
		1613	if (drbd_issue_discard_or_zero_out(device, peer_req->i.sector,
		1614	peer_req->i.size >> 9, peer_req->flags & (EE_ZEROOUT\|EE_TRIM)))
		1615	peer_req->flags \|= EE_WAS_ERROR;
1501	drbd_endio_write_sec_final(peer_req);	1616	drbd_endio_write_sec_final(peer_req);
1502	}	1617	}
1503		1618
@@ -1550,7 +1665,7 @@ int drbd_submit_peer_request(struct drbd_device *device, · 46 unmodified lines
1550	* Correctness first, performance later. Next step is to code an	1665	* Correctness first, performance later. Next step is to code an
1551	* asynchronous variant of the same.	1666	* asynchronous variant of the same.
1552	*/	1667	*/
1553	if (peer_req->flags & (EE_IS_TRIM\|EE_WRITE_SAME)) {	1668	if (peer_req->flags & (EE_TRIM\|EE_WRITE_SAME\|EE_ZEROOUT)) {
1554	/* wait for all pending IO completions, before we start	1669	/* wait for all pending IO completions, before we start
1555	* zeroing things out. */	1670	* zeroing things out. */
1556	conn_wait_active_ee_empty(peer_req->peer_device->connection);	1671	conn_wait_active_ee_empty(peer_req->peer_device->connection);
@@ -1567,8 +1682,8 @@ int drbd_submit_peer_request(struct drbd_device *device, · 10 unmodified lines
1567	spin_unlock_irq(&device->resource->req_lock);	1682	spin_unlock_irq(&device->resource->req_lock);
1568	}	1683	}
1569		1684
1570	if (peer_req->flags & EE_IS_TRIM)	1685	if (peer_req->flags & (EE_TRIM\|EE_ZEROOUT))
1571	drbd_issue_peer_discard(device, peer_req);	1686	drbd_issue_peer_discard_or_zero_out(device, peer_req);
1572	else /* EE_WRITE_SAME */	1687	else /* EE_WRITE_SAME */
1573	drbd_issue_peer_wsame(device, peer_req);	1688	drbd_issue_peer_wsame(device, peer_req);
1574	return 0;	1689	return 0;
@@ -1765,6 +1880,7 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, · 190 unmodified lines
1765	void *dig_vv = peer_device->connection->int_dig_vv;	1880	void *dig_vv = peer_device->connection->int_dig_vv;
1766	unsigned long *data;	1881	unsigned long *data;
1767	struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL;	1882	struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL;
		1883	struct p_trim *zeroes = (pi->cmd == P_ZEROES) ? pi->data : NULL;
1768	struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL;	1884	struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL;
1769		1885
1770	digest_size = 0;	1886	digest_size = 0;
@@ -1786,6 +1902,10 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, · 15 unmodified lines
1786	if (!expect(data_size == 0))	1902	if (!expect(data_size == 0))
1787	return NULL;	1903	return NULL;
1788	ds = be32_to_cpu(trim->size);	1904	ds = be32_to_cpu(trim->size);
		1905	} else if (zeroes) {
		1906	if (!expect(data_size == 0))
		1907	return NULL;
		1908	ds = be32_to_cpu(zeroes->size);
1789	} else if (wsame) {	1909	} else if (wsame) {
1790	if (data_size != queue_logical_block_size(device->rq_queue)) {	1910	if (data_size != queue_logical_block_size(device->rq_queue)) {
1791	drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n",	1911	drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n",
@@ -1802,7 +1922,7 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, · 10 unmodified lines
1802		1922
1803	if (!expect(IS_ALIGNED(ds, 512)))	1923	if (!expect(IS_ALIGNED(ds, 512)))
1804	return NULL;	1924	return NULL;
1805	if (trim \|\| wsame) {	1925	if (trim \|\| wsame \|\| zeroes) {
1806	if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9)))	1926	if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9)))
1807	return NULL;	1927	return NULL;
1808	} else if (!expect(ds <= DRBD_MAX_BIO_SIZE))	1928	} else if (!expect(ds <= DRBD_MAX_BIO_SIZE))
@@ -1827,7 +1947,11 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, · 18 unmodified lines
1827		1947
1828	peer_req->flags \|= EE_WRITE;	1948	peer_req->flags \|= EE_WRITE;
1829	if (trim) {	1949	if (trim) {
1830	peer_req->flags \|= EE_IS_TRIM;	1950	peer_req->flags \|= EE_TRIM;
		1951	return peer_req;
		1952	}
		1953	if (zeroes) {
		1954	peer_req->flags \|= EE_ZEROOUT;
1831	return peer_req;	1955	return peer_req;
1832	}	1956	}
1833	if (wsame)	1957	if (wsame)
@@ -2326,8 +2450,12 @@ static unsigned long wire_flags_to_bio_flags(u32 dpf) · 492 unmodified lines
2326		2450
2327	static unsigned long wire_flags_to_bio_op(u32 dpf)	2451	static unsigned long wire_flags_to_bio_op(u32 dpf)
2328	{	2452	{
2329	if (dpf & DP_DISCARD)	2453	if (dpf & DP_ZEROES)
2330	return REQ_OP_WRITE_ZEROES;	2454	return REQ_OP_WRITE_ZEROES;
		2455	if (dpf & DP_DISCARD)
		2456	return REQ_OP_DISCARD;
		2457	if (dpf & DP_WSAME)
		2458	return REQ_OP_WRITE_SAME;
2331	else	2459	else
2332	return REQ_OP_WRITE;	2460	return REQ_OP_WRITE;
2333	}	2461	}
@@ -2517,9 +2645,20 @@ static int receive_Data(struct drbd_connection connection, struct packet_info · 183 unmodified lines
2517	op = wire_flags_to_bio_op(dp_flags);	2645	op = wire_flags_to_bio_op(dp_flags);
2518	op_flags = wire_flags_to_bio_flags(dp_flags);	2646	op_flags = wire_flags_to_bio_flags(dp_flags);
2519	if (pi->cmd == P_TRIM) {	2647	if (pi->cmd == P_TRIM) {
		2648	D_ASSERT(peer_device, peer_req->i.size > 0);
		2649	D_ASSERT(peer_device, op == REQ_OP_DISCARD);
		2650	D_ASSERT(peer_device, peer_req->pages == NULL);
		2651	/* need to play safe: an older DRBD sender
		2652	* may mean zero-out while sending P_TRIM. */
		2653	if (0 == (connection->agreed_features & DRBD_FF_WZEROES))
		2654	peer_req->flags \|= EE_ZEROOUT;
		2655	} else if (pi->cmd == P_ZEROES) {
2520	D_ASSERT(peer_device, peer_req->i.size > 0);	2656	D_ASSERT(peer_device, peer_req->i.size > 0);
2521	D_ASSERT(peer_device, op == REQ_OP_WRITE_ZEROES);	2657	D_ASSERT(peer_device, op == REQ_OP_WRITE_ZEROES);
2522	D_ASSERT(peer_device, peer_req->pages == NULL);	2658	D_ASSERT(peer_device, peer_req->pages == NULL);
		2659	/* Do (not) pass down BLKDEV_ZERO_NOUNMAP? */
		2660	if (dp_flags & DP_DISCARD)
		2661	peer_req->flags \|= EE_TRIM;
2523	} else if (peer_req->pages == NULL) {	2662	} else if (peer_req->pages == NULL) {
2524	D_ASSERT(device, peer_req->i.size == 0);	2663	D_ASSERT(device, peer_req->i.size == 0);
2525	D_ASSERT(device, dp_flags & DP_FLUSH);	2664	D_ASSERT(device, dp_flags & DP_FLUSH);
@@ -2587,7 +2726,7 @@ static int receive_Data(struct drbd_connection connection, struct packet_info · 61 unmodified lines
2587	* we wait for all pending requests, respectively wait for	2726	* we wait for all pending requests, respectively wait for
2588	* active_ee to become empty in drbd_submit_peer_request();	2727	* active_ee to become empty in drbd_submit_peer_request();
2589	* better not add ourselves here. */	2728	* better not add ourselves here. */
2590	if ((peer_req->flags & (EE_IS_TRIM\|EE_WRITE_SAME)) == 0)	2729	if ((peer_req->flags & (EE_TRIM\|EE_WRITE_SAME\|EE_ZEROOUT)) == 0)
2591	list_add_tail(&peer_req->w.list, &device->active_ee);	2730	list_add_tail(&peer_req->w.list, &device->active_ee);
2592	spin_unlock_irq(&device->resource->req_lock);	2731	spin_unlock_irq(&device->resource->req_lock);
2593		2732
@@ -3364,7 +3503,7 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, · 770 unmodified lines
3364	enum drbd_conns rv = C_MASK;	3503	enum drbd_conns rv = C_MASK;
3365	enum drbd_disk_state mydisk;	3504	enum drbd_disk_state mydisk;
3366	struct net_conf *nc;	3505	struct net_conf *nc;
3367	int hg, rule_nr, rr_conflict, tentative;	3506	int hg, rule_nr, rr_conflict, tentative, always_asbp;
3368		3507
3369	mydisk = device->state.disk;	3508	mydisk = device->state.disk;
3370	if (mydisk == D_NEGOTIATING)	3509	if (mydisk == D_NEGOTIATING)
@@ -3415,8 +3554,12 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, · 44 unmodified lines
3415		3554
3416	rcu_read_lock();	3555	rcu_read_lock();
3417	nc = rcu_dereference(peer_device->connection->net_conf);	3556	nc = rcu_dereference(peer_device->connection->net_conf);
		3557	always_asbp = nc->always_asbp;
		3558	rr_conflict = nc->rr_conflict;
		3559	tentative = nc->tentative;
		3560	rcu_read_unlock();
3418		3561
3419	if (hg == 100 \|\| (hg == -100 && nc->always_asbp)) {	3562	if (hg == 100 \|\| (hg == -100 && always_asbp)) {
3420	int pcount = (device->state.role == R_PRIMARY)	3563	int pcount = (device->state.role == R_PRIMARY)
3421	+ (peer_role == R_PRIMARY);	3564	+ (peer_role == R_PRIMARY);
3422	int forced = (hg == -100);	3565	int forced = (hg == -100);
@@ -3455,9 +3598,6 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, · 32 unmodified lines
3455	"Sync from %s node\n",	3598	"Sync from %s node\n",
3456	(hg < 0) ? "peer" : "this");	3599	(hg < 0) ? "peer" : "this");
3457	}	3600	}
3458	rr_conflict = nc->rr_conflict;
3459	tentative = nc->tentative;
3460	rcu_read_unlock();
3461		3601
3462	if (hg == -100) {	3602	if (hg == -100) {
3463	/* FIXME this log message is not correct if we end up here	3603	/* FIXME this log message is not correct if we end up here
@@ -3980,6 +4120,7 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 516 unmodified lines
3980	struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL;	4120	struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL;
3981	enum determine_dev_size dd = DS_UNCHANGED;	4121	enum determine_dev_size dd = DS_UNCHANGED;
3982	sector_t p_size, p_usize, p_csize, my_usize;	4122	sector_t p_size, p_usize, p_csize, my_usize;
		4123	sector_t new_size, cur_size;
3983	int ldsc = 0; /* local disk size changed */	4124	int ldsc = 0; /* local disk size changed */
3984	enum dds_flags ddsf;	4125	enum dds_flags ddsf;
3985		4126
@@ -3987,6 +4128,7 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 1 unmodified line
3987	if (!peer_device)	4128	if (!peer_device)
3988	return config_unknown_volume(connection, pi);	4129	return config_unknown_volume(connection, pi);
3989	device = peer_device->device;	4130	device = peer_device->device;
		4131	cur_size = drbd_get_capacity(device->this_bdev);
3990		4132
3991	p_size = be64_to_cpu(p->d_size);	4133	p_size = be64_to_cpu(p->d_size);
3992	p_usize = be64_to_cpu(p->u_size);	4134	p_usize = be64_to_cpu(p->u_size);
@@ -3997,7 +4139,6 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 4 unmodified lines
3997	device->p_size = p_size;	4139	device->p_size = p_size;
3998		4140
3999	if (get_ldev(device)) {	4141	if (get_ldev(device)) {
4000	sector_t new_size, cur_size;
4001	rcu_read_lock();	4142	rcu_read_lock();
4002	my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size;	4143	my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size;
4003	rcu_read_unlock();	4144	rcu_read_unlock();
@@ -4012,13 +4153,13 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 8 unmodified lines
4012	if (device->state.conn == C_WF_REPORT_PARAMS)	4153	if (device->state.conn == C_WF_REPORT_PARAMS)
4013	p_usize = min_not_zero(my_usize, p_usize);	4154	p_usize = min_not_zero(my_usize, p_usize);
4014		4155
4015	/* Never shrink a device with usable data during connect.	4156	/* Never shrink a device with usable data during connect,
4016	But allow online shrinking if we are connected. */	4157	* or "attach" on the peer.
		4158	* But allow online shrinking if we are connected. */
4017	new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0);	4159	new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0);
4018	cur_size = drbd_get_capacity(device->this_bdev);
4019	if (new_size < cur_size &&	4160	if (new_size < cur_size &&
4020	device->state.disk >= D_OUTDATED &&	4161	device->state.disk >= D_OUTDATED &&
4021	device->state.conn < C_CONNECTED) {	4162	(device->state.conn < C_CONNECTED \|\| device->state.pdsk == D_DISKLESS)) {
4022	drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n",	4163	drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n",
4023	(unsigned long long)new_size, (unsigned long long)cur_size);	4164	(unsigned long long)new_size, (unsigned long long)cur_size);
4024	conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);	4165	conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
@@ -4046,8 +4187,8 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 21 unmodified lines
4046	synchronize_rcu();	4187	synchronize_rcu();
4047	kfree(old_disk_conf);	4188	kfree(old_disk_conf);
4048		4189
4049	drbd_info(device, "Peer sets u_size to %lu sectors\n",	4190	drbd_info(device, "Peer sets u_size to %lu sectors (old: %lu)\n",
4050	(unsigned long)my_usize);	4191	(unsigned long)p_usize, (unsigned long)my_usize);
4051	}	4192	}
4052		4193
4053	put_ldev(device);	4194	put_ldev(device);
@@ -4080,9 +4221,36 @@ static int receive_sizes(struct drbd_connection *connection, struct packet_info · 26 unmodified lines
4080	*	4221	*
4081	* However, if he sends a zero current size,	4222	* However, if he sends a zero current size,
4082	* take his (user-capped or) backing disk size anyways.	4223	* take his (user-capped or) backing disk size anyways.
		4224	*
		4225	* Unless of course he does not have a disk himself.
		4226	* In which case we ignore this completely.
4083	*/	4227	*/
		4228	sector_t new_size = p_csize ?: p_usize ?: p_size;
4084	drbd_reconsider_queue_parameters(device, NULL, o);	4229	drbd_reconsider_queue_parameters(device, NULL, o);
4085	drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size);	4230	if (new_size == 0) {
		4231	/* Ignore, peer does not know nothing. */
		4232	} else if (new_size == cur_size) {
		4233	/* nothing to do */
		4234	} else if (cur_size != 0 && p_size == 0) {
		4235	drbd_warn(device, "Ignored diskless peer device size (peer:%llu != me:%llu sectors)!\n",
		4236	(unsigned long long)new_size, (unsigned long long)cur_size);
		4237	} else if (new_size < cur_size && device->state.role == R_PRIMARY) {
		4238	drbd_err(device, "The peer's device size is too small! (%llu < %llu sectors); demote me first!\n",
		4239	(unsigned long long)new_size, (unsigned long long)cur_size);
		4240	conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD);
		4241	return -EIO;
		4242	} else {
		4243	/* I believe the peer, if
		4244	* - I don't have a current size myself
		4245	* - we agree on the size anyways
		4246	* - I do have a current size, am Secondary,
		4247	* and he has the only disk
		4248	* - I do have a current size, am Primary,
		4249	* and he has the only disk,
		4250	* which is larger than my current size
		4251	*/
		4252	drbd_set_my_capacity(device, new_size);
		4253	}
4086	}	4254	}
4087		4255
4088	if (get_ldev(device)) {	4256	if (get_ldev(device)) {
@@ -4142,7 +4310,7 @@ static int receive_uuids(struct drbd_connection *connection, struct packet_info · 53 unmodified lines
4142	kfree(device->p_uuid);	4310	kfree(device->p_uuid);
4143	device->p_uuid = p_uuid;	4311	device->p_uuid = p_uuid;
4144		4312
4145	if (device->state.conn < C_CONNECTED &&	4313	if ((device->state.conn < C_CONNECTED \|\| device->state.pdsk == D_DISKLESS) &&
4146	device->state.disk < D_INCONSISTENT &&	4314	device->state.disk < D_INCONSISTENT &&
4147	device->state.role == R_PRIMARY &&	4315	device->state.role == R_PRIMARY &&
4148	(device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {	4316	(device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
@@ -4368,6 +4536,25 @@ static int receive_state(struct drbd_connection *connection, struct packet_info · 219 unmodified lines
4368	if (peer_state.conn == C_AHEAD)	4536	if (peer_state.conn == C_AHEAD)
4369	ns.conn = C_BEHIND;	4537	ns.conn = C_BEHIND;
4370		4538
		4539	/* TODO:
		4540	* if (primary and diskless and peer uuid != effective uuid)
		4541	* abort attach on peer;
		4542	*
		4543	* If this node does not have good data, was already connected, but
		4544	* the peer did a late attach only now, trying to "negotiate" with me,
		4545	* AND I am currently Primary, possibly frozen, with some specific
		4546	* "effective" uuid, this should never be reached, really, because
		4547	* we first send the uuids, then the current state.
		4548	*
		4549	* In this scenario, we already dropped the connection hard
		4550	* when we received the unsuitable uuids (receive_uuids().
		4551	*
		4552	* Should we want to change this, that is: not drop the connection in
		4553	* receive_uuids() already, then we would need to add a branch here
		4554	* that aborts the attach of "unsuitable uuids" on the peer in case
		4555	* this node is currently Diskless Primary.
		4556	*/
		4557
4371	if (device->p_uuid && peer_state.disk >= D_NEGOTIATING &&	4558	if (device->p_uuid && peer_state.disk >= D_NEGOTIATING &&
4372	get_ldev_if_state(device, D_NEGOTIATING)) {	4559	get_ldev_if_state(device, D_NEGOTIATING)) {
4373	int cr; /* consider resync */	4560	int cr; /* consider resync */
@@ -4380,7 +4567,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info · 6 unmodified lines
4380	(peer_state.disk == D_NEGOTIATING \|\|	4567	(peer_state.disk == D_NEGOTIATING \|\|
4381	os.disk == D_NEGOTIATING));	4568	os.disk == D_NEGOTIATING));
4382	/* if we have both been inconsistent, and the peer has been	4569	/* if we have both been inconsistent, and the peer has been
4383	* forced to be UpToDate with --overwrite-data */	4570	* forced to be UpToDate with --force */
4384	cr \|= test_bit(CONSIDER_RESYNC, &device->flags);	4571	cr \|= test_bit(CONSIDER_RESYNC, &device->flags);
4385	/* if we had been plain connected, and the admin requested to	4572	/* if we had been plain connected, and the admin requested to
4386	* start a sync by "invalidate" or "invalidate-remote" */	4573	* start a sync by "invalidate" or "invalidate-remote" */
@@ -4845,7 +5032,7 @@ static int receive_rs_deallocated(struct drbd_connection *connection, struct pac · 458 unmodified lines
4845		5032
4846	peer_req->w.cb = e_end_resync_block;	5033	peer_req->w.cb = e_end_resync_block;
4847	peer_req->submit_jif = jiffies;	5034	peer_req->submit_jif = jiffies;
4848	peer_req->flags \|= EE_IS_TRIM;	5035	peer_req->flags \|= EE_TRIM;
4849		5036
4850	spin_lock_irq(&device->resource->req_lock);	5037	spin_lock_irq(&device->resource->req_lock);
4851	list_add_tail(&peer_req->w.list, &device->sync_ee);	5038	list_add_tail(&peer_req->w.list, &device->sync_ee);
@@ -4913,6 +5100,7 @@ static struct data_cmd drbd_cmd_handler[] = { · 61 unmodified lines
4913	[P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state },	5100	[P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state },
4914	[P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol },	5101	[P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol },
4915	[P_TRIM] = { 0, sizeof(struct p_trim), receive_Data },	5102	[P_TRIM] = { 0, sizeof(struct p_trim), receive_Data },
		5103	[P_ZEROES] = { 0, sizeof(struct p_trim), receive_Data },
4916	[P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated },	5104	[P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated },
4917	[P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data },	5105	[P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data },
4918	};	5106	};
@@ -5197,11 +5385,12 @@ static int drbd_do_features(struct drbd_connection *connection) · 278 unmodified lines
5197	drbd_info(connection, "Handshake successful: "	5385	drbd_info(connection, "Handshake successful: "
5198	"Agreed network protocol version %d\n", connection->agreed_pro_version);	5386	"Agreed network protocol version %d\n", connection->agreed_pro_version);
5199		5387
5200	drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s.\n",	5388	drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s%s.\n",
5201	connection->agreed_features,	5389	connection->agreed_features,
5202	connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "",	5390	connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "",
5203	connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "",	5391	connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "",
5204	connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" :	5392	connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : "",
		5393	connection->agreed_features & DRBD_FF_WZEROES ? " WRITE_ZEROES" :
5205	connection->agreed_features ? "" : " none");	5394	connection->agreed_features ? "" : " none");
5206		5395
5207	return 1;	5396	return 1;
@@ -5284,7 +5473,7 @@ static int drbd_do_auth(struct drbd_connection *connection) · 76 unmodified lines
5284	if (pi.cmd != P_AUTH_CHALLENGE) {	5473	if (pi.cmd != P_AUTH_CHALLENGE) {
5285	drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n",	5474	drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n",
5286	cmdname(pi.cmd), pi.cmd);	5475	cmdname(pi.cmd), pi.cmd);
5287	rv = 0;	5476	rv = -1;
5288	goto fail;	5477	goto fail;
5289	}	5478	}
5290		5479

drivers/block/drbd/drbd_req.c+10−9

@@ -63,7 +63,7 @@ static struct drbd_request drbd_req_new(struct drbd_device device, struct bio · 62 unmodified lines
63	drbd_req_make_private_bio(req, bio_src);	63	drbd_req_make_private_bio(req, bio_src);
64	req->rq_state = (bio_data_dir(bio_src) == WRITE ? RQ_WRITE : 0)	64	req->rq_state = (bio_data_dir(bio_src) == WRITE ? RQ_WRITE : 0)
65	\| (bio_op(bio_src) == REQ_OP_WRITE_SAME ? RQ_WSAME : 0)	65	\| (bio_op(bio_src) == REQ_OP_WRITE_SAME ? RQ_WSAME : 0)
66	\| (bio_op(bio_src) == REQ_OP_WRITE_ZEROES ? RQ_UNMAP : 0)	66	\| (bio_op(bio_src) == REQ_OP_WRITE_ZEROES ? RQ_ZEROES : 0)
67	\| (bio_op(bio_src) == REQ_OP_DISCARD ? RQ_UNMAP : 0);	67	\| (bio_op(bio_src) == REQ_OP_DISCARD ? RQ_UNMAP : 0);
68	req->device = device;	68	req->device = device;
69	req->master_bio = bio_src;	69	req->master_bio = bio_src;
@@ -1155,12 +1155,11 @@ static int drbd_process_write_request(struct drbd_request *req) · 1085 unmodified lines
1155	return remote;	1155	return remote;
1156	}	1156	}
1157		1157
1158	static void drbd_process_discard_req(struct drbd_request *req)	1158	static void drbd_process_discard_or_zeroes_req(struct drbd_request *req, int flags)
1159	{	1159	{
1160	struct block_device *bdev = req->device->ldev->backing_bdev;	1160	int err = drbd_issue_discard_or_zero_out(req->device,
1161		1161	req->i.sector, req->i.size >> 9, flags);
1162	if (blkdev_issue_zeroout(bdev, req->i.sector, req->i.size >> 9,	1162	if (err)
1163	GFP_NOIO, 0))
1164	req->private_bio->bi_status = BLK_STS_IOERR;	1163	req->private_bio->bi_status = BLK_STS_IOERR;
1165	bio_endio(req->private_bio);	1164	bio_endio(req->private_bio);
1166	}	1165	}
@@ -1189,9 +1188,11 @@ drbd_submit_req_private_bio(struct drbd_request *req) · 22 unmodified lines
1189	if (get_ldev(device)) {	1188	if (get_ldev(device)) {
1190	if (drbd_insert_fault(device, type))	1189	if (drbd_insert_fault(device, type))
1191	bio_io_error(bio);	1190	bio_io_error(bio);
1192	else if (bio_op(bio) == REQ_OP_WRITE_ZEROES \|\|	1191	else if (bio_op(bio) == REQ_OP_WRITE_ZEROES)
1193	bio_op(bio) == REQ_OP_DISCARD)	1192	drbd_process_discard_or_zeroes_req(req, EE_ZEROOUT \|
1194	drbd_process_discard_req(req);	1193	((bio->bi_opf & REQ_NOUNMAP) ? 0 : EE_TRIM));
		1194	else if (bio_op(bio) == REQ_OP_DISCARD)
		1195	drbd_process_discard_or_zeroes_req(req, EE_TRIM);
1195	else	1196	else
1196	generic_make_request(bio);	1197	generic_make_request(bio);
1197	put_ldev(device);	1198	put_ldev(device);

drivers/block/drbd/drbd_req.h+2−0

 	__RQ_WRITE,
 	__RQ_WSAME,
 	__RQ_UNMAP,
+	__RQ_ZEROES,
 	/* Should call drbd_al_complete_io() for this request... */
 	__RQ_IN_ACT_LOG,
 #define RQ_WRITE           (1UL << __RQ_WRITE)
 #define RQ_WSAME           (1UL << __RQ_WSAME)
 #define RQ_UNMAP           (1UL << __RQ_UNMAP)
+#define RQ_ZEROES          (1UL << __RQ_ZEROES)
 #define RQ_IN_ACT_LOG      (1UL << __RQ_IN_ACT_LOG)
 #define RQ_UNPLUG          (1UL << __RQ_UNPLUG)
 #define RQ_POSTPONED	   (1UL << __RQ_POSTPONED)

drivers/block/drbd/drbd_state.c+4−7

 			CS_VERBOSE | CS_ORDERED | CS_INHIBIT_MD_IO);
 }
-enum drbd_state_rv
+int drbd_request_detach_interruptible(struct drbd_device *device)
-drbd_request_detach_interruptible(struct drbd_device *device)
 {
-	enum drbd_state_rv rv;
+	int ret, rv;
-	int ret;
 	drbd_suspend_io(device); /* so no-one is stuck in drbd_al_begin_io */
 	wait_event_interruptible(device->state_wait,
 			ns.pdsk = D_UP_TO_DATE;
 	}
-	/* Implications of the connection stat on the disk states */
+	/* Implications of the connection state on the disk states */
 	disk_min = D_DISKLESS;
 	disk_max = D_UP_TO_DATE;
 	pdsk_min = D_INCONSISTENT;
 			spin_unlock_irq(&connection->resource->req_lock);
 		}
 	}
-	kref_put(&connection->kref, drbd_destroy_connection);
 	conn_md_sync(connection);
+	kref_put(&connection->kref, drbd_destroy_connection);
 	return 0;
 }

drivers/block/drbd/drbd_state.h+2−3

 					  enum chg_state_flags,
 					  struct completion *done);
 extern void print_st_err(struct drbd_device *, union drbd_state,
-			union drbd_state, int);
+			union drbd_state, enum drbd_state_rv);
 enum drbd_state_rv
 _conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val,
 }
 /* for use in adm_detach() (drbd_adm_detach(), drbd_adm_down()) */
-enum drbd_state_rv
+int drbd_request_detach_interruptible(struct drbd_device *device);
-drbd_request_detach_interruptible(struct drbd_device *device);
 enum drbd_role conn_highest_role(struct drbd_connection *connection);
 enum drbd_role conn_highest_peer(struct drbd_connection *connection);

drivers/block/drbd/drbd_worker.c+1−1

@@ -153,7 +153,7 @@ void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(l · 152 unmodified lines
153	do_wake = list_empty(block_id == ID_SYNCER ? &device->sync_ee : &device->active_ee);	153	do_wake = list_empty(block_id == ID_SYNCER ? &device->sync_ee : &device->active_ee);
154		154
155	/* FIXME do we want to detach for failed REQ_OP_DISCARD?	155	/* FIXME do we want to detach for failed REQ_OP_DISCARD?
156	* ((peer_req->flags & (EE_WAS_ERROR\|EE_IS_TRIM)) == EE_WAS_ERROR) */	156	* ((peer_req->flags & (EE_WAS_ERROR\|EE_TRIM)) == EE_WAS_ERROR) */
157	if (peer_req->flags & EE_WAS_ERROR)	157	if (peer_req->flags & EE_WAS_ERROR)
158	__drbd_chk_io_error(device, DRBD_WRITE_ERROR);	158	__drbd_chk_io_error(device, DRBD_WRITE_ERROR);
159		159

drivers/block/loop.c+0−1

@@ -616,7 +616,6 @@ static int do_req_filebacked(struct loop_device lo, struct request rq) · 615 unmodified lines
616	default:	616	default:
617	WARN_ON_ONCE(1);	617	WARN_ON_ONCE(1);
618	return -EIO;	618	return -EIO;
619	break;
620	}	619	}
621	}	620	}
622		621

drivers/block/sunvdc.c+0−1

@@ -633,7 +633,6 @@ static int generic_request(struct vdc_port port, u8 op, void buf, int len) · 632 unmodified lines
633	case VD_OP_GET_EFI:	633	case VD_OP_GET_EFI:
634	case VD_OP_SET_EFI:	634	case VD_OP_SET_EFI:
635	return -EOPNOTSUPP;	635	return -EOPNOTSUPP;
636	break;
637	};	636	};
638		637
639	map_perm \|= LDC_MAP_SHADOW \| LDC_MAP_DIRECT \| LDC_MAP_IO;	638	map_perm \|= LDC_MAP_SHADOW \| LDC_MAP_DIRECT \| LDC_MAP_IO;

drivers/block/swim3.c+8−6

 	struct swim3 __iomem *sw = fs->swim3;
 	mutex_lock(&swim3_mutex);
-	if (fs->ref_count > 0 && --fs->ref_count == 0) {
+	if (fs->ref_count > 0)
+		--fs->ref_count;
+	else if (fs->ref_count == -1)
+		fs->ref_count = 0;
+	if (fs->ref_count == 0) {
 		swim3_action(fs, MOTOR_OFF);
 		out_8(&sw->control_bic, 0xff);
 		swim3_select(fs, RELAX);
 	struct floppy_state *fs = &floppy_states[index];
 	int rc = -EBUSY;
-	/* Do this first for message macros */
-	memset(fs, 0, sizeof(*fs));
 	fs->mdev = mdev;
 	fs->index = index;
 		swim3_err("%s", "Couldn't request interrupt\n");
 		pmac_call_feature(PMAC_FTR_SWIM3_ENABLE, swim, 0, 0);
 		goto out_unmap;
-		return -EBUSY;
 	}
 	timer_setup(&fs->timeout, NULL, 0);
 			return rc;
 	}
-	fs = &floppy_states[floppy_count];
 	disk = alloc_disk(1);
 	if (disk == NULL) {
 		rc = -ENOMEM;
 		goto out_unregister;
 	}
+	fs = &floppy_states[floppy_count];
+	memset(fs, 0, sizeof(*fs));
 	disk->queue = blk_mq_init_sq_queue(&fs->tag_set, &swim3_mq_ops, 2,
 						BLK_MQ_F_SHOULD_MERGE);
 	if (IS_ERR(disk->queue)) {

drivers/cdrom/gdrom.c+1−0

@@ -873,6 +873,7 @@ static void __exit exit_gdrom(void) · 872 unmodified lines
873	platform_device_unregister(pd);	873	platform_device_unregister(pd);
874	platform_driver_unregister(&gdrom_driver);	874	platform_driver_unregister(&gdrom_driver);
875	kfree(gd.toc);	875	kfree(gd.toc);
		876	kfree(gd.cd_info);
876	}	877	}
877		878
878	module_init(init_gdrom);	879	module_init(init_gdrom);

drivers/lightnvm/pblk-recovery.c+0−1

@@ -418,7 +418,6 @@ retry_rq: · 417 unmodified lines
418	if (ret) {	418	if (ret) {
419	pblk_err(pblk, "I/O submission failed: %d\n", ret);	419	pblk_err(pblk, "I/O submission failed: %d\n", ret);
420	bio_put(bio);	420	bio_put(bio);
421	bio_put(bio);
422	return ret;	421	return ret;
423	}	422	}
424		423

include/linux/blk-cgroup.h+16−5

  */
 static inline bool blkg_tryget(struct blkcg_gq *blkg)
 {
-	return percpu_ref_tryget(&blkg->refcnt);
+	return blkg && percpu_ref_tryget(&blkg->refcnt);
 }
 /**
  * blkg_tryget_closest - try and get a blkg ref on the closet blkg
  * @blkg: blkg to get
  *
- * This walks up the blkg tree to find the closest non-dying blkg and returns
+ * This needs to be called rcu protected.  As the failure mode here is to walk
- * the blkg that it did association with as it may not be the passed in blkg.
+ * up the blkg tree, this ensure that the blkg->parent pointers are always
+ * valid.  This returns the blkg that it ended up taking a reference on or %NULL
+ * if no reference was taken.
  */
 static inline struct blkcg_gq *blkg_tryget_closest(struct blkcg_gq *blkg)
 {
-	while (blkg && !percpu_ref_tryget(&blkg->refcnt))
+	struct blkcg_gq *ret_blkg = NULL;
+	WARN_ON_ONCE(!rcu_read_lock_held());
+	while (blkg) {
+		if (blkg_tryget(blkg)) {
+			ret_blkg = blkg;
+			break;
+		}
 		blkg = blkg->parent;
+	}
-	return blkg;
+	return ret_blkg;
 }
 /**

include/linux/drbd.h+1−1

@@ -51,7 +51,7 @@ · 50 unmodified lines
51	#endif	51	#endif
52		52
53	extern const char *drbd_buildtag(void);	53	extern const char *drbd_buildtag(void);
54	#define REL_VERSION "8.4.10"	54	#define REL_VERSION "8.4.11"
55	#define API_VERSION 1	55	#define API_VERSION 1
56	#define PRO_VERSION_MIN 86	56	#define PRO_VERSION_MIN 86
57	#define PRO_VERSION_MAX 101	57	#define PRO_VERSION_MAX 101

include/linux/genl_magic_struct.h+4−1

 {
 	switch (0) {
 #include GENL_MAGIC_INCLUDE_FILE
+	case 0:
 		;
 	}
 }
 {
 	switch (0) {
 #include GENL_MAGIC_INCLUDE_FILE
+	case 0:
 		;
 	}
 }
 static inline void ct_assert_unique_ ## s_name ## _attributes(void)	\
 {									\
 	switch (0) {							\
-		s_fields						\
+	s_fields							\
+	case 0:								\
 			;						\
 	}								\
 }

Merge tag 'for-4.21/block-20190102' of git://git.kernel.dk/linux-block

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code