Re: command line arguments

["black hole" <neyrith@xxxxxxxxx>]

Hi,

Here is a simple kernel module, that prints the arguments
of a particular task.

// Print task's arguments, Linux Kernel 2.6.12.2.
//
// A simple kernel module that prints the arguments of a given task.
// After successfull execve(), the arguments (together with the environment)
// reside in user space memory. There is no kernel data structure that
// provides direct access to task's arguments. This fact can be observed
// from how do_execve() and proc_pid_cmdline() work.
//
// The do_execve() first copies the arguments and environment into
// kernel space. Looking at the source code reveals that bprm variable
// holds the copied data and it is freed later.
//
// The proc_pid_cmdline() shows how to access the relevant data from
// user space pages. It uses the access_process_vm() to do this.
// Since this function is not exported, the get_user_pages() is used instead.
//
// This kernel module implements a simple character device with file operations
// open(), release() and read(). The read() method prints the task's arguments.
//
// I hope the code is correct. It is essentially a copy-paste-edit
// of access_process_vm().
//
// # mknod args c 253 0
// # cat args a b c d e f
// # dmesg
//
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/binfmts.h>
#include <linux/highmem.h>
#include <linux/pagemap.h>


#define FIRST_MINOR 0
#define MINOR_COUNT 1
#define DEVICE_NAME "args"

static dev_t device_number;
static struct cdev device;

static int open_fop(struct inode *, struct file *);
static int release_fop(struct inode *, struct file *);
static ssize_t read_fop(struct file *file, char __user *buf,
       size_t size, loff_t *off);

static struct file_operations fops=
{
   owner:THIS_MODULE,
   open:open_fop,
   release:release_fop,
   read:read_fop,
};

static void print_args(struct task_struct *task);


static int __init init(void)
{
   int ret;

   if((ret=alloc_chrdev_region(&device_number, FIRST_MINOR,
           MINOR_COUNT, DEVICE_NAME))<0)
       goto out;

   cdev_init(&device, &fops);
   if((ret=cdev_add(&device, device_number, MINOR_COUNT))<0){
       unregister_chrdev_region(device_number, MINOR_COUNT);
       goto out;
   }

out:
   return ret;
}

static void __exit exit(void)
{
   cdev_del(&device);
   unregister_chrdev_region(device_number, MINOR_COUNT);
}


module_init(init);
module_exit(exit);
MODULE_LICENSE("GPL");

static int open_fop(struct inode *inode, struct file *file)
{
   try_module_get(THIS_MODULE);
   return 0;
}

static int release_fop(struct inode *inode, struct file *file)
{
   module_put(THIS_MODULE);
   return 0;
}

static ssize_t read_fop(struct file *file, char __user *buf,
       size_t size, loff_t *off)
{
   print_args(current);
   return 0;
}


#define NEWLINE     '\n'
#define NULLCHAR    0

#define GUP_LEN     1
#define GUP_WRITE   0
#define GUP_FORCE   1

static void print_args(struct task_struct *task)
{
   struct mm_struct *mm=task->mm;
   struct page *page=0;
   struct vm_area_struct *vma=0;
   char *addr=0;
   int offset=0;
   int bytes=0;
   int i=0;

   // The task's arguments lie in the user space
   // virtual memory range <mm->arg_start, mm->arg_end).
   // Therefore the total size of task's arguments is the following.
   int args_size=mm->arg_end-mm->arg_start;
   int start=mm->arg_start;

   struct page *tmp_page=0;
   char *tmp_addr=0;


   tmp_page=alloc_page(GFP_HIGHUSER);
   tmp_addr=kmap(tmp_page);

   down_read(&mm->mmap_sem);

   // The arguments are printed page by page.
   // Every cycle prints the contents of one page.
   while(args_size){

       // Make the user space page available in kernel space.
       // The get_user_pages() creates shared mapping (not a copy
       // of the user space contents).
       if(get_user_pages(task, mm, start, GUP_LEN, GUP_WRITE,
               GUP_FORCE, &page, &vma)<=0)
           goto out;

       addr=kmap(page);

       // Here, the task's arguments are available in kernel space memory.
       // Note that the mm->arg_start does not have to be page-aligned,
       // therefore the arguments can start in the middle of the page
       // (not just at the beginning).

       offset=start&(PAGE_SIZE-1);
       bytes=PAGE_SIZE-offset;
       if(args_size<bytes)
           bytes=args_size;

       // Every null-character is substituted for newline for the
       // purpose of pretty-printing. Because the get_user_pages
       // creates shared mapping, the contents are first copied
       // to temporary storage.
       memcpy(tmp_addr, addr, PAGE_SIZE);
       for(i=offset; i<PAGE_SIZE; ++i)
           if(tmp_addr[i]==NULLCHAR)
               tmp_addr[i]=NEWLINE;

       // The printing is not very precise. A single argument can
       // overlap two consecutive pages. In that case, its print
       // is interrupted by a newline.
       printk(KERN_NOTICE "%.*s\n", bytes, tmp_addr+offset);

       kunmap(page);
       page_cache_release(page);

       args_size-=bytes;
       start+=bytes;
   }

out:
   up_read(&mm->mmap_sem);

   kunmap(tmp_page);
   __free_page(tmp_page);
}


BlackHole

--
To unsubscribe from this list: send an email with
"unsubscribe kernelnewbies" to ecartis@xxxxxxxxxxxx
Please read the FAQ at http://kernelnewbies.org/FAQ