1ccd979bdSMark Fasheh /* -*- mode: c; c-basic-offset: 8; -*- 2ccd979bdSMark Fasheh * vim: noexpandtab sw=8 ts=8 sts=0: 3ccd979bdSMark Fasheh * 4ccd979bdSMark Fasheh * ocfs2.h 5ccd979bdSMark Fasheh * 6ccd979bdSMark Fasheh * Defines macros and structures used in OCFS2 7ccd979bdSMark Fasheh * 8ccd979bdSMark Fasheh * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9ccd979bdSMark Fasheh * 10ccd979bdSMark Fasheh * This program is free software; you can redistribute it and/or 11ccd979bdSMark Fasheh * modify it under the terms of the GNU General Public 12ccd979bdSMark Fasheh * License as published by the Free Software Foundation; either 13ccd979bdSMark Fasheh * version 2 of the License, or (at your option) any later version. 14ccd979bdSMark Fasheh * 15ccd979bdSMark Fasheh * This program is distributed in the hope that it will be useful, 16ccd979bdSMark Fasheh * but WITHOUT ANY WARRANTY; without even the implied warranty of 17ccd979bdSMark Fasheh * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18ccd979bdSMark Fasheh * General Public License for more details. 19ccd979bdSMark Fasheh * 20ccd979bdSMark Fasheh * You should have received a copy of the GNU General Public 21ccd979bdSMark Fasheh * License along with this program; if not, write to the 22ccd979bdSMark Fasheh * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23ccd979bdSMark Fasheh * Boston, MA 021110-1307, USA. 24ccd979bdSMark Fasheh */ 25ccd979bdSMark Fasheh 26ccd979bdSMark Fasheh #ifndef OCFS2_H 27ccd979bdSMark Fasheh #define OCFS2_H 28ccd979bdSMark Fasheh 29ccd979bdSMark Fasheh #include <linux/spinlock.h> 30ccd979bdSMark Fasheh #include <linux/sched.h> 31ccd979bdSMark Fasheh #include <linux/wait.h> 32ccd979bdSMark Fasheh #include <linux/list.h> 33ccd979bdSMark Fasheh #include <linux/rbtree.h> 34ccd979bdSMark Fasheh #include <linux/workqueue.h> 35ccd979bdSMark Fasheh #include <linux/kref.h> 36c74ec2f7SArjan van de Ven #include <linux/mutex.h> 371fabe148SMark Fasheh #include <linux/jbd.h> 38ccd979bdSMark Fasheh 39ccd979bdSMark Fasheh #include "cluster/nodemanager.h" 40ccd979bdSMark Fasheh #include "cluster/heartbeat.h" 41ccd979bdSMark Fasheh #include "cluster/tcp.h" 42ccd979bdSMark Fasheh 43ccd979bdSMark Fasheh #include "dlm/dlmapi.h" 44ccd979bdSMark Fasheh 45ccd979bdSMark Fasheh #include "ocfs2_fs.h" 46ccd979bdSMark Fasheh #include "endian.h" 47ccd979bdSMark Fasheh #include "ocfs2_lockid.h" 48ccd979bdSMark Fasheh 49ccd979bdSMark Fasheh /* Most user visible OCFS2 inodes will have very few pieces of 50ccd979bdSMark Fasheh * metadata, but larger files (including bitmaps, etc) must be taken 51ccd979bdSMark Fasheh * into account when designing an access scheme. We allow a small 52ccd979bdSMark Fasheh * amount of inlined blocks to be stored on an array and grow the 53ccd979bdSMark Fasheh * structure into a rb tree when necessary. */ 54ccd979bdSMark Fasheh #define OCFS2_INODE_MAX_CACHE_ARRAY 2 55ccd979bdSMark Fasheh 56ccd979bdSMark Fasheh struct ocfs2_caching_info { 57ccd979bdSMark Fasheh unsigned int ci_num_cached; 58ccd979bdSMark Fasheh union { 59ccd979bdSMark Fasheh sector_t ci_array[OCFS2_INODE_MAX_CACHE_ARRAY]; 60ccd979bdSMark Fasheh struct rb_root ci_tree; 61ccd979bdSMark Fasheh } ci_cache; 62ccd979bdSMark Fasheh }; 63ccd979bdSMark Fasheh 64ccd979bdSMark Fasheh /* this limits us to 256 nodes 65ccd979bdSMark Fasheh * if we need more, we can do a kmalloc for the map */ 66ccd979bdSMark Fasheh #define OCFS2_NODE_MAP_MAX_NODES 256 67ccd979bdSMark Fasheh struct ocfs2_node_map { 68ccd979bdSMark Fasheh u16 num_nodes; 69ccd979bdSMark Fasheh unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)]; 70ccd979bdSMark Fasheh }; 71ccd979bdSMark Fasheh 72ccd979bdSMark Fasheh enum ocfs2_ast_action { 73ccd979bdSMark Fasheh OCFS2_AST_INVALID = 0, 74ccd979bdSMark Fasheh OCFS2_AST_ATTACH, 75ccd979bdSMark Fasheh OCFS2_AST_CONVERT, 76ccd979bdSMark Fasheh OCFS2_AST_DOWNCONVERT, 77ccd979bdSMark Fasheh }; 78ccd979bdSMark Fasheh 79ccd979bdSMark Fasheh /* actions for an unlockast function to take. */ 80ccd979bdSMark Fasheh enum ocfs2_unlock_action { 81ccd979bdSMark Fasheh OCFS2_UNLOCK_INVALID = 0, 82ccd979bdSMark Fasheh OCFS2_UNLOCK_CANCEL_CONVERT, 83ccd979bdSMark Fasheh OCFS2_UNLOCK_DROP_LOCK, 84ccd979bdSMark Fasheh }; 85ccd979bdSMark Fasheh 86ccd979bdSMark Fasheh /* ocfs2_lock_res->l_flags flags. */ 87ccd979bdSMark Fasheh #define OCFS2_LOCK_ATTACHED (0x00000001) /* have we initialized 88ccd979bdSMark Fasheh * the lvb */ 89ccd979bdSMark Fasheh #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in 90ccd979bdSMark Fasheh * dlm_lock */ 91ccd979bdSMark Fasheh #define OCFS2_LOCK_BLOCKED (0x00000004) /* blocked waiting to 92ccd979bdSMark Fasheh * downconvert*/ 93ccd979bdSMark Fasheh #define OCFS2_LOCK_LOCAL (0x00000008) /* newly created inode */ 94ccd979bdSMark Fasheh #define OCFS2_LOCK_NEEDS_REFRESH (0x00000010) 95ccd979bdSMark Fasheh #define OCFS2_LOCK_REFRESHING (0x00000020) 96ccd979bdSMark Fasheh #define OCFS2_LOCK_INITIALIZED (0x00000040) /* track initialization 97ccd979bdSMark Fasheh * for shutdown paths */ 98ccd979bdSMark Fasheh #define OCFS2_LOCK_FREEING (0x00000080) /* help dlmglue track 99ccd979bdSMark Fasheh * when to skip queueing 100ccd979bdSMark Fasheh * a lock because it's 101ccd979bdSMark Fasheh * about to be 102ccd979bdSMark Fasheh * dropped. */ 103ccd979bdSMark Fasheh #define OCFS2_LOCK_QUEUED (0x00000100) /* queued for downconvert */ 104ccd979bdSMark Fasheh 105ccd979bdSMark Fasheh struct ocfs2_lock_res_ops; 106ccd979bdSMark Fasheh 107ccd979bdSMark Fasheh typedef void (*ocfs2_lock_callback)(int status, unsigned long data); 108ccd979bdSMark Fasheh 109ccd979bdSMark Fasheh struct ocfs2_lock_res { 110ccd979bdSMark Fasheh void *l_priv; 111ccd979bdSMark Fasheh struct ocfs2_lock_res_ops *l_ops; 112ccd979bdSMark Fasheh spinlock_t l_lock; 113ccd979bdSMark Fasheh 114ccd979bdSMark Fasheh struct list_head l_blocked_list; 115ccd979bdSMark Fasheh struct list_head l_mask_waiters; 116ccd979bdSMark Fasheh 117ccd979bdSMark Fasheh enum ocfs2_lock_type l_type; 118ccd979bdSMark Fasheh unsigned long l_flags; 119ccd979bdSMark Fasheh char l_name[OCFS2_LOCK_ID_MAX_LEN]; 120ccd979bdSMark Fasheh int l_level; 121ccd979bdSMark Fasheh unsigned int l_ro_holders; 122ccd979bdSMark Fasheh unsigned int l_ex_holders; 123ccd979bdSMark Fasheh struct dlm_lockstatus l_lksb; 124ccd979bdSMark Fasheh 125ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 126ccd979bdSMark Fasheh enum ocfs2_ast_action l_action; 127ccd979bdSMark Fasheh enum ocfs2_unlock_action l_unlock_action; 128ccd979bdSMark Fasheh int l_requested; 129ccd979bdSMark Fasheh int l_blocking; 130ccd979bdSMark Fasheh 131ccd979bdSMark Fasheh wait_queue_head_t l_event; 132ccd979bdSMark Fasheh 133ccd979bdSMark Fasheh struct list_head l_debug_list; 134ccd979bdSMark Fasheh }; 135ccd979bdSMark Fasheh 136ccd979bdSMark Fasheh struct ocfs2_dlm_debug { 137ccd979bdSMark Fasheh struct kref d_refcnt; 138ccd979bdSMark Fasheh struct dentry *d_locking_state; 139ccd979bdSMark Fasheh struct list_head d_lockres_tracking; 140ccd979bdSMark Fasheh }; 141ccd979bdSMark Fasheh 142ccd979bdSMark Fasheh enum ocfs2_vol_state 143ccd979bdSMark Fasheh { 144ccd979bdSMark Fasheh VOLUME_INIT = 0, 145ccd979bdSMark Fasheh VOLUME_MOUNTED, 146ccd979bdSMark Fasheh VOLUME_DISMOUNTED, 147ccd979bdSMark Fasheh VOLUME_DISABLED 148ccd979bdSMark Fasheh }; 149ccd979bdSMark Fasheh 150ccd979bdSMark Fasheh struct ocfs2_alloc_stats 151ccd979bdSMark Fasheh { 152ccd979bdSMark Fasheh atomic_t moves; 153ccd979bdSMark Fasheh atomic_t local_data; 154ccd979bdSMark Fasheh atomic_t bitmap_data; 155ccd979bdSMark Fasheh atomic_t bg_allocs; 156ccd979bdSMark Fasheh atomic_t bg_extends; 157ccd979bdSMark Fasheh }; 158ccd979bdSMark Fasheh 159ccd979bdSMark Fasheh enum ocfs2_local_alloc_state 160ccd979bdSMark Fasheh { 161ccd979bdSMark Fasheh OCFS2_LA_UNUSED = 0, 162ccd979bdSMark Fasheh OCFS2_LA_ENABLED, 163ccd979bdSMark Fasheh OCFS2_LA_DISABLED 164ccd979bdSMark Fasheh }; 165ccd979bdSMark Fasheh 166ccd979bdSMark Fasheh enum ocfs2_mount_options 167ccd979bdSMark Fasheh { 168ccd979bdSMark Fasheh OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Heartbeat started in local mode */ 169ccd979bdSMark Fasheh OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 170ccd979bdSMark Fasheh OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 171ccd979bdSMark Fasheh OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 172ccd979bdSMark Fasheh OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 173ccd979bdSMark Fasheh }; 174ccd979bdSMark Fasheh 175ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 176ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 177ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 1787f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 179ccd979bdSMark Fasheh 180ccd979bdSMark Fasheh struct ocfs2_journal; 181ccd979bdSMark Fasheh struct ocfs2_super 182ccd979bdSMark Fasheh { 183ccd979bdSMark Fasheh struct task_struct *commit_task; 184ccd979bdSMark Fasheh struct super_block *sb; 185ccd979bdSMark Fasheh struct inode *root_inode; 186ccd979bdSMark Fasheh struct inode *sys_root_inode; 187ccd979bdSMark Fasheh struct inode *system_inodes[NUM_SYSTEM_INODES]; 188ccd979bdSMark Fasheh 189ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 190ccd979bdSMark Fasheh 191ccd979bdSMark Fasheh spinlock_t node_map_lock; 192ccd979bdSMark Fasheh struct ocfs2_node_map recovery_map; 193ccd979bdSMark Fasheh 194ccd979bdSMark Fasheh u64 root_blkno; 195ccd979bdSMark Fasheh u64 system_dir_blkno; 196ccd979bdSMark Fasheh u64 bitmap_blkno; 197ccd979bdSMark Fasheh u32 bitmap_cpg; 198ccd979bdSMark Fasheh u8 *uuid; 199ccd979bdSMark Fasheh char *uuid_str; 200ccd979bdSMark Fasheh u8 *vol_label; 201ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 202ccd979bdSMark Fasheh u32 fs_generation; 203ccd979bdSMark Fasheh 204ccd979bdSMark Fasheh u32 s_feature_compat; 205ccd979bdSMark Fasheh u32 s_feature_incompat; 206ccd979bdSMark Fasheh u32 s_feature_ro_compat; 207ccd979bdSMark Fasheh 208ccd979bdSMark Fasheh /* Protects s_next_generaion, osb_flags. Could protect more on 209ccd979bdSMark Fasheh * osb as it's very short lived. */ 210ccd979bdSMark Fasheh spinlock_t osb_lock; 211ccd979bdSMark Fasheh u32 s_next_generation; 212ccd979bdSMark Fasheh unsigned long osb_flags; 213ccd979bdSMark Fasheh 214ccd979bdSMark Fasheh unsigned long s_mount_opt; 2157f1a37e3STiger Yang unsigned int s_atime_quantum; 216ccd979bdSMark Fasheh 217ccd979bdSMark Fasheh u16 max_slots; 218ccd979bdSMark Fasheh s16 node_num; 219ccd979bdSMark Fasheh s16 slot_num; 220baf4661aSSunil Mushran s16 preferred_slot; 221ccd979bdSMark Fasheh int s_sectsize_bits; 222ccd979bdSMark Fasheh int s_clustersize; 223ccd979bdSMark Fasheh int s_clustersize_bits; 224ccd979bdSMark Fasheh 225ccd979bdSMark Fasheh atomic_t vol_state; 226c74ec2f7SArjan van de Ven struct mutex recovery_lock; 227ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 228ccd979bdSMark Fasheh int disable_recovery; 229ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 230ccd979bdSMark Fasheh atomic_t needs_checkpoint; 231ccd979bdSMark Fasheh struct ocfs2_journal *journal; 232ccd979bdSMark Fasheh 233ccd979bdSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; 234ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 235883d4caeSMark Fasheh u64 la_last_gd; 236ccd979bdSMark Fasheh 237ccd979bdSMark Fasheh /* Next two fields are for local node slot recovery during 238ccd979bdSMark Fasheh * mount. */ 239ccd979bdSMark Fasheh int dirty; 240ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 241ccd979bdSMark Fasheh 242ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 243ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 244ccd979bdSMark Fasheh 245ccd979bdSMark Fasheh struct dlm_ctxt *dlm; 246ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 247ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 248ccd979bdSMark Fasheh struct dlm_eviction_cb osb_eviction_cb; 249ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 250ccd979bdSMark Fasheh 251ccd979bdSMark Fasheh struct dentry *osb_debug_root; 252ccd979bdSMark Fasheh 253ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 254ccd979bdSMark Fasheh 25534d024f8SMark Fasheh spinlock_t dc_task_lock; 25634d024f8SMark Fasheh struct task_struct *dc_task; 25734d024f8SMark Fasheh wait_queue_head_t dc_event; 25834d024f8SMark Fasheh unsigned long dc_wake_sequence; 25934d024f8SMark Fasheh unsigned long dc_work_sequence; 260ccd979bdSMark Fasheh 261ccd979bdSMark Fasheh struct list_head blocked_lock_list; 262ccd979bdSMark Fasheh unsigned long blocked_lock_count; 263ccd979bdSMark Fasheh 264ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 265ccd979bdSMark Fasheh 266ccd979bdSMark Fasheh /* Truncate log info */ 267ccd979bdSMark Fasheh struct inode *osb_tl_inode; 268ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 269c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 270b4df6ed8SMark Fasheh 271b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 272b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 273b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 274ccd979bdSMark Fasheh }; 275ccd979bdSMark Fasheh 276ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 277ccd979bdSMark Fasheh 278ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 279ccd979bdSMark Fasheh { 280ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 281ccd979bdSMark Fasheh return 0; 282ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 283ccd979bdSMark Fasheh return 0; 284ccd979bdSMark Fasheh return 1; 285ccd979bdSMark Fasheh } 286ccd979bdSMark Fasheh 287dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 288dcd0538fSMark Fasheh { 289dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 290dcd0538fSMark Fasheh return 1; 291dcd0538fSMark Fasheh return 0; 292dcd0538fSMark Fasheh } 293dcd0538fSMark Fasheh 294328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 295328d5752SMark Fasheh { 296328d5752SMark Fasheh /* 297328d5752SMark Fasheh * Support for sparse files is a pre-requisite 298328d5752SMark Fasheh */ 299328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 300328d5752SMark Fasheh return 0; 301328d5752SMark Fasheh 302328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 303328d5752SMark Fasheh return 1; 304328d5752SMark Fasheh return 0; 305328d5752SMark Fasheh } 306328d5752SMark Fasheh 30715b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 30815b1e36bSMark Fasheh { 30915b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 31015b1e36bSMark Fasheh return 1; 31115b1e36bSMark Fasheh return 0; 31215b1e36bSMark Fasheh } 31315b1e36bSMark Fasheh 314ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 315ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 316ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 317ccd979bdSMark Fasheh * too! */ 318ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 319ccd979bdSMark Fasheh unsigned long flag) 320ccd979bdSMark Fasheh { 321ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 322ccd979bdSMark Fasheh osb->osb_flags |= flag; 323ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 324ccd979bdSMark Fasheh } 325ccd979bdSMark Fasheh 326ccd979bdSMark Fasheh static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 327ccd979bdSMark Fasheh int hard) 328ccd979bdSMark Fasheh { 329ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 330ccd979bdSMark Fasheh osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 331ccd979bdSMark Fasheh if (hard) 332ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_HARD_RO; 333ccd979bdSMark Fasheh else 334ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_SOFT_RO; 335ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 336ccd979bdSMark Fasheh } 337ccd979bdSMark Fasheh 338ccd979bdSMark Fasheh static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 339ccd979bdSMark Fasheh { 340ccd979bdSMark Fasheh int ret; 341ccd979bdSMark Fasheh 342ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 343ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 344ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 345ccd979bdSMark Fasheh 346ccd979bdSMark Fasheh return ret; 347ccd979bdSMark Fasheh } 348ccd979bdSMark Fasheh 349ccd979bdSMark Fasheh static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 350ccd979bdSMark Fasheh { 351ccd979bdSMark Fasheh int ret; 352ccd979bdSMark Fasheh 353ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 354ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 355ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 356ccd979bdSMark Fasheh 357ccd979bdSMark Fasheh return ret; 358ccd979bdSMark Fasheh } 359ccd979bdSMark Fasheh 360c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 361c271c5c2SSunil Mushran { 362c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 363c271c5c2SSunil Mushran } 364c271c5c2SSunil Mushran 365ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 366ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 367ccd979bdSMark Fasheh 368ccd979bdSMark Fasheh #define OCFS2_RO_ON_INVALID_DINODE(__sb, __di) do { \ 369ccd979bdSMark Fasheh typeof(__di) ____di = (__di); \ 370ccd979bdSMark Fasheh ocfs2_error((__sb), \ 371b0697053SMark Fasheh "Dinode # %llu has bad signature %.*s", \ 3721ca1a111SMark Fasheh (unsigned long long)le64_to_cpu((____di)->i_blkno), 7, \ 373ccd979bdSMark Fasheh (____di)->i_signature); \ 3741ca1a111SMark Fasheh } while (0) 375ccd979bdSMark Fasheh 376ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 377ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 378ccd979bdSMark Fasheh 379ccd979bdSMark Fasheh #define OCFS2_RO_ON_INVALID_EXTENT_BLOCK(__sb, __eb) do { \ 380ccd979bdSMark Fasheh typeof(__eb) ____eb = (__eb); \ 381ccd979bdSMark Fasheh ocfs2_error((__sb), \ 382b0697053SMark Fasheh "Extent Block # %llu has bad signature %.*s", \ 3831ca1a111SMark Fasheh (unsigned long long)le64_to_cpu((____eb)->h_blkno), 7, \ 384ccd979bdSMark Fasheh (____eb)->h_signature); \ 3851ca1a111SMark Fasheh } while (0) 386ccd979bdSMark Fasheh 387ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 388ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 389ccd979bdSMark Fasheh 390ccd979bdSMark Fasheh #define OCFS2_RO_ON_INVALID_GROUP_DESC(__sb, __gd) do { \ 391ccd979bdSMark Fasheh typeof(__gd) ____gd = (__gd); \ 392ccd979bdSMark Fasheh ocfs2_error((__sb), \ 393b0697053SMark Fasheh "Group Descriptor # %llu has bad signature %.*s", \ 3941ca1a111SMark Fasheh (unsigned long long)le64_to_cpu((____gd)->bg_blkno), 7, \ 395ccd979bdSMark Fasheh (____gd)->bg_signature); \ 3961ca1a111SMark Fasheh } while (0) 397ccd979bdSMark Fasheh 398ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 399ccd979bdSMark Fasheh u64 blkno) 400ccd979bdSMark Fasheh { 401ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 402ccd979bdSMark Fasheh } 403ccd979bdSMark Fasheh 404ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 405ccd979bdSMark Fasheh u32 clusters) 406ccd979bdSMark Fasheh { 407ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 408ccd979bdSMark Fasheh sb->s_blocksize_bits; 409ccd979bdSMark Fasheh 410ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 411ccd979bdSMark Fasheh } 412ccd979bdSMark Fasheh 413ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 414ccd979bdSMark Fasheh u64 blocks) 415ccd979bdSMark Fasheh { 416ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 417ccd979bdSMark Fasheh sb->s_blocksize_bits; 418ccd979bdSMark Fasheh 419ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 420ccd979bdSMark Fasheh } 421ccd979bdSMark Fasheh 422ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 423ccd979bdSMark Fasheh u64 bytes) 424ccd979bdSMark Fasheh { 425ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 426ccd979bdSMark Fasheh unsigned int clusters; 427ccd979bdSMark Fasheh 428ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 429ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 430ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 431ccd979bdSMark Fasheh 432ccd979bdSMark Fasheh return clusters; 433ccd979bdSMark Fasheh } 434ccd979bdSMark Fasheh 435ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 436ccd979bdSMark Fasheh u64 bytes) 437ccd979bdSMark Fasheh { 438ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 439ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 440ccd979bdSMark Fasheh } 441ccd979bdSMark Fasheh 442ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 443ccd979bdSMark Fasheh u32 clusters) 444ccd979bdSMark Fasheh { 445ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 446ccd979bdSMark Fasheh } 447ccd979bdSMark Fasheh 448ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 449ccd979bdSMark Fasheh u64 bytes) 450ccd979bdSMark Fasheh { 451ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 452ccd979bdSMark Fasheh unsigned int clusters; 453ccd979bdSMark Fasheh 454ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 455ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 456ccd979bdSMark Fasheh } 457ccd979bdSMark Fasheh 458ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 459ccd979bdSMark Fasheh u64 bytes) 460ccd979bdSMark Fasheh { 461ccd979bdSMark Fasheh u64 blocks; 462ccd979bdSMark Fasheh 463ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 464ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 465ccd979bdSMark Fasheh } 466ccd979bdSMark Fasheh 467ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 468ccd979bdSMark Fasheh { 469ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 470ccd979bdSMark Fasheh } 471ccd979bdSMark Fasheh 4729517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 4739517bac6SMark Fasheh unsigned long pg_index) 4749517bac6SMark Fasheh { 4759517bac6SMark Fasheh u32 clusters = pg_index; 4769517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 4779517bac6SMark Fasheh 4789517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 4799517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 4809517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 4819517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 4829517bac6SMark Fasheh 4839517bac6SMark Fasheh return clusters; 4849517bac6SMark Fasheh } 4859517bac6SMark Fasheh 4869517bac6SMark Fasheh /* 4879517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 4889517bac6SMark Fasheh */ 4897c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 4909517bac6SMark Fasheh u32 clusters) 4919517bac6SMark Fasheh { 4929517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 4937c08d70cSMark Fasheh pgoff_t index = clusters; 4949517bac6SMark Fasheh 4959517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 4967c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 4979517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 4987c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 4999517bac6SMark Fasheh } 5009517bac6SMark Fasheh 5019517bac6SMark Fasheh return index; 5029517bac6SMark Fasheh } 5039517bac6SMark Fasheh 50460b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 50560b11392SMark Fasheh { 50660b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 50760b11392SMark Fasheh unsigned int pages_per_cluster = 1; 50860b11392SMark Fasheh 50960b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 51060b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 51160b11392SMark Fasheh 51260b11392SMark Fasheh return pages_per_cluster; 51360b11392SMark Fasheh } 51460b11392SMark Fasheh 515ccd979bdSMark Fasheh #define ocfs2_set_bit ext2_set_bit 516ccd979bdSMark Fasheh #define ocfs2_clear_bit ext2_clear_bit 517ccd979bdSMark Fasheh #define ocfs2_test_bit ext2_test_bit 518ccd979bdSMark Fasheh #define ocfs2_find_next_zero_bit ext2_find_next_zero_bit 519ccd979bdSMark Fasheh #endif /* OCFS2_H */ 520ccd979bdSMark Fasheh 521