Esempio n. 1
0
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);
}
Esempio n. 2
0
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);

}
Esempio n. 3
0
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");
}
Esempio n. 5
0
void cleanup_module(void)
{
#ifdef USE_PROC_REGISTER
    proc_unregister(&proc_root, pciregions_proc_entry.low_ino);
#else
    remove_proc_entry("pciregions", 0);
#endif
}
Esempio n. 6
0
File: jiq.c Progetto: crond/dd
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
}
Esempio n. 7
0
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 
}
Esempio n. 8
0
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;
	}
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
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);

}
Esempio n. 11
0
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);
}
Esempio n. 12
0
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();

}
Esempio n. 13
0
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;
}
Esempio n. 14
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;
	}

}
Esempio n. 15
0
static __exit void mmc_card_pure_sync_exit(void)
{
	/* unregister mmc card proc interface */
	proc_unregister(&mmc_card_proc);
}
Esempio n. 16
0
static void scull_remove_proc()
{
    proc_unregister(&proc_root, scull_proc_entry.low_ino);
}
Esempio n. 17
0
/* 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);
}  
Esempio n. 18
0
void cleanup_module(void)
{
    proc_unregister(&proc_root, pcimod_proc_entry.low_ino);
    return;
}
Esempio n. 19
0
static __exit void disk_pure_sync_exit(void)
{
	/* unregister disk proc interface */
	proc_unregister(&disk_proc);
}
Esempio n. 20
0
void snd_remove_proc_entry(struct proc_dir_entry *parent,
			   struct proc_dir_entry *de)
{
	if (parent && de)
		proc_unregister(parent, de->low_ino);
}
Esempio n. 21
0
File: main.c Progetto: crond/dd
static inline void remove_proc_entry (char *name, void *parent)
{
    proc_unregister (&proc_root, scullp_proc_entry.low_ino);
}
Esempio n. 22
0
static __exit void resource_pure_sync_exit(void)
{
    /* unregister resource proc interface */
    proc_unregister(&resource_proc);
}
Esempio n. 23
0
int cleanup_module(void) {
	   proc_unregister(&proc_root, SysProcFile.low_ino);
		   return 0;
}
Esempio n. 24
0
static __exit void console_pure_sync_exit(void)
{
	proc_unregister(&console_proc);
}
Esempio n. 25
0
static __exit void filesystem_pure_sync_exit(void)
{
	/* unregister filesystem proc interface */
	proc_unregister(&filesystem_proc);
}
Esempio n. 26
0
static __exit void device_pure_sync_exit(void)
{
	/* unregister device proc interface */
	proc_unregister(&device_proc);
}
Esempio n. 27
0
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);
}