Write data to proc

strider82 · 04-02-2009, 10:37 AM

I have some pre-computed data which I need to write to /proc, so that another kernel module can access it. I have written a kernel module to create the file in /proc, but not sure how to write data into it. The data to be written is already hardcoded into a structure in the module.

Thanks,

David1357 · 04-02-2009, 12:20 PM

Quote:

Originally Posted by strider82

I have written a kernel module to create the file in /proc, but not sure how to write data into it.

You need to add a read handler to the "struct file_operations" that you assign to entry->proc_fops. When someone does something like "cat /proc/sys/your_entry", the read handler will be called. In your read handler, you will convert the data in the structure to human readable format using snprintf.

Look at pages 83-90 of "Linux Device Drivers, 3rd. Ed", Corbet et. al.

If you don't have this book, run, don't walk, to Amazon.com and buy it.

jiml8 · 04-02-2009, 01:38 PM

This code does that. A command string is passed in (by a userspace app that writes to /proc ) with an arbitrary number of commands in the form var=val;var=val and so forth. This code parses the individual var=val strings using the semicolon as a separator then passes the result on to a subroutine (proc_cmd) that does appropriate things with the data.

This is code that I wrote from scratch; you may use those portions of it that help you.

Code:

#define CMD_BUFFER_MAX_LEN 40

int dsp_write_procmem(struct file *file, const char __user *buf,
			   unsigned long count, void *data)
{
  char *loc_buf,*stst,*sten,*cmdbuf,tstchar,delimit;
  int cmdlen,stdiff,stdiff2,cmdpassed;
  char usecmd[CMD_BUFFER_MAX_LEN];
  cmdlen = CMD_BUFFER_MAX_LEN; //maximum length of any given command string
  delimit = 0x3b; //semicolon as a command delimiter
  cmdbuf = &usecmd[0];
  loc_buf = kmalloc(count,GFP_KERNEL);
  if(copy_from_user(loc_buf,buf,count)) {return -EFAULT;}
  stst = loc_buf;
  sten = loc_buf;
  stdiff = 0;
  while(*stst == 0x20 && stdiff < count) { //strip any leading spaces
	stst++;
	sten++;
  	stdiff = stst - loc_buf;
  }
  stdiff = (int)(stst - loc_buf);
  stdiff2 = (int)(sten - loc_buf);
  while(stdiff <= count && stdiff2 <= count){  //parse the command line, separating commands on semicolons
	tstchar = *sten;
	if(tstchar == delimit || tstchar == 0x0) {
		if(sten-stst <= 1) {//two semicolons in a row; no data
			sten++;
			stst = sten;
		} else {
			cmdpassed = 0;
			memset(cmdbuf,0x0,CMD_BUFFER_MAX_LEN);
			while(stst < sten && cmdpassed < CMD_BUFFER_MAX_LEN) {
				if(*stst == 0x0a || *stst == 0x0d){stst++;} //strip newlines
				*cmdbuf++ = *stst++;
				cmdpassed++;
			}
			cmdbuf = &usecmd[0];
			if(cmdpassed == CMD_BUFFER_MAX_LEN) {
				printk("<1>tidsp:  Error; command buffer length overflow.  Command was %s\n",(char *)usecmd);
			}
			sten++;
			stst = sten;
			if(tstchar == 0x0) {
				stdiff = count;
			} else {
  				stdiff = (int)(stst - loc_buf);
			}
  			stdiff2 = (int)(sten - loc_buf);
			proc_cmd(file,cmdbuf);
		}
	} else {
		sten++;
  		stdiff = (int)(stst - loc_buf);
  		stdiff2 = (int)(sten - loc_buf);
	}
  }
  kfree(loc_buf);
return count;
}