writeback相关数据结构
 
与writeback相关的数据结构主要有:
1,backing_dev_info,该数据结构描述了backing_dev的所有信息,通常块设备的request queue中会包含backing_dev对象。
2,bdi_writeback,该数据结构封装了writeback的内核线程以及需要操作的inode队列。
3,wb_writeback_work,该数据结构封装了writeback的工作任务。
 
各数据结构之间的关系如下图所示:
 

 

下面对各个数据结构做简要介绍。
 
bdi information
 
bdi对象在块设备添加的时候需要注册到系统的bdi队列中。对于ext3而言,在mount的时候需要将底层块设备的bdi对象联系到ext3 root_inode中。bdi对象数据结构定义如下:
  1. struct backing_dev_info {  
  2.     struct list_head bdi_list;  
  3.     unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */  
  4.     unsigned long state;    /* Always use atomic bitops on this */  
  5.     unsigned int capabilities; /* Device capabilities */  
  6.     congested_fn *congested_fn; /* Function pointer if device is md/dm */  
  7.     void *congested_data;   /* Pointer to aux data for congested func */  
  8.  
  9.     char *name;  
  10.  
  11.     struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];  
  12.  
  13.     unsigned long bw_time_stamp;    /* last time write bw is updated */  
  14.     unsigned long dirtied_stamp;  
  15.     unsigned long written_stamp;    /* pages written at bw_time_stamp */  
  16.     unsigned long write_bandwidth;  /* the estimated write bandwidth */  
  17.     unsigned long avg_write_bandwidth; /* further smoothed write bw */  
  18.  
  19.     /*  
  20.      * The base dirty throttle rate, re-calculated on every 200ms.  
  21.      * All the bdi tasks' dirty rate will be curbed under it.  
  22.      * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit  
  23.      * in small steps and is much more smooth/stable than the latter.  
  24.      */  
  25.     unsigned long dirty_ratelimit;  
  26.     unsigned long balanced_dirty_ratelimit;  
  27.  
  28.     struct prop_local_percpu completions;  
  29.     int dirty_exceeded;  
  30.  
  31.     unsigned int min_ratio;  
  32.     unsigned int max_ratio, max_prop_frac;  
  33.  
  34.     struct bdi_writeback wb;  /* default writeback info for this bdi,writeback对象 */  
  35.     spinlock_t wb_lock;   /* protects work_list */  
  36.  
  37.     /* 任务链表 */  
  38.     struct list_head work_list;  
  39.  
  40.     struct device *dev;  
  41.     /* 在laptop模式下应用的定时器 */  
  42.     struct timer_list laptop_mode_wb_timer;  
  43.  
  44. #ifdef CONFIG_DEBUG_FS  
  45.     struct dentry *debug_dir;  
  46.     struct dentry *debug_stats;  
  47. #endif  
  48. }; 

 

在bdi数据结构中定义了一个writeback对象,该对象是对writeback内核线程的描述,并且封装了需要处理的inode队列。在bdi数据结构中有一条work_list,该work队列维护了writeback内核线程需要处理的任务。如果该队列上没有work可以处理,那么writeback内核线程将会睡眠等待。
writeback
 
writeback对象封装了内核线程task以及需要处理的inode队列。当page cache/buffer cache需要刷新radix tree上的inode时,可以将该inode挂载到writeback对象的b_dirty队列上,然后唤醒writeback线程。在处理过程中,inode会被移到b_io队列上进行处理。多条链表的方式可以降低多线程之间的资源共享。writeback数据结构具体定义如下:

 

  1. struct bdi_writeback {  
  2.     struct backing_dev_info *bdi;   /* our parent bdi */  
  3.     unsigned int nr;  
  4.  
  5.     unsigned long last_old_flush;   /* last old data flush */  
  6.     unsigned long last_active;  /* last time bdi thread was active */  
  7.  
  8.     struct task_struct *task;   /* writeback thread */  
  9.     struct timer_list wakeup_timer; /* used for delayed bdi thread wakeup */  
  10.     struct list_head b_dirty;   /* dirty inodes */  
  11.     struct list_head b_io;      /* parked for writeback */  
  12.     struct list_head b_more_io; /* parked for more writeback */  
  13.     spinlock_t list_lock;       /* protects the b_* lists */  
  14. }; 

writeback work

 
wb_writeback_work数据结构是对writeback任务的封装,不同的任务可以采用不同的刷新策略。writeback线程的处理对象就是writeback_work。如果writeback_work队列为空,那么内核线程就可以睡眠了。Writeback_work的数据结构定义如下:
  1. struct wb_writeback_work {  
  2.     long nr_pages;  
  3.     struct super_block *sb; /* superblock对象 */  
  4.     unsigned long *older_than_this;  
  5.     enum writeback_sync_modes sync_mode;  
  6.     unsigned int tagged_writepages:1;  
  7.     unsigned int for_kupdate:1;  
  8.     unsigned int range_cyclic:1;  
  9.     unsigned int for_background:1;  
  10.     enum wb_reason reason;      /* why was writeback initiated? */  
  11.       
  12.     struct list_head list;      /* pending work list,链入bdi-> work_list队列 */  
  13.     struct completion *done;    /* set if the caller waits,work完成时通知调用者 */  
  14. }; 

 

writeback主要函数分析
 
writeback机制的主要函数包括如下两个方面:
1,管理bdi对象并且fork相应的writeback内核线程处理cache数据的刷新工作。
2,writeback内核线程处理函数,实现dirty page的刷新操作
 
writeback线程管理
 
Linux中有一个内核守护线程,该线程用来管理系统bdi队列,并且负责为block device创建writeback thread。当bdi中有dirty page并且还没有为bdi分配内核线程的时候,bdi_forker_thread程序会为其分配线程资源;当一个writeback线程长时间处于空闲状态时,bdi_forker_thread程序会释放该线程资源。
 
writeback线程管理程序分析如下:
  1. static int bdi_forker_thread(void *ptr)  
  2. {  
  3.     struct bdi_writeback *me = ptr;  
  4.  
  5.     current->flags |= PF_SWAPWRITE;  
  6.     set_freezable();  
  7.  
  8.     /*  
  9.      * Our parent may run at a different priority, just set us to normal  
  10.      */  
  11.     set_user_nice(current, 0);  
  12.  
  13.     for (;;) {  
  14.         struct task_struct *task = NULL;  
  15.         struct backing_dev_info *bdi;  
  16.         enum {  
  17.             NO_ACTION,   /* Nothing to do */  
  18.             FORK_THREAD, /* Fork bdi thread */  
  19.             KILL_THREAD, /* Kill inactive bdi thread */  
  20.         } action = NO_ACTION;  
  21.  
  22.         /*  
  23.          * Temporary measure, we want to make sure we don't see  
  24.          * dirty data on the default backing_dev_info  
  25.          */  
  26.         if (wb_has_dirty_io(me) || !list_empty(&me->bdi->work_list)) {  
  27.             del_timer(&me->wakeup_timer);  
  28.             wb_do_writeback(me, 0);  
  29.         }  
  30.  
  31.         spin_lock_bh(&bdi_lock);  
  32.         /*  
  33.          * In the following loop we are going to check whether we have  
  34.          * some work to do without any synchronization with tasks  
  35.          * waking us up to do work for them. Set the task state here  
  36.          * so that we don't miss wakeups after verifying conditions.  
  37.          */  
  38.         set_current_state(TASK_INTERRUPTIBLE);  
  39.         /* 遍历所有的bdi对象,检查这些bdi是否存在脏数据,如果有脏数据,那么需要为其fork线程,然后做writeback操作 */  
  40.         list_for_each_entry(bdi, &bdi_list, bdi_list) {  
  41.             bool have_dirty_io;  
  42.  
  43.             if (!bdi_cap_writeback_dirty(bdi) ||  
  44.                  bdi_cap_flush_forker(bdi))  
  45.                 continue;  
  46.  
  47.             WARN(!test_bit(BDI_registered, &bdi->state),  
  48.                  "bdi %p/%s is not registered!\n", bdi, bdi->name);  
  49.             /* 检查是否存在脏数据 */  
  50.             have_dirty_io = !list_empty(&bdi->work_list) ||  
  51.                     wb_has_dirty_io(&bdi->wb);  
  52.  
  53.             /*  
  54.              * If the bdi has work to do, but the thread does not  
  55.              * exist - create it.  
  56.              */  
  57.             if (!bdi->wb.task && have_dirty_io) {  
  58.                 /*  
  59.                  * Set the pending bit - if someone will try to  
  60.                  * unregister this bdi - it'll wait on this bit.  
  61.                  */  
  62.                 /* 如果有脏数据,并且不存在线程,那么接下来做线程的FORK操作 */  
  63.                 set_bit(BDI_pending, &bdi->state);  
  64.                 action = FORK_THREAD;  
  65.                 break;  
  66.             }  
  67.  
  68.             spin_lock(&bdi->wb_lock);  
  69.  
  70.             /*  
  71.              * If there is no work to do and the bdi thread was  
  72.              * inactive long enough - kill it. The wb_lock is taken  
  73.              * to make sure no-one adds more work to this bdi and  
  74.              * wakes the bdi thread up.  
  75.              */  
  76.             /* 如果一个bdi长时间没有脏数据,那么执行线程的KILL操作,结束掉该bdi对应的writeback线程 */  
  77.             if (bdi->wb.task && !have_dirty_io &&  
  78.                 time_after(jiffies, bdi->wb.last_active +  
  79.                         bdi_longest_inactive())) {  
  80.                 task = bdi->wb.task;  
  81.                 bdi->wb.task = NULL;  
  82.                 spin_unlock(&bdi->wb_lock);  
  83.                 set_bit(BDI_pending, &bdi->state);  
  84.                 action = KILL_THREAD;  
  85.                 break;  
  86.             }  
  87.             spin_unlock(&bdi->wb_lock);  
  88.         }  
  89.         spin_unlock_bh(&bdi_lock);  
  90.  
  91.         /* Keep working if default bdi still has things to do */  
  92.         if (!list_empty(&me->bdi->work_list))  
  93.             __set_current_state(TASK_RUNNING);  
  94.         /* 执行线程的FORK和KILL操作 */  
  95.         switch (action) {  
  96.         case FORK_THREAD:  
  97.             /* FORK一个bdi_writeback_thread线程,该线程的名字为flush-major:minor */  
  98.             __set_current_state(TASK_RUNNING);  
  99.             task = kthread_create(bdi_writeback_thread, &bdi->wb,  
  100.                           "flush-%s", dev_name(bdi->dev));  
  101.             if (IS_ERR(task)) {  
  102.                 /*  
  103.                  * If thread creation fails, force writeout of  
  104.                  * the bdi from the thread. Hopefully 1024 is  
  105.                  * large enough for efficient IO.  
  106.                  */  
  107.                 writeback_inodes_wb(&bdi->wb, 1024,  
  108.                             WB_REASON_FORKER_THREAD);  
  109.             } else {  
  110.                 /*  
  111.                  * The spinlock makes sure we do not lose  
  112.                  * wake-ups when racing with 'bdi_queue_work()'.  
  113.                  * And as soon as the bdi thread is visible, we  
  114.                  * can start it.  
  115.                  */  
  116.                 spin_lock_bh(&bdi->wb_lock);  
  117.                 bdi->wb.task = task;  
  118.                 spin_unlock_bh(&bdi->wb_lock);  
  119.                 wake_up_process(task);  
  120.             }  
  121.             bdi_clear_pending(bdi);  
  122.             break;  
  123.  
  124.         case KILL_THREAD:  
  125.             /* KILL一个线程 */  
  126.             __set_current_state(TASK_RUNNING);  
  127.             kthread_stop(task);  
  128.             bdi_clear_pending(bdi);  
  129.             break;  
  130.  
  131.         case NO_ACTION:  
  132.             /* 如果没有可执行的动作,那么调度本线程睡眠一段时间 */  
  133.             if (!wb_has_dirty_io(me) || !dirty_writeback_interval)  
  134.                 /*  
  135.                  * There are no dirty data. The only thing we  
  136.                  * should now care about is checking for  
  137.                  * inactive bdi threads and killing them. Thus,  
  138.                  * let's sleep for longer time, save energy and  
  139.                  * be friendly for battery-driven devices.  
  140.                  */  
  141.                 schedule_timeout(bdi_longest_inactive());  
  142.             else  
  143.                 schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10));  
  144.             try_to_freeze();  
  145.             break;  
  146.         }  
  147.     }  
  148.  
  149.     return 0;  

writeback线程

 
writeback线程是bdi_forker_thread 创建的,该线程的任务就是处理等待的数据回刷任务。线程处理函数为bdi_writeback_thread,其会调用wb_do_writeback函数完成具体操作,该函数分析如下:
  1. long wb_do_writeback(struct bdi_writeback *wb, int force_wait)  
  2. {  
  3.     struct backing_dev_info *bdi = wb->bdi;  
  4.     struct wb_writeback_work *work;  
  5.     long wrote = 0;  
  6.  
  7.     set_bit(BDI_writeback_running, &wb->bdi->state);  
  8.     /* 处理等待的work,所有等待work pengding在bdi->work_list上 */  
  9.     while ((work = get_next_work_item(bdi)) != NULL) {  
  10.         /*  
  11.          * Override sync mode, in case we must wait for completion  
  12.          * because this thread is exiting now.  
  13.          */  
  14.         if (force_wait)  
  15.             work->sync_mode = WB_SYNC_ALL;  
  16.  
  17.         trace_writeback_exec(bdi, work);  
  18.         /* 调用wb_writeback函数处理相应的inode */  
  19.         wrote += wb_writeback(wb, work);  
  20.  
  21.         /*  
  22.          * Notify the caller of completion if this is a synchronous  
  23.          * work item, otherwise just free it.  
  24.          */  
  25.         /* 通知上层软件,相应的work已经完成 */  
  26.         if (work->done)  
  27.             complete(work->done);  
  28.         else  
  29.             kfree(work);  
  30.     }  
  31.  
  32.     /*  
  33.      * Check for periodic writeback, kupdated() style  
  34.      */  
  35.     /* 处理周期性的dirty page刷新作业,buffer cache就会走这条路径,在下面的函数中会创建work,并且调用wb_writeback函数进行处理 */  
  36.     wrote += wb_check_old_data_flush(wb);  
  37.     wrote += wb_check_background_flush(wb);  
  38.     clear_bit(BDI_writeback_running, &wb->bdi->state);  
  39.  
  40.     return wrote;  

 

小结
 
本文在linux-3.2的基础上对writeback代码进行了浏览。整体上来讲,writeback机制是比较简单的,其核心是通过一个常驻内核线程为bdi对象分配writeback线程,实现对cache中dirty page的数据回刷。