自学教程：C++ sysfs_create_file函数代码示例

/* * Add sysfs entries to ethernet device added to a bridge. * Creates a brport subdirectory with bridge attributes. * Puts symlink in bridge's brif subdirectory */int br_sysfs_addif(struct net_bridge_port *p) {  struct net_bridge *br = p->br;  const struct brport_attribute **a;  int err;  err = sysfs_create_link(&p->kobj, &br->dev->dev.kobj,                          SYSFS_BRIDGE_PORT_LINK);  if (err) {    return err;  }  for (a = brport_attrs; *a; ++a) {    err = sysfs_create_file(&p->kobj, &((*a)->attr));    if (err) {      return err;    }  }  strlcpy(p->sysfs_name, p->dev->name, IFNAMSIZ);  return sysfs_create_link(br->ifobj, &p->kobj, p->sysfs_name);}

/*! * This is the probe routine for the lp_mode driver. * * @param   pdev   The platform device structure * * @return         The function returns 0 on success * */static int __devinit mx37_lpmode_probe(struct platform_device *pdev){	u32 res = 0;	lpmode_dev = &pdev->dev;	res = sysfs_create_file(&lpmode_dev->kobj, &dev_attr_lp_modes.attr);	if (res) {		printk(KERN_ERR		       "lpmode_dev: Unable to register sysdev entry for lpmode_dev");		return res;	}	if (res != 0) {		printk(KERN_ERR "lpmode_dev: Unable to start");		return res;	}	lp_video_mode = 0;	lp_audio_mode = 0;	return 0;}

static int display_sysfs_init(void){	int ret ;	printk(KERN_INFO "display_sysfs_init : kobject_create_and_add/n");	android_display = kobject_create_and_add("android_display", NULL);	if (android_display == NULL) {		printk(KERN_INFO "display_sysfs_init: subsystem_register " /		"failed/n");		ret = -ENOMEM;		return ret ;	}	printk(KERN_INFO "display_sysfs_init : sysfs_create_file/n");	ret = sysfs_create_file(android_display, &dev_attr_panel.attr);	if (ret) {		printk(KERN_INFO "display_sysfs_init : sysfs_create_file " /		"failed/n");		kobject_del(android_display);	}	return 0 ;}

static int cam_get_awb_cal(void){	int ret ;	/* Create /sys/android_camera_awb_cal/awb_cal */	cam_awb_cal = kobject_create_and_add("android_camera_awb_cal", NULL);	if (cam_awb_cal == NULL) {		pr_info("cam_get_awb_cal: subsystem_register failed/n");		ret = -ENOMEM;		return ret ;	}   /* dev_attr_[register_name]<== DEVICE_ATTR(awb_cal, 0444,   awb_calibration_show, NULL); */	ret = sysfs_create_file(cam_awb_cal, &dev_attr_awb_cal.attr);	if (ret) {		pr_info("cam_get_awb_cal:: sysfs_create_file failed/n");		kobject_del(cam_awb_cal);	}	return 0 ;}

static int s5k6a2ya_sysfs_init(void){	int ret ;	pr_info("s5k6a2ya:kobject creat and add/n");	android_s5k6a2ya = kobject_create_and_add("android_camera2", NULL);	if (android_s5k6a2ya == NULL) {		pr_info("s5k6a2ya_sysfs_init: subsystem_register " /		"failed/n");		ret = -ENOMEM;		return ret ;	}	pr_info("s5k6a2ya:sysfs_create_file/n");	ret = sysfs_create_file(android_s5k6a2ya, &dev_attr_sensor.attr);	if (ret) {		pr_info("s5k6a2ya_sysfs_init: sysfs_create_file " /		"failed/n");		kobject_del(android_s5k6a2ya);	}	return 0 ;}

int __init exynos_powermode_init(void){	store_boot_cpu_info();	if (IS_ENABLED(CONFIG_CPU_IDLE_EXYNOS))		exynos_idle_clock_down(true);	init_cpd_state_mask();	exynos_lpm_dt_init();	exynos_pmu_cal_sys_init();	if (sysfs_create_file(power_kobj, &lpc_attribute.attr))		pr_err("%s: failed to create sysfs to control LPC/n", __func__);#ifdef CONFIG_ARM_EXYNOS_SMP_CPUFREQ	disable_c3_idle = exynos_disable_cluster_power_down;#endif	return 0;}

static int __init coresight_sysfs_init(void){	int ret;	coresight.modulekobj = kset_find_obj(module_kset, KBUILD_MODNAME);	if (!coresight.modulekobj) {		pr_err("failed to find CORESIGHT sysfs module kobject/n");		ret = -ENOENT;		goto err;	}	ret = sysfs_create_file(coresight.modulekobj, &max_clk_attr.attr);	if (ret) {		pr_err("failed to create CORESIGHT sysfs max_clk attribute/n");		goto err;	}	return 0;err:	return ret;}

static int edac_device_add_main_sysfs_attributes(			struct edac_device_ctl_info *edac_dev){	struct edac_dev_sysfs_attribute *sysfs_attrib;	int err = 0;	sysfs_attrib = edac_dev->sysfs_attributes;	if (sysfs_attrib) {		while (sysfs_attrib->attr.name != NULL) {			err = sysfs_create_file(&edac_dev->kobj,				(struct attribute*) sysfs_attrib);			if (err)				goto err_out;			sysfs_attrib++;		}	}err_out:	return err;}

static int __init cpufreq_stats_init(void){	int ret;	unsigned int cpu;	spin_lock_init(&cpufreq_stats_lock);	ret = cpufreq_register_notifier(&notifier_policy_block,				CPUFREQ_POLICY_NOTIFIER);	if (ret)		return ret;	register_hotcpu_notifier(&cpufreq_stat_cpu_notifier);	for_each_online_cpu(cpu)		cpufreq_update_policy(cpu);	ret = cpufreq_register_notifier(&notifier_trans_block,				CPUFREQ_TRANSITION_NOTIFIER);	if (ret) {		cpufreq_unregister_notifier(&notifier_policy_block,				CPUFREQ_POLICY_NOTIFIER);		unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);		for_each_online_cpu(cpu)			cpufreq_stats_free_table(cpu);		return ret;	}	create_all_freq_table();	for_each_possible_cpu(cpu) {		cpufreq_allstats_create(cpu);	}	if (all_freq_table && all_freq_table->freq_table)		sort(all_freq_table->freq_table, all_freq_table->table_size,				sizeof(unsigned int), &compare_for_sort, NULL);	ret = sysfs_create_file(cpufreq_global_kobject,			&_attr_all_time_in_state.attr);	if (ret)		pr_warn("Error creating sysfs file for cpufreq stats/n");	return 0;}

static int rmi4_f54_create_sysfs_files(struct rmi4_function_device *fdev,				       bool create){	int i;	int err = 0;	for (i = 0; i < ARRAY_SIZE(rmi4_f54_attrs); i++) {		if (create)			err = sysfs_create_file(&fdev->dev.kobj,						&rmi4_f54_attrs[i].attr);		else			sysfs_remove_file(&fdev->dev.kobj,					  &rmi4_f54_attrs[i].attr);		if (err) {			dev_err(&fdev->dev, "Failed to create sysfs files/n");			goto fail;		}	}	if (create) {		err = sysfs_create_bin_file(&fdev->dev.kobj,					    &rmi4_f54_rep_data);		if (err) {			dev_err(&fdev->dev,				"Failed to create binary sysfs files/n");			goto fail;		}	} else {		sysfs_remove_bin_file(&fdev->dev.kobj, &rmi4_f54_rep_data);	}	return err;fail:	for (i--; i >= 0; i--)		sysfs_remove_file(&fdev->dev.kobj,				  &rmi4_f54_attrs[i].attr);	return err;}

void mt_idle_init(void){    int err = 0;        idle_info("[%s]entry!!/n", __func__);    arm_pm_idle = arch_idle;#ifndef SPM_SODI_ENABLED    idle_switch[IDLE_TYPE_SO] = 0;#endif    //92 deepidle keep use xgpt    err = request_gpt(GPT4, GPT_ONE_SHOT, GPT_CLK_SRC_SYS, GPT_CLK_DIV_1,                 0, NULL, GPT_NOAUTOEN);    if (err) {        idle_info("[%s]fail to request GPT4/n", __func__);    }    err = cpu_xgpt_register_timer(0,NULL);    err |= cpu_xgpt_register_timer(1,NULL);    err |= cpu_xgpt_register_timer(2,NULL);    err |= cpu_xgpt_register_timer(3,NULL);    err |= cpu_xgpt_register_timer(4,NULL);    err |= cpu_xgpt_register_timer(5,NULL);    err |= cpu_xgpt_register_timer(6,NULL);    err |= cpu_xgpt_register_timer(7,NULL);    if (err) {        idle_info("[%s]fail to request cpuxgpt/n", __func__);    }        err = sysfs_create_file(power_kobj, &idle_state_attr.attr);#ifdef SPM_SODI_ENABLED    err |= sysfs_create_file(power_kobj, &soidle_state_attr.attr);#endif#ifdef SPM_MCDI_FUNC    err |= sysfs_create_file(power_kobj, &mcidle_state_attr.attr);#endif    err |= sysfs_create_file(power_kobj, &dpidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &slidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &rgidle_state_attr.attr);    if (err) {        idle_err("[%s]: fail to create sysfs/n", __func__);    }}

static int imx219_sysfs_init(void){	int ret ;	pr_info("%s: imx219:kobject creat and add/n", __func__);	android_imx219 = kobject_create_and_add("android_camera", NULL);	if (android_imx219 == NULL) {		pr_info("imx219_sysfs_init: subsystem_register " /		"failed/n");		ret = -ENOMEM;		return ret ;	}	pr_info("imx219:sysfs_create_file/n");	ret = sysfs_create_file(android_imx219, &dev_attr_sensor.attr);	if (ret) {		pr_info("imx219_sysfs_init: sysfs_create_file " /		"failed/n");		kobject_del(android_imx219);	}	return 0 ;}

static int __init mntest_init(void){	int ret;#ifdef SYSFS_ATTR_CREATE	/*	 * Create a simple kobject with the name of "mntest",	 * located under /sys/kernel/	 **/	mntest_kobj = kobject_create_and_add("mntest", kernel_kobj);	if (!mntest_kobj)		return -ENOMEM;	ret = sysfs_create_file(mntest_kobj, &test_value_attribute);	if (ret)		kobject_put(mntest_kobj);#endif	printk("%s:%d/n", __func__, __LINE__);	return ret;}

static int create_test_nodes(int size, struct kobject *parent_kobj){    int i, j;    int retval = 0;    char *name;    //struct attribute *temp_attr;    //char test_mode[][DEVNAME_SIZE] = {"DATA_READ", "DATA_WRITE", "CMD"};    //int test_mode_count = sizeof(test_mode)/sizeof(test_mode[0]);        test_attrs = kzalloc(TEST_MODE_COUNT * size * sizeof(struct attribute*), GFP_KERNEL);    test_kattr = kzalloc(TEST_MODE_COUNT * size * sizeof(struct kobj_attribute*), GFP_KERNEL);        tmode_kobj = kzalloc(size * sizeof(struct kobject*), GFP_KERNEL);    for(i=0; i<size; i++){        name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);        sprintf(name, "%d", i);        tmode_kobj[i] = kobject_create_and_add(name, parent_kobj);        if (tmode_kobj[i] == NULL)            return -ENOMEM;        for(j=0; j<TEST_MODE_COUNT; j++){                test_attrs[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct attribute), GFP_KERNEL);            test_kattr[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL);            name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);            sprintf(name, "%s", test_mode[j]);            test_attrs[i*TEST_MODE_COUNT+j]->name = name;            test_attrs[i*TEST_MODE_COUNT+j]->mode = 0777;            test_kattr[i*TEST_MODE_COUNT+j]->attr = *test_attrs[i*TEST_MODE_COUNT+j];//*temp_attr;            test_kattr[i*TEST_MODE_COUNT+j]->show = test_show;            test_kattr[i*TEST_MODE_COUNT+j]->store = test_store;            //test_attrs[i*TEST_MODE_COUNT+j] = &test_kattr[i*TEST_MODE_COUNT+j]->attr;            retval = sysfs_create_file(tmode_kobj[i], &test_kattr[i*TEST_MODE_COUNT+j]->attr);            if (retval)                kobject_put(tmode_kobj[i]);                    }    }    return 0;}

int init_module(void){	int ret;	ProcBuffer = vmalloc(sizeof(char)*MAXDATASIZE);	if(ProcBuffer == NULL) {		return -ENOMEM;	}	memset(ProcBuffer,0,sizeof(char)*MAXDATASIZE);	WritingLength = 0;	/* Procfs setting *//*	if( (proc_mtd = create_proc_entry("htc_monitor", 0444, NULL)) ) {		proc_mtd->proc_fops = &log_proc_ops;	}*/	proc_mtd = proc_create_data("htc_monitor", 0444, NULL, &log_proc_ops, NULL);	if (proc_mtd == NULL) {		pr_info("proc_create_data is null/n");	}	/* Attribute file setting */	htc_monitor_status_obj = kobject_create_and_add("htc_monitor_status", NULL);	if (htc_monitor_status_obj == NULL) {		pr_info("kobject_create_and_add: htc_monitor_status failed/n");                return -EFAULT;	}	ret = sysfs_create_file(htc_monitor_status_obj,             &dev_attr_htc_monitor_param.attr);        if (ret) {                pr_info("sysfs_create_file: dev_attr_htc_monitor_param failed/n");                return -EFAULT;        }	return 0;}

static int __init enhance_init(void){	int retval;	int attr_count = 0;	enhance__kobj = kobject_create_and_add("lcd_enhance", kernel_kobj);	if (!enhance__kobj)		return -ENOMEM;	/* Create the files associated with this kobject */	for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) {				if(!zte_enhance_val.en_colortmp && (attr_count == 1))			continue;			retval = sysfs_create_file(enhance__kobj, &attrs[attr_count].attr);		if (retval < 0) {			pr_err("%s: Failed to create sysfs attributes/n", __func__);			goto err_sys;		}	}		pr_info("lcd: %s Done./n",__func__);	return retval;	err_sys:	for (attr_count--; attr_count >= 0; attr_count--) {		sysfs_remove_file(enhance__kobj, &attrs[attr_count].attr);	}		kobject_put(enhance__kobj);		pr_info("lcd: %s init ERR./n",__func__);	return retval;}

/* Module registration */static int __init phonet_init(void){	int err;#ifdef ACTIVATE_PHONET_DEBUG	err = sysfs_create_file(kernel_kobj, &phonet_attr.attr);	if (err)		printk(KERN_DEBUG "phonet sysfs_create_file failed: %d/n", err);#endif	err = phonet_device_init();	if (err)		return err;	pn_sock_init();	err = sock_register(&phonet_proto_family);	if (err) {		printk(KERN_ALERT			"phonet protocol family initialization failed/n");		goto err_sock;	}	dev_add_pack(&phonet_packet_type);	phonet_sysctl_init();	err = isi_register();	if (err)		goto err;	return 0;err:	phonet_sysctl_exit();	sock_unregister(PF_PHONET);	dev_remove_pack(&phonet_packet_type);err_sock:	phonet_device_exit();	return err;}

static int cap_ts_vkeys_init(void){	int rc,i;	struct kobject * cap_ts_properties_kobj=NULL;	cap_ts_properties_kobj = kobject_create_and_add("board_properties", NULL);	if (cap_ts_properties_kobj == NULL) {		printk("%s: subsystem_register failed/n", __func__);		rc = -ENOMEM;		return rc;	}	android_touch_kobj = cap_ts_properties_kobj;	for ( i=0; i < ARRAY_SIZE(cap_ts_device_attr); i++ ){		rc = sysfs_create_file(cap_ts_properties_kobj, &cap_ts_device_attr[i].attr);		if (rc) {			printk("%s: sysfs_create_file failed/n", __func__);			return rc;		}	}	return 0;}

static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,			      char *_name, struct kobject *_kobj,			      ssize_t (*show)(struct device *dev,					      struct device_attribute *attr,					      char *buf),			      ssize_t (*store)(struct device *dev,					       struct device_attribute *attr,					       const char *buf, size_t count)			      ){	int ret = 0;	struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;	vdentry->ctx = _ctx;	vdentry->dentry.show = show;	vdentry->dentry.store = store;	sysfs_attr_init(&vdentry->dentry.attr);	vdentry->dentry.attr.name = vdentry->name;	vdentry->dentry.attr.mode = 0;	vdentry->kobj = _kobj;	snprintf(vdentry->name, 15, "%s", _name);	if (vdentry->dentry.store)		vdentry->dentry.attr.mode |= S_IWUSR;	if (vdentry->dentry.show)		vdentry->dentry.attr.mode |= S_IRUGO;	ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);	if (ret) {		pr_err("failed to create %s/n", vdentry->dentry.attr.name);		vdentry->ctx = NULL;		return ret;	}	return ret;}

static int __init edac_init_mce_inject(void){	struct sysdev_class *edac_class = NULL;	int i, err = 0;	edac_class = edac_get_sysfs_class();	if (!edac_class)		return -EINVAL;	mce_kobj = kobject_create_and_add("mce", &edac_class->kset.kobj);	if (!mce_kobj) {		printk(KERN_ERR "Error creating a mce kset./n");		err = -ENOMEM;		goto err_mce_kobj;	}	for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) {		err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr);		if (err) {			printk(KERN_ERR "Error creating %s in sysfs./n",					sysfs_attrs[i]->attr.name);			goto err_sysfs_create;		}	}	return 0;err_sysfs_create:	while (--i >= 0)		sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);	kobject_del(mce_kobj);err_mce_kobj:	edac_put_sysfs_class();	return err;}

static int create_stage1_nodes(int size, struct kobject *parent_kobj){    #define NODE_COUNT (TOTAL_STAGE1_NODE_COUNT)    int i, j;    int retval = 0;    char *name;    stage1_attrs = kzalloc(NODE_COUNT * size * sizeof(struct attribute*), GFP_KERNEL);    stage1_kattr = kzalloc(NODE_COUNT * size * sizeof(struct kobj_attribute*), GFP_KERNEL);        s1_host_kobj = kzalloc(size * sizeof(struct kobject*), GFP_KERNEL);    for(i=0; i<size; i++){        name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);        sprintf(name, "%d", i);        s1_host_kobj[i] = kobject_create_and_add(name, parent_kobj);        if (s1_host_kobj[i] == NULL)            return -ENOMEM;        for(j=0; j<NODE_COUNT; j++){                stage1_attrs[i*NODE_COUNT+j] = kzalloc(sizeof(struct attribute), GFP_KERNEL);            stage1_kattr[i*NODE_COUNT+j] = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL);            //name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);            //sprintf(name, "%s", args_type[j]);            stage1_attrs[i*NODE_COUNT+j]->name = stage1_nodes[j];            stage1_attrs[i*NODE_COUNT+j]->mode = 0660;            stage1_kattr[i*NODE_COUNT+j]->attr = *stage1_attrs[i*NODE_COUNT+j];//*temp_attr;            stage1_kattr[i*NODE_COUNT+j]->show = stage1_show;            stage1_kattr[i*NODE_COUNT+j]->store = stage1_store;            sysfs_attr_init(&stage1_kattr[i*NODE_COUNT+j]->attr);            retval = sysfs_create_file(s1_host_kobj[i], &stage1_kattr[i*NODE_COUNT+j]->attr);            if (retval)                kobject_put(s1_host_kobj[i]);        }    }    p_autok_thread_data->is_autok_done = kzalloc(sizeof(u8)*size, GFP_KERNEL);    cur_voltage = kzalloc(sizeof(u32)*size, GFP_KERNEL);    p_single_autok = kzalloc(sizeof(struct autok_predata)*size, GFP_KERNEL);    return 0;}

static int __devinit mipi_nt35510_lcd_probe(struct platform_device *pdev){	struct platform_device *msm_fb_pdev;	struct lcd_device *lcd_device;	int ret;	DPRINT("%s/n", __func__);	if (pdev->id == 0) {		mipi_nt35510_pdata = pdev->dev.platform_data;		return 0;	}	/*	 * save returned struct platform_device pointer	 * as we later need to get msm_fb_data_type	 */	msm_fb_pdev = msm_fb_add_device(pdev);	/* struct lcd_device now has needed platform data */	lcd_device = lcd_device_register("panel", &pdev->dev,					 platform_get_drvdata(msm_fb_pdev),					 &mipi_lcd_props);	if (IS_ERR(lcd_device)) {		ret = PTR_ERR(lcd_device);		printk(KERN_ERR "lcd : failed to register device/n");		return ret;	}	ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr);	if (ret)		printk(KERN_ERR "sysfs create fail - %s/n",		       dev_attr_lcd_type.attr.name);	return 0;}

int sysfs_add_meshif(struct net_device *dev){    struct kobject *batif_kobject = &dev->dev.kobj;    struct bat_priv *bat_priv = netdev_priv(dev);    struct bat_attribute **bat_attr;    int err;    bat_priv->mesh_obj = kobject_create_and_add(SYSFS_IF_MESH_SUBDIR,                         batif_kobject);    if (!bat_priv->mesh_obj) {        bat_err(dev, "Can't add sysfs directory: %s/%s/n", dev->name,                SYSFS_IF_MESH_SUBDIR);        goto out;    }    for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr) {        err = sysfs_create_file(bat_priv->mesh_obj,                                &((*bat_attr)->attr));        if (err) {            bat_err(dev, "Can't add sysfs file: %s/%s/%s/n",                    dev->name, SYSFS_IF_MESH_SUBDIR,                    ((*bat_attr)->attr).name);            goto rem_attr;        }    }    return 0;rem_attr:    for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr)        sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));    kobject_put(bat_priv->mesh_obj);    bat_priv->mesh_obj = NULL;out:    return -ENOMEM;}

void mt_idle_init(void){    int err = 0;    int i = 0;    CHIP_SW_VER ver=mt_get_chip_sw_ver();    if(CHIP_SW_VER_02<=ver)    {        memcpy(idle_switch,idle_switch_E2,sizeof(idle_switch));        //return;//TODO,for E2 default off arch_idle    }    idle_info("[%s]entry!!/n", __func__);    arm_pm_idle = arch_idle;    err = request_gpt(idle_gpt, GPT_ONE_SHOT, GPT_CLK_SRC_SYS, GPT_CLK_DIV_1,                0, NULL, GPT_NOAUTOEN);    if (err) {        idle_info("[%s]fail to request GPT%d/n", __func__,idle_gpt+1);    }    err = 0;    for(i=0;i<NR_CPUS;i++){        err |= cpu_xgpt_register_timer(i,NULL);    }    if (err) {        idle_info("[%s]fail to request cpuxgpt/n", __func__);    }    err = sysfs_create_file(power_kobj, &idle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &soidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &mcidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &dpidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &slidle_state_attr.attr);    err |= sysfs_create_file(power_kobj, &rgidle_state_attr.attr);    if (err) {        idle_err("[%s]: fail to create sysfs/n", __func__);    }}

/* * edac_device_add_main_sysfs_attributes *	add some attributes to this instance's main kobject */static int edac_device_add_main_sysfs_attributes(			struct edac_device_ctl_info *edac_dev){	struct edac_dev_sysfs_attribute *sysfs_attrib;	int err = 0;	sysfs_attrib = edac_dev->sysfs_attributes;	if (sysfs_attrib) {		/* iterate over the array and create an attribute for each		 * entry in the list		 */		while (sysfs_attrib->attr.name != NULL) {			err = sysfs_create_file(&edac_dev->kobj,				(struct attribute*) sysfs_attrib);			if (err)				goto err_out;			sysfs_attrib++;		}	}err_out:	return err;}