From 4b1ba33d7ab5f122e02b1cf8da4285b2ba798613 Mon Sep 17 00:00:00 2001 From: Emoly Liu Date: Wed, 26 Feb 2020 16:00:17 +0800 Subject: [PATCH] LU-12811 ptlrpc: do some cleanups in swabber_dumper_helper() This patch combines the process of dump/swab/dump calls for both array and non-array cases in function swabber_dumper_helper(), also does some code cleanups. Signed-off-by: Emoly Liu Change-Id: Iccd487999ad998068b4fae6a614bad3b17737d07 Reviewed-on: https://review.whamcloud.com/36848 Reviewed-by: Andreas Dilger Tested-by: jenkins Tested-by: Maloo Reviewed-by: Sebastien Buisson --- lustre/ptlrpc/layout.c | 136 ++++++++++++++++++++++--------------------------- 1 file changed, 61 insertions(+), 75 deletions(-) diff --git a/lustre/ptlrpc/layout.c b/lustre/ptlrpc/layout.c index ad804d8..c963114 100644 --- a/lustre/ptlrpc/layout.c +++ b/lustre/ptlrpc/layout.c @@ -1997,57 +1997,33 @@ swabber_dumper_helper(struct req_capsule *pill, const struct req_msg_field *field, enum req_location loc, int offset, - void *value, int len, int dump, void (*swabber)(void *)) + void *value, int len, bool dump, void (*swabber)(void *)) { - void *p; - int i; - int n; - int size; - int rc = 0; - int do_swab; - int inout = loc == RCL_CLIENT; + void *p; + int i; + int n; + int size; + int rc = 0; + bool do_swab; + bool inout = loc == RCL_CLIENT; + bool array = field->rmf_flags & RMF_F_STRUCT_ARRAY; swabber = swabber ?: field->rmf_swabber; if (ptlrpc_buf_need_swab(pill->rc_req, inout, offset) && (swabber != NULL || field->rmf_swab_len != NULL) && value != NULL) - do_swab = 1; + do_swab = true; else - do_swab = 0; + do_swab = false; if (!field->rmf_dumper) - dump = 0; - - if (!(field->rmf_flags & RMF_F_STRUCT_ARRAY)) { - if (dump) { - CDEBUG(D_RPCTRACE, "Dump of %sfield %s follows\n", - do_swab ? "unswabbed " : "", field->rmf_name); - field->rmf_dumper(value); - } - if (!do_swab) - return 0; - if (!field->rmf_swab_len) { - swabber(value); - } else { - size = field->rmf_swab_len(value, len); - if (size < 0) - rc = size; - } - ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset); - if (dump) { - CDEBUG(D_RPCTRACE, "Dump of swabbed field %s " - "follows\n", field->rmf_name); - field->rmf_dumper(value); - } - - return rc; - } + dump = false; /* * We're swabbing an array; swabber() swabs a single array element, so * swab every element. */ - if (len % field->rmf_size) { + if (array && (len % field->rmf_size)) { static const struct req_msg_field *last_field; if (field != last_field) { @@ -2056,17 +2032,27 @@ swabber_dumper_helper(struct req_capsule *pill, last_field = field; } } - for (p = value, i = 0, n = len / field->rmf_size; - i < n; - i++, p += field->rmf_size) { - if (dump) { - CDEBUG(D_RPCTRACE, "Dump of %sarray field %s, " - "element %d follows\n", - do_swab ? "unswabbed " : "", field->rmf_name, i); - field->rmf_dumper(p); - } - if (!do_swab) - continue; + /* For the non-array cases, the process of swab/dump/swab only + * needs to be done once. (n = 1) + */ + if (!array) + len = field->rmf_size; + for (p = value, i = 0, n = len / field->rmf_size; + i < n; + i++, p += field->rmf_size) { + if (dump) { + CDEBUG(D_RPCTRACE, "Dump of %s%sfield %s element %d follows\n", + do_swab ? "unswabbed " : "", + array ? "array " : "", + field->rmf_name, i); + field->rmf_dumper(p); + } + if (!do_swab) { + if (array) + continue; + else + break; + } if (!field->rmf_swab_len) { swabber(p); } else { @@ -2078,11 +2064,11 @@ swabber_dumper_helper(struct req_capsule *pill, break; } } - if (dump) { - CDEBUG(D_RPCTRACE, "Dump of swabbed array field %s, " - "element %d follows\n", field->rmf_name, i); - field->rmf_dumper(value); - } + if (dump) { + CDEBUG(D_RPCTRACE, "Dump of swabbed %sfield %s, element %d follows\n", + array ? "array " : "", field->rmf_name, i); + field->rmf_dumper(value); + } } if (do_swab) ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset); @@ -2101,14 +2087,14 @@ swabber_dumper_helper(struct req_capsule *pill, * element of the array swabbed. */ static void *__req_capsule_get(struct req_capsule *pill, - const struct req_msg_field *field, - enum req_location loc, - void (*swabber)( void *), - int dump) + const struct req_msg_field *field, + enum req_location loc, + void (*swabber)(void *), + bool dump) { - const struct req_format *fmt; - struct lustre_msg *msg; - void *value; + const struct req_format *fmt; + struct lustre_msg *msg; + void *value; __u32 len; __u32 offset; @@ -2194,7 +2180,7 @@ void __req_capsule_dump(struct req_capsule *pill, enum req_location loc) field->rmf_name, len); } else { /* It's dumping side-effect that we're interested in */ - (void) __req_capsule_get(pill, field, loc, NULL, 1); + (void) __req_capsule_get(pill, field, loc, NULL, true); } } CDEBUG(D_RPCTRACE, "END REQ CAPSULE DUMP\n"); @@ -2223,9 +2209,9 @@ EXPORT_SYMBOL(req_capsule_server_dump); * buffer corresponding to the given RMF (\a field) of a \a pill. */ void *req_capsule_client_get(struct req_capsule *pill, - const struct req_msg_field *field) + const struct req_msg_field *field) { - return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0); + return __req_capsule_get(pill, field, RCL_CLIENT, NULL, false); } EXPORT_SYMBOL(req_capsule_client_get); @@ -2239,7 +2225,7 @@ void *req_capsule_client_swab_get(struct req_capsule *pill, const struct req_msg_field *field, void *swabber) { - return __req_capsule_get(pill, field, RCL_CLIENT, swabber, 0); + return __req_capsule_get(pill, field, RCL_CLIENT, swabber, false); } EXPORT_SYMBOL(req_capsule_client_swab_get); @@ -2254,8 +2240,8 @@ void *req_capsule_client_sized_get(struct req_capsule *pill, const struct req_msg_field *field, __u32 len) { - req_capsule_set_size(pill, field, RCL_CLIENT, len); - return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0); + req_capsule_set_size(pill, field, RCL_CLIENT, len); + return __req_capsule_get(pill, field, RCL_CLIENT, NULL, false); } EXPORT_SYMBOL(req_capsule_client_sized_get); @@ -2266,7 +2252,7 @@ EXPORT_SYMBOL(req_capsule_client_sized_get); void *req_capsule_server_get(struct req_capsule *pill, const struct req_msg_field *field) { - return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0); + return __req_capsule_get(pill, field, RCL_SERVER, NULL, false); } EXPORT_SYMBOL(req_capsule_server_get); @@ -2277,10 +2263,10 @@ EXPORT_SYMBOL(req_capsule_server_get); * swabbing done outside this capsule abstraction. */ void *req_capsule_server_swab_get(struct req_capsule *pill, - const struct req_msg_field *field, - void *swabber) + const struct req_msg_field *field, + void *swabber) { - return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0); + return __req_capsule_get(pill, field, RCL_SERVER, swabber, false); } EXPORT_SYMBOL(req_capsule_server_swab_get); @@ -2295,8 +2281,8 @@ void *req_capsule_server_sized_get(struct req_capsule *pill, const struct req_msg_field *field, __u32 len) { - req_capsule_set_size(pill, field, RCL_SERVER, len); - return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0); + req_capsule_set_size(pill, field, RCL_SERVER, len); + return __req_capsule_get(pill, field, RCL_SERVER, NULL, false); } EXPORT_SYMBOL(req_capsule_server_sized_get); @@ -2305,7 +2291,7 @@ void *req_capsule_server_sized_swab_get(struct req_capsule *pill, __u32 len, void *swabber) { req_capsule_set_size(pill, field, RCL_SERVER, len); - return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0); + return __req_capsule_get(pill, field, RCL_SERVER, swabber, false); } EXPORT_SYMBOL(req_capsule_server_sized_swab_get); @@ -2318,9 +2304,9 @@ EXPORT_SYMBOL(req_capsule_server_sized_swab_get); * client and server alike. */ const void *req_capsule_other_get(struct req_capsule *pill, - const struct req_msg_field *field) + const struct req_msg_field *field) { - return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL, 0); + return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL, false); } EXPORT_SYMBOL(req_capsule_other_get); -- 1.8.3.1