writeback: get rid of pdflush completely (d0bceac7) · Commits · e / devices / android_kernel_oneplus_sm7250

fs/fs-writeback.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,11 @@

		#define inode_to_bdi(inode) ((inode)->i_mapping->backing_dev_info)

		/*
		* We don't actually have pdflush, but this one is exported though /proc...
		*/
		int nr_pdflush_threads;

		/*
		* Work items for the bdi_writeback threads
		*/

include/linux/writeback.h

+0 −12

Original line number	Diff line number	Diff line
		@@ -13,17 +13,6 @@ extern spinlock_t inode_lock;
		extern struct list_head inode_in_use;
		extern struct list_head inode_unused;

		/*
		* Yes, writeback.h requires sched.h
		* No, sched.h is not included from here.
		*/
		static inline int task_is_pdflush(struct task_struct *task)
		{
		return task->flags & PF_FLUSHER;
		}

		#define current_is_pdflush() task_is_pdflush(current)

		/*
		* fs/fs-writeback.c
		*/
		@@ -155,7 +144,6 @@ balance_dirty_pages_ratelimited(struct address_space *mapping)
		typedef int (writepage_t)(struct page page, struct writeback_control *wbc,
		void *data);

		int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
		int generic_writepages(struct address_space *mapping,
		struct writeback_control *wbc);
		int write_cache_pages(struct address_space *mapping,

mm/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -8,7 +8,7 @@ mmu-$(CONFIG_MMU) := fremap.o highmem.o madvise.o memory.o mincore.o \
		vmalloc.o

		obj-y := bootmem.o filemap.o mempool.o oom_kill.o fadvise.o \
		maccess.o page_alloc.o page-writeback.o pdflush.o \
		maccess.o page_alloc.o page-writeback.o \
		readahead.o swap.o truncate.o vmscan.o shmem.o \
		prio_tree.o util.o mmzone.o vmstat.o backing-dev.o \
		page_isolation.o mm_init.o $(mmu-y)

mm/pdflush.c

deleted100644 → 0

+0 −269

Original line number	Diff line number	Diff line
		/*
		* mm/pdflush.c - worker threads for writing back filesystem data
		*
		* Copyright (C) 2002, Linus Torvalds.
		*
		* 09Apr2002 Andrew Morton
		* Initial version
		* 29Feb2004 kaos@sgi.com
		* Move worker thread creation to kthread to avoid chewing
		* up stack space with nested calls to kernel_thread.
		*/

		#include <linux/sched.h>
		#include <linux/list.h>
		#include <linux/signal.h>
		#include <linux/spinlock.h>
		#include <linux/gfp.h>
		#include <linux/init.h>
		#include <linux/module.h>
		#include <linux/fs.h> /* Needed by writeback.h */
		#include <linux/writeback.h> /* Prototypes pdflush_operation() */
		#include <linux/kthread.h>
		#include <linux/cpuset.h>
		#include <linux/freezer.h>


		/*
		* Minimum and maximum number of pdflush instances
		*/
		#define MIN_PDFLUSH_THREADS 2
		#define MAX_PDFLUSH_THREADS 8

		static void start_one_pdflush_thread(void);


		/*
		* The pdflush threads are worker threads for writing back dirty data.
		* Ideally, we'd like one thread per active disk spindle. But the disk
		* topology is very hard to divine at this level. Instead, we take
		* care in various places to prevent more than one pdflush thread from
		* performing writeback against a single filesystem. pdflush threads
		* have the PF_FLUSHER flag set in current->flags to aid in this.
		*/

		/*
		* All the pdflush threads. Protected by pdflush_lock
		*/
		static LIST_HEAD(pdflush_list);
		static DEFINE_SPINLOCK(pdflush_lock);

		/*
		* The count of currently-running pdflush threads. Protected
		* by pdflush_lock.
		*
		* Readable by sysctl, but not writable. Published to userspace at
		* /proc/sys/vm/nr_pdflush_threads.
		*/
		int nr_pdflush_threads = 0;

		/*
		* The time at which the pdflush thread pool last went empty
		*/
		static unsigned long last_empty_jifs;

		/*
		* The pdflush thread.
		*
		* Thread pool management algorithm:
		*
		* - The minimum and maximum number of pdflush instances are bound
		* by MIN_PDFLUSH_THREADS and MAX_PDFLUSH_THREADS.
		*
		* - If there have been no idle pdflush instances for 1 second, create
		* a new one.
		*
		* - If the least-recently-went-to-sleep pdflush thread has been asleep
		* for more than one second, terminate a thread.
		*/

		/*
		* A structure for passing work to a pdflush thread. Also for passing
		* state information between pdflush threads. Protected by pdflush_lock.
		*/
		struct pdflush_work {
		struct task_struct who; / The thread */
		void (fn)(unsigned long); / A callback function */
		unsigned long arg0; /* An argument to the callback */
		struct list_head list; /* On pdflush_list, when idle */
		unsigned long when_i_went_to_sleep;
		};

		static int __pdflush(struct pdflush_work *my_work)
		{
		current->flags \|= PF_FLUSHER \| PF_SWAPWRITE;
		set_freezable();
		my_work->fn = NULL;
		my_work->who = current;
		INIT_LIST_HEAD(&my_work->list);

		spin_lock_irq(&pdflush_lock);
		for ( ; ; ) {
		struct pdflush_work *pdf;

		set_current_state(TASK_INTERRUPTIBLE);
		list_move(&my_work->list, &pdflush_list);
		my_work->when_i_went_to_sleep = jiffies;
		spin_unlock_irq(&pdflush_lock);
		schedule();
		try_to_freeze();
		spin_lock_irq(&pdflush_lock);
		if (!list_empty(&my_work->list)) {
		/*
		* Someone woke us up, but without removing our control
		* structure from the global list. swsusp will do this
		* in try_to_freeze()->refrigerator(). Handle it.
		*/
		my_work->fn = NULL;
		continue;
		}
		if (my_work->fn == NULL) {
		printk("pdflush: bogus wakeup\n");
		continue;
		}
		spin_unlock_irq(&pdflush_lock);

		(*my_work->fn)(my_work->arg0);

		spin_lock_irq(&pdflush_lock);

		/*
		* Thread creation: For how long have there been zero
		* available threads?
		*
		* To throttle creation, we reset last_empty_jifs.
		*/
		if (time_after(jiffies, last_empty_jifs + 1 * HZ)) {
		if (list_empty(&pdflush_list)) {
		if (nr_pdflush_threads < MAX_PDFLUSH_THREADS) {
		last_empty_jifs = jiffies;
		nr_pdflush_threads++;
		spin_unlock_irq(&pdflush_lock);
		start_one_pdflush_thread();
		spin_lock_irq(&pdflush_lock);
		}
		}
		}

		my_work->fn = NULL;

		/*
		* Thread destruction: For how long has the sleepiest
		* thread slept?
		*/
		if (list_empty(&pdflush_list))
		continue;
		if (nr_pdflush_threads <= MIN_PDFLUSH_THREADS)
		continue;
		pdf = list_entry(pdflush_list.prev, struct pdflush_work, list);
		if (time_after(jiffies, pdf->when_i_went_to_sleep + 1 * HZ)) {
		/* Limit exit rate */
		pdf->when_i_went_to_sleep = jiffies;
		break; /* exeunt */
		}
		}
		nr_pdflush_threads--;
		spin_unlock_irq(&pdflush_lock);
		return 0;
		}

		/*
		* Of course, my_work wants to be just a local in __pdflush(). It is
		* separated out in this manner to hopefully prevent the compiler from
		* performing unfortunate optimisations against the auto variables. Because
		* these are visible to other tasks and CPUs. (No problem has actually
		* been observed. This is just paranoia).
		*/
		static int pdflush(void *dummy)
		{
		struct pdflush_work my_work;
		cpumask_var_t cpus_allowed;

		/*
		* Since the caller doesn't even check kthread_run() worked, let's not
		* freak out too much if this fails.
		*/
		if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
		printk(KERN_WARNING "pdflush failed to allocate cpumask\n");
		return 0;
		}

		/*
		* pdflush can spend a lot of time doing encryption via dm-crypt. We
		* don't want to do that at keventd's priority.
		*/
		set_user_nice(current, 0);

		/*
		* Some configs put our parent kthread in a limited cpuset,
		* which kthread() overrides, forcing cpus_allowed == cpu_all_mask.
		* Our needs are more modest - cut back to our cpusets cpus_allowed.
		* This is needed as pdflush's are dynamically created and destroyed.
		* The boottime pdflush's are easily placed w/o these 2 lines.
		*/
		cpuset_cpus_allowed(current, cpus_allowed);
		set_cpus_allowed_ptr(current, cpus_allowed);
		free_cpumask_var(cpus_allowed);

		return __pdflush(&my_work);
		}

		/*
		* Attempt to wake up a pdflush thread, and get it to do some work for you.
		* Returns zero if it indeed managed to find a worker thread, and passed your
		* payload to it.
		*/
		int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0)
		{
		unsigned long flags;
		int ret = 0;

		BUG_ON(fn == NULL); /* Hard to diagnose if it's deferred */

		spin_lock_irqsave(&pdflush_lock, flags);
		if (list_empty(&pdflush_list)) {
		ret = -1;
		} else {
		struct pdflush_work *pdf;

		pdf = list_entry(pdflush_list.next, struct pdflush_work, list);
		list_del_init(&pdf->list);
		if (list_empty(&pdflush_list))
		last_empty_jifs = jiffies;
		pdf->fn = fn;
		pdf->arg0 = arg0;
		wake_up_process(pdf->who);
		}
		spin_unlock_irqrestore(&pdflush_lock, flags);

		return ret;
		}

		static void start_one_pdflush_thread(void)
		{
		struct task_struct *k;

		k = kthread_run(pdflush, NULL, "pdflush");
		if (unlikely(IS_ERR(k))) {
		spin_lock_irq(&pdflush_lock);
		nr_pdflush_threads--;
		spin_unlock_irq(&pdflush_lock);
		}
		}

		static int __init pdflush_init(void)
		{
		int i;

		/*
		* Pre-set nr_pdflush_threads... If we fail to create,
		* the count will be decremented.
		*/
		nr_pdflush_threads = MIN_PDFLUSH_THREADS;

		for (i = 0; i < MIN_PDFLUSH_THREADS; i++)
		start_one_pdflush_thread();
		return 0;
		}

		module_init(pdflush_init);