Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-01 02:36:02 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

net: netconsole: split send_msg_fragmented

Browse Source 
Refactor the send_msg_fragmented() function by extracting the logic for
sending the message body into a new function called
send_fragmented_body().

Now, send_msg_fragmented() handles appending the release and header, and
then delegates the task of breaking up the body and sending the
fragments to send_fragmented_body().

This is the final flow now:

When send_ext_msg_udp() is called to send a message, it will:
  - call send_msg_no_fragmentation() if no fragmentation is needed
  or
  - call send_msg_fragmented() if fragmentation is needed
    * send_msg_fragmented() appends the header to the buffer, which is
      be persisted until the function returns
      * call send_fragmented_body() to iterate and populate the body of
	the message. It will not touch the header, and it will only
	replace the body, writing the msgbody and/or userdata.

Also add some comment to make the code easier to review.

Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Simon Horman <horms@kernel.org>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
This commit is contained in:
Breno Leitao 2024-10-17 02:50:24 -07:00 committed by Paolo Abeni
parent 144d57360f
commit 60be416c63
1 changed files with 50 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
drivers/net/netconsole.c
View File

@ -1096,46 +1096,30 @@ static void append_release(char *buf)
scnprintf(buf, MAX_PRINT_CHUNK, "%s,", release);
}
static void send_msg_fragmented(struct netconsole_target *nt,
const char *msg,
int msg_len,
int release_len)
static void send_fragmented_body(struct netconsole_target *nt, char *buf,
const char *msgbody, int header_len,
int msgbody_len)
{
int header_len, msgbody_len, body_len;
static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
int offset = 0, userdata_len = 0;
const char *header, *msgbody;
const char *userdata = NULL;
int body_len, offset = 0;
int userdata_len = 0;
#ifdef CONFIG_NETCONSOLE_DYNAMIC
userdata = nt->userdata_complete;
userdata_len = nt->userdata_length;
#endif
/* need to insert extra header fields, detect header and msgbody */
header = msg;
msgbody = memchr(msg, ';', msg_len);
if (WARN_ON_ONCE(!msgbody))
return;
header_len = msgbody - header;
msgbody_len = msg_len - header_len - 1;
msgbody++;
/*
* Transfer multiple chunks with the following extra header.
* "ncfrag=<byte-offset>/<total-bytes>"
/* body_len represents the number of bytes that will be sent. This is
* bigger than MAX_PRINT_CHUNK, thus, it will be split in multiple
* packets
*/
if (release_len)
append_release(buf);
/* Copy the header into the buffer */
memcpy(buf + release_len, header, header_len);
header_len += release_len;
body_len = msgbody_len + userdata_len;
/* for now on, the header will be persisted, and the msgbody
* will be replaced
/* In each iteration of the while loop below, we send a packet
* containing the header and a portion of the body. The body is
* composed of two parts: msgbody and userdata. We keep track of how
* many bytes have been sent so far using the offset variable, which
* ranges from 0 to the total length of the body.
*/
while (offset < body_len) {
int this_header = header_len;
@ -1144,7 +1128,7 @@ static void send_msg_fragmented(struct netconsole_target *nt,
int this_chunk = 0;
this_header += scnprintf(buf + this_header,
sizeof(buf) - this_header,
MAX_PRINT_CHUNK - this_header,
",ncfrag=%d/%d;", offset,
body_len);
@ -1199,6 +1183,41 @@ static void send_msg_fragmented(struct netconsole_target *nt,
}
}
static void send_msg_fragmented(struct netconsole_target *nt,
const char *msg,
int msg_len,
int release_len)
{
static char buf[MAX_PRINT_CHUNK]; /* protected by target_list_lock */
int header_len, msgbody_len;
const char *msgbody;
/* need to insert extra header fields, detect header and msgbody */
msgbody = memchr(msg, ';', msg_len);
if (WARN_ON_ONCE(!msgbody))
return;
header_len = msgbody - msg;
msgbody_len = msg_len - header_len - 1;
msgbody++;
/*
* Transfer multiple chunks with the following extra header.
* "ncfrag=<byte-offset>/<total-bytes>"
*/
if (release_len)
append_release(buf);
/* Copy the header into the buffer */
memcpy(buf + release_len, msg, header_len);
header_len += release_len;
/* for now on, the header will be persisted, and the msgbody
* will be replaced
*/
send_fragmented_body(nt, buf, msgbody, header_len, msgbody_len);
}
/**
* send_ext_msg_udp - send extended log message to target
* @nt: target to send message to