libceph: add support for sparse reads to msgr2/crc
Subsystems (2)
cover libceph: add support for sparse reads to msgr2/crc
This is a first stab at a patchset to add support for sparse reads to libceph. This is a prerequisite for fscrypt support, since we need to be able to know whether a region is sparse in order to know whether we need to decrypt it.
The patches basically work at this point, but it's still a RFC for a few reasons:
1) the ms_mode=secure and ms_mode=legacy codepaths are not yet supported. "legacy" doesn't look too bad, but "secure" is a bit tougher, as I'd like to avoid extra buffering.
2) the OSD currently throws back -EINVAL on a sparse read if an extent has a non-zero truncate_seq. I've opened this bug to request that this be remedied: https://tracker.ceph.com/issues/54280
3) I'm not sure I got the revoke_at_* patch correct. I added a new field to the v2_info structure. Maybe there is some better way to handle that? What's the best way to test the revocation codepaths?
I ran this through xfstests yesterday, and several of them failed because of #2 above, but it didn't oops!
Jeff Layton (5):
libceph: allow ceph_msg_data_advance to advance more than a page
libceph: add sparse read support to msgr2 crc state machine
libceph: add sparse read support to OSD client
libceph: add revoke support for sparse data
ceph: switch to sparse reads
fs/ceph/addr.c | 2 +- fs/ceph/file.c | 4 +- include/linux/ceph/messenger.h | 20 ++++ include/linux/ceph/osd_client.h | 37 ++++++ net/ceph/messenger.c | 12 +- net/ceph/messenger_v2.c | 195 +++++++++++++++++++++++++++++--- net/ceph/osd_client.c | 161 +++++++++++++++++++++++++- 7 files changed, 408 insertions(+), 23 deletions(-)
Signature · 1 line
2.34.1
RFC PATCH 4/5 libceph: add revoke support for sparse data
Since sparse read handling is so complex, add a new field for tracking how much data we've read out of the data blob, and decrement that whenever we marshal up a new iov_iter for a read off the socket.
On a revoke, just ensure we skip past whatever remains in the iter, plus the remaining data_len and epilogue.
--- include/linux/ceph/messenger.h | 1 + net/ceph/messenger_v2.c | 37 +++++++++++++++++++++++++++++++--- 2 files changed, 35 insertions(+), 3 deletions(-)
include/linux/ceph/messenger.h +1 -0
@@ -413,6 +413,7 @@ struct ceph_connection_v2_info {void *conn_bufs[16 ];int conn_buf_cnt; +int data_len_remain;struct kvec in_sign_kvecs[8 ];struct kvec out_sign_kvecs[8 ];
net/ceph/messenger_v2.c +34 -3
@@ -1866,6 +1866,7 @@ static int prepare_sparse_read_cont(struct ceph_connection *con) bv.bv_offset =0 ; }set_in_bvec (con, &bv); + con->v2.data_len_remain -= bv.bv_len;WARN_ON (con->v2.in_state !=IN_S_PREPARE_SPARSE_DATA_CONT );return 0 ; }
@@ -1882,7 +1883,10 @@ static int prepare_sparse_read_cont(struct ceph_connection *con)return 0 ; } -return prepare_read_data_extent (con, off, len); + ret =prepare_read_data_extent (con, off, len); +if (ret ==0 ) + con->v2.data_len_remain -= len; +return ret; }static int prepare_sparse_read_header (struct ceph_connection *con)
@@ -1918,19 +1922,24 @@ static int prepare_sparse_read_header(struct ceph_connection *con)if (!buf) { ret =prepare_read_data_extent (con, off, len); -if (!ret) +if (!ret) { + con->v2.data_len_remain -= len; con->v2.in_state =IN_S_PREPARE_SPARSE_DATA_CONT ; + }return ret; }WARN_ON_ONCE (con->v2.in_state !=IN_S_PREPARE_SPARSE_DATA_HDR );reset_in_kvecs (con);add_in_kvec (con, buf, len); + con->v2.data_len_remain -= len;return 0 ; }static int prepare_sparse_read_data (struct ceph_connection *con) { +struct ceph_msg *msg = con->in_msg; +if (WARN_ON_ONCE (!con->ops->sparse_read))return -EOPNOTSUPP ;
@@ -1939,6 +1948,7 @@ static int prepare_sparse_read_data(struct ceph_connection *con)reset_in_kvecs (con); con->v2.in_state =IN_S_PREPARE_SPARSE_DATA_HDR ; + con->v2.data_len_remain =data_len (msg);return prepare_sparse_read_header (con); }
@@ -3620,6 +3630,23 @@ static void revoke_at_prepare_read_enc_page(struct ceph_connection *con) con->v2.in_state =IN_S_FINISH_SKIP ; } +static void revoke_at_prepare_sparse_data (struct ceph_connection *con) +{ +int resid;/* current piece of data */ +int remaining; + +WARN_ON (con_secure (con)); +WARN_ON (!data_len (con->in_msg)); +WARN_ON (!iov_iter_is_bvec (&con->v2.in_iter)); + resid =iov_iter_count (&con->v2.in_iter); +dout ("%s con %p resid %d\n" , __func__, con, resid); + + remaining =CEPH_EPILOGUE_PLAIN_LEN + con->v2.data_len_remain; + con->v2.in_iter.count -= resid; +set_in_skip (con, resid + remaining); + con->v2.in_state =IN_S_FINISH_SKIP ; +} +static void revoke_at_handle_epilogue (struct ceph_connection *con) {int resid;
@@ -3636,7 +3663,7 @@ static void revoke_at_handle_epilogue(struct ceph_connection *con)void ceph_con_v2_revoke_incoming (struct ceph_connection *con) {switch (con->v2.in_state) { -case IN_S_PREPARE_SPARSE_DATA :// FIXME +case IN_S_PREPARE_SPARSE_DATA :case IN_S_PREPARE_READ_DATA :revoke_at_prepare_read_data (con);break ;
@@ -3646,6 +3673,10 @@ void ceph_con_v2_revoke_incoming(struct ceph_connection *con)case IN_S_PREPARE_READ_ENC_PAGE :revoke_at_prepare_read_enc_page (con);break ; +case IN_S_PREPARE_SPARSE_DATA_HDR : +case IN_S_PREPARE_SPARSE_DATA_CONT : +revoke_at_prepare_sparse_data (con); +break ;case IN_S_HANDLE_EPILOGUE :revoke_at_handle_epilogue (con);break ;
Signature · 1 line
2.34.1
RFC PATCH 5/5 ceph: switch to sparse reads
In reply to Jeff LaytonSwitch the cephfs client to use sparse reads instead of normal ones.
XXX: doesn't currently work since OSD doesn't support truncate_seq
on a sparse read. See: https://tracker.ceph.com/issues/54280
--- fs/ceph/addr.c | 2 +- fs/ceph/file.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/ceph/addr.c +1 -1
@@ -317,7 +317,7 @@ static void ceph_netfs_issue_op(struct netfs_read_subrequest *subreq)return ; req =ceph_osdc_new_request (&fsc->client->osdc, &ci->i_layout, vino, subreq->start, &len, -0 ,1 ,CEPH_OSD_OP_READ , +0 ,1 ,CEPH_OSD_OP_SPARSE_READ ,CEPH_OSD_FLAG_READ | fsc->client->osdc.client->options->read_from_replica,NULL , ci->i_truncate_seq, ci->i_truncate_size, false);if (IS_ERR (req)) {
fs/ceph/file.c +2 -2
@@ -934,7 +934,7 @@ static ssize_t ceph_sync_read(struct kiocb *iocb, struct iov_iter *to, req =ceph_osdc_new_request (osdc, &ci->i_layout, ci->i_vino, off, &len,0 ,1 , -CEPH_OSD_OP_READ ,CEPH_OSD_FLAG_READ , +CEPH_OSD_OP_SPARSE_READ ,CEPH_OSD_FLAG_READ ,NULL , ci->i_truncate_seq, ci->i_truncate_size, false);if (IS_ERR (req)) {
@@ -1291,7 +1291,7 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter, vino, pos, &size,0 ,1 , write ?CEPH_OSD_OP_WRITE : -CEPH_OSD_OP_READ , +CEPH_OSD_OP_SPARSE_READ , flags, snapc, ci->i_truncate_seq, ci->i_truncate_size,
Signature · 1 line
2.34.1
RFC PATCH 1/5 libceph: allow ceph_msg_data_advance to advance more than a page
In reply to Jeff LaytonIn later patches, we're going to need to advance deeper into the data buffer in order to set up for a sparse read. Rename the existing routine, and add a wrapper around it that successively calls it until it has advanced far enougb.
--- net/ceph/messenger.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
net/ceph/messenger.c +11 -1
@@ -1084,7 +1084,7 @@ struct page *ceph_msg_data_next(struct ceph_msg_data_cursor *cursor,* Returns true if the result moves the cursor on to the next piece * of the data item. */ -void ceph_msg_data_advance (struct ceph_msg_data_cursor *cursor,size_t bytes) +static void __ceph_msg_data_advance (struct ceph_msg_data_cursor *cursor,size_t bytes) {bool new_piece;
@@ -1120,6 +1120,16 @@ void ceph_msg_data_advance(struct ceph_msg_data_cursor *cursor, size_t bytes) cursor->need_crc = new_piece; } +void ceph_msg_data_advance (struct ceph_msg_data_cursor *cursor,size_t bytes) +{ +while (bytes) { +size_t cur =min (bytes,PAGE_SIZE ); + +__ceph_msg_data_advance (cursor, cur); + bytes -= cur; + } +} +u32 ceph_crc32c_page (u32 crc,struct page *page,unsigned int page_offset,unsigned int length) {
Signature · 1 line
2.34.1
RFC PATCH 3/5 libceph: add sparse read support to OSD client
In reply to Jeff LaytonAdd a new sparse_read operation for the OSD client, driven by its own state machine. The messenger can repeatedly call the sparse_read operation, and it will pass back the necessary info to set up to read the next extent of data, while zeroing in the sparse regions.
--- include/linux/ceph/osd_client.h | 37 ++++++++ net/ceph/osd_client.c | 161 +++++++++++++++++++++++++++++++- 2 files changed, 193 insertions(+), 5 deletions(-)
include/linux/ceph/osd_client.h +37 -0
@@ -29,6 +29,42 @@ typedef void (*ceph_osdc_callback_t)(struct ceph_osd_request *);#define CEPH_HOMELESS_OSD -1 +enum ceph_sparse_read_state { +CEPH_SPARSE_READ_COUNT =0 , +CEPH_SPARSE_READ_EXTENTS , +CEPH_SPARSE_READ_DATA_LEN , +CEPH_SPARSE_READ_DATA , +}; + +/* A single extent in a SPARSE_READ reply */ +struct ceph_sparse_extent { +__le64 off; +__le64 len; +} __attribute__((packed)); + +/* +* A SPARSE_READ reply is a 32-bit count of extents, followed by an array of +* 64-bit offset/length pairs, and then all of the actual file data +* concatenated after it (sans holes). +* +* Unfortunately, we don't know how long the extent array is until we've +* started reading the data section of the reply, so for a real sparse read, we +* have to allocate the array after alloc_msg returns. +* +* For the common case of a single extent, we keep an embedded extent here so +* we can avoid the extra allocation. +*/ +struct ceph_sparse_read { +enum ceph_sparse_read_state sr_state;/* state machine state */ +u64 sr_offset;/* request obj offset */ +u64 sr_pos;/* current pos in buffer */ +int sr_index;/* current extent index */ +__le32 sr_count;/* number of extents */ +__le32 sr_datalen;/* length of actual data */ +struct ceph_sparse_extent *sr_extent;/* extent array */ +struct ceph_sparse_extent sr_emb_ext[1 ];/* extent (for trivial cases */ +}; +/* a given osd we're communicating with */ struct ceph_osd {refcount_t o_ref;
@@ -46,6 +82,7 @@ struct ceph_osd {unsigned long lru_ttl;struct list_head o_keepalive_item;struct mutex lock; +struct ceph_sparse_read o_sparse_read; };#define CEPH_OSD_SLAB_OPS 2
net/ceph/osd_client.c +156 -5
261 lines not on this page · raw message
Signature · 1 line
2.34.1
RFC PATCH 2/5 libceph: add sparse read support to msgr2 crc state machine
In reply to Jeff LaytonAdd support for a new sparse_read ceph_connection operation. The idea is that the client code can define this operation use it to do special handling for incoming reads.
The alloc_msg routine can look at the request and determine whether the reply is expected to be sparse. If it is, then we'll dispatch to a different set of state machine states that will repeatedly call sparse_read get length and placement info for reading the extent map, and the extents themselves.
TODO: support for revoke during a sparse read
--- include/linux/ceph/messenger.h | 19 ++++ net/ceph/messenger_v2.c | 164 ++++++++++++++++++++++++++++++--- 2 files changed, 169 insertions(+), 14 deletions(-)
include/linux/ceph/messenger.h +19 -0
@@ -25,6 +25,22 @@ struct ceph_connection_operations {struct ceph_connection *(*get)(struct ceph_connection *);void (*put)(struct ceph_connection *); +/** +* sparse_read: read sparse data +* @con: connection we're reading from +* @off: offset into msgr data caller should read into +* @len: len of the data that msgr should read +* @buf: optional buffer to read into +* +* This should be called more than once, each time setting up to +* receive an extent into the correct portion of the buffer (and +* zeroing the holes between them). +* +* Returns 1 if there is more data to be read, 0 if reading is +* complete, or -errno if there was an error. +*/ +int (*sparse_read)(struct ceph_connection *con,u64 *off,u64 *len,char **buf); +/* handle an incoming message. */ void (*dispatch) (struct ceph_connection *con,struct ceph_msg *m);
@@ -252,6 +268,7 @@ struct ceph_msg {struct kref kref;bool more_to_follow;bool needs_out_seq; +bool sparse_read;int front_alloc_len;struct ceph_msgpool *pool;
@@ -464,6 +481,8 @@ struct ceph_connection {struct page *bounce_page;u32 in_front_crc, in_middle_crc, in_data_crc;/* calculated crc */ +int sparse_resid; +struct timespec64 last_keepalive_ack;/* keepalive2 ack stamp */ struct delayed_work work;/* send|recv work */
net/ceph/messenger_v2.c +150 -14
212 lines not on this page · raw message
Signature · 1 line
2.34.1