add_partition 函数学习

    add_partition，是添加磁盘分区信息的函数，负责向通用磁盘数据结构添加一个新的分区：

    通用磁盘数据结构如下：

1. struct gendisk {
   
2.     int major;            /* major number of driver */
   
3.     int first_minor;
   
4.     int minors; /* maximum number of minors, =1 for
   
5.                                          * disks that can't be partitioned. */
   
6.     char disk_name[32];        /* name of major driver */
   
7.     struct hd_struct **part;    /* [indexed by minor] */
   
8.     struct block_device_operations *fops;
   
9.     struct request_queue *queue;
   
10.     void *private_data;
    
11.     sector_t capacity;
    
12. 
    
13.     int flags;
    
14.     struct device *driverfs_dev; // FIXME: remove
    
15.     struct device dev;
    
16.     struct kobject *holder_dir;
    
17.     struct kobject *slave_dir;
    
18. 
    
19.     struct timer_rand_state *random;
    
20.     int policy;
    
21. 
    
22.     atomic_t sync_io;        /* RAID */
    
23.     unsigned long stamp;
    
24.     int in_flight;
    
25. #ifdef    CONFIG_SMP
    
26.     struct disk_stats *dkstats;
    
27. #else
    
28.     struct disk_stats dkstats;
    
29. #endif
    
30.     struct work_struct async_notify;
    
31. };
    
32. vents *ev;
    
33. #ifdef CONFIG_BLK_DEV_INTEGRITY
    
34.     struct blk_integrity *integrity;
    
35. #endif
    
36.     int node_id;
    
37. };

    蓝色的struct hd_struct类型 指向分区相关的数据区。看下下面的函数，

    首先是分配一个hd_struct类型的变量作为分区的结构：disk的第part个分区指针指向该结构。

1. p = kzalloc(sizeof(*p), GFP_KERNEL);

1. disk->part[part-1] = p;

    然后是将分区的起始扇区赋值为入参start，扇区个数赋值为入参len，partno赋值为入参part。SCSI磁盘的分区个数最多为15个。

1. void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)
   
2. {
   
3.     struct hd_struct *p;
   
4.     int err;
   
5. 
   
6.     p = kzalloc(sizeof(*p), GFP_KERNEL);
   
7.     if (!p)
   
8.         return;
   
9. 
   
10.     if (!init_part_stats(p)) {
    
11.         kfree(p);
    
12.         return;
    
13.     }
    
14.     p->start_sect = start;
    
15.     p->nr_sects = len;
    
16.     p->partno = part;
    
17.     p->policy = disk->policy;
    
18. 
    
19.     if (isdigit(disk->dev.bus_id[strlen(disk->dev.bus_id)-1]))
    
20.         snprintf(p->dev.bus_id, BUS_ID_SIZE,
    
21.         "%sp%d", disk->dev.bus_id, part);
    
22.     else
    
23.         snprintf(p->dev.bus_id, BUS_ID_SIZE,
    
24.              "%s%d", disk->dev.bus_id, part);
    
25. 
    
26.     device_initialize(&p->dev);
    
27.     p->dev.devt = MKDEV(disk->major, disk->first_minor + part);
    
28.     p->dev.class = &block_class;
    
29.     p->dev.type = &part_type;
    
30.     p->dev.parent = &disk->dev;
    
31.     disk->part[part-1] = p;
    
32. 
    
33.     /* delay uevent until 'holders' subdir is created */
    
34.     p->dev.uevent_suppress = 1;
    
35.     device_add(&p->dev);
    
36.     partition_sysfs_add_subdir(p);
    
37.     p->dev.uevent_suppress = 0;
    
38.     if (flags & ADDPART_FLAG_WHOLEDISK)
    
39.         err = device_create_file(&p->dev, &dev_attr_whole_disk);
    
40. 
    
41.     /* suppress uevent if the disk supresses it */
    
42.     if (!disk->dev.uevent_suppress)
    
43.         kobject_uevent(&p->dev.kobj, KOBJ_ADD);
    
44. }

    接下来的问题是，每个磁盘有几个分区，每个分区的起始扇区是多少，每个分区的扇区个数是多少是怎么来的。

    我们先看下rescan_partitions 中添加分区的流程

1. struct parsed_partitions *state;

 ...

1. for (p = 1; p < state->limit; p++) {
   
2.         sector_t size = state->parts[p].size;
   
3.         sector_t from = state->parts[p].from;
   
4.         if (!size)
   
5.             continue;
   
6.         if (from + size > get_capacity(disk)) {
   
7.             printk(" %s: p%d exceeds device capacity\n",
   
8.                 disk->disk_name, p);
   
9.         }
   
10.         add_partition(disk, p, from, size, state->parts[p].flags);
    
11. #ifdef CONFIG_BLK_DEV_MD
    
12.         if (state->parts[p].flags & ADDPART_FLAG_RAID)
    
13.             md_autodetect_dev(bdev->bd_dev+p);
    
14. #endif
    
15.     }

    我们看到，add_partition的入参比如分区起始扇区，分区扇区的个数等都是从struct parsed_partitions *state 获取到的，那么state指向的数据是从哪里来的呢，这个问题浮出水面，就到了检测分区的函数check_partition闪亮登场的时刻了。

1. static struct parsed_partitions *
   
2. check_partition(struct gendisk *hd, struct block_device *bdev)
   
3. {
   
4.     struct parsed_partitions *state;
   
5.     int i, res, err;
   
6. 
   
7.     state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
   
8.     if (!state)
   
9.         return NULL;
   
10.     state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
    
11.     if (!state->pp_buf) {
    
12.         kfree(state);
    
13.         return NULL;
    
14.     }
    
15.     state->pp_buf[0] = '\0';
    
16. 
    
17.     state->bdev = bdev;
    
18.     disk_name(hd, 0, state->name);
    
19.     snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
    
20.     if (isdigit(state->name[strlen(state->name)-1]))
    
21.         sprintf(state->name, "p");
    
22. 
    
23.     state->limit = disk_max_parts(hd);
    
24.     i = res = err = 0;
    
25.     while (!res && check_part[i]) {
    
26.         memset(&state->parts, 0, sizeof(state->parts));
    
27.         res = check_part[i++](state);
    
28.         if (res < 0) {
    
29.             /* We have hit an I/O error which we don't report now.
    
30.              * But record it, and let the others do their job.
    
31.              */
    
32.             err = res;
    
33.             res = 0;
    
34.         }
    
35. 
    
36.     }
    
37.     if (res > 0) {
    
38.         printk(KERN_INFO "%s", state->pp_buf);
    
39. 
    
40.         free_page((unsigned long)state->pp_buf);
    
41.         return state;
    
42.     }
    
43.     if (state->access_beyond_eod)
    
44.         err = -ENOSPC;
    
45.     if (err)
    
46.     /* The partition is unrecognized. So report I/O errors if there were any */
    
47.         res = err;
    
48.     if (!res)
    
49.         strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
    
50.     else if (warn_no_part)
    
51.         strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);
    
52. 
    
53.     printk(KERN_INFO "%s", state->pp_buf);
    
54. 
    
55.     free_page((unsigned long)state->pp_buf);
    
56.     kfree(state);
    
57.     return ERR_PTR(res);
    
58. }

    很吓人是不？原理起始很简单，最关键语句是绿色的那一句。我们知道有很多种类型的磁盘，不可能存在一个处理函数，能够解析出所有磁盘分区信息。那怎么办呢。神农 尝百草，一个一个的实验。我们有个函数数组 check_part，每种函数解析一种磁盘分区信息。那个函数能成功的解析磁盘分区信息，就不需要继续尝试了，可以打完收工了。当然解析出来的数据 存放在struct parsed_partitions 类型的结构体state中。

    那么神农尝百草，那么一共有多少种草呢？

    看下函数数组的定义：

1. static int (*check_part[])(struct parsed_partitions *, struct block_device *) = {
   
2.     /*
   
3.      * Probe partition formats with tables at disk address 0
   
4.      * that also have an ADFS boot block at 0xdc0.
   
5.      */
   
6. #ifdef CONFIG_ACORN_PARTITION_ICS
   
7.     adfspart_check_ICS,
   
8. #endif
   
9. #ifdef CONFIG_ACORN_PARTITION_POWERTEC
   
10.     adfspart_check_POWERTEC,
    
11. #endif
    
12. #ifdef CONFIG_ACORN_PARTITION_EESOX
    
13.     adfspart_check_EESOX,
    
14. #endif
    
15. 
    
16.     /*
    
17.      * Now move on to formats that only have partition info at
    
18.      * disk address 0xdc0. Since these may also have stale
    
19.      * PC/BIOS partition tables, they need to come before
    
20.      * the msdos entry.
    
21.      */
    
22. #ifdef CONFIG_ACORN_PARTITION_CUMANA
    
23.     adfspart_check_CUMANA,
    
24. #endif
    
25. #ifdef CONFIG_ACORN_PARTITION_ADFS
    
26.     adfspart_check_ADFS,
    
27. #endif
    
28. 
    
29. #ifdef CONFIG_EFI_PARTITION
    
30.     efi_partition,        /* this must come before msdos */
    
31. #endif
    
32. #ifdef CONFIG_SGI_PARTITION
    
33.     sgi_partition,
    
34. #endif
    
35. #ifdef CONFIG_LDM_PARTITION
    
36.     ldm_partition,        /* this must come before msdos */
    
37. #endif
    
38. #ifdef CONFIG_MSDOS_PARTITION
    
39.     msdos_partition,
    
40. #endif
    
41. #ifdef CONFIG_OSF_PARTITION
    
42.     osf_partition,
    
43. #endif
    
44. #ifdef CONFIG_SUN_PARTITION
    
45.     sun_partition,
    
46. #endif
    
47. #ifdef CONFIG_AMIGA_PARTITION
    
48.     amiga_partition,
    
49. #endif
    
50. #ifdef CONFIG_ATARI_PARTITION
    
51.     atari_partition,
    
52. #endif
    
53. #ifdef CONFIG_MAC_PARTITION
    
54.     mac_partition,
    
55. #endif
    
56. #ifdef CONFIG_ULTRIX_PARTITION
    
57.     ultrix_partition,
    
58. #endif
    
59. #ifdef CONFIG_IBM_PARTITION
    
60.     ibm_partition,
    
61. #endif
    
62. #ifdef CONFIG_KARMA_PARTITION
    
63.     karma_partition,
    
64. #endif
    
65. #ifdef CONFIG_SYSV68_PARTITION
    
66.     sysv68_partition,
    
67. #endif
    
68.     NULL
    
69. };

    这么多函数，来自五湖四海，就是为了共同的目的，封装到了一起，就是为了获取分区的信息。把获取到信息存入结构体struct parsed_partitions *state;包含 分区的起始扇区，分区扇区的个数，flag等信息。

    定义如下：

1. struct parsed_partitions {
   
2.     char name[BDEVNAME_SIZE];
   
3.     struct {
   
4.         sector_t from;
   
5.         sector_t size;
   
6.         int flags;
   
7.     } parts[MAX_PART];
   
8.     int next;
   
9.     int limit;
   
10. };

参考文献：

1 Linux 那些事儿

2 Linux Kernel Source Code