linux_seq_file.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2016-2018, Matthew Macy <mmacy@freebsd.org>
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD$");
   31 
   32 #include <sys/types.h>
   33 #include <sys/systm.h>
   34 #include <sys/param.h>
   35 #include <sys/sbuf.h>
   36 #include <sys/syslog.h>
   37 #include <sys/vnode.h>
   38 
   39 #include <linux/seq_file.h>
   40 #include <linux/file.h>
   41 
   42 #undef file
   43 MALLOC_DEFINE(M_LSEQ, "seq_file", "seq_file");
   44 
   45 ssize_t
   46 seq_read(struct linux_file *f, char *ubuf, size_t size, off_t *ppos)
   47 {
   48         struct seq_file *m;
   49         struct sbuf *sbuf;
   50         void *p;
   51         ssize_t rc;
   52 
   53         m = f->private_data;
   54         sbuf = m->buf;
   55 
   56         p = m->op->start(m, ppos);
   57         rc = m->op->show(m, p);
   58         if (rc)
   59                 return (rc);
   60 
   61         rc = sbuf_finish(sbuf);
   62         if (rc)
   63                 return (rc);
   64 
   65         rc = sbuf_len(sbuf);
   66         if (*ppos >= rc || size < 1)
   67                 return (-EINVAL);
   68 
   69         size = min(rc - *ppos, size);
   70         rc = strscpy(ubuf, sbuf_data(sbuf) + *ppos, size + 1);
   71 
   72         /* add 1 for null terminator */
   73         if (rc > 0)
   74                 rc += 1;
   75 
   76         return (rc);
   77 }
   78 
   79 int
   80 seq_write(struct seq_file *seq, const void *data, size_t len)
   81 {
   82 
   83         return (sbuf_bcpy(seq->buf, data, len));
   84 }
   85 
   86 /*
   87  * This only needs to be a valid address for lkpi
   88  * drivers it should never actually be called
   89  */
   90 off_t
   91 seq_lseek(struct linux_file *file, off_t offset, int whence)
   92 {
   93 
   94         panic("%s not supported\n", __FUNCTION__);
   95         return (0);
   96 }
   97 
   98 static void *
   99 single_start(struct seq_file *p, off_t *pos)
  100 {
  101 
  102         return ((void *)(uintptr_t)(*pos == 0));
  103 }
  104 
  105 static void *
  106 single_next(struct seq_file *p, void *v, off_t *pos)
  107 {
  108 
  109         ++*pos;
  110         return (NULL);
  111 }
  112 
  113 static void
  114 single_stop(struct seq_file *p, void *v)
  115 {
  116 }
  117 
  118 int
  119 seq_open(struct linux_file *f, const struct seq_operations *op)
  120 {
  121         struct seq_file *p;
  122 
  123         if ((p = malloc(sizeof(*p), M_LSEQ, M_NOWAIT|M_ZERO)) == NULL)
  124                 return (-ENOMEM);
  125 
  126         p->buf = sbuf_new_auto();
  127         p->file = f;
  128         p->op = op;
  129         f->private_data = (void *) p;
  130         return (0);
  131 }
  132 
  133 void *
  134 __seq_open_private(struct linux_file *f, const struct seq_operations *op, int size)
  135 {
  136         struct seq_file *seq_file;
  137         void *private;
  138         int error;
  139 
  140         private = malloc(size, M_LSEQ, M_NOWAIT|M_ZERO);
  141         if (private == NULL)
  142                 return (NULL);
  143 
  144         error = seq_open(f, op);
  145         if (error < 0) {
  146                 free(private, M_LSEQ);
  147                 return (NULL);
  148         }
  149 
  150         seq_file = (struct seq_file *)f->private_data;
  151         seq_file->private = private;
  152 
  153         return (private);
  154 }
  155 
  156 int
  157 single_open(struct linux_file *f, int (*show)(struct seq_file *, void *), void *d)
  158 {
  159         struct seq_operations *op;
  160         int rc = -ENOMEM;
  161 
  162         op = malloc(sizeof(*op), M_LSEQ, M_NOWAIT);
  163         if (op) {
  164                 op->start = single_start;
  165                 op->next = single_next;
  166                 op->stop = single_stop;
  167                 op->show = show;
  168                 rc = seq_open(f, op);
  169                 if (rc)
  170                         free(op, M_LSEQ);
  171                 else
  172                         ((struct seq_file *)f->private_data)->private = d;
  173         }
  174         return (rc);
  175 }
  176 
  177 int
  178 seq_release(struct inode *inode __unused, struct linux_file *file)
  179 {
  180         struct seq_file *m;
  181         struct sbuf *s;
  182 
  183         m = file->private_data;
  184         s = m->buf;
  185 
  186         sbuf_delete(s);
  187         free(m, M_LSEQ);
  188 
  189         return (0);
  190 }
  191 
  192 int
  193 seq_release_private(struct inode *inode __unused, struct linux_file *f)
  194 {
  195         struct seq_file *seq;
  196 
  197         seq = (struct seq_file *)f->private_data;
  198         free(seq->private, M_LSEQ);
  199         return (seq_release(inode, f));
  200 }
  201 
  202 int
  203 single_release(struct vnode *v, struct linux_file *f)
  204 {
  205         const struct seq_operations *op;
  206         struct seq_file *m;
  207         int rc;
  208 
  209         /* be NULL safe */
  210         if ((m = f->private_data) == NULL)
  211                 return (0);
  212 
  213         op = m->op;
  214         rc = seq_release(v, f);
  215         free(__DECONST(void *, op), M_LSEQ);
  216         return (rc);
  217 }
  218 
  219 void
  220 lkpi_seq_vprintf(struct seq_file *m, const char *fmt, va_list args)
  221 {
  222         sbuf_vprintf(m->buf, fmt, args);
  223 }
  224 
  225 void
  226 lkpi_seq_printf(struct seq_file *m, const char *fmt, ...)
  227 {
  228         va_list args;
  229 
  230         va_start(args, fmt);
  231         seq_vprintf(m, fmt, args);
  232         va_end(args);
  233 }

Cache object: cae2aa00386a286c08a94455908345e5

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/compat/linuxkpi/common/src/linux_seq_file.c

FreeBSD/Linux Kernel Cross Reference
sys/compat/linuxkpi/common/src/linux_seq_file.c