程序博客网 > js左右滑动图片轮播

writeback机制源码分析

来源：互联网 发布：js左右滑动图片轮播 编辑：程序博客网 时间：2024/05/21 21:16
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://alanwu.blog.51cto.com/3652632/1110046

 

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;  
  150. } 

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;  
  41. } 

 

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

本文出自 “存储之道” 博客，请务必保留此出处http://alanwu.blog.51cto.com/3652632/1110046

0 0
js左右滑动图片轮播 js左右滑动图片轮播
原创粉丝点击
热门IT博客
网络监控解决方案网络监控解决方案
苹果原装充电器数据苹果原装充电器数据
郑州seo
帝国cms产品展示模板
c语言strcpy函数实现
欧美流行歌手知乎
网络主播毒药磁力
linux .ssh目录不存在
淘宝网注册首页
淘宝开店卖什么好
58同城网络兼职招聘
java对象数组定义
数据眼txt qingkan
百度 霸屏 js 代码
恺英网络股票千股千评
网络对小学生的利与弊
淘宝详情页psd素材
squid与nginx
一淘跟淘宝什么关系
中超边后卫防守数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 微通时代 龙子湖微时代售楼部 微时代网络营销 微时代房子 时代微卡汽车报价 微时代餐饮 微时代app 微时代之恋演员表 微商2.0时代 微时代好看么 网络微时代 微时代是做什么的 微时代平台怎么样 微时代恋人 v微时代 微时代阅读 全微时代 微时代会员卡 微时代插曲 微时代教程 微时代 作文 掘金微时代 微时代预告 微时代金融 微时代下载 时代微卡怎么样 微时代全集下载 微时代后台 微时代多少集 微时代登录 微时代男主角 2015微商时代 微时代主题曲 微时代主演 微时代 营销 类似微时代 北京微影时代科技有限公司 微时代源码 微思时代科技 微时代有限公司 微时代英文

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里