-#define OBD_IOC_CREATE _IOR ('f', 101, long)
-#define OBD_IOC_SETUP _IOW ('f', 102, long)
-#define OBD_IOC_CLEANUP _IO ('f', 103 )
-#define OBD_IOC_DESTROY _IOW ('f', 104, long)
-#define OBD_IOC_PREALLOCATE _IOWR('f', 105, long)
-#define OBD_IOC_DEC_USE_COUNT _IO ('f', 106 )
-#define OBD_IOC_SETATTR _IOW ('f', 107, long)
-#define OBD_IOC_GETATTR _IOR ('f', 108, long)
-#define OBD_IOC_READ _IOWR('f', 109, long)
-#define OBD_IOC_WRITE _IOWR('f', 110, long)
-#define OBD_IOC_CONNECT _IOR ('f', 111, long)
-#define OBD_IOC_DISCONNECT _IOW ('f', 112, long)
-#define OBD_IOC_STATFS _IOWR('f', 113, long)
-#define OBD_IOC_SYNC _IOR ('f', 114, long)
-#define OBD_IOC_READ2 _IOWR('f', 115, long)
-#define OBD_IOC_FORMAT _IOWR('f', 116, long)
-#define OBD_IOC_PARTITION _IOWR('f', 117, long)
-#define OBD_IOC_ATTACH _IOWR('f', 118, long)
-#define OBD_IOC_DETACH _IOWR('f', 119, long)
-#define OBD_IOC_COPY _IOWR('f', 120, long)
-#define OBD_IOC_MIGR _IOWR('f', 121, long)
-#define OBD_IOC_PUNCH _IOWR('f', 122, long)
-#define OBD_IOC_DEVICE _IOWR('f', 123, long)
-#define OBD_IOC_MODULE_DEBUG _IOWR('f', 124, long)
-#define OBD_IOC_BRW_READ _IOWR('f', 125, long)
-#define OBD_IOC_BRW_WRITE _IOWR('f', 126, long)
-#define OBD_IOC_NAME2DEV _IOWR('f', 127, long)
-#define OBD_IOC_NEWDEV _IOWR('f', 128, long)
-#define OBD_IOC_LIST _IOWR('f', 129, long)
-#define OBD_IOC_UUID2DEV _IOWR('f', 130, long)
-
-#define OBD_IOC_RECOVD_NEWCONN _IOWR('f', 131, long)
-#define OBD_IOC_LOV_CONFIG _IOWR('f', 132, long)
-
-#define OBD_IOC_DEC_FS_USE_COUNT _IO ('f', 133 )
-
-#define OBD_IOC_OPEN _IOWR('f', 134, long)
-#define OBD_IOC_CLOSE _IOWR('f', 135, long)
-
-/*
- * l_wait_event is a flexible sleeping function, permitting simple caller
- * configuration of interrupt and timeout sensitivity along with actions to
- * be performed in the event of either exception.
- *
- * Common usage looks like this:
- *
- * struct l_wait_info lwi = LWI_TIMEOUT_INTR(timeout, timeout_handler,
- * intr_handler, callback_data);
- * rc = l_wait_event(waitq, condition, &lwi);
- *
- * (LWI_TIMEOUT and LWI_INTR macros are available for timeout- and
- * interrupt-only variants, respectively.)
- *
- * If a timeout is specified, the timeout_handler will be invoked in the event
- * that the timeout expires before the process is awakened. (Note that any
- * waking of the process will restart the timeout, even if the condition is
- * not satisfied and the process immediately returns to sleep. This might be
- * considered a bug.) If the timeout_handler returns non-zero, l_wait_event
- * will return -ETIMEDOUT and the caller will continue. If the handler returns
- * zero instead, the process will go back to sleep until it is awakened by the
- * waitq or some similar mechanism, or an interrupt occurs (if the caller has
- * asked for interrupts to be detected). The timeout will only fire once, so
- * callers should take care that a timeout_handler which returns zero will take
- * future steps to awaken the process. N.B. that these steps must include making
- * the provided condition become true.
- *
- * If the interrupt flag (lwi_signals) is non-zero, then the process will be
- * interruptible, and will be awakened by any "killable" signal (SIGTERM,
- * SIGKILL or SIGINT). If a timeout is also specified, then the process will
- * only become interruptible _after_ the timeout has expired, though it can be
- * awakened by a signal that was delivered before the timeout and is still
- * pending when the timeout expires. If a timeout is not specified, the process
- * will be interruptible at all times during l_wait_event.
- */
-
-struct l_wait_info {
- long lwi_timeout;
- int (*lwi_on_timeout)(void *);
- long lwi_signals;
- int (*lwi_on_signal)(void *); /* XXX return is ignored for now */
- void *lwi_cb_data;
-};
-
-#define LWI_TIMEOUT(time, cb, data) \
-((struct l_wait_info) { \
- lwi_timeout: time, \
- lwi_on_timeout: cb, \
- lwi_cb_data: data \
-})
-
-#define LWI_INTR(cb, data) \
-((struct l_wait_info) { \
- lwi_signals: 1, \
- lwi_on_signal: cb, \
- lwi_cb_data: data \
-})
-
-#define LWI_TIMEOUT_INTR(time, time_cb, sig_cb, data) \
-((struct l_wait_info) { \
- lwi_timeout: time, \
- lwi_on_timeout: time_cb, \
- lwi_signals: 1, \
- lwi_on_signal: sig_cb, \
- lwi_cb_data: data \
-})
-
-/* XXX this should be one mask-check */
-#define l_killable_pending(task) \
-(sigismember(&(task->pending.signal), SIGKILL) || \
- sigismember(&(task->pending.signal), SIGINT) || \
- sigismember(&(task->pending.signal), SIGTERM))
-
-#define __l_wait_event(wq, condition, info, ret) \
-do { \
- wait_queue_t __wait; \
- long __state; \
- int __timed_out = 0; \
- init_waitqueue_entry(&__wait, current); \
- \
- add_wait_queue(&wq, &__wait); \
- if (info->lwi_signals && !info->lwi_timeout) \
- __state = TASK_INTERRUPTIBLE; \
- else \
- __state = TASK_UNINTERRUPTIBLE; \
- for (;;) { \
- set_current_state(__state); \
- if (condition) \
- break; \
- if (__state == TASK_INTERRUPTIBLE && l_killable_pending(current)) { \
- CERROR("lwe: interrupt\n"); \
- if (info->lwi_on_signal) \
- info->lwi_on_signal(info->lwi_cb_data); \
- ret = -EINTR; \
- break; \
- } \
- if (info->lwi_timeout && !__timed_out) { \
- if (schedule_timeout(info->lwi_timeout) == 0) { \
- CERROR("lwe: timeout\n"); \
- __timed_out = 1; \
- if (!info->lwi_on_timeout || \
- info->lwi_on_timeout(info->lwi_cb_data)) { \
- ret = -ETIMEDOUT; \
- break; \
- } \
- /* We'll take signals after a timeout. */ \
- if (info->lwi_signals) { \
- __state = TASK_INTERRUPTIBLE; \
- /* Check for a pending interrupt. */ \
- if (info->lwi_signals && l_killable_pending(current)) { \
- CERROR("lwe: pending interrupt\n"); \
- if (info->lwi_on_signal) \
- info->lwi_on_signal(info->lwi_cb_data); \
- ret = -EINTR; \
- break; \
- } \
- } \
- } \
- } else { \
- schedule(); \
- } \
- } \
- current->state = TASK_RUNNING; \
- remove_wait_queue(&wq, &__wait); \
-} while(0)
-
-#define l_wait_event(wq, condition, info) \
-({ \
- int __ret = 0; \
- struct l_wait_info *__info = (info); \
- if (!(condition)) \
- __l_wait_event(wq, condition, __info, __ret); \
- __ret; \
-})
-