main.c

File system using stacked.

#include <linux/module.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <linux/slab.h>

#if defined __KERNEL__ && defined KERNEL_DEBUG

static int num_indents = 0;
char indent_buf[80] = "                                                                               ";

char * add_indent(void)
{
    indent_buf[num_indents] = ' ';
    num_indents++;
    if (num_indents > 79)
	num_indents = 79;
    indent_buf[num_indents] = '\0';
    return indent_buf;
}

char *del_indent(void)
{
    if (num_indents <= 0)
	return "<IBUG>";
    indent_buf[num_indents] = ' ';
    num_indents--;
    indent_buf[num_indents] = '\0';
    return indent_buf;
}

#endif /* defined __KERNEL__ && defined KERNEL_DEBUG */


#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_shash.h"
#include "dbinc/db_swap.h"
#include "dbinc/btree.h"
#include "dbinc/db_am.h"
#include "dbinc/hash.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/qam.h"
//#include "dbinc/common_ext.h"
//#include "dbinc/clib_ext.h"



/* This definition must only appear after we include <linux/module.h> */
#ifndef MODULE_LICENSE
#define MODULE_LICENSE(foo)
#endif /* not MODULE_LICENSE */

extern void *sys_call_table[];

#define __NR_db3_create 255
#define __NR_db3_open 254
#define __NR_db3_get 253
#define __NR_db3_put 252
#define __NR_db3_close 251
#define __NR_db3_get_table 250

/* A pointer to the original system call*/
void (*original_call255)(void);
void (*original_call254)(void);
void (*original_call253)(void);
void (*original_call252)(void);
void (*original_call251)(void);
void (*original_call250)(void);


//global variables
DB_ENV *dbenvp1, *dbenvp2;
DB *dbp1, *dbp2;
static void dumpdb(DB *dbp);

//EXPORT_NO_SYMBOLS;
//EXPORT_SYMBOL(db_create);
MODULE_AUTHOR("Erez Zadok <[e-mail]>");
MODULE_DESCRIPTION("kdb3");
MODULE_LICENSE("GPL");



int sys_db3_create(int db, u_int32_t flags)
{
        DB **dbpp; 
        int ret;

	printk("entering sys_db3_create()\n");

        if (db == 1)
        {
                dbpp = &dbp1;
        }
        else
        {
                dbpp = &dbp2;
        }

        if ((ret = db_create(dbpp, NULL, flags)) == 0)
        {
                printk("Create db succssfully\n");
        }

        return ret;
        
}

int sys_db3_get(int db, DBT * key, u_int32_t flags)
{
        DB *dbp;
              
        DBT  data;
        int ret;

	printk("entering sys_db3_get()\n");

        if (db == 1)
        {
                dbp = dbp1;
        }
        else
        {
                dbp = dbp2;
        }

	memset(&data, 0, sizeof(data));
	
	printk("trying to get key=%s\n", (char *)key->data);
	if ((ret = dbp->get(dbp, NULL, key, &data, 0)) == 0) 
		printk("db: %s: key retrieved: data was %s.\n", (char *)key->data, (char *)data.data); 
	else { 
		printk("get operation unsucessful\n"); 
	} 
	


	/*   if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) == 0)
        {
                c = 0;
                while ((ret = dbcp->c_get(dbcp, &tk, &td, DB_NEXT)) == 0)
                {
                        c ++;
                        if (c == ind)
                                break;
                }
                dbcp->c_close(dbcp);//close cursor
        }

        printk("Located record: key = %s, data = %s\n", (char *)tk.data, (char *)td.data);
	*/
        //dumpdb(dbp);  
        
        return ret;
}


int sys_db3_delete(int db, DBT * key, u_int32_t flags)
{
        DB *dbp;
     
	DBT  data;
        int ret;

	printk("entering sys_db3_delete()\n");

        if (db == 1)
        {
                dbp = dbp1;
        }
        else
        {
                dbp = dbp2;
        }

	printk("trying to delete key=%s\n", (char *)key->data);
	
	if ((ret = dbp->del(dbp, NULL, key, 0)) == 0) 
		printk("db: %s: key was deleted.\n", (char *)key->data); 
	else { 
		printk("del operation unsucessful\n"); 
		goto out;
	}
	
	if ((ret = dbp->get(dbp, NULL, key, &data, 0)) == 0) 
		printk("db: %s: key retrieved: data was %s.\n", (char *)key->data, (char *)data.data); 
	else {
		printk("del operation unsucessful\n"); 
	}
/*
        memset(&tk, 0, sizeof(tk));
        memset(&td, 0, sizeof(td));
        
        if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) == 0)
        {
                c = 0;
                while ((ret = dbcp->c_get(dbcp, &tk, &td, DB_NEXT)) == 0 )
                {
                        c ++;
                        if (c==ind)
                                break;
                }
                printk("Located record: key = %s, data = %s\n", (char *)tk.data, (char *)td.data);
                dbcp->c_del(dbcp, 0);
                printk("Record deleted succssfully\n");
                dbcp->c_close(dbcp);//close cursor
        }
*/
//        dumpdb(dbp);
out:
        return ret;
}


int sys_db3_put(int db, DBT * key, DBT * data, u_int32_t flags)
{
        DB *dbp; 
        DBT tk, td;
        int ret;


	printk("entering sys_db3_put()\n");
        if (db == 1)
        {
                dbp = dbp1;
        }
        else
        {
                dbp = dbp2;
        }

        copy_from_user(&tk, key, sizeof(DBT));
	// tk.data = malloc(tk.size);
        copy_from_user(tk.data, key->data, tk.size+1);
//      printk("key: size %d, data %s\n", tk.size, (char *)tk.data);
        copy_from_user(&td, data, sizeof(DBT));
        //td.data = malloc(td.size);
        copy_from_user(td.data, data->data, td.size+1);
//      printk("data: size %d, data %s\n", td.size, (char *)td.data);

        printk("Put record to db: key = %s, data = %s\n", (char *)tk.data, (char *)td.data);
        ret = dbp->put(dbp, NULL, &tk, &td, flags);

        //free(tk.data);
        //free(td.data);

        dumpdb(dbp);

	if (ret == 0)
		printk("Put stuff succssfully\n");

        
        return ret;
        
}

int sys_db3_open(int db, char * name, DBTYPE type, u_int32_t flags, int mode)
{
        DB *dbp; 
        DB_ENV *dbenvp;
        char *tmp;
        int ret = 0;

	printk("entering sys_db3_open()\n");
        if (db == 1)
        {
                dbp = dbp1;
                dbenvp = dbenvp1;
        }
        else
        {
                dbp = dbp2;
                dbenvp = dbenvp2;
        }
        tmp = getname(name);

        ret = dbp->open(dbp, NULL, tmp, NULL, type, flags, mode);

        putname(tmp);

        if (ret == 0)
		printk("Open db succssfully\n");
	
        return ret;     
}

int sys_db3_close(int db, u_int32_t flags)
{
        DB *dbp; 
        int ret;

	printk("entering sys_db3_close()\n");

        if (db == 1)
        {
                dbp = dbp1;
        }
        else
        {
                dbp = dbp2;
        }

        ret = dbp->close(dbp, flags);

        if (ret == 0) 
		printk("Closed db succssfully\n");  
        return ret;
}



int sys_db3_get_table(int db) 
{
         DBC *dbcp;
         DB *dbp;
         DBT tk, td;
         int ret, c;
	 if (db == 1)
	   {
	     dbp = dbp1;
	   }
	 else
	   {
	     dbp = dbp2;
	   }
	 

         memset(&tk, 0, sizeof(tk));
         memset(&td, 0, sizeof(td));
         printk("Records in DB: \n");
         printk("key        data\n");
         printk("--------------------\n");
         if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) == 0)
         {
                 c = 0;
                 while ((ret = dbcp->c_get(dbcp, &tk, &td, DB_NEXT)) == 0)
                 {
                         printk("%s        %s\n", (char *)tk.data, (char *)td.data);
                         c ++;
                 }
                 dbcp->c_close(dbcp);//close cursor
                 printk("Totally %d records in db\n", c);
         }
	 return ret;
}
	



static void dumpdb(DB *dbp)
 {
         DBC *dbcp;
         
         DBT tk, td;
         int ret, c;
 
         memset(&tk, 0, sizeof(tk));
         memset(&td, 0, sizeof(td));
         printk("Records in DB: \n");
         printk("key        data\n");
         printk("--------------------\n");
         if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) == 0)
         {
                 c = 0;
                 while ((ret = dbcp->c_get(dbcp, &tk, &td, DB_NEXT)) == 0)
                 {
                         printk("%s        %s\n", (char *)tk.data, (char *)td.data);
                         c ++;
                 }
                 dbcp->c_close(dbcp);//close cursor
                 printk("Totally %d records in db\n", c);
         }
 }


int init_module(void)
{
	printk("initializing the module\n");

#if 0
        original_call255 = sys_call_table[__NR_db3_create];
        sys_call_table[__NR_db3_create] = sys_db3_create;
	
        original_call254 = sys_call_table[__NR_db3_open];
        sys_call_table[__NR_db3_open] = sys_db3_open;

        original_call253 = sys_call_table[__NR_db3_get];
        sys_call_table[__NR_db3_get] = sys_db3_get;

        original_call252 = sys_call_table[__NR_db3_put];
        sys_call_table[__NR_db3_put] = sys_db3_put;

        original_call251 = sys_call_table[__NR_db3_close];
        sys_call_table[__NR_db3_close] = sys_db3_close;

	//        original_call250 = sys_call_table[__NR_db3_delete];
        original_call250 = sys_call_table[__NR_db3_get_table];
	//	sys_call_table[__NR_db3_delete] = sys_db3_delete;
	sys_call_table[__NR_db3_get_table] = sys_db3_get_table;
        dbp1 = NULL; dbp2 = NULL;
        dbenvp1 = NULL; dbenvp2 = NULL;
#endif
        return 0;
}





void cleanup_module(void)
{
	printk("cleaning up the module\n");
#if 0
	sys_call_table[__NR_db3_create] = original_call255;
        sys_call_table[__NR_db3_open] = original_call254;
        sys_call_table[__NR_db3_get] = original_call253; 
        sys_call_table[__NR_db3_put] = original_call252;
        sys_call_table[__NR_db3_close] = original_call251;
	//        sys_call_table[__NR_db3_delete] = original_call250;
        sys_call_table[__NR_db3_get_table] = original_call250;
#endif
}