int parport_device_proc_register(struct pardevice *device)
{
struct parport_device_sysctl_table *t;
struct parport * port = device->port;
t = kmalloc(sizeof(*t), GFP_KERNEL);
if (t == NULL)
return -ENOMEM;
memcpy(t, &parport_device_sysctl_template, sizeof(*t));
t->dev_dir[0].child = t->parport_dir;
t->parport_dir[0].child = t->port_dir;
t->port_dir[0].procname = port->name;
t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */
t->port_dir[0].child = t->devices_root_dir;
t->devices_root_dir[0].child = t->device_dir;
#ifdef CONFIG_PARPORT_1284
t->device_dir[0].ctl_name =
parport_device_num(port->number, port->muxport,
device->daisy)
+ 1; /* nb 0 isn't legal here */
#else /* No IEEE 1284 support */
/* parport_device_num isn't available. */
t->device_dir[0].ctl_name = 1;
#endif /* IEEE 1284 support or not */
t->device_dir[0].procname = device->name;
t->device_dir[0].extra1 = device;
t->device_dir[0].child = t->vars;
t->vars[0].data = &device->timeslice;
t->sysctl_header = register_sysctl_table(t->dev_dir, 0);
if (t->sysctl_header == NULL) {
kfree(t);
t = NULL;
}
device->sysctl_table = t;
return 0;
}
void coda_sysctl_init()
{
reset_coda_vfs_stats();
reset_coda_cache_inv_stats();
#ifdef CONFIG_PROC_FS
proc_fs_coda = proc_mkdir("coda", proc_root_fs);
if (proc_fs_coda) {
proc_fs_coda->owner = THIS_MODULE;
coda_proc_create("vfs_stats", coda_vfs_stats_get_info);
coda_proc_create("cache_inv_stats", coda_cache_inv_stats_get_info);
}
#endif
#ifdef CONFIG_SYSCTL
if ( !fs_table_header )
fs_table_header = register_sysctl_table(fs_table, 0);
#endif
}
void coda_sysctl_init()
{
memset(&coda_callstats, 0, sizeof(coda_callstats));
reset_coda_vfs_stats();
reset_coda_upcall_stats();
reset_coda_permission_stats();
reset_coda_cache_inv_stats();
#ifdef CONFIG_PROC_FS
proc_register(&proc_root_fs,&proc_fs_coda);
proc_register(&proc_fs_coda,&proc_coda_vfs);
proc_register(&proc_fs_coda,&proc_coda_upcall);
proc_register(&proc_fs_coda,&proc_coda_permission);
proc_register(&proc_fs_coda,&proc_coda_cache_inv);
#endif
#ifdef CONFIG_SYSCTL
if ( !fs_table_header )
fs_table_header = register_sysctl_table(fs_table, 0);
#endif
}
static int
cmm_init (void)
{
int rc = -ENOMEM;
#ifdef CONFIG_CMM_PROC
cmm_sysctl_header = register_sysctl_table(cmm_dir_table);
if (!cmm_sysctl_header)
goto out;
#endif
#ifdef CONFIG_CMM_IUCV
rc = smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
if (rc < 0)
goto out_smsg;
#endif
rc = register_oom_notifier(&cmm_oom_nb);
if (rc < 0)
goto out_oom_notify;
init_waitqueue_head(&cmm_thread_wait);
init_timer(&cmm_timer);
cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread");
rc = IS_ERR(cmm_thread_ptr) ? PTR_ERR(cmm_thread_ptr) : 0;
if (!rc)
goto out;
/*
* kthread_create failed. undo all the stuff from above again.
*/
unregister_oom_notifier(&cmm_oom_nb);
out_oom_notify:
#ifdef CONFIG_CMM_IUCV
smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
out_smsg:
#endif
#ifdef CONFIG_CMM_PROC
unregister_sysctl_table(cmm_sysctl_header);
#endif
out:
return rc;
}
static int __init init_nlm(void)
{
int err;
#ifdef CONFIG_SYSCTL
err = -ENOMEM;
nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
if (nlm_sysctl_table == NULL)
goto err_sysctl;
#endif
err = register_pernet_subsys(&lockd_net_ops);
if (err)
goto err_pernet;
return 0;
err_pernet:
#ifdef CONFIG_SYSCTL
unregister_sysctl_table(nlm_sysctl_table);
#endif
err_sysctl:
return err;
}
static int
cmm_init (void)
{
int rc;
/* Prevent logical cpu 0 from being set offline. */
rc = smp_get_cpu(cpumask_of_cpu(0));
if (rc) {
printk(KERN_ERR "CMM: unable to reserve cpu 0\n");
return rc;
}
#ifdef CONFIG_CMM_PROC
cmm_sysctl_header = register_sysctl_table(cmm_dir_table, 1);
#endif
#ifdef CONFIG_CMM_IUCV
smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
#endif
INIT_WORK(&cmm_thread_starter, (void *) cmm_start_thread, 0);
init_waitqueue_head(&cmm_thread_wait);
init_timer(&cmm_timer);
return 0;
}
static int
cmm_init (void)
{
int rc = -ENOMEM;
#ifdef CONFIG_CMM_PROC
cmm_sysctl_header = register_sysctl_table(cmm_dir_table, 1);
if (!cmm_sysctl_header)
goto out;
#endif
#ifdef CONFIG_CMM_IUCV
rc = smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
if (rc < 0)
goto out_smsg;
#endif
rc = register_oom_notifier(&cmm_oom_nb);
if (rc < 0)
goto out_oom_notify;
cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread");
rc = IS_ERR(cmm_thread_ptr) ? PTR_ERR(cmm_thread_ptr) : 0;
if (rc)
goto out_kthread;
return 0;
out_kthread:
unregister_oom_notifier(&cmm_oom_nb);
out_oom_notify:
#ifdef CONFIG_CMM_IUCV
smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
out_smsg:
#endif
#ifdef CONFIG_CMM_PROC
unregister_sysctl_table(cmm_sysctl_header);
out:
#endif
del_timer_sync(&cmm_timer);
return rc;
}
int __init h3600_stowaway_init_module( void )
{
/* register our character device */
SFDEBUG(0,"registering char device\n");
g_stowaway_major = devfs_register_chrdev(0, H3600_STOWAWAY_MODULE_NAME, &stowaway_fops);
if (g_stowaway_major < 0) {
printk(KERN_ALERT __FUNCTION__ ": can't get major number\n");
return g_stowaway_major;
}
devfs_stowaway = devfs_register( NULL, H3600_STOWAWAY_DEVICE_NAME,
DEVFS_FL_DEFAULT, g_stowaway_major,
0, S_IFCHR | S_IRUSR | S_IWUSR, &stowaway_fops, NULL );
/* Register in /proc filesystem */
create_proc_read_entry(H3600_STOWAWAY_PROC_STATS, 0, proc_dir,
h3600_stowaway_proc_stats_read, NULL );
h3600_stowaway_sysctl_header = register_sysctl_table(h3600_stowaway_dir_table, 0);
return 0;
}
int parport_proc_register(struct parport *port)
{
struct parport_sysctl_table *t;
int i;
t = kmalloc(sizeof(*t), GFP_KERNEL);
if (t == NULL)
return -ENOMEM;
memcpy(t, &parport_sysctl_template, sizeof(*t));
t->device_dir[0].extra1 = port;
for (i = 0; i < 8; i++)
t->vars[i].extra1 = port;
t->vars[0].data = &port->spintime;
t->vars[5].child = t->device_dir;
for (i = 0; i < 5; i++)
t->vars[6 + i].extra2 = &port->probe_info[i];
t->port_dir[0].procname = port->name;
t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */
t->port_dir[0].child = t->vars;
t->parport_dir[0].child = t->port_dir;
t->dev_dir[0].child = t->parport_dir;
t->sysctl_header = register_sysctl_table(t->dev_dir, 0);
if (t->sysctl_header == NULL) {
kfree(t);
t = NULL;
}
port->sysctl_table = t;
return 0;
}
int xprt_rdma_init(void)
{
int rc;
rc = rpcrdma_alloc_wq();
if (rc)
return rc;
rc = xprt_register_transport(&xprt_rdma);
if (rc) {
rpcrdma_destroy_wq();
return rc;
}
rc = xprt_register_transport(&xprt_rdma_bc);
if (rc) {
xprt_unregister_transport(&xprt_rdma);
rpcrdma_destroy_wq();
return rc;
}
dprintk("RPCRDMA Module Init, register RPC RDMA transport\n");
dprintk("Defaults:\n");
dprintk("\tSlots %d\n"
"\tMaxInlineRead %d\n\tMaxInlineWrite %d\n",
xprt_rdma_slot_table_entries,
xprt_rdma_max_inline_read, xprt_rdma_max_inline_write);
dprintk("\tPadding 0\n\tMemreg %d\n", xprt_rdma_memreg_strategy);
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
if (!sunrpc_table_header)
sunrpc_table_header = register_sysctl_table(sunrpc_table);
#endif
return 0;
}
int ethinit_module(void)
{
int res;
printk(KERN_INFO "init module called \n");
init_module2_2();
spin_lock_init(ð_lock);
schar_name = "schar2";
/* register device with kernel */
res = register_chrdev(SCHAR_MAJOR_2, schar_name, &schar_fops);
if (res) {
printk(KERN_INFO "can't register device with kernel\n");
return res;
}
/* register proc entry */
schar_root_header_2 = register_sysctl_table(schar_root_dir_2, 0);
return 0;
}
/* allocate the tables for the presto devices. We need
* sizeof(proto_channel_table)/sizeof(proto_channel_table[0])
* entries for each dev
*/
int /* __init */ init_intermezzo_sysctl(void)
{
int i;
int total_dev = MAX_CHANNEL;
int entries_per_dev = sizeof(proto_psdev_table) /
sizeof(proto_psdev_table[0]);
int total_entries = entries_per_dev * total_dev;
ctl_table *dev_ctl_table;
PRESTO_ALLOC(dev_ctl_table, sizeof(ctl_table) * total_entries);
if (! dev_ctl_table) {
CERROR("WARNING: presto couldn't allocate dev_ctl_table\n");
EXIT;
return -ENOMEM;
}
/* now fill in the entries ... we put the individual presto<x>
* entries at the end of the table, and the per-presto stuff
* starting at the front. We assume that the compiler makes
* this code more efficient, but really, who cares ... it
* happens once per reboot.
*/
for(i = 0; i < total_dev; i++) {
void *p;
/* entry for this /proc/sys/intermezzo/intermezzo"i" */
ctl_table *psdev = &presto_table[i + PRESTO_PRIMARY_CTLCNT];
/* entries for the individual "files" in this "directory" */
ctl_table *psdev_entries = &dev_ctl_table[i * entries_per_dev];
/* init the psdev and psdev_entries with the prototypes */
*psdev = proto_channel_entry;
memcpy(psdev_entries, proto_psdev_table,
sizeof(proto_psdev_table));
/* now specialize them ... */
/* the psdev has to point to psdev_entries, and fix the number */
psdev->ctl_name = psdev->ctl_name + i + 1; /* sorry */
PRESTO_ALLOC(p, PROCNAME_SIZE);
psdev->procname = p;
if (!psdev->procname) {
PRESTO_FREE(dev_ctl_table,
sizeof(ctl_table) * total_entries);
return -ENOMEM;
}
sprintf((char *) psdev->procname, "intermezzo%d", i);
/* hook presto into */
psdev->child = psdev_entries;
/* now for each psdev entry ... */
psdev_entries[0].data = &(izo_channels[i].uc_hard);
psdev_entries[1].data = &(izo_channels[i].uc_no_filter);
psdev_entries[2].data = &(izo_channels[i].uc_no_journal);
psdev_entries[3].data = &(izo_channels[i].uc_no_upcall);
psdev_entries[4].data = &(izo_channels[i].uc_timeout);
#ifdef PRESTO_DEBUG
psdev_entries[5].data = &(izo_channels[i].uc_errorval);
#endif
}
#ifdef CONFIG_SYSCTL
if ( !intermezzo_table_header )
intermezzo_table_header =
register_sysctl_table(intermezzo_table, 0);
#endif
#ifdef CONFIG_PROC_FS
proc_fs_intermezzo = proc_mkdir("intermezzo", proc_root_fs);
proc_fs_intermezzo->owner = THIS_MODULE;
create_proc_info_entry("mounts", 0, proc_fs_intermezzo,
intermezzo_mount_get_info);
#endif
return 0;
}
static int __init ipc_sysctl_init(void)
{
register_sysctl_table(ipc_root_table);
return 0;
}
void ipx_register_sysctl(void)
{
ipx_table_header = register_sysctl_table(ipx_root_table);
}
static int __init
abi_register_sysctl(void)
{
register_sysctl_table(abi_root_table, 1);
return 0;
}
void coda_sysctl_init(void)
{
if ( !fs_table_header )
fs_table_header = register_sysctl_table(fs_table);
}
static int __init init_sysctl(void)
{
sysctl_header = register_sysctl_table(dev_root);
return 0;
}
/*
* initialise the fs caching module
*/
static int __init fscache_init(void)
{
unsigned int nr_cpus = num_possible_cpus();
unsigned int cpu;
int ret;
fscache_object_max_active =
clamp_val(nr_cpus,
fscache_object_max_active, WQ_UNBOUND_MAX_ACTIVE);
ret = -ENOMEM;
fscache_object_wq = alloc_workqueue("fscache_object", WQ_UNBOUND,
fscache_object_max_active);
if (!fscache_object_wq)
goto error_object_wq;
fscache_op_max_active =
clamp_val(fscache_object_max_active / 2,
fscache_op_max_active, WQ_UNBOUND_MAX_ACTIVE);
ret = -ENOMEM;
fscache_op_wq = alloc_workqueue("fscache_operation", WQ_UNBOUND,
fscache_op_max_active);
if (!fscache_op_wq)
goto error_op_wq;
for_each_possible_cpu(cpu)
init_waitqueue_head(&per_cpu(fscache_object_cong_wait, cpu));
ret = fscache_proc_init();
if (ret < 0)
goto error_proc;
#ifdef CONFIG_SYSCTL
ret = -ENOMEM;
fscache_sysctl_header = register_sysctl_table(fscache_sysctls_root);
if (!fscache_sysctl_header)
goto error_sysctl;
#endif
fscache_cookie_jar = kmem_cache_create("fscache_cookie_jar",
sizeof(struct fscache_cookie),
0,
0,
fscache_cookie_init_once);
if (!fscache_cookie_jar) {
printk(KERN_NOTICE
"FS-Cache: Failed to allocate a cookie jar\n");
ret = -ENOMEM;
goto error_cookie_jar;
}
fscache_root = kobject_create_and_add("fscache", kernel_kobj);
if (!fscache_root)
goto error_kobj;
printk(KERN_NOTICE "FS-Cache: Loaded\n");
return 0;
error_kobj:
kmem_cache_destroy(fscache_cookie_jar);
error_cookie_jar:
#ifdef CONFIG_SYSCTL
unregister_sysctl_table(fscache_sysctl_header);
error_sysctl:
#endif
fscache_proc_cleanup();
error_proc:
destroy_workqueue(fscache_op_wq);
error_op_wq:
destroy_workqueue(fscache_object_wq);
error_object_wq:
return ret;
}
void unix_sysctl_register(void)
{
unix_sysctl_header = register_sysctl_table(unix_root_table, 0);
}
/*
* Initialize power interface
*/
static int __init pm_init(void)
{
register_sysctl_table(pm_dir_table);
return 0;
}
int __init
xpc_init(void)
{
int ret;
struct task_struct *kthread;
dev_set_name(xpc_part, "part");
dev_set_name(xpc_chan, "chan");
if (is_shub()) {
/*
* The ia64-sn2 architecture supports at most 64 partitions.
* And the inability to unregister remote amos restricts us
* further to only support exactly 64 partitions on this
* architecture, no less.
*/
if (xp_max_npartitions != 64) {
dev_err(xpc_part, "max #of partitions not set to 64\n");
ret = -EINVAL;
} else {
ret = xpc_init_sn2();
}
} else if (is_uv()) {
ret = xpc_init_uv();
} else {
ret = -ENODEV;
}
if (ret != 0)
return ret;
ret = xpc_setup_partitions();
if (ret != 0) {
dev_err(xpc_part, "can't get memory for partition structure\n");
goto out_1;
}
xpc_sysctl = register_sysctl_table(xpc_sys_dir);
/*
* Fill the partition reserved page with the information needed by
* other partitions to discover we are alive and establish initial
* communications.
*/
ret = xpc_setup_rsvd_page();
if (ret != 0) {
dev_err(xpc_part, "can't setup our reserved page\n");
goto out_2;
}
/* add ourselves to the reboot_notifier_list */
ret = register_reboot_notifier(&xpc_reboot_notifier);
if (ret != 0)
dev_warn(xpc_part, "can't register reboot notifier\n");
/* add ourselves to the die_notifier list */
ret = register_die_notifier(&xpc_die_notifier);
if (ret != 0)
dev_warn(xpc_part, "can't register die notifier\n");
/*
* The real work-horse behind xpc. This processes incoming
* interrupts and monitors remote heartbeats.
*/
kthread = kthread_run(xpc_hb_checker, NULL, XPC_HB_CHECK_THREAD_NAME);
if (IS_ERR(kthread)) {
dev_err(xpc_part, "failed while forking hb check thread\n");
ret = -EBUSY;
goto out_3;
}
/*
* Startup a thread that will attempt to discover other partitions to
* activate based on info provided by SAL. This new thread is short
* lived and will exit once discovery is complete.
*/
kthread = kthread_run(xpc_initiate_discovery, NULL,
XPC_DISCOVERY_THREAD_NAME);
if (IS_ERR(kthread)) {
dev_err(xpc_part, "failed while forking discovery thread\n");
/* mark this new thread as a non-starter */
complete(&xpc_discovery_exited);
xpc_do_exit(xpUnloading);
return -EBUSY;
}
/* set the interface to point at XPC's functions */
xpc_set_interface(xpc_initiate_connect, xpc_initiate_disconnect,
xpc_initiate_send, xpc_initiate_send_notify,
xpc_initiate_received, xpc_initiate_partid_to_nasids);
return 0;
/* initialization was not successful */
out_3:
xpc_teardown_rsvd_page();
(void)unregister_die_notifier(&xpc_die_notifier);
(void)unregister_reboot_notifier(&xpc_reboot_notifier);
out_2:
if (xpc_sysctl)
unregister_sysctl_table(xpc_sysctl);
xpc_teardown_partitions();
out_1:
if (is_shub())
xpc_exit_sn2();
else if (is_uv())
xpc_exit_uv();
return ret;
}
void
rpc_register_sysctl(void)
{
if (!sunrpc_table_header)
sunrpc_table_header = register_sysctl_table(sunrpc_table);
}
int __init
xpc_init(void)
{
int ret;
struct task_struct *kthread;
dev_set_name(xpc_part, "part");
dev_set_name(xpc_chan, "chan");
if (is_shub()) {
/*
*/
if (xp_max_npartitions != 64) {
dev_err(xpc_part, "max #of partitions not set to 64\n");
ret = -EINVAL;
} else {
ret = xpc_init_sn2();
}
} else if (is_uv()) {
ret = xpc_init_uv();
} else {
ret = -ENODEV;
}
if (ret != 0)
return ret;
ret = xpc_setup_partitions();
if (ret != 0) {
dev_err(xpc_part, "can't get memory for partition structure\n");
goto out_1;
}
xpc_sysctl = register_sysctl_table(xpc_sys_dir);
/*
*/
ret = xpc_setup_rsvd_page();
if (ret != 0) {
dev_err(xpc_part, "can't setup our reserved page\n");
goto out_2;
}
/* */
ret = register_reboot_notifier(&xpc_reboot_notifier);
if (ret != 0)
dev_warn(xpc_part, "can't register reboot notifier\n");
/* */
ret = register_die_notifier(&xpc_die_notifier);
if (ret != 0)
dev_warn(xpc_part, "can't register die notifier\n");
/*
*/
kthread = kthread_run(xpc_hb_checker, NULL, XPC_HB_CHECK_THREAD_NAME);
if (IS_ERR(kthread)) {
dev_err(xpc_part, "failed while forking hb check thread\n");
ret = -EBUSY;
goto out_3;
}
/*
*/
kthread = kthread_run(xpc_initiate_discovery, NULL,
XPC_DISCOVERY_THREAD_NAME);
if (IS_ERR(kthread)) {
dev_err(xpc_part, "failed while forking discovery thread\n");
/* */
complete(&xpc_discovery_exited);
xpc_do_exit(xpUnloading);
return -EBUSY;
}
/* */
xpc_set_interface(xpc_initiate_connect, xpc_initiate_disconnect,
xpc_initiate_send, xpc_initiate_send_notify,
xpc_initiate_received, xpc_initiate_partid_to_nasids);
return 0;
/* */
out_3:
xpc_teardown_rsvd_page();
(void)unregister_die_notifier(&xpc_die_notifier);
(void)unregister_reboot_notifier(&xpc_reboot_notifier);
out_2:
if (xpc_sysctl)
unregister_sysctl_table(xpc_sysctl);
xpc_teardown_partitions();
out_1:
if (is_shub())
xpc_exit_sn2();
else if (is_uv())
xpc_exit_uv();
return ret;
}
struct ctl_table_header *mq_register_sysctl_table(void)
{
return register_sysctl_table(mq_sysctl_root);
}
static void crypto_proc_fips_init(void)
{
crypto_sysctls = register_sysctl_table(crypto_dir_table);
}
static void __init init_sysctl(void)
{
sysctl_header = register_sysctl_table(root_table);
}
static __init int ia32_binfmt_init(void)
{
register_sysctl_table(abi_root_table2);
return 0;
}
static int __init init_nlm(void)
{
nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
return nlm_sysctl_table ? 0 : -ENOMEM;
}
/* This rather complex function must be called when you want to add an entry
to /proc/sys/dev/sensors/chips. It also creates a new directory within
/proc/sys/dev/sensors/.
ctl_template should be a template of the newly created directory. It is
copied in memory. The extra2 field of each file is set to point to client.
If any driver wants subdirectories within the newly created directory,
this function must be updated!
controlling_mod is the controlling module. It should usually be
THIS_MODULE when calling. Note that this symbol is not defined in
kernels before 2.3.13; define it to NULL in that case. We will not use it
for anything older than 2.3.27 anyway. */
int i2c_register_entry(struct i2c_client *client, const char *prefix,
ctl_table * ctl_template,
struct module *controlling_mod)
{
int i, res, len, id;
ctl_table *new_table;
char *name;
struct ctl_table_header *new_header;
if ((res = i2c_create_name(&name, prefix, client->adapter,
client->addr))) return res;
for (id = 0; id < SENSORS_ENTRY_MAX; id++)
if (!i2c_entries[id]) {
break;
}
if (id == SENSORS_ENTRY_MAX) {
kfree(name);
return -ENOMEM;
}
id += 256;
len = 0;
while (ctl_template[len].procname)
len++;
len += 7;
if (!(new_table = kmalloc(sizeof(ctl_table) * len, GFP_KERNEL))) {
kfree(name);
return -ENOMEM;
}
memcpy(new_table, sysctl_table, 6 * sizeof(ctl_table));
new_table[0].child = &new_table[2];
new_table[2].child = &new_table[4];
new_table[4].child = &new_table[6];
new_table[4].procname = name;
new_table[4].ctl_name = id;
memcpy(new_table + 6, ctl_template, (len - 6) * sizeof(ctl_table));
for (i = 6; i < len; i++)
new_table[i].extra2 = client;
if (!(new_header = register_sysctl_table(new_table, 0))) {
kfree(new_table);
kfree(name);
return -ENOMEM;
}
i2c_entries[id - 256] = new_header;
i2c_clients[id - 256] = client;
#ifdef DEBUG
if (!new_header || !new_header->ctl_table ||
!new_header->ctl_table->child ||
!new_header->ctl_table->child->child ||
!new_header->ctl_table->child->child->de) {
printk
("i2c-proc.o: NULL pointer when trying to install fill_inode fix!\n");
return id;
}
#endif /* DEBUG */
i2c_inodes[id - 256] =
new_header->ctl_table->child->child->de->low_ino;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
new_header->ctl_table->child->child->de->owner = controlling_mod;
#else
new_header->ctl_table->child->child->de->fill_inode =
&i2c_dir_fill_inode;
#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */
return id;
}
int __init iodump_init(void)
{
int rc;
printk(gBanner);
// Register our device with Linux
if ((rc = register_chrdev(BCM_IODUMP_MAJOR, "iodump", &iodump_fops)) < 0)
{
printk(KERN_WARNING "iodump: register_chrdev failed for major %d\n", BCM_IODUMP_MAJOR);
return rc;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
gSysCtlHeader = register_sysctl_table(gSysCtl, 0);
if (gSysCtlHeader != NULL)
{
gSysCtlHeader->ctl_table->child->de->owner = THIS_MODULE;
}
#else
gSysCtlHeader = register_sysctl_table(gSysCtl);
#endif
memset(&IoDump, 0, sizeof(IoDump));
IoDump.bufsize = IODUMP_DEFAULT_BUFSIZE;
IoDump.bufp = vmalloc(IoDump.bufsize);
if (!IoDump.bufp)
{
return -ENOMEM;
}
memset(IoDump.bufp, 0, IoDump.bufsize);
IoDump.bufwritep = IoDump.bufp;
IoDump.bufreadp = IoDump.bufp;
IoDump.bufendp = IoDump.bufp + IoDump.bufsize;
strcpy(IoDump.filename, "/tmp/iodump.bin"); // default local file name
IoDump.logfile = 0; // log to socket by default
strcpy(IoDump.ipaddr, "192.168.1.99"); // currently USB over ethernet host IP
IoDump.port = 4000; // default logging ip:port
IoDump.enable = 0; // dumping enabled flag
IoDump.stream[0].ingress = 1; // Main audio stream
IoDump.stream[0].egress = 1;
IoDump.stream[1].ingress = 0;
IoDump.stream[1].egress = 0;
IoDump.stream[2].ingress = 0;
IoDump.stream[2].egress = 0;
IoDump.stream[3].ingress = 0; // Video stream (doesn't hurt to enable on audio device)
IoDump.stream[3].egress = 0;
IoDump.tdm.ingress = 1; // TDM directions to log
IoDump.tdm.egress = 1;
IoDump.read_timeout = msecs_to_jiffies(50);
IoDump.netDumpLock = SPIN_LOCK_UNLOCKED;
// Create dumping to file or socket thread
init_completion(&IoDumpExited);
IoDumpThreadPid = kernel_thread(iodump_thread, 0, 0);
// Create timer to tickle thread at regular intervals
init_timer(&IoDumpTimer);
IoDumpTimer.function = iodump_timer;
return 0;
}
