fs/gfs2/util.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   4  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
   5  */
   6
   7 #ifndef __UTIL_DOT_H__
   8 #define __UTIL_DOT_H__
   9
  10 #ifdef pr_fmt
  11 #undef pr_fmt
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13 #endif
  14
  15 #include <linux/mempool.h>
  16
  17 #include "incore.h"
  18
  19 #define fs_emerg(fs, fmt, ...)                                          \
  20         pr_emerg("fsid=%s: " fmt, (fs)->sd_fsname, ##__VA_ARGS__)
  21 #define fs_warn(fs, fmt, ...)                                           \
  22         pr_warn("fsid=%s: " fmt, (fs)->sd_fsname, ##__VA_ARGS__)
  23 #define fs_err(fs, fmt, ...)                                            \
  24         pr_err("fsid=%s: " fmt, (fs)->sd_fsname, ##__VA_ARGS__)
  25 #define fs_info(fs, fmt, ...)                                           \
  26         pr_info("fsid=%s: " fmt, (fs)->sd_fsname, ##__VA_ARGS__)
  27
  28 void gfs2_assert_i(struct gfs2_sbd *sdp);
  29
  30 #define gfs2_assert(sdp, assertion) \
  31 do { \
  32         if (unlikely(!(assertion))) { \
  33                 gfs2_assert_i(sdp); \
  34                 BUG(); \
  35         } \
  36 } while (0)
  37
  38
  39 void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
  40                             const char *function, char *file, unsigned int line,
  41                             bool delayed);
  42
  43 #define gfs2_assert_withdraw(sdp, assertion) \
  44         ({ \
  45                 bool _bool = (assertion); \
  46                 if (unlikely(!_bool)) \
  47                         gfs2_assert_withdraw_i((sdp), #assertion, \
  48                                         __func__, __FILE__, __LINE__, false); \
  49                 !_bool; \
  50         })
  51
  52 #define gfs2_assert_withdraw_delayed(sdp, assertion) \
  53         ({ \
  54                 bool _bool = (assertion); \
  55                 if (unlikely(!_bool)) \
  56                         gfs2_assert_withdraw_i((sdp), #assertion, \
  57                                         __func__, __FILE__, __LINE__, true); \
  58                 !_bool; \
  59         })
  60
  61 void gfs2_assert_warn_i(struct gfs2_sbd *sdp, char *assertion,
  62                         const char *function, char *file, unsigned int line);
  63
  64 #define gfs2_assert_warn(sdp, assertion) \
  65         ({ \
  66                 bool _bool = (assertion); \
  67                 if (unlikely(!_bool)) \
  68                         gfs2_assert_warn_i((sdp), #assertion, \
  69                                         __func__, __FILE__, __LINE__); \
  70                 !_bool; \
  71         })
  72
  73 void gfs2_consist_i(struct gfs2_sbd *sdp,
  74                     const char *function, char *file, unsigned int line);
  75
  76 #define gfs2_consist(sdp) \
  77 gfs2_consist_i((sdp), __func__, __FILE__, __LINE__)
  78
  79
  80 void gfs2_consist_inode_i(struct gfs2_inode *ip,
  81                           const char *function, char *file, unsigned int line);
  82
  83 #define gfs2_consist_inode(ip) \
  84 gfs2_consist_inode_i((ip), __func__, __FILE__, __LINE__)
  85
  86
  87 void gfs2_consist_rgrpd_i(struct gfs2_rgrpd *rgd,
  88                           const char *function, char *file, unsigned int line);
  89
  90 #define gfs2_consist_rgrpd(rgd) \
  91 gfs2_consist_rgrpd_i((rgd), __func__, __FILE__, __LINE__)
  92
  93
  94 int gfs2_meta_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
  95                        const char *function,
  96                        char *file, unsigned int line);
  97
  98 static inline int gfs2_meta_check(struct gfs2_sbd *sdp,
  99                                     struct buffer_head *bh)
 100 {
 101         struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
 102         u32 magic = be32_to_cpu(mh->mh_magic);
 103         if (unlikely(magic != GFS2_MAGIC)) {
 104                 fs_err(sdp, "Magic number missing at %llu\n",
 105                        (unsigned long long)bh->b_blocknr);
 106                 return -EIO;
 107         }
 108         return 0;
 109 }
 110
 111 int gfs2_metatype_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
 112                            u16 type, u16 t,
 113                            const char *function,
 114                            char *file, unsigned int line);
 115
 116 static inline int gfs2_metatype_check_i(struct gfs2_sbd *sdp,
 117                                         struct buffer_head *bh,
 118                                         u16 type,
 119                                         const char *function,
 120                                         char *file, unsigned int line)
 121 {
 122         struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;
 123         u32 magic = be32_to_cpu(mh->mh_magic);
 124         u16 t = be32_to_cpu(mh->mh_type);
 125         if (unlikely(magic != GFS2_MAGIC))
 126                 return gfs2_meta_check_ii(sdp, bh, function,
 127                                           file, line);
 128         if (unlikely(t != type))
 129                 return gfs2_metatype_check_ii(sdp, bh, type, t, function,
 130                                               file, line);
 131         return 0;
 132 }
 133
 134 #define gfs2_metatype_check(sdp, bh, type) \
 135 gfs2_metatype_check_i((sdp), (bh), (type), __func__, __FILE__, __LINE__)
 136
 137 static inline void gfs2_metatype_set(struct buffer_head *bh, u16 type,
 138                                      u16 format)
 139 {
 140         struct gfs2_meta_header *mh;
 141         mh = (struct gfs2_meta_header *)bh->b_data;
 142         mh->mh_type = cpu_to_be32(type);
 143         mh->mh_format = cpu_to_be32(format);
 144 }
 145
 146
 147 int gfs2_io_error_i(struct gfs2_sbd *sdp, const char *function,
 148                     char *file, unsigned int line);
 149
 150 int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
 151                         bool verbose);
 152 int gfs2_freeze_lock_shared(struct gfs2_sbd *sdp);
 153 void gfs2_freeze_unlock(struct gfs2_sbd *sdp);
 154
 155 #define gfs2_io_error(sdp) \
 156 gfs2_io_error_i((sdp), __func__, __FILE__, __LINE__)
 157
 158
 159 void gfs2_io_error_bh_i(struct gfs2_sbd *sdp, struct buffer_head *bh,
 160                         const char *function, char *file, unsigned int line,
 161                         bool withdraw);
 162
 163 #define gfs2_io_error_bh_wd(sdp, bh) \
 164 gfs2_io_error_bh_i((sdp), (bh), __func__, __FILE__, __LINE__, true)
 165
 166 #define gfs2_io_error_bh(sdp, bh) \
 167 gfs2_io_error_bh_i((sdp), (bh), __func__, __FILE__, __LINE__, false)
 168
 169
 170 extern struct kmem_cache *gfs2_glock_cachep;
 171 extern struct kmem_cache *gfs2_glock_aspace_cachep;
 172 extern struct kmem_cache *gfs2_inode_cachep;
 173 extern struct kmem_cache *gfs2_bufdata_cachep;
 174 extern struct kmem_cache *gfs2_rgrpd_cachep;
 175 extern struct kmem_cache *gfs2_quotad_cachep;
 176 extern struct kmem_cache *gfs2_qadata_cachep;
 177 extern struct kmem_cache *gfs2_trans_cachep;
 178 extern mempool_t *gfs2_page_pool;
 179 extern struct workqueue_struct *gfs2_control_wq;
 180
 181 static inline unsigned int gfs2_tune_get_i(struct gfs2_tune *gt,
 182                                            unsigned int *p)
 183 {
 184         unsigned int x;
 185         spin_lock(&gt->gt_spin);
 186         x = *p;
 187         spin_unlock(&gt->gt_spin);
 188         return x;
 189 }
 190
 191 /**
 192  * gfs2_withdraw_delayed - withdraw as soon as possible without deadlocks
 193  * @sdp: the superblock
 194  */
 195 static inline void gfs2_withdraw_delayed(struct gfs2_sbd *sdp)
 196 {
 197         set_bit(SDF_WITHDRAWING, &sdp->sd_flags);
 198 }
 199
 200 /**
 201  * gfs2_withdrawing_or_withdrawn - test whether the file system is withdrawing
 202  *                                 or withdrawn
 203  * @sdp: the superblock
 204  */
 205 static inline bool gfs2_withdrawing_or_withdrawn(struct gfs2_sbd *sdp)
 206 {
 207         return unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags) ||
 208                         test_bit(SDF_WITHDRAWING, &sdp->sd_flags));
 209 }
 210
 211 /**
 212  * gfs2_withdrawing - check if a withdraw is pending
 213  * @sdp: the superblock
 214  */
 215 static inline bool gfs2_withdrawing(struct gfs2_sbd *sdp)
 216 {
 217         return unlikely(test_bit(SDF_WITHDRAWING, &sdp->sd_flags) &&
 218                         !test_bit(SDF_WITHDRAWN, &sdp->sd_flags));
 219 }
 220
 221 static inline bool gfs2_withdraw_in_prog(struct gfs2_sbd *sdp)
 222 {
 223         return unlikely(test_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags));
 224 }
 225
 226 #define gfs2_tune_get(sdp, field) \
 227 gfs2_tune_get_i(&(sdp)->sd_tune, &(sdp)->sd_tune.field)
 228
 229 __printf(2, 3)
 230 void gfs2_lm(struct gfs2_sbd *sdp, const char *fmt, ...);
 231 int gfs2_withdraw(struct gfs2_sbd *sdp);
 232
 233 #endif /* __UTIL_DOT_H__ */