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

static int init_rttest(void){	int ret, i;	spin_lock_init(&rttest_lock);	for (i = 0; i < MAX_RT_TEST_MUTEXES; i++)		rt_mutex_init(&mutexes[i]);	ret = sysdev_class_register(&rttest_sysclass);	if (ret)		return ret;	for (i = 0; i < MAX_RT_TEST_THREADS; i++) {		ret = init_test_thread(i);		if (ret)			break;		ret = sysdev_create_file(&thread_data[i].sysdev, &attr_status);		if (ret)			break;		ret = sysdev_create_file(&thread_data[i].sysdev, &attr_command);		if (ret)			break;	}	printk("Initializing RT-Tester: %s/n", ret ? "Failed" : "OK" );	return ret;}

static int __init omap_battery_init_devicefs(void){	const struct archos_charge_config *charge_cfg;	int ret;	sysdev_class_register(&omap_battery_sysclass);		ret = sysdev_register(&omap_battery0_device);	if (ret < 0)		return ret;#ifdef CONFIG_POWER_SUPPLY	ret = platform_device_register(&archos_battery_device);	if (ret < 0) {		printk(KERN_INFO "omap_battery_init_devicefs: failed to register battery device/n");		return ret;	}#endif	sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_state);	sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_level);	sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_usblevel);	/* charge pin */	charge_cfg = omap_get_config( ARCHOS_TAG_CHARGE, struct archos_charge_config );	if (charge_cfg && (hardware_rev < charge_cfg->nrev)) {		charge_gpio = charge_cfg->rev[hardware_rev];		GPIO_INIT_OUTPUT( charge_gpio );		omap_set_gpio_dataout( GPIO_PIN( charge_gpio ), 1);		} else		printk(KERN_DEBUG "omap_battery_init_devicefs: no board configuration found/n");		return 0;}

int dma_create_sysfs_files(struct dma_channel *chan, struct dma_info *info){	struct sys_device *dev = &chan->dev;	char name[16];	int ret;	dev->id  = chan->vchan;	dev->cls = &dma_sysclass;	ret = sysdev_register(dev);	if (ret)		return ret;	ret |= sysdev_create_file(dev, &attr_dev_id);	ret |= sysdev_create_file(dev, &attr_count);	ret |= sysdev_create_file(dev, &attr_mode);	ret |= sysdev_create_file(dev, &attr_flags);	ret |= sysdev_create_file(dev, &attr_config);	if (unlikely(ret)) {		dev_err(&info->pdev->dev, "Failed creating attrs/n");		return ret;	}	snprintf(name, sizeof(name), "dma%d", chan->chan);	return sysfs_create_link(&info->pdev->dev.kobj, &dev->kobj, name);}

static int dvfs_sysdev_ctrl_init(void){	int err;	err = sysdev_class_register(&dvfs_sysclass);	if (!err)		err = sysdev_register(&dvfs_device);	if (!err) {		err = sysdev_create_file(&dvfs_device, &attr_enable);		err = sysdev_create_file(&dvfs_device, &attr_status);	}	return err;}

/* * register_node - Setup a driverfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */int __init register_node(struct node *node, int num, struct node *parent){	int error;	node->cpumap = node_to_cpumask(num);	node->sysdev.id = num;	node->sysdev.cls = &node_class;	error = sys_device_register(&node->sysdev);	if (!error){		sysdev_create_file(&node->sysdev, &attr_cpumap);		sysdev_create_file(&node->sysdev, &attr_meminfo);	}	return error;}

static int register_mmu_stats(struct sys_device *s){	if (!mmu_stats_supported)		return 0;	sysdev_create_file(s, &attr_mmustat_enable);	return sysfs_create_group(&s->kobj, &mmu_stat_group);}

/** * cmm_sysfs_register - Register with sysfs * * Return value: * 	0 on success / other on failure **/static int cmm_sysfs_register(struct sys_device *sysdev){	int i, rc;	if ((rc = sysdev_class_register(&cmm_sysdev_class)))		return rc;	sysdev->id = 0;	sysdev->cls = &cmm_sysdev_class;	if ((rc = sysdev_register(sysdev)))		goto class_unregister;	for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) {		if ((rc = sysdev_create_file(sysdev, cmm_attrs[i])))			goto fail;	}	return 0;fail:	while (--i >= 0)		sysdev_remove_file(sysdev, cmm_attrs[i]);	sysdev_unregister(sysdev);class_unregister:	sysdev_class_unregister(&cmm_sysdev_class);	return rc;}

/* * register_node - Setup a sysfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */int register_node(struct node *node, int num, struct node *parent){	int error;	node->sysdev.id = num;	node->sysdev.cls = &node_class;	error = sysdev_register(&node->sysdev);	if (!error){		sysdev_create_file(&node->sysdev, &attr_cpumap);		sysdev_create_file(&node->sysdev, &attr_meminfo);		sysdev_create_file(&node->sysdev, &attr_numastat);		sysdev_create_file(&node->sysdev, &attr_distance);	}	return error;}

static int __init topology_init(void){	int cpu;	register_nodes();	register_cpu_notifier(&sysfs_cpu_nb);	for_each_possible_cpu(cpu) {		struct cpu *c = &per_cpu(cpu_devices, cpu);		/*		 * For now, we just see if the system supports making		 * the RTAS calls for CPU hotplug.  But, there may be a		 * more comprehensive way to do this for an individual		 * CPU.  For instance, the boot cpu might never be valid		 * for hotplugging.		 */		if (ppc_md.cpu_die)			c->hotpluggable = 1;		if (cpu_online(cpu) || c->hotpluggable) {			register_cpu(c, cpu);			sysdev_create_file(&c->sysdev, &attr_physical_id);		}		if (cpu_online(cpu))			register_cpu_online(cpu);	}	return 0;}

static void register_cpu_online(unsigned int cpu){	struct cpu *c = &per_cpu(cpu_devices, cpu);	struct sys_device *s = &c->sysdev;	int i;	for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++)		sysdev_create_file(s, &cpu_core_attrs[i]);	register_mmu_stats(s);}

int __init dma_create_sysfs_files(struct dma_channel *chan){	struct sys_device *dev = &chan->dev;	int ret;	dev->id  = chan->chan;	dev->cls = &dma_sysclass;	ret = sysdev_register(dev);	if (ret)		return ret;	sysdev_create_file(dev, &attr_dev_id);	sysdev_create_file(dev, &attr_count);	sysdev_create_file(dev, &attr_mode);	sysdev_create_file(dev, &attr_flags);	sysdev_create_file(dev, &attr_config);	return 0;}

static int __init leds_init(void){	int ret;	ret = sysdev_class_register(&leds_sysclass);	if (ret == 0)		ret = sysdev_register(&leds_device);	if (ret == 0)		ret = sysdev_create_file(&leds_device, &attr_event);        if (ret == 0)                idle_notifier_register(&leds_idle_nb);	return ret;}

static int __init init_cpu_idle_sysfs(void){	int error = sysdev_class_register(&cpu_idle_sysclass);	if (!error)		error = sysdev_register(&device_cpu_idle);	if (!error)		error = sysdev_create_file(				&device_cpu_idle, &attr_idle_count);	return error;}

static int mx50_accessory_sysdev_ctrl_init(void){	int err = 0;	err = sysdev_class_register(&mx50_accessory_sysclass);	if (!err)		err = sysdev_register(&mx50_accessory_device);	if (!err) {		sysdev_create_file(&mx50_accessory_device, &attr_mx50_accessory_state);	}	return err;}

int cpu_add_sysdev_attr(struct sysdev_attribute *attr){	int cpu;	mutex_lock(&cpu_mutex);	for_each_possible_cpu(cpu) {		sysdev_create_file(get_cpu_sysdev(cpu), attr);	}	mutex_unlock(&cpu_mutex);	return 0;}

/* * register_node - Setup a sysfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */int register_node(struct node *node, int num, struct node *parent){	int error;	node->sysdev.id = num;	node->sysdev.cls = &node_class;	error = sysdev_register(&node->sysdev);	if (!error){		sysdev_create_file(&node->sysdev, &attr_cpumap);		sysdev_create_file(&node->sysdev, &attr_cpulist);		sysdev_create_file(&node->sysdev, &attr_meminfo);		sysdev_create_file(&node->sysdev, &attr_numastat);		sysdev_create_file(&node->sysdev, &attr_distance);		scan_unevictable_register_node(node);		hugetlb_register_node(node);		compaction_register_node(node);	}	return error;}

static int __init qfprom_create_files(struct sys_device *dev,					struct sysdev_attribute files[],					int size){	int i;	for (i = 0; i < size; i++) {		int err = sysdev_create_file(dev, &files[i]);		if (err) {			pr_err("%s: sysdev_create_file(%s)=%d/n",				__func__, files[i].attr.name, err);			return err;		}	}	return 0;}

static void register_cpu_online(unsigned int cpu){	struct cpu *c = &per_cpu(cpu_devices, cpu);	struct sys_device *s = &c->sysdev;	struct sysdev_attribute *attrs, *pmc_attrs;	int i, nattrs;	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&			cpu_has_feature(CPU_FTR_SMT))		sysdev_create_file(s, &attr_smt_snooze_delay);	/* PMC stuff */	switch (cur_cpu_spec->pmc_type) {	case PPC_PMC_IBM:		attrs = ibm_common_attrs;		nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);		pmc_attrs = ibm_pmc_attrs;		break;	case PPC_PMC_PA6T:		/* PA Semi starts counting at PMC0 */		attrs = pa6t_attrs;		nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);		pmc_attrs = NULL;		break;	default:		attrs = NULL;		nattrs = 0;		pmc_attrs = NULL;	}	for (i = 0; i < nattrs; i++)		sysdev_create_file(s, &attrs[i]);	if (pmc_attrs)		for (i = 0; i < cur_cpu_spec->num_pmcs; i++)			sysdev_create_file(s, &pmc_attrs[i]);	if (cpu_has_feature(CPU_FTR_MMCRA))		sysdev_create_file(s, &attr_mmcra);	if (cpu_has_feature(CPU_FTR_PURR))		sysdev_create_file(s, &attr_purr);	if (cpu_has_feature(CPU_FTR_SPURR))		sysdev_create_file(s, &attr_spurr);	if (cpu_has_feature(CPU_FTR_DSCR))		sysdev_create_file(s, &attr_dscr);}

static int __init topology_init(void){	int cpu;	struct node *parent = NULL;	register_nodes();	register_cpu_notifier(&sysfs_cpu_nb);	for_each_cpu(cpu) {		struct cpu *c = &per_cpu(cpu_devices, cpu);#ifdef CONFIG_NUMA		/* The node to which a cpu belongs can't be known		 * until the cpu is made present.		 */		parent = NULL;		if (cpu_present(cpu))			parent = &node_devices[cpu_to_node(cpu)];#endif		/*		 * For now, we just see if the system supports making		 * the RTAS calls for CPU hotplug.  But, there may be a		 * more comprehensive way to do this for an individual		 * CPU.  For instance, the boot cpu might never be valid		 * for hotplugging.		 */		if (!ppc_md.cpu_die)			c->no_control = 1;		if (cpu_online(cpu) || (c->no_control == 0)) {			register_cpu(c, cpu, parent);			sysdev_create_file(&c->sysdev, &attr_physical_id);		}		if (cpu_online(cpu))			register_cpu_online(cpu);	}	return 0;}

/* * register_cpu - Setup a driverfs device for a CPU. * @cpu - cpu->hotpluggable field set to 1 will generate a control file in *	  sysfs for this CPU. * @num - CPU number to use when creating the device. * * Initialize and register the CPU device. */int __devinit register_cpu(struct cpu *cpu, int num){	int error;	cpu->node_id = cpu_to_node(num);	cpu->sysdev.id = num;	cpu->sysdev.cls = &cpu_sysdev_class;	error = sysdev_register(&cpu->sysdev);	if (!error && cpu->hotpluggable)		register_cpu_control(cpu);	if (!error)		cpu_sys_devices[num] = &cpu->sysdev;	if (!error)		register_cpu_under_node(num, cpu_to_node(num));#ifdef CONFIG_KEXEC	if (!error)		error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);#endif	return error;}

/* * MSM LED Trigger Sys Device Register * * 1. Torch Mode *     enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/torch *    disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/torch * * 2. Flash Mode *     enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/flash *    disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/flash */static int32_t msm_led_trigger_register_sysdev(struct msm_led_flash_ctrl_t *fctrl){	int32_t i, rc;	rc = sysdev_class_register(&msm_led_trigger_sysdev_class);	if (rc) {			return rc;	}	msm_led_trigger_sysdev.id = 0;	msm_led_trigger_sysdev.cls = &msm_led_trigger_sysdev_class;	rc = sysdev_register(&msm_led_trigger_sysdev);	if (rc) {		sysdev_class_unregister(&msm_led_trigger_sysdev_class);		return rc;	}	for (i = 0; i < ARRAY_SIZE(msm_led_trigger_sysdev_attrs); ++i) {		rc = sysdev_create_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]);		if (rc) {			goto msm_led_trigger_register_sysdev_failed;		}	}	msm_led_trigger_sysdev_fctrl = fctrl;	return 0;msm_led_trigger_register_sysdev_failed:	while (--i >= 0) sysdev_remove_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]);	sysdev_unregister(&msm_led_trigger_sysdev);	sysdev_class_unregister(&msm_led_trigger_sysdev_class);	return rc;}

/* * Sys device register * * sysdev file: * * /sys/devices/system/zte_ftm/zte_ftm0/fusion * /sys/devices/system/zte_ftm/zte_ftm0/simlocking */static int32_t ftm_register_sysdev(struct sys_device *sysdev){	int32_t ret;	int32_t i;	ret = sysdev_class_register(&ftm_sysdev_class);	if (ret) {		return ret;	}	sysdev->id = 0;	sysdev->cls = &ftm_sysdev_class;	ret = sysdev_register(sysdev);	if (ret) {		sysdev_class_unregister(&ftm_sysdev_class);		return ret;	}	for (i = 0; i < ARRAY_SIZE(ftm_attrs); i++) {		ret = sysdev_create_file(sysdev, ftm_attrs[i]);		if (ret) {			goto ftm_fail;		}	}	return 0;ftm_fail:	while (--i >= 0) sysdev_remove_file(sysdev, ftm_attrs[i]);	sysdev_unregister(sysdev);	sysdev_class_unregister(&ftm_sysdev_class);	  return ret;}

static int __init register_balloon(struct sys_device *sysdev){	int i, error;	error = sysdev_class_register(&balloon_sysdev_class);	if (error)		return error;	sysdev->id = 0;	sysdev->cls = &balloon_sysdev_class;	error = sysdev_register(sysdev);	if (error) {		sysdev_class_unregister(&balloon_sysdev_class);		return error;	}	for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) {		error = sysdev_create_file(sysdev, balloon_attrs[i]);		if (error)			goto fail;	}	error = sysfs_create_group(&sysdev->kobj, &balloon_info_group);	if (error)		goto fail;		return 0; fail:	while (--i >= 0)		sysdev_remove_file(sysdev, balloon_attrs[i]);	sysdev_unregister(sysdev);	sysdev_class_unregister(&balloon_sysdev_class);	return error;}

/* * register_cpu - Setup a driverfs device for a CPU. * @cpu - Callers can set the cpu->no_control field to 1, to indicate not to *		  generate a control file in sysfs for this CPU. * @num - CPU number to use when creating the device. * * Initialize and register the CPU device. */int __devinit register_cpu(struct cpu *cpu, int num, struct node *root){	int error;	cpu->node_id = cpu_to_node(num);	cpu->sysdev.id = num;	cpu->sysdev.cls = &cpu_sysdev_class;	error = sysdev_register(&cpu->sysdev);	if (!error && root)		error = sysfs_create_link(&root->sysdev.kobj,					  &cpu->sysdev.kobj,					  kobject_name(&cpu->sysdev.kobj));	if (!error && !cpu->no_control)		register_cpu_control(cpu);	if (!error)		cpu_sys_devices[num] = &cpu->sysdev;#ifdef CONFIG_KEXEC	if (!error)		error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);#endif	return error;}

static int __init topology_init(void){    int cpu;    for_each_possible_cpu(cpu) {        struct cpu *c = &per_cpu(cpu_devices, cpu);        register_cpu(c, cpu);#ifdef CONFIG_PERFORMANCE_COUNTERS        sysdev_create_file(&c->sysdev, &attr_pc0event);        sysdev_create_file(&c->sysdev, &attr_pc0count);        sysdev_create_file(&c->sysdev, &attr_pc1event);        sysdev_create_file(&c->sysdev, &attr_pc1count);        sysdev_create_file(&c->sysdev, &attr_pccycles);        sysdev_create_file(&c->sysdev, &attr_pcenable);#endif    }    return 0;}

static int bq27541_battery_sysdev_ctrl_init(void){	int err = 0;	err = sysdev_class_register(&bq27541_battery_sysclass);	if (!err)		err = sysdev_register(&bq27541_battery_device);	if (!err) {		sysdev_create_file(&bq27541_battery_device, &attr_battery_id);		sysdev_create_file(&bq27541_battery_device, &attr_battery_current);		sysdev_create_file(&bq27541_battery_device, &attr_battery_voltage);		sysdev_create_file(&bq27541_battery_device, &attr_battery_temperature);		sysdev_create_file(&bq27541_battery_device, &attr_battery_capacity);		sysdev_create_file(&bq27541_battery_device, &attr_battery_mAH);		sysdev_create_file(&bq27541_battery_device, &attr_battery_voltage_thresholds);		sysdev_create_file(&bq27541_battery_device, &attr_battery_polling_intervals);		sysdev_create_file(&bq27541_battery_device, &attr_battery_temp_thresholds);		sysdev_create_file(&bq27541_battery_device, &attr_battery_i2c_address);		sysdev_create_file(&bq27541_battery_device, &attr_battery_error);		sysdev_create_file(&bq27541_battery_device, &attr_battery_suspend_current);		sysdev_create_file(&bq27541_battery_device, &attr_battery_current_diags);		sysdev_create_file(&bq27541_battery_device, &attr_battery_suspend_current_diags);		sysdev_create_file(&bq27541_battery_device, &attr_battery_cycl);		sysdev_create_file(&bq27541_battery_device, &attr_battery_lmd);		sysdev_create_file(&bq27541_battery_device, &attr_battery_cyct);		sysdev_create_file(&bq27541_battery_device, &attr_resume_stats);		sysdev_create_file(&bq27541_battery_device, &attr_battreg);		sysdev_create_file(&bq27541_battery_device, &attr_battreg_value);	}	return err;}

static int summit_smb347_probe(struct i2c_client *client, const struct i2c_device_id *id){	struct summit_smb347_info *info;	int ret = 0;#ifdef SUMMIT_SMB347_DEBUG	int i = 0;#endif	int error = 0;	unsigned char value = 0xff;	info = kzalloc(sizeof(*info), GFP_KERNEL);	if (!info) {		return -ENOMEM;	}	client->addr = SUMMIT_SMB347_I2C_ADDRESS;	i2c_set_clientdata(client, info);	info->client = client;	info->charger.name = "summit_smb347";	info->charger.type = POWER_SUPPLY_TYPE_MAINS;	info->charger.get_property = smb347_get_property;	info->charger.properties = smb347_charger_props;	info->charger.num_properties = ARRAY_SIZE(smb347_charger_props);	ret = power_supply_register(&client->dev, &info->charger);	if (ret) {		dev_err(&client->dev, "failed: power supply register/n");		i2c_set_clientdata(client, NULL);		kfree(info);		return ret;	}	summit_smb347_i2c_client = info->client;	summit_smb347_i2c_client->addr = SUMMIT_SMB347_I2C_ADDRESS;	if (summit_smb347_read_id(&summit_smb347_id_reg) < 0)		return -ENODEV;	printk(KERN_INFO "Summit SMB347 detected, chip_id=0x%x/n", summit_smb347_id_reg);	ret = request_irq(summit_smb347_i2c_client->irq, summit_smb347_irq,			IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING, "summit_smb347", NULL);	if (ret != 0) {		printk(KERN_ERR "Failed to request IRQ %d: %d/n",				summit_smb347_i2c_client->irq, ret);	}	summit_smb347_init_registers();#ifdef SUMMIT_SMB347_DEBUG	for (i = 0; i <= 0xE; i++) {		ret = summit_smb347_i2c_read(i, &value);		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x/n", i, value);	}	for (i = 0x30; i <= 0x3F; i++) {		ret = summit_smb347_i2c_read(i, &value);		printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x/n", i, value);	}#endif	error = sysdev_class_register(&smb347_reg_sysclass);	if (!error)		error = sysdev_register(&device_smb347_reg);	if (!error)		error = sysdev_create_file(&device_smb347_reg, &attr_smb347_reg);	error = sysdev_class_register(&smb347_register_sysclass);	if (!error)		error = sysdev_register(&device_smb347_register);	if (!error)		error = sysdev_create_file(&device_smb347_register, &attr_smb347_register);	return 0;}

static void register_cpu_online(unsigned int cpu){	struct cpu *c = &per_cpu(cpu_devices, cpu);	struct sys_device *s = &c->sysdev;#ifndef CONFIG_PPC_ISERIES	if (cpu_has_feature(CPU_FTR_SMT))		sysdev_create_file(s, &attr_smt_snooze_delay);#endif	/* PMC stuff */	sysdev_create_file(s, &attr_mmcr0);	sysdev_create_file(s, &attr_mmcr1);	if (cpu_has_feature(CPU_FTR_MMCRA))		sysdev_create_file(s, &attr_mmcra);	if (cur_cpu_spec->num_pmcs >= 1)		sysdev_create_file(s, &attr_pmc1);	if (cur_cpu_spec->num_pmcs >= 2)		sysdev_create_file(s, &attr_pmc2);	if (cur_cpu_spec->num_pmcs >= 3)		sysdev_create_file(s, &attr_pmc3);	if (cur_cpu_spec->num_pmcs >= 4)		sysdev_create_file(s, &attr_pmc4);	if (cur_cpu_spec->num_pmcs >= 5)		sysdev_create_file(s, &attr_pmc5);	if (cur_cpu_spec->num_pmcs >= 6)		sysdev_create_file(s, &attr_pmc6);	if (cur_cpu_spec->num_pmcs >= 7)		sysdev_create_file(s, &attr_pmc7);	if (cur_cpu_spec->num_pmcs >= 8)		sysdev_create_file(s, &attr_pmc8);	if (cpu_has_feature(CPU_FTR_SMT))		sysdev_create_file(s, &attr_purr);}

static void __cpuinit register_cpu_control(struct cpu *cpu){	sysdev_create_file(&cpu->sysdev, &attr_online);}