The flood of patches going into the mainline 2.6.13 brings with it the
usual assortment of changes to the internal kernel API. Here's a subset of
The configurable HZ patch has been merged. If there is, somehow,
code which has survived this far with assumptions about the value of
HZ, it should probably be fixed sometime soon.
There is a new timer function:
int try_to_del_timer_sync(struct timer_list *timer);
This function will make a best effort to delete the timer. Should the
timer function actually be running at the time, however, this version will
not wait for it to complete; it will return -1 immediately. It
can thus be used in interrupt handlers and other contexts where waiting for
a timer function to finish is not an option.
The block_device_operations structure has a new member:
long (*unlocked_ioctl) (struct file *filp, unsigned cmd,
unsigned long arg);
If an unlocked_ioctl() method exists, it will be called (in
preference to ioctl()), and the big kernel lock will not be held.
Drivers which perform their own locking (which should be all of them,
really) can use the new method to avoid the overhead of the BKL.
The netif_rx() function, used by network drivers (when not in NAPI
mode) to feed packets into the kernel, has traditionally returned one of
several values indicating how congested the system was. The idea was that
drivers could use this information to reduce load on the kernel as
congestion increases. No drivers do this, however; instead, NAPI is used
for high-traffic situations. So netif_rx() now will return one of
two values: NETIF_RX_SUCCESS if all is well, or
NETIF_RX_DROP if the packet was dropped.
It's also worth noting that the sk_buff structure has changed
again, leading to the usual troubles with binary-only drivers.
Authors of PCI drivers who want to squeeze out every bit of DMA performance
from their hardware can use a new function to determine the optimal DMA
void pci_dma_burst_advice(struct pci_dev *pdev,
enum pci_dma_burst_strategy *strat,
unsigned long *param);
On return, strat will tell which strategy works best on the
current platform. PCI_DMA_BURST_INFINITY says that bursts should
simply be made as large as possible; in this case, param contains
no information. PCI_DMA_BURST_BOUNDARY tells the driver to not
burst across memory boundaries which are a multiple of the value returned
in param. And PCI_DMA_BURST_MULTIPLE sets a maximum size
(returned in param) on each individual burst.
Thomas Graf has contributed a generic text searching mechanism for the
kernel. It can handle searching through non-contiguous data, and is
designed to work with pluggable searching algorithms. A couple of search
modules have been provided: a straight Knuth/Morris/Pratt string matcher
and a finite state machine version which provides a limited regular
expression mechanism. The initial application for this library is for
flexible packet classification in the networking traffic control code, but
other uses are possible.
Performing a search requires first setting up a configuration:
struct ts_config *textsearch_prepare(const char *algorithm,
const void *pattern,
unsigned int patlen,
int gfp_mask, int flags);
Here, algorithm is the searching algorithm to use;
"kmp" will get Knuth/Morris/Pratt. pattern is the actual
pattern to search for; patlen is its length. The usual memory
allocation flags are provided in gfp_mask, and flags is
for search-specific flags. Currently, the only flag is
TS_AUTOLOAD, which allows the kernel to load a module implementing
the desired search algorithm, if necessary. The return value is a
pointer to a configuration structure to be used with the other functions,
or an error value (as determined by IS_ERR()).
A ts_config structure, once initialized, can be reused as many
times as desired. It
contains no per-search state, so it can be used in parallel searches as
well. When the structure is no longer needed, it should be returned with a
call to textsearch_destroy().
If the data to be searched is a single, contiguous block, then searching is
a matter of calling:
unsigned int textsearch_find_continuous(struct ts_config *config,
struct ts_state *state,
const void *data,
unsigned int datalen);
unsigned int textsearch_next(struct ts_config *config,
struct ts_state *state);
For these calls, config is a configuration returned from
textsearch_prepare(), and state is a local state
variable. A call to textsearch_find_continuous() must come first;
it will initialize state for a search through the given
data array. Both functions will return the offset of the
beginning of the match, or UINT_MAX if no (further) match is
If the data to be searched is not contiguous in memory, things get a little
more complicated. The caller must provide a method which can obtain a
pointer to a block of data:
unsigned int (*get_next_block)(unsigned int consumed,
const u8 **dst,
struct ts_config *config,
struct ts_state *state);
This function will be called by the textsearch code when it needs more data
to look through. It should locate the first byte beyond consumed
and store its address in *dst. The config pointer will
not normally be used; state->cb is a 40-byte "control buffer"
which can be used to store data between calls to
get_next_block(). The return value is the length of the block, or
zero if there is no more data.
void (*finish)(struct ts_config *config, struct ts_state *state);
will be called after each search completes. Note that there can be several
get_next_block() calls for each call to finish().
Both of these methods are stored in the ts_config structure; they
should be set there after the call to textsearch_prepare(). The
first search is performed with:
unsigned int textsearch_find(struct ts_config *config,
struct ts_state *state);
Subsequent searches can be performed with textsearch_next().
to post comments)