Linux Device Drivers (3rd Edition) [Electronic resources] نسخه متنی

8.6. Obtaining Large Buffers

As we have noted in previous
sections, allocations of large, contiguous memory buffers are prone
to failure. System memory fragments over time, and chances are that a
truly large region of memory will simply not be available. Since
there are usually ways of getting the job done without huge buffers,
the kernel developers have not put a high priority on making large
allocations work. Before you try to obtain a large memory area, you
should really consider the alternatives. By far the best way of
performing large I/O operations is through scatter/gather operations,
which we discuss
in Chapter 15.

8.6.1. Acquiring a Dedicated Buffer at Boot Time

If you really need a huge buffer of physically contiguous memory, the
best approach is often to allocate it by requesting memory at boot
time. Allocation at boot time is the only way to retrieve consecutive
memory pages while bypassing the limits imposed by _
_get_free_pages on the buffer size, both in terms of
maximum allowed size and limited choice of sizes. Allocating memory
at boot time is a "dirty"
technique, because it bypasses all memory management policies by
reserving a private memory pool. This technique is inelegant and
inflexible, but it is also the least prone to failure. Needless to
say, a module can't allocate memory at boot time;
only drivers directly linked to the kernel can do that.

One noticeable problem with boot-time allocation is that it is not a
feasible option for the average user, since this mechanism is
available only for code linked in the kernel image. A device driver
using this kind of allocation can be installed or replaced only by
rebuilding the kernel and rebooting the computer.

When the kernel is booted, it gains access to all the physical memory
available in the system. It then initializes each of its subsystems
by calling that subsystem's initialization function,
allowing initialization code to allocate a memory buffer for private
use by reducing the amount of RAM left for normal system operation.

Boot-time memory allocation is performed by calling one of these
functions:

#include <linux/bootmem.h>
void *alloc_bootmem(unsigned long size);
void *alloc_bootmem_low(unsigned long size);
void *alloc_bootmem_pages(unsigned long size);
void *alloc_bootmem_low_pages(unsigned long size);

The functions allocate either whole pages (if they end with
_pages) or non-page-aligned memory areas. The
allocated memory may be high memory unless one of the
_low versions is used. If you are allocating this
buffer for a device driver, you probably want to use it for DMA
operations, and that is not always possible with high memory; thus,
you probably want to use one of the _low variants.

It is rare to free memory allocated at boot time; you will almost
certainly be unable to get it back later if you want it. There is an
interface to free this memory, however:

void free_bootmem(unsigned long addr, unsigned long size);

Note that partial pages freed in this manner are not returned to the
systembut, if you are using this technique, you have probably
allocated a fair number of whole pages to begin with.

If you must use boot-time allocation, you need to link your driver
directly into the kernel. See the files in the kernel source under
Documentation/kbuild for more information on how
this should be done.