diff --git a/sys/compat/linuxkpi/common/include/linux/seq_file.h b/sys/compat/linuxkpi/common/include/linux/seq_file.h index 8fb93646f9a5..d18d3cd906ab 100644 --- a/sys/compat/linuxkpi/common/include/linux/seq_file.h +++ b/sys/compat/linuxkpi/common/include/linux/seq_file.h @@ -1,93 +1,95 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2016-2018, Matthew Macy * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _LINUXKPI_LINUX_SEQ_FILE_H_ #define _LINUXKPI_LINUX_SEQ_FILE_H_ #include #include #undef file #define inode vnode MALLOC_DECLARE(M_LSEQ); #define DEFINE_SHOW_ATTRIBUTE(__name) \ static int __name ## _open(struct inode *inode, struct linux_file *file) \ { \ return single_open(file, __name ## _show, inode->i_private); \ } \ \ static const struct file_operations __name ## _fops = { \ .owner = THIS_MODULE, \ .open = __name ## _open, \ .read = seq_read, \ .llseek = seq_lseek, \ .release = single_release, \ } struct seq_file { struct sbuf *buf; + size_t size; const struct seq_operations *op; const struct linux_file *file; void *private; }; struct seq_operations { void * (*start) (struct seq_file *m, off_t *pos); void (*stop) (struct seq_file *m, void *v); void * (*next) (struct seq_file *m, void *v, off_t *pos); int (*show) (struct seq_file *m, void *v); }; ssize_t seq_read(struct linux_file *, char *, size_t, off_t *); int seq_write(struct seq_file *seq, const void *data, size_t len); +void seq_putc(struct seq_file *m, char c); +void seq_puts(struct seq_file *m, const char *str); +bool seq_has_overflowed(struct seq_file *m); void *__seq_open_private(struct linux_file *, const struct seq_operations *, int); int seq_release_private(struct inode *, struct linux_file *); int seq_open(struct linux_file *f, const struct seq_operations *op); int seq_release(struct inode *inode, struct linux_file *file); off_t seq_lseek(struct linux_file *file, off_t offset, int whence); int single_open(struct linux_file *, int (*)(struct seq_file *, void *), void *); +int single_open_size(struct linux_file *, int (*)(struct seq_file *, void *), void *, size_t); int single_release(struct inode *, struct linux_file *); void lkpi_seq_vprintf(struct seq_file *m, const char *fmt, va_list args); void lkpi_seq_printf(struct seq_file *m, const char *fmt, ...); #define seq_vprintf(...) lkpi_seq_vprintf(__VA_ARGS__) #define seq_printf(...) lkpi_seq_printf(__VA_ARGS__) -#define seq_puts(m, str) sbuf_printf((m)->buf, str) -#define seq_putc(m, str) sbuf_putc((m)->buf, str) - #define file linux_file #endif /* _LINUXKPI_LINUX_SEQ_FILE_H_ */ diff --git a/sys/compat/linuxkpi/common/src/linux_seq_file.c b/sys/compat/linuxkpi/common/src/linux_seq_file.c index d4d8ef059ac4..80b13a3ac28f 100644 --- a/sys/compat/linuxkpi/common/src/linux_seq_file.c +++ b/sys/compat/linuxkpi/common/src/linux_seq_file.c @@ -1,233 +1,304 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2016-2018, Matthew Macy * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #undef file MALLOC_DEFINE(M_LSEQ, "seq_file", "seq_file"); ssize_t seq_read(struct linux_file *f, char *ubuf, size_t size, off_t *ppos) { struct seq_file *m; struct sbuf *sbuf; void *p; ssize_t rc; m = f->private_data; sbuf = m->buf; p = m->op->start(m, ppos); rc = m->op->show(m, p); if (rc) return (rc); rc = sbuf_finish(sbuf); if (rc) return (rc); rc = sbuf_len(sbuf); if (*ppos >= rc || size < 1) return (-EINVAL); size = min(rc - *ppos, size); rc = strscpy(ubuf, sbuf_data(sbuf) + *ppos, size + 1); /* add 1 for null terminator */ if (rc > 0) rc += 1; return (rc); } int seq_write(struct seq_file *seq, const void *data, size_t len) { + int ret; - return (sbuf_bcpy(seq->buf, data, len)); + ret = sbuf_bcpy(seq->buf, data, len); + if (ret == 0) + seq->size = sbuf_len(seq->buf); + + return (ret); +} + +void +seq_putc(struct seq_file *seq, char c) +{ + int ret; + + ret = sbuf_putc(seq->buf, c); + if (ret == 0) + seq->size = sbuf_len(seq->buf); +} + +void +seq_puts(struct seq_file *seq, const char *str) +{ + int ret; + + ret = sbuf_printf(seq->buf, "%s", str); + if (ret == 0) + seq->size = sbuf_len(seq->buf); } /* * This only needs to be a valid address for lkpi * drivers it should never actually be called */ off_t seq_lseek(struct linux_file *file, off_t offset, int whence) { panic("%s not supported\n", __FUNCTION__); return (0); } static void * single_start(struct seq_file *p, off_t *pos) { return ((void *)(uintptr_t)(*pos == 0)); } static void * single_next(struct seq_file *p, void *v, off_t *pos) { ++*pos; return (NULL); } static void single_stop(struct seq_file *p, void *v) { } -int -seq_open(struct linux_file *f, const struct seq_operations *op) +static int +_seq_open_without_sbuf(struct linux_file *f, const struct seq_operations *op) { struct seq_file *p; if ((p = malloc(sizeof(*p), M_LSEQ, M_NOWAIT|M_ZERO)) == NULL) return (-ENOMEM); - p->buf = sbuf_new_auto(); p->file = f; p->op = op; f->private_data = (void *) p; return (0); } +int +seq_open(struct linux_file *f, const struct seq_operations *op) +{ + int ret; + + ret = _seq_open_without_sbuf(f, op); + if (ret == 0) + ((struct seq_file *)f->private_data)->buf = sbuf_new_auto(); + + return (ret); +} + void * __seq_open_private(struct linux_file *f, const struct seq_operations *op, int size) { struct seq_file *seq_file; void *private; int error; private = malloc(size, M_LSEQ, M_NOWAIT|M_ZERO); if (private == NULL) return (NULL); error = seq_open(f, op); if (error < 0) { free(private, M_LSEQ); return (NULL); } seq_file = (struct seq_file *)f->private_data; seq_file->private = private; return (private); } -int -single_open(struct linux_file *f, int (*show)(struct seq_file *, void *), void *d) +static int +_single_open_without_sbuf(struct linux_file *f, int (*show)(struct seq_file *, void *), void *d) { struct seq_operations *op; int rc = -ENOMEM; op = malloc(sizeof(*op), M_LSEQ, M_NOWAIT); if (op) { op->start = single_start; op->next = single_next; op->stop = single_stop; op->show = show; - rc = seq_open(f, op); + rc = _seq_open_without_sbuf(f, op); if (rc) free(op, M_LSEQ); else ((struct seq_file *)f->private_data)->private = d; } return (rc); } +int +single_open(struct linux_file *f, int (*show)(struct seq_file *, void *), void *d) +{ + int ret; + + ret = _single_open_without_sbuf(f, show, d); + if (ret == 0) + ((struct seq_file *)f->private_data)->buf = sbuf_new_auto(); + + return (ret); +} + +int +single_open_size(struct linux_file *f, int (*show)(struct seq_file *, void *), void *d, size_t size) +{ + int ret; + + ret = _single_open_without_sbuf(f, show, d); + if (ret == 0) + ((struct seq_file *)f->private_data)->buf = sbuf_new( + NULL, NULL, size, SBUF_AUTOEXTEND); + + return (ret); +} + int seq_release(struct inode *inode __unused, struct linux_file *file) { struct seq_file *m; struct sbuf *s; m = file->private_data; s = m->buf; sbuf_delete(s); free(m, M_LSEQ); return (0); } int seq_release_private(struct inode *inode __unused, struct linux_file *f) { struct seq_file *seq; seq = (struct seq_file *)f->private_data; free(seq->private, M_LSEQ); return (seq_release(inode, f)); } int single_release(struct vnode *v, struct linux_file *f) { const struct seq_operations *op; struct seq_file *m; int rc; /* be NULL safe */ if ((m = f->private_data) == NULL) return (0); op = m->op; rc = seq_release(v, f); free(__DECONST(void *, op), M_LSEQ); return (rc); } void lkpi_seq_vprintf(struct seq_file *m, const char *fmt, va_list args) { - sbuf_vprintf(m->buf, fmt, args); + int ret; + + ret = sbuf_vprintf(m->buf, fmt, args); + if (ret == 0) + m->size = sbuf_len(m->buf); } void lkpi_seq_printf(struct seq_file *m, const char *fmt, ...) { va_list args; va_start(args, fmt); - seq_vprintf(m, fmt, args); + lkpi_seq_vprintf(m, fmt, args); va_end(args); } + +bool +seq_has_overflowed(struct seq_file *m) +{ + return (sbuf_len(m->buf) == -1); +}