linux内核源码阅读之facebook硬盘加速flashcache之六

其实到目前为止，如果对读流程已经能轻松地看懂了，那么写流程不需要太多脑细胞。我觉得再写下去没有太大的必要了，后面想想为了保持flashcache完整性，还是写出来吧。接着到写流程：

1530static void

1531flashcache_write(struct cache_c *dmc, struct bio *bio)

1532{

1533     int index;

1534     int res;

1535     struct cacheblock *cacheblk;

1536     int queued;

1537    

1538     spin_lock_irq(&dmc->cache_spin_lock);

1539     res = flashcache_lookup(dmc, bio, &index);

1540     /*

1541     * If cache hit and !BUSY, simply redirty page.

1542     * If cache hit and BUSY, must wait for IO in prog to complete.

1543     * If cache miss and found a block to recycle, we need to

1544     * (a) invalidate any partial hits,

1545     * (b) write to cache.

1546     */

1547     if (res != -1) {

1548          /* Cache Hit */

1549          cacheblk = &dmc->cache[index];         

1550          if ((cacheblk->cache_state & VALID) &&

1551              (cacheblk->dbn == bio->bi_sector)) {

1552               /* Cache Hit */

1553               flashcache_write_hit(dmc, bio, index);

1554          } else {

1555               /* Cache Miss, found block to recycle */

1556               flashcache_write_miss(dmc, bio, index);

1557          }

1558          return;

1559     }

1560     /*

1561     * No room in the set. We cannot write to the cache and have to

1562     * send the request to disk. Before we do that, we must check

1563     * for potential invalidations !

1564     */

1565     queued = flashcache_inval_blocks(dmc, bio);

1566     spin_unlock_irq(&dmc->cache_spin_lock);

1567     if (queued) {

1568          if (unlikely(queued < 0))

1569               flashcache_bio_endio(bio, -EIO);

1570          return;

1571     }

1572     /* Start uncached IO */

1573     flashcache_start_uncached_io(dmc, bio);

1574     flashcache_clean_set(dmc, hash_block(dmc, bio->bi_sector));

1575}

第1539行查找是否命中，这里有几种情况：

1）命中且cache空闲，直接写cache块并设置DIRTY标志

2）命中且cache忙，等待上一个请求完成

3）不命中并且找到可用的cache块，invalid有交集的cache块，然后再写到cache

4）没有可用cache块，invalid有次的cache块，写到磁盘

第4种情况在第1573行直接写到磁盘，最后调用的还是dm_io_async_bvec。

再看第1种情况，进入到命中处理分支：

1468static void

1469flashcache_write_hit(struct cache_c *dmc, struct bio *bio, int index)

1470{

1471     struct cacheblock *cacheblk;

1472     struct pending_job *pjob;

1473     struct kcached_job *job;

1474

1475     cacheblk = &dmc->cache[index];

1476     if (!(cacheblk->cache_state & BLOCK_IO_INPROG) && (cacheblk->head == NULL)) {

1477          if (cacheblk->cache_state & DIRTY)

1478               dmc->dirty_write_hits++;

1479          dmc->write_hits++;

1480          cacheblk->cache_state |= CACHEWRITEINPROG;

1481          spin_unlock_irq(&dmc->cache_spin_lock);

1482          job = new_kcached_job(dmc, bio, index);

1483          if (unlikely(sysctl_flashcache_error_inject & WRITE_HIT_JOB_ALLOC_FAIL)) {

1484               if (job)

1485                    flashcache_free_cache_job(job);

1486               job = NULL;

1487               sysctl_flashcache_error_inject &= ~WRITE_HIT_JOB_ALLOC_FAIL;

1488          }

1489          if (unlikely(job == NULL)) {

1490               /* 

1491               * We have a write hit, and can't allocate a job.

1492               * Since we dropped the spinlock, we have to drain any 

1493               * pending jobs.

1494               */

1495               DMERR("flashcache: Write (hit) failed ! Can't allocate memory for cache IO, block %lu", 

1496                     cacheblk->dbn);

1497               flashcache_bio_endio(bio, -EIO);

1498               spin_lock_irq(&dmc->cache_spin_lock);

1499               flashcache_free_pending_jobs(dmc, cacheblk, -EIO);

1500               cacheblk->cache_state &= ~(BLOCK_IO_INPROG);

1501               spin_unlock_irq(&dmc->cache_spin_lock);

1502          } else {

1503               job->action = WRITECACHE; /* Write data to the source device */

1504               DPRINTK("Queue job for %llu", bio->bi_sector);

1505               atomic_inc(&dmc->nr_jobs);

1506               dmc->ssd_writes++;

1507               dm_io_async_bvec(1, &job->cache, WRITE, 

1508                         bio->bi_io_vec + bio->bi_idx,

1509                         flashcache_io_callback, job);

1510               flashcache_unplug_device(dmc->cache_dev->bdev);

1511               flashcache_clean_set(dmc, index / dmc->assoc);

1512          }

1513     } else {

1514          pjob = flashcache_alloc_pending_job(dmc);

1515          if (unlikely(sysctl_flashcache_error_inject & WRITE_HIT_PENDING_JOB_ALLOC_FAIL)) {

1516               if (pjob) {

1517                    flashcache_free_pending_job(pjob);

1518                    pjob = NULL;

1519               }

1520               sysctl_flashcache_error_inject &= ~WRITE_HIT_PENDING_JOB_ALLOC_FAIL;

1521          }

1522          if (unlikely(pjob == NULL))

1523               flashcache_bio_endio(bio, -EIO);

1524          else

1525               flashcache_enq_pending(dmc, bio, index, WRITECACHE, pjob);

1526          spin_unlock_irq(&dmc->cache_spin_lock);

1527     }

1528}

在1475行获得cache块，在1476行判断是否空闲，在有IO处理或者有pending_job挂着的时候都视为忙。如果cache块空闲，则进入if分支，接下来又是套路了，创建kcached_job，成功的话就在1507行下发写请求。然后接着看写返回时做了哪些处理？进入写回调函数之前，要记住这里设置了两个标志，一个是1480行cache块的CACHEWRITEINPROG，另一个是1503行kcached_job的WRITECACHE，带着这两个标志进入到写回调函数flashcache_io_callback，并直接找到需要的地方：

188     case WRITECACHE:

189          DPRINTK("flashcache_io_callback: WRITECACHE %d",

190               index);

191          spin_lock_irqsave(&dmc->cache_spin_lock, flags);

192          if (unlikely(sysctl_flashcache_error_inject & WRITECACHE_ERROR)) {

193               job->error = error = -EIO;

194               sysctl_flashcache_error_inject &= ~WRITECACHE_ERROR;

195          }

196          VERIFY(cacheblk->cache_state & CACHEWRITEINPROG);

197          if (likely(error == 0)) {

198#ifdef FLASHCACHE_DO_CHECKSUMS

199               dmc->checksum_store++;

200               spin_unlock_irqrestore(&dmc->cache_spin_lock, flags);

201               flashcache_store_checksum(job);

202               /* 

203               * We need to update the metadata on a DIRTY->DIRTY as well 

204               * since we save the checksums.

205               */

206               push_md_io(job);

207               schedule_work(&_kcached_wq);

208               return;

209#else

210               spin_unlock_irqrestore(&dmc->cache_spin_lock, flags);

211               /* Only do cache metadata update on a non-DIRTY->DIRTY transition */

212               if ((cacheblk->cache_state & DIRTY) == 0) {

213                    push_md_io(job);

214                    schedule_work(&_kcached_wq);

215                    return;

216               }

217#endif

218          } else {

219               dmc->ssd_write_errors++;               

220               spin_unlock_irqrestore(&dmc->cache_spin_lock, flags);

221          }

222          flashcache_bio_endio(bio, error);

223          break;

写到缓存成功的话，暂不管cache块的校验值，会来到210行，判断原来的cache块是否为脏，如果为脏那就什么事情都不用做了。因为如果cache块本来就是脏，那新来的IO可以直接覆盖到cache块上去。反之如果原来cache块是干净的，那么这个时候要把cache块已经变脏记录到SSD上，于是进入了第213行开始写cache块管理信息。到了这里似乎cache块已经写到缓存中，IO可以返回了，但是到了第215行为什么直接return呢？这里涉及到数据一致性的问题。其实cache块管理结构没有写到缓存中，这个写请求不能算完成。试想如果在这里调用了第222行flashcache_bio_endio把IO返回了，会有什么样的后果？其实大多数情况下是没有什么问题的，但如果在这个时候系统掉电或者宕机了，这时候缓存中记录的cache块状态是干净的，但又已经跟上层返回说IO已经写成功了，那么最后这一次写的数据就丢失了。当然对于大部分用户来说，这一点数据算什么？但对于像银行这样的系统，当你把辛苦了十年的积蓄存到自动取款机，这时自动取款机告诉你存成功了，但不幸的是后台刚好发生了我们上面描述的问题。结果你再查的时候没有你刚才存进去的钱，但你的钱确确实实被取款机收进去了，这时你会有怎样的感受？这里只是举个数据一致性在某些应用中是非常重要的，当然现实中绝大数银行是不会有这样的问题，银行可以有日志查出来，系统也有热备，也是带UPS保护的。

如果原来的cache块为脏的情况就以第222行flashcache_bio_endio结束了。

如果不为脏，那么调用213行将cache块管理结构写到缓存。

272void

273push_md_io(struct kcached_job *job)

274{

275     push(&_md_io_jobs, job);     

276}

这里只是简单放到队列中，具体处理的是第214行唤醒的工作队列。该工作队列对应的处理函数是：

303     process_jobs(&_md_io_jobs, flashcache_md_write);

这个函数怎么这么面熟呢？因为在第一小节里已经介绍过了：

http://blog.csdn.net/liumangxiong/article/details/11681787

这里小结一下写命中并且原cache块为干净的数据流程：

1）写命中调用dm_io_async_bvec写缓存

2）写缓存完成回调函数flashcache_io_callback，判断原cache块为干净，需要写cache块管理结构

3）由工作队列_kcached_wq调用flashcache_md_write写cache块管理结构，最终由flashcache_md_write_kickoff调用dm_io_async_bvec将cache块管理结构写到缓存

4）写缓存完成之后调用flashcache_md_write_callback

5）由工作队列_kcached_wq调用flashcache_md_write_done处理

6）在flashcache_md_write_done中判断job类型为WRITECACHE，最后调用flashcache_bio_endio返回

至此，这个IO才完成使命。

接下来讲第3种情况，这种情况就非常简单了。

1411static void

1412flashcache_write_miss(struct cache_c *dmc, struct bio *bio, int index)

1413{

1414     struct cacheblock *cacheblk;

1415     struct kcached_job *job;

1416     int queued;

1417

1418     cacheblk = &dmc->cache[index];

1419     queued = flashcache_inval_blocks(dmc, bio);

1420     if (queued) {

1421          if (unlikely(queued < 0))

1422               flashcache_bio_endio(bio, -EIO);

1423          spin_unlock_irq(&dmc->cache_spin_lock);

1424          return;

1425     }

1426     if (cacheblk->cache_state & VALID)

1427          dmc->wr_replace++;

1428     else

1429          dmc->cached_blocks++;

1430     cacheblk->cache_state = VALID | CACHEWRITEINPROG;

1431     cacheblk->dbn = bio->bi_sector;

1432     spin_unlock_irq(&dmc->cache_spin_lock);

1433     job = new_kcached_job(dmc, bio, index);

1434     if (unlikely(sysctl_flashcache_error_inject & WRITE_MISS_JOB_ALLOC_FAIL)) {

1435          if (job)

1436               flashcache_free_cache_job(job);

1437          job = NULL;

1438          sysctl_flashcache_error_inject &= ~WRITE_MISS_JOB_ALLOC_FAIL;

1439     }

1440     if (unlikely(job == NULL)) {

1441          /* 

1442          * We have a write miss, and can't allocate a job.

1443          * Since we dropped the spinlock, we have to drain any 

1444          * pending jobs.

1445          */

1446          DMERR("flashcache: Write (miss) failed ! Can't allocate memory for cache IO, block %lu", 

1447                cacheblk->dbn);

1448          flashcache_bio_endio(bio, -EIO);

1449          spin_lock_irq(&dmc->cache_spin_lock);

1450          dmc->cached_blocks--;

1451          cacheblk->cache_state &= ~VALID;

1452          cacheblk->cache_state |= INVALID;

1453          flashcache_free_pending_jobs(dmc, cacheblk, -EIO);

1454          cacheblk->cache_state &= ~(BLOCK_IO_INPROG);

1455          spin_unlock_irq(&dmc->cache_spin_lock);

1456     } else {

1457          job->action = WRITECACHE; 

1458          atomic_inc(&dmc->nr_jobs);

1459          dmc->ssd_writes++;

1460          dm_io_async_bvec(1, &job->cache, WRITE, 

1461                    bio->bi_io_vec + bio->bi_idx,

1462                    flashcache_io_callback, job);

1463          flashcache_unplug_device(dmc->cache_dev->bdev);

1464          flashcache_clean_set(dmc, index / dmc->assoc);

1465     }

1466}

大多数函数都已经是老朋友了。第1430行cache块设置了VALID标志，表示在有效数据，第1431行设置cache块对应的磁盘的bi_sector扇区。接着到第1460行下发写缓存请求，写缓存的情况与写命中的一样就不再继续跟进了。

下一节讲缓存超水位线写回磁盘。