/** * bus_add_driver - Add a driver to the bus. * @drv: driver. * */ int bus_add_driver(struct device_driver * drv) { struct bus_type * bus = get_bus(drv->bus); int error = 0; if (bus) { pr_debug("bus %s: add driver %s\n", bus->name, drv->name); error = kobject_set_name(&drv->kobj, "%s", drv->name); if (error) { put_bus(bus); return error; } drv->kobj.kset = &bus->drivers; if ((error = kobject_register(&drv->kobj))) { put_bus(bus); return error; } driver_attach(drv); klist_add_tail(&drv->knode_bus, &bus->klist_drivers); module_add_driver(drv->owner, drv); driver_add_attrs(bus, drv); add_bind_files(drv); } return error; }
/* Initialize the main sysfs entries for edac: * /sys/devices/system/edac * * and children * * Return: 0 SUCCESS * !0 FAILURE */ static int edac_sysfs_memctrl_setup(void) { int err=0; debugf1("%s()\n", __func__); /* create the /sys/devices/system/edac directory */ err = sysdev_class_register(&edac_class); if (!err) { /* Init the MC's kobject */ memset(&edac_memctrl_kobj, 0, sizeof (edac_memctrl_kobj)); edac_memctrl_kobj.parent = &edac_class.kset.kobj; edac_memctrl_kobj.ktype = &ktype_memctrl; /* generate sysfs "..../edac/mc" */ err = kobject_set_name(&edac_memctrl_kobj,"mc"); if (!err) { /* FIXME: maybe new sysdev_create_subdir() */ err = kobject_register(&edac_memctrl_kobj); if (err) debugf1("Failed to register '.../edac/mc'\n"); else debugf1("Registered '.../edac/mc' kobject\n"); } } else debugf1("%s() error=%d\n", __func__, err); return err; }
int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, struct kobject *parent, const char *fmt, ...) { va_list args; va_start(args, fmt); kobject_set_name_vargs(kobj, fmt, args); va_end(args); kobj->parent = parent; kobj->ktype = ktype; return kobject_register(kobj); }
/** * bus_add_driver - Add a driver to the bus. * @drv: driver. * */ int bus_add_driver(struct device_driver *drv) { struct bus_type * bus = bus_get(drv->bus); int error = 0; if (!bus) return -EINVAL; pr_debug("bus %s: add driver %s\n", bus->name, drv->name); error = kobject_set_name(&drv->kobj, "%s", drv->name); if (error) goto out_put_bus; drv->kobj.kset = &bus->drivers; error = kobject_register(&drv->kobj); if (error) goto out_put_bus; //如果总线支持自动探测,则调用driver_attach。 if (drv->bus->drivers_autoprobe) { error = driver_attach(drv); if (error) goto out_unregister; } //将该驱动程序添加到总线上注册的所有驱动程序的链表中 klist_add_tail(&drv->knode_bus, &bus->klist_drivers); module_add_driver(drv->owner, drv); error = driver_create_file(drv, &driver_attr_uevent); if (error) { printk(KERN_ERR "%s: uevent attr (%s) failed\n", __FUNCTION__, drv->name); } error = driver_add_attrs(bus, drv); if (error) { /* How the hell do we get out of this pickle? Give up */ printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", __FUNCTION__, drv->name); } error = add_bind_files(drv); if (error) { /* Ditto */ printk(KERN_ERR "%s: add_bind_files(%s) failed\n", __FUNCTION__, drv->name); } return error; out_unregister: kobject_unregister(&drv->kobj); out_put_bus: bus_put(bus); return error; }
int rfs_sysfs_create(void) { int rv; rfs_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); if (!rfs_kobj) return -ENOMEM; kobject_init(rfs_kobj); rfs_kobj->ktype = &rfs_kobj_ktype; rfs_kobj->parent = &fs_subsys.kobj; rv = kobject_set_name(rfs_kobj, "%s", "redirfs"); if (rv) { kobject_put(rfs_kobj); return rv; } rv = kobject_register(rfs_kobj); if (rv) { kobject_put(rfs_kobj); return rv; } rv = -ENOMEM; rfs_flt_kset = kzalloc(sizeof(struct kset), GFP_KERNEL); if (!rfs_flt_kset) goto err_kobj; kobject_init(&rfs_flt_kset->kobj); rfs_flt_kset->kobj.ktype = &rfs_kobj_ktype; rfs_flt_kset->kobj.parent = rfs_kobj; rv = kobject_set_name(&rfs_flt_kset->kobj, "%s", "filters"); if (rv) goto err_kset; rv = kset_register(rfs_flt_kset); if (rv) goto err_kset; return 0; err_kset: kset_put(rfs_flt_kset); err_kobj: kobject_unregister(rfs_kobj); return rv; }
static int edd_device_register(struct edd_device *edev, int i) { int error; if (!edev) return 1; memset(edev, 0, sizeof (*edev)); edd_dev_set_info(edev, &edd[i]); snprintf(edev->kobj.name, EDD_DEVICE_NAME_SIZE, "int13_dev%02x", edd[i].device); kobj_set_kset_s(edev,edd_subsys); error = kobject_register(&edev->kobj); if (!error) edd_populate_dir(edev); return error; }
/** * bus_add_driver - Add a driver to the bus. * @drv: driver. * */ int bus_add_driver(struct device_driver *drv) { struct bus_type * bus = get_bus(drv->bus); int error = 0; if (!bus) return 0; pr_debug("bus %s: add driver %s\n", bus->name, drv->name); error = kobject_set_name(&drv->kobj, "%s", drv->name); if (error) goto out_put_bus; drv->kobj.kset = &bus->drivers; if ((error = kobject_register(&drv->kobj))) goto out_put_bus; error = driver_attach(drv); if (error) goto out_unregister; klist_add_tail(&drv->knode_bus, &bus->klist_drivers); module_add_driver(drv->owner, drv); error = driver_add_attrs(bus, drv); if (error) { /* How the hell do we get out of this pickle? Give up */ printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n", __FUNCTION__, drv->name); } error = add_bind_files(drv); if (error) { /* Ditto */ printk(KERN_ERR "%s: add_bind_files(%s) failed\n", __FUNCTION__, drv->name); } return error; out_unregister: kobject_unregister(&drv->kobj); out_put_bus: put_bus(bus); return error; }
int gdlm_kobject_setup(struct gdlm_ls *ls, struct kobject *fskobj) { int error; error = kobject_set_name(&ls->kobj, "%s", "lock_module"); if (error) { log_error("can't set kobj name %d", error); return error; } ls->kobj.kset = &gdlm_kset; ls->kobj.ktype = &gdlm_ktype; ls->kobj.parent = fskobj; error = kobject_register(&ls->kobj); if (error) log_error("can't register kobj %d", error); return error; }
/* * Add entries in sysfs onto the existing network class device * for the bridge. * Adds a attribute group "bridge" containing tuning parameters. * Binary attribute containing the forward table * Sub directory to hold links to interfaces. * * Note: the ifobj exists only to be a subdirectory * to hold links. The ifobj exists in same data structure * as it's parent the bridge so reference counting works. */ int br_sysfs_addbr(struct net_device *dev) { struct kobject *brobj = &dev->class_dev.kobj; struct net_bridge *br = netdev_priv(dev); int err; err = sysfs_create_group(brobj, &bridge_group); if (err) { pr_info("%s: can't create group %s/%s\n", __FUNCTION__, dev->name, bridge_group.name); goto out1; } err = sysfs_create_bin_file(brobj, &bridge_forward); if (err) { pr_info("%s: can't create attribue file %s/%s\n", __FUNCTION__, dev->name, bridge_forward.attr.name); goto out2; } kobject_set_name(&br->ifobj, SYSFS_BRIDGE_PORT_SUBDIR); br->ifobj.ktype = NULL; br->ifobj.kset = NULL; br->ifobj.parent = brobj; err = kobject_register(&br->ifobj); if (err) { pr_info("%s: can't add kobject (directory) %s/%s\n", __FUNCTION__, dev->name, br->ifobj.name); goto out3; } return 0; out3: sysfs_remove_bin_file(&dev->class_dev.kobj, &bridge_forward); out2: sysfs_remove_group(&dev->class_dev.kobj, &bridge_group); out1: return err; }
/* * kernel_param_sysfs_setup - wrapper for built-in params support */ static void __init kernel_param_sysfs_setup(const char *name, struct kernel_param *kparam, unsigned int num_params, unsigned int name_skip) { struct module_kobject *mk; mk = kmalloc(sizeof(struct module_kobject), GFP_KERNEL); memset(mk, 0, sizeof(struct module_kobject)); mk->mod = THIS_MODULE; kobj_set_kset_s(mk, module_subsys); kobject_set_name(&mk->kobj, name); kobject_register(&mk->kobj); /* no need to keep the kobject if no parameter is exported */ if (!param_sysfs_setup(mk, kparam, num_params, name_skip)) { kobject_unregister(&mk->kobj); kfree(mk); } }
int gfs2_sys_fs_add(struct gfs2_sbd *sdp) { int error; sdp->sd_kobj.kset = &gfs2_kset; sdp->sd_kobj.ktype = &gfs2_ktype; error = kobject_set_name(&sdp->sd_kobj, "%s", sdp->sd_table_name); if (error) goto fail; error = kobject_register(&sdp->sd_kobj); if (error) goto fail; error = sysfs_create_group(&sdp->sd_kobj, &lockstruct_group); if (error) goto fail_reg; error = sysfs_create_group(&sdp->sd_kobj, &args_group); if (error) goto fail_lockstruct; error = sysfs_create_group(&sdp->sd_kobj, &tune_group); if (error) goto fail_args; return 0; fail_args: sysfs_remove_group(&sdp->sd_kobj, &args_group); fail_lockstruct: sysfs_remove_group(&sdp->sd_kobj, &lockstruct_group); fail_reg: kobject_unregister(&sdp->sd_kobj); fail: fs_err(sdp, "error %d adding sysfs files", error); return error; }
/** * pdcs_register_pathentries - Prepares path entries kobjects for sysfs usage. * * It creates kobjects corresponding to each path entry with nice sysfs * links to the real device. This is where the magic takes place: when * registering the subsystem attributes during module init, each kobject hereby * created will show in the sysfs tree as a folder containing files as defined * by path_subsys_attr[]. */ static inline int __init pdcs_register_pathentries(void) { unsigned short i; struct pdcspath_entry *entry; int err; /* Initialize the entries rw_lock before anything else */ for (i = 0; (entry = pdcspath_entries[i]); i++) rwlock_init(&entry->rw_lock); for (i = 0; (entry = pdcspath_entries[i]); i++) { write_lock(&entry->rw_lock); err = pdcspath_fetch(entry); write_unlock(&entry->rw_lock); if (err < 0) continue; if ((err = kobject_set_name(&entry->kobj, "%s", entry->name))) return err; kobj_set_kset_s(entry, paths_subsys); if ((err = kobject_register(&entry->kobj))) return err; /* kobject is now registered */ write_lock(&entry->rw_lock); entry->ready = 2; /* Add a nice symlink to the real device */ if (entry->dev) sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device"); write_unlock(&entry->rw_lock); } return 0; }
/** * edac_sysfs_pci_setup() * */ static int edac_sysfs_pci_setup(void) { int err; debugf1("%s()\n", __func__); memset(&edac_pci_kobj, 0, sizeof(edac_pci_kobj)); edac_pci_kobj.parent = &edac_class.kset.kobj; edac_pci_kobj.ktype = &ktype_edac_pci; err = kobject_set_name(&edac_pci_kobj, "pci"); if (!err) { /* Instanstiate the csrow object */ /* FIXME: maybe new sysdev_create_subdir() */ err = kobject_register(&edac_pci_kobj); if (err) debugf1("Failed to register '.../edac/pci'\n"); else debugf1("Registered '.../edac/pci' kobject\n"); } return err; }
/* * Helper function for ibft_register_kobjects. */ static int __init ibft_create_kobject(struct ibft_table_header *header, struct ibft_hdr *hdr, struct list_head *list) { struct ibft_kobject *ibft_kobj = NULL; struct ibft_nic *nic = (struct ibft_nic *)hdr; struct pci_dev *pci_dev; int rc = 0; ibft_kobj = kzalloc(sizeof(*ibft_kobj), GFP_KERNEL); if (!ibft_kobj) return -ENOMEM; ibft_kobj->header = header; ibft_kobj->hdr = hdr; switch (hdr->id) { case id_initiator: rc = ibft_verify_hdr("initiator", hdr, id_initiator, sizeof(*ibft_kobj->initiator)); break; case id_nic: rc = ibft_verify_hdr("ethernet", hdr, id_nic, sizeof(*ibft_kobj->nic)); break; case id_target: rc = ibft_verify_hdr("target", hdr, id_target, sizeof(*ibft_kobj->tgt)); break; case id_reserved: case id_control: case id_extensions: /* Fields which we don't support. Ignore them */ rc = 1; break; default: printk(KERN_ERR "iBFT has unknown structure type (%d). " \ "Report this bug to your vendor!\n", hdr->id); rc = 1; break; } if (rc) { kfree(ibft_kobj); goto out_invalid_struct; } /* kobject fief. We will let the reference counter do the job of deleting its name if we fail here. */ kobj_set_kset_s(ibft_kobj, ibft_subsys); ibft_kobj->kobj.ktype = &ibft_ktype; rc = kobject_set_name(&ibft_kobj->kobj, ibft_id_names[hdr->id], hdr->index); if (rc) goto kobject_do_put; rc = kobject_register(&ibft_kobj->kobj); if (rc) goto kobject_do_put; if (hdr->id == id_nic) { pci_dev = pci_get_bus_and_slot((nic->pci_bdf & 0xff00) >> 8, (nic->pci_bdf & 0xff)); if (pci_dev) { rc = sysfs_create_link(&ibft_kobj->kobj, &pci_dev->dev.kobj, "device"); pci_dev_put(pci_dev); } }