add read only status in lvs level

Author: root

include/spdk/blob.h

@@ -388,6 +388,7 @@ void spdk_blob_update_failed_cleanup(struct spdk_blob *blob,
 				 spdk_blob_op_complete cb_fn, void *cb_arg);
 
 void spdk_bs_set_leader(struct spdk_blob_store *bs, bool state);
+void spdk_bs_set_read_only(struct spdk_blob_store *bs, bool state);
 /**
  * update a blobstore according to bit array synced.
  * Can be used on loaded blobstore, even with opened blobs.

include/spdk/lvol.h

@@ -313,6 +313,7 @@ void spdk_lvs_change_leader_state(uint64_t groupid);
 bool spdk_lvs_trigger_leadership_switch(uint64_t *groupid);
 bool spdk_lvs_queued_rsp(struct spdk_lvol_store *lvs, struct spdk_bdev_io *bdev_io);
 void spdk_lvs_set_op(struct spdk_lvol_store *lvs, uint64_t groupid, uint64_t port);
+void spdk_lvs_set_read_only(struct spdk_lvol_store *lvs, bool status);
 void spdk_lvs_set_failed_on_update(struct spdk_lvol_store *lvs, bool state);
 /**
  * Get the lvol that has a particular UUID.

include/spdk_internal/lvolstore.h

@@ -140,6 +140,7 @@ struct spdk_lvol_store {
 	uint64_t			leadership_timeout;
 	uint64_t			timeout_trigger;
 	bool 				trigger_leader_sent;
+	bool 				read_only;
 	int 				subsystem_port;
 };
 

lib/blob/blobstore.c

@@ -3811,6 +3811,12 @@ blob_request_submit_op(struct spdk_blob *blob, struct spdk_io_channel *_channel,
 		return;
 	}
 
+	if (blob->bs->read_only && 
+		(op_type == SPDK_BLOB_WRITE || op_type == SPDK_BLOB_WRITE_ZEROES)) {
+		// SPDK_NOTICELOG("FAILED IO on update filed condition.\n");
+		cb_fn(cb_arg, -EIO);
+	}
+
 	if (blob->failed_on_update) {
 		SPDK_NOTICELOG("FAILED IO on update filed condition.\n");
 		cb_fn(cb_arg, -EIO);
@@ -3952,6 +3958,11 @@ blob_request_submit_rw_iov(struct spdk_blob *blob, struct spdk_io_channel *_chan
 		return;
 	}
 
+	if (blob->bs->read_only && !read) {
+		// SPDK_NOTICELOG("FAILED IO on update filed condition.\n");
+		cb_fn(cb_arg, -EIO);
+	}
+
 	if (blob->failed_on_update) {
 		SPDK_NOTICELOG("FAILED IO on update filed condition \n");
 		cb_fn(cb_arg, -EIO);
@@ -4472,6 +4483,7 @@ bs_alloc(struct spdk_bs_dev *dev, struct spdk_bs_opts *opts, struct spdk_blob_st
 
 	bs->priority_class = 0;
 	bs->is_leader = true;
+	bs->read_only = false;
 	/*
 	 * Do not use bs_lba_to_cluster() here since blockcnt may not be an
 	 *  even multiple of the cluster size.
@@ -7351,6 +7363,12 @@ spdk_bs_set_leader(struct spdk_blob_store *bs, bool state)
 	bs->is_leader = state;	
 }
 
+void
+spdk_bs_set_read_only(struct spdk_blob_store *bs, bool state)
+{
+	bs->read_only = state;
+}
+
 uint64_t
 spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
 {

lib/blob/blobstore.h

@@ -212,6 +212,7 @@ struct spdk_blob_store {
 	 * Only when the distrib internal force state changes, it will be set to false.
 	 */
 	bool				is_leader;
+	bool				read_only;
 
 	spdk_bs_esnap_dev_create	esnap_bs_dev_create;
 	void				*esnap_ctx;

lib/lvol/lvol.c

@@ -82,6 +82,7 @@ lvs_alloc(void)
 
 	lvs->load_esnaps = false;
 	lvs->leader = false;
+	lvs->read_only = false;
 	RB_INIT(&lvs->degraded_lvol_sets_tree);
 	lvs->thread = spdk_get_thread();
 
@@ -2972,6 +2973,17 @@ spdk_lvs_set_op(struct spdk_lvol_store *lvs, uint64_t groupid, uint64_t port)
 	return;
 }
 
+void
+spdk_lvs_set_read_only(struct spdk_lvol_store *lvs, bool status)
+{
+	SPDK_NOTICELOG("Set lvostore read_only %s.\n", status ? "true" : "false");
+	pthread_mutex_lock(&g_lvol_stores_mutex);
+	lvs->read_only = status;
+	spdk_bs_set_read_only(lvs->blobstore, status);
+	pthread_mutex_unlock(&g_lvol_stores_mutex);
+	return;
+}
+
 void
 spdk_lvs_check_active_process(struct spdk_lvol_store *lvs, struct spdk_lvol *lvol, uint8_t type)
 {

module/bdev/lvol/vbdev_lvol.c

@@ -1260,6 +1260,10 @@ vbdev_lvol_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_
 				     bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
 		break;
 	case SPDK_BDEV_IO_TYPE_WRITE:
+		if (lvs->read_only) {
+			spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
+			return;
+		}
 		lvol_write(lvol, ch, bdev_io);
 		break;
 	case SPDK_BDEV_IO_TYPE_RESET:
@@ -1269,6 +1273,10 @@ vbdev_lvol_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_
 		lvol_unmap(lvol, ch, bdev_io);
 		break;
 	case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
+		if (lvs->read_only) {
+			spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
+			return;
+		}
 		lvol_write_zeroes(lvol, ch, bdev_io);
 		break;
 	case SPDK_BDEV_IO_TYPE_SEEK_DATA:

module/bdev/lvol/vbdev_lvol_rpc.c

@@ -1575,6 +1575,59 @@ rpc_bdev_lvol_set_read_only(struct spdk_jsonrpc_request *request,
 
 SPDK_RPC_REGISTER("bdev_lvol_set_read_only", rpc_bdev_lvol_set_read_only, SPDK_RPC_RUNTIME)
 
+struct rpc_set_ro_lvs_bdev {
+	char *lvs_name;
+	char *uuid;
+	bool read_only;
+
+};
+
+static void
+free_rpc_set_ro_lvs_bdev(struct rpc_set_ro_lvs_bdev *req)
+{
+	free(req->lvs_name);
+	free(req->uuid);
+}
+
+static const struct spdk_json_object_decoder rpc_set_ro_lvs_bdev_decoders[] = {
+	{"lvs_name", offsetof(struct rpc_set_ro_lvs_bdev, lvs_name), spdk_json_decode_string, true},
+	{"uuid", offsetof(struct rpc_set_ro_lvs_bdev, uuid), spdk_json_decode_string, true},
+	{"read_only", offsetof(struct rpc_set_ro_lvs_bdev, read_only), spdk_json_decode_bool},
+};
+
+static void
+rpc_bdev_lvol_set_lvs_read_only(struct spdk_jsonrpc_request *request,
+			    const struct spdk_json_val *params)
+{
+	struct rpc_set_ro_lvs_bdev req = {};
+	struct spdk_lvol_store *lvs = NULL;
+	int rc;
+
+	SPDK_INFOLOG(lvol_rpc, "Setting lvol as read only\n");
+
+	if (spdk_json_decode_object(params, rpc_set_ro_lvs_bdev_decoders,
+				    SPDK_COUNTOF(rpc_set_ro_lvs_bdev_decoders),
+				    &req)) {
+		SPDK_INFOLOG(lvol_rpc, "spdk_json_decode_object failed\n");
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
+						 "spdk_json_decode_object failed");
+		goto cleanup;
+	}
+
+	rc = vbdev_get_lvol_store_by_uuid_xor_name(req.uuid, req.lvs_name, &lvs);
+	if (rc != 0) {
+		spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
+		goto cleanup;
+	}
+	
+	spdk_lvs_set_read_only(lvs, req.read_only);
+	spdk_jsonrpc_send_bool_response(request, true);
+cleanup:
+	free_rpc_set_ro_lvs_bdev(&req);
+}
+
+SPDK_RPC_REGISTER("bdev_lvol_set_lvs_read_only", rpc_bdev_lvol_set_lvs_read_only, SPDK_RPC_RUNTIME)
+
 struct rpc_bdev_lvol_delete {
 	char *name;
 	bool sync;
@@ -1699,6 +1752,7 @@ rpc_dump_lvol_store_info(struct spdk_json_write_ctx *w, struct lvol_store_bdev *
 	spdk_json_write_named_uuid(w, "uuid", &lvs_bdev->lvs->uuid);
 	spdk_json_write_named_string(w, "name", lvs_bdev->lvs->name);
 	spdk_json_write_named_bool(w, "lvs leadership", lvs_bdev->lvs->leader);
+	spdk_json_write_named_bool(w, "lvs_read_only", lvs_bdev->lvs->read_only);
 	spdk_json_write_named_string(w, "base_bdev", spdk_bdev_get_name(lvs_bdev->bdev));
 	spdk_json_write_named_uint64(w, "total_data_clusters", spdk_bs_total_data_cluster_count(bs));
 	spdk_json_write_named_uint64(w, "free_clusters", spdk_bs_free_cluster_count(bs));

python/spdk/rpc/lvol.py

@@ -95,6 +95,24 @@ def bdev_lvol_set_leader_all(client, uuid=None, lvs_name=None, leadership=False)
         params['lvs_name'] = lvs_name
     return client.call('bdev_lvol_set_leader_all', params)
 
+def bdev_lvol_set_lvs_read_only(client, uuid=None, lvs_name=None, read_only=False):
+    """Change state of the read only
+
+    Args:
+        uuid: UUID of the lvolstore
+        lvs_name: lvolstore name
+        read_only: Read only state for lvolstore (default: False)        
+    """ 
+    params = {'read_only': read_only}
+        
+    if (uuid and lvs_name):
+        raise ValueError("Exactly one of uuid or lvs_name may be specified")
+    if uuid:
+        params['uuid'] = uuid
+    if lvs_name:
+        params['lvs_name'] = lvs_name
+    return client.call('bdev_lvol_set_lvs_read_only', params)
+
 def bdev_lvol_create(client, lvol_name, size_in_mib, thin_provision=False, uuid=None, lvs_name=None, clear_method=None, lvol_priority_class=0):
     """Create a logical volume on a logical volume store.
 

scripts/rpc.py

@@ -2067,6 +2067,19 @@ def bdev_lvol_set_leader_all(args):
     p.add_argument('-u', '--uuid', help='lvol store UUID')
     p.add_argument('-s', '--lvs-name', help='lvol store name')
     p.set_defaults(func=bdev_lvol_set_leader_all)
+    
+    def bdev_lvol_set_lvs_read_only(args):
+        print_dict(rpc.lvol.bdev_lvol_set_lvs_read_only(args.client,
+                                                   uuid=args.uuid,
+                                                   lvs_name=args.lvs_name,
+                                                   read_only=args.read_only))
+
+    p = subparsers.add_parser('bdev_lvol_set_lvs_read_only',
+                              help='Change read only state for lvstore')
+    p.add_argument('-r', '--read-only', action='store_true', help='read only state for lvolstore level, default False')
+    p.add_argument('-u', '--uuid', help='lvol store UUID')
+    p.add_argument('-s', '--lvs-name', help='lvol store name')
+    p.set_defaults(func=bdev_lvol_set_lvs_read_only)
 
     def bdev_lvol_create(args):
         print_json(rpc.lvol.bdev_lvol_create(args.client,