Sorry, I forgot to finish a thought related to the topic of userspace parameters passed to system calls.


The fixed string you are passing to acct_process is coming from an address inside kernel space (since the fixed string is part of the module you compile and link into the kernel with insmod). The error you get, -14, or EFAULT, means that you have a "bad address".

Or in other words, the real sys_creat function doesn't like the pointer to your fixed string because sys_creat expects a pointer in userspace, whereas you've given it one in kernelspace.


This can be fixed by one of two ways:


One, you find a way to allocate userspace memory, copy your string to that allocated userspace memory, and then pass acc_process() the pointer to that userspace memory. This is difficult since you can't readily allocate userspace memory from the kernel (at least it would be _very_ tricky).


The other option is to trick the kernel into thinking the pointer you're passing sys_creat is in fact in userspace and it's okay to operate on it. For this, I will explain a little bit of background:


The kernel uses register segments to define where userspace and kernelspace are split. Commonly, userspace is assigned to any address below 3GB, and kernelspace is assigned to any address above 3GB (up to 4GB, assuming a 32-bit architecture, and more specifically, x86 hardware). There are lots of caveats to what I just said, but you can probably assume what I said is okay in your situation.


The kernel uses the 3GB boundary to determine if an address comes from userspace (0-3GB) or kernelspace (3-4GB), and can generate an EFAULT error when it doesn't like where something is coming from.


If you change the boundary from 3GB to 4GB, so that the kernel's idea of "valid userspace addresses" is now from 0-4GB it won't have an error.


To change the boundary, you have to change the segment register in your processor (I'm assuming x86 architecture here). To do that, you have to temporarily store the original segment, replace it, call your system call (where it will think even kernelspace pointers are okay), and finally set the segment back to its original value.


That being said, and I may have screwed up there, but the following is taken from a reprint of a Linux Magazine article, which has a much more detailed (and probably more correct) explaination of this process:

      mm_segment_t fs;

      fs = get_fs();     /* save previous value */
      set_fs (get_ds()); /* use kernel limit */

      /* system calls can be invoked */

      set_fs(fs); /* restore before returning to user space */

So, using that idea in your code would yeild:

long (*acct_process) (const char * , int ) = ( long (*) (const char*,int )) 0xc0149640 ;

int init_module(void)
{
    long ret =10 ;
    mm_segment_t fs;
    printk("SYSCREATE : MODULE INIT \n");
    *(long *)&acct_code[1] = (long)_acct_process;

    /* Modify kernel's limit for valid addresses */
    fs = get_fs();
    set_fs (get_ds());

    /* Make system call */
    ret =acct_process("/home/appadurai/TestWorld.txt",0777 );

    /* Restore to previous limit */
    set_fs(fs);

    printk("SYSCREATE : RETURN VALUE AFTER %ld \n" , ret);
    return 0;
}

void cleanup_module(void)
{
    printk(" SYSCREATE : CLEANING MODULE PARAMETERS\n");
} 

In general, this will allow you to supply kernelspace pointers where other system calls expect userspace pointers.


And, assuming that I haven't spaced off another critical part of what I was trying to say, that should work. One final note, though - make use of the MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros. If you oops the kernel, you'll at least know about it when it shows a constant use count in lsmod output.