0

I believe I may be over-thinking this problem a bit... I've got a text file located on my filesystem which I am parsing at boot and storing the results into an array of structs. I need to copy this array from user space into kernel space (copy_from_user), and must have this data accessible by the kernel at any time. The data in kernel space will need to be accessed by the Sockets.c file. Is there a special place to store an array within kernel space, or can I simply add a reference to the array in Sockets.c? My C is a bit rusty...

Thanks for any advice.

CxD
  • 1
  • 1
  • 1
  • I am not sure what you are asking... A pointer to a kmalloc'ed (or vmalloc'ed if there's a lot of data) buffer containing your array would suffice. Make sure to free it once you are done. – thkala Nov 23 '10 at 22:18
  • Sorry if I wasn't clear. The file is to be read initially upon booting the system, and this data will need to be accessed at any time within the kernel. Basically, I'm using a helper program in user space to parse the file. I would like to copy the results of the array to kernel space, and then terminate the user space program. I need to be able to access the data at any time within the Sockets.c file. I'm unsure of how to do this exactly. My searching has brought up a lot of information regarding modules, but I'm unsure if this is the "proper" way of doing this. – CxD Nov 23 '10 at 22:27

4 Answers4

6

I believe there are two main parts in your problem:

  • Passing the data from userspace to kernelspace

  • Storing the data in the kernelspace

For the first issue, I would suggest using a Netlink socket, rather than the more traditional system call (read/write/ioctl) interface. Netlink sockets allow configuration data to be passed to the kernel using a socket-like interface, which is significantly simpler and safer to use.

Your program should perform all the input parsing and validation and then pass the data to the kernel, preferably in a more structured form (e.g. entry-by-entry) than a massive data blob.

Unless you are interested in high throughput (megabytes of data per second), the netlink interface is fine. The following links provide an explanation, as well as an example:

http://en.wikipedia.org/wiki/Netlink

http://www.linuxjournal.com/article/7356

http://linux-net.osdl.org/index.php/Generic_Netlink_HOWTO

http://www.kernel.org/doc/Documentation/connector/

As far as the array storage goes, if you plan on storing more than 128KB of data you will have to use vmalloc() to allocate the space, otherwise kmalloc() is preferred. You should read the related chapter of the Linux Device Drivers book:

http://lwn.net/images/pdf/LDD3/ch08.pdf

Please note that buffers allocated with vmalloc() are not suitable for DMA to/from devices, since the memory pages are not contiguous. You might also want to consider a more complex data structure like a list if you do not know how many entries you will have beforehand.

As for accessing the storage globally, you can do it as with any C program:

In a header file included by all .c files that you need to access the data put something like:

extern struct my_struct *unique_name_that_will_not_conflict_with_other_symbols;

The extern keyword indicates that this declares a variable that is implemented at another source file. This will make this pointer accesible to all C files that include this header. Then in a C file, preferrably the one with the rest of your code - if one exists:

struct my_struct *unique_name_that_will_not_conflict_with_other_symbols = NULL;

Which is the actual implementation of the variable declared in the header file.

PS: If you are going to work with the Linux kernel, you really need to brush up on your C. Otherwise you will be in for some very frustrating moments and you WILL end up sorry and sore.

PS2: You will also save a lot of time if you at least skim through the whole Linux Device Drivers book. Despite its name and its relative age, it has a lot of information that is both current and important when writing any code for the Linux Kernel.

thkala
  • 84,049
  • 23
  • 157
  • 201
  • netlink is not simpler or "safer" than an ioctl, that doesn't mean you shouldn't use netlink, but there's nothing wrong with ioctls either. – mpe Nov 24 '10 at 11:58
  • @mpe: It is in the sense that the userspace API is more familiar and that the netlink kernel facilities are at a somewhat higher level. Otherwise you can mess up with netlink just as much as you can with anything else in the kernel :-/ – thkala Nov 25 '10 at 00:01
1

You can just define an extern pointer somewhere in the kernel (say, in the sockets.c file where you're going to use it). Initialise it to NULL, and include a declaration for it in some appropriate header file.

In the part of the code that does the copy_from_user(), allocate space for the array using kmalloc() and store the address in the pointer. Copy the data into it. You'll also want a mutex to be locked around access to the array.

The memory allocated by kmalloc() will persist until freed with kfree().

caf
  • 233,326
  • 40
  • 323
  • 462
1

Your question is basic and vague enough that I recommend you work through some of the exercises in this book. The whole of chapter 8 is dedicated to allocating kernel memory.

Karl Bielefeldt
  • 47,314
  • 10
  • 60
  • 94
0

Initializing the Array as a global variable in your Kernel Module will make it accessible forever until the kernel is running i.e. until your system is running.

BoRRis
  • 983
  • 8
  • 23