Merge tag 'trace-seq-file-cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace into for-next

Pull the beginning of seq_file cleanup from Steven:
  "I'm looking to clean up the seq_file code and to eventually merge the
  trace_seq code with seq_file as well, since they basically do the same thing.

  Part of this process is to remove the return code of seq_printf() and friends
  as they are rather inconsistent. It is better to use the new function
  seq_has_overflowed() if you want to stop processing when the buffer
  is full. Note, if the buffer is full, the seq_file code will throw away
  the contents, allocate a bigger buffer, and then call your code again
  to fill in the data. The only thing that breaking out of the function
  early does is to save a little time which is probably never noticed.

  I started with patches from Joe Perches and modified them as well.
  There's many more places that need to be updated before we can convert
  seq_printf() and friends to return void. But this patch set introduces
  the seq_has_overflowed() and does some initial updates."

10 files changed, 191 insertions, 240 deletions

diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index 76c08c2beb2f..8e0f2f410189 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -692,18 +692,19 @@ EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
  * because some peripherals have several blocks of identical registers,
  * for example configuration of dma channels
  */
-int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
-                           int nregs, void __iomem *base, char *prefix)
+void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+                          int nregs, void __iomem *base, char *prefix)
 {
-        int i, ret = 0;
+        int i;
 
         for (i = 0; i < nregs; i++, regs++) {
                 if (prefix)
-                        ret += seq_printf(s, "%s", prefix);
-                ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
-                                  readl(base + regs->offset));
+                        seq_printf(s, "%s", prefix);
+                seq_printf(s, "%s = 0x%08x\n", regs->name,
+                           readl(base + regs->offset));
+                if (seq_has_overflowed(s))
+                        break;
         }
-        return ret;
 }
 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
 
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index 1323c568e362..eea64912c9c0 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -48,8 +48,8 @@ static char *print_lockmode(int mode)
         }
 }
 
-static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
-                              struct dlm_rsb *res)
+static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *res)
 {
         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)
                 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;
         int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
-        int rv;
 
         lock_rsb(res);
 
-        rv = seq_printf(s, "\nResource %p Name (len=%d) \"",
-                        res, res->res_length);
-        if (rv)
-                goto out;
+        seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
 
         for (i = 0; i < res->res_length; 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)
-                rv = seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
-                                res->res_nodeid);
+                seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
+                           res->res_nodeid);
         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)
-                rv = seq_printf(s, "\"\nLooking up master (lkid %x)\n",
-                                res->res_first_lkid);
+                seq_printf(s, "\"\nLooking up master (lkid %x)\n",
+                           res->res_first_lkid);
         else
-                rv = seq_printf(s, "\"\nInvalid master %d\n",
-                                res->res_nodeid);
-        if (rv)
+                seq_printf(s, "\"\nInvalid master %d\n", res->res_nodeid);
+        if (seq_has_overflowed(s))
                 goto out;
 
         /* 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))
                         seq_puts(s, " (INVALID)");
-                rv = seq_puts(s, "\n");
-                if (rv)
+                seq_puts(s, "\n");
+                if (seq_has_overflowed(s))
                         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);
 
         if (root_list || recover_list) {
-                rv = seq_printf(s, "Recovery: root %d recover %d flags %lx "
-                                "count %d\n", root_list, recover_list,
-                                res->res_flags, res->res_recover_locks_count);
-                if (rv)
-                        goto out;
+                seq_printf(s, "Recovery: root %d recover %d flags %lx count %d\n",
+                           root_list, recover_list,
+                           res->res_flags, res->res_recover_locks_count);
         }
 
         /* Print the locks attached to this resource */
         seq_puts(s, "Granted Queue\n");
         list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         seq_puts(s, "Conversion Queue\n");
         list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         seq_puts(s, "Waiting Queue\n");
         list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
@@ -159,23 +152,23 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
 
         seq_puts(s, "Lookup Queue\n");
         list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
-                rv = seq_printf(s, "%08x %s", lkb->lkb_id,
-                                print_lockmode(lkb->lkb_rqmode));
+                seq_printf(s, "%08x %s",
+                           lkb->lkb_id, print_lockmode(lkb->lkb_rqmode));
                 if (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:
         unlock_rsb(res);
-        return rv;
 }
 
-static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
-                              struct dlm_rsb *r)
+static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *r)
 {
         u64 xid = 0;
         u64 us;
-        int rv;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 if (lkb->lkb_ua)
@@ -188,103 +181,97 @@ 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
            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",
-                        lkb->lkb_id,
-                        lkb->lkb_nodeid,
-                        lkb->lkb_remid,
-                        lkb->lkb_ownpid,
-                        (unsigned long long)xid,
-                        lkb->lkb_exflags,
-                        lkb->lkb_flags,
-                        lkb->lkb_status,
-                        lkb->lkb_grmode,
-                        lkb->lkb_rqmode,
-                        (unsigned long long)us,
-                        r->res_nodeid,
-                        r->res_length,
-                        r->res_name);
-        return rv;
+        seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
+                   lkb->lkb_id,
+                   lkb->lkb_nodeid,
+                   lkb->lkb_remid,
+                   lkb->lkb_ownpid,
+                   (unsigned long long)xid,
+                   lkb->lkb_exflags,
+                   lkb->lkb_flags,
+                   lkb->lkb_status,
+                   lkb->lkb_grmode,
+                   lkb->lkb_rqmode,
+                   (unsigned long long)us,
+                   r->res_nodeid,
+                   r->res_length,
+                   r->res_name);
 }
 
-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;
-        int rv = 0;
 
         lock_rsb(r);
 
         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
  out:
         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)
 {
         u64 xid = 0;
-        int rv;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 if (lkb->lkb_ua)
                         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",
-                        lkb->lkb_id,
-                        lkb->lkb_nodeid,
-                        lkb->lkb_remid,
-                        lkb->lkb_ownpid,
-                        (unsigned long long)xid,
-                        lkb->lkb_exflags,
-                        lkb->lkb_flags,
-                        lkb->lkb_status,
-                        lkb->lkb_grmode,
-                        lkb->lkb_rqmode,
-                        lkb->lkb_last_bast.mode,
-                        rsb_lookup,
-                        lkb->lkb_wait_type,
-                        lkb->lkb_lvbseq,
-                        (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
-                        (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
-        return rv;
+        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_nodeid,
+                   lkb->lkb_remid,
+                   lkb->lkb_ownpid,
+                   (unsigned long long)xid,
+                   lkb->lkb_exflags,
+                   lkb->lkb_flags,
+                   lkb->lkb_status,
+                   lkb->lkb_grmode,
+                   lkb->lkb_rqmode,
+                   lkb->lkb_last_bast.mode,
+                   rsb_lookup,
+                   lkb->lkb_wait_type,
+                   lkb->lkb_lvbseq,
+                   (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
+                   (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
 }
 
-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;
         int i, lvblen = r->res_ls->ls_lvblen;
         int print_name = 1;
-        int rv;
 
         lock_rsb(r);
 
-        rv = seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
-                        r,
-                        r->res_nodeid,
-                        r->res_first_lkid,
-                        r->res_flags,
-                        !list_empty(&r->res_root_list),
-                        !list_empty(&r->res_recover_list),
-                        r->res_recover_locks_count,
-                        r->res_length);
-        if (rv)
+        seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
+                   r,
+                   r->res_nodeid,
+                   r->res_first_lkid,
+                   r->res_flags,
+                   !list_empty(&r->res_root_list),
+                   !list_empty(&r->res_recover_list),
+                   r->res_recover_locks_count,
+                   r->res_length);
+        if (seq_has_overflowed(s))
                 goto out;
 
         for (i = 0; i < r->res_length; i++) {
@@ -292,7 +279,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                         print_name = 0;
         }
 
-        seq_printf(s, "%s", print_name ? "str " : "hex");
+        seq_puts(s, print_name ? "str " : "hex");
 
         for (i = 0; i < r->res_length; i++) {
                 if (print_name)
@@ -300,8 +287,8 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_puts(s, "\n");
-        if (rv)
+        seq_puts(s, "\n");
+        if (seq_has_overflowed(s))
                 goto out;
 
         if (!r->res_lvbptr)
@@ -311,65 +298,62 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
 
         for (i = 0; i < lvblen; i++)
                 seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
-        rv = seq_puts(s, "\n");
-        if (rv)
+        seq_puts(s, "\n");
+        if (seq_has_overflowed(s))
                 goto out;
 
  do_locks:
         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) {
-                rv = print_format3_lock(s, lkb, 1);
-                if (rv)
+                print_format3_lock(s, lkb, 1);
+                if (seq_has_overflowed(s))
                         goto out;
         }
  out:
         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 print_name = 1;
-        int i, rv;
+        int i;
 
         lock_rsb(r);
 
-        rv = seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
-                        r,
-                        r->res_nodeid,
-                        r->res_master_nodeid,
-                        r->res_dir_nodeid,
-                        our_nodeid,
-                        r->res_toss_time,
-                        r->res_flags,
-                        r->res_length);
-        if (rv)
-                goto out;
+        seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
+                   r,
+                   r->res_nodeid,
+                   r->res_master_nodeid,
+                   r->res_dir_nodeid,
+                   our_nodeid,
+                   r->res_toss_time,
+                   r->res_flags,
+                   r->res_length);
 
         for (i = 0; i < r->res_length; i++) {
                 if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
                         print_name = 0;
         }
 
-        seq_printf(s, "%s", print_name ? "str " : "hex");
+        seq_puts(s, print_name ? "str " : "hex");
 
         for (i = 0; i < r->res_length; i++) {
                 if (print_name)
@@ -377,10 +361,9 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_puts(s, "\n");
- out:
+        seq_puts(s, "\n");
+
         unlock_rsb(r);
-        return rv;
 }
 
 struct rsbtbl_iter {
@@ -390,47 +373,45 @@ struct rsbtbl_iter {
         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
-   does nothing and just returns -1.  So, the these printing routines
-   periodically check the return value to avoid wasting too much time
-   trying to print to a full buffer. */
+/*
+ * If the buffer is full, seq_printf can be called again, but it
+ * does nothing.  So, the these printing routines periodically check
+ * seq_has_overflowed to avoid wasting too much time trying to print to
+ * a full buffer.
+ */
 
 static int table_seq_show(struct seq_file *seq, void *iter_ptr)
 {
         struct rsbtbl_iter *ri = iter_ptr;
-        int rv = 0;
 
         switch (ri->format) {
         case 1:
-                rv = print_format1(ri->rsb, seq);
+                print_format1(ri->rsb, seq);
                 break;
         case 2:
                 if (ri->header) {
-                        seq_printf(seq, "id nodeid remid pid xid exflags "
-                                        "flags sts grmode rqmode time_ms "
-                                        "r_nodeid r_len r_name\n");
+                        seq_puts(seq, "id nodeid remid pid xid exflags flags sts grmode rqmode time_ms r_nodeid r_len r_name\n");
                         ri->header = 0;
                 }
-                rv = print_format2(ri->rsb, seq);
+                print_format2(ri->rsb, seq);
                 break;
         case 3:
                 if (ri->header) {
-                        seq_printf(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
+                        seq_puts(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
                         ri->header = 0;
                 }
-                rv = print_format3(ri->rsb, seq);
+                print_format3(ri->rsb, seq);
                 break;
         case 4:
                 if (ri->header) {
-                        seq_printf(seq, "version 4 rsb 2\n");
+                        seq_puts(seq, "version 4 rsb 2\n");
                         ri->header = 0;
                 }
-                rv = print_format4(ri->rsb, seq);
+                print_format4(ri->rsb, seq);
                 break;
         }
 
-        return rv;
+        return 0;
 }
 
 static const struct seq_operations format1_seq_ops;
diff --git a/fs/eventfd.c b/fs/eventfd.c
index d6a88e7812f3..4b0a226024fa 100644
--- a/fs/eventfd.c
+++ b/fs/eventfd.c
@@ -287,17 +287,14 @@ static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t c
 }
 
 #ifdef CONFIG_PROC_FS
-static int eventfd_show_fdinfo(struct seq_file *m, struct file *f)
+static void eventfd_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct eventfd_ctx *ctx = f->private_data;
-        int ret;
 
         spin_lock_irq(&ctx->wqh.lock);
-        ret = seq_printf(m, "eventfd-count: %16llx\n",
-                         (unsigned long long)ctx->count);
+        seq_printf(m, "eventfd-count: %16llx\n",
+                   (unsigned long long)ctx->count);
         spin_unlock_irq(&ctx->wqh.lock);
-
-        return ret;
 }
 #endif
 
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 7bcfff900f05..d77f94491352 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -870,25 +870,22 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
 }
 
 #ifdef CONFIG_PROC_FS
-static int ep_show_fdinfo(struct seq_file *m, struct file *f)
+static void ep_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct eventpoll *ep = f->private_data;
         struct rb_node *rbp;
-        int ret = 0;
 
         mutex_lock(&ep->mtx);
         for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
                 struct epitem *epi = rb_entry(rbp, struct epitem, rbn);
 
-                ret = seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
-                                 epi->ffd.fd, epi->event.events,
-                                 (long long)epi->event.data);
-                if (ret)
+                seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
+                           epi->ffd.fd, epi->event.events,
+                           (long long)epi->event.data);
+                if (seq_has_overflowed(m))
                         break;
         }
         mutex_unlock(&ep->mtx);
-
-        return ret;
 }
 #endif
 
diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
index 9d7e2b9659cb..6ffd220eb14d 100644
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@ -20,25 +20,24 @@
 
 #if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
 
-static int show_fdinfo(struct seq_file *m, struct file *f,
-                       int (*show)(struct seq_file *m, struct fsnotify_mark *mark))
+static void show_fdinfo(struct seq_file *m, struct file *f,
+                        void (*show)(struct seq_file *m,
+                                     struct fsnotify_mark *mark))
 {
         struct fsnotify_group *group = f->private_data;
         struct fsnotify_mark *mark;
-        int ret = 0;
 
         mutex_lock(&group->mark_mutex);
         list_for_each_entry(mark, &group->marks_list, g_list) {
-                ret = show(m, mark);
-                if (ret)
+                show(m, mark);
+                if (seq_has_overflowed(m))
                         break;
         }
         mutex_unlock(&group->mark_mutex);
-        return ret;
 }
 
 #if defined(CONFIG_EXPORTFS)
-static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
 {
         struct {
                 struct file_handle handle;
@@ -52,71 +51,62 @@ static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
         ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
         if ((ret == FILEID_INVALID) || (ret < 0)) {
                 WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
-                return 0;
+                return;
         }
 
         f.handle.handle_type = ret;
         f.handle.handle_bytes = size * sizeof(u32);
 
-        ret = seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
-                         f.handle.handle_bytes, f.handle.handle_type);
+        seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
+                   f.handle.handle_bytes, f.handle.handle_type);
 
         for (i = 0; i < f.handle.handle_bytes; i++)
-                ret |= seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
-
-        return ret;
+                seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
 }
 #else
-static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
 {
-        return 0;
 }
 #endif
 
 #ifdef CONFIG_INOTIFY_USER
 
-static int inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 {
         struct inotify_inode_mark *inode_mark;
         struct inode *inode;
-        int ret = 0;
 
         if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE)))
-                return 0;
+                return;
 
         inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
         inode = igrab(mark->i.inode);
         if (inode) {
-                ret = seq_printf(m, "inotify wd:%x ino:%lx sdev:%x "
-                                 "mask:%x ignored_mask:%x ",
-                                 inode_mark->wd, inode->i_ino,
-                                 inode->i_sb->s_dev,
-                                 mark->mask, mark->ignored_mask);
-                ret |= show_mark_fhandle(m, inode);
-                ret |= seq_putc(m, '\n');
+                seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:%x ",
+                           inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
+                           mark->mask, mark->ignored_mask);
+                show_mark_fhandle(m, inode);
+                seq_putc(m, '\n');
                 iput(inode);
         }
-
-        return ret;
 }
 
-int inotify_show_fdinfo(struct seq_file *m, struct file *f)
+void inotify_show_fdinfo(struct seq_file *m, struct file *f)
 {
-        return show_fdinfo(m, f, inotify_fdinfo);
+        show_fdinfo(m, f, inotify_fdinfo);
 }
 
 #endif /* CONFIG_INOTIFY_USER */
 
 #ifdef CONFIG_FANOTIFY
 
-static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 {
         unsigned int mflags = 0;
         struct inode *inode;
-        int ret = 0;
 
         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
-                return 0;
+                return;
 
         if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
                 mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
@@ -124,26 +114,22 @@ static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
         if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
                 inode = igrab(mark->i.inode);
                 if (!inode)
-                        goto out;
-                ret = seq_printf(m, "fanotify ino:%lx sdev:%x "
-                                 "mflags:%x mask:%x ignored_mask:%x ",
-                                 inode->i_ino, inode->i_sb->s_dev,
-                                 mflags, mark->mask, mark->ignored_mask);
-                ret |= show_mark_fhandle(m, inode);
-                ret |= seq_putc(m, '\n');
+                        return;
+                seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
+                           inode->i_ino, inode->i_sb->s_dev,
+                           mflags, mark->mask, mark->ignored_mask);
+                show_mark_fhandle(m, inode);
+                seq_putc(m, '\n');
                 iput(inode);
         } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
                 struct mount *mnt = real_mount(mark->m.mnt);
 
-                ret = seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x "
-                                 "ignored_mask:%x\n", mnt->mnt_id, mflags,
-                                 mark->mask, mark->ignored_mask);
+                seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
+                           mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
         }
-out:
-        return ret;
 }
 
-int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
+void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct fsnotify_group *group = f->private_data;
         unsigned int flags = 0;
@@ -169,7 +155,7 @@ int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
         seq_printf(m, "fanotify flags:%x event-flags:%x\n",
                    flags, group->fanotify_data.f_flags);
 
-        return show_fdinfo(m, f, fanotify_fdinfo);
+        show_fdinfo(m, f, fanotify_fdinfo);
 }
 
 #endif /* CONFIG_FANOTIFY */
diff --git a/fs/notify/fdinfo.h b/fs/notify/fdinfo.h
index 556afda990e9..9664c4904d6b 100644
--- a/fs/notify/fdinfo.h
+++ b/fs/notify/fdinfo.h
@@ -10,11 +10,11 @@ struct file;
 #ifdef CONFIG_PROC_FS
 
 #ifdef CONFIG_INOTIFY_USER
-extern int inotify_show_fdinfo(struct seq_file *m, struct file *f);
+void inotify_show_fdinfo(struct seq_file *m, struct file *f);
 #endif
 
 #ifdef CONFIG_FANOTIFY
-extern int fanotify_show_fdinfo(struct seq_file *m, struct file *f);
+void fanotify_show_fdinfo(struct seq_file *m, struct file *f);
 #endif
 
 #else /* CONFIG_PROC_FS */
diff --git a/fs/proc/fd.c b/fs/proc/fd.c
index e11d7c590bb0..8e5ad83b629a 100644
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -53,7 +53,8 @@ static int seq_show(struct seq_file *m, void *v)
                            (long long)file->f_pos, f_flags,
                            real_mount(file->f_path.mnt)->mnt_id);
                 if (file->f_op->show_fdinfo)
-                        ret = file->f_op->show_fdinfo(m, file);
+                        file->f_op->show_fdinfo(m, file);
+                ret = seq_has_overflowed(m);
                 fput(file);
         }
 
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 3857b720cb1b..353948ba1c5b 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -16,17 +16,6 @@
 #include <asm/uaccess.h>
 #include <asm/page.h>
 
-
-/*
- * seq_files have a buffer which can may overflow. When this happens a larger
- * buffer is reallocated and all the data will be printed again.
- * The overflow state is true when m->count == m->size.
- */
-static bool seq_overflow(struct seq_file *m)
-{
-        return m->count == m->size;
-}
-
 static void seq_set_overflow(struct seq_file *m)
 {
         m->count = m->size;
@@ -124,7 +113,7 @@ static int traverse(struct seq_file *m, loff_t offset)
                         error = 0;
                         m->count = 0;
                 }
-                if (seq_overflow(m))
+                if (seq_has_overflowed(m))
                         goto Eoverflow;
                 if (pos + m->count > offset) {
                         m->from = offset - pos;
@@ -267,7 +256,7 @@ Fill:
                         break;
                 }
                 err = m->op->show(m, p);
-                if (seq_overflow(m) || err) {
+                if (seq_has_overflowed(m) || err) {
                         m->count = offs;
                         if (likely(err <= 0))
                                 break;
diff --git a/fs/signalfd.c b/fs/signalfd.c
index 424b7b65321f..7e412ad74836 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -230,7 +230,7 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
 }
 
 #ifdef CONFIG_PROC_FS
-static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
+static void signalfd_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct signalfd_ctx *ctx = f->private_data;
         sigset_t sigmask;
@@ -238,8 +238,6 @@ static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
         sigmask = ctx->sigmask;
         signotset(&sigmask);
         render_sigset_t(m, "sigmask:\t", &sigmask);
-
-        return 0;
 }
 #endif
 
diff --git a/fs/timerfd.c b/fs/timerfd.c
index b46ffa94372a..b94fa6c3c6eb 100644
--- a/fs/timerfd.c
+++ b/fs/timerfd.c
@@ -288,7 +288,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
 }
 
 #ifdef CONFIG_PROC_FS
-static int timerfd_show(struct seq_file *m, struct file *file)
+static void timerfd_show(struct seq_file *m, struct file *file)
 {
         struct timerfd_ctx *ctx = file->private_data;
         struct itimerspec t;
@@ -298,18 +298,19 @@ static int timerfd_show(struct seq_file *m, struct file *file)
         t.it_interval = ktime_to_timespec(ctx->tintv);
         spin_unlock_irq(&ctx->wqh.lock);
 
-        return seq_printf(m,
-                          "clockid: %d\n"
-                          "ticks: %llu\n"
-                          "settime flags: 0%o\n"
-                          "it_value: (%llu, %llu)\n"
-                          "it_interval: (%llu, %llu)\n",
-                          ctx->clockid, (unsigned long long)ctx->ticks,
-                          ctx->settime_flags,
-                          (unsigned long long)t.it_value.tv_sec,
-                          (unsigned long long)t.it_value.tv_nsec,
-                          (unsigned long long)t.it_interval.tv_sec,
-                          (unsigned long long)t.it_interval.tv_nsec);
+        seq_printf(m,
+                   "clockid: %d\n"
+                   "ticks: %llu\n"
+                   "settime flags: 0%o\n"
+                   "it_value: (%llu, %llu)\n"
+                   "it_interval: (%llu, %llu)\n",
+                   ctx->clockid,
+                   (unsigned long long)ctx->ticks,
+                   ctx->settime_flags,
+                   (unsigned long long)t.it_value.tv_sec,
+                   (unsigned long long)t.it_value.tv_nsec,
+                   (unsigned long long)t.it_interval.tv_sec,
+                   (unsigned long long)t.it_interval.tv_nsec);
 }
 #else
 #define timerfd_show NULL