MTD(memory technology device):内存技术设备，是linux用于描述ROM,NAND,NOR等设备的子系统的抽象，MTD设备可以按块读写也可以按字节读写,也就是说MTD设备既可以是块设备也可以是字符设备，块设备(mtdblackx)操作针对文件系统，字符设备(mtdx)操作主要针对格式化等操作的测试用。

一个MTD设备的描述为mtd_info这个结构体，填充好这个结构体，然后调用add_mtd_device添加mtd设备函数就可以注册MTD设备了。在内核的源代码中，mtdram.c是一个很简单的例子，他把一块内存空间模拟了一个MTD device，研究MTD的框架，从这个mtdram.c开始：

1. /*
2. * mtdram - a test mtd device
3. * Author: Alexander Larsson <alex@cendio.se>
4. *
5. * Copyright (c) 1999 Alexander Larsson <alex@cendio.se>
6. * Copyright (c) 2005 Joern Engel <joern@wh.fh-wedel.de>
7. *
8. * This code is GPL
9. *
10. */
11. #include <linux/module.h>
12. #include <linux/slab.h>
13. #include <linux/ioport.h>
14. #include <linux/vmalloc.h>
15. #include <linux/init.h>
16. #include <linux/mtd/compatmac.h>
17. #include <linux/mtd/mtd.h>
18. #include <linux/mtd/mtdram.h>
19. static unsigned long total_size = CONFIG_MTDRAM_TOTAL_SIZE;
20. static unsigned long erase_size = CONFIG_MTDRAM_ERASE_SIZE;
21. #define MTDRAM_TOTAL_SIZE (total_size * 1024)
22. #define MTDRAM_ERASE_SIZE (erase_size * 1024)
23. #ifdef MODULE
24. module_param(total_size, ulong, 0);
25. MODULE_PARM_DESC(total_size, "Total device size in KiB");
26. module_param(erase_size, ulong, 0);
27. MODULE_PARM_DESC(erase_size, "Device erase block size in KiB");
28. #endif
29. // We could store these in the mtd structure, but we only support 1 device..
30. static struct mtd_info *mtd_info;
31. static int ram_erase(struct mtd_info *mtd, struct erase_info *instr)
32. {
33. if (instr->addr + instr->len > mtd->size)
34. return -EINVAL;
35. memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
36. instr->state = MTD_ERASE_DONE;
37. mtd_erase_callback(instr);
38. return 0;
39. }
40. static int ram_point(struct mtd_info *mtd, loff_t from, size_t len,
41. size_t *retlen, void **virt, resource_size_t *phys)
42. {
43. if (from + len > mtd->size)
44. return -EINVAL;
45. /* can we return a physical address with this driver? */
46. if (phys)
47. return -EINVAL;
48. *virt = mtd->priv + from;
49. *retlen = len;
50. return 0;
51. }
52. static void ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
53. {
54. }
55. /*
56. * Allow NOMMU mmap() to directly map the device (if not NULL)
57. * - return the address to which the offset maps
58. * - return -ENOSYS to indicate refusal to do the mapping
59. */
60. static unsigned long ram_get_unmapped_area(struct mtd_info *mtd,
61. unsigned long len,
62. unsigned long offset,
63. unsigned long flags)
64. {
65. return (unsigned long) mtd->priv + offset;
66. }
67. static int ram_read(struct mtd_info *mtd, loff_t from, size_t len,
68. size_t *retlen, u_char *buf)
69. {
70. if (from + len > mtd->size)
71. return -EINVAL;
72. memcpy(buf, mtd->priv + from, len);
73. *retlen = len;
74. return 0;
75. }
76. static int ram_write(struct mtd_info *mtd, loff_t to, size_t len,
77. size_t *retlen, const u_char *buf)
78. {
79. if (to + len > mtd->size)
80. return -EINVAL;
81. memcpy((char *)mtd->priv + to, buf, len);
82. *retlen = len;
83. return 0;
84. }
85. static void __exit cleanup_mtdram(void)
86. {
87. if (mtd_info) {
88. del_mtd_device(mtd_info);
89. vfree(mtd_info->priv);
90. kfree(mtd_info);
91. }
92. }
93. int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
94. unsigned long size, char *name)
95. {
96. memset(mtd, 0, sizeof(*mtd));
97. /* Setup the MTD structure */
98. mtd->name = name;
99. mtd->type = MTD_RAM;
100. mtd->flags = MTD_CAP_RAM;
101. mtd->size = size;
102. mtd->writesize = 1;
103. mtd->erasesize = MTDRAM_ERASE_SIZE;
104. mtd->priv = mapped_address;
105. mtd->owner = THIS_MODULE;
106. mtd->erase = ram_erase;
107. mtd->point = ram_point;
108. mtd->unpoint = ram_unpoint;
109. mtd->get_unmapped_area = ram_get_unmapped_area;
110. mtd->read = ram_read;
111. mtd->write = ram_write;
112. if (add_mtd_device(mtd)) { //填充好mtd_info之后注册这个mtd设备
113. return -EIO;
114. }
115. return 0;
116. }
117. static int __init init_mtdram(void)
118. {
119. void *addr;
120. int err;
121. if (!total_size)
122. return -EINVAL;
123. /* Allocate some memory */
124. mtd_info = kmalloc(sizeof(struct mtd_info), GFP_KERNEL); //分配mtd_info
125. if (!mtd_info)
126. return -ENOMEM;
127. addr = vmalloc(MTDRAM_TOTAL_SIZE); //开辟一段内存用来模拟MTD设备
128. if (!addr) {
129. kfree(mtd_info);
130. mtd_info = NULL;
131. return -ENOMEM;
132. }
133. err = mtdram_init_device(mtd_info, addr, MTDRAM_TOTAL_SIZE, "mtdram test device");
134. if (err) {
135. vfree(addr);
136. kfree(mtd_info);
137. mtd_info = NULL;
138. return err;
139. }
140. memset(mtd_info->priv, 0xff, MTDRAM_TOTAL_SIZE);
141. return err;
142. }
143. module_init(init_mtdram);
144. module_exit(cleanup_mtdram);
145. MODULE_LICENSE("GPL");
146. MODULE_AUTHOR("Alexander Larsson <alexl@redhat.com>");
147. MODULE_DESCRIPTION("Simulated MTD driver for testing");

这是一个很简单的mtd设备驱动，以一块ram来模拟一个mtd设备，从上面代码可以看到，一个mtd设备的注册就是先填充好一个mtd_info，这个结构体提供设备的硬件信息以及读写擦除等操作方法。注册这个结构体就完成了一个mtd设备的添加。这里对应的是ram设备，读写是直接操作内存的，如果是nandflash和norflash设备，对读写擦除等操作函数比较复杂，但是最终mtd的设备都要调用add_mtd_device这个函数来注册，下面来分析到底这个函数做了什么来注册一个mtd设备的：

1. int add_mtd_device(struct mtd_info *mtd)
2. {
3. int i;
4. if (!mtd->backing_dev_info) {
5. switch (mtd->type) {
6. case MTD_RAM:
7. mtd->backing_dev_info = &mtd_bdi_rw_mappable;
8. break;
9. case MTD_ROM:
10. mtd->backing_dev_info = &mtd_bdi_ro_mappable;
11. break;
12. default:
13. mtd->backing_dev_info = &mtd_bdi_unmappable;
14. break;
15. }
16. }
17. BUG_ON(mtd->writesize == 0);
18. mutex_lock(&mtd_table_mutex);
19. for (i=0; i < MAX_MTD_DEVICES; i++)
20. if (!mtd_table[i]) {
21. struct mtd_notifier *not;
22. mtd_table[i] = mtd;
23. mtd->index = i;
24. mtd->usecount = 0;
25. if (is_power_of_2(mtd->erasesize))
26. mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
27. else
28. mtd->erasesize_shift = 0;
29. if (is_power_of_2(mtd->writesize))
30. mtd->writesize_shift = ffs(mtd->writesize) - 1;
31. else
32. mtd->writesize_shift = 0;
33. mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
34. mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
35. /* Some chips always power up locked. Unlock them now */
36. if ((mtd->flags & MTD_WRITEABLE)
37. && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
38. if (mtd->unlock(mtd, 0, mtd->size))
39. printk(KERN_WARNING
40. "%s: unlock failed, "
41. "writes may not work\n",
42. mtd->name);
43. }
44. /* Caller should have set dev.parent to match the
45. * physical device.
46. */
47. mtd->dev.type = &mtd_devtype;
48. mtd->dev.class = &mtd_class;
49. mtd->dev.devt = MTD_DEVT(i);
50. dev_set_name(&mtd->dev, "mtd%d", i); //设置mtd设备名称
51. dev_set_drvdata(&mtd->dev, mtd);
52. if (device_register(&mtd->dev) != 0) { //注册mtd设备(会自动创建mtd设备可读写的节点)
53. mtd_table[i] = NULL;
54. break;
55. }
56. if (MTD_DEVT(i))
57. device_create(&mtd_class, mtd->dev.parent, //创建mtd设备只读的节点
58. MTD_DEVT(i) + 1,
59. NULL, "mtd%dro", i);
60. DEBUG(0, "mtd: Giving out device %d to %s\n",i, mtd->name);
61. /* No need to get a refcount on the module containing
62. the notifier, since we hold the mtd_table_mutex */
63. list_for_each_entry(not, &mtd_notifiers, list)
64. not->add(mtd); //把这个mtd device注册到mtd
65. mutex_unlock(&mtd_table_mutex);
66. /* We _know_ we aren't being removed, because
67. our caller is still holding us here. So none
68. of this try_ nonsense, and no bitching about it
69. either. :) */
70. __module_get(THIS_MODULE);
71. return 0;
72. }
73. mutex_unlock(&mtd_table_mutex);
74. return 1;
75. }

可以看出注册device的时候，需要调用mtd_notifiers链表里面的add函数，这个函数指针在哪里被添加进去的？

1. void register_mtd_user (struct mtd_notifier *new)
2. {
3. int i;
4. mutex_lock(&mtd_table_mutex);
5. list_add(&new->list, &mtd_notifiers); //new添加到mtd_notifiers链表
6. __module_get(THIS_MODULE);
7. for (i=0; i< MAX_MTD_DEVICES; i++)
8. if (mtd_table[i])
9. new->add(mtd_table[i]);
10. mutex_unlock(&mtd_table_mutex);
11. }

那么register_mtd_user是谁调用的？查看代码可以知道在mtdchar.c与mtdblock.c以及mtdblock_ro.c里面注册MTD字符设备与MTD块设备的时候调用的，所以可以知道这个链表放的就是支持mtd设备的所有驱动，都放在这个链表里面，在执行add_mtd_device里面的

list_for_each_entry(not, &mtd_notifiers, list)
not->add(mtd);

的时候，一个for循环调用不同驱动(字符，块，只读块驱动)的add函数来添加这个device到不同的驱动。这里以块设备驱动为例，如果添加到块驱动，那么：

1. static struct mtd_notifier blktrans_notifier = {
2. .add = blktrans_notify_add,
3. .remove = blktrans_notify_remove,
4. };

调用add就是调用：

1. static void blktrans_notify_add(struct mtd_info *mtd)
2. {
3. struct mtd_blktrans_ops *tr;
4. if (mtd->type == MTD_ABSENT)
5. return;
6. list_for_each_entry(tr, &blktrans_majors, list)
7. tr->add_mtd(tr, mtd);
8. }

可以知道执行blktrans_majors链表里面的add_mtd，这个链表的元素通过下面函数添加进去：

1. int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
2. {
3. int ret, i;
4. /* Register the notifier if/when the first device type is
5. registered, to prevent the link/init ordering from fucking
6. us over. */
7. if (!blktrans_notifier.list.next)
8. register_mtd_user(&blktrans_notifier);
9. tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
10. if (!tr->blkcore_priv)
11. return -ENOMEM;
12. mutex_lock(&mtd_table_mutex);
13. ret = register_blkdev(tr->major, tr->name);
14. if (ret) {
15. printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
16. tr->name, tr->major, ret);
17. kfree(tr->blkcore_priv);
18. mutex_unlock(&mtd_table_mutex);
19. return ret;
20. }
21. spin_lock_init(&tr->blkcore_priv->queue_lock);
22. tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
23. if (!tr->blkcore_priv->rq) {
24. unregister_blkdev(tr->major, tr->name);
25. kfree(tr->blkcore_priv);
26. mutex_unlock(&mtd_table_mutex);
27. return -ENOMEM;
28. }
29. tr->blkcore_priv->rq->queuedata = tr;
30. blk_queue_logical_block_size(tr->blkcore_priv->rq, tr->blksize);
31. if (tr->discard)
32. queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
33. tr->blkcore_priv->rq);
34. tr->blkshift = ffs(tr->blksize) - 1;
35. tr->blkcore_priv->thread = kthread_run(mtd_blktrans_thread, tr,
36. "%sd", tr->name);
37. if (IS_ERR(tr->blkcore_priv->thread)) {
38. int ret = PTR_ERR(tr->blkcore_priv->thread);
39. blk_cleanup_queue(tr->blkcore_priv->rq);
40. unregister_blkdev(tr->major, tr->name);
41. kfree(tr->blkcore_priv);
42. mutex_unlock(&mtd_table_mutex);
43. return ret;
44. }
45. INIT_LIST_HEAD(&tr->devs);
46. list_add(&tr->list, &blktrans_majors); //添加这个块驱动到链表
47. for (i=0; i<MAX_MTD_DEVICES; i++) { //注册块驱动的时候添加所有mtd的块设备
48. if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
49. tr->add_mtd(tr, mtd_table[i]);
50. }
51. mutex_unlock(&mtd_table_mutex);
52. return 0;
53. }

这个函数就是注册一个块驱动，然后添加所有mtd的块设备。所以最终的核心就是add_mtd这个，他在mtd块设备里面是mtdblock_add_mtd函数，这个函数最终会调用下面函数来添加一个MTD块设备：

1. int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
2. {
3. struct mtd_blktrans_ops *tr = new->tr;
4. struct mtd_blktrans_dev *d;
5. int last_devnum = -1;
6. struct gendisk *gd;
7. if (mutex_trylock(&mtd_table_mutex)) {
8. mutex_unlock(&mtd_table_mutex);
9. BUG();
10. }
11. list_for_each_entry(d, &tr->devs, list) {
12. if (new->devnum == -1) {
13. /* Use first free number */
14. if (d->devnum != last_devnum+1) {
15. /* Found a free devnum. Plug it in here */
16. new->devnum = last_devnum+1;
17. list_add_tail(&new->list, &d->list);
18. goto added;
19. }
20. } else if (d->devnum == new->devnum) {
21. /* Required number taken */
22. return -EBUSY;
23. } else if (d->devnum > new->devnum) {
24. /* Required number was free */
25. list_add_tail(&new->list, &d->list);
26. goto added;
27. }
28. last_devnum = d->devnum;
29. }
30. if (new->devnum == -1)
31. new->devnum = last_devnum+1;
32. if ((new->devnum << tr->part_bits) > 256) {
33. return -EBUSY;
34. }
35. list_add_tail(&new->list, &tr->devs);
36. added:
37. mutex_init(&new->lock);
38. if (!tr->writesect)
39. new->readonly = 1;
40. gd = alloc_disk(1 << tr->part_bits); //分配disk
41. if (!gd) {
42. list_del(&new->list);
43. return -ENOMEM;
44. }
45. gd->major = tr->major;
46. gd->first_minor = (new->devnum) << tr->part_bits;
47. gd->fops = &mtd_blktrans_ops;
48. if (tr->part_bits)
49. if (new->devnum < 26)
50. snprintf(gd->disk_name, sizeof(gd->disk_name),
51. "%s%c", tr->name, 'a' + new->devnum);
52. else
53. snprintf(gd->disk_name, sizeof(gd->disk_name),
54. "%s%c%c", tr->name,
55. 'a' - 1 + new->devnum / 26,
56. 'a' + new->devnum % 26);
57. else
58. snprintf(gd->disk_name, sizeof(gd->disk_name),
59. "%s%d", tr->name, new->devnum);
60. /* 2.5 has capacity in units of 512 bytes while still
61. having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
62. set_capacity(gd, (new->size * tr->blksize) >> 9);
63. gd->private_data = new;
64. new->blkcore_priv = gd;
65. gd->queue = tr->blkcore_priv->rq;
66. gd->driverfs_dev = &new->mtd->dev;
67. if (new->readonly)
68. set_disk_ro(gd, 1);
69. add_disk(gd); //添加disk
70. return 0;
71. }

alloc_disk与add_disk这在之前分析块设备驱动框架的时候已经分析了，这两个就是注册块设备的基本函数。而如果是mtd字符设备，就会调用字符设备的添加函数，所以add_mtd_device这个函数就是这样来添加mtd设备的。
mtd设备驱动由块设备，字符设备，只读块设备等类型：

MTD块driver（针对文件系统）：

1. static struct mtd_blktrans_ops mtdblock_tr = {
2. .name = "mtdblock",
3. .major = 31,
4. .part_bits = 0,
5. .blksize = 512,
6. .open = mtdblock_open,
7. .flush = mtdblock_flush,
8. .release = mtdblock_release,
9. .readsect = mtdblock_readsect,
10. .writesect = mtdblock_writesect,
11. .add_mtd = mtdblock_add_mtd,
12. .remove_dev = mtdblock_remove_dev,
13. .owner = THIS_MODULE,
14. };
15. static int __init init_mtdblock(void)
16. {
17. mutex_init(&mtdblks_lock);
18. return register_mtd_blktrans(&mtdblock_tr);
19. }
20. static void __exit cleanup_mtdblock(void)
21. {
22. deregister_mtd_blktrans(&mtdblock_tr);
23. }
24. module_init(init_mtdblock);
25. module_exit(cleanup_mtdblock);

MTD字符driver（支持块设备像字符设备那样去操作，一般用作测试）

1. static int __init init_mtdchar(void)
2. {
3. int ret;
4. ret = __register_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS,"mtd", &mtd_fops); //注册字符设备,捆绑mtd_fops
5. if (ret < 0) {
6. pr_notice("Can't allocate major number %d for Memory Technology Devices.\n", MTD_CHAR_MAJOR);
7. return ret;
8. }
9. ret = register_filesystem(&mtd_inodefs_type); //注册mtd_inodefs_type文件系统
10. if (ret) {
11. pr_notice("Can't register mtd_inodefs filesystem: %d\n", ret);
12. goto err_unregister_chdev;
13. }
14. mtd_inode_mnt = kern_mount(&mtd_inodefs_type); //挂载mtd_inodefs_type文件系统
15. if (IS_ERR(mtd_inode_mnt)) {
16. ret = PTR_ERR(mtd_inode_mnt);
17. pr_notice("Error mounting mtd_inodefs filesystem: %d\n", ret);
18. goto err_unregister_filesystem;
19. }
20. register_mtd_user(&mtdchar_notifier); //注册到链表
21. return ret;
22. err_unregister_filesystem:
23. unregister_filesystem(&mtd_inodefs_type);
24. err_unregister_chdev:
25. __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
26. return ret;
27. }

MTD的框架跟输入子系统一样类似的分离框架，一边注册驱动(driver)，一边注册设备(device)，驱动有字符，块，只读块，系统开机会注册mtd设备的驱动同时添加已注册的设备。

MTD驱动端：这里可以注册mtd的字符与块设备，只读块驱动，分别对应内核代码的mtdblock.c与mtdchar.c还有只读的mtdblock_ro.c

MTD设备端：调用add_mtd_device注册设备

驱动专题：第五章MTD及Flash驱动 1.mtd框架分析相关推荐

1. 驱动专题：第四章MTD及Flash驱动 3. nandflash 详细硬件特性

   [详解]如何编写Linux下Nand Flash驱动 版本:v2.2.1 Crifan Li 摘要 本文先解释了Nand Flash相关的一些名词,再从Flash硬件机制开始,介绍到Nand Flas ...

2. Android深度探索--HAL与驱动开发----第五章读书笔记

   第五章主要学习了搭建S3C6410开发板的测试环境.首先要了解到S3C6410是一款低功耗.高性价比的RISC处理器它是基于ARMI1内核,广泛应用于移动电话和通用处理等领域. 开发板从技术上说与我们 ...

3. 需求工程：第五章 确定项目的前景和范围-目标分析第六章 涉众分析与硬数据采样

   第五章 确定项目的前景和范围-目标分析 目标分析 为什么需要目标?业务需求不够严谨,无法形成方法学支持(建模) 目标: 是系统被开发的目的,有着明确的定义方式,名称.类型.关注.定义(正式,非正式). ...

4. 驱动专题：第五章MTD及Flash驱动 4.Norflash驱动

   嵌入式Linux--nor flash (1):硬件介绍 声明:本文章是学完韦东山老师的教学视频后看过一些文章后所写,在看文章时我会将一些可能重要的知识点复制下来,所以可能会抄到您文章中的一些内容,如 ...

5. 驱动专题：第五章MTD及Flash驱动 2.Nandflash驱动

   一.MTD体系结构:Linux内核提供MTD子系统来建立FLASH针对Linux的统一.抽象接口.MTD将文件系统与底层的FLASH存储器进行隔离. 引入MTD后Linux系统中对FLASH的设备驱动 ...

6. linux下nand flash驱动工作原理,1.3.4. Nand flash驱动工作原理

   1.3.4. Nand flash驱动工作原理 在介绍具体如何写Nand Flash驱动之前,我们先要了解,大概的整个系统,和Nand Flash相关的部分的驱动工作流程,这样,对于后面的驱动实现,才 ...

7. 第五章 系统方法---------基于业务驱动的企业安全架构（翻译，原作者John Sherwood）----仅学习使用

   第 5 章:系统方法 安全架构的合理合理设计是通过采用系统方法来实现的. 这将确保最终结果与业务需求一致,并确保设计过程得到正确执行. 本书所提倡的系统方法基于成熟的系统工程原则. 在本章中,您将了解 ...

8. Android深度探索(卷1)HAL与驱动开发第五章总结

   开发板是开发和学习嵌入式技术的主要硬件设备,开发板的型号和种类很多,目前流行的是基于S3C6410 ARM11架构的开发板,S3C6410是由三星公司推出的一款低功耗,高性价比的RISC处理器,它基于 ...

9. Spring基础专题——第五章（Aop代理）

   前言:去年到现在一直没有很好的时间完成这个spring基础+源码的博客目标,去年一年比较懒吧,所以今年我希望我的知识可以分享给正在奋斗中的互联网开发人员,以及未来想往架构师上走的道友们我们一起进步,从 ...

最新文章

1. python【OS操作系统库】Python的os模块大宝剑（全）
2. centos7中systemctl 对系统服务的控制
3. 手把手教你--JAVA微信支付（H5支付）
4. 如果打开MSSQL server 显示无项目的解决方法
5. OpenGL基础39：GLSL内建变量与接口块
6. python字符串去掉最后的逗号_拼接字符串时去掉最后一个多余逗号
7. postgresql安装报错
8. oa工作任务管理系统设计
9. 黑群晖vmm专业版_群晖的ABB应用不错，但必须吐槽群晖 VMM功能，让你看看就是不让你好好用！！！...
10. 付出不亚于任何人的努力
11. Python九九口诀表
12. CSS绘制形状（三角形、四分之一圆、半圆、圆、梯形、球体、菱形）
13. 如何从瘫痪windows系统里面找到原来的IP地址设置
14. Xcode 4.1~4.6 + iOS 5、iOS 6免证书(iDP)开发+真机调试+生成IPA全攻略
15. 【研究生】学会这几步，还怕不会写硕士论文？
16. python使用大漠插件教程_python调用大漠插件教程04鼠键事件及基本项目思维
17. 特征工程(七)：图像特征提取和深度学习
18. 用学生邮箱注册JetBrains官网账号
19. “H5结婚请柬电子版”制作攻略
20. 谷歌浏览器最新版下载链接

热门文章

1. 每日一录20220816—01
2. 南阳OJ独木舟上的旅行
3. 穿普拉达的女王 观后感
4. 世上最经典的爱情诗句
5. 用水浒传来学习OKR
6. 关于最新版go-cqhttp无法登录qq
7. Leetcode典型题解答和分析、归纳和汇总——T51（N皇后）
8. 心...............................
9. Android开发一个美食app
10. 看《我是特种兵》有感