obd_support.h

来自「lustre 1.6.5 source code」· C头文件 代码 · 共 679 行 · 第 1/3 页

#define OBD_FAIL_OSC_BRW_PREP_REQ2       0x40a
#define OBD_FAIL_OSC_CONNECT_CKSUM       0x40b
#define OBD_FAIL_OSC_CKSUM_ADLER_ONLY    0x40c

#define OBD_FAIL_PTLRPC                  0x500
#define OBD_FAIL_PTLRPC_ACK              0x501
#define OBD_FAIL_PTLRPC_RQBD             0x502
#define OBD_FAIL_PTLRPC_BULK_GET_NET     0x503
#define OBD_FAIL_PTLRPC_BULK_PUT_NET     0x504
#define OBD_FAIL_PTLRPC_DROP_RPC         0x505
#define OBD_FAIL_PTLRPC_DELAY_SEND       0x506
#define OBD_FAIL_PTLRPC_DELAY_RECOV      0x507
#define OBD_FAIL_PTLRPC_CLIENT_BULK_CB   0x508
#define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
#define OBD_FAIL_PTLRPC_PAUSE_REP        0x50c

#define OBD_FAIL_OBD_PING_NET            0x600
#define OBD_FAIL_OBD_LOG_CANCEL_NET      0x601
#define OBD_FAIL_OBD_LOGD_NET            0x602
#define OBD_FAIL_OBD_QC_CALLBACK_NET     0x603
#define OBD_FAIL_OBD_DQACQ               0x604

#define OBD_FAIL_TGT_REPLY_NET           0x700
#define OBD_FAIL_TGT_CONN_RACE           0x701
#define OBD_FAIL_TGT_FORCE_RECONNECT     0x702
#define OBD_FAIL_TGT_DELAY_CONNECT       0x703
#define OBD_FAIL_TGT_DELAY_RECONNECT     0x704
#define OBD_FAIL_TGT_DELAY_PRECREATE     0x705
#define OBD_FAIL_TGT_TOOMANY_THREADS     0x706

#define OBD_FAIL_MDC_REVALIDATE_PAUSE    0x800
#define OBD_FAIL_MDC_ENQUEUE_PAUSE       0x801
#define OBD_FAIL_MDC_OLD_EXT_FLAGS       0x802
#define OBD_FAIL_MDC_GETATTR_ENQUEUE     0x803

#define OBD_FAIL_MGS                     0x900
#define OBD_FAIL_MGS_ALL_REQUEST_NET     0x901
#define OBD_FAIL_MGS_ALL_REPLY_NET       0x902
#define OBD_FAIL_MGC_PAUSE_PROCESS_LOG   0x903
#define OBD_FAIL_MGS_PAUSE_REQ           0x904
#define OBD_FAIL_MGS_PAUSE_TARGET_REG    0x905

#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(1, 7, 0, 0)
#define OBD_FAIL_QUOTA_QD_COUNT_32BIT    0xA00
#else
#warning "remove quota code above for format obsolete in new release"
#endif
#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(1, 9, 0, 0)
#define OBD_FAIL_QUOTA_WITHOUT_CHANGE_QS    0xA01
#else
#warning "remove quota code above for format obsolete in new release"
#endif

#define OBD_FAIL_QUOTA_RET_QDATA         0xA02

#define OBD_FAIL_LPROC_REMOVE            0xB00

#define OBD_FAIL_GENERAL_ALLOC           0xC00

/* Failure injection control */
#define OBD_FAIL_MASK_SYS    0x0000FF00
#define OBD_FAIL_MASK_LOC   (0x000000FF | OBD_FAIL_MASK_SYS)
#define OBD_FAIL_ONCE        0x80000000
#define OBD_FAILED           0x40000000
/* The following flags aren't made to be combined */
#define OBD_FAIL_SKIP        0x20000000 /* skip N then fail */
#define OBD_FAIL_SOME        0x10000000 /* fail N times */
#define OBD_FAIL_RAND        0x08000000 /* fail 1/N of the time */
#define OBD_FAIL_USR1        0x04000000 /* user flag */

int obd_fail_check(__u32 id);
#define OBD_FAIL_CHECK(id)                                                   \
({                                                                           \
        int _ret_ = 0;                                                       \
        if (unlikely(obd_fail_loc && (_ret_ = obd_fail_check(id)))) {        \
                CERROR("*** obd_fail_loc=%x ***\n", id);                     \
        }                                                                    \
        _ret_;                                                               \
})

#define OBD_FAIL_CHECK_QUIET(id)                                             \
        (unlikely(obd_fail_loc) ? obd_fail_check(id) : 0)

/* deprecated - just use OBD_FAIL_CHECK */
#define OBD_FAIL_CHECK_ONCE OBD_FAIL_CHECK

#define OBD_FAIL_RETURN(id, ret)                                             \
do {                                                                         \
        if (unlikely(obd_fail_loc && obd_fail_check(id))) {                  \
                CERROR("*** obd_fail_return=%x rc=%d ***\n", id, ret);       \
                RETURN(ret);                                                 \
        }                                                                    \
} while(0)

#define OBD_FAIL_TIMEOUT(id, secs)                                           \
({      int _ret_ = 0;                                                       \
        if (unlikely(obd_fail_loc && (_ret_ = obd_fail_check(id)))) {        \
                CERROR("obd_fail_timeout id %x sleeping for %d secs\n",      \
                       (id), (secs));                                        \
                set_current_state(TASK_UNINTERRUPTIBLE);                     \
                cfs_schedule_timeout(CFS_TASK_UNINT,                         \
                                    cfs_time_seconds(secs));                 \
                set_current_state(TASK_RUNNING);                             \
                CERROR("obd_fail_timeout id %x awake\n", (id));              \
        }                                                                    \
        _ret_;                                                               \
})

#define OBD_FAIL_TIMEOUT_MS(id, ms)                                          \
({      int _ret_ = 0;                                                       \
        if (unlikely(obd_fail_loc && (_ret_ = obd_fail_check(id)))) {        \
                CERROR("obd_fail_timeout id %x sleeping for %d ms\n",        \
                       (id), (ms));                                          \
                set_current_state(TASK_UNINTERRUPTIBLE);                     \
                cfs_schedule_timeout(CFS_TASK_UNINT,                         \
                                     cfs_time_seconds(ms)/1000);             \
                set_current_state(TASK_RUNNING);                             \
                CERROR("obd_fail_timeout id %x awake\n", (id));              \
        }                                                                    \
        _ret_;                                                               \
})

#ifdef __KERNEL__
/* The idea here is to synchronise two threads to force a race. The
 * first thread that calls this with a matching fail_loc is put to
 * sleep. The next thread that calls with the same fail_loc wakes up
 * the first and continues. */
#define OBD_RACE(id)                                                         \
do {                                                                         \
        if (unlikely(obd_fail_loc && obd_fail_check(id))) {                  \
                obd_race_state = 0;                                          \
                CERROR("obd_race id %x sleeping\n", (id));                   \
                OBD_SLEEP_ON(obd_race_waitq, obd_race_state != 0);           \
                CERROR("obd_fail_race id %x awake\n", (id));                 \
        } else if ((obd_fail_loc & OBD_FAIL_MASK_LOC) ==                     \
                    ((id) & OBD_FAIL_MASK_LOC)) {                            \
                CERROR("obd_fail_race id %x waking\n", (id));                \
                obd_race_state = 1;                                          \
                wake_up(&obd_race_waitq);                                    \
        }                                                                    \
} while(0)
#else
/* sigh.  an expedient fix until OBD_RACE is fixed up */
#define OBD_RACE(foo) do {} while(0)
#endif

#define fixme() CDEBUG(D_OTHER, "FIXME\n");

extern atomic_t libcfs_kmemory;

#ifdef RANDOM_FAIL_ALLOC
#define HAS_FAIL_ALLOC_FLAG OBD_FAIL_CHECK_QUIET(OBD_FAIL_GENERAL_ALLOC)
#else
#define HAS_FAIL_ALLOC_FLAG 0
#endif

#define OBD_ALLOC_FAIL_BITS 24
#define OBD_ALLOC_FAIL_MASK ((1 << OBD_ALLOC_FAIL_BITS) - 1)
#define OBD_ALLOC_FAIL_MULT (OBD_ALLOC_FAIL_MASK / 100)

#ifdef LPROCFS 
#define obd_memory_add(size)                                                  \
        lprocfs_counter_add(obd_memory, OBD_MEMORY_STAT, (long)(size))
#define obd_memory_sub(size)                                                  \
        lprocfs_counter_sub(obd_memory, OBD_MEMORY_STAT, (long)(size))
#define obd_memory_sum()                                                      \
        lprocfs_stats_collector(obd_memory, OBD_MEMORY_STAT,                  \
                                LPROCFS_FIELDS_FLAGS_SUM)
#define obd_pages_add(order)                                                  \
        lprocfs_counter_add(obd_memory, OBD_MEMORY_PAGES_STAT,                \
                            (long)(1 << (order)))
#define obd_pages_sub(order)                                                  \
        lprocfs_counter_sub(obd_memory, OBD_MEMORY_PAGES_STAT,                \
                            (long)(1 << (order)))
#define obd_pages_sum()                                                       \
        lprocfs_stats_collector(obd_memory, OBD_MEMORY_PAGES_STAT,            \
                                LPROCFS_FIELDS_FLAGS_SUM)

extern void obd_update_maxusage(void);
extern __u64 obd_memory_max(void);
extern __u64 obd_pages_max(void);

#else

extern __u64 obd_alloc;
extern __u64 obd_pages;

extern __u64 obd_max_alloc;
extern __u64 obd_max_pages;

static inline void obd_memory_add(long size)
{
        obd_alloc += size;
        if (obd_alloc > obd_max_alloc)
                obd_max_alloc = obd_alloc;
}

static inline void obd_memory_sub(long size)
{
        obd_alloc -= size;
}

static inline void obd_pages_add(int order) 
{
        obd_pages += 1<< order;
        if (obd_pages > obd_max_pages)
                obd_max_pages = obd_pages;
}

static inline void obd_pages_sub(int order)
{
        obd_pages -= 1<< order;
}

#define obd_memory_sum() (obd_alloc)
#define obd_pages_sum()  (obd_pages)

#define obd_memory_max() (obd_max_alloc)
#define obd_pages_max() (obd_max_pages)

#endif

#if defined(LUSTRE_UTILS) /* this version is for utils only */
#define OBD_ALLOC_GFP(ptr, size, gfp_mask)                                    \
do {                                                                          \
        (ptr) = cfs_alloc(size, (gfp_mask));                                  \
        if (unlikely((ptr) == NULL)) {                                        \