linux硬盘识别过程

//AHCI初始化

kernel_init

kernel_init_freeable

do_one_initcall

driver_register

bus_add_driver

bus_for_each_dev

__driver_attach

driver_probe_device

(ahci_platform.c, struct platform_driver ahci_driver, ahci_platform_ops)

|- ahci_probe

    |- ata_host_alloc_pinfo     //热插拔

        |- ata_host_alloc      

            |- ata_port_alloc   //增加WARN_ON(1)

                |- INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);   //初始化热插拔检测工作队列

    |- ata_host_activate(host, irq, ahci_interrupt, IRQF_SHARED, &ahci_platform_sht);   //申请了中断，并调用ata_host_register函数注册host

        |- ata_host_register(host, sht);    //增加WARN_ON(1) 

            |- ata_scsi_add_hosts(host, sht);   //添加ATA的SCSI主机适配器包括两部分，为主机适配器分配数据结构，然后将主机适配器添加到系统

                |- scsi_host_alloc(sht, sizeof(struct ata_port *))  //继续初始化scsi_host结构体

                    |- shost->ehandler = kthread_run(scsi_error_handler, shost, "scsi_eh_%d", shost->host_no);  //创建并运行scsi错误处理线程

                |- scsi_add_host_with_dma(ap->scsi_host, &ap->tdev, ap->host->dev);

            |- async_schedule(async_port_probe, ap) //async_port_probe调用ata_scsi_scan_host扫描scsi_devcie，并向上层注册scsi_device

                |- __async_schedule

                    |- INIT_WORK(&entry->work, async_run_entry_fn);  //初始化硬盘扫描工作队列

//

//硬盘识别前错误处理识别硬盘信息

kthread

|- scsi_error_handler

    |- shost->transportt->eh_strategy_handler(shost) --> ata_scsi_error    // ata_init 中初始化

        |- ata_scsi_cmd_error_handler(host, ap, &eh_work_q);

        |- ata_scsi_port_error_handler(host, ap);

            |- ap->ops->error_handler(ap);--> ahci_error_handler

                |- sata_pmp_error_handler

                    |- ata_eh_report

                        |- ata_eh_link_report   //打印调试信息

                    |- sata_pmp_eh_recover

                        |- ata_eh_recover(ap, ops->prereset, ops->softreset, ops->hardreset, ops->postreset, NULL);

                            |- ata_eh_reset(link, ata_link_nr_vacant(link), prereset, softreset, hardreset, postreset);//打印hard resetting link

                                |- postreset(slave, classes) --> ata_std_postreset

                                    |- sata_print_link_status   //打印sata link状态，SATA link up 1.5 Gbps (SStatus 113 SControl 310)

                            |- ata_set_mode(link, &dev) //Set ATA device disk transfer mode

                                |- ap->ops->set_mode(link, r_failed_dev) --> generic_set_mode

                                    |- ata_dev_info(dev, "configured for %s\n", name);

                            |- ata_eh_revalidate_and_attach(link, &dev);

                                |- ata_dev_read_id(dev, &dev->class, readid_flags, dev->id);  //初始化ata_taskfile的参数，其命令ATA_CMD_ID_ATA，返回值保存在dev_id中，共512字节

                                    |- ata_do_dev_read_id(dev, &tf, id);

                                        |- ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE, id, sizeof(id[0]) * ATA_ID_WORDS, 0);

                                            |- ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem, timeout);   //通过完成变量阻塞执行命令

                                                |- ata_qc_issue(qc);   

                                |- ata_dev_configure(dev);

//

//运行硬盘扫描工作队列                                                   

|- worker_thread

    |- process_one_work                                                        

        |- worker->current_func(work) --> ata_scsi_hotplug / async_run_entry_fn -- async_port_probe

|- ata_scsi_scan_host   //扫描scsi_devcie，并向上层注册scsi_device

    |- sdev = __scsi_add_device //添加并注册一个scsi_device

        |- scsi_alloc_target

        |- scsi_probe_and_add_lun   //如果sdev设备已经存在，就返回SCSI_SCAN_LUN_PRESENT，不进行下面操作

            |- scsi_alloc_sdev 

                |- sdev->request_queue = scsi_alloc_queue(sdev)  //为SCSI设备分配了请求队列,设置回调处理函数,设置超时处理函数

                    |- blk_queue_softirq_done(q, scsi_softirq_done);

                    |- blk_queue_rq_timed_out(q, scsi_times_out);

            |- scsi_probe_lun   //发送SCSI INQUIRY命令探测lun单元

                |- scsi_execute_req     //scsi命令转换成request

            |- scsi_add_lun     //通过SCSI INQUIRY 返回的参数初始化sdev的一些成员，初始化设备类型sdev->type，其在sd_probe中会使用

                |- scsi_sysfs_add_sdev  //向上层注册sdev

                    |- scsi_target_add

                        |- device_add(&starget->dev) //把设备添加到所属总线的设备列表

                            |- bus_add_device

                            |- bus_probe_device(dev)    //为新找到的设备匹配一个driver

                                |- device_attach(dev)

                                    |- bus_for_each_drv(dev->bus, NULL, dev, __device_attach);   //用bus上的每个drv来匹配dev

                                        |- __device_attach

                                            |- driver_match_device  //如果匹配成功，则执行driver_probe_device函数

                                                |- return drv->bus->match ? drv->bus->match(dev, drv) : 1 --> scsi_bus_type.match=scsi_bus_match

                                            |- driver_probe_device

                                                |- really_probe     //根据bus->probe是否为真来判断是否调用drv->probe；无论调用哪个probe，都会执行到sd_probe函数。

                                                    |- drv->probe(dev) --> sd_probe   //匹配到设备时调用，在给定的ID和设备名之间建立映射，同时确定了块设备的主次设备号。并关联到了通用块层 //增加WARN_ON(1)

                                                        |- gd = alloc_disk(SD_MINORS);

                                                        |- async_schedule_domain(sd_probe_async, sdkp, &scsi_sd_probe_domain)

                                                            |- __async_schedule

                                                                |- sd_probe_async   //正常是通过工作队列执行,当工作队列满了或者内存不足时直接执行

                                                                    |- gendisk参数初始化

                                                                    |- scsi_disk参数初始化

                                                                    |- sd_revalidate_disk   //打印信息

                                                                        |- sd_read_capacity    

                                                                        |- sd_read_write_protect_flag

                                                                        |- sd_read_cache_type

                                                                    |- blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);

                                                                    |- add_disk(gd);    //注册到通用块层

//

//硬盘识别过程中scsi_alloc_sdev调用，初始化request_fn和make_request_fn

scsi_alloc_queue

    |- q = __scsi_alloc_queue(sdev->host, scsi_request_fn);

        |- q = blk_init_queue(request_fn, NULL);

            |- blk_init_queue_node

                |- blk_init_allocated_queue

                    |- q->request_fn = rfn   //request_fn初始化为scsi_request_fn

                    |- blk_queue_make_request(q, blk_queue_bio)

                        |- q->make_request_fn = mfn  //make_request_fn初始化为blk_queue_bio

                    |- elevator_init(q, NULL)

    |- blk_queue_prep_rq(q, scsi_prep_fn);  //在sd_probe中修改为sd_prep_fn

    |- blk_queue_softirq_done(q, scsi_softirq_done);

    |- blk_queue_rq_timed_out(q, scsi_times_out);

    |- blk_queue_lld_busy(q, scsi_lld_busy);

//

//scsi命令转换成request再转换成scsi命令发送

scsi_probe_lun

    |- result = scsi_execute_req(sdev,  scsi_cmd, DMA_FROM_DEVICE,inq_result, try_inquiry_len, &sshdr, HZ / 2 + HZ * scsi_inq_timeout, 3,&resid);

        |- scsi_execute_req_flags

            |- result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen, sense, timeout, retries, flags, resid);

                |- blk_get_request  //申请request并初始化

                    |- rq = get_request(q, rw, NULL, gfp_mask);

                        |- __get_request

                            |- rq = mempool_alloc(rl->rq_pool, gfp_mask);   

                            |- blk_rq_init(q, rq); 

                |- blk_execute_rq(req->q, NULL, req, 1); //利用完成变量来进行同步操作，探测lun

                    |- rq->end_io_data = &wait; 

                    |- blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq); //把请求插入I/O调度队列，之后处理请求

                        |- rq->end_io = blk_end_sync_rq; //scsi第一次回调过程中会调用该函数，其会调用complete(waiting)，scsi_probe_lun继续运行

                        |- __elv_add_request(q, rq, where);

                        |- __blk_run_queue(q);

                            |- __blk_run_queue_uncond(q);

                                |- q->request_fn(q) --> scsi_request_fn

                    |- wait_for_completion_io(&wait);   //scsi_probe_lun一直会阻塞在这里直到接收到完成信号，默认超时时间为LONG_MAX,可忽略

            |- scsi_execute_req_flags   //将感测数据格式化为公共格式

//

//SCSI中间层(SCSI协议层)

request_queue->request_fn---> scsi_request_fn //scsi设备请求队列处理函数

        |- req = blk_peek_request(q).

            |- rq = __elv_next_request(q)   //从请求队列中获取一个请求

            |- q->end_sector = rq_end_sector(rq);

            |- ret = q->prep_rq_fn(q, rq)--> sd_prep_fn   //根据request初始化SCSI命令，构建SCSI CDB

        |- blk_queue_start_tag

            |- blk_start_request(rq);

                |- blk_dequeue_request(req);

                    |- list_del_init(&rq->queuelist);    //把request从request queue队列里删除掉

        |- rtn = scsi_dispatch_cmd(cmd)     //分发请求,把SCSI命令提交给SCSI控制器 

            |- cmd->scsi_done = scsi_done;

            |- host->hostt->queuecommand(host, cmd)   --> ata_scsi_queuecmd   

//SCSI底层(SCSI传输层/SCSI控制器驱动层)//向ata管理器发出scsi cdb

                |- __ata_scsi_queuecmd(cmd, dev)

                    |- xlat_func = ata_get_xlat_func(dev, scsi_op);

                    |- ata_scsi_translate(dev, scmd, xlat_func);    //Scis命令真实转换为ata命令的流程

                        |- qc = ata_scsi_qc_new(dev, cmd)

                            |- qc->scsidone = cmd->scsi_done == scsi_done //设置ata—scsi回调函数

                        |- qc->complete_fn = ata_scsi_qc_complete;   //设置ata处理完成回调函数

                        |- xlat_func(qc) ---> 假设是READ_6调用函数 ata_scsi_rw_xlat //前面返回的xlat_func函数

                            |- ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags, qc->tag);//打包ata命令,主要是scsi_cmd初始化qc->tf,其代表ata—cmd

                        |- ata_qc_issue(qc);    //发送命令给指定设备

                            |- ap->ops->qc_prep(qc) --> ahci_qc_prep   //把ata cmd 转换成fis

                                |- ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl); 

                                |- ahci_fill_sg(qc, cmd_tbl);   //

                                |- ahci_fill_cmd_slot(pp, qc->tag, opts);    //

                            |- ap->ops->qc_issue(qc) --> ahci_qc_issue //激活定时器去通知硬件发送fis，fis通过中断发送，还未找到

                    |- ata_scsi_simulate(dev, scmd);    //sata命令不转换成ata命令，通过加载时的错误处理获取的id赋值

                        |- cmd->scsi_done == scsi_done

//
//AHCI中断
|- ahci_interrupt
    |- ahci_port_intr(ap);
        |- ahci_handle_port_interrupt(ap, port_mmio, status)
            |- ata_qc_complete_multiple(ap, qc_active)
                |- ata_qc_complete(qc);
                    |- __ata_qc_complete(qc);
                        |- qc->complete_fn(qc) --> ata_scsi_qc_complete

//

//scsi第一次回调：底层调用scsi_done函数产生软中断，运行函数scsi_softirq_done,scsi中间层根据其判断是否成功

ata_scsi_qc_complete

qc->scsidone(cmd) --> scsi_done

|- raise_softirq_irqoff(BLOCK_SOFTIRQ) --> blk_done_softirq

    |- rq->q->softirq_done_fn(rq) --> scsi_softirq_done

        |- scsi_decide_disposition

        |- scsi_finish_command  //成功，结束命令

            |- scsi_io_completion(cmd, good_bytes);

                |- scsi_end_request

                    |- blk_end_request

                        |- blk_end_bidi_request

                            |- blk_finish_request

                                |- req->end_io(req, error) --> blk_end_sync_rq

        |- scsi_queue_insert    //如果错误，从此执行

        |- scsi_eh_scmd_add    

            |- scsi_host_set_state(shost, SHOST_RECOVERY)   //后该host将处于阻塞状态，任何发往该host的IO都将阻塞，直至error handler处理完成

                |- shost->shost_state = SHOST_RECOVERY

            |- scsi_eh_wakeup(shost);   //唤醒错误处理线程，调度运行

                |- wake_up_process(shost->ehandler) --> scsi_error_handler

                    |- return try_to_wake_up(p, TASK_NORMAL, 0)

        |- scsi_finish_command  //结束命令

//

//得到block_device块设备，这样scsi层和块设备层就联系了

|- add_disk

    |- disk_alloc_events(disk)

    |- register_disk(disk)

         |- bdev = bdget_disk(disk, 0);

             |- bdev = bdget(part_devt(part));

                 |- inode = iget5_locked(blockdev_superblock, hash(dev), bdev_test,bdev_set, &dev);

                      |- inode = alloc_inode(sb);

                            |- inode = sb->s_op->alloc_inode(sb); //inode通过超级块获得，超级块初始化见下面

                 |- bdev = &BDEV_I(inode)->bdev; //通过这个inode得到bdev

    |- blk_register_queue(disk)

    |- disk_add_events(disk)

//

//超级块初始化

|- vfs_caches_init

    |- bdev_cache_init

        |- struct vfsmount bd_mnt = kern_mount(&bd_type) --> kern_mount_data

            |- struct vfsmount mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);   //根据文件系统类型分配安装点并初始化

                  |- struct dentry root = mount_fs(type, flags, name, data)

                        |- root = mount_fs(type, flags, name, data);

                             |- root = type->mount(&bd_type, flags, name, data) --> bd_mount

                                 |- mount_pseudo(fs_type, "bdev:", &bdev_sops, NULL,BDEVFS_MAGIC);    //分配超级块和目录项并初始化

                                    |- s->s_op = ops ? ops : &simple_super_operations;(ops是&bdev_sops)       //超级块ops初始化为bdev_sops

        |- blockdev_superblock = bd_mnt->mnt_sb; //获得超级块