static int __init inv_pthread_init(void) { int retval; status_kobj = kzalloc(sizeof(*status_kobj), GFP_KERNEL); if(!status_kobj) return PTR_ERR(status_kobj); status_kset = kset_create_and_add("platform_status", NULL, kernel_kobj); if(!status_kset) return -1; status_kobj->kset = status_kset; retval = kobject_init_and_add(status_kobj, &status_ktype, NULL, "fan"); if(retval) return retval; retval = sysfs_create_file(status_kobj, &status_att); thread_control_set(1); printk(KERN_INFO "[p_thread] %s/%d: Creating Thread\n",__func__,__LINE__); //Create the kernel thread with name 'inv_pthread' thread_st = kthread_run(thread_fn, (void*)&thread_data, "inv_pthread"); if (thread_st) printk(KERN_INFO "[p_thread] inv_pthread Created successfully\n"); else printk(KERN_ERR "[p_thread] inv_pthread creation failed\n"); return retval; }
static int __init devicemodeldemo_init(void) { printk(KERN_ALERT "DeviceModelDemo: Entry devicemodeldemo_init !\n"); kobject_init_and_add( &dmdkobj, &dmdkobj_type, NULL, "devicemodeldemo" ); return 0; }
int punit_create_sys_info(fw_info_t *fw_info) { int retval = 0; retval = kobject_init_and_add(&fw_info->fw_info_kobj, &ktype, &(THIS_MODULE->mkobj.kobj), "fw_info"); if (retval != 0) printk(KERN_ERR "Kobject create failed: (%s)\n", __FUNCTION__); return retval; }
/* * edac_device_register_sysfs_main_kobj * * perform the high level setup for the new edac_device instance * * Return: 0 SUCCESS * !0 FAILURE */ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev) { struct sysdev_class *edac_class; int err; debugf1("%s()\n", __func__); /* get the /sys/devices/system/edac reference */ edac_class = edac_get_edac_class(); if (edac_class == NULL) { debugf1("%s() no edac_class error\n", __func__); err = -ENODEV; goto err_out; } /* Point to the 'edac_class' this instance 'reports' to */ edac_dev->edac_class = edac_class; /* Init the devices's kobject */ memset(&edac_dev->kobj, 0, sizeof(struct kobject)); /* Record which module 'owns' this control structure * and bump the ref count of the module */ edac_dev->owner = THIS_MODULE; if (!try_module_get(edac_dev->owner)) { err = -ENODEV; goto err_out; } /* register */ err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl, &edac_class->kset.kobj, "%s", edac_dev->name); if (err) { debugf1("%s()Failed to register '.../edac/%s'\n", __func__, edac_dev->name); goto err_kobj_reg; } kobject_uevent(&edac_dev->kobj, KOBJ_ADD); /* At this point, to 'free' the control struct, * edac_device_unregister_sysfs_main_kobj() must be used */ debugf4("%s() Registered '.../edac/%s' kobject\n", __func__, edac_dev->name); return 0; /* Error exit stack */ err_kobj_reg: module_put(edac_dev->owner); err_out: return err; }
/***************************************************************************** *Name : *Description : *Parameter : *Return : *Note : *****************************************************************************/ int add_nand_for_test(struct _nand_phy_partition* phy_partition) { int i; __u32 cur_offset = 0; struct _nftl_blk *nftl_blk; struct _nand_dev *nand_dev; struct _nand_disk* disk; struct _nand_disk* head_disk; struct nand_kobject* nand_kobj; uint16 PartitionNO; PartitionNO = get_partitionNO(phy_partition); nftl_blk = kmalloc(sizeof(struct _nftl_blk), GFP_KERNEL); if (!nftl_blk) { printk("nftl_blk kmalloc fail!\n"); return 1; } nftl_blk->nand = build_nand_partition(phy_partition); if (nftl_initialize(nftl_blk,PartitionNO)) { printk("nftl_initialize failed\n"); return 1; } nftl_blk->blk_lock = kmalloc(sizeof(struct mutex), GFP_KERNEL); if (!nftl_blk->blk_lock) { printk("blk_lock kmalloc fail!\n"); return 1; } mutex_init(nftl_blk->blk_lock); nftl_blk->nftl_thread = kthread_run(nftl_test_thread, nftl_blk, "%sd", "nftl"); if (IS_ERR(nftl_blk->nftl_thread)) { printk("nftl_thread kthread_run fail!\n"); return 1; } add_nftl_blk_list(&nftl_blk_head,nftl_blk); nand_kobj = kzalloc(sizeof(struct nand_kobject), GFP_KERNEL); if (!nand_kobj) { printk("nand_kobj kzalloc fail!\n"); return 1; } nand_kobj->nftl_blk = nftl_blk; if(kobject_init_and_add(&nand_kobj->kobj,&ktype,NULL,"nand_driver%d",PartitionNO) != 0 ) { printk("init nand sysfs fail!\n"); return 1; } return 0; }
static __init int hello_init(void) { int error = kobject_init_and_add(&dirKobj, &dirKtype, kernel_kobj, "%s", DIR_NAME); if (error < 0) return error; return error; }
int gfs_sysfs_init_sb(struct gfs_super_info *sbi) { struct super_block *sb = sbi->s_vfs_sb; int err = 0; BUG_ON(!gfs_kset); sbi->s_kobj.kset = gfs_kset; err = kobject_init_and_add(&sbi->s_kobj, &gfs_ktype, NULL, "%s", sb->s_id); return err; }
/* add 5 attributes to /sys/devices/b0300000.gpu/pvrsrv */ int owl_gpu_fun_add_attr(struct kobject *dev_kobj) { int err=0; err = kobject_init_and_add(&owl_gpu.kobj,&gpu_ktype,dev_kobj,"pvrsrv"); if (err) { printk("failed to create sysfs file\n"); } return err; }
int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev) { struct bus_type *edac_subsys; int err; debugf1("%s()\n", __func__); edac_subsys = edac_get_sysfs_subsys(); if (edac_subsys == NULL) { debugf1("%s() no edac_subsys error\n", __func__); err = -ENODEV; goto err_out; } edac_dev->edac_subsys = edac_subsys; memset(&edac_dev->kobj, 0, sizeof(struct kobject)); edac_dev->owner = THIS_MODULE; if (!try_module_get(edac_dev->owner)) { err = -ENODEV; goto err_mod_get; } err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl, &edac_subsys->dev_root->kobj, "%s", edac_dev->name); if (err) { debugf1("%s()Failed to register '.../edac/%s'\n", __func__, edac_dev->name); goto err_kobj_reg; } kobject_uevent(&edac_dev->kobj, KOBJ_ADD); debugf4("%s() Registered '.../edac/%s' kobject\n", __func__, edac_dev->name); return 0; err_kobj_reg: module_put(edac_dev->owner); err_mod_get: edac_put_sysfs_subsys(); err_out: return err; }
/** * iommu_group_alloc - Allocate a new group * @name: Optional name to associate with group, visible in sysfs * * This function is called by an iommu driver to allocate a new iommu * group. The iommu group represents the minimum granularity of the iommu. * Upon successful return, the caller holds a reference to the supplied * group in order to hold the group until devices are added. Use * iommu_group_put() to release this extra reference count, allowing the * group to be automatically reclaimed once it has no devices or external * references. */ struct iommu_group *iommu_group_alloc(void) { struct iommu_group *group; int ret; group = kzalloc(sizeof(*group), GFP_KERNEL); if (!group) return ERR_PTR(-ENOMEM); group->kobj.kset = iommu_group_kset; mutex_init(&group->mutex); INIT_LIST_HEAD(&group->devices); BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier); mutex_lock(&iommu_group_mutex); again: if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) { kfree(group); mutex_unlock(&iommu_group_mutex); return ERR_PTR(-ENOMEM); } if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id)) goto again; mutex_unlock(&iommu_group_mutex); ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype, NULL, "%d", group->id); if (ret) { mutex_lock(&iommu_group_mutex); ida_remove(&iommu_group_ida, group->id); mutex_unlock(&iommu_group_mutex); kfree(group); return ERR_PTR(ret); } group->devices_kobj = kobject_create_and_add("devices", &group->kobj); if (!group->devices_kobj) { kobject_put(&group->kobj); /* triggers .release & free */ return ERR_PTR(-ENOMEM); } /* * The devices_kobj holds a reference on the group kobject, so * as long as that exists so will the group. We can therefore * use the devices_kobj for reference counting. */ kobject_put(&group->kobj); pr_debug("Allocated group %d\n", group->id); return group; }
void dss_init_overlays(struct platform_device *pdev) { int i, r; num_overlays = dss_feat_get_num_ovls(); overlays = kzalloc(sizeof(struct omap_overlay) * num_overlays, GFP_KERNEL); BUG_ON(overlays == NULL); for (i = 0; i < num_overlays; ++i) { struct omap_overlay *ovl = &overlays[i]; switch (i) { case 0: ovl->name = "gfx"; ovl->id = OMAP_DSS_GFX; break; case 1: ovl->name = "vid1"; ovl->id = OMAP_DSS_VIDEO1; break; case 2: ovl->name = "vid2"; ovl->id = OMAP_DSS_VIDEO2; break; case 3: ovl->name = "vid3"; ovl->id = OMAP_DSS_VIDEO3; break; } ovl->is_enabled = &dss_ovl_is_enabled; ovl->enable = &dss_ovl_enable; ovl->disable = &dss_ovl_disable; ovl->set_manager = &dss_ovl_set_manager; ovl->unset_manager = &dss_ovl_unset_manager; ovl->set_overlay_info = &dss_ovl_set_info; ovl->get_overlay_info = &dss_ovl_get_info; ovl->wait_for_go = &dss_mgr_wait_for_go_ovl; ovl->caps = dss_feat_get_overlay_caps(ovl->id); ovl->supported_modes = dss_feat_get_supported_color_modes(ovl->id); r = kobject_init_and_add(&ovl->kobj, &overlay_ktype, &pdev->dev.kobj, "overlay%d", i); if (r) DSSERR("failed to create sysfs file\n"); } }
/* * edac_device_register_sysfs_main_kobj * * perform the high level setup for the new edac_device instance * * Return: 0 SUCCESS * !0 FAILURE */ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev) { struct bus_type *edac_subsys; int err; edac_dbg(1, "\n"); /* get the /sys/devices/system/edac reference */ edac_subsys = edac_get_sysfs_subsys(); /* Point to the 'edac_subsys' this instance 'reports' to */ edac_dev->edac_subsys = edac_subsys; /* Init the devices's kobject */ memset(&edac_dev->kobj, 0, sizeof(struct kobject)); /* Record which module 'owns' this control structure * and bump the ref count of the module */ edac_dev->owner = THIS_MODULE; if (!try_module_get(edac_dev->owner)) { err = -ENODEV; goto err_out; } /* register */ err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl, &edac_subsys->dev_root->kobj, "%s", edac_dev->name); if (err) { edac_dbg(1, "Failed to register '.../edac/%s'\n", edac_dev->name); goto err_kobj_reg; } kobject_uevent(&edac_dev->kobj, KOBJ_ADD); /* At this point, to 'free' the control struct, * edac_device_unregister_sysfs_main_kobj() must be used */ edac_dbg(4, "Registered '.../edac/%s' kobject\n", edac_dev->name); return 0; /* Error exit stack */ err_kobj_reg: module_put(edac_dev->owner); err_out: return err; }
int kgsl_pwrscale_init(struct kgsl_device *device) { int ret; ret = kobject_init_and_add(&device->pwrscale_kobj, &ktype_pwrscale, &device->dev->kobj, "pwrscale"); if (ret) return ret; kobject_init(&device->pwrscale.kobj, &ktype_pwrscale_policy); return ret; }
int sysaufs_si_init(struct au_sbinfo *sbinfo) { int err; sbinfo->si_kobj.kset = au_kset; /* some people doesn't like to show a pointer in kernel */ err = kobject_init_and_add(&sbinfo->si_kobj, &au_sbi_ktype, NULL/*&au_kset->kobj*/, SysaufsSb_PREFIX "%lx", au_si_mask ^ (unsigned long)sbinfo); AuTraceErr(err); return err; }
int gdlm_kobject_setup(struct gdlm_ls *ls, struct kobject *fskobj) { int error; ls->kobj.kset = gdlm_kset; error = kobject_init_and_add(&ls->kobj, &gdlm_ktype, fskobj, "lock_module"); if (error) log_error("can't register kobj %d", error); kobject_uevent(&ls->kobj, KOBJ_ADD); return error; }
int setup_snapfs_mount_point_mgmt(struct dentry *dentry) { int result; int next_snapfs_mnt_point_number; const int mnt_point_name_length = 30; struct snapfs_mnt_point *mnt_point; next_snapfs_mnt_point_number = snapfs_mnt_point_number + 1; mnt_point = &snapfs_mnt_points[next_snapfs_mnt_point_number]; mnt_point->name = kmalloc(mnt_point_name_length, GFP_KERNEL); if (!mnt_point->name) { printk(KERN_ERR "Can't do kmalloc\n"); return -ENOMEM; } snprintf(mnt_point->name, mnt_point_name_length, "mnt_point_%d", next_snapfs_mnt_point_number); snapfs_mntpoint_ktype.sysfs_ops = snapfs_kobj->ktype->sysfs_ops; result = kobject_init_and_add(&mnt_point->kobj, &snapfs_mntpoint_ktype, snapfs_kobj, mnt_point->name); if (result) { printk(KERN_ERR "Can't init SnapFS mount point KObject\n"); kobject_put(&mnt_point->kobj); return -ENOMEM; } mnt_point->attrs = kmalloc(sizeof(*(mnt_point->attrs)), GFP_KERNEL); if (!mnt_point->attrs) { printk(KERN_ERR "Can't do kmalloc\n"); kfree(mnt_point->name); kobject_put(&mnt_point->kobj); return -ENOMEM; } memset(mnt_point->attrs, 0, sizeof(*mnt_point->attrs)); mnt_point->attrs->attrs = snapfs_mnt_attrs; mnt_point->dentry = dentry; result = sysfs_create_group(&mnt_point->kobj, mnt_point->attrs); if (result) { printk(KERN_ERR "Can't create sysfs group"); kfree(mnt_point->name); kobject_put(&mnt_point->kobj); kfree(mnt_point->attrs); return result; } snapfs_mnt_point_number = next_snapfs_mnt_point_number; return result; }
/** * efivar_create_sysfs_entry - create a new entry in sysfs * @new_var: efivar entry to create * * Returns 0 on success, negative error code on failure */ static int efivar_create_sysfs_entry(struct efivar_entry *new_var) { int i, short_name_size; char *short_name; unsigned long variable_name_size; efi_char16_t *variable_name; int ret; variable_name = new_var->var.VariableName; variable_name_size = ucs2_strlen(variable_name) * sizeof(efi_char16_t); /* * Length of the variable bytes in ASCII, plus the '-' separator, * plus the GUID, plus trailing NUL */ short_name_size = variable_name_size / sizeof(efi_char16_t) + 1 + EFI_VARIABLE_GUID_LEN + 1; short_name = kzalloc(short_name_size, GFP_KERNEL); if (!short_name) return -ENOMEM; /* Convert Unicode to normal chars (assume top bits are 0), ala UTF-8 */ for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) { short_name[i] = variable_name[i] & 0xFF; } /* This is ugly, but necessary to separate one vendor's private variables from another's. */ *(short_name + strlen(short_name)) = '-'; efi_guid_to_str(&new_var->var.VendorGuid, short_name + strlen(short_name)); new_var->kobj.kset = efivars_kset; ret = kobject_init_and_add(&new_var->kobj, &efivar_ktype, NULL, "%s", short_name); kfree(short_name); if (ret) return ret; kobject_uevent(&new_var->kobj, KOBJ_ADD); efivar_entry_add(new_var, &efivar_sysfs_list); return 0; }
int ccci_sysfs_add_modem(struct ccci_modem *md) { int ret; if(!ccci_sys_info) return -CCCI_ERR_SYSFS_NOT_READY; memset(&md->kobj, 0, sizeof(struct kobject)); ret = kobject_init_and_add(&md->kobj, &ccci_md_ktype, &ccci_sys_info->kobj, "MDSYS%d", md->index+1); if (ret < 0) { kobject_put(&md->kobj); CCCI_ERR_MSG(md->index, SYSFS, "fail to add md kobject\n"); } return ret; }
int mem_rns_init() { int status = SUCCESS; #ifdef RNS_SYSFS status = kobject_init_and_add( &mem_kobj, &mem_sys_ktype, &core_kobj, "memory"); if(status) { LOG_ERR("Memory sysfs failure, status=%d", status); return ERR_MEM_INIT_SYSFS; } #endif return status; }
int gb_audio_manager_module_create( struct gb_audio_manager_module **module, struct kset *manager_kset, int id, struct gb_audio_manager_module_descriptor *desc) { int err; struct gb_audio_manager_module *m; m = kzalloc(sizeof(*m), GFP_ATOMIC); if (!m) return -ENOMEM; /* Initialize the node */ INIT_LIST_HEAD(&m->list); /* Set the module id */ m->id = id; /* Copy the provided descriptor */ memcpy(&m->desc, desc, sizeof(*desc)); /* set the kset */ m->kobj.kset = manager_kset; /* * Initialize and add the kobject to the kernel. All the default files * will be created here. As we have already specified a kset for this * kobject, we don't have to set a parent for the kobject, the kobject * will be placed beneath that kset automatically. */ err = kobject_init_and_add(&m->kobj, &gb_audio_module_type, NULL, "%d", id); if (err) { pr_err("failed initializing kobject for audio module #%d\n", id); kobject_put(&m->kobj); return err; } /* * Notify the object was created */ send_add_uevent(m); *module = m; pr_info("Created audio module #%d\n", id); return 0; }
int ttm_bo_global_init(struct drm_global_reference *ref) { struct ttm_bo_global_ref *bo_ref = container_of(ref, struct ttm_bo_global_ref, ref); struct ttm_bo_global *glob = ref->object; int ret; mutex_init(&glob->device_list_mutex); spin_lock_init(&glob->lru_lock); glob->mem_glob = bo_ref->mem_glob; glob->dummy_read_page = alloc_page(__GFP_ZERO | GFP_DMA32); if (unlikely(glob->dummy_read_page == NULL)) { ret = -ENOMEM; goto out_no_drp; } INIT_LIST_HEAD(&glob->swap_lru); INIT_LIST_HEAD(&glob->device_list); ttm_mem_init_shrink(&glob->shrink, ttm_bo_swapout); ret = ttm_mem_register_shrink(glob->mem_glob, &glob->shrink); if (unlikely(ret != 0)) { printk(KERN_ERR TTM_PFX "Could not register buffer object swapout.\n"); goto out_no_shrink; } glob->ttm_bo_extra_size = ttm_round_pot(sizeof(struct ttm_tt)) + ttm_round_pot(sizeof(struct ttm_backend)); glob->ttm_bo_size = glob->ttm_bo_extra_size + ttm_round_pot(sizeof(struct ttm_buffer_object)); atomic_set(&glob->bo_count, 0); ret = kobject_init_and_add( &glob->kobj, &ttm_bo_glob_kobj_type, ttm_get_kobj(), "buffer_objects"); if (unlikely(ret != 0)) kobject_put(&glob->kobj); return ret; out_no_shrink: __free_page(glob->dummy_read_page); out_no_drp: kfree(glob); return ret; }
static struct usb_function *acm_alloc_func(struct usb_function_instance *fi) { struct f_serial_opts *opts; struct f_acm *acm; int ret; acm = kzalloc(sizeof(*acm), GFP_KERNEL); if (!acm) return ERR_PTR(-ENOMEM); spin_lock_init(&acm->lock); acm->port.connect = acm_connect; acm->port.disconnect = acm_disconnect; acm->port.send_break = acm_send_break; acm->port.func.name = "acm"; acm->port.func.strings = acm_strings; /* descriptors are per-instance copies */ acm->port.func.bind = acm_bind; acm->port.func.set_alt = acm_set_alt; acm->port.func.setup = acm_setup; acm->port.func.disable = acm_disable; opts = container_of(fi, struct f_serial_opts, func_inst); acm->port_num = opts->port_num; acm->port.func.unbind = acm_unbind; acm->port.func.free_func = acm_free_func; /* Initialize sysfs defaults */ strcpy(acm->ctrl_string_buf, "CDC Abstract Control Model (ACM)"); strcpy(acm->data_string_buf, "CDC ACM Data"); strcpy(acm->iad_string_buf, "CDC Serial"); acm->iad_proto = USB_CDC_ACM_PROTO_AT_V25TER; acm->ctrl_intf_proto = USB_CDC_ACM_PROTO_AT_V25TER; WARN_ON_ONCE(!fi->fd->parent); ret = kobject_init_and_add(&acm->kobj, &acm_type, fi->fd->parent, "%s%d", "port", acm->port_num); if (ret) { pr_err("%s: Failed to add kobject\n", __func__); kobject_put(&acm->kobj); kfree(acm); return ERR_PTR(-EINVAL); } return &acm->port.func; }
int btrfs_sysfs_add_root(struct btrfs_root *root) { int error; error = kobject_init_and_add(&root->root_kobj, &btrfs_root_ktype, &root->fs_info->super_kobj, "%s", root->name); if (error) goto fail; return 0; fail: printk(KERN_ERR "btrfs: sysfs creation for root failed\n"); return error; }
static int htc_simhotswap_probe(struct platform_device *pdev) { int ret = 0; printk(KERN_INFO"delay work version %s\n",__func__); mutex_init(&htc_hotswap_info.lock); //INIT_WORK(&htc_hotswap_info.hotswap_work, hotswap_work_func); INIT_DELAYED_WORK(&htc_hotswap_info.hotswap_work, hotswap_work_func); htc_hotswap_info.hotswap_wq = create_singlethread_workqueue("htc_simhotswap"); ret = misc_register(&sim_hotswap_misc); if (ret) { pr_err("failed to register misc device!\n"); goto fail; } htc_hotswap_kset = kset_create_and_add("event", NULL, kobject_get(&sim_hotswap_misc.this_device->kobj)); if (!htc_hotswap_kset) { ret = -ENOMEM; goto fail; } htc_hotswap_info.simhotswap_kobj.kset = htc_hotswap_kset; ret = kobject_init_and_add(&htc_hotswap_info.simhotswap_kobj, &htc_hotswap_ktype, NULL, "simhotswap"); if (ret) { kobject_put(&htc_hotswap_info.simhotswap_kobj); goto fail; } oldStatus = gpio_get_value(SIM_DETECT); pr_info("htc_simhotswap_probe(): finish SIM init status=%d\n",oldStatus); ret = request_irq(gpio_to_irq(SIM_DETECT), sim_detect_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "sim_detect", NULL); if (ret) { pr_err("%s:Failed to request irq, ret=%d\n", __func__, ret); } fail: return ret; }
static int kobj_test_init() { printk("kobj test init\n"); printk("kobj->state_initialized=%d\n",kobj.state_initialized); printk("kobj->state_in_sysfs=%d\n",kobj.state_add_uevent_sent); printk("kobj->state_add_uevent_sent=%d\n",kobj.state_remove_uevent_sent); printk("kobj->uevent_suppress=%d\n",kobj.uevent_suppress); printk("kobj->name = %s\n",kobj.name); kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test"); printk("\n\n*******************************\n\n"); printk("kobj->state_initialized=%d\n",kobj.state_initialized); printk("kobj->state_in_sysfs=%d\n",kobj.state_add_uevent_sent); printk("kobj->state_add_uevent_sent=%d\n",kobj.state_remove_uevent_sent); printk("kobj->uevent_suppress=%d\n",kobj.uevent_suppress); printk("kobj->name = %s\n",kobj.name); return 0; }
/** * create_most_dci_obj - allocates a dci object * @parent: parent kobject * * This creates a dci object and registers it with sysfs. * Returns a pointer to the object or NULL when something went wrong. */ static struct most_dci_obj *create_most_dci_obj(struct kobject *parent) { struct most_dci_obj *most_dci = kzalloc(sizeof(*most_dci), GFP_KERNEL); int retval; if (!most_dci) return NULL; retval = kobject_init_and_add(&most_dci->kobj, &most_dci_ktype, parent, "dci"); if (retval) { kobject_put(&most_dci->kobj); return NULL; } return most_dci; }
static int __init boot_mod_init(void) { int ret; /* allocate device major number */ if (alloc_chrdev_region(&boot_dev_num, 0, 1, BOOT_DEV_NAME) < 0) { printk("[%s] fail to register chrdev\n",MOD); return -1; } /* add character driver */ cdev_init(&boot_cdev, &boot_fops); ret = cdev_add(&boot_cdev, boot_dev_num, 1); if (ret < 0) { printk("[%s] fail to add cdev\n",MOD); return ret; } /* create class (device model) */ boot_class = class_create(THIS_MODULE, BOOT_DEV_NAME); if (IS_ERR(boot_class)) { printk("[%s] fail to create class\n",MOD); return (int)boot_class; } boot_device = device_create(boot_class, NULL, boot_dev_num, NULL, BOOT_DEV_NAME); if (IS_ERR(boot_device)) { printk("[%s] fail to create device\n",MOD); return (int)boot_device; } /* add kobject */ ret = kobject_init_and_add(&boot_kobj, &boot_ktype, &(boot_device->kobj), BOOT_SYSFS); if (ret < 0) { printk("[%s] fail to add kobject\n",MOD); return ret; } printk("[%s] chip hw code = 0x%x\n",MOD,get_chip_code()); printk("[%s] chip eco version = 0x%x\n",MOD,get_chip_eco_ver()); /* create proc entry at /proc/boot_mode */ create_proc_read_entry("boot_mode", S_IRUGO, NULL, boot_mode_proc, NULL); return 0; }
int sysaufs_si_init(struct au_sbinfo *sbinfo) { int err; sbinfo->si_kobj.kset = sysaufs_kset; /* cf. sysaufs_name() */ err = kobject_init_and_add (&sbinfo->si_kobj, &au_sbi_ktype, /*&sysaufs_kset->kobj*/NULL, SysaufsSiNamePrefix "%lx", sysaufs_si_id(sbinfo)); dbgaufs_si_null(sbinfo); if (!err) { err = dbgaufs_si_init(sbinfo); if (unlikely(err)) kobject_put(&sbinfo->si_kobj); } return err; }
int __init f2fs_init_sysfs(void) { int ret; kobject_set_name(&f2fs_kset.kobj, "f2fs"); f2fs_kset.kobj.parent = fs_kobj; ret = kset_register(&f2fs_kset); if (ret) return ret; ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype, NULL, "features"); if (ret) kset_unregister(&f2fs_kset); else f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); return ret; }
int kgsl_device_snapshot_init(struct kgsl_device *device) { int ret; struct platform_device *pdev = container_of(device->parentdev, struct platform_device, dev); struct kgsl_device_platform_data *pdata = pdev->dev.platform_data; if (device->snapshot == NULL) { if(pdata->snapshot_address) { device->snapshot = ioremap(pdata->snapshot_address, KGSL_SNAPSHOT_MEMSIZE); PR_DISP_INFO("snapshot created at va %p pa %x\n", device->snapshot, pdata->snapshot_address); } else device->snapshot = kzalloc(KGSL_SNAPSHOT_MEMSIZE, GFP_KERNEL); } if (device->snapshot == NULL) return -ENOMEM; device->snapshot_maxsize = KGSL_SNAPSHOT_MEMSIZE; device->snapshot_timestamp = 0; ret = kobject_init_and_add(&device->snapshot_kobj, &ktype_snapshot, &device->dev->kobj, "snapshot"); if (ret) goto done; ret = sysfs_create_bin_file(&device->snapshot_kobj, &snapshot_attr); if (ret) goto done; ret = sysfs_create_file(&device->snapshot_kobj, &attr_trigger.attr); if (ret) goto done; ret = sysfs_create_file(&device->snapshot_kobj, &attr_timestamp.attr); if (ret) goto done; ret = sysfs_create_file(&device->snapshot_kobj, &attr_no_panic.attr); done: return ret; }