941f45ac117a41363fb0758243950d382d16a919
[linux-2.6.git] / include / linux / textsearch.h
1 #ifndef __LINUX_TEXTSEARCH_H
2 #define __LINUX_TEXTSEARCH_H
3
4 #ifdef __KERNEL__
5
6 #include <linux/types.h>
7 #include <linux/list.h>
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/err.h>
11
12 struct ts_config;
13
14 /**
15  * TS_AUTOLOAD - Automatically load textsearch modules when needed
16  */
17 #define TS_AUTOLOAD     1
18
19 /**
20  * struct ts_state - search state
21  * @offset: offset for next match
22  * @cb: control buffer, for persistant variables of get_next_block()
23  */
24 struct ts_state
25 {
26         unsigned int            offset;
27         char                    cb[40];
28 };
29
30 /**
31  * struct ts_ops - search module operations
32  * @name: name of search algorithm
33  * @init: initialization function to prepare a search
34  * @find: find the next occurrence of the pattern
35  * @destroy: destroy algorithm specific parts of a search configuration
36  * @get_pattern: return head of pattern
37  * @get_pattern_len: return length of pattern
38  * @owner: module reference to algorithm
39  */
40 struct ts_ops
41 {
42         const char              *name;
43         struct ts_config *      (*init)(const void *, unsigned int, int);
44         unsigned int            (*find)(struct ts_config *,
45                                         struct ts_state *);
46         void                    (*destroy)(struct ts_config *);
47         void *                  (*get_pattern)(struct ts_config *);
48         unsigned int            (*get_pattern_len)(struct ts_config *);
49         struct module           *owner;
50         struct list_head        list;
51 };
52
53 /**
54  * struct ts_config - search configuration
55  * @ops: operations of chosen algorithm
56  * @get_next_block: callback to fetch the next block to search in
57  * @finish: callback to finalize a search
58  */
59 struct ts_config
60 {
61         struct ts_ops           *ops;
62
63         /**
64          * get_next_block - fetch next block of data
65          * @consumed: number of bytes consumed by the caller
66          * @dst: destination buffer
67          * @conf: search configuration
68          * @state: search state
69          *
70          * Called repeatedly until 0 is returned. Must assign the
71          * head of the next block of data to &*dst and return the length
72          * of the block or 0 if at the end. consumed == 0 indicates
73          * a new search. May store/read persistant values in state->cb.
74          */
75         unsigned int            (*get_next_block)(unsigned int consumed,
76                                                   const u8 **dst,
77                                                   struct ts_config *conf,
78                                                   struct ts_state *state);
79
80         /**
81          * finish - finalize/clean a series of get_next_block() calls
82          * @conf: search configuration
83          * @state: search state
84          *
85          * Called after the last use of get_next_block(), may be used
86          * to cleanup any leftovers.
87          */
88         void                    (*finish)(struct ts_config *conf,
89                                           struct ts_state *state);
90 };
91
92 /**
93  * textsearch_next - continue searching for a pattern
94  * @conf: search configuration
95  * @state: search state
96  *
97  * Continues a search looking for more occurrences of the pattern.
98  * textsearch_find() must be called to find the first occurrence
99  * in order to reset the state.
100  *
101  * Returns the position of the next occurrence of the pattern or
102  * UINT_MAX if not match was found.
103  */ 
104 static inline unsigned int textsearch_next(struct ts_config *conf,
105                                            struct ts_state *state)
106 {
107         unsigned int ret = conf->ops->find(conf, state);
108
109         if (conf->finish)
110                 conf->finish(conf, state);
111
112         return ret;
113 }
114
115 /**
116  * textsearch_find - start searching for a pattern
117  * @conf: search configuration
118  * @state: search state
119  *
120  * Returns the position of first occurrence of the pattern or
121  * UINT_MAX if no match was found.
122  */ 
123 static inline unsigned int textsearch_find(struct ts_config *conf,
124                                            struct ts_state *state)
125 {
126         state->offset = 0;
127         return textsearch_next(conf, state);
128 }
129
130 /**
131  * textsearch_get_pattern - return head of the pattern
132  * @conf: search configuration
133  */
134 static inline void *textsearch_get_pattern(struct ts_config *conf)
135 {
136         return conf->ops->get_pattern(conf);
137 }
138
139 /**
140  * textsearch_get_pattern_len - return length of the pattern
141  * @conf: search configuration
142  */
143 static inline unsigned int textsearch_get_pattern_len(struct ts_config *conf)
144 {
145         return conf->ops->get_pattern_len(conf);
146 }
147
148 extern int textsearch_register(struct ts_ops *);
149 extern int textsearch_unregister(struct ts_ops *);
150 extern struct ts_config *textsearch_prepare(const char *, const void *,
151                                             unsigned int, int, int);
152 extern void textsearch_destroy(struct ts_config *conf);
153 extern unsigned int textsearch_find_continuous(struct ts_config *,
154                                                struct ts_state *,
155                                                const void *, unsigned int);
156
157
158 #define TS_PRIV_ALIGNTO 8
159 #define TS_PRIV_ALIGN(len) (((len) + TS_PRIV_ALIGNTO-1) & ~(TS_PRIV_ALIGNTO-1))
160
161 static inline struct ts_config *alloc_ts_config(size_t payload, int gfp_mask)
162 {
163         struct ts_config *conf;
164
165         conf = kmalloc(TS_PRIV_ALIGN(sizeof(*conf)) + payload, gfp_mask);
166         if (conf == NULL)
167                 return ERR_PTR(-ENOMEM);
168
169         memset(conf, 0, TS_PRIV_ALIGN(sizeof(*conf)) + payload);
170         return conf;
171 }
172
173 static inline void *ts_config_priv(struct ts_config *conf)
174 {
175         return ((u8 *) conf + TS_PRIV_ALIGN(sizeof(struct ts_config)));
176 }
177
178 #endif /* __KERNEL__ */
179
180 #endif