extern "C" {
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/init.h>

#include <asm/errno.h>

//#include <linux/slab.h>
#define __GFP_WAIT      0x10    /* Can wait and reschedule? */
#define __GFP_HIGH      0x20    /* Should access emergency pools? */
#define __GFP_IO        0x40    /* Can start low memory physical IO? */
#define __GFP_HIGHIO    0x80    /* Can start high mem physical IO? */
#define __GFP_FS        0x100   /* Can call down to low-level FS? */

#define GFP_KERNEL      (__GFP_HIGH | __GFP_WAIT | __GFP_IO | __GFP_HIGHIO | __GFP_FS)

extern void *kmalloc(size_t, int);
extern void kfree(const void *);

void __pure_virtual() 
{
	printk( KERN_INFO "__pure_virtual: Hello bonehead, your are calling a pure virtual!!!\n");
}

void __cxa_pure_virtual()
{
	printk( KERN_INFO "__cxa_pure_virtual: Hello bonehead, your are calling a pure virtual!!!\n");
}
}

void *operator new(size_t n)
{
	return kmalloc( n, GFP_KERNEL);
}

void operator delete(void *p)
{
	kfree( p);
}

class MyModule
{
public:
	MyModule( void)
	{
		printk( KERN_INFO "MyModule::MyModule\n");
	}

	virtual ~MyModule()
	{
		printk( KERN_INFO "MyModule::~MyModule\n");
	}
	
	virtual int init( void)
	{
		printk( KERN_INFO "MyModule::init\n");
		return 0;
	}

	virtual void gong( void) = 0;
};

class MyDerivedKernelModule: public MyModule
{
public:
	MyDerivedKernelModule( int i): MyModule()
	{
		printk( KERN_INFO "MyDerivedKernelModule::MyDerivedKernelModule(int i=%d)\n", i);
	}

	~MyDerivedKernelModule()
	{
		printk( KERN_INFO "MyDerivedKernelModule::~MyDerivedKernelModule\n");
	}
	
	virtual void gong( void)
	{
		printk( KERN_INFO "MyDerivedKernelModule::gong\n");
	}
};

static MyModule *myModule = 0;

extern "C" {
int __init cpp_init(void)
{
	myModule = new MyDerivedKernelModule(9);

	if( !myModule) return -ENOMEM;

	myModule->gong();

	return myModule->init();
}

void __exit cpp_exit(void)
{
	delete myModule;
}

module_init(cpp_init);
module_exit(cpp_exit);
}