UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

printk: introduce a kmsg_dump iterator 

Rather than storing the iterator information in the registered
kmsg_dumper structure, create a separate iterator structure. The
kmsg_dump_iter structure can reside on the stack of the caller, thus
allowing lockless use of the kmsg_dump functions.

Update code that accesses the kernel logs using the kmsg_dumper
structure to use the new kmsg_dump_iter structure. For kmsg_dumpers,
this also means adding a call to kmsg_dump_rewind() to initialize
the iterator.

All this is in preparation for removal of @logbuf_lock.

Signed-off-by: John Ogness <john.ogness@linutronix.de>
Reviewed-by: Kees Cook <keescook@chromium.org> # pstore
Reviewed-by: Petr Mladek <pmladek@suse.com>
Signed-off-by: Petr Mladek <pmladek@suse.com>
Link: https://lore.kernel.org/r/20210303101528.29901-13-john.ogness@linutronix.de
This commit is contained in:
John Ogness 2021-03-03 11:15:25 +01:00 committed by Petr Mladek
parent 5f6c7648e5
commit f9f3f02db9
9 changed files with 80 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
arch/powerpc/kernel/nvram_64.c
View File

@ -647,6 +647,7 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
{ {
struct oops_log_info *oops_hdr = (struct oops_log_info *)oops_buf; struct oops_log_info *oops_hdr = (struct oops_log_info *)oops_buf;
static unsigned int oops_count = 0; static unsigned int oops_count = 0;
static struct kmsg_dump_iter iter;
static bool panicking = false; static bool panicking = false;
static DEFINE_SPINLOCK(lock); static DEFINE_SPINLOCK(lock);
unsigned long flags; unsigned long flags;
@ -681,13 +682,14 @@ static void oops_to_nvram(struct kmsg_dumper *dumper,
return; return;
if (big_oops_buf) { if (big_oops_buf) {
kmsg_dump_get_buffer(dumper, false, kmsg_dump_rewind(&iter);
kmsg_dump_get_buffer(&iter, false,
big_oops_buf, big_oops_buf_sz, &text_len); big_oops_buf, big_oops_buf_sz, &text_len);
rc = zip_oops(text_len); rc = zip_oops(text_len);
} }
if (rc != 0) { if (rc != 0) {
kmsg_dump_rewind(dumper); kmsg_dump_rewind(&iter);
kmsg_dump_get_buffer(dumper, false, kmsg_dump_get_buffer(&iter, false,
oops_data, oops_data_sz, &text_len); oops_data, oops_data_sz, &text_len);
err_type = ERR_TYPE_KERNEL_PANIC; err_type = ERR_TYPE_KERNEL_PANIC;
oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION); oops_hdr->version = cpu_to_be16(OOPS_HDR_VERSION);

6
arch/powerpc/xmon/xmon.c
View File

@ -3005,7 +3005,7 @@ print_address(unsigned long addr)
static void static void
dump_log_buf(void) dump_log_buf(void)
{ {
struct kmsg_dumper dumper; struct kmsg_dump_iter iter;
unsigned char buf[128]; unsigned char buf[128];
size_t len; size_t len;
@ -3017,9 +3017,9 @@ dump_log_buf(void)
catch_memory_errors = 1; catch_memory_errors = 1;
sync(); sync();
kmsg_dump_rewind_nolock(&dumper); kmsg_dump_rewind_nolock(&iter);
xmon_start_pagination(); xmon_start_pagination();
while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) { while (kmsg_dump_get_line_nolock(&iter, false, buf, sizeof(buf), &len)) {
buf[len] = '\0'; buf[len] = '\0';
printf("%s", buf); printf("%s", buf);
} }

5
arch/um/kernel/kmsg_dump.c
View File

@ -10,6 +10,7 @@
static void kmsg_dumper_stdout(struct kmsg_dumper *dumper, static void kmsg_dumper_stdout(struct kmsg_dumper *dumper,
enum kmsg_dump_reason reason) enum kmsg_dump_reason reason)
{ {
static struct kmsg_dump_iter iter;
static DEFINE_SPINLOCK(lock); static DEFINE_SPINLOCK(lock);
static char line[1024]; static char line[1024];
struct console *con; struct console *con;
@ -35,8 +36,10 @@ static void kmsg_dumper_stdout(struct kmsg_dumper *dumper,
if (!spin_trylock_irqsave(&lock, flags)) if (!spin_trylock_irqsave(&lock, flags))
return; return;
kmsg_dump_rewind(&iter);
printf("kmsg_dump:\n"); printf("kmsg_dump:\n");
while (kmsg_dump_get_line(dumper, true, line, sizeof(line), &len)) { while (kmsg_dump_get_line(&iter, true, line, sizeof(line), &len)) {
line[len] = '\0'; line[len] = '\0';
printf("%s", line); printf("%s", line);
} }

4
drivers/hv/vmbus_drv.c
View File

@ -1391,6 +1391,7 @@ static void vmbus_isr(void)
static void hv_kmsg_dump(struct kmsg_dumper *dumper, static void hv_kmsg_dump(struct kmsg_dumper *dumper,
enum kmsg_dump_reason reason) enum kmsg_dump_reason reason)
{ {
struct kmsg_dump_iter iter;
size_t bytes_written; size_t bytes_written;
phys_addr_t panic_pa; phys_addr_t panic_pa;
@ -1404,7 +1405,8 @@ static void hv_kmsg_dump(struct kmsg_dumper *dumper,
* Write dump contents to the page. No need to synchronize; panic should * Write dump contents to the page. No need to synchronize; panic should
* be single-threaded. * be single-threaded.
*/ */
kmsg_dump_get_buffer(dumper, false, hv_panic_page, HV_HYP_PAGE_SIZE, kmsg_dump_rewind(&iter);
kmsg_dump_get_buffer(&iter, false, hv_panic_page, HV_HYP_PAGE_SIZE,
&bytes_written); &bytes_written);
if (bytes_written) if (bytes_written)
hyperv_report_panic_msg(panic_pa, bytes_written); hyperv_report_panic_msg(panic_pa, bytes_written);

5
drivers/mtd/mtdoops.c
View File

@ -277,14 +277,17 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
{ {
struct mtdoops_context *cxt = container_of(dumper, struct mtdoops_context *cxt = container_of(dumper,
struct mtdoops_context, dump); struct mtdoops_context, dump);
struct kmsg_dump_iter iter;
/* Only dump oopses if dump_oops is set */ /* Only dump oopses if dump_oops is set */
if (reason == KMSG_DUMP_OOPS && !dump_oops) if (reason == KMSG_DUMP_OOPS && !dump_oops)
return; return;
kmsg_dump_rewind(&iter);
if (test_and_set_bit(0, &cxt->oops_buf_busy)) if (test_and_set_bit(0, &cxt->oops_buf_busy))
return; return;
kmsg_dump_get_buffer(dumper, true, cxt->oops_buf + MTDOOPS_HEADER_SIZE, kmsg_dump_get_buffer(&iter, true, cxt->oops_buf + MTDOOPS_HEADER_SIZE,
record_size - MTDOOPS_HEADER_SIZE, NULL); record_size - MTDOOPS_HEADER_SIZE, NULL);
clear_bit(0, &cxt->oops_buf_busy); clear_bit(0, &cxt->oops_buf_busy);

5
fs/pstore/platform.c
View File

@ -385,6 +385,7 @@ void pstore_record_init(struct pstore_record *record,
static void pstore_dump(struct kmsg_dumper *dumper, static void pstore_dump(struct kmsg_dumper *dumper,
enum kmsg_dump_reason reason) enum kmsg_dump_reason reason)
{ {
struct kmsg_dump_iter iter;
unsigned long total = 0; unsigned long total = 0;
const char *why; const char *why;
unsigned int part = 1; unsigned int part = 1;
@ -405,6 +406,8 @@ static void pstore_dump(struct kmsg_dumper *dumper,
} }
} }
kmsg_dump_rewind(&iter);
oopscount++; oopscount++;
while (total < kmsg_bytes) { while (total < kmsg_bytes) {
char *dst; char *dst;
@ -435,7 +438,7 @@ static void pstore_dump(struct kmsg_dumper *dumper,
dst_size -= header_size; dst_size -= header_size;
/* Write dump contents. */ /* Write dump contents. */
if (!kmsg_dump_get_buffer(dumper, true, dst + header_size, if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,
dst_size, &dump_size)) dst_size, &dump_size))
break; break;

36
include/linux/kmsg_dump.h
View File

@ -29,6 +29,16 @@ enum kmsg_dump_reason {
KMSG_DUMP_MAX KMSG_DUMP_MAX
}; };
/**
* struct kmsg_dump_iter - iterator for retrieving kernel messages
* @cur_seq: Points to the oldest message to dump
* @next_seq: Points after the newest message to dump
*/
struct kmsg_dump_iter {
u64 cur_seq;
u64 next_seq;
};
/** /**
* struct kmsg_dumper - kernel crash message dumper structure * struct kmsg_dumper - kernel crash message dumper structure
* @list: Entry in the dumper list (private) * @list: Entry in the dumper list (private)
@ -36,35 +46,29 @@ enum kmsg_dump_reason {
* through the record iterator * through the record iterator
* @max_reason: filter for highest reason number that should be dumped * @max_reason: filter for highest reason number that should be dumped
* @registered: Flag that specifies if this is already registered * @registered: Flag that specifies if this is already registered
* @cur_seq: Points to the oldest message to dump
* @next_seq: Points after the newest message to dump
*/ */
struct kmsg_dumper { struct kmsg_dumper {
struct list_head list; struct list_head list;
void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason); void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason);
enum kmsg_dump_reason max_reason; enum kmsg_dump_reason max_reason;
bool registered; bool registered;
/* private state of the kmsg iterator */
u64 cur_seq;
u64 next_seq;
}; };
#ifdef CONFIG_PRINTK #ifdef CONFIG_PRINTK
void kmsg_dump(enum kmsg_dump_reason reason); void kmsg_dump(enum kmsg_dump_reason reason);
bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_line_nolock(struct kmsg_dump_iter *iter, bool syslog,
char *line, size_t size, size_t *len); char *line, size_t size, size_t *len);
bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,
char *line, size_t size, size_t *len); char *line, size_t size, size_t *len);
bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,
char *buf, size_t size, size_t *len_out); char *buf, size_t size, size_t *len_out);
void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper); void kmsg_dump_rewind_nolock(struct kmsg_dump_iter *iter);
void kmsg_dump_rewind(struct kmsg_dumper *dumper); void kmsg_dump_rewind(struct kmsg_dump_iter *iter);
int kmsg_dump_register(struct kmsg_dumper *dumper); int kmsg_dump_register(struct kmsg_dumper *dumper);
@ -76,30 +80,30 @@ static inline void kmsg_dump(enum kmsg_dump_reason reason)
{ {
} }
static inline bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, static inline bool kmsg_dump_get_line_nolock(struct kmsg_dump_iter *iter,
bool syslog, const char *line, bool syslog, const char *line,
size_t size, size_t *len) size_t size, size_t *len)
{ {
return false; return false;
} }
static inline bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog, static inline bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,
const char *line, size_t size, size_t *len) const char *line, size_t size, size_t *len)
{ {
return false; return false;
} }
static inline bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog, static inline bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,
char *buf, size_t size, size_t *len) char *buf, size_t size, size_t *len)
{ {
return false; return false;
} }
static inline void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper) static inline void kmsg_dump_rewind_nolock(struct kmsg_dump_iter *iter)
{ {
} }
static inline void kmsg_dump_rewind(struct kmsg_dumper *dumper) static inline void kmsg_dump_rewind(struct kmsg_dump_iter *iter)
{ {
} }

10
kernel/debug/kdb/kdb_main.c
View File

@ -2101,7 +2101,7 @@ static int kdb_dmesg(int argc, const char **argv)
int adjust = 0; int adjust = 0;
int n = 0; int n = 0;
int skip = 0; int skip = 0;
struct kmsg_dumper dumper; struct kmsg_dump_iter iter;
size_t len; size_t len;
char buf[201]; char buf[201];
@ -2126,8 +2126,8 @@ static int kdb_dmesg(int argc, const char **argv)
kdb_set(2, setargs); kdb_set(2, setargs);
} }
kmsg_dump_rewind_nolock(&dumper); kmsg_dump_rewind_nolock(&iter);
while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL)) while (kmsg_dump_get_line_nolock(&iter, 1, NULL, 0, NULL))
n++; n++;
if (lines < 0) { if (lines < 0) {
@ -2159,8 +2159,8 @@ static int kdb_dmesg(int argc, const char **argv)
if (skip >= n || skip < 0) if (skip >= n || skip < 0)
return 0; return 0;
kmsg_dump_rewind_nolock(&dumper); kmsg_dump_rewind_nolock(&iter);
while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) { while (kmsg_dump_get_line_nolock(&iter, 1, buf, sizeof(buf), &len)) {
if (skip) { if (skip) {
skip--; skip--;
continue; continue;

63
kernel/printk/printk.c
View File

@ -3390,7 +3390,6 @@ EXPORT_SYMBOL_GPL(kmsg_dump_reason_str);
void kmsg_dump(enum kmsg_dump_reason reason) void kmsg_dump(enum kmsg_dump_reason reason)
{ {
struct kmsg_dumper *dumper; struct kmsg_dumper *dumper;
unsigned long flags;
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(dumper, &dump_list, list) { list_for_each_entry_rcu(dumper, &dump_list, list) {
@ -3407,12 +3406,6 @@ void kmsg_dump(enum kmsg_dump_reason reason)
if (reason > max_reason) if (reason > max_reason)
continue; continue;
/* initialize iterator with data about the stored records */
logbuf_lock_irqsave(flags);
dumper->cur_seq = latched_seq_read_nolock(&clear_seq);
dumper->next_seq = prb_next_seq(prb);
logbuf_unlock_irqrestore(flags);
/* invoke dumper which will iterate over records */ /* invoke dumper which will iterate over records */
dumper->dump(dumper, reason); dumper->dump(dumper, reason);
} }
@ -3421,7 +3414,7 @@ void kmsg_dump(enum kmsg_dump_reason reason)
/** /**
* kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version) * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
* @dumper: registered kmsg dumper * @iter: kmsg dump iterator
* @syslog: include the "<4>" prefixes * @syslog: include the "<4>" prefixes
* @line: buffer to copy the line to * @line: buffer to copy the line to
* @size: maximum size of the buffer * @size: maximum size of the buffer
@ -3438,24 +3431,28 @@ void kmsg_dump(enum kmsg_dump_reason reason)
* *
* The function is similar to kmsg_dump_get_line(), but grabs no locks. * The function is similar to kmsg_dump_get_line(), but grabs no locks.
*/ */
bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_line_nolock(struct kmsg_dump_iter *iter, bool syslog,
char *line, size_t size, size_t *len) char *line, size_t size, size_t *len)
{ {
u64 min_seq = latched_seq_read_nolock(&clear_seq);
struct printk_info info; struct printk_info info;
unsigned int line_count; unsigned int line_count;
struct printk_record r; struct printk_record r;
size_t l = 0; size_t l = 0;
bool ret = false; bool ret = false;
if (iter->cur_seq < min_seq)
iter->cur_seq = min_seq;
prb_rec_init_rd(&r, &info, line, size); prb_rec_init_rd(&r, &info, line, size);
/* Read text or count text lines? */ /* Read text or count text lines? */
if (line) { if (line) {
if (!prb_read_valid(prb, dumper->cur_seq, &r)) if (!prb_read_valid(prb, iter->cur_seq, &r))
goto out; goto out;
l = record_print_text(&r, syslog, printk_time); l = record_print_text(&r, syslog, printk_time);
} else { } else {
if (!prb_read_valid_info(prb, dumper->cur_seq, if (!prb_read_valid_info(prb, iter->cur_seq,
&info, &line_count)) { &info, &line_count)) {
goto out; goto out;
} }
@ -3464,7 +3461,7 @@ bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
} }
dumper->cur_seq = r.info->seq + 1; iter->cur_seq = r.info->seq + 1;
ret = true; ret = true;
out: out:
if (len) if (len)
@ -3474,7 +3471,7 @@ out:
/** /**
* kmsg_dump_get_line - retrieve one kmsg log line * kmsg_dump_get_line - retrieve one kmsg log line
* @dumper: registered kmsg dumper * @iter: kmsg dump iterator
* @syslog: include the "<4>" prefixes * @syslog: include the "<4>" prefixes
* @line: buffer to copy the line to * @line: buffer to copy the line to
* @size: maximum size of the buffer * @size: maximum size of the buffer
@ -3489,14 +3486,14 @@ out:
* A return value of FALSE indicates that there are no more records to * A return value of FALSE indicates that there are no more records to
* read. * read.
*/ */
bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,
char *line, size_t size, size_t *len) char *line, size_t size, size_t *len)
{ {
unsigned long flags; unsigned long flags;
bool ret; bool ret;
logbuf_lock_irqsave(flags); logbuf_lock_irqsave(flags);
ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len); ret = kmsg_dump_get_line_nolock(iter, syslog, line, size, len);
logbuf_unlock_irqrestore(flags); logbuf_unlock_irqrestore(flags);
return ret; return ret;
@ -3505,7 +3502,7 @@ EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
/** /**
* kmsg_dump_get_buffer - copy kmsg log lines * kmsg_dump_get_buffer - copy kmsg log lines
* @dumper: registered kmsg dumper * @iter: kmsg dump iterator
* @syslog: include the "<4>" prefixes * @syslog: include the "<4>" prefixes
* @buf: buffer to copy the line to * @buf: buffer to copy the line to
* @size: maximum size of the buffer * @size: maximum size of the buffer
@ -3522,9 +3519,10 @@ EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
* A return value of FALSE indicates that there are no more records to * A return value of FALSE indicates that there are no more records to
* read. * read.
*/ */
bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog, bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,
char *buf, size_t size, size_t *len_out) char *buf, size_t size, size_t *len_out)
{ {
u64 min_seq = latched_seq_read_nolock(&clear_seq);
struct printk_info info; struct printk_info info;
struct printk_record r; struct printk_record r;
unsigned long flags; unsigned long flags;
@ -3537,16 +3535,19 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
if (!buf || !size) if (!buf || !size)
goto out; goto out;
if (iter->cur_seq < min_seq)
iter->cur_seq = min_seq;
logbuf_lock_irqsave(flags); logbuf_lock_irqsave(flags);
if (prb_read_valid_info(prb, dumper->cur_seq, &info, NULL)) { if (prb_read_valid_info(prb, iter->cur_seq, &info, NULL)) {
if (info.seq != dumper->cur_seq) { if (info.seq != iter->cur_seq) {
/* messages are gone, move to first available one */ /* messages are gone, move to first available one */
dumper->cur_seq = info.seq; iter->cur_seq = info.seq;
} }
} }
/* last entry */ /* last entry */
if (dumper->cur_seq >= dumper->next_seq) { if (iter->cur_seq >= iter->next_seq) {
logbuf_unlock_irqrestore(flags); logbuf_unlock_irqrestore(flags);
goto out; goto out;
} }
@ -3557,7 +3558,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
* because this function (by way of record_print_text()) will * because this function (by way of record_print_text()) will
* not write more than size-1 bytes of text into @buf. * not write more than size-1 bytes of text into @buf.
*/ */
seq = find_first_fitting_seq(dumper->cur_seq, dumper->next_seq, seq = find_first_fitting_seq(iter->cur_seq, iter->next_seq,
size - 1, syslog, time); size - 1, syslog, time);
/* /*
@ -3570,7 +3571,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
len = 0; len = 0;
prb_for_each_record(seq, prb, seq, &r) { prb_for_each_record(seq, prb, seq, &r) {
if (r.info->seq >= dumper->next_seq) if (r.info->seq >= iter->next_seq)
break; break;
len += record_print_text(&r, syslog, time); len += record_print_text(&r, syslog, time);
@ -3579,7 +3580,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
prb_rec_init_rd(&r, &info, buf + len, size - len); prb_rec_init_rd(&r, &info, buf + len, size - len);
} }
dumper->next_seq = next_seq; iter->next_seq = next_seq;
ret = true; ret = true;
logbuf_unlock_irqrestore(flags); logbuf_unlock_irqrestore(flags);
out: out:
@ -3591,7 +3592,7 @@ EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
/** /**
* kmsg_dump_rewind_nolock - reset the iterator (unlocked version) * kmsg_dump_rewind_nolock - reset the iterator (unlocked version)
* @dumper: registered kmsg dumper * @iter: kmsg dump iterator
* *
* Reset the dumper's iterator so that kmsg_dump_get_line() and * Reset the dumper's iterator so that kmsg_dump_get_line() and
* kmsg_dump_get_buffer() can be called again and used multiple * kmsg_dump_get_buffer() can be called again and used multiple
@ -3599,26 +3600,26 @@ EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
* *
* The function is similar to kmsg_dump_rewind(), but grabs no locks. * The function is similar to kmsg_dump_rewind(), but grabs no locks.
*/ */
void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper) void kmsg_dump_rewind_nolock(struct kmsg_dump_iter *iter)
{ {
dumper->cur_seq = latched_seq_read_nolock(&clear_seq); iter->cur_seq = latched_seq_read_nolock(&clear_seq);
dumper->next_seq = prb_next_seq(prb); iter->next_seq = prb_next_seq(prb);
} }
/** /**
* kmsg_dump_rewind - reset the iterator * kmsg_dump_rewind - reset the iterator
* @dumper: registered kmsg dumper * @iter: kmsg dump iterator
* *
* Reset the dumper's iterator so that kmsg_dump_get_line() and * Reset the dumper's iterator so that kmsg_dump_get_line() and
* kmsg_dump_get_buffer() can be called again and used multiple * kmsg_dump_get_buffer() can be called again and used multiple
* times within the same dumper.dump() callback. * times within the same dumper.dump() callback.
*/ */
void kmsg_dump_rewind(struct kmsg_dumper *dumper) void kmsg_dump_rewind(struct kmsg_dump_iter *iter)
{ {
unsigned long flags; unsigned long flags;
logbuf_lock_irqsave(flags); logbuf_lock_irqsave(flags);
kmsg_dump_rewind_nolock(dumper); kmsg_dump_rewind_nolock(iter);
logbuf_unlock_irqrestore(flags); logbuf_unlock_irqrestore(flags);
} }
EXPORT_SYMBOL_GPL(kmsg_dump_rewind); EXPORT_SYMBOL_GPL(kmsg_dump_rewind);