scsi底层设备注册——如何一步步注册到block层

来源：互联网发布：特征提取算法如何优化编辑：程序博客网时间：2024/05/18 19:35

首先，让我们先进入ata_host_register函数，看如何一步一步的去向上层注册的。

intata_host_register(struct ata_host *host, struct scsi_host_template *sht)

{

int i, rc;

host->n_tags =clamp(sht->can_queue, 1, ATA_MAX_QUEUE - 1);// can_queue =1 MAX_QUEUE = 32 by wyf

/* host must have been started */

if (!(host->flags &ATA_HOST_STARTED)) { //ata_host_startset ATA_HOST_STARTED by wyf

dev_err(host->dev,”BUG: trying to register unstarted host\n”);

WARN_ON(1);

return -EINVAL;

}

/* Blow away unused ports. This happens when LLD can’t

* determine the exact number of ports toallocate at

* allocation time.

for (i = host->n_ports;host->ports[i]; i++)

kfree(host->ports[i]);

/* give ports names and add SCSI hosts*/

for (i = 0; i < host->n_ports; i++){

host->ports[i]->print_id= atomic_inc_return(&ata_print_id);

host->ports[i]->local_port_no= i + 1;

}

/* Create associated sysfs transportobjects */

for (i = 0; i < host->n_ports;i++) {

rc =ata_tport_add(host->dev,host->ports[i]);

if (rc) {

goto err_tadd;

}

rc = ata_scsi_add_hosts(host, sht);

if (rc)

goto err_tadd;

/* set cable, sata_spd_limit and report*/

for (i = 0; i < host->n_ports;i++) {

struct ata_port *ap =host->ports[i];

unsigned long xfer_mask;

/* set SATA cable type ifstill unset */

if (ap->cbl ==ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))

ap->cbl =ATA_CBL_SATA;

/* init sata_spd_limit to thecurrent value */

sata_link_init_spd(&ap->link);

if (ap->slave_link)

sata_link_init_spd(ap->slave_link);

/* print per-port info todmesg */

xfer_mask =ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,

ap->udma_mask);

if (!ata_port_is_dummy(ap)) {

ata_port_info(ap,”%cATA max %s %s\n”,

(ap->flags & ATA_FLAG_SATA) ? ‘S’: ‘P’,

ata_mode_string(xfer_mask),

ap->link.eh_info.desc);

ata_ehi_clear_desc(&ap->link.eh_info);

} else

ata_port_info(ap,”DUMMY\n”);

}

/* perform each probe asynchronously */

for (i = 0; i < host->n_ports;i++) {

struct ata_port *ap =host->ports[i];

async_schedule(async_port_probe,ap);

}

return 0;

err_tadd:

while (–i >= 0) {

ata_tport_delete(host->ports[i]);

}

return rc;

}

在ata_host_register中调用了ata_scsi_add_hosts和async_port_probe两个重要的函数，其中ata_scsi_add_hosts主要是分配一个scsi_host结构，并向上层注册一个scsi_host；

在async_port_probe 中主要调用ata_scsi_scan_host进行扫描scsi_devcie，并向上层注册scsi_device;

下面让我们一起走进scsi_device如何被注册的把！

voidata_scsi_scan_host(struct ata_port *ap, int sync)

{

int tries = 5;

struct ata_device *last_failed_dev =NULL;

struct ata_link *link;

struct ata_device *dev;

repeat:

ata_for_each_link(link, ap, EDGE) {

ata_for_each_dev(dev, link,ENABLED) {

struct scsi_device *sdev;

int channel = 0, id= 0;

if (dev->sdev)

continue;

if(ata_is_host_link(link))

id =dev->devno;

else

channel =link->pmp;

sdev =__scsi_add_device(ap->scsi_host, channel, id, 0,

NULL);

if (!IS_ERR(sdev)) {

dev->sdev= sdev;

scsi_device_put(sdev);

} else {

dev->sdev= NULL;

}

/* If we scanned while EH was inprogress or allocation

* failure occurred, scan would have failedsilently. Check

* whether all devices are attached.

ata_for_each_link(link, ap, EDGE) {

ata_for_each_dev(dev, link,ENABLED) {

if (!dev->sdev)

gotoexit_loop;

}

exit_loop:

if (!link)

return;

/* we’re missing some SCSI devices */

if (sync) {

/* If caller requestedsynchrnous scan && we’ve made

* any progress, sleep briefly and repeat.

if (dev != last_failed_dev) {

msleep(100);

last_failed_dev =dev;

goto repeat;

}

/* We might be failing todetect boot device, give it

* a few more chances.

if (–tries) {

msleep(100);

goto repeat;

}

ata_port_err(ap,

“WARNING: synchronous SCSI scanfailed without making any progress, switching to async\n”);

}

queue_delayed_work(system_long_wq,&ap->hotplug_task,

round_jiffies_relative(HZ));

}

通过__add_scsi_device添加并注册一个scsi_device;

structscsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,

uint id, u64 lun, void *hostdata)

{

struct scsi_device *sdev =ERR_PTR(-ENODEV);

struct device *parent =&shost->shost_gendev;

struct scsi_target *starget;

if (strncmp(scsi_scan_type,”none”, 4) == 0)

return ERR_PTR(-ENODEV);

starget = scsi_alloc_target(parent,channel, id);

if (!starget)

return ERR_PTR(-ENOMEM);

scsi_autopm_get_target(starget);

mutex_lock(&shost->scan_mutex);

if (!shost->async_scan)

scsi_complete_async_scans();

if (scsi_host_scan_allowed(shost)&& scsi_autopm_get_host(shost) == 0) {

scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1,hostdata);//*sdev = alloced scsi_device by wyf

scsi_autopm_put_host(shost);

}

mutex_unlock(&shost->scan_mutex);

scsi_autopm_put_target(starget);

* paired with scsi_alloc_target(). Target will be destroyed unless

* scsi_probe_and_add_lun made an underlyingdevice visible

scsi_target_reap(starget);

put_device(&starget->dev);

return sdev;

}

在上面函数中调用了scsi_probe_and_add_lun，该函数主要实现轮询是否有scsi_device 并添加一个Lun 设备。

staticint scsi_probe_and_add_lun(struct scsi_target *starget,

u64 lun, int *bflagsp,

struct scsi_device **sdevp, int rescan,

void *hostdata)//starget, 0, NULL, &sdev,1, hostdata by wyf

{

struct scsi_device *sdev;

unsigned char *result;

int bflags, res =SCSI_SCAN_NO_RESPONSE, result_len = 256;

struct Scsi_Host *shost =dev_to_shost(starget->dev.parent);

* The rescan flag is used as an optimization,the first scan of a

* host adapter calls into here with rescan ==0.

sdev =scsi_device_lookup_by_target(starget, lun);

if (sdev) {

if (rescan ||!scsi_device_created(sdev)) {

SCSI_LOG_SCAN_BUS(3,sdev_printk(KERN_INFO, sdev,

“scsiscan: device exists on %s\n”,

dev_name(&sdev->sdev_gendev)));

if (sdevp)

*sdevp =sdev;

else

scsi_device_put(sdev);

if (bflagsp)

*bflagsp =scsi_get_device_flags(sdev,

sdev->vendor,

sdev->model);

returnSCSI_SCAN_LUN_PRESENT;

}

scsi_device_put(sdev);

} else

sdev = scsi_alloc_sdev(starget, lun, hostdata);

if (!sdev)

goto out;

result = kmalloc(result_len, GFP_ATOMIC|

((shost->unchecked_isa_dma)? __GFP_DMA : 0));

if (!result)

goto out_free_sdev;

if (scsi_probe_lun(sdev, result, result_len,&bflags))

goto out_free_result;

if (bflagsp)

*bflagsp = bflags;

* result contains valid SCSI INQUIRY data.

if (((result[0] >> 5) == 3)&& !(bflags & BLIST_ATTACH_PQ3)) {

* For a Peripheral qualifier 3 (011b), theSCSI

* spec says: The device server is not capableof

* supporting a physical device on this logical

* unit.

* For disks, this implies that there is no

* logical disk configured at sdev->lun, butthere

* is a target id responding.

SCSI_LOG_SCAN_BUS(2,sdev_printk(KERN_INFO, sdev, “scsi scan:”

” peripheral qualifier of 3, devicenot”

” added\n”))

if (lun == 0) {

SCSI_LOG_SCAN_BUS(1,{

unsignedchar vend[9];

unsigned char mod[17];

sdev_printk(KERN_INFO,sdev,

“scsiscan: consider passing scsi_mod.”

“dev_flags=%s:%s:0x240or 0x1000240\n”,

scsi_inq_str(vend,result, 8, 16),

scsi_inq_str(mod,result, 16, 32));

});

}

res =SCSI_SCAN_TARGET_PRESENT;

goto out_free_result;

}

* Some targets may set slight variations of PQand PDT to signal

* that no LUN is present, so don’t add sdev inthese cases.

* Two specific examples are:

* 1) NetApp targets: return PQ=1, PDT=0x1f

* 2) USB UFI: returns PDT=0x1f, with the PQbits being “reserved”

* inthe UFI 1.0 spec (we cannot rely on reserved bits).

* References:

* 1) SCSI SPC-3, pp. 145-146

* PQ=1: “A peripheral device having thespecified peripheral

* device type is not connected to this logicalunit. However, the

* device server is capable of supporting thespecified peripheral

* device type on this logical unit.”

* PDT=0x1f: “Unknown or no devicetype”

* 2) USB UFI 1.0, p. 20

* PDT=00h Direct-access device (floppy)

* PDT=1Fh none (no FDD connected to therequested logical unit)

if (((result[0] >> 5) == 1 ||starget->pdt_1f_for_no_lun) &&

(result[0] & 0x1f) == 0x1f &&

!scsi_is_wlun(lun)) {

SCSI_LOG_SCAN_BUS(3,sdev_printk(KERN_INFO, sdev,

“scsiscan: peripheral device type”

“of 31, no device added\n”));

res =SCSI_SCAN_TARGET_PRESENT;

goto out_free_result;

}

res = scsi_add_lun(sdev, result, &bflags,shost->async_scan);

if (res == SCSI_SCAN_LUN_PRESENT) {

if (bflags & BLIST_KEY) {

sdev->lockable =0;

scsi_unlock_floptical(sdev,result);

}

out_free_result:

kfree(result);

out_free_sdev:

if (res == SCSI_SCAN_LUN_PRESENT) {

if (sdevp) {

if (scsi_device_get(sdev)== 0) {

*sdevp =sdev;

} else {

__scsi_remove_device(sdev);

res =SCSI_SCAN_NO_RESPONSE;

}

} else

__scsi_remove_device(sdev);

out:

return res;

}

可以在上面函数中看到，如果找到一个sdev，就返回SCSI_SCAN_LUN_PRESENT;如果sdev为kong，则scsi_alloc_sdev分配一个sdev，然后scsi_probe_lun利用SCSI INQUIRY命令探测一个lun，最后通过scsi_add_lun注册一个lun设备。

重点看scsi层如何向上层提交一个scsi_device的。

staticint scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,

int *bflags, int async)

{

int ret;

* XXX do not save the inquiry, since it canchange underneath us,

* save just vendor/model/rev.

* Rather than save it and have an ioctl thatretrieves the saved

* value, have an ioctl that executes the sameINQUIRY code used

* in scsi_probe_lun, let user level programsdoing INQUIRY

* scanning run at their own risk, or supply auser level program

* that can correctly scan.

* Copy at least 36 bytes of INQUIRY data, sothat we don’t

* dereference unallocated memory whenaccessing the Vendor,

* Product, and Revision strings. Badly behaved devices may set

* the INQUIRY Additional Length byte to asmall value, indicating

* these strings are invalid, but often theycontain plausible data

* nonetheless. It doesn’t matter if the device sent < 36 bytes

* total, since scsi_probe_lun() initializesinq_result with 0s.

sdev->inquiry = kmemdup(inq_result,

max_t(size_t,sdev->inquiry_len, 36),

GFP_ATOMIC);

if (sdev->inquiry == NULL)

return SCSI_SCAN_NO_RESPONSE;

sdev->vendor = (char *)(sdev->inquiry + 8);

sdev->model = (char *)(sdev->inquiry + 16);

sdev->rev = (char *)(sdev->inquiry + 32);

if (strncmp(sdev->vendor,”ATA “, 8) == 0) {

* sata emulation layer device. This is a hack to work around

* the SATL power management specificationswhich state that

* when the SATL detects the device has goneinto standby

* mode, it shall respond with NOT READY.

sdev->allow_restart = 1;

}

if (*bflags & BLIST_ISROM) {

sdev->type = TYPE_ROM;

sdev->removable = 1;

} else {

sdev->type =(inq_result[0] & 0x1f);

sdev->removable =(inq_result[1] & 0x80) >> 7;

* some devices may respond with wrong type for

* well-known logical units. Force well-knowntype

* to enumerate them correctly.

if(scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {

sdev_printk(KERN_WARNING,sdev,

“%s:correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n”,

__func__,sdev->type, (unsigned int)sdev->lun);

sdev->type =TYPE_WLUN;

}

if (sdev->type == TYPE_RBC ||sdev->type == TYPE_ROM) {

/* RBC and MMC devices can returnSCSI-3 compliance and yet

* still not support REPORT LUNS, so make themact as

* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is

* specifically set */

if ((*bflags &BLIST_REPORTLUN2) == 0)

*bflags |=BLIST_NOREPORTLUN;

}

* For a peripheral qualifier (PQ) value of 1(001b), the SCSI

* spec says: The device server is capable ofsupporting the

* specified peripheral device type on thislogical unit. However,

* the physical device is not currentlyconnected to this logical

* unit.

* The above is vague, as it implies that wecould treat 001 and

* 011 the same. Stay compatible with previouscode, and create a

* scsi_device for a PQ of 1

* Don’t set the device offline here; ratherlet the upper

* level drivers eval the PQ to decide whetherthey should

* attach. So remove ((inq_result[0] >>5) & 7) == 1 check.

sdev->inq_periph_qual =(inq_result[0] >> 5) & 7;

sdev->lockable = sdev->removable;

sdev->soft_reset = (inq_result[7]& 1) && ((inq_result[3] & 7) == 2);

if (sdev->scsi_level >= SCSI_3 ||

(sdev->inquiry_len> 56 && inq_result[56] & 0x04))

sdev->ppr = 1;

if (inq_result[7] & 0x60)

sdev->wdtr = 1;

if (inq_result[7] & 0x10)

sdev->sdtr = 1;

sdev_printk(KERN_NOTICE, sdev, “%s%.8s %.16s %.4s PQ: %d “

“ANSI:%d%s\n”, scsi_device_type(sdev->type),

sdev->vendor,sdev->model, sdev->rev,

sdev->inq_periph_qual,inq_result[2] & 0x07,

(inq_result[3] &0x0f) == 1 ? ” CCS” : “”);

if ((sdev->scsi_level >= SCSI_2)&& (inq_result[7] & 2) &&

!(*bflags & BLIST_NOTQ)) {

sdev->tagged_supported =1;

sdev->simple_tags = 1;

}

* Some devices (Texel CD ROM drives) havehandshaking problems

* when used with the Seagate controllers.borken is initialized

* to 1, and then set it to 0 here.

if ((*bflags & BLIST_BORKEN) == 0)

sdev->borken = 0;

if (*bflags & BLIST_NO_ULD_ATTACH)

sdev->no_uld_attach = 1;

* Apparently some really broken devices(contrary to the SCSI

* standards) need to be selected withoutasserting ATN

if (*bflags & BLIST_SELECT_NO_ATN)

sdev->select_no_atn = 1;

* Maximum 512 sector transfer length

* broken RA4x00 Compaq Disk Array

if (*bflags & BLIST_MAX_512)

blk_queue_max_hw_sectors(sdev->request_queue,512);

* Some devices may not want to have a startcommand automatically

* issued when a device is added.

if (*bflags & BLIST_NOSTARTONADD)

sdev->no_start_on_add = 1;

if (*bflags & BLIST_SINGLELUN)

scsi_target(sdev)->single_lun= 1;

sdev->use_10_for_rw = 1;

if (*bflags &BLIST_MS_SKIP_PAGE_08)

sdev->skip_ms_page_8 = 1;

if (*bflags &BLIST_MS_SKIP_PAGE_3F)

sdev->skip_ms_page_3f = 1;

if (*bflags & BLIST_USE_10_BYTE_MS)

sdev->use_10_for_ms = 1;

/* some devices don’t like REPORTSUPPORTED OPERATION CODES

* and will simply timeout causing sd_mod initto take a very

* very long time */

if (*bflags & BLIST_NO_RSOC)

sdev->no_report_opcodes =1;

/* set the device running here so thatslave configure

* may do I/O */

ret = scsi_device_set_state(sdev,SDEV_RUNNING);

if (ret) {

ret =scsi_device_set_state(sdev, SDEV_BLOCK);

if (ret) {

sdev_printk(KERN_ERR,sdev,

“in wrong state %s to completescan\n”,

scsi_device_state_name(sdev->sdev_state));

returnSCSI_SCAN_NO_RESPONSE;

}

if (*bflags &BLIST_MS_192_BYTES_FOR_3F)

sdev->use_192_bytes_for_3f= 1;

if (*bflags & BLIST_NOT_LOCKABLE)

sdev->lockable = 0;

if (*bflags & BLIST_RETRY_HWERROR)

sdev->retry_hwerror = 1;

if (*bflags & BLIST_NO_DIF)

sdev->no_dif = 1;

sdev->eh_timeout =SCSI_DEFAULT_EH_TIMEOUT;

if (*bflags & BLIST_TRY_VPD_PAGES)

sdev->try_vpd_pages = 1;

else if (*bflags &BLIST_SKIP_VPD_PAGES)

sdev->skip_vpd_pages = 1;

transport_configure_device(&sdev->sdev_gendev);

if(sdev->host->hostt->slave_configure) {

ret =sdev->host->hostt->slave_configure(sdev);

if (ret) {

* if LLDD reports slave not present, don’tclutter

* console with alloc failure messages

if (ret != -ENXIO) {

sdev_printk(KERN_ERR,sdev,

“failedto configure device\n”);

}

returnSCSI_SCAN_NO_RESPONSE;

}

if (sdev->scsi_level >= SCSI_3)

scsi_attach_vpd(sdev);

sdev->max_queue_depth =sdev->queue_depth;

* Ok, the device is now all set up, we can

* register it and tell the rest of the kernel

* about it.

if (!async && scsi_sysfs_add_sdev(sdev)!= 0)

return SCSI_SCAN_NO_RESPONSE;

return SCSI_SCAN_LUN_PRESENT;

}

在scsi_add_lun中主要做的工作是通过SCSI INQUIRY 返回的参数初始化sdev的一些成员，并通过if (!async && scsi_sysfs_add_sdev(sdev) != 0)中的scsi_sysfs_add_sdev向上层注册sdev。

/**

* scsi_sysfs_add_sdev - add scsi device tosysfs

* @sdev: scsi_deviceto add

* Return value:

* 0 onSuccess / non-zero on Failure

**/

intscsi_sysfs_add_sdev(struct scsi_device *sdev)

{

int error, i;

struct request_queue *rq =sdev->request_queue;

struct scsi_target *starget =sdev->sdev_target;

error = scsi_device_set_state(sdev,SDEV_RUNNING);

if (error)

return error;

error = scsi_target_add(starget);

if (error)

return error;

transport_configure_device(&starget->dev);

device_enable_async_suspend(&sdev->sdev_gendev);

scsi_autopm_get_target(starget);

pm_runtime_set_active(&sdev->sdev_gendev);

pm_runtime_forbid(&sdev->sdev_gendev);

pm_runtime_enable(&sdev->sdev_gendev);

scsi_autopm_put_target(starget);

scsi_autopm_get_device(sdev);

error = device_add(&sdev->sdev_gendev);

if (error) {

sdev_printk(KERN_INFO, sdev,

“failedto add device: %d\n”, error);

return error;

}

device_enable_async_suspend(&sdev->sdev_dev);

error =device_add(&sdev->sdev_dev);

if (error) {

sdev_printk(KERN_INFO, sdev,

“failedto add class device: %d\n”, error);

device_del(&sdev->sdev_gendev);

return error;

}

transport_add_device(&sdev->sdev_gendev);

sdev->is_visible = 1;

error = bsg_register_queue(rq,&sdev->sdev_gendev, NULL, NULL);

if (error)

/* we’re treating error onbsg register as non-fatal,

* so pretend nothing went wrong */

sdev_printk(KERN_INFO, sdev,

“Failed to register bsg queue,errno=%d\n”, error);

/* add additional host specificattributes */

if(sdev->host->hostt->sdev_attrs) {

for (i = 0;sdev->host->hostt->sdev_attrs[i]; i++) {

error =device_create_file(&sdev->sdev_gendev,

sdev->host->hostt->sdev_attrs[i]);

if (error)

returnerror;

}

scsi_autopm_put_device(sdev);

return error;

}

通过device_add(sdev-> sdev_gendev)注册scsi middle layer。

int device_add(struct device*dev)

{

struct device *parent = NULL;

struct kobject *kobj;

struct class_interface *class_intf;

int error = -EINVAL;

dev = get_device(dev);

if (!dev)

goto done;

if (!dev->p) {

error =device_private_init(dev);

if (error)

goto done;

}

* for statically allocated devices, whichshould all be converted

* some day, we need to initialize the name. Weprevent reading back

* the name, and force the use of dev_name()

if (dev->init_name) {

dev_set_name(dev,”%s”, dev->init_name);

dev->init_name = NULL;

}

/* subsystems can specify simple deviceenumeration */

if (!dev_name(dev) &&dev->bus && dev->bus->dev_name)

dev_set_name(dev,”%s%u”, dev->bus->dev_name, dev->id);

if (!dev_name(dev)) {

error = -EINVAL;

goto name_error;

}

pr_debug(“device: ‘%s’:%s\n”, dev_name(dev), __func__);

parent = get_device(dev->parent);

kobj = get_device_parent(dev, parent);

if (kobj)

dev->kobj.parent = kobj;

/* use parent numa_node */

if (parent)

set_dev_node(dev,dev_to_node(parent));

/* first, register with generic layer.*/

/* we require the name to be setbefore, and pass NULL */

error = kobject_add(&dev->kobj,dev->kobj.parent, NULL);

if (error)

goto Error;

/* notify platform of device entry */

if (platform_notify)

platform_notify(dev);

error = device_create_file(dev,&dev_attr_uevent);

if (error)

goto attrError;

error = device_add_class_symlinks(dev);

if (error)

goto SymlinkError;

error = device_add_attrs(dev);

if (error)

goto AttrsError;

error = bus_add_device(dev);

if (error)

goto BusError;

error = dpm_sysfs_add(dev);

if (error)

goto DPMError;

device_pm_add(dev);

if (MAJOR(dev->devt)) {

error =device_create_file(dev, &dev_attr_dev);

if (error)

goto DevAttrError;

error =device_create_sys_dev_entry(dev);

if (error)

goto SysEntryError;

devtmpfs_create_node(dev);

}

/* Notify clients of deviceaddition. This call must come

* after dpm_sysfs_add() and beforekobject_uevent().

if (dev->bus)

blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

BUS_NOTIFY_ADD_DEVICE, dev);

kobject_uevent(&dev->kobj,KOBJ_ADD);

bus_probe_device(dev);

if (parent)

klist_add_tail(&dev->p->knode_parent,

&parent->p->klist_children);

if (dev->class) {

mutex_lock(&dev->class->p->mutex);

/* tie the class to thedevice */

klist_add_tail(&dev->knode_class,

&dev->class->p->klist_devices);

/* notify any interfaces thatthe device is here */

list_for_each_entry(class_intf,

&dev->class->p->interfaces,node)

if (class_intf->add_dev)

class_intf->add_dev(dev,class_intf);

mutex_unlock(&dev->class->p->mutex);

}

done:

put_device(dev);

return error;

SysEntryError:

if (MAJOR(dev->devt))

device_remove_file(dev,&dev_attr_dev);

DevAttrError:

device_pm_remove(dev);

dpm_sysfs_remove(dev);

DPMError:

bus_remove_device(dev);

BusError:

device_remove_attrs(dev);

AttrsError:

device_remove_class_symlinks(dev);

SymlinkError:

device_remove_file(dev,&dev_attr_uevent);

attrError:

kobject_uevent(&dev->kobj,KOBJ_REMOVE);

kobject_del(&dev->kobj);

Error:

cleanup_device_parent(dev);

if (parent)

put_device(parent);

name_error:

kfree(dev->p);

dev->p = NULL;

goto done;

}

在device_add中调用了bus_probe_device，为新找到的设备匹配一个driver。

voidbus_probe_device(struct device *dev)

{

struct bus_type *bus = dev->bus;

struct subsys_interface *sif;

int ret;

if (!bus)

return;

if (bus->p->drivers_autoprobe) {

ret = device_attach(dev);

WARN_ON(ret < 0);

}

mutex_lock(&bus->p->mutex);

list_for_each_entry(sif,&bus->p->interfaces, node)

if (sif->add_dev)

sif->add_dev(dev,sif);

mutex_unlock(&bus->p->mutex);

}

匹配过程通过device_attach来实现。

intdevice_attach(struct device *dev)

{

int ret = 0;

device_lock(dev);

if (dev->driver) {

if(klist_node_attached(&dev->p->knode_driver)) {

ret = 1;

goto out_unlock;

}

ret =device_bind_driver(dev);

if (ret == 0)

ret = 1;

else {

dev->driver =NULL;

ret = 0;

}

} else {

ret = bus_for_each_drv(dev->bus, NULL, dev,__device_attach);

pm_request_idle(dev);

}

out_unlock:

device_unlock(dev);

return ret;

}

在match过程中会执行ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);，用bus上的每个drv来匹配dev。具体的匹配函数由__device_attach来实现。

staticint __device_attach(struct device_driver *drv, void *data)

{

struct device *dev = data;

if (!driver_match_device(drv, dev))

return 0;

return driver_probe_device(drv, dev);

}

如果匹配成功，则执行driver_probe_device函数。具体匹配过程自己看driver_match_device.

intdriver_probe_device(struct device_driver *drv, struct device *dev)

{

int ret = 0;

if (!device_is_registered(dev))

return -ENODEV;

pr_debug(“bus: ‘%s’: %s: matcheddevice %s with driver %s\n”,

drv->bus->name, __func__, dev_name(dev),drv->name);

pm_runtime_barrier(dev);

ret = really_probe(dev, drv);

pm_request_idle(dev);

return ret;

}

在driver_probe_device中调用了really_probe;

staticint really_probe(struct device *dev, struct device_driver *drv)

{

int ret = 0;

int local_trigger_count =atomic_read(&deferred_trigger_count);

atomic_inc(&probe_count);

pr_debug(“bus: ‘%s’: %s: probingdriver %s with device %s\n”,

drv->bus->name, __func__, drv->name,dev_name(dev));

WARN_ON(!list_empty(&dev->devres_head));

dev->driver = drv;

/* If using pinctrl, bind pins nowbefore probing */

ret = pinctrl_bind_pins(dev);

if (ret)

goto probe_failed;

if (driver_sysfs_add(dev)) {

printk(KERN_ERR “%s:driver_sysfs_add(%s) failed\n”,

__func__,dev_name(dev));

goto probe_failed;

}

if (dev->bus->probe) {

ret = dev->bus->probe(dev);

if (ret)

goto probe_failed;

} else if (drv->probe) {

ret = drv->probe(dev);

if (ret)

goto probe_failed;

}

driver_bound(dev);

ret = 1;

pr_debug(“bus: ‘%s’: %s: bounddevice %s to driver %s\n”,

drv->bus->name, __func__, dev_name(dev),drv->name);

goto done;

probe_failed:

devres_release_all(dev);

driver_sysfs_remove(dev);

dev->driver = NULL;

dev_set_drvdata(dev, NULL);

if (ret == -EPROBE_DEFER) {

/* Driver requested deferredprobing */

dev_info(dev, “Driver %srequests probe deferral\n”, drv->name);

driver_deferred_probe_add(dev);

/* Did a trigger occur whileprobing? Need to re-trigger if yes */

if (local_trigger_count !=atomic_read(&deferred_trigger_count))

driver_deferred_probe_trigger();

} else if (ret != -ENODEV &&ret != -ENXIO) {

/* driver matched but theprobe failed */

printk(KERN_WARNING

“%s: probe of %s failed with error%d\n”,

drv->name, dev_name(dev), ret);

} else {

pr_debug(“%s: probe of%s rejects match %d\n”,

drv->name, dev_name(dev), ret);

}

* Ignore errors returned by ->probe so thatthe next driver can try

* its luck.

ret = 0;

done:

atomic_dec(&probe_count);

wake_up(&probe_waitqueue);

return ret;

}

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

staticstruct scsi_driver sd_template = {

.gendrv = {

.name = “sd”,

.owner = THIS_MODULE,

.probe = sd_probe,

.remove = sd_remove,

.shutdown = sd_shutdown,

.pm = &sd_pm_ops,

.rescan =sd_rescan,

.init_command = sd_init_command,

.uninit_command = sd_uninit_command,

.done =sd_done,

.eh_action = sd_eh_action,

};

这是由于在sd.c中注册scsi mid layer 的driver。

module_init(init_sd);

staticint __init init_sd(void)

{

int majors = 0, i, err;

SCSI_LOG_HLQUEUE(3,printk(“init_sd: sd driver entry point\n”));

for (i = 0; i < SD_MAJORS; i++) {

if(register_blkdev(sd_major(i), “sd”) != 0)

continue;

majors++;

blk_register_region(sd_major(i),SD_MINORS, NULL,

sd_default_probe, NULL, NULL);

}

if (!majors)

return -ENODEV;

err =class_register(&sd_disk_class);

if (err)

goto err_out;

sd_cdb_cache =kmem_cache_create(“sd_ext_cdb”, SD_EXT_CDB_SIZE,

0, 0, NULL);

if (!sd_cdb_cache) {

printk(KERN_ERR “sd:can’t init extended cdb cache\n”);

err = -ENOMEM;

goto err_out_class;

}

sd_cdb_pool =mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache);

if (!sd_cdb_pool) {

printk(KERN_ERR “sd:can’t init extended cdb pool\n”);

err = -ENOMEM;

goto err_out_cache;

}

err = scsi_register_driver(&sd_template.gendrv);

if (err)

goto err_out_driver;

return 0;

err_out_driver:

mempool_destroy(sd_cdb_pool);

err_out_cache:

kmem_cache_destroy(sd_cdb_cache);

err_out_class:

class_unregister(&sd_disk_class);

err_out:

for (i = 0; i < SD_MAJORS; i++)

unregister_blkdev(sd_major(i),”sd”);

return err;

}

在sd_init中注册了scsi_reigster_driver(&sd_template_gendrv)；这样gendrv就加入到bus上了，当在上面添加设备时，轮询drv时，就找到gendrv与scsi_device匹配，从而调用到sd_probe.

staticint sd_probe(struct device *dev)

{

struct scsi_device *sdp =to_scsi_device(dev);

struct scsi_disk *sdkp;

struct gendisk *gd;

int index;

int error;

scsi_autopm_get_device(sdp);

error = -ENODEV;

if (sdp->type != TYPE_DISK&& sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)

goto out;

SCSI_LOG_HLQUEUE(3,sdev_printk(KERN_INFO, sdp,

“sd_probe\n”));

error = -ENOMEM;

sdkp = kzalloc(sizeof(*sdkp),GFP_KERNEL);

if (!sdkp)

goto out;

gd = alloc_disk(SD_MINORS);

if (!gd)

goto out_free;

do {

if(!ida_pre_get(&sd_index_ida, GFP_KERNEL))

goto out_put;

spin_lock(&sd_index_lock);

error =ida_get_new(&sd_index_ida, &index);

spin_unlock(&sd_index_lock);

} while (error == -EAGAIN);

if (error) {

sdev_printk(KERN_WARNING,sdp, “sd_probe: memory exhausted.\n”);

goto out_put;

}

error =sd_format_disk_name(“sd”, index, gd->disk_name, DISK_NAME_LEN);//得到gd->disk_name by wyf

if (error) {

sdev_printk(KERN_WARNING,sdp, “SCSI disk (sd) name length exceeded.\n”);

goto out_free_index;

}

sdkp->device = sdp;

sdkp->driver = &sd_template;

sdkp->disk = gd;

sdkp->index = index;

atomic_set(&sdkp->openers, 0);

atomic_set(&sdkp->device->ioerr_cnt,0);

if(!sdp->request_queue->rq_timeout) {

if (sdp->type != TYPE_MOD)

blk_queue_rq_timeout(sdp->request_queue,SD_TIMEOUT);

else

blk_queue_rq_timeout(sdp->request_queue,

SD_MOD_TIMEOUT);

}

device_initialize(&sdkp->dev);

sdkp->dev.parent = dev;

sdkp->dev.class =&sd_disk_class;

dev_set_name(&sdkp->dev,”%s”, dev_name(dev));

if (device_add(&sdkp->dev))

goto out_free_index;

get_device(dev);

dev_set_drvdata(dev, sdkp);

get_device(&sdkp->dev); /* prevent release beforeasync_schedule */

async_schedule_domain(sd_probe_async, sdkp,&scsi_sd_probe_domain);

return 0;

out_free_index:

spin_lock(&sd_index_lock);

ida_remove(&sd_index_ida, index);

spin_unlock(&sd_index_lock);

out_put:

put_disk(gd);

out_free:

kfree(sdkp);

out:

scsi_autopm_put_device(sdp);

return error;

}

在sd_probe中先alloc_disk，然后通过sd_probe_async调用add_disk来注册一个scsi-device。

voidadd_disk(struct gendisk *disk)

{

struct backing_dev_info *bdi;

dev_t devt;

int retval;

/* minors == 0 indicates to use extdevt 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);

if (retval) {

WARN_ON(1);

return;

}

disk_to_dev(disk)->devt = devt;

/* ->major and ->first_minoraren’t supposed to be

* dereferenced from here on, but set them justin case.

disk->major = MAJOR(devt);

disk->first_minor = MINOR(devt);

disk_alloc_events(disk);

/* Register BDI before referencing itfrom bdev */

bdi =&disk->queue->backing_dev_info;

bdi_register_dev(bdi, disk_devt(disk));

blk_register_region(disk_devt(disk),disk->minors, NULL,

exact_match, exact_lock, disk);

register_disk(disk);

blk_register_queue(disk);

* Take an extra ref on queue which will be puton disk_release()

* so that it sticks around as long as @disk isthere.

WARN_ON_ONCE(!blk_get_queue(disk->queue));

retval =sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,

“bdi”);

WARN_ON(retval);

disk_add_events(disk);

}

这里面重要的函数有这几个，首先分配一个diskevent(通过disk_alloc_event)，注册一个disk（register_disk(disk)），注册一个queue（blk_reigster_queue(disk)）、添加一个事件（disk_add_events（disk））。其中事件机制是linux通知上层的一种机制，这里不详细阐述。下面来看看如何注册一个disk的。

staticvoid 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, “%s”,disk->disk_name);

/* delay uevents, until we scannedpartition table */

dev_set_uevent_suppress(ddev, 1);

if (device_add(ddev))

return;

if (!sysfs_deprecated) {

err =sysfs_create_link(block_depr, &ddev->kobj,

kobject_name(&ddev->kobj));

if (err) {

device_del(ddev);

return;

}

* avoid probable deadlock caused by allocatingmemory with

* GFP_KERNEL in runtime_resume callback of itsall ancestor

* devices

pm_runtime_set_memalloc_noio(ddev,true);

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_part_scan_enabled(disk))

goto exit;

/* No such device (e.g., media werejust removed) */

if (!get_capacity(disk))

goto exit;

bdev = bdget_disk(disk, 0);

if (!bdev)

goto exit;

bdev->bd_invalidated = 1;

err = blkdev_get(bdev, FMODE_READ,NULL);

if (err < 0)

goto exit;

blkdev_put(bdev, FMODE_READ);

exit:

/* announce disk after possiblepartitions are created */

dev_set_uevent_suppress(ddev, 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);

}

我们看到在register_disk中得到一个block_device块设备。这样scsi层和block_dev层就这样联系在一起了。看看如何得到struct block_device *bdev的。

structblock_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));

disk_put_part(part);

return bdev;

}

调用了bdget(part_devt(part);

structblock_device *bdget(dev_t dev)

{

struct block_device *bdev;

struct inode *inode;

inode = iget5_locked(blockdev_superblock, hash(dev),

bdev_test,bdev_set, &dev);

if (!inode)

return NULL;

bdev = &BDEV_I(inode)->bdev;

if (inode->i_state & I_NEW) {

bdev->bd_contains = NULL;

bdev->bd_super = NULL;

bdev->bd_inode = inode;

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;

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;

}

这里就调用了上层的东东了，居然分配了一个inode，然后通过这个inode得到bdev啦。Tips：inode中有一个block_device指针，同样也存在char_device指针，和网络设备指针。具体参看inode结构体定义。

看看这个inode是怎么创建的把。

structinode *iget5_locked(struct super_block *sb, unsigned long hashval,

int (*test)(struct inode *,void *),

int (*set)(struct inode *,void *), void *data)

{

struct hlist_head *head =inode_hashtable + hash(sb, hashval);

struct inode *inode;

spin_lock(&inode_hash_lock);

inode = find_inode(sb, head, test,data);

spin_unlock(&inode_hash_lock);

if (inode) {

wait_on_inode(inode);

return inode;

}

inode = alloc_inode(sb);

if (inode) {

struct inode *old;

spin_lock(&inode_hash_lock);

/* We released the lock, so..*/

old = find_inode(sb, head,test, data);

if (!old) {

if (set(inode,data))

gotoset_failed;

spin_lock(&inode->i_lock);

inode->i_state =I_NEW;

hlist_add_head(&inode->i_hash,head);

spin_unlock(&inode->i_lock);

inode_sb_list_add(inode);

spin_unlock(&inode_hash_lock);

/* Return the lockedinode with I_NEW set, the

* caller is responsible for filling in thecontents

return inode;

}

* Uhhuh, somebody else created the same inodeunder

* us. Use the old inode instead of the one wejust

* allocated.

spin_unlock(&inode_hash_lock);

destroy_inode(inode);

inode = old;

wait_on_inode(inode);

}

return inode;

set_failed:

spin_unlock(&inode_hash_lock);

destroy_inode(inode);

return NULL;

}

通过调用alloc_inode分配了一个inode。

staticstruct inode *alloc_inode(struct super_block *sb)

{

struct inode *inode;

if (sb->s_op->alloc_inode)

inode = sb->s_op->alloc_inode(sb);

else

inode = kmem_cache_alloc(inode_cachep,GFP_KERNEL);

if (!inode)

return NULL;

if (unlikely(inode_init_always(sb,inode))) {

if(inode->i_sb->s_op->destroy_inode)

inode->i_sb->s_op->destroy_inode(inode);

else

kmem_cache_free(inode_cachep,inode);

return NULL;

}

return inode;

}

这里分配有两个路径，到底走哪个呢？当然走上面的inode啦，如果走下面的inode，通过在inode_cachep中获取一个inode，那么在struct block_device *bdget(dev_t dev)函数中通过bdev =&BDEV_I(inode)->bdev;就得不到bdev啦。那么这个sb->s_op->alloc_inode（sb）哪里来的呢？不要把它当作傻逼了呀，这个就是我们的超级块super block。

一步步返回我们看看sb是从哪里传进来的。

这个sb居然是blockdev_superblock这个东东。

好，既然知道了blockdev_superblock，那么看看在哪里创建的把。

搜索了以下，他就是在bdev_cache_init中创建的。

void__init bdev_cache_init(void)

{

int err;

static struct vfsmount *bd_mnt;

bdev_cachep =kmem_cache_create(“bdev_cache”, sizeof(struct bdev_inode),

0,(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|

SLAB_MEM_SPREAD|SLAB_PANIC),

init_once);

err =register_filesystem(&bd_type);

if (err)

panic(“Cannot registerbdev pseudo-fs”);

bd_mnt = kern_mount(&bd_type);

if (IS_ERR(bd_mnt))

panic(“Cannot createbdev pseudo-fs”);

blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */

}

这里有个bdev_cachep东东，这是内核向开辟了一块缓存，然后我们用到的时候，直接从这里面拿，速度较快。看看究竟是什么东东在这里面取呢？

staticstruct inode *bdev_alloc_inode(struct super_block *sb)

{

struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep,GFP_KERNEL);

if (!ei)

return NULL;

return &ei->vfs_inode;

}

发现我们要的bdev_inode从这里面取到的。还记得我们上面讲到的得到block_device的地方吗？有个bdev =&BDEV_I(inode)->bdev;BDEV_I(inode)先返回的是bdev_inode指针。这个bdev_inode就是在这里分配了。

再往上追，发现bdev_alloc_inode赋给了它。

staticconst struct super_operations bdev_sops = {

.statfs = simple_statfs,

.alloc_inode = bdev_alloc_inode,

.destroy_inode = bdev_destroy_inode,

.drop_inode = generic_delete_inode,

.evict_inode = bdev_evict_inode,

};

好吧，看看那bdev_sops是怎么用的呢？

结果发现，在这里被调用。

回顾__initbdev_cache_init函数，里面先注册了bd_type,register_filesystem（&bd_type）,然后调用了kern_mount(&bd_type);

#definekern_mount(type) kern_mount_data(type,NULL)

structvfsmount *kern_mount_data(structfile_system_type *type, void *data)

{

struct vfsmount *mnt;

mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);

if (!IS_ERR(mnt)) {

* it is a longterm mount, don’t release mntuntil

* we unmount before file sys is unregistered

real_mount(mnt)->mnt_ns =MNT_NS_INTERNAL;

}

return mnt;

}

structvfsmount *

vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void*data)

{

struct mount *mnt;

struct dentry *root;

if (!type)

return ERR_PTR(-ENODEV);

mnt = alloc_vfsmnt(name);

if (!mnt)

return ERR_PTR(-ENOMEM);

if (flags & MS_KERNMOUNT)

mnt->mnt.mnt_flags =MNT_INTERNAL;

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

if (IS_ERR(root)) {

mnt_free_id(mnt);

free_vfsmnt(mnt);

return ERR_CAST(root);

}

mnt->mnt.mnt_root = root;

mnt->mnt.mnt_sb = root->d_sb;

mnt->mnt_mountpoint =mnt->mnt.mnt_root;

mnt->mnt_parent = mnt;

lock_mount_hash();

list_add_tail(&mnt->mnt_instance,&root->d_sb->s_mounts);

unlock_mount_hash();

return &mnt->mnt;

}

structdentry *

mount_fs(struct file_system_type *type, int flags, const char *name, void*data)

{

struct dentry *root;

struct super_block *sb;

char *secdata = NULL;

int error = -ENOMEM;

if (data && !(type->fs_flags& FS_BINARY_MOUNTDATA)) {

secdata = alloc_secdata();

if (!secdata)

goto out;

error = security_sb_copy_data(data,secdata);

if (error)

gotoout_free_secdata;

}

root = type->mount(type, flags, name, data);

if (IS_ERR(root)) {

error = PTR_ERR(root);

goto out_free_secdata;

}

sb = root->d_sb;

BUG_ON(!sb);

WARN_ON(!sb->s_bdi);

WARN_ON(sb->s_bdi ==&default_backing_dev_info);

sb->s_flags |= MS_BORN;

error = security_sb_kern_mount(sb,flags, secdata);

if (error)

goto out_sb;

* filesystems should never set s_maxbyteslarger than MAX_LFS_FILESIZE

* but s_maxbytes was an unsigned long long formany releases. Throw

* this warning for a little while to try andcatch filesystems that

* violate this rule.

WARN((sb->s_maxbytes < 0),”%s set sb->s_maxbytes to “

“negative value(%lld)\n”, type->name, sb->s_maxbytes);

up_write(&sb->s_umount);

free_secdata(secdata);

return root;

out_sb:

dput(root);

deactivate_locked_super(sb);

out_free_secdata:

free_secdata(secdata);

out:

return ERR_PTR(error);

}

这里的type->mount(type, flags, name, data);中的mount就是bd_mount,传进来的bd_type中赋值：

staticstruct file_system_type bd_type = {

.name =”bdev”,

.mount =bd_mount,

.kill_sb = kill_anon_super,

};

staticstruct dentry *bd_mount(struct file_system_type *fs_type,

int flags, const char *dev_name, void*data)

{

return mount_pseudo(fs_type, “bdev:”, &bdev_sops, NULL,BDEVFS_MAGIC);

}

structdentry *mount_pseudo(structfile_system_type *fs_type, char *name,

const struct super_operations *ops,

const struct dentry_operations *dops,unsigned long magic)

{

struct super_block *s;

struct dentry *dentry;

struct inode *root;

struct qstr d_name = QSTR_INIT(name,strlen(name));

s = sget(fs_type, NULL, set_anon_super,MS_NOUSER, NULL);

if (IS_ERR(s))

return ERR_CAST(s);

s->s_maxbytes = MAX_LFS_FILESIZE;

s->s_blocksize = PAGE_SIZE;

s->s_blocksize_bits = PAGE_SHIFT;

s->s_magic = magic;

s->s_op = ops ? ops : &simple_super_operations;

s->s_time_gran = 1;

root = new_inode(s);

if (!root)

goto Enomem;

* since this is the first inode, make itnumber 1. New inodes created

* after this must take care not to collidewith it (by passing

* max_reserved of 1 to iunique).

root->i_ino = 1;

root->i_mode = S_IFDIR | S_IRUSR |S_IWUSR;

root->i_atime = root->i_mtime =root->i_ctime = CURRENT_TIME;

dentry = __d_alloc(s, &d_name);

if (!dentry) {

iput(root);

goto Enomem;

}

d_instantiate(dentry, root);

s->s_root = dentry;

s->s_d_op = dops;

s->s_flags |= MS_ACTIVE;

return dget(s->s_root);

Enomem:

deactivate_locked_super(s);

return ERR_PTR(-ENOMEM);

}

在这里把super_operation bdev_sops的操作赋给了super_block成员的s_op。

到这里我们super_block的super operations有了。

下面来看看bdev_cache_init在哪里调用？

void__init vfs_caches_init(unsigned long mempages)

{

unsigned long reserve;

/* Base hash sizes on available memory,with a reserve equal to

150% of current kernel size */

reserve = min((mempages -nr_free_pages()) * 3/2, mempages - 1);

mempages -= reserve;

names_cachep =kmem_cache_create(“names_cache”, PATH_MAX, 0,

SLAB_HWCACHE_ALIGN|SLAB_PANIC,NULL);

dcache_init();

inode_init();

files_init(mempages);

mnt_init();

bdev_cache_init();

chrdev_init();

}

可以发现在vfs初始化时，调用的bdev_cache_init(),把相关的block_device需要的信息初始化。

阅读全文

0 0