list.h   list.h 
skipping to change at line 20 skipping to change at line 20
The GNU C Library is distributed in the hope that it will be useful, The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */ 02111-1307 USA. */
#ifndef _LIST_H #ifndef _CDS_LIST_H
#define _LIST_H 1 #define _CDS_LIST_H 1
/* The definitions of this file are adopted from those which can be /* The definitions of this file are adopted from those which can be
found in the Linux kernel headers to enable people familiar with found in the Linux kernel headers to enable people familiar with
the latter find their way in these sources as well. */ the latter find their way in these sources as well. */
/* Basic type for the double-link list. */ /* Basic type for the double-link list. */
typedef struct cds_list_head struct cds_list_head
{ {
struct cds_list_head *next; struct cds_list_head *next;
struct cds_list_head *prev; struct cds_list_head *prev;
} list_t; };
/* Define a variable with the head and tail of the list. */ /* Define a variable with the head and tail of the list. */
#define CDS_LIST_HEAD(name) \ #define CDS_LIST_HEAD(name) \
list_t name = { &(name), &(name) } struct cds_list_head name = { &(name), &(name) }
/* Initialize a new list head. */ /* Initialize a new list head. */
#define CDS_INIT_LIST_HEAD(ptr) \ #define CDS_INIT_LIST_HEAD(ptr) \
(ptr)->next = (ptr)->prev = (ptr) (ptr)->next = (ptr)->prev = (ptr)
#define CDS_LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) } #define CDS_LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) }
/* Add new element at the head of the list. */ /* Add new element at the head of the list. */
static inline void static inline void
cds_list_add (list_t *newp, list_t *head) cds_list_add (struct cds_list_head *newp, struct cds_list_head *head)
{ {
head->next->prev = newp; head->next->prev = newp;
newp->next = head->next; newp->next = head->next;
newp->prev = head; newp->prev = head;
head->next = newp; head->next = newp;
} }
/* Add new element at the tail of the list. */ /* Add new element at the tail of the list. */
static inline void static inline void
cds_list_add_tail (list_t *newp, list_t *head) cds_list_add_tail (struct cds_list_head *newp, struct cds_list_head *head)
{ {
head->prev->next = newp; head->prev->next = newp;
newp->next = head; newp->next = head;
newp->prev = head->prev; newp->prev = head->prev;
head->prev = newp; head->prev = newp;
} }
/* Remove element from list. */ /* Remove element from list. */
static inline void static inline void
__cds_list_del (list_t *prev, list_t *next) __cds_list_del (struct cds_list_head *prev, struct cds_list_head *next)
{ {
next->prev = prev; next->prev = prev;
prev->next = next; prev->next = next;
} }
/* Remove element from list. */ /* Remove element from list. */
static inline void static inline void
cds_list_del (list_t *elem) cds_list_del (struct cds_list_head *elem)
{ {
__cds_list_del (elem->prev, elem->next); __cds_list_del (elem->prev, elem->next);
} }
/* delete from list, add to another list as head */ /* delete from list, add to another list as head */
static inline void static inline void
cds_list_move (list_t *elem, list_t *head) cds_list_move (struct cds_list_head *elem, struct cds_list_head *head)
{ {
__cds_list_del (elem->prev, elem->next); __cds_list_del (elem->prev, elem->next);
cds_list_add (elem, head); cds_list_add (elem, head);
} }
/* replace an old entry. /* replace an old entry.
*/ */
static inline void static inline void
cds_list_replace(list_t *old, list_t *_new) cds_list_replace(struct cds_list_head *old, struct cds_list_head *_new)
{ {
_new->next = old->next; _new->next = old->next;
_new->prev = old->prev; _new->prev = old->prev;
_new->prev->next = _new; _new->prev->next = _new;
_new->next->prev = _new; _new->next->prev = _new;
} }
/* Join two lists. */ /* Join two lists. */
static inline void static inline void
cds_list_splice (list_t *add, list_t *head) cds_list_splice (struct cds_list_head *add, struct cds_list_head *head)
{ {
/* Do nothing if the list which gets added is empty. */ /* Do nothing if the list which gets added is empty. */
if (add != add->next) if (add != add->next)
{ {
add->next->prev = head; add->next->prev = head;
add->prev->next = head->next; add->prev->next = head->next;
head->next->prev = add->prev; head->next->prev = add->prev;
head->next = add->next; head->next = add->next;
} }
} }
skipping to change at line 147 skipping to change at line 147
for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \ for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \
&pos->member != (head); \ &pos->member != (head); \
pos = cds_list_entry(pos->member.prev, typeof(*pos), member)) pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
#define cds_list_for_each_entry_safe(pos, p, head, member) \ #define cds_list_for_each_entry_safe(pos, p, head, member) \
for (pos = cds_list_entry((head)->next, typeof(*pos), member), \ for (pos = cds_list_entry((head)->next, typeof(*pos), member), \
p = cds_list_entry(pos->member.next,typeof(*pos), membe r); \ p = cds_list_entry(pos->member.next,typeof(*pos), membe r); \
&pos->member != (head); \ &pos->member != (head); \
pos = p, p = cds_list_entry(pos->member.next, typeof(*pos), mem ber)) pos = p, p = cds_list_entry(pos->member.next, typeof(*pos), mem ber))
static inline int cds_list_empty(list_t *head) static inline int cds_list_empty(struct cds_list_head *head)
{ {
return head == head->next; return head == head->next;
} }
static inline void cds_list_replace_init(list_t *old, static inline void cds_list_replace_init(struct cds_list_head *old,
list_t *_new) struct cds_list_head *_new)
{ {
list_t *head = old->next; struct cds_list_head *head = old->next;
cds_list_del(old); cds_list_del(old);
cds_list_add_tail(_new, head); cds_list_add_tail(_new, head);
CDS_INIT_LIST_HEAD(old); CDS_INIT_LIST_HEAD(old);
} }
#endif /* list.h */ #endif /* _CDS_LIST_H */
 End of changes. 15 change blocks. 
16 lines changed or deleted 16 lines changed or added


 rculist.h   rculist.h 
skipping to change at line 33 skipping to change at line 33
#ifndef _URCU_RCULIST_H #ifndef _URCU_RCULIST_H
#define _URCU_RCULIST_H #define _URCU_RCULIST_H
#include <urcu/list.h> #include <urcu/list.h>
#include <urcu/arch.h> #include <urcu/arch.h>
#include <urcu-pointer.h> #include <urcu-pointer.h>
/* Add new element at the head of the list. /* Add new element at the head of the list.
*/ */
static inline void cds_list_add_rcu(list_t *newp, list_t *head) static inline void cds_list_add_rcu(struct cds_list_head *newp, struct cds_ list_head *head)
{ {
newp->next = head->next; newp->next = head->next;
newp->prev = head; newp->prev = head;
cmm_smp_wmb(); cmm_smp_wmb();
head->next->prev = newp; head->next->prev = newp;
head->next = newp; head->next = newp;
} }
/* replace an old entry atomically. /* replace an old entry atomically.
*/ */
static inline void cds_list_replace_rcu(list_t *old, list_t *_new) static inline void cds_list_replace_rcu(struct cds_list_head *old, struct c ds_list_head *_new)
{ {
_new->next = old->next; _new->next = old->next;
_new->prev = old->prev; _new->prev = old->prev;
rcu_assign_pointer(_new->prev->next, _new); rcu_assign_pointer(_new->prev->next, _new);
_new->next->prev = _new; _new->next->prev = _new;
} }
/* Remove element from list. */ /* Remove element from list. */
static inline void cds_list_del_rcu(list_t *elem) static inline void cds_list_del_rcu(struct cds_list_head *elem)
{ {
elem->next->prev = elem->prev; elem->next->prev = elem->prev;
elem->prev->next = elem->next; elem->prev->next = elem->next;
} }
/* /*
* Iteration through all elements of the list must be done while rcu_read_l ock() * Iteration through all elements of the list must be done while rcu_read_l ock()
* is held. * is held.
*/ */
 End of changes. 3 change blocks. 
3 lines changed or deleted 3 lines changed or added


 urcu-defer.h   urcu-defer.h 
skipping to change at line 66 skipping to change at line 66
* call_rcu will eventually be implemented with an API similar to the Linux * call_rcu will eventually be implemented with an API similar to the Linux
* kernel call_rcu(), which will allow its use within RCU read-side C.S. * kernel call_rcu(), which will allow its use within RCU read-side C.S.
* Generate an error if used for now. * Generate an error if used for now.
*/ */
#define call_rcu __error_call_rcu_not_implemented_please_use_defer_rc u #define call_rcu __error_call_rcu_not_implemented_please_use_defer_rc u
/* /*
* Thread registration for reclamation. * Thread registration for reclamation.
*/ */
extern void rcu_defer_register_thread(void); extern int rcu_defer_register_thread(void);
extern void rcu_defer_unregister_thread(void); extern void rcu_defer_unregister_thread(void);
extern void rcu_defer_barrier(void); extern void rcu_defer_barrier(void);
extern void rcu_defer_barrier_thread(void); extern void rcu_defer_barrier_thread(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _URCU_BATCH_H */ #endif /* _URCU_BATCH_H */
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/