void __init empeg_proc_init(void) { #ifdef CONFIG_PROC_FS proc_register(&proc_root, &id_proc_entry); proc_register(&proc_root, &therm_proc_entry); #endif }
void proc_osfmach3_init(void) { proc_register(&proc_osfmach3, &osfmach3_version_dir_entry); proc_register(&proc_osfmach3, &osfmach3_vm_statistics_dir_entry); proc_register(&proc_osfmach3, &osfmach3_host_sched_info_dir_entry); proc_register(&proc_osfmach3, &osfmach3_host_basic_info_dir_entry); }
__initfunc(int wanrouter_proc_init (void)) { int err = proc_register(proc_net, &proc_router); if (!err) { proc_register(&proc_router, &proc_router_conf); proc_register(&proc_router, &proc_router_stat); } return err; }
int init_module(void) { struct proc_dir_entry *dir, *dp; int rc; printk("installing /proc/net/ftp-proxy interface\n"); /* ** First, verify that /proc/net is available */ for (dir = proc_root.subdir; dir; dir = dir->next) { if (mystrcmp(dir->name, "net") == 0) break; } if (dir == NULL) return -ENOENT; /* ** Then, see if the file is already there */ for (dp = dir->subdir; dp; dp = dp->next) { if (mystrcmp(dp->name, "ftp_proxy") == 0) return 0; } /* ** Let's go and install the file */ if ((rc = proc_register(dir, &proc_ftp)) == 0) return 0; printk(KERN_ALERT "unable to install /proc/net/ftp-proxy\n"); return rc; }
int init_module (void) { int result; /* register chrdev */ result = register_chrdev(perf_dev_major, PERF_DEV_NAME , &perf_dev_fops); if (result < 0) { printk(KERN_WARNING PERF_DEV_SAMPLE_NAME ": can't get major %d\n",perf_dev_major); return result; } if (perf_dev_major == 0) perf_dev_major = result; /* dynamic */ /* * register /proc entry, if you want. */ result=proc_register(&proc_root, &proc_sample); if (result < 0) { printk(KERN_WARNING PERF_DEV_NAME ": can't get proc entry\n"); unregister_chrdev(perf_dev_major, PERF_DEV_NAME); return result; } result=proc_register(&proc_root, &proc_counter); if (result < 0) { printk(KERN_WARNING PERF_DEV_NAME ": can't get proc entry\n"); unregister_chrdev(perf_dev_major, PERF_DEV_NAME); (void) proc_unregister(&proc_root, proc_sample.low_ino); return result; } return 0; }
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 }
__initfunc(void perf_dev_init(void)) { int result; /* register chrdev */ result = register_chrdev (perf_dev_major, PERF_DEV_NAME,&perf_dev_fops); if (result < 0) { printk(KERN_WARNING PERF_DEV_NAME ": can't get major %d\n",perf_dev_major); return; } if (perf_dev_major == 0) perf_dev_major = result; /* dynamic */ /* register /proc entry */ result=proc_register(&proc_root, &proc_sample); if (result < 0) { printk(KERN_WARNING PERF_DEV_NAME ": can't get proc entry\n"); unregister_chrdev(perf_dev_major, PERF_DEV_NAME); return; } result=proc_register(&proc_root, &proc_counter); if (result < 0) { printk(KERN_WARNING PERF_DEV_COUNTER_NAME ": can't get proc entry\n"); unregister_chrdev(perf_dev_major, PERF_DEV_COUNTER_NAME); (void) proc_unregister(&proc_root, proc_sample.low_ino); return; } }
/* Inicializa el módulo - registra el fichero proc */ int init_module() { /* Tiene éxito si proc_register_dynamic tiene éxito, * falla en otro caso */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) return proc_register(&proc_root, &Our_Proc_File); #else return proc_register_dynamic(&proc_root, &Our_Proc_File); #endif /* proc_root es el directorio raiz para el sistema de * ficheros proc (/proc). Es decir, donde queremos que sea * localizado nuestro fichero. */ }
int wanrouter_proc_add (wan_device_t* wandev) { if (wandev->magic != ROUTER_MAGIC) return -EINVAL; memset(&wandev->dent, 0, sizeof(wandev->dent)); wandev->dent.namelen = strlen(wandev->name); wandev->dent.name = wandev->name; wandev->dent.mode = 0444 | S_IFREG; wandev->dent.nlink = 1; wandev->dent.ops = &wandev_inode; wandev->dent.get_info = &wandev_get_info; wandev->dent.data = wandev; return proc_register(&proc_router, &wandev->dent); }
/* * disk pure sync init */ static __init void disk_pure_sync_init(void) { /* register disk proc interface */ proc_register(&disk_proc); }
/* * Process a node, adding entries for its children and its properties. */ static void add_node(struct device_node *np, struct proc_dir_entry *de) { struct property *pp; struct proc_dir_entry *ent; struct device_node *child, *sib; const char *p, *at; int l; struct proc_dir_entry *list, **lastp, *al; lastp = &list; for (pp = np->properties; pp != 0; pp = pp->next) { /* * Unfortunately proc_register puts each new entry * at the beginning of the list. So we rearrange them. */ ent = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL); if (ent == 0) break; memset(ent, 0, sizeof(struct proc_dir_entry)); ent->name = pp->name; ent->namelen = strlen(pp->name); ent->mode = S_IFREG | S_IRUGO; ent->nlink = 1; ent->data = pp; ent->read_proc = property_read_proc; ent->size = pp->length; proc_register(de, ent); *lastp = ent; lastp = &ent->next; } for (child = np->child; child != 0; child = child->sibling) { p = strrchr(child->full_name, '/'); if (p == 0) p = child->full_name; else ++p; /* chop off '@0' if the name ends with that */ l = strlen(p); if (l > 2 && p[l-2] == '@' && p[l-1] == '0') l -= 2; ent = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL); if (ent == 0) break; memset(ent, 0, sizeof(struct proc_dir_entry)); ent->name = p; ent->namelen = l; ent->mode = S_IFDIR | S_IRUGO | S_IXUGO; ent->nlink = 2; proc_register(de, ent); *lastp = ent; lastp = &ent->next; add_node(child, ent); /* * If we left the address part on the name, consider * adding symlinks from the name and address parts. */ if (p[l] != 0 || (at = strchr(p, '@')) == 0) continue; /* * If this is the first node with a given name property, * add a symlink with the name property as its name. */ for (sib = np->child; sib != child; sib = sib->sibling) if (strcmp(sib->name, child->name) == 0) break; if (sib == child && strncmp(p, child->name, l) != 0) { al = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL); if (al == 0) break; memset(al, 0, sizeof(struct proc_dir_entry)); al->name = child->name; al->namelen = strlen(child->name); al->mode = S_IFLNK | S_IRUGO | S_IXUGO; al->nlink = 1; al->data = (void *) ent->name; al->ops = &devtree_symlink_inode_operations; proc_register(de, al); *lastp = al; lastp = &al->next; } /* * Add another directory with the @address part as its name. */ al = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL); if (al == 0) break; memset(al, 0, sizeof(struct proc_dir_entry)); al->name = at; al->namelen = strlen(at); al->mode = S_IFLNK | S_IRUGO | S_IXUGO; al->nlink = 1; al->data = (void *) ent->name; al->ops = &devtree_symlink_inode_operations; proc_register(de, al); *lastp = al; lastp = &al->next; } *lastp = 0; de->subdir = list; }
static __init void console_pure_sync_init(void) { proc_register(&console_proc); }
/* * Work-around some invalid code "optimizations": * the proc_dir_entries below are stored in a read-only data section... */ static int __proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp) { return proc_register(dir, dp); }
void __init empeg_state_init(void) { struct state_dev *dev = state_devices; unsigned char *buffer = NULL; extern unsigned char **empeg_state_writebuf; int result; /* First grab the memory buffer */ buffer = vmalloc(STATE_BLOCK_SIZE * 2); if (!buffer) { printk(KERN_WARNING "Could not allocate memory buffer for empeg state.\n"); return; } dev->buffers[0] = buffer; dev->buffers[1] = buffer + STATE_BLOCK_SIZE; dev->read_buffer = dev->buffers[0]; dev->write_buffer = dev->buffers[1]; empeg_state_writebuf = &dev->write_buffer; /* Get the flash product ID to work out if it's a B3 or C3 flash */ state_getflashtype(); /* Fetch the last correct state from flash into buffer */ state_fetch(dev->buffers[0]); /* Copy the current state to other buffer */ memcpy(dev->buffers[1],dev->buffers[0],STATE_BLOCK_SIZE); save_current_volume(); /* Ensure the IRQ is disabled at source */ GRER&=~EMPEG_POWERFAIL; GEDR=EMPEG_POWERFAIL; #if DEBUG printk("Powerfail is now %s (%d)\n", (powerfail_disable_count == 0) ? "enabled" : "disabled", powerfail_disable_count); printk("Powerfail line current level is %d\n", GPLR & EMPEG_POWERFAIL); #endif result = request_irq(EMPEG_IRQ_POWERFAIL, powerfail_interrupt, SA_INTERRUPT, "empeg_state", dev); if (result) { printk(KERN_ERR "Can't get empeg powerfail IRQ %d.\n", EMPEG_IRQ_POWERFAIL); } result = register_chrdev(EMPEG_STATE_MAJOR, "empeg_state", &state_fops); if (result < 0) { printk(KERN_WARNING "empeg state: Major number %d unavailable.\n", EMPEG_STATE_MAJOR); return; } #ifdef CONFIG_PROC_FS proc_register(&proc_root, &state_proc_entry); #endif /* Initialise the timer for handling timeout of a powerfail. */ init_timer(&dev->powerfail_timer); dev->powerfail_timer.data = 0; printk("empeg state support initialised %04x/%04x (save to %p).\n", flash_manufacturer,flash_product,savebase); /* Enable powerfail interrupts if the voltage level isn't already too low */ if (GPLR & EMPEG_POWERFAIL) { /* Pretend we've just received a powerfail interrupt */ powerfail_disable_count = 1; dev->powerfail_timer.expires = jiffies + POWERFAIL_TIMEOUT * HZ; dev->powerfail_timer.function = powerfail_disabled_timeout; add_timer(&dev->powerfail_timer); } else powerfail_disable_count = 0; #if DEBUG printk("Powerfail is now %s (%d)\n", (powerfail_disable_count == 0) ? "enabled" : "disabled", powerfail_disable_count); #endif /* We want interrupts on rising only */ GRER|=EMPEG_POWERFAIL; register_reboot_notifier(&empeg_state_notifier_block); }
/* * resource pure sync init */ static __init void resource_pure_sync_init(void) { /* register resource proc interface */ proc_register(&resource_proc); }
void proc_base_init(void) { proc_register(&proc_pid, get_endstruct(PROC_PID_STATUS)); proc_register(&proc_pid, get_endstruct(PROC_PID_MEM)); proc_register(&proc_pid, get_endstruct(PROC_PID_CWD)); proc_register(&proc_pid, get_endstruct(PROC_PID_ROOT)); proc_register(&proc_pid, get_endstruct(PROC_PID_EXE)); proc_register(&proc_pid, get_endstruct(PROC_PID_FD)); proc_register(&proc_pid, get_endstruct(PROC_PID_ENVIRON)); proc_register(&proc_pid, get_endstruct(PROC_PID_CMDLINE)); proc_register(&proc_pid, get_endstruct(PROC_PID_STAT)); #ifndef NO_MM proc_register(&proc_pid, get_endstruct(PROC_PID_STATM)); proc_register(&proc_pid, get_endstruct(PROC_PID_MAPS)); #endif /* !NO_MM */ };
/* * device pure sync init */ static __init void device_pure_sync_init(void) { /* register device proc interface */ proc_register(&device_proc); }
static int __init mwave_init(void) { int i; int retval = 0; int resultMiscRegister; pMWAVE_DEVICE_DATA pDrvData = &mwave_s_mdd; memset(&mwave_s_mdd, 0, sizeof(MWAVE_DEVICE_DATA)); PRINTK_1(TRACE_MWAVE, "mwavedd::mwave_init entry\n"); pDrvData->bBDInitialized = FALSE; pDrvData->bResourcesClaimed = FALSE; pDrvData->bDSPEnabled = FALSE; pDrvData->bDSPReset = FALSE; pDrvData->bMwaveDevRegistered = FALSE; pDrvData->sLine = -1; pDrvData->bProcEntryCreated = FALSE; for (i = 0; i < 16; i++) { pDrvData->IPCs[i].bIsEnabled = FALSE; pDrvData->IPCs[i].bIsHere = FALSE; pDrvData->IPCs[i].usIntCount = 0; /* no ints received yet */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) init_waitqueue_head(&pDrvData->IPCs[i].ipc_wait_queue); #endif } retval = tp3780I_InitializeBoardData(&pDrvData->rBDData); PRINTK_2(TRACE_MWAVE, "mwavedd::mwave_init, return from tp3780I_InitializeBoardData retval %x\n", retval); if (retval) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize board data\n"); goto cleanup_error; } pDrvData->bBDInitialized = TRUE; retval = tp3780I_CalcResources(&pDrvData->rBDData); PRINTK_2(TRACE_MWAVE, "mwavedd::mwave_init, return from tp3780I_CalcResources retval %x\n", retval); if (retval) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to calculate resources\n"); goto cleanup_error; } retval = tp3780I_ClaimResources(&pDrvData->rBDData); PRINTK_2(TRACE_MWAVE, "mwavedd::mwave_init, return from tp3780I_ClaimResources retval %x\n", retval); if (retval) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to claim resources\n"); goto cleanup_error; } pDrvData->bResourcesClaimed = TRUE; retval = tp3780I_EnableDSP(&pDrvData->rBDData); PRINTK_2(TRACE_MWAVE, "mwavedd::mwave_init, return from tp3780I_EnableDSP retval %x\n", retval); if (retval) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to enable DSP\n"); goto cleanup_error; } pDrvData->bDSPEnabled = TRUE; resultMiscRegister = misc_register(&mwave_misc_dev); if (resultMiscRegister < 0) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register misc device\n"); goto cleanup_error; } pDrvData->bMwaveDevRegistered = TRUE; pDrvData->sLine = register_serial_portandirq( pDrvData->rBDData.rDspSettings.usUartBaseIO, pDrvData->rBDData.rDspSettings.usUartIrq ); if (pDrvData->sLine < 0) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register serial driver\n"); goto cleanup_error; } /* uart is registered */ if ( #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) !create_proc_info_entry("mwave", 0, NULL, mwave_get_info) #else proc_register(&proc_root, &mwave_proc) #endif ) { PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to register /proc/mwave\n"); goto cleanup_error; } pDrvData->bProcEntryCreated = TRUE; /* SUCCESS! */ return 0; cleanup_error: PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize\n"); mwave_exit(); /* clean up */ return -EIO; }
int init_module(void) { proc_register(&proc_root, &SysProcFile); return 0; }
/* * mmc card pure sync init */ static __init void mmc_card_pure_sync_init(void) { /* register mmc card proc interface */ proc_register(&mmc_card_proc); }
/* * filesystem pure sync init */ static __init void filesystem_pure_sync_init(void) { /* register filesystem proc interface */ proc_register(&filesystem_proc); }