linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Implement the manual drop-all-pagecache function

 */

​

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/fs.h>

#include <linux/writeback.h>

#include <linux/sysctl.h>

#include <linux/gfp.h>

#include "internal.h"

​

/* A global variable is a bit ugly, but it keeps the code simple */

int sysctl_drop_caches;

​

static void drop_pagecache_sb(struct super_block *sb, void *unused)

{

    struct inode *inode, *toput_inode = NULL;

​

    spin_lock(&sb->s_inode_list_lock);

    list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {

        spin_lock(&inode->i_lock);

        /*

         * We must skip inodes in unusual state. We may also skip

         * inodes without pages but we deliberately won't in case

         * we need to reschedule to avoid softlockups.

         */

        if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||

            (inode->i_mapping->nrpages == 0 && !need_resched())) {

            spin_unlock(&inode->i_lock);

            continue;

        }

        __iget(inode);

        spin_unlock(&inode->i_lock);

        spin_unlock(&sb->s_inode_list_lock);

​

        cond_resched();

        invalidate_mapping_pages(inode->i_mapping, 0, -1);

        iput(toput_inode);

        toput_inode = inode;

​

        spin_lock(&sb->s_inode_list_lock);

    }

    spin_unlock(&sb->s_inode_list_lock);

    iput(toput_inode);

}

​

int drop_caches_sysctl_handler(struct ctl_table *table, int write,

    void __user *buffer, size_t *length, loff_t *ppos)

{

    int ret;

​

    ret = proc_dointvec_minmax(table, write, buffer, length, ppos);

    if (ret)

        return ret;

    if (write) {

        static int stfu;

​

        if (sysctl_drop_caches & 1) {

            iterate_supers(drop_pagecache_sb, NULL);

            count_vm_event(DROP_PAGECACHE);

        }