redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

dlm: Remove seq_printf() return checks and use seq_has_overflowed()

Browse source 
The seq_printf() return is going away soon and users of it should
check seq_has_overflowed() to see if the buffer is full and will
not accept any more data.

Convert functions returning int to void where seq_printf() is used.

Link: http://lkml.kernel.org/p/43590057bcb83846acbbcc1fe641f792b2fb7773.1412031505.git.joe@perches.com
Link: http://lkml.kernel.org/r/20141029220107.939492048@goodmis.org

Acked-by: David Teigland <teigland@redhat.com>
Cc: Christine Caulfield <ccaulfie@redhat.com>
Cc: cluster-devel@redhat.com
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Joe Perches 2014-09-29 16:08:23 -07:00 committed by Steven Rostedt
parent e71456ae98
commit d6d906b234
1 changed files with 117 additions and 134 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
fs/dlm/debug_fs.c
View file

@ -48,7 +48,7 @@ static char *print_lockmode(int mode)
} }
} }
static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb, static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
struct dlm_rsb *res) struct dlm_rsb *res)
{ {
seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode)); seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
@ -68,21 +68,17 @@ static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
if (lkb->lkb_wait_type) if (lkb->lkb_wait_type)
seq_printf(s, " wait_type: %d", lkb->lkb_wait_type); seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
return seq_puts(s, "\n"); seq_puts(s, "\n");
} }
static int print_format1(struct dlm_rsb *res, struct seq_file *s) static void print_format1(struct dlm_rsb *res, struct seq_file *s)
{ {
struct dlm_lkb *lkb; struct dlm_lkb *lkb;
int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list; int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
int rv;
lock_rsb(res); lock_rsb(res);
rv = seq_printf(s, "\nResource %p Name (len=%d) \"", seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
res, res->res_length);
if (rv)
goto out;
for (i = 0; i < res->res_length; i++) { for (i = 0; i < res->res_length; i++) {
if (isprint(res->res_name[i])) if (isprint(res->res_name[i]))
@ -92,17 +88,16 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
} }
if (res->res_nodeid > 0) if (res->res_nodeid > 0)
rv = seq_printf(s, "\"\nLocal Copy, Master is node %d\n", seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
res->res_nodeid); res->res_nodeid);
else if (res->res_nodeid == 0) else if (res->res_nodeid == 0)
rv = seq_puts(s, "\"\nMaster Copy\n"); seq_puts(s, "\"\nMaster Copy\n");
else if (res->res_nodeid == -1) else if (res->res_nodeid == -1)
rv = seq_printf(s, "\"\nLooking up master (lkid %x)\n", seq_printf(s, "\"\nLooking up master (lkid %x)\n",
res->res_first_lkid); res->res_first_lkid);
else else
rv = seq_printf(s, "\"\nInvalid master %d\n", seq_printf(s, "\"\nInvalid master %d\n", res->res_nodeid);
res->res_nodeid); if (seq_has_overflowed(s))
if (rv)
goto out; goto out;
/* Print the LVB: */ /* Print the LVB: */
@ -116,8 +111,8 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
} }
if (rsb_flag(res, RSB_VALNOTVALID)) if (rsb_flag(res, RSB_VALNOTVALID))
seq_puts(s, " (INVALID)"); seq_puts(s, " (INVALID)");
rv = seq_puts(s, "\n"); seq_puts(s, "\n");
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
@ -125,32 +120,30 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
recover_list = !list_empty(&res->res_recover_list); recover_list = !list_empty(&res->res_recover_list);
if (root_list || recover_list) { if (root_list || recover_list) {
rv = seq_printf(s, "Recovery: root %d recover %d flags %lx " seq_printf(s, "Recovery: root %d recover %d flags %lx count %d\n",
"count %d\n", root_list, recover_list, root_list, recover_list,
res->res_flags, res->res_recover_locks_count); res->res_flags, res->res_recover_locks_count);
if (rv)
goto out;
} }
/* Print the locks attached to this resource */ /* Print the locks attached to this resource */
seq_puts(s, "Granted Queue\n"); seq_puts(s, "Granted Queue\n");
list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) { list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
rv = print_format1_lock(s, lkb, res); print_format1_lock(s, lkb, res);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
seq_puts(s, "Conversion Queue\n"); seq_puts(s, "Conversion Queue\n");
list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) { list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
rv = print_format1_lock(s, lkb, res); print_format1_lock(s, lkb, res);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
seq_puts(s, "Waiting Queue\n"); seq_puts(s, "Waiting Queue\n");
list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) { list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
rv = print_format1_lock(s, lkb, res); print_format1_lock(s, lkb, res);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
@ -159,23 +152,23 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
seq_puts(s, "Lookup Queue\n"); seq_puts(s, "Lookup Queue\n");
list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) { list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
rv = seq_printf(s, "%08x %s", lkb->lkb_id, seq_printf(s, "%08x %s",
print_lockmode(lkb->lkb_rqmode)); lkb->lkb_id, print_lockmode(lkb->lkb_rqmode));
if (lkb->lkb_wait_type) if (lkb->lkb_wait_type)
seq_printf(s, " wait_type: %d", lkb->lkb_wait_type); seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
rv = seq_puts(s, "\n"); seq_puts(s, "\n");
if (seq_has_overflowed(s))
goto out;
} }
out: out:
unlock_rsb(res); unlock_rsb(res);
return rv;
} }
static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb, static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
struct dlm_rsb *r) struct dlm_rsb *r)
{ {
u64 xid = 0; u64 xid = 0;
u64 us; u64 us;
int rv;
if (lkb->lkb_flags & DLM_IFL_USER) { if (lkb->lkb_flags & DLM_IFL_USER) {
if (lkb->lkb_ua) if (lkb->lkb_ua)
@ -188,7 +181,7 @@ static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
/* id nodeid remid pid xid exflags flags sts grmode rqmode time_us /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us
r_nodeid r_len r_name */ r_nodeid r_len r_name */
rv = seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n", seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
lkb->lkb_id, lkb->lkb_id,
lkb->lkb_nodeid, lkb->lkb_nodeid,
lkb->lkb_remid, lkb->lkb_remid,
@ -203,50 +196,46 @@ static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
r->res_nodeid, r->res_nodeid,
r->res_length, r->res_length,
r->res_name); r->res_name);
return rv;
} }
static int print_format2(struct dlm_rsb *r, struct seq_file *s) static void print_format2(struct dlm_rsb *r, struct seq_file *s)
{ {
struct dlm_lkb *lkb; struct dlm_lkb *lkb;
int rv = 0;
lock_rsb(r); lock_rsb(r);
list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
rv = print_format2_lock(s, lkb, r); print_format2_lock(s, lkb, r);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
rv = print_format2_lock(s, lkb, r); print_format2_lock(s, lkb, r);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
rv = print_format2_lock(s, lkb, r); print_format2_lock(s, lkb, r);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
out: out:
unlock_rsb(r); unlock_rsb(r);
return rv;
} }
static int print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb, static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
int rsb_lookup) int rsb_lookup)
{ {
u64 xid = 0; u64 xid = 0;
int rv;
if (lkb->lkb_flags & DLM_IFL_USER) { if (lkb->lkb_flags & DLM_IFL_USER) {
if (lkb->lkb_ua) if (lkb->lkb_ua)
xid = lkb->lkb_ua->xid; xid = lkb->lkb_ua->xid;
} }
rv = seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n", seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
lkb->lkb_id, lkb->lkb_id,
lkb->lkb_nodeid, lkb->lkb_nodeid,
lkb->lkb_remid, lkb->lkb_remid,
@ -263,19 +252,17 @@ static int print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
lkb->lkb_lvbseq, lkb->lkb_lvbseq,
(unsigned long long)ktime_to_ns(lkb->lkb_timestamp), (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
(unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time)); (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
return rv;
} }
static int print_format3(struct dlm_rsb *r, struct seq_file *s) static void print_format3(struct dlm_rsb *r, struct seq_file *s)
{ {
struct dlm_lkb *lkb; struct dlm_lkb *lkb;
int i, lvblen = r->res_ls->ls_lvblen; int i, lvblen = r->res_ls->ls_lvblen;
int print_name = 1; int print_name = 1;
int rv;
lock_rsb(r); lock_rsb(r);
rv = seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ", seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
r, r,
r->res_nodeid, r->res_nodeid,
r->res_first_lkid, r->res_first_lkid,
@ -284,7 +271,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
!list_empty(&r->res_recover_list), !list_empty(&r->res_recover_list),
r->res_recover_locks_count, r->res_recover_locks_count,
r->res_length); r->res_length);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
for (i = 0; i < r->res_length; i++) { for (i = 0; i < r->res_length; i++) {
@ -300,8 +287,8 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
else else
seq_printf(s, " %02x", (unsigned char)r->res_name[i]); seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
} }
rv = seq_puts(s, "\n"); seq_puts(s, "\n");
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
if (!r->res_lvbptr) if (!r->res_lvbptr)
@ -311,48 +298,47 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
for (i = 0; i < lvblen; i++) for (i = 0; i < lvblen; i++)
seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]); seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
rv = seq_puts(s, "\n"); seq_puts(s, "\n");
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
do_locks: do_locks:
list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
rv = print_format3_lock(s, lkb, 0); print_format3_lock(s, lkb, 0);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
rv = print_format3_lock(s, lkb, 0); print_format3_lock(s, lkb, 0);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) { list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
rv = print_format3_lock(s, lkb, 0); print_format3_lock(s, lkb, 0);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) { list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) {
rv = print_format3_lock(s, lkb, 1); print_format3_lock(s, lkb, 1);
if (rv) if (seq_has_overflowed(s))
goto out; goto out;
} }
out: out:
unlock_rsb(r); unlock_rsb(r);
return rv;
} }
static int print_format4(struct dlm_rsb *r, struct seq_file *s) static void print_format4(struct dlm_rsb *r, struct seq_file *s)
{ {
int our_nodeid = dlm_our_nodeid(); int our_nodeid = dlm_our_nodeid();
int print_name = 1; int print_name = 1;
int i, rv; int i;
lock_rsb(r); lock_rsb(r);
rv = seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ", seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
r, r,
r->res_nodeid, r->res_nodeid,
r->res_master_nodeid, r->res_master_nodeid,
@ -361,8 +347,6 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
r->res_toss_time, r->res_toss_time,
r->res_flags, r->res_flags,
r->res_length); r->res_length);
if (rv)
goto out;
for (i = 0; i < r->res_length; i++) { for (i = 0; i < r->res_length; i++) {
if (!isascii(r->res_name[i]) || !isprint(r->res_name[i])) if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
@ -377,10 +361,9 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
else else
seq_printf(s, " %02x", (unsigned char)r->res_name[i]); seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
} }
rv = seq_puts(s, "\n"); seq_puts(s, "\n");
out:
unlock_rsb(r); unlock_rsb(r);
return rv;
} }
struct rsbtbl_iter { struct rsbtbl_iter {
@ -390,20 +373,20 @@ struct rsbtbl_iter {
int header; int header;
}; };
/* seq_printf returns -1 if the buffer is full, and 0 otherwise. /*
If the buffer is full, seq_printf can be called again, but it * If the buffer is full, seq_printf can be called again, but it
does nothing and just returns -1. So, the these printing routines * does nothing. So, the these printing routines periodically check
periodically check the return value to avoid wasting too much time * seq_has_overflowed to avoid wasting too much time trying to print to
trying to print to a full buffer. */ * a full buffer.
*/
static int table_seq_show(struct seq_file *seq, void *iter_ptr) static int table_seq_show(struct seq_file *seq, void *iter_ptr)
{ {
struct rsbtbl_iter *ri = iter_ptr; struct rsbtbl_iter *ri = iter_ptr;
int rv = 0;
switch (ri->format) { switch (ri->format) {
case 1: case 1:
rv = print_format1(ri->rsb, seq); print_format1(ri->rsb, seq);
break; break;
case 2: case 2:
if (ri->header) { if (ri->header) {
@ -412,25 +395,25 @@ static int table_seq_show(struct seq_file *seq, void *iter_ptr)
"r_nodeid r_len r_name\n"); "r_nodeid r_len r_name\n");
ri->header = 0; ri->header = 0;
} }
rv = print_format2(ri->rsb, seq); print_format2(ri->rsb, seq);
break; break;
case 3: case 3:
if (ri->header) { if (ri->header) {
seq_printf(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n"); seq_printf(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
ri->header = 0; ri->header = 0;
} }
rv = print_format3(ri->rsb, seq); print_format3(ri->rsb, seq);
break; break;
case 4: case 4:
if (ri->header) { if (ri->header) {
seq_printf(seq, "version 4 rsb 2\n"); seq_printf(seq, "version 4 rsb 2\n");
ri->header = 0; ri->header = 0;
} }
rv = print_format4(ri->rsb, seq); print_format4(ri->rsb, seq);
break; break;
} }
return rv; return 0;
} }
static const struct seq_operations format1_seq_ops; static const struct seq_operations format1_seq_ops;