cat /proc/meminfo produces the output below. I haven't been able to find any documenation explaining what the Active(File) field is? Can somebody please point me in the right direction?

Active appears to be equal to the sum of Active(anon) and Active(file). I know it's not what you're currently looking for but it's an observation that brings us a little closer to understanding.

The latest kernel Ubuntu 12.04 is Linux Kernel 3.2.x. According to the documentation in the kernel source under Documentation/filesystems/proc.txt there doesn't appear to be Active(anon) nor Active(file) listed. So I'm not sure if this is a case of missing documentation on the subject without actually diving into the source code.

I think Active(anon) shows anonymous pages counts and Active(file) shows page/swap cache i.e., cached and swap cache file counts.

anon in Active(anon) is likely referring to anonymous memory which is essentially heap/stack memory which is allocated by programs using malloc. It basically is memory with no filesystem associations.

file in Active(file) is likely referring to the File Cache which contains disk and network filesystem data and metadata (can include files loaded into memory and possibly execution code from disk?).

I'm still not trying to answer what exactly Active(anon) and Active(file) fields actually mean (though I could make an educated guess by adding the definition of Active memory to the terms discussed). I'd rather know for sure before giving a final answer. I've asked about it in the #kernel channel on freenode so we'll see if anyone replies over the next couple of days with (hopefully) reliable sources.

Here's some additional reading I found while looking into the subject...

• http://linux-mm.org/PageReplacementDesign
• http://oreilly.com/catalog/spt2/chapter/ch04.html#21495

I did search for answers on this one but couldn't find a direct one, although I found some related info that might be interesting to read:
http://lxr.free-electrons.com/source...=2.6.36;a=mips
http://linux.die.net/man/5/proc

Regards

I'm asking because I'm trying to understand if my embedded design is swapping memory or not. The output below is from my board running 2.6.30. All of the swap fields report 0, however, I'm not convinced.

I've posted this scenario in another topic in the embedded forum, but I'll describe it here as well since the question is really platform independent.

1. An application thread reads from a device driver, passing in a pointer.
2. The device driver blocks until an interrupt occurs
3. While the device driver is blocking, the thread gets swapped out (what happens to the pointer from step one here, is it still valid?)
4. The driver gets an interrupt, and writes to the pointer. If the pointer is no longer valid, a kernel oops would occur.

Is this scenario possible? I'm having a problem where my application crashes at random intervals. I'm wondering if the scenario above is causing it. Here's the kernel output:

Perhaps this would be more useful. See also 2nd bullet. You didn't bother linking this "other topic" you posted this in. Seeing source code is many times useful to learning more about the problem. Time = wasted; please don't.

A good resource: Linux Device Drivers

I resolved the kernel oops. My application is crashing (still not resolved). When it crashes, a pointer sent to one of my drivers is used when cleaning up, causing the kernel oops. I was dereferencing the pointer in the driver, without using copy_to_user.

I appreciate your time regarding the active file information.

That resource I referenced you is a good one for kernel debugging. I'd highly recommend reading through Ch 4 at least (if I recall that's the chapter on the debugging).