Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

[platform/kernel/linux-starfive.git] / drivers / block / drbd / drbd_receiver.c

diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index fa00cf2..08da922 100644 (file)
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -1604,19 +1604,7 @@ static void drbd_issue_peer_discard_or_zero_out(struct drbd_device *device, stru
        drbd_endio_write_sec_final(peer_req);
 }
 
-static void drbd_issue_peer_wsame(struct drbd_device *device,
-                                 struct drbd_peer_request *peer_req)
-{
-       struct block_device *bdev = device->ldev->backing_bdev;
-       sector_t s = peer_req->i.sector;
-       sector_t nr = peer_req->i.size >> 9;
-       if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages))
-               peer_req->flags |= EE_WAS_ERROR;
-       drbd_endio_write_sec_final(peer_req);
-}
-
-
-/*
+/**
  * drbd_submit_peer_request()
  * @device:    DRBD device.
  * @peer_req:  peer request
@@ -1651,7 +1639,7 @@ int drbd_submit_peer_request(struct drbd_device *device,
         * Correctness first, performance later.  Next step is to code an
         * asynchronous variant of the same.
         */
-       if (peer_req->flags & (EE_TRIM|EE_WRITE_SAME|EE_ZEROOUT)) {
+       if (peer_req->flags & (EE_TRIM | EE_ZEROOUT)) {
                /* wait for all pending IO completions, before we start
                 * zeroing things out. */
                conn_wait_active_ee_empty(peer_req->peer_device->connection);
@@ -1668,10 +1656,7 @@ int drbd_submit_peer_request(struct drbd_device *device,
                        spin_unlock_irq(&device->resource->req_lock);
                }
 
-               if (peer_req->flags & (EE_TRIM|EE_ZEROOUT))
-                       drbd_issue_peer_discard_or_zero_out(device, peer_req);
-               else /* EE_WRITE_SAME */
-                       drbd_issue_peer_wsame(device, peer_req);
+               drbd_issue_peer_discard_or_zero_out(device, peer_req);
                return 0;
        }
 
@@ -1854,7 +1839,6 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
        unsigned long *data;
        struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL;
        struct p_trim *zeroes = (pi->cmd == P_ZEROES) ? pi->data : NULL;
-       struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL;
 
        digest_size = 0;
        if (!trim && peer_device->connection->peer_integrity_tfm) {
@@ -1869,7 +1853,7 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
                data_size -= digest_size;
        }
 
-       /* assume request_size == data_size, but special case trim and wsame. */
+       /* assume request_size == data_size, but special case trim. */
        ds = data_size;
        if (trim) {
                if (!expect(data_size == 0))
@@ -1879,23 +1863,11 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
                if (!expect(data_size == 0))
                        return NULL;
                ds = be32_to_cpu(zeroes->size);
-       } else if (wsame) {
-               if (data_size != queue_logical_block_size(device->rq_queue)) {
-                       drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n",
-                               data_size, queue_logical_block_size(device->rq_queue));
-                       return NULL;
-               }
-               if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) {
-                       drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n",
-                               data_size, bdev_logical_block_size(device->ldev->backing_bdev));
-                       return NULL;
-               }
-               ds = be32_to_cpu(wsame->size);
        }
 
        if (!expect(IS_ALIGNED(ds, 512)))
                return NULL;
-       if (trim || wsame || zeroes) {
+       if (trim || zeroes) {
                if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9)))
                        return NULL;
        } else if (!expect(ds <= DRBD_MAX_BIO_SIZE))
@@ -1927,8 +1899,6 @@ read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector,
                peer_req->flags |= EE_ZEROOUT;
                return peer_req;
        }
-       if (wsame)
-               peer_req->flags |= EE_WRITE_SAME;
 
        /* receive payload size bytes into page chain */
        ds = data_size;
@@ -2427,8 +2397,6 @@ static unsigned long wire_flags_to_bio_op(u32 dpf)
                return REQ_OP_WRITE_ZEROES;
        if (dpf & DP_DISCARD)
                return REQ_OP_DISCARD;
-       if (dpf & DP_WSAME)
-               return REQ_OP_WRITE_SAME;
        else
                return REQ_OP_WRITE;
 }
@@ -2695,11 +2663,11 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
                update_peer_seq(peer_device, peer_seq);
                spin_lock_irq(&device->resource->req_lock);
        }
-       /* TRIM and WRITE_SAME are processed synchronously,
+       /* TRIM and is processed synchronously,
         * we wait for all pending requests, respectively wait for
         * active_ee to become empty in drbd_submit_peer_request();
         * better not add ourselves here. */
-       if ((peer_req->flags & (EE_TRIM|EE_WRITE_SAME|EE_ZEROOUT)) == 0)
+       if ((peer_req->flags & (EE_TRIM | EE_ZEROOUT)) == 0)
                list_add_tail(&peer_req->w.list, &device->active_ee);
        spin_unlock_irq(&device->resource->req_lock);
 
@@ -5068,7 +5036,6 @@ static struct data_cmd drbd_cmd_handler[] = {
        [P_TRIM]            = { 0, sizeof(struct p_trim), receive_Data },
        [P_ZEROES]          = { 0, sizeof(struct p_trim), receive_Data },
        [P_RS_DEALLOCATED]  = { 0, sizeof(struct p_block_desc), receive_rs_deallocated },
-       [P_WSAME]           = { 1, sizeof(struct p_wsame), receive_Data },
 };
 
 static void drbdd(struct drbd_connection *connection)