redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

writeback: harmonize writeback threads naming

Browse source 
The write-back code mixes words "thread" and "task" for the same things. This
is not a big deal, but still an inconsistency.

hch: a convention I tend to use and I've seen in various places
is to always use _task for the storage of the task_struct pointer,
and thread everywhere else.  This especially helps with having
foo_thread for the actual thread and foo_task for a global
variable keeping the task_struct pointer

This patch renames:
* 'bdi_add_default_flusher_task()' -> 'bdi_add_default_flusher_thread()'
* 'bdi_forker_task()'              -> 'bdi_forker_thread()'

because bdi threads are 'bdi_writeback_thread()', so these names are more
consistent.

This patch also amends commentaries and makes them refer the forker and bdi
threads as "thread", not "task".

Also, while on it, make 'bdi_add_default_flusher_thread()' declaration use
'static void' instead of 'void static' and make checkpatch.pl happy.

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>
This commit is contained in:
Artem Bityutskiy 2010-07-25 14:29:11 +03:00 committed by Jens Axboe
parent 4aeefdc69f
commit 6f904ff0e3
3 changed files with 15 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
fs/fs-writeback.c
View file

@ -840,7 +840,7 @@ int bdi_writeback_thread(void *data)
/* /*
* Longest period of inactivity that we tolerate. If we * Longest period of inactivity that we tolerate. If we
* see dirty data again later, the task will get * see dirty data again later, the thread will get
* recreated automatically. * recreated automatically.
*/ */
max_idle = max(5UL * 60 * HZ, wait_jiffies); max_idle = max(5UL * 60 * HZ, wait_jiffies);

2
include/linux/backing-dev.h
View file

@ -50,7 +50,7 @@ struct bdi_writeback {
unsigned long last_old_flush; /* last old data flush */ unsigned long last_old_flush; /* last old data flush */
struct task_struct *task; /* writeback task */ struct task_struct *task; /* writeback thread */
struct list_head b_dirty; /* dirty inodes */ struct list_head b_dirty; /* dirty inodes */
struct list_head b_io; /* parked for writeback */ struct list_head b_io; /* parked for writeback */
struct list_head b_more_io; /* parked for more writeback */ struct list_head b_more_io; /* parked for more writeback */

26
mm/backing-dev.c
View file

@ -50,7 +50,7 @@ static struct timer_list sync_supers_timer;
static int bdi_sync_supers(void *); static int bdi_sync_supers(void *);
static void sync_supers_timer_fn(unsigned long); static void sync_supers_timer_fn(unsigned long);
static void bdi_add_default_flusher_task(struct backing_dev_info *bdi); static void bdi_add_default_flusher_thread(struct backing_dev_info *bdi);
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
#include <linux/debugfs.h> #include <linux/debugfs.h>
@ -279,10 +279,10 @@ static void bdi_flush_io(struct backing_dev_info *bdi)
} }
/* /*
* kupdated() used to do this. We cannot do it from the bdi_forker_task() * kupdated() used to do this. We cannot do it from the bdi_forker_thread()
* or we risk deadlocking on ->s_umount. The longer term solution would be * or we risk deadlocking on ->s_umount. The longer term solution would be
* to implement sync_supers_bdi() or similar and simply do it from the * to implement sync_supers_bdi() or similar and simply do it from the
* bdi writeback tasks individually. * bdi writeback thread individually.
*/ */
static int bdi_sync_supers(void *unused) static int bdi_sync_supers(void *unused)
{ {
@ -318,7 +318,7 @@ static void sync_supers_timer_fn(unsigned long unused)
bdi_arm_supers_timer(); bdi_arm_supers_timer();
} }
static int bdi_forker_task(void *ptr) static int bdi_forker_thread(void *ptr)
{ {
struct bdi_writeback *me = ptr; struct bdi_writeback *me = ptr;
@ -354,7 +354,7 @@ static int bdi_forker_task(void *ptr)
!bdi_has_dirty_io(bdi)) !bdi_has_dirty_io(bdi))
continue; continue;
bdi_add_default_flusher_task(bdi); bdi_add_default_flusher_thread(bdi);
} }
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
@ -376,7 +376,7 @@ static int bdi_forker_task(void *ptr)
/* /*
* This is our real job - check for pending entries in * This is our real job - check for pending entries in
* bdi_pending_list, and create the tasks that got added * bdi_pending_list, and create the threads that got added
*/ */
bdi = list_entry(bdi_pending_list.next, struct backing_dev_info, bdi = list_entry(bdi_pending_list.next, struct backing_dev_info,
bdi_list); bdi_list);
@ -387,7 +387,7 @@ static int bdi_forker_task(void *ptr)
wb->task = kthread_run(bdi_writeback_thread, wb, "flush-%s", wb->task = kthread_run(bdi_writeback_thread, wb, "flush-%s",
dev_name(bdi->dev)); dev_name(bdi->dev));
/* /*
* If task creation fails, then readd the bdi to * If thread creation fails, then readd the bdi to
* the pending list and force writeout of the bdi * the pending list and force writeout of the bdi
* from this forker thread. That will free some memory * from this forker thread. That will free some memory
* and we can try again. * and we can try again.
@ -430,10 +430,10 @@ static void bdi_add_to_pending(struct rcu_head *head)
} }
/* /*
* Add the default flusher task that gets created for any bdi * Add the default flusher thread that gets created for any bdi
* that has dirty data pending writeout * that has dirty data pending writeout
*/ */
void static bdi_add_default_flusher_task(struct backing_dev_info *bdi) static void bdi_add_default_flusher_thread(struct backing_dev_info *bdi)
{ {
if (!bdi_cap_writeback_dirty(bdi)) if (!bdi_cap_writeback_dirty(bdi))
return; return;
@ -445,10 +445,10 @@ void static bdi_add_default_flusher_task(struct backing_dev_info *bdi)
} }
/* /*
* Check with the helper whether to proceed adding a task. Will only * Check with the helper whether to proceed adding a thread. Will only
* abort if we two or more simultanous calls to * abort if we two or more simultanous calls to
* bdi_add_default_flusher_task() occured, further additions will block * bdi_add_default_flusher_thread() occured, further additions will
* waiting for previous additions to finish. * block waiting for previous additions to finish.
*/ */
if (!test_and_set_bit(BDI_pending, &bdi->state)) { if (!test_and_set_bit(BDI_pending, &bdi->state)) {
list_del_rcu(&bdi->bdi_list); list_del_rcu(&bdi->bdi_list);
@ -506,7 +506,7 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
if (bdi_cap_flush_forker(bdi)) { if (bdi_cap_flush_forker(bdi)) {
struct bdi_writeback *wb = &bdi->wb; struct bdi_writeback *wb = &bdi->wb;
wb->task = kthread_run(bdi_forker_task, wb, "bdi-%s", wb->task = kthread_run(bdi_forker_thread, wb, "bdi-%s",
dev_name(dev)); dev_name(dev));
if (IS_ERR(wb->task)) { if (IS_ERR(wb->task)) {
wb->task = NULL; wb->task = NULL;