linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * linux/fs/seq_file.c

 *

 * helper functions for making synthetic files from sequences of records.

 * initial implementation -- AV, Oct 2001.

 */

​

#include <linux/cache.h>

#include <linux/fs.h>

#include <linux/export.h>

#include <linux/seq_file.h>

#include <linux/vmalloc.h>

#include <linux/slab.h>

#include <linux/cred.h>

#include <linux/mm.h>

#include <linux/printk.h>

#include <linux/string_helpers.h>

​

#include <linux/uaccess.h>

#include <asm/page.h>

​

static struct kmem_cache *seq_file_cache __ro_after_init;

​

static void seq_set_overflow(struct seq_file *m)

{

    m->count = m->size;

}

​

static void *seq_buf_alloc(unsigned long size)

{

    return kvmalloc(size, GFP_KERNEL_ACCOUNT);

}

​

/**

 *  seq_open -  initialize sequential file

 *  @file: file we initialize

 *  @op: method table describing the sequence

 *

 *  seq_open() sets @file, associating it with a sequence described

 *  by @op.  @op->start() sets the iterator up and returns the first

 *  element of sequence. @op->stop() shuts it down.  @op->next()

 *  returns the next element of sequence.  @op->show() prints element

 *  into the buffer.  In case of error ->start() and ->next() return

 *  ERR_PTR(error).  In the end of sequence they return %NULL. ->show()

 *  returns 0 in case of success and negative number in case of error.

 *  Returning SEQ_SKIP means "discard this element and move on".

 *  Note: seq_open() will allocate a struct seq_file and store its

 *  pointer in @file->private_data. This pointer should not be modified.

 */

int seq_open(struct file *file, const struct seq_operations *op)

{

    struct seq_file *p;

​

    WARN_ON(file->private_data);

​

    p = kmem_cache_zalloc(seq_file_cache, GFP_KERNEL);

    if (!p)

        return -ENOMEM;

​

    file->private_data = p;

​

    mutex_init(&p->lock);

    p->op = op;

​

    // No refcounting: the lifetime of 'p' is constrained

    // to the lifetime of the file.

    p->file = file;

​

    /*

     * Wrappers around seq_open(e.g. swaps_open) need to be

     * aware of this. If they set f_version themselves, they

     * should call seq_open first and then set f_version.

     */

    file->f_version = 0;

​

    /*

     * seq_files support lseek() and pread().  They do not implement

     * write() at all, but we clear FMODE_PWRITE here for historical

     * reasons.

     *

     * If a client of seq_files a) implements file.write() and b) wishes to

     * support pwrite() then that client will need to implement its own

     * file.open() which calls seq_open() and then sets FMODE_PWRITE.

     */

    file->f_mode &= ~FMODE_PWRITE;

    return 0;

}

EXPORT_SYMBOL(seq_open);

​

static int traverse(struct seq_file *m, loff_t offset)

{