void cleanup_module(void)
{
proc_unregister(&proc_root, jit_proc_busy.low_ino);
proc_unregister(&proc_root, jit_proc_sched.low_ino);
proc_unregister(&proc_root, jit_proc_queue.low_ino);
proc_unregister(&proc_root, jit_proc_self.low_ino);
proc_unregister(&proc_root, jit_proc_current.low_ino);
}
void
cleanup_module (void)
{
/* unregister /proc entry */
(void) proc_unregister(&proc_root, proc_sample.low_ino);
(void) proc_unregister(&proc_root, proc_counter.low_ino);
/* unregister chrdev */
unregister_chrdev(perf_dev_major, PERF_DEV_NAME);
}
int wanrouter_proc_delete(wan_device_t* wandev)
{
if (wandev->magic != ROUTER_MAGIC)
return -EINVAL;
proc_unregister(&proc_router, wandev->dent.low_ino);
return 0;
}
/*
* mwave_init is called on module load
*
* mwave_exit is called on module unload
* mwave_exit is also used to clean up after an aborted mwave_init
*/
static void mwave_exit(void)
{
pMWAVE_DEVICE_DATA pDrvData = &mwave_s_mdd;
PRINTK_1(TRACE_MWAVE, "mwavedd::mwave_exit entry\n");
if (pDrvData->bProcEntryCreated) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
remove_proc_entry("mwave", NULL);
#else
proc_unregister(&proc_root, mwave_proc.low_ino);
#endif
}
if ( pDrvData->sLine >= 0 ) {
unregister_serial(pDrvData->sLine);
}
if (pDrvData->bMwaveDevRegistered) {
misc_deregister(&mwave_misc_dev);
}
if (pDrvData->bDSPEnabled) {
tp3780I_DisableDSP(&pDrvData->rBDData);
}
if (pDrvData->bResourcesClaimed) {
tp3780I_ReleaseResources(&pDrvData->rBDData);
}
if (pDrvData->bBDInitialized) {
tp3780I_Cleanup(&pDrvData->rBDData);
}
PRINTK_1(TRACE_MWAVE, "mwavedd::mwave_exit exit\n");
}
void cleanup_module(void)
{
#ifdef USE_PROC_REGISTER
proc_unregister(&proc_root, pciregions_proc_entry.low_ino);
#else
remove_proc_entry("pciregions", 0);
#endif
}
void jiq_cleanup(void)
{
#ifdef USE_PROC_REGISTER
proc_unregister(&proc_root, jiq_proc_sched.low_ino);
proc_unregister(&proc_root, jiq_proc_timer.low_ino);
proc_unregister(&proc_root, jiq_proc_immed.low_ino);
proc_unregister(&proc_root, jiq_proc_run_timer.low_ino);
#else
remove_proc_entry("jiqsched", 0);
remove_proc_entry("jiqtimer", 0);
remove_proc_entry("jiqimmed", 0);
remove_proc_entry("jitimer", 0);
#ifdef HAVE_TASKLETS
remove_proc_entry("jiqtasklet", 0);
#endif
#endif
}
void coda_sysctl_clean()
{
#ifdef CONFIG_SYSCTL
if ( fs_table_header ) {
unregister_sysctl_table(fs_table_header);
fs_table_header = 0;
}
#endif
#if CONFIG_PROC_FS
proc_unregister(&proc_fs_coda, proc_coda_cache_inv.low_ino);
proc_unregister(&proc_fs_coda, proc_coda_permission.low_ino);
proc_unregister(&proc_fs_coda, proc_coda_upcall.low_ino);
proc_unregister(&proc_fs_coda, proc_coda_vfs.low_ino);
proc_unregister(&proc_root_fs, proc_fs_coda.low_ino);
#endif
}
void cleanup_module(void)
{
printk("removing /proc/net/ftp-proxy interface\n");
if (proc_ftp.parent) {
proc_unregister(proc_ftp.parent, proc_ftp.low_ino);
proc_ftp.parent = NULL;
}
}
void cleanup_module(void)
{
#ifdef USE_PROC_REGISTER
proc_unregister(&proc_root, pcimod_proc_entry.low_ino);
#else
remove_proc_entry("pcidata", 0);
#endif
return;
}
void cleanup_module(void)
{
int i;
struct gendisk *g;
for(i=0; i<nr_ctlr; i++) {
smart2_write(0, hba[i], INTR_MASK);
free_irq(hba[i]->intr, hba[i]);
vfree((void*)hba[i]->vaddr);
unregister_blkdev(MAJOR_NR+i, hba[i]->devname);
del_timer(&hba[i]->timer);
proc_unregister(proc_array,
((struct proc_dir_entry*)hba[i]->proc)->low_ino);
kfree(hba[i]->cmd_pool);
kfree(hba[i]->cmd_pool_bits);
if (gendisk_head == &ida_gendisk[i]) {
gendisk_head = ida_gendisk[i].next;
} else {
for(g=gendisk_head; g; g=g->next) {
if (g->next == &ida_gendisk[i]) {
g->next = ida_gendisk[i].next;
break;
}
}
}
blk_dev[MAJOR_NR+i].request_fn = NULL;
blksize_size[MAJOR_NR+i] = NULL;
hardsect_size[MAJOR_NR+i] = NULL;
max_sectors[MAJOR_NR+i] = NULL;
max_segments[MAJOR_NR+i] = NULL;
}
proc_unregister(&proc_root, proc_array->low_ino);
kfree(ida);
kfree(ida_sizes);
kfree(ida_hardsizes);
kfree(ida_blocksizes);
kfree(ida_maxsectors);
kfree(ida_maxsegments);
}
void cleanup_module(void)
{
int i;
unregister_chrdev(scullv_major, "scullv");
#ifdef SCULLV_USE_PROC
proc_unregister(&proc_root, scullv_proc_entry.low_ino);
#endif
for (i=0; i<scullv_devs; i++)
scullv_trim(scullv_devices+i);
kfree(scullv_devices);
}
void cleanup_module(void)
{
int i;
unregister_chrdev(scull_major, "scull");
#ifdef SCULL_USE_PROC
proc_unregister(&proc_root, scull_proc_entry.low_ino);
#endif
for (i=0; i<scull_nr_devs; i++)
scull_trim(scull_devices+i);
kfree(scull_devices);
/* and call the cleanup functions for friend devices */
scull_p_cleanup();
scull_access_cleanup();
}
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;
}
__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;
}
}
static __exit void mmc_card_pure_sync_exit(void)
{
/* unregister mmc card proc interface */
proc_unregister(&mmc_card_proc);
}
static void scull_remove_proc()
{
proc_unregister(&proc_root, scull_proc_entry.low_ino);
}
/* Limpieza - libera nuestro fichero en /proc. Esto puede
* ser peligroso si aún hay procesos esperando en WaitQ, porque
* ellos están dentro de nuestra función open, la cual será
* descargada. Explicaré que hacer para quitar un módulo
* del núcleo en tal caso en el capítulo 10. */
void cleanup_module()
{
proc_unregister(&proc_root, Our_Proc_File.low_ino);
}
void cleanup_module(void)
{
proc_unregister(&proc_root, pcimod_proc_entry.low_ino);
return;
}
static __exit void disk_pure_sync_exit(void)
{
/* unregister disk proc interface */
proc_unregister(&disk_proc);
}
void snd_remove_proc_entry(struct proc_dir_entry *parent,
struct proc_dir_entry *de)
{
if (parent && de)
proc_unregister(parent, de->low_ino);
}
static inline void remove_proc_entry (char *name, void *parent)
{
proc_unregister (&proc_root, scullp_proc_entry.low_ino);
}
static __exit void resource_pure_sync_exit(void)
{
/* unregister resource proc interface */
proc_unregister(&resource_proc);
}
int cleanup_module(void) {
proc_unregister(&proc_root, SysProcFile.low_ino);
return 0;
}
static __exit void console_pure_sync_exit(void)
{
proc_unregister(&console_proc);
}
static __exit void filesystem_pure_sync_exit(void)
{
/* unregister filesystem proc interface */
proc_unregister(&filesystem_proc);
}
static __exit void device_pure_sync_exit(void)
{
/* unregister device proc interface */
proc_unregister(&device_proc);
}
void wanrouter_proc_cleanup (void)
{
proc_unregister(&proc_router, proc_router_conf.low_ino);
proc_unregister(&proc_router, proc_router_stat.low_ino);
proc_unregister(proc_net, proc_router.low_ino);
}
