班级信息员的职务描述:MTD系列 - MTD User modules -- Raw block

前言：
 本来最初的目的只是为了研究内核中nand的驱动，但好奇心太强，忍不住往上层追溯，然后再往下层跟踪。这个过程中，
 特别是在block层，yaffs文件系统和用户空间中相关的分析，其实仅仅只是找到了他们之间的关键联系点而已，没有深
 入详细分析。
 
 * linux2.6.29
 * pxa935
 * Hynix NAND 512MB 1.8V 16-bit
 * 李枝果/lizgo 2010-11-8 lizhiguo0532@163.com
 * 由于本人水平有限，望读者阅读时三思，同时也指正我的错误，谢谢！
 
 话说MTD子系统向上层提供了几种在用户空间可以直接使用的接口：Raw char device、Raw block device、FTL、NFTL、
 JFFS(2)。前文中主要讨论的yaffs文件系统没有包含在其中，因为yaffs是直接建立在MTD原始设备层之上的。在nand驱动
 注册的时候，会在probe函数中将nand的每个分区通过mtd块设备层、通用磁盘层、block层向内核注册成一个block设备。
 另外挂载yaffs文件系统的时候呢，就会通过设备节点找到block层中对应的block_device结构体，最后在填充超级块的时候
 直接通过主次设备号在mtd_table[]中找到对应的mtd_info结构体。而且在yaffs文件系统层封装的读写等函数中，也是将
 找到的mtd_info结构体传入，直接利用了mtd_info结构体中的相关读写函数指针来进行底层的读写。
 
 本文主要讨论的接口是Raw block device，也就是传说中的mtdblock，本文中称为mtdblock翻译层，
 主要集中在文件drivers/mtd/mtdblock.c
一、init_mtdblock()
static struct mtd_blktrans_ops mtdblock_tr = {
 .name  = "mtdblock",
 .major  = 31,
 .part_bits = 0,
 .blksize  = 512,
 .open  = mtdblock_open,
 .flush  = mtdblock_flush,
 .release = mtdblock_release,
 .readsect = mtdblock_readsect,
 .writesect = mtdblock_writesect,
 .add_mtd = mtdblock_add_mtd,
 .remove_dev = mtdblock_remove_dev,
 .owner  = THIS_MODULE,
};
static int __init init_mtdblock(void)
{
 return register_mtd_blktrans(&mtdblock_tr);
}
int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
 int ret, i;
 /* Register the notifier if/when the first device type is
    registered, to prevent the link/init ordering from fucking
    us over. */
 // 注册一个该接口的用户通知器，在分区动态添加或删除的时候被调用，
 // 通知使用该接口的用户做出相应动作。
 // 关于这个用户通知器后面再介绍
 if (!blktrans_notifier.list.next)
  register_mtd_user(&blktrans_notifier);
 tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
 if (!tr->blkcore_priv)
  return -ENOMEM;
 mutex_lock(&mtd_table_mutex);
 ret = register_blkdev(tr->major, tr->name); // 块设备注册,major_names
 // 此时可以在proc/devices中看到注册的该设备
 if (ret) {
  printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
         tr->name, tr->major, ret);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return ret;
 }
 spin_lock_init(&tr->blkcore_priv->queue_lock);  // 初始化请求队列锁
 tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
 // 初始化请求队列头和安装请求处理函数mtd_blktrans_request()
 if (!tr->blkcore_priv->rq) {
  unregister_blkdev(tr->major, tr->name);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return -ENOMEM;
 }
 tr->blkcore_priv->rq->queuedata = tr; // 保存该翻译层的操作集  ， &mtdblock_tr
 blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
 if (tr->discard)
  blk_queue_set_discard(tr->blkcore_priv->rq,
          blktrans_discard_request);
 tr->blkshift = ffs(tr->blksize) - 1;
 tr->blkcore_priv->thread = kthread_run(mtd_blktrans_thread, tr,
   "%sd", tr->name);      // 创建内核线程mtd_blktrans_thread
 if (IS_ERR(tr->blkcore_priv->thread)) {
  blk_cleanup_queue(tr->blkcore_priv->rq);
  unregister_blkdev(tr->major, tr->name);
  kfree(tr->blkcore_priv);
  mutex_unlock(&mtd_table_mutex);
  return PTR_ERR(tr->blkcore_priv->thread);
 }
 INIT_LIST_HEAD(&tr->devs);// 该链表用来挂接使用该翻译层的所有设备
 list_add(&tr->list, &blktrans_majors);
 // 所有翻译层通过blktrans_majors链表来链接在一起
 for (i=0; i  if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
   tr->add_mtd(tr, mtd_table[i]);
 }
 // 对mtd_table中的所有分区调用该翻译层操作集中的add_mtd函数
 mutex_unlock(&mtd_table_mutex);
 return 0;
}
 使用函数blk_init_queue初始化一个请求队列和安装一个请求处理函数mtd_blktrans_request():
static void mtd_blktrans_request(struct request_queue *rq)
 {
  struct mtd_blktrans_ops *tr = rq->queuedata;
  wake_up_process(tr->blkcore_priv->thread);  // 唤醒内核线程
 }
 接下来就创建一个内核线程：mtd_blktrans_thread()
static int mtd_blktrans_thread(void *arg)
{
 struct mtd_blktrans_ops *tr = arg;
 struct request_queue *rq = tr->blkcore_priv->rq;
 /* we might get involved when memory gets low, so use PF_MEMALLOC */
 current->flags |= PF_MEMALLOC;
 spin_lock_irq(rq->queue_lock);
 while (!kthread_should_stop()) {
  struct request *req;
  struct mtd_blktrans_dev *dev;
  int res = 0;
  req = elv_next_request(rq);  // 获取对列中第一个未完成的请求
  if (!req) {      // 如果请求为空将线程置于睡眠状态
   set_current_state(TASK_INTERRUPTIBLE);
   spin_unlock_irq(rq->queue_lock);
   schedule();
   spin_lock_irq(rq->queue_lock);
   continue;
  }
 
  /*
  一个请求队列管理着很多请求，但是每一个请求都只能针对一个块设备gendisk。
  所以每一个请求被创建出来后都会指向它的请求对象gendisk。
  这个指向关系在函数__make_request()->init_request_from_bio()->blk_rq_bio_prep()
  -> rq->rq_disk = bio->bi_bdev->bd_disk
  中建立。
  */
 
  dev = req->rq_disk->private_data;
  tr = dev->tr;
  spin_unlock_irq(rq->queue_lock);
  mutex_lock(&dev->lock);
  res = do_blktrans_request(tr, dev, req);
  /*
  在函数do_blktrans_request(tr, dev, req)中
  根据请求的数据传输方向来决定调用读或写函数进行数据传输
  tr->readsect(dev, block, buf)
  tr->writesect(dev, block, buf)
  */
  //如果res是0表示不能成功完成请求，为非0表示成功完成请求
  mutex_unlock(&dev->lock);
  spin_lock_irq(rq->queue_lock);
  end_request(req, res);
 }
 spin_unlock_irq(rq->queue_lock);
 return 0;
}
 
二、用户通知器
结构体定义：
struct mtd_notifier {
 void (*add)(struct mtd_info *mtd);
 void (*remove)(struct mtd_info *mtd);
 struct list_head list;
};
有两个方法和一个链表挂钩，参数均为mtd_info指针。
在drivers/mtd/mtd_blkdevs.c中定义了下面的块翻译层通知器
static struct mtd_notifier blktrans_notifier = {
 .add = blktrans_notify_add,
 .remove = blktrans_notify_remove,
};
该通知器被FTL、NFTL、mtdblock翻译层使用。
int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
...
/* Register the notifier if/when the first device type is
  registered, to prevent the link/init ordering from fucking
  us over. */
if (!blktrans_notifier.list.next)
  register_mtd_user(&blktrans_notifier); // 只有第一个翻译层注册的时候该函数才会调用
...
}
void register_mtd_user (struct mtd_notifier *new)
{
 int i;
 mutex_lock(&mtd_table_mutex);
 list_add(&new->list, &mtd_notifiers);
 // 将这个新的用户通知器添加到全局链表mtd_notifiers中(该链表中还可能存在其他用户通知器)
  __module_get(THIS_MODULE);// 增加模块引用计数
 for (i=0; i< MAX_MTD_DEVICES; i++)
  if (mtd_table[i])
   new->add(mtd_table[i]);
   // 对mtd_table中的所有分区调用该翻译层操作集中的add_mtd函数，第一次注册该工作在后面会重复再做一次
   // blktrans_notify_add()
 mutex_unlock(&mtd_table_mutex);
}
static void blktrans_notify_add(struct mtd_info *mtd)
{
 struct mtd_blktrans_ops *tr;
 if (mtd->type == MTD_ABSENT)
  return;
 list_for_each_entry(tr, &blktrans_majors, list)
  tr->add_mtd(tr, mtd);
  // blktrans_majors链表管理着所有的翻译层操作集结构体
  // 该处的意思是对于传入的同一个mtd_info结构体，所有的翻译层都会调用自己的
  // add_mtd函数(这些函数都不一样，对于mtdblock层该函数是mtdblock_add_mtd())
}
在系统启动的时候，register_mtd_blktrans(&mtdblock_tr)执行的时候，mtd_table数组中是空的，所以就不会执行到翻译层
的add_mtd函数上来，那么在又在什么时候调用了翻译层的add_mtd()函数了呢？请看下面
三、将分区向上层注册成block device。
 // pxa3xx_nand.c
 在注册nand驱动的时候：
 pxa3xx_nand_init()
 --> platform_driver_register()
   --> ...经过注册和设备匹配后调用probe()函数
     --> pxa3xx_nand_probe()
       --> ...
       --> add_mtd_partitions(monahans_mtd, pdata->parts, pdata->nr_parts)
         --> add_one_partition()
           --> add_mtd_device()
             --> list_for_each_entry(not, &mtd_notifiers, list)
                 not->add(mtd);
               // 这里就是调用mtd_notifiers链表中所有用户通知器的add函数，以mtdblock的用户通知
               // 器为例，那么就是调用函数 mtdblock_add_mtd()。这就是证实了当添加一个分区的时候
               // 用户通知器的add函数被调用，那么当移除分区的时候，remove函数就会被调用，只是
               // 我们这里没有移除的分区动作。
代码如下：
static int pxa3xx_nand_probe(struct platform_device *pdev)
{
 ...
 return add_mtd_partitions(monahans_mtd, pdata->parts, pdata->nr_parts);
 ...
}
int add_mtd_partitions(struct mtd_info *master,
         const struct mtd_partition *parts,
         int nbparts)
{
 struct mtd_part *slave;
 uint64_t cur_offset = 0;
 int i;
 printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
 for (i = 0; i < nbparts; i++) {
  slave = add_one_partition(master, parts + i, i, cur_offset);
  if (!slave)
   return -ENOMEM;
  cur_offset = slave->offset + slave->mtd.size;
 }
 return 0;
}
static struct mtd_part *add_one_partition(struct mtd_info *master,
  const struct mtd_partition *part, int partno,
  uint64_t cur_offset)
{
 struct mtd_part *slave;
 /* allocate the partition structure */
 slave = kzalloc(sizeof(*slave), GFP_KERNEL);
 if (!slave) {
  printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n",
   master->name);
  del_mtd_partitions(master);
  return NULL;
 }
 list_add(&slave->list, &mtd_partitions);
 // mtd_partitions 用于在MTD原始设备层统一管理所有分区信息
 // static LIST_HEAD(mtd_partitions) 本文件中定义
 /* set up the MTD object for this partition */
 slave->mtd.type = master->type;
 slave->mtd.flags = master->flags & ~part->mask_flags;
 slave->mtd.size = part->size;  // 分区大小
 slave->mtd.writesize = master->writesize;
 slave->mtd.oobsize = master->oobsize;
 slave->mtd.oobavail = master->oobavail;
 slave->mtd.subpage_sft = master->subpage_sft;
 slave->mtd.name = part->name;  // 分区名字
 slave->mtd.owner = master->owner;
 slave->mtd.read = part_read;  // 分区读写函数
 slave->mtd.write = part_write;
 if (master->panic_write)
  slave->mtd.panic_write = part_panic_write;
 if (master->point && master->unpoint) {
  slave->mtd.point = part_point;
  slave->mtd.unpoint = part_unpoint;
 }
 if (master->read_oob)
  slave->mtd.read_oob = part_read_oob;
 if (master->write_oob)
  slave->mtd.write_oob = part_write_oob;
 if (master->read_user_prot_reg)
  slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
 if (master->read_fact_prot_reg)
  slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
 if (master->write_user_prot_reg)
  slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
 if (master->lock_user_prot_reg)
  slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
 if (master->get_user_prot_info)
  slave->mtd.get_user_prot_info = part_get_user_prot_info;
 if (master->get_fact_prot_info)
  slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
 if (master->sync)
  slave->mtd.sync = part_sync;
 if (!partno && master->suspend && master->resume) {
   slave->mtd.suspend = part_suspend;
   slave->mtd.resume = part_resume;
 }
 if (master->writev)
  slave->mtd.writev = part_writev;
 if (master->lock)
  slave->mtd.lock = part_lock;
 if (master->unlock)
  slave->mtd.unlock = part_unlock;
 if (master->block_isbad)
  slave->mtd.block_isbad = part_block_isbad;
 if (master->block_markbad)
  slave->mtd.block_markbad = part_block_markbad;
 slave->mtd.erase = part_erase;
 slave->master = master;   // 该分区的主分区
 slave->offset = part->offset; // 该分区偏移
 slave->index = partno;   // 分区索引
 if (slave->offset == MTDPART_OFS_APPEND)
  slave->offset = cur_offset;
 if (slave->offset == MTDPART_OFS_NXTBLK) {
  slave->offset = cur_offset;
  if (mtd_mod_by_eb(cur_offset, master) != 0) {
   /* Round up to next erasesize */
   slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
   printk(KERN_NOTICE "Moving partition %d: "
          "0x%012llx -> 0x%012llx\n", partno,
          (unsigned long long)cur_offset, (unsigned long long)slave->offset);
  }
 }
 if (slave->mtd.size == MTDPART_SIZ_FULL)
  slave->mtd.size = master->size - slave->offset;
 printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset,
  (unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name);
 // 打印分区表信息
 /* let's do some sanity checks */
 if (slave->offset >= master->size) {
  /* let's register it anyway to preserve ordering */
  slave->offset = 0;
  slave->mtd.size = 0;
  printk(KERN_ERR"mtd: partition \"%s\" is out of reach -- disabled\n",
   part->name);
  goto out_register;
 }
 if (slave->offset + slave->mtd.size > master->size) {
  slave->mtd.size = master->size - slave->offset;
  printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n",
   part->name, master->name, (unsigned long long)slave->mtd.size);
 }
 if (master->numeraseregions > 1) {
  /* Deal with variable erase size stuff */
  int i, max = master->numeraseregions;
  u64 end = slave->offset + slave->mtd.size;
  struct mtd_erase_region_info *regions = master->eraseregions;
  /* Find the first erase regions which is part of this
   * partition. */
  for (i = 0; i < max && regions[i].offset <= slave->offset; i++)
   ;
  /* The loop searched for the region _behind_ the first one */
  i--;
  /* Pick biggest erasesize */
  for (; i < max && regions[i].offset < end; i++) {
   if (slave->mtd.erasesize < regions[i].erasesize) {
    slave->mtd.erasesize = regions[i].erasesize;
   }
  }
  BUG_ON(slave->mtd.erasesize == 0);
 } else {
  /* Single erase size */
  slave->mtd.erasesize = master->erasesize;  // 分区擦除大小赋值
 }
 if ((slave->mtd.flags & MTD_WRITEABLE) &&
     mtd_mod_by_eb(slave->offset, &slave->mtd)) {
  /* Doesn't start on a boundary of major erase size */
  /* FIXME: Let it be writable if it is on a boundary of
   * _minor_ erase size though */
  slave->mtd.flags &= ~MTD_WRITEABLE;
  printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
   part->name);
 }
 if ((slave->mtd.flags & MTD_WRITEABLE) &&
     mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
  slave->mtd.flags &= ~MTD_WRITEABLE;
  printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
   part->name);
 }
 slave->mtd.ecclayout = master->ecclayout;
 if (master->block_isbad) {
  uint64_t offs = 0;
  while (offs < slave->mtd.size) {
   if (master->block_isbad(master,
      offs + slave->offset))
    slave->mtd.ecc_stats.badblocks++; // 分区内坏块检查统计
   offs += slave->mtd.erasesize;
  }
 }
out_register:
 if (part->mtdp) {
  /* store the object pointer (caller may or may not register it*/
  *part->mtdp = &slave->mtd;
  slave->registered = 0;
 } else {
  /* register our partition */
  add_mtd_device(&slave->mtd);      // importment
  // 将该从分区作为MTD原始设备加入到mtd_table中，成功返回0
  // MTD原始设备层和MTD设备层就是依靠mtd_table来联系的
  slave->registered = 1;
 }
 return slave;
}
int add_mtd_device(struct mtd_info *mtd)
{
 int i;
 BUG_ON(mtd->writesize == 0);
 mutex_lock(&mtd_table_mutex);
 for (i=0; i < MAX_MTD_DEVICES; i++)
  if (!mtd_table[i]) {
   struct mtd_notifier *not;
   mtd_table[i] = mtd;   // 填充mtd_table[]数组，mtd原始设备层和mtd块设备层通过mtd_table[]联系在了一起
   mtd->index = i;     // mtd_table[]数组的下标赋给mtd->index
   mtd->usecount = 0;
   if (is_power_of_2(mtd->erasesize))
    mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
   else
    mtd->erasesize_shift = 0;
   if (is_power_of_2(mtd->writesize))
    mtd->writesize_shift = ffs(mtd->writesize) - 1;
   else
    mtd->writesize_shift = 0;
   mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
   mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
   /* Some chips always power up locked. Unlock them now */
   if ((mtd->flags & MTD_WRITEABLE)
       && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
    if (mtd->unlock(mtd, 0, mtd->size))
     printk(KERN_WARNING
            "%s: unlock failed, "
            "writes may not work\n",
            mtd->name);
   }
   DEBUG(0, "mtd: Giving out device %d to %s\n",i, mtd->name);
   /* No need to get a refcount on the module containing
      the notifier, since we hold the mtd_table_mutex */
   list_for_each_entry(not, &mtd_notifiers, list)
     not->add(mtd);        // 只要底层向上层添加一个mtd原始设备的话，那么就会遍历所有用户通知器
                    // 然后调用其add函数，再向mtd块设备层的上层通用磁盘层和block层注册。
                    // 对于mtdblock翻译层，其add_mtd函数指针指向mtdblock_add_mtd()
   mutex_unlock(&mtd_table_mutex);
   /* We _know_ we aren't being removed, because
      our caller is still holding us here. So none
      of this try_ nonsense, and no bitching about it
      either. :) */
   __module_get(THIS_MODULE);
   return 0;
  }
 mutex_unlock(&mtd_table_mutex);
 return 1;
}
//////////////////////////////////////////////////////////////////////////////////////////////
struct mtd_blktrans_dev {
 struct mtd_blktrans_ops *tr;
 struct list_head list;
 struct mtd_info *mtd;
 struct mutex lock;
 int devnum;
 unsigned long size;
 int readonly;
 void *blkcore_priv; /* gendisk in 2.5, devfs_handle in 2.4 */
};
static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
{
 struct mtd_blktrans_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 if (!dev)
  return;
 // 这里将分区作为的MTD设备联系在了一起，mtd_table
 dev->mtd = mtd;
 dev->devnum = mtd->index; // 分区表的索引值
 dev->size = mtd->size >> 9; // 该分区的大小以512为单位来计算
 dev->tr = tr;    // 操作集
 if (!(mtd->flags & MTD_WRITEABLE))
  dev->readonly = 1;
 add_mtd_blktrans_dev(dev);
 // 后面详解
}
int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
{
 struct mtd_blktrans_ops *tr = new->tr;
 struct mtd_blktrans_dev *d;
 int last_devnum = -1;
 struct gendisk *gd;
 if (mutex_trylock(&mtd_table_mutex)) {
  mutex_unlock(&mtd_table_mutex);
  BUG();
 }
 list_for_each_entry(d, &tr->devs, list) {
  if (new->devnum == -1) {
   /* Use first free number */
   if (d->devnum != last_devnum+1) {
    /* Found a free devnum. Plug it in here */
    new->devnum = last_devnum+1;
    list_add_tail(&new->list, &d->list);
    goto added;
   }
  } else if (d->devnum == new->devnum) {
   /* Required number taken */
   return -EBUSY;
   // 这里返回上层没有错误判断，因此也就没有释放掉上层函数开辟的struct mtd_blktrans_dev
   // 的内存空间，存在内存泄露，这里应该算是一个内核bug吧，不过呢，这个bug基本上是不会出现的
   // 如果你的分区不会动态被增加或者删除的话，这里就不会返回这个错误的
  } else if (d->devnum > new->devnum) {
   /* Required number was free */
   list_add_tail(&new->list, &d->list);
   goto added;
  }
  last_devnum = d->devnum;
 }
 if (new->devnum == -1)
  new->devnum = last_devnum+1;
 if ((new->devnum << tr->part_bits) > 256) {
  return -EBUSY;
 }
 list_add_tail(&new->list, &tr->devs);
 // 翻译层操作集管理者所有属于该层的设备
 added:
 mutex_init(&new->lock);
 if (!tr->writesect)
  new->readonly = 1;
 gd = alloc_disk(1 << tr->part_bits);        // note 1
 // 分配gendisk结构体空间，并做一些初始的设置
 if (!gd) {
  list_del(&new->list);
  return -ENOMEM;
 }
 gd->major = tr->major;               // mtdblock  , 31
 gd->first_minor = (new->devnum) << tr->part_bits;  // mtd_table[]下标
 gd->fops = &mtd_blktrans_ops;            // 操作函数集
 if (tr->part_bits)  // 0
  if (new->devnum < 26)
   snprintf(gd->disk_name, sizeof(gd->disk_name),
     "%s%c", tr->name, 'a' + new->devnum);
  else
   snprintf(gd->disk_name, sizeof(gd->disk_name),
     "%s%c%c", tr->name,
     'a' - 1 + new->devnum / 26,
     'a' + new->devnum % 26);
 else
  snprintf(gd->disk_name, sizeof(gd->disk_name),
    "%s%d", tr->name, new->devnum);
                           // gd->disk_name = mtdblock{0 - 31}
 /* 2.5 has capacity in units of 512 bytes while still
    having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
 set_capacity(gd, (new->size * tr->blksize) >> 9);
 gd->private_data = new;
 new->blkcore_priv = gd;  // 互相指向对方
 gd->queue = tr->blkcore_priv->rq; // 该mtd设备的请求队列
 if (new->readonly)
  set_disk_ro(gd, 1);
 add_disk(gd);  // 向上层添加一个gendisk note2
 return 0;
}
/** note1 gd = alloc_disk(1) **/
struct gendisk *alloc_disk(int minors)
{
 return alloc_disk_node(minors, -1);  // note1-1
}
/**** note1-1  alloc_disk_node(1, -1) ****/
struct gendisk *alloc_disk_node(int minors, int node_id)
{
 struct gendisk *disk;
 disk = kmalloc_node(sizeof(struct gendisk),
    GFP_KERNEL | __GFP_ZERO, node_id);   // node_id就是NUMA系统中的节点号
 if (disk) {
  if (!init_part_stats(&disk->part0)) {
   kfree(disk);
   return NULL;
  }
  disk->node_id = node_id;          // -1
  if (disk_expand_part_tbl(disk, 0)) {
   free_part_stats(&disk->part0);
   kfree(disk);
   return NULL;
  }
  disk->part_tbl->part[0] = &disk->part0;
  disk->minors = minors;           // 1
  rand_initialize_disk(disk);
  disk_to_dev(disk)->class = &block_class;  // #define disk_to_dev(disk) (&(disk)->part0.__dev)
  disk_to_dev(disk)->type = &disk_type;
  device_initialize(disk_to_dev(disk));
  INIT_WORK(&disk->async_notify,
   media_change_notify_thread);
 }
 return disk;
}
/**** note1-1  alloc_disk_node(1, -1) ****/
/** note1 gd = alloc_disk(1) **/
/** note2 add_disk(gd) **/
void add_disk(struct gendisk *disk)
{
 struct backing_dev_info *bdi;
 dev_t devt;
 int retval;
 /* minors == 0 indicates to use ext devt from part0 and should
  * be accompanied with EXT_DEVT flag.  Make sure all
  * parameters make sense.
  */
 WARN_ON(disk->minors && !(disk->major || disk->first_minor));
 WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
 disk->flags |= GENHD_FL_UP;
 retval = blk_alloc_devt(&disk->part0, &devt);   // note2-1
 if (retval) {
  WARN_ON(1);
  return;
 }
 disk_to_dev(disk)->devt = devt;  // disk->part0.__dev->devt = devt
 // 主次设备号
 /* ->major and ->first_minor aren't supposed to be
  * dereferenced from here on, but set them just in case.
  */
 disk->major = MAJOR(devt);    // 31
 disk->first_minor = MINOR(devt); // {0 - 31}
 blk_register_region(disk_devt(disk), disk->minors, NULL,
       exact_match, exact_lock, disk);
 register_disk(disk);       // note2-2
 blk_register_queue(disk);
 bdi = &disk->queue->backing_dev_info;
 bdi_register_dev(bdi, disk_devt(disk));
 retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
       "bdi");
 WARN_ON(retval);
}
/**** note2-1  blk_alloc_devt() ****/
int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
{
 struct gendisk *disk = part_to_disk(part);
 int idx, rc;
 
// part->partno = 0, disk->minors = 1, disk->major = 31, disk->first_minor = {0 - 31}
 /* in consecutive minor range? */
 if (part->partno < disk->minors) {
  *devt = MKDEV(disk->major, disk->first_minor + part->partno);  // 最后组织的主次设备号为31<<20 | {0 ~ 31}
  return 0;
 }
 /* allocate ext devt */      // 另外的方式来分配主次设备号
 do {
  if (!idr_pre_get(&ext_devt_idr, GFP_KERNEL))
   return -ENOMEM;
  rc = idr_get_new(&ext_devt_idr, part, &idx);
 } while (rc == -EAGAIN);
 if (rc)
  return rc;
 if (idx > MAX_EXT_DEVT) {
  idr_remove(&ext_devt_idr, idx);
  return -EBUSY;
 }
 *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
 return 0;
}
/**** note2-1  blk_alloc_devt() ****/
/**** note2-2  register_disk(disk) ****/
void register_disk(struct gendisk *disk)
{
 struct device *ddev = disk_to_dev(disk);
 struct block_device *bdev;
 struct disk_part_iter piter;
 struct hd_struct *part;
 int err;
 ddev->parent = disk->driverfs_dev;
 dev_set_name(ddev, disk->disk_name);    // mtdblock{0 - 31}
 /* delay uevents, until we scanned partition table */
 ddev->uevent_suppress = 1;
 if (device_add(ddev))            // 将该设备添加到系统设备树中
  return;
#ifndef CONFIG_SYSFS_DEPRECATED
 err = sysfs_create_link(block_depr, &ddev->kobj,
    kobject_name(&ddev->kobj));
 if (err) {
  device_del(ddev);
  return;
 }
#endif
 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
 /* No minors to use for partitions */
 if (!disk_partitionable(disk))
  goto exit;
 /* No such device (e.g., media were just removed) */
 if (!get_capacity(disk))
  goto exit;
 bdev = bdget_disk(disk, 0);   // note2-2-1
 if (!bdev)
  goto exit;
 bdev->bd_invalidated = 1;
 err = blkdev_get(bdev, FMODE_READ); // 获取一次以验证
 if (err < 0)
  goto exit;
 blkdev_put(bdev, FMODE_READ);
exit:
 /* announce disk after possible partitions are created */
 ddev->uevent_suppress = 0;
 kobject_uevent(&ddev->kobj, KOBJ_ADD);
 /* announce possible partitions */
 disk_part_iter_init(&piter, disk, 0);
 while ((part = disk_part_iter_next(&piter)))
  kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
 disk_part_iter_exit(&piter);
}
/****** note2-2-1  bdev = bdget_disk(disk, 0) ******/
struct block_device *bdget_disk(struct gendisk *disk, int partno)
{
 struct hd_struct *part;
 struct block_device *bdev = NULL;
 part = disk_get_part(disk, partno);
 if (part)
  bdev = bdget(part_devt(part));  // note 2-2-1-1
  // 根据主次设备号得到block_device结构体
 disk_put_part(part);
 return bdev;
}
/******** note2-2-1-1  bdev = bdget(part_devt(part)) ********/
// fs/block_dev.c
struct bdev_inode {
 struct block_device bdev;
 struct inode vfs_inode;
};
static inline struct bdev_inode *BDEV_I(struct inode *inode)
{
 return container_of(inode, struct bdev_inode, vfs_inode);
}
inline struct block_device *I_BDEV(struct inode *inode)
{
 return &BDEV_I(inode)->bdev;
}
static inline unsigned long hash(dev_t dev)
{
 return MAJOR(dev)+MINOR(dev);
}
static int bdev_test(struct inode *inode, void *data)
{
 return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
}
static int bdev_set(struct inode *inode, void *data)
{
 BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
 return 0;
}
static LIST_HEAD(all_bdevs);
struct block_device *bdget(dev_t dev)
{
 struct block_device *bdev;
 struct inode *inode;
 inode = iget5_locked(blockdev_superblock, hash(dev),
   bdev_test, bdev_set, &dev);
 // 该函数最终会调用函数bdev_set()将dev的值赋值给BDEV_I(inode)->bdev.bd_dev
 if (!inode)
  return NULL;
 bdev = &BDEV_I(inode)->bdev;
 if (inode->i_state & I_NEW) {
  bdev->bd_contains = NULL;
  bdev->bd_inode = inode;  // inode关联到block_device结构体中
  bdev->bd_block_size = (1 << inode->i_blkbits);
  bdev->bd_part_count = 0;
  bdev->bd_invalidated = 0;
  inode->i_mode = S_IFBLK; // 对应的是块设备节点
  inode->i_rdev = dev;   // 主次设备号关联
  inode->i_bdev = bdev;   // block_device结构体关联
 
  /************************
  在使用mount挂载该设备上的文件系统时，例如上一篇文章中为了挂载nand分区中的yaffs2文件系统，那么系统是在哪个
  地方使用了注册时设置的这些信息呢？
  ...
  get_sb_bdev()
  --> open_bdev_exclusive()
    --> lookup_bdev()
      --> kern_path()
      --> bdev = bd_acquire(inode)
        这里只是取出了block_device结构体的指针
  而对于上面函数iget5_locked()-->bdev_set()中设置在对应block_device结构体中的主次设备号在文件系统挂载的时候
  ，在下面这个函数中获取到后存放在超级块中。
  ...
  get_sb_bdev()
  --> open_bdev_exclusive()
  --> sget()
    --> set_bdev_super()
      --> s->s_bdev = data;        // 就是open_bdev_exclusive()函数获得的block_device结构体
      --> s->s_dev = s->s_bdev->bd_dev;  // 主次设备号
 
  最后在yaffs2文件系统超级块填充函数yaffs_internal_read_super()中是这么使用的：
  ...
  if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
   return NULL; /* This isn't an mtd device */
  ...
  mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); // 取得对应的mtd_info结构体
  ...
  ************************/
 
  inode->i_data.a_ops = &def_blk_aops;
  mapping_set_gfp_mask(&inode->i_data, GFP_USER);
  inode->i_data.backing_dev_info = &default_backing_dev_info;
  spin_lock(&bdev_lock);
  list_add(&bdev->bd_list, &all_bdevs);
  spin_unlock(&bdev_lock);
  unlock_new_inode(inode);
 }
 return bdev;        // 返回这个block_device指针
}
/******** note2-2-1-1  bdev = bdget(part_devt(part)) ********/
/****** note2-2-1  bdev = bdget_disk(disk, 0) ******/
/**** note2-2  register_disk(disk) ****/
/** note2 add_disk(gd) **/
四、一点补充
static struct mtdblk_dev {
 struct mtd_info *mtd;
 int count;
 struct mutex cache_mutex;
 unsigned char *cache_data;
 unsigned long cache_offset;
 unsigned int cache_size;
 enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;
} *mtdblks[MAX_MTD_DEVICES];  // #define MAX_MTD_DEVICES 32
/*
** 这里是定义了一个指针数组，其中的每一个指针均指向一个struct mtdblk_dev
** 的类型的对象，每一个struct mtdblk_dev类型的对象都是一个MTD块设备，
** 这里的每一个指针指向的MTD块设备和mtd_table[]中元素指向的每一个
** struct mtd_info一一对应。
** 另外，可以看出linux最多支持32个MTD块设备
 
 关于mtdblks[]指针数组，我这里是以yaffs文件系统为例，所以是不会使用到这个指针数组的，应为yaffs它是建立在mtd原始设备层上，在其封装的函数内直接使用了mtd_info结构体内的函数，而没有经过mtdblock翻译层。如果我们的系统中使用的是mtd的其他接口，比如block device，那么就会使用到这个指针数组，在哪里使用呢？
 mtdblock.c文件中定义了mtdblock翻译层的操作集：
static struct mtd_blktrans_ops mtdblock_tr = {
 .name  = "mtdblock",
 .major  = 31,
 .part_bits = 0,
 .blksize  = 512,
 .open  = mtdblock_open,
 .flush  = mtdblock_flush,
 .release = mtdblock_release,
 .readsect = mtdblock_readsect,
 .writesect = mtdblock_writesect,
 .add_mtd = mtdblock_add_mtd,
 .remove_dev = mtdblock_remove_dev,
 .owner  = THIS_MODULE,
};
这些mtdblks[]的指针在哪里赋值的呢？请看函数mtdblock_open()中：
static int mtdblock_open(struct mtd_blktrans_dev *mbd)
{
 // mtd_blktrans_dev这个设备就是我们在初始化经过mtdblock翻译层向上层注册时的产物，表示了本层环境中的mtd设备
 // mbd->mtd在mtdblock_add_mtd()函数中被赋值，就是对应的mtd原始设备
 struct mtdblk_dev *mtdblk;
 struct mtd_info *mtd = mbd->mtd;
 int dev = mbd->devnum;
 DEBUG(MTD_DEBUG_LEVEL1,"mtdblock_open\n");
 if (mtdblks[dev]) {
  mtdblks[dev]->count++;
  return 0;
 } // 如果已经打开了，那么只需要增加引用计数
 /* OK, it's not open. Create cache info for it */
 mtdblk = kzalloc(sizeof(struct mtdblk_dev), GFP_KERNEL); // 否则，分配空间
 if (!mtdblk)
  return -ENOMEM;
 mtdblk->count = 1;  // 引用计数初始化成1
 mtdblk->mtd = mtd;  // 重要的联系
 mutex_init(&mtdblk->cache_mutex);
 mtdblk->cache_state = STATE_EMPTY;
 if ( !(mtdblk->mtd->flags & MTD_NO_ERASE) && mtdblk->mtd->erasesize) {
  mtdblk->cache_size = mtdblk->mtd->erasesize;
  mtdblk->cache_data = NULL;
 }
 mtdblks[dev] = mtdblk; // mtdblks指针数组中相应位置设置
 DEBUG(MTD_DEBUG_LEVEL1, "ok\n");
 return 0;
}