0 _I|Mjq؂File not found. File not found. " lm_J*j"Tfqţ h 00 A l4( (  fB- _I|+am_J*j"Tfq)F /* SPDX-License-Identifier: GPL-2.0 */ #ifndef __LINUX_TEXTSEARCH_FSM_H #define __LINUX_TEXTSEARCH_FSM_H #include enum { TS_FSM_SPECIFIC, /* specific character */ TS_FSM_WILDCARD, /* any character */ TS_FSM_DIGIT, /* isdigit() */ TS_FSM_XDIGIT, /* isxdigit() */ TS_FSM_PRINT, /* isprint() */ TS_FSM_ALPHA, /* isalpha() */ TS_FSM_ALNUM, /* isalnum() */ TS_FSM_ASCII, /* isascii() */ TS_FSM_CNTRL, /* iscntrl() */ TS_FSM_GRAPH, /* isgraph() */ TS_FSM_LOWER, /* islower() */ TS_FSM_UPPER, /* isupper() */ TS_FSM_PUNCT, /* ispunct() */ TS_FSM_SPACE, /* isspace() */ __TS_FSM_TYPE_MAX, }; #define TS_FSM_TYPE_MAX (__TS_FSM_TYPE_MAX - 1) enum { TS_FSM_SINGLE, /* 1 occurrence */ TS_FSM_PERHAPS, /* 1 or 0 occurrence */ TS_FSM_ANY, /* 0..n occurrences */ TS_FSM_MULTI, /* 1..n occurrences */ TS_FSM_HEAD_IGNORE, /* 0..n ignored occurrences at head */ __TS_FSM_RECUR_MAX, }; #define TS_FSM_RECUR_MAX (__TS_FSM_RECUR_MAX - 1) /** * struct ts_fsm_token - state machine token (state) * @type: type of token * @recur: number of recurrences * @value: character value for TS_FSM_SPECIFIC */ struct ts_fsm_token { __u16 type; __u8 recur; __u8 value; }; #endif   e\ /* SPDX-License-Identifier: GPL-2.0-only */ #ifndef LWQ_H #define LWQ_H /* * Light-weight single-linked queue built from llist * * Entries can be enqueued from any context with no locking. * Entries can be dequeued from process context with integrated locking. * * This is particularly suitable when work items are queued in * BH or IRQ context, and where work items are handled one at a time * by dedicated threads. */ #include #include #include struct lwq_node { struct llist_node node; }; struct lwq { spinlock_t lock; struct llist_node *ready; /* entries to be dequeued */ struct llist_head new; /* entries being enqueued */ }; /** * lwq_init - initialise a lwq * @q: the lwq object */ static inline void lwq_init(struct lwq *q) { spin_lock_init(&q->lock); q->ready = NULL; init_llist_head(&q->new); } /** * lwq_empty - test if lwq contains any entry * @q: the lwq object * * This empty test contains an acquire barrier so that if a wakeup * is sent when lwq_dequeue returns true, it is safe to go to sleep after * a test on lwq_empty(). */ static inline bool lwq_empty(struct lwq *q) { /* acquire ensures ordering wrt lwq_enqueue() */ return smp_load_acquire(&q->ready) == NULL && llist_empty(&q->new); } struct llist_node *__lwq_dequeue(struct lwq *q); /** * lwq_dequeue - dequeue first (oldest) entry from lwq * @q: the queue to dequeue from * @type: the type of object to return * @member: them member in returned object which is an lwq_node. * * Remove a single object from the lwq and return it. This will take * a spinlock and so must always be called in the same context, typcially * process contet. */ #define lwq_dequeue(q, type, member) \ ({ struct llist_node *_n = __lwq_dequeue(q); \ _n ? container_of(_n, type, member.node) : NULL; }) struct llist_node *lwq_dequeue_all(struct lwq *q); /** * lwq_for_each_safe - iterate over detached queue allowing deletion * @_n: iterator variable * @_t1: temporary struct llist_node ** * @_t2: temporary struct llist_node * * @_l: address of llist_node pointer from lwq_dequeue_all() * @_member: member in _n where lwq_node is found. * * Iterate over members in a dequeued list. If the iterator variable * is set to NULL, the iterator removes that entry from the queue. */ #define lwq_for_each_safe(_n, _t1, _t2, _l, _member) \ for (_t1 = (_l); \ *(_t1) ? (_n = container_of(*(_t1), typeof(*(_n)), _member.node),\ _t2 = ((*_t1)->next), \ true) \ : false; \ (_n) ? (_t1 = &(_