ossp-util.h

   1 /*
   2  * ossp-util - OSS Proxy: Common utilities
   3  *
   4  * Copyright (C) 2008-2010  SUSE Linux Products GmbH
   5  * Copyright (C) 2008-2010  Tejun Heo <tj@kernel.org>
   6  *
   7  * This file is released under the GPLv2.
   8  */
   9
  10 #ifndef _OSSP_UTIL_H
  11 #define _OSSP_UTIL_H
  12
  13 #include <assert.h>
  14 #include <stddef.h>
  15 #include <string.h>
  16 #include <sys/types.h>
  17 #include <errno.h>
  18 #include <unistd.h>
  19 #include "ossp.h"
  20
  21 #define OSSP_LOG_NAME_LEN       128
  22
  23 enum {
  24         OSSP_LOG_CRIT   = 1,
  25         OSSP_LOG_ERR,
  26         OSSP_LOG_WARN,
  27         OSSP_LOG_INFO,
  28         OSSP_LOG_DFL    = OSSP_LOG_INFO, /* default log level */
  29         OSSP_LOG_DBG0,
  30         OSSP_LOG_DBG1,
  31         OSSP_LOG_MAX    = OSSP_LOG_DBG1,
  32 };
  33
  34 extern char ossp_log_name[OSSP_LOG_NAME_LEN];
  35 extern int ossp_log_level;
  36 extern int ossp_log_timestamp;
  37
  38 #define BITS_PER_BYTE           8
  39 #define BITS_PER_LONG           (BITS_PER_BYTE * sizeof(long))
  40 #define DIV_ROUND_UP(n,d)       (((n) + (d) - 1) / (d))
  41 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
  42
  43 /* ARRAY_SIZE and min/max macros stolen from linux/kernel.h */
  44 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
  45
  46 #define min(x, y) ({                            \
  47         typeof(x) _min1 = (x);                  \
  48         typeof(y) _min2 = (y);                  \
  49         (void) (&_min1 == &_min2);              \
  50         _min1 < _min2 ? _min1 : _min2; })
  51
  52 #define max(x, y) ({                            \
  53         typeof(x) _max1 = (x);                  \
  54         typeof(y) _max2 = (y);                  \
  55         (void) (&_max1 == &_max2);              \
  56         _max1 > _max2 ? _max1 : _max2; })
  57
  58 #define min_t(type, x, y) ({                    \
  59         type __min1 = (x);                      \
  60         type __min2 = (y);                      \
  61         __min1 < __min2 ? __min1: __min2; })
  62
  63 #define max_t(type, x, y) ({                    \
  64         type __max1 = (x);                      \
  65         type __max2 = (y);                      \
  66         __max1 > __max2 ? __max1: __max2; })
  67
  68 void log_msg(int severity, const char *fmt, ...)
  69         __attribute__ ((format (printf, 2, 3)));
  70
  71 #define fatal(fmt, args...) do {                                        \
  72         log_msg(OSSP_LOG_CRIT, fmt , ##args);                           \
  73         _exit(1);                                                       \
  74 } while (0)
  75 #define err(fmt, args...)               log_msg(OSSP_LOG_ERR, fmt , ##args)
  76 #define warn(fmt, args...)              log_msg(OSSP_LOG_WARN, fmt , ##args)
  77 #define info(fmt, args...)              log_msg(OSSP_LOG_INFO, fmt , ##args)
  78 #define dbg0(fmt, args...)              log_msg(OSSP_LOG_DBG0, fmt , ##args)
  79 #define dbg1(fmt, args...)              log_msg(OSSP_LOG_DBG1, fmt , ##args)
  80
  81 #define fatal_e(e, fmt, args...)        \
  82         fatal(fmt" (%s)" , ##args, strerror(-(e)))
  83 #define err_e(e, fmt, args...)  \
  84         err(fmt" (%s)" , ##args, strerror(-(e)))
  85 #define warn_e(e, fmt, args...) \
  86         warn(fmt" (%s)" , ##args, strerror(-(e)))
  87 #define info_e(e, fmt, args...) \
  88         info(fmt" (%s)" , ##args, strerror(-(e)))
  89 #define dbg0_e(e, fmt, args...) \
  90         dbg0(fmt" (%s)" , ##args, strerror(-(e)))
  91 #define dbg1_e(e, fmt, args...) \
  92         dbg1(fmt" (%s)" , ##args, strerror(-(e)))
  93
  94 struct ring_buf {
  95         char            *buf;
  96         size_t          size;
  97         size_t          head;
  98         size_t          bytes;
  99 };
 100
 101 static inline size_t ring_size(struct ring_buf *ring)
 102 {
 103         return ring->size;
 104 }
 105
 106 static inline size_t ring_bytes(struct ring_buf *ring)
 107 {
 108         return ring->bytes;
 109 }
 110
 111 static inline size_t ring_space(struct ring_buf *ring)
 112 {
 113         return ring->size - ring->bytes;
 114 }
 115
 116 static inline void ring_consume(struct ring_buf *ring, size_t size)
 117 {
 118         assert(ring->bytes >= size);
 119         ring->bytes -= size;
 120 }
 121
 122 static inline void ring_manual_init(struct ring_buf *ring, void *buf,
 123                                     size_t size, size_t head, size_t bytes)
 124 {
 125         ring->buf = buf;
 126         ring->size = size;
 127         ring->head = head;
 128         ring->bytes = bytes;
 129 }
 130
 131 void ring_fill(struct ring_buf *ring, const void *buf, size_t size);
 132 void *ring_data(struct ring_buf *ring, size_t *sizep);
 133 int ring_resize(struct ring_buf *ring, size_t new_size);
 134
 135 struct sized_buf {
 136         char            *buf;
 137         size_t          size;
 138 };
 139
 140 int ensure_sbuf_size(struct sized_buf *sbuf, size_t size);
 141
 142 int read_fill(int fd, void *buf, size_t size);
 143 int write_fill(int fd, const void *buf, size_t size);
 144
 145 /*
 146  * Bitops lifted from linux asm-generic implementation.
 147  */
 148 unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
 149                                  long size, unsigned long offset);
 150 #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
 151 extern void __set_bit(int nr, volatile unsigned long *addr);
 152 extern void __clear_bit(int nr, volatile unsigned long *addr);
 153
 154 typedef ssize_t (*ossp_action_fn_t)(enum ossp_opcode opcode,
 155                                     void *carg, void *din, size_t din_sz,
 156                                     void *rarg, void *dout, size_t *dout_szp,
 157                                     int fd);
 158
 159 int get_proc_self_info(pid_t tid, pid_t *pgrp,
 160                        char *cmd_buf, size_t cmd_buf_sz);
 161
 162 /*
 163  * Doubly linked list handling code shamelessly stolen from the Linux
 164  * kernel 2.6.26 include/linux/list.h.
 165  */
 166
 167 /**
 168  * container_of - cast a member of a structure out to the containing structure
 169  * @ptr:        the pointer to the member.
 170  * @type:       the type of the container struct this is embedded in.
 171  * @member:     the name of the member within the struct.
 172  *
 173  */
 174 #define container_of(ptr, type, member) ({                      \
 175         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 176         (type *)( (char *)__mptr - offsetof(type,member) );})
 177
 178 #define LIST_POISON1  ((void *) 0x00100100)
 179 #define LIST_POISON2  ((void *) 0x00200200)
 180
 181 /*
 182  * Simple doubly linked list implementation.
 183  *
 184  * Some of the internal functions ("__xxx") are useful when
 185  * manipulating whole lists rather than single entries, as
 186  * sometimes we already know the next/prev entries and we can
 187  * generate better code by using them directly rather than
 188  * using the generic single-entry routines.
 189  */
 190
 191 struct list_head {
 192         struct list_head *next, *prev;
 193 };
 194
 195 #define LIST_HEAD_INIT(name) { &(name), &(name) }
 196
 197 #define LIST_HEAD(name) \
 198         struct list_head name = LIST_HEAD_INIT(name)
 199
 200 static inline void INIT_LIST_HEAD(struct list_head *list)
 201 {
 202         list->next = list;
 203         list->prev = list;
 204 }
 205
 206 /*
 207  * Insert a new entry between two known consecutive entries.
 208  *
 209  * This is only for internal list manipulation where we know
 210  * the prev/next entries already!
 211  */
 212 static inline void __list_add(struct list_head *new,
 213                               struct list_head *prev,
 214                               struct list_head *next)
 215 {
 216         next->prev = new;
 217         new->next = next;
 218         new->prev = prev;
 219         prev->next = new;
 220 }
 221
 222 /**
 223  * list_add - add a new entry
 224  * @new: new entry to be added
 225  * @head: list head to add it after
 226  *
 227  * Insert a new entry after the specified head.
 228  * This is good for implementing stacks.
 229  */
 230 static inline void list_add(struct list_head *new, struct list_head *head)
 231 {
 232         __list_add(new, head, head->next);
 233 }
 234
 235 /**
 236  * list_add_tail - add a new entry
 237  * @new: new entry to be added
 238  * @head: list head to add it before
 239  *
 240  * Insert a new entry before the specified head.
 241  * This is useful for implementing queues.
 242  */
 243 static inline void list_add_tail(struct list_head *new, struct list_head *head)
 244 {
 245         __list_add(new, head->prev, head);
 246 }
 247
 248 /*
 249  * Delete a list entry by making the prev/next entries
 250  * point to each other.
 251  *
 252  * This is only for internal list manipulation where we know
 253  * the prev/next entries already!
 254  */
 255 static inline void __list_del(struct list_head * prev, struct list_head * next)
 256 {
 257         next->prev = prev;
 258         prev->next = next;
 259 }
 260
 261 /**
 262  * list_del - deletes entry from list.
 263  * @entry: the element to delete from the list.
 264  * Note: list_empty() on entry does not return true after this, the entry is
 265  * in an undefined state.
 266  */
 267 static inline void list_del(struct list_head *entry)
 268 {
 269         __list_del(entry->prev, entry->next);
 270         entry->next = LIST_POISON1;
 271         entry->prev = LIST_POISON2;
 272 }
 273
 274 /**
 275  * list_replace - replace old entry by new one
 276  * @old : the element to be replaced
 277  * @new : the new element to insert
 278  *
 279  * If @old was empty, it will be overwritten.
 280  */
 281 static inline void list_replace(struct list_head *old,
 282                                 struct list_head *new)
 283 {
 284         new->next = old->next;
 285         new->next->prev = new;
 286         new->prev = old->prev;
 287         new->prev->next = new;
 288 }
 289
 290 static inline void list_replace_init(struct list_head *old,
 291                                         struct list_head *new)
 292 {
 293         list_replace(old, new);
 294         INIT_LIST_HEAD(old);
 295 }
 296
 297 /**
 298  * list_del_init - deletes entry from list and reinitialize it.
 299  * @entry: the element to delete from the list.
 300  */
 301 static inline void list_del_init(struct list_head *entry)
 302 {
 303         __list_del(entry->prev, entry->next);
 304         INIT_LIST_HEAD(entry);
 305 }
 306
 307 /**
 308  * list_move - delete from one list and add as another's head
 309  * @list: the entry to move
 310  * @head: the head that will precede our entry
 311  */
 312 static inline void list_move(struct list_head *list, struct list_head *head)
 313 {
 314         __list_del(list->prev, list->next);
 315         list_add(list, head);
 316 }
 317
 318 /**
 319  * list_move_tail - delete from one list and add as another's tail
 320  * @list: the entry to move
 321  * @head: the head that will follow our entry
 322  */
 323 static inline void list_move_tail(struct list_head *list,
 324                                   struct list_head *head)
 325 {
 326         __list_del(list->prev, list->next);
 327         list_add_tail(list, head);
 328 }
 329
 330 /**
 331  * list_is_last - tests whether @list is the last entry in list @head
 332  * @list: the entry to test
 333  * @head: the head of the list
 334  */
 335 static inline int list_is_last(const struct list_head *list,
 336                                 const struct list_head *head)
 337 {
 338         return list->next == head;
 339 }
 340
 341 /**
 342  * list_empty - tests whether a list is empty
 343  * @head: the list to test.
 344  */
 345 static inline int list_empty(const struct list_head *head)
 346 {
 347         return head->next == head;
 348 }
 349
 350 /**
 351  * list_empty_careful - tests whether a list is empty and not being modified
 352  * @head: the list to test
 353  *
 354  * Description:
 355  * tests whether a list is empty _and_ checks that no other CPU might be
 356  * in the process of modifying either member (next or prev)
 357  *
 358  * NOTE: using list_empty_careful() without synchronization
 359  * can only be safe if the only activity that can happen
 360  * to the list entry is list_del_init(). Eg. it cannot be used
 361  * if another CPU could re-list_add() it.
 362  */
 363 static inline int list_empty_careful(const struct list_head *head)
 364 {
 365         struct list_head *next = head->next;
 366         return (next == head) && (next == head->prev);
 367 }
 368
 369 /**
 370  * list_is_singular - tests whether a list has just one entry.
 371  * @head: the list to test.
 372  */
 373 static inline int list_is_singular(const struct list_head *head)
 374 {
 375         return !list_empty(head) && (head->next == head->prev);
 376 }
 377
 378 static inline void __list_splice(const struct list_head *list,
 379                                  struct list_head *head)
 380 {
 381         struct list_head *first = list->next;
 382         struct list_head *last = list->prev;
 383         struct list_head *at = head->next;
 384
 385         first->prev = head;
 386         head->next = first;
 387
 388         last->next = at;
 389         at->prev = last;
 390 }
 391
 392 /**
 393  * list_splice - join two lists
 394  * @list: the new list to add.
 395  * @head: the place to add it in the first list.
 396  */
 397 static inline void list_splice(const struct list_head *list,
 398                                 struct list_head *head)
 399 {
 400         if (!list_empty(list))
 401                 __list_splice(list, head);
 402 }
 403
 404 /**
 405  * list_splice_init - join two lists and reinitialise the emptied list.
 406  * @list: the new list to add.
 407  * @head: the place to add it in the first list.
 408  *
 409  * The list at @list is reinitialised
 410  */
 411 static inline void list_splice_init(struct list_head *list,
 412                                     struct list_head *head)
 413 {
 414         if (!list_empty(list)) {
 415                 __list_splice(list, head);
 416                 INIT_LIST_HEAD(list);
 417         }
 418 }
 419
 420 /**
 421  * list_entry - get the struct for this entry
 422  * @ptr:        the &struct list_head pointer.
 423  * @type:       the type of the struct this is embedded in.
 424  * @member:     the name of the list_struct within the struct.
 425  */
 426 #define list_entry(ptr, type, member) \
 427         container_of(ptr, type, member)
 428
 429 /**
 430  * list_first_entry - get the first element from a list
 431  * @ptr:        the list head to take the element from.
 432  * @type:       the type of the struct this is embedded in.
 433  * @member:     the name of the list_struct within the struct.
 434  *
 435  * Note, that list is expected to be not empty.
 436  */
 437 #define list_first_entry(ptr, type, member) \
 438         list_entry((ptr)->next, type, member)
 439
 440 /**
 441  * list_for_each        -       iterate over a list
 442  * @pos:        the &struct list_head to use as a loop cursor.
 443  * @head:       the head for your list.
 444  */
 445 #define list_for_each(pos, head) \
 446         for (pos = (head)->next; pos != (head); pos = pos->next)
 447
 448 /**
 449  * list_for_each_prev   -       iterate over a list backwards
 450  * @pos:        the &struct list_head to use as a loop cursor.
 451  * @head:       the head for your list.
 452  */
 453 #define list_for_each_prev(pos, head) \
 454         for (pos = (head)->prev; pos != (head); pos = pos->prev)
 455
 456 /**
 457  * list_for_each_safe - iterate over a list safe against removal of list entry
 458  * @pos:        the &struct list_head to use as a loop cursor.
 459  * @n:          another &struct list_head to use as temporary storage
 460  * @head:       the head for your list.
 461  */
 462 #define list_for_each_safe(pos, n, head) \
 463         for (pos = (head)->next, n = pos->next; pos != (head); \
 464                 pos = n, n = pos->next)
 465
 466 /**
 467  * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
 468  * @pos:        the &struct list_head to use as a loop cursor.
 469  * @n:          another &struct list_head to use as temporary storage
 470  * @head:       the head for your list.
 471  */
 472 #define list_for_each_prev_safe(pos, n, head) \
 473         for (pos = (head)->prev, n = pos->prev; \
 474              pos != (head); pos = n, n = pos->prev)
 475
 476 /**
 477  * list_for_each_entry  -       iterate over list of given type
 478  * @pos:        the type * to use as a loop cursor.
 479  * @head:       the head for your list.
 480  * @member:     the name of the list_struct within the struct.
 481  */
 482 #define list_for_each_entry(pos, head, member)                          \
 483         for (pos = list_entry((head)->next, typeof(*pos), member);      \
 484              &pos->member != (head);                                    \
 485              pos = list_entry(pos->member.next, typeof(*pos), member))
 486
 487 /**
 488  * list_for_each_entry_reverse - iterate backwards over list of given type.
 489  * @pos:        the type * to use as a loop cursor.
 490  * @head:       the head for your list.
 491  * @member:     the name of the list_struct within the struct.
 492  */
 493 #define list_for_each_entry_reverse(pos, head, member)                  \
 494         for (pos = list_entry((head)->prev, typeof(*pos), member);      \
 495              &pos->member != (head);                                    \
 496              pos = list_entry(pos->member.prev, typeof(*pos), member))
 497
 498 /**
 499  * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
 500  * @pos:        the type * to use as a start point
 501  * @head:       the head of the list
 502  * @member:     the name of the list_struct within the struct.
 503  *
 504  * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
 505  */
 506 #define list_prepare_entry(pos, head, member) \
 507         ((pos) ? : list_entry(head, typeof(*pos), member))
 508
 509 /**
 510  * list_for_each_entry_continue - continue iteration over list of given type
 511  * @pos:        the type * to use as a loop cursor.
 512  * @head:       the head for your list.
 513  * @member:     the name of the list_struct within the struct.
 514  *
 515  * Continue to iterate over list of given type, continuing after
 516  * the current position.
 517  */
 518 #define list_for_each_entry_continue(pos, head, member)                 \
 519         for (pos = list_entry(pos->member.next, typeof(*pos), member);  \
 520              &pos->member != (head);                                    \
 521              pos = list_entry(pos->member.next, typeof(*pos), member))
 522
 523 /**
 524  * list_for_each_entry_continue_reverse - iterate backwards from the given point
 525  * @pos:        the type * to use as a loop cursor.
 526  * @head:       the head for your list.
 527  * @member:     the name of the list_struct within the struct.
 528  *
 529  * Start to iterate over list of given type backwards, continuing after
 530  * the current position.
 531  */
 532 #define list_for_each_entry_continue_reverse(pos, head, member)         \
 533         for (pos = list_entry(pos->member.prev, typeof(*pos), member);  \
 534              &pos->member != (head);                                    \
 535              pos = list_entry(pos->member.prev, typeof(*pos), member))
 536
 537 /**
 538  * list_for_each_entry_from - iterate over list of given type from the current point
 539  * @pos:        the type * to use as a loop cursor.
 540  * @head:       the head for your list.
 541  * @member:     the name of the list_struct within the struct.
 542  *
 543  * Iterate over list of given type, continuing from current position.
 544  */
 545 #define list_for_each_entry_from(pos, head, member)                     \
 546         for (; &pos->member != (head);                                  \
 547              pos = list_entry(pos->member.next, typeof(*pos), member))
 548
 549 /**
 550  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 551  * @pos:        the type * to use as a loop cursor.
 552  * @n:          another type * to use as temporary storage
 553  * @head:       the head for your list.
 554  * @member:     the name of the list_struct within the struct.
 555  */
 556 #define list_for_each_entry_safe(pos, n, head, member)                  \
 557         for (pos = list_entry((head)->next, typeof(*pos), member),      \
 558                 n = list_entry(pos->member.next, typeof(*pos), member); \
 559              &pos->member != (head);                                    \
 560              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 561
 562 /**
 563  * list_for_each_entry_safe_continue
 564  * @pos:        the type * to use as a loop cursor.
 565  * @n:          another type * to use as temporary storage
 566  * @head:       the head for your list.
 567  * @member:     the name of the list_struct within the struct.
 568  *
 569  * Iterate over list of given type, continuing after current point,
 570  * safe against removal of list entry.
 571  */
 572 #define list_for_each_entry_safe_continue(pos, n, head, member)                 \
 573         for (pos = list_entry(pos->member.next, typeof(*pos), member),          \
 574                 n = list_entry(pos->member.next, typeof(*pos), member);         \
 575              &pos->member != (head);                                            \
 576              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 577
 578 /**
 579  * list_for_each_entry_safe_from
 580  * @pos:        the type * to use as a loop cursor.
 581  * @n:          another type * to use as temporary storage
 582  * @head:       the head for your list.
 583  * @member:     the name of the list_struct within the struct.
 584  *
 585  * Iterate over list of given type from current point, safe against
 586  * removal of list entry.
 587  */
 588 #define list_for_each_entry_safe_from(pos, n, head, member)                     \
 589         for (n = list_entry(pos->member.next, typeof(*pos), member);            \
 590              &pos->member != (head);                                            \
 591              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 592
 593 /**
 594  * list_for_each_entry_safe_reverse
 595  * @pos:        the type * to use as a loop cursor.
 596  * @n:          another type * to use as temporary storage
 597  * @head:       the head for your list.
 598  * @member:     the name of the list_struct within the struct.
 599  *
 600  * Iterate backwards over list of given type, safe against removal
 601  * of list entry.
 602  */
 603 #define list_for_each_entry_safe_reverse(pos, n, head, member)          \
 604         for (pos = list_entry((head)->prev, typeof(*pos), member),      \
 605                 n = list_entry(pos->member.prev, typeof(*pos), member); \
 606              &pos->member != (head);                                    \
 607              pos = n, n = list_entry(n->member.prev, typeof(*n), member))
 608
 609 #endif /*_OSSP_UTIL_H*/