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> 37cb25797dSJan Kara #include <linux/lockdep.h> 382b4e30fbSJoel Becker #include <linux/jbd2.h> 39ccd979bdSMark Fasheh 408f2c9c1bSJoel Becker /* For union ocfs2_dlm_lksb */ 418f2c9c1bSJoel Becker #include "stackglue.h" 42ccd979bdSMark Fasheh 43ccd979bdSMark Fasheh #include "ocfs2_fs.h" 44ccd979bdSMark Fasheh #include "ocfs2_lockid.h" 459df5778eSTristan Ye #include "ocfs2_ioctl.h" 46ccd979bdSMark Fasheh 4773be192bSJoel Becker /* For struct ocfs2_blockcheck_stats */ 4873be192bSJoel Becker #include "blockcheck.h" 4973be192bSJoel Becker 50d02f00ccSMark Fasheh #include "reservations.h" 5147460d65SJoel Becker 5247460d65SJoel Becker /* Caching of metadata buffers */ 5347460d65SJoel Becker 54ccd979bdSMark Fasheh /* Most user visible OCFS2 inodes will have very few pieces of 55ccd979bdSMark Fasheh * metadata, but larger files (including bitmaps, etc) must be taken 56ccd979bdSMark Fasheh * into account when designing an access scheme. We allow a small 57ccd979bdSMark Fasheh * amount of inlined blocks to be stored on an array and grow the 58ccd979bdSMark Fasheh * structure into a rb tree when necessary. */ 5947460d65SJoel Becker #define OCFS2_CACHE_INFO_MAX_ARRAY 2 6047460d65SJoel Becker 6147460d65SJoel Becker /* Flags for ocfs2_caching_info */ 6247460d65SJoel Becker 6347460d65SJoel Becker enum ocfs2_caching_info_flags { 6447460d65SJoel Becker /* Indicates that the metadata cache is using the inline array */ 6547460d65SJoel Becker OCFS2_CACHE_FL_INLINE = 1<<1, 6647460d65SJoel Becker }; 67ccd979bdSMark Fasheh 686e5a3d75SJoel Becker struct ocfs2_caching_operations; 69ccd979bdSMark Fasheh struct ocfs2_caching_info { 7047460d65SJoel Becker /* 7147460d65SJoel Becker * The parent structure provides the locks, but because the 726e5a3d75SJoel Becker * parent structure can differ, it provides locking operations 736e5a3d75SJoel Becker * to struct ocfs2_caching_info. 7447460d65SJoel Becker */ 756e5a3d75SJoel Becker const struct ocfs2_caching_operations *ci_ops; 7647460d65SJoel Becker 77292dd27eSJoel Becker /* next two are protected by trans_inc_lock */ 78292dd27eSJoel Becker /* which transaction were we created on? Zero if none. */ 79292dd27eSJoel Becker unsigned long ci_created_trans; 8066fb345dSJoel Becker /* last transaction we were a part of. */ 8166fb345dSJoel Becker unsigned long ci_last_trans; 8266fb345dSJoel Becker 8366fb345dSJoel Becker /* Cache structures */ 8447460d65SJoel Becker unsigned int ci_flags; 85ccd979bdSMark Fasheh unsigned int ci_num_cached; 86ccd979bdSMark Fasheh union { 8747460d65SJoel Becker sector_t ci_array[OCFS2_CACHE_INFO_MAX_ARRAY]; 88ccd979bdSMark Fasheh struct rb_root ci_tree; 89ccd979bdSMark Fasheh } ci_cache; 90ccd979bdSMark Fasheh }; 910cf2f763SJoel Becker /* 920cf2f763SJoel Becker * Need this prototype here instead of in uptodate.h because journal.h 930cf2f763SJoel Becker * uses it. 940cf2f763SJoel Becker */ 950cf2f763SJoel Becker struct super_block *ocfs2_metadata_cache_get_super(struct ocfs2_caching_info *ci); 96ccd979bdSMark Fasheh 97ccd979bdSMark Fasheh /* this limits us to 256 nodes 98ccd979bdSMark Fasheh * if we need more, we can do a kmalloc for the map */ 99ccd979bdSMark Fasheh #define OCFS2_NODE_MAP_MAX_NODES 256 100ccd979bdSMark Fasheh struct ocfs2_node_map { 101ccd979bdSMark Fasheh u16 num_nodes; 102ccd979bdSMark Fasheh unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)]; 103ccd979bdSMark Fasheh }; 104ccd979bdSMark Fasheh 105ccd979bdSMark Fasheh enum ocfs2_ast_action { 106ccd979bdSMark Fasheh OCFS2_AST_INVALID = 0, 107ccd979bdSMark Fasheh OCFS2_AST_ATTACH, 108ccd979bdSMark Fasheh OCFS2_AST_CONVERT, 109ccd979bdSMark Fasheh OCFS2_AST_DOWNCONVERT, 110ccd979bdSMark Fasheh }; 111ccd979bdSMark Fasheh 112ccd979bdSMark Fasheh /* actions for an unlockast function to take. */ 113ccd979bdSMark Fasheh enum ocfs2_unlock_action { 114ccd979bdSMark Fasheh OCFS2_UNLOCK_INVALID = 0, 115ccd979bdSMark Fasheh OCFS2_UNLOCK_CANCEL_CONVERT, 116ccd979bdSMark Fasheh OCFS2_UNLOCK_DROP_LOCK, 117ccd979bdSMark Fasheh }; 118ccd979bdSMark Fasheh 119ccd979bdSMark Fasheh /* ocfs2_lock_res->l_flags flags. */ 1203b5da018SColy Li #define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized 121ccd979bdSMark Fasheh * the lvb */ 122ccd979bdSMark Fasheh #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in 123ccd979bdSMark Fasheh * dlm_lock */ 124ccd979bdSMark Fasheh #define OCFS2_LOCK_BLOCKED (0x00000004) /* blocked waiting to 125ccd979bdSMark Fasheh * downconvert*/ 126ccd979bdSMark Fasheh #define OCFS2_LOCK_LOCAL (0x00000008) /* newly created inode */ 127ccd979bdSMark Fasheh #define OCFS2_LOCK_NEEDS_REFRESH (0x00000010) 128ccd979bdSMark Fasheh #define OCFS2_LOCK_REFRESHING (0x00000020) 129ccd979bdSMark Fasheh #define OCFS2_LOCK_INITIALIZED (0x00000040) /* track initialization 130ccd979bdSMark Fasheh * for shutdown paths */ 131ccd979bdSMark Fasheh #define OCFS2_LOCK_FREEING (0x00000080) /* help dlmglue track 132ccd979bdSMark Fasheh * when to skip queueing 133ccd979bdSMark Fasheh * a lock because it's 134ccd979bdSMark Fasheh * about to be 135ccd979bdSMark Fasheh * dropped. */ 136ccd979bdSMark Fasheh #define OCFS2_LOCK_QUEUED (0x00000100) /* queued for downconvert */ 137cf8e06f1SMark Fasheh #define OCFS2_LOCK_NOCACHE (0x00000200) /* don't use a holder count */ 138de551246SJoel Becker #define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a 139de551246SJoel Becker call to dlm_lock. Only 140de551246SJoel Becker exists with BUSY set. */ 141a1912826SSunil Mushran #define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread 142a1912826SSunil Mushran * from downconverting 143a1912826SSunil Mushran * before the upconvert 144a1912826SSunil Mushran * has completed */ 145ccd979bdSMark Fasheh 146ccd979bdSMark Fasheh struct ocfs2_lock_res_ops; 147ccd979bdSMark Fasheh 148ccd979bdSMark Fasheh typedef void (*ocfs2_lock_callback)(int status, unsigned long data); 149ccd979bdSMark Fasheh 150ccd979bdSMark Fasheh struct ocfs2_lock_res { 151ccd979bdSMark Fasheh void *l_priv; 152ccd979bdSMark Fasheh struct ocfs2_lock_res_ops *l_ops; 153ccd979bdSMark Fasheh spinlock_t l_lock; 154ccd979bdSMark Fasheh 155ccd979bdSMark Fasheh struct list_head l_blocked_list; 156ccd979bdSMark Fasheh struct list_head l_mask_waiters; 157ccd979bdSMark Fasheh 158ccd979bdSMark Fasheh enum ocfs2_lock_type l_type; 159ccd979bdSMark Fasheh unsigned long l_flags; 160ccd979bdSMark Fasheh char l_name[OCFS2_LOCK_ID_MAX_LEN]; 161ccd979bdSMark Fasheh int l_level; 162ccd979bdSMark Fasheh unsigned int l_ro_holders; 163ccd979bdSMark Fasheh unsigned int l_ex_holders; 164c0e41338SJoel Becker struct ocfs2_dlm_lksb l_lksb; 165ccd979bdSMark Fasheh 166ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 167ccd979bdSMark Fasheh enum ocfs2_ast_action l_action; 168ccd979bdSMark Fasheh enum ocfs2_unlock_action l_unlock_action; 169ccd979bdSMark Fasheh int l_requested; 170ccd979bdSMark Fasheh int l_blocking; 171de551246SJoel Becker unsigned int l_pending_gen; 172ccd979bdSMark Fasheh 173ccd979bdSMark Fasheh wait_queue_head_t l_event; 174ccd979bdSMark Fasheh 175ccd979bdSMark Fasheh struct list_head l_debug_list; 1768ddb7b00SSunil Mushran 1778ddb7b00SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 1788ddb7b00SSunil Mushran unsigned long long l_lock_num_prmode; /* PR acquires */ 1798ddb7b00SSunil Mushran unsigned long long l_lock_num_exmode; /* EX acquires */ 1808ddb7b00SSunil Mushran unsigned int l_lock_num_prmode_failed; /* Failed PR gets */ 1818ddb7b00SSunil Mushran unsigned int l_lock_num_exmode_failed; /* Failed EX gets */ 1828ddb7b00SSunil Mushran unsigned long long l_lock_total_prmode; /* Tot wait for PR */ 1838ddb7b00SSunil Mushran unsigned long long l_lock_total_exmode; /* Tot wait for EX */ 1848ddb7b00SSunil Mushran unsigned int l_lock_max_prmode; /* Max wait for PR */ 1858ddb7b00SSunil Mushran unsigned int l_lock_max_exmode; /* Max wait for EX */ 1868ddb7b00SSunil Mushran unsigned int l_lock_refresh; /* Disk refreshes */ 1878ddb7b00SSunil Mushran #endif 188cb25797dSJan Kara #ifdef CONFIG_DEBUG_LOCK_ALLOC 189cb25797dSJan Kara struct lockdep_map l_lockdep_map; 190cb25797dSJan Kara #endif 191ccd979bdSMark Fasheh }; 192ccd979bdSMark Fasheh 193692684e1SSunil Mushran enum ocfs2_orphan_scan_state { 194692684e1SSunil Mushran ORPHAN_SCAN_ACTIVE, 195692684e1SSunil Mushran ORPHAN_SCAN_INACTIVE 196692684e1SSunil Mushran }; 197692684e1SSunil Mushran 19883273932SSrinivas Eeda struct ocfs2_orphan_scan { 19983273932SSrinivas Eeda struct mutex os_lock; 20083273932SSrinivas Eeda struct ocfs2_super *os_osb; 20183273932SSrinivas Eeda struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */ 20283273932SSrinivas Eeda struct delayed_work os_orphan_scan_work; 20315633a22SSrinivas Eeda struct timespec os_scantime; /* time this node ran the scan */ 20415633a22SSrinivas Eeda u32 os_count; /* tracks node specific scans */ 20515633a22SSrinivas Eeda u32 os_seqno; /* tracks cluster wide scans */ 206692684e1SSunil Mushran atomic_t os_state; /* ACTIVE or INACTIVE */ 20783273932SSrinivas Eeda }; 20883273932SSrinivas Eeda 209ccd979bdSMark Fasheh struct ocfs2_dlm_debug { 210ccd979bdSMark Fasheh struct kref d_refcnt; 211ccd979bdSMark Fasheh struct dentry *d_locking_state; 212ccd979bdSMark Fasheh struct list_head d_lockres_tracking; 213ccd979bdSMark Fasheh }; 214ccd979bdSMark Fasheh 215ccd979bdSMark Fasheh enum ocfs2_vol_state 216ccd979bdSMark Fasheh { 217ccd979bdSMark Fasheh VOLUME_INIT = 0, 218ccd979bdSMark Fasheh VOLUME_MOUNTED, 21919ece546SJan Kara VOLUME_MOUNTED_QUOTAS, 220ccd979bdSMark Fasheh VOLUME_DISMOUNTED, 221ccd979bdSMark Fasheh VOLUME_DISABLED 222ccd979bdSMark Fasheh }; 223ccd979bdSMark Fasheh 224ccd979bdSMark Fasheh struct ocfs2_alloc_stats 225ccd979bdSMark Fasheh { 226ccd979bdSMark Fasheh atomic_t moves; 227ccd979bdSMark Fasheh atomic_t local_data; 228ccd979bdSMark Fasheh atomic_t bitmap_data; 229ccd979bdSMark Fasheh atomic_t bg_allocs; 230ccd979bdSMark Fasheh atomic_t bg_extends; 231ccd979bdSMark Fasheh }; 232ccd979bdSMark Fasheh 233ccd979bdSMark Fasheh enum ocfs2_local_alloc_state 234ccd979bdSMark Fasheh { 2359c7af40bSMark Fasheh OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for 2369c7af40bSMark Fasheh * this mountpoint. */ 2379c7af40bSMark Fasheh OCFS2_LA_ENABLED, /* Local alloc is in use. */ 2389c7af40bSMark Fasheh OCFS2_LA_THROTTLED, /* Local alloc is in use, but number 2399c7af40bSMark Fasheh * of bits has been reduced. */ 2409c7af40bSMark Fasheh OCFS2_LA_DISABLED /* Local alloc has temporarily been 2419c7af40bSMark Fasheh * disabled. */ 242ccd979bdSMark Fasheh }; 243ccd979bdSMark Fasheh 244ccd979bdSMark Fasheh enum ocfs2_mount_options 245ccd979bdSMark Fasheh { 246ccd979bdSMark Fasheh OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Heartbeat started in local mode */ 247ccd979bdSMark Fasheh OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 248ccd979bdSMark Fasheh OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 249ccd979bdSMark Fasheh OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 250ccd979bdSMark Fasheh OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 25153fc622bSMark Fasheh OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */ 252cf1d6c76STiger Yang OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */ 25312462f1dSJoel Becker OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */ 2545297aad8SJan Kara OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */ 2555297aad8SJan Kara OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access 2565297aad8SJan Kara control lists */ 2575297aad8SJan Kara OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */ 2585297aad8SJan Kara OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */ 259ccd979bdSMark Fasheh }; 260ccd979bdSMark Fasheh 261ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 262ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 263ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 264f7b1aa69SJan Kara #define OCFS2_OSB_DROP_DENTRY_LOCK_IMMED 0x0008 265f7b1aa69SJan Kara 2667f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 267ccd979bdSMark Fasheh 268ccd979bdSMark Fasheh struct ocfs2_journal; 269d85b20e4SJoel Becker struct ocfs2_slot_info; 270553abd04SJoel Becker struct ocfs2_recovery_map; 2719140db04SSrinivas Eeda struct ocfs2_replay_map; 2722205363dSJan Kara struct ocfs2_quota_recovery; 273ea455f8aSJan Kara struct ocfs2_dentry_lock; 274ccd979bdSMark Fasheh struct ocfs2_super 275ccd979bdSMark Fasheh { 276ccd979bdSMark Fasheh struct task_struct *commit_task; 277ccd979bdSMark Fasheh struct super_block *sb; 278ccd979bdSMark Fasheh struct inode *root_inode; 279ccd979bdSMark Fasheh struct inode *sys_root_inode; 280ccd979bdSMark Fasheh struct inode *system_inodes[NUM_SYSTEM_INODES]; 281ccd979bdSMark Fasheh 282ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 283ccd979bdSMark Fasheh 284539d8264SSunil Mushran u32 *slot_recovery_generations; 285539d8264SSunil Mushran 286ccd979bdSMark Fasheh spinlock_t node_map_lock; 287ccd979bdSMark Fasheh 288ccd979bdSMark Fasheh u64 root_blkno; 289ccd979bdSMark Fasheh u64 system_dir_blkno; 290ccd979bdSMark Fasheh u64 bitmap_blkno; 291ccd979bdSMark Fasheh u32 bitmap_cpg; 292ccd979bdSMark Fasheh u8 *uuid; 293ccd979bdSMark Fasheh char *uuid_str; 294cf1d6c76STiger Yang u32 uuid_hash; 295ccd979bdSMark Fasheh u8 *vol_label; 296ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 297ccd979bdSMark Fasheh u32 fs_generation; 298ccd979bdSMark Fasheh 299ccd979bdSMark Fasheh u32 s_feature_compat; 300ccd979bdSMark Fasheh u32 s_feature_incompat; 301ccd979bdSMark Fasheh u32 s_feature_ro_compat; 302ccd979bdSMark Fasheh 3034d0ddb2cSTao Ma /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 3044d0ddb2cSTao Ma * Could protect more on osb as it's very short lived. 3054d0ddb2cSTao Ma */ 306ccd979bdSMark Fasheh spinlock_t osb_lock; 307ccd979bdSMark Fasheh u32 s_next_generation; 308ccd979bdSMark Fasheh unsigned long osb_flags; 3094d0ddb2cSTao Ma s16 s_inode_steal_slot; 310b89c5428STiger Yang s16 s_meta_steal_slot; 3114d0ddb2cSTao Ma atomic_t s_num_inodes_stolen; 312b89c5428STiger Yang atomic_t s_num_meta_stolen; 313ccd979bdSMark Fasheh 314ccd979bdSMark Fasheh unsigned long s_mount_opt; 3157f1a37e3STiger Yang unsigned int s_atime_quantum; 316ccd979bdSMark Fasheh 317fc881fa0SJoel Becker unsigned int max_slots; 31819fdb624SJoel Becker unsigned int node_num; 319fc881fa0SJoel Becker int slot_num; 320fc881fa0SJoel Becker int preferred_slot; 321ccd979bdSMark Fasheh int s_sectsize_bits; 322ccd979bdSMark Fasheh int s_clustersize; 323ccd979bdSMark Fasheh int s_clustersize_bits; 324fdd77704STiger Yang unsigned int s_xattr_inline_size; 325ccd979bdSMark Fasheh 326ccd979bdSMark Fasheh atomic_t vol_state; 327c74ec2f7SArjan van de Ven struct mutex recovery_lock; 328553abd04SJoel Becker struct ocfs2_recovery_map *recovery_map; 3299140db04SSrinivas Eeda struct ocfs2_replay_map *replay_map; 330ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 331ccd979bdSMark Fasheh int disable_recovery; 332ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 333ccd979bdSMark Fasheh atomic_t needs_checkpoint; 334ccd979bdSMark Fasheh struct ocfs2_journal *journal; 335d147b3d6SMark Fasheh unsigned long osb_commit_interval; 336ccd979bdSMark Fasheh 3379c7af40bSMark Fasheh struct delayed_work la_enable_wq; 3389c7af40bSMark Fasheh 3399c7af40bSMark Fasheh /* 3409c7af40bSMark Fasheh * Must hold local alloc i_mutex and osb->osb_lock to change 3419c7af40bSMark Fasheh * local_alloc_bits. Reads can be done under either lock. 3429c7af40bSMark Fasheh */ 343ebcee4b5SMark Fasheh unsigned int local_alloc_bits; 3449c7af40bSMark Fasheh unsigned int local_alloc_default_bits; 3456b82021bSMark Fasheh /* osb_clusters_at_boot can become stale! Do not trust it to 3466b82021bSMark Fasheh * be up to date. */ 3476b82021bSMark Fasheh unsigned int osb_clusters_at_boot; 3489c7af40bSMark Fasheh 3499c7af40bSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; /* protected 3509c7af40bSMark Fasheh * by osb_lock */ 3519c7af40bSMark Fasheh 352ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 3539c7af40bSMark Fasheh 354883d4caeSMark Fasheh u64 la_last_gd; 355ccd979bdSMark Fasheh 356d02f00ccSMark Fasheh struct ocfs2_reservation_map osb_la_resmap; 357d02f00ccSMark Fasheh 358d02f00ccSMark Fasheh unsigned int osb_resv_level; 35983f92318SMark Fasheh unsigned int osb_dir_resv_level; 360d02f00ccSMark Fasheh 3612205363dSJan Kara /* Next three fields are for local node slot recovery during 362ccd979bdSMark Fasheh * mount. */ 363ccd979bdSMark Fasheh int dirty; 364ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 3652205363dSJan Kara struct ocfs2_quota_recovery *quota_rec; 366ccd979bdSMark Fasheh 36773be192bSJoel Becker struct ocfs2_blockcheck_stats osb_ecc_stats; 368ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 369ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 370ccd979bdSMark Fasheh 371b61817e1SJoel Becker char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 3724670c46dSJoel Becker struct ocfs2_cluster_connection *cconn; 373ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 374ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 3756ca497a8Swengang wang struct ocfs2_lock_res osb_nfs_sync_lockres; 376ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 377ccd979bdSMark Fasheh 378ccd979bdSMark Fasheh struct dentry *osb_debug_root; 37950397507SSunil Mushran struct dentry *osb_ctxt; 380ccd979bdSMark Fasheh 381ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 382ccd979bdSMark Fasheh 38334d024f8SMark Fasheh spinlock_t dc_task_lock; 38434d024f8SMark Fasheh struct task_struct *dc_task; 38534d024f8SMark Fasheh wait_queue_head_t dc_event; 38634d024f8SMark Fasheh unsigned long dc_wake_sequence; 38734d024f8SMark Fasheh unsigned long dc_work_sequence; 388ccd979bdSMark Fasheh 3897ec373cfSMark Fasheh /* 3907ec373cfSMark Fasheh * Any thread can add locks to the list, but the downconvert 3917ec373cfSMark Fasheh * thread is the only one allowed to remove locks. Any change 3927ec373cfSMark Fasheh * to this rule requires updating 3937ec373cfSMark Fasheh * ocfs2_downconvert_thread_do_work(). 3947ec373cfSMark Fasheh */ 395ccd979bdSMark Fasheh struct list_head blocked_lock_list; 396ccd979bdSMark Fasheh unsigned long blocked_lock_count; 397ccd979bdSMark Fasheh 398ea455f8aSJan Kara /* List of dentry locks to release. Anyone can add locks to 399ea455f8aSJan Kara * the list, ocfs2_wq processes the list */ 400ea455f8aSJan Kara struct ocfs2_dentry_lock *dentry_lock_list; 401ea455f8aSJan Kara struct work_struct dentry_lock_work; 402ea455f8aSJan Kara 403ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 404ccd979bdSMark Fasheh 405ccd979bdSMark Fasheh /* Truncate log info */ 406ccd979bdSMark Fasheh struct inode *osb_tl_inode; 407ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 408c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 409b4df6ed8SMark Fasheh 410b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 411b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 412b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 413c8b9cf9aSTao Ma 41483273932SSrinivas Eeda struct ocfs2_orphan_scan osb_orphan_scan; 41583273932SSrinivas Eeda 416c8b9cf9aSTao Ma /* used to protect metaecc calculation check of xattr. */ 417c8b9cf9aSTao Ma spinlock_t osb_xattr_lock; 4189b7895efSMark Fasheh 4199b7895efSMark Fasheh unsigned int osb_dx_mask; 4209b7895efSMark Fasheh u32 osb_dx_seed[4]; 421feb473a6STao Ma 422feb473a6STao Ma /* the group we used to allocate inodes. */ 423feb473a6STao Ma u64 osb_inode_alloc_group; 424374a263eSTao Ma 425374a263eSTao Ma /* rb tree root for refcount lock. */ 426374a263eSTao Ma struct rb_root osb_rf_lock_tree; 427374a263eSTao Ma struct ocfs2_refcount_tree *osb_ref_tree_lru; 428ccd979bdSMark Fasheh }; 429ccd979bdSMark Fasheh 430ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 431ccd979bdSMark Fasheh 43213723d00SJoel Becker /* Useful typedef for passing around journal access functions */ 4330cf2f763SJoel Becker typedef int (*ocfs2_journal_access_func)(handle_t *handle, 4340cf2f763SJoel Becker struct ocfs2_caching_info *ci, 43513723d00SJoel Becker struct buffer_head *bh, int type); 43613723d00SJoel Becker 437ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 438ccd979bdSMark Fasheh { 439ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 440ccd979bdSMark Fasheh return 0; 441ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 442ccd979bdSMark Fasheh return 0; 443ccd979bdSMark Fasheh return 1; 444ccd979bdSMark Fasheh } 445ccd979bdSMark Fasheh 446dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 447dcd0538fSMark Fasheh { 448dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 449dcd0538fSMark Fasheh return 1; 450dcd0538fSMark Fasheh return 0; 451dcd0538fSMark Fasheh } 452dcd0538fSMark Fasheh 453328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 454328d5752SMark Fasheh { 455328d5752SMark Fasheh /* 456328d5752SMark Fasheh * Support for sparse files is a pre-requisite 457328d5752SMark Fasheh */ 458328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 459328d5752SMark Fasheh return 0; 460328d5752SMark Fasheh 461328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 462328d5752SMark Fasheh return 1; 463328d5752SMark Fasheh return 0; 464328d5752SMark Fasheh } 465328d5752SMark Fasheh 46615b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 46715b1e36bSMark Fasheh { 46815b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 46915b1e36bSMark Fasheh return 1; 47015b1e36bSMark Fasheh return 0; 47115b1e36bSMark Fasheh } 47215b1e36bSMark Fasheh 4738154da3dSTiger Yang static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 4748154da3dSTiger Yang { 4758154da3dSTiger Yang if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 4768154da3dSTiger Yang return 1; 4778154da3dSTiger Yang return 0; 4788154da3dSTiger Yang } 4798154da3dSTiger Yang 48070ad1ba7SJoel Becker static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 48170ad1ba7SJoel Becker { 48270ad1ba7SJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 48370ad1ba7SJoel Becker return 1; 48470ad1ba7SJoel Becker return 0; 48570ad1ba7SJoel Becker } 48670ad1ba7SJoel Becker 4879b7895efSMark Fasheh static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 4889b7895efSMark Fasheh { 4899b7895efSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 4909b7895efSMark Fasheh return 1; 4919b7895efSMark Fasheh return 0; 4929b7895efSMark Fasheh } 4939b7895efSMark Fasheh 494198a1ca3SMark Fasheh static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 495198a1ca3SMark Fasheh { 496198a1ca3SMark Fasheh if (ocfs2_supports_indexed_dirs(osb)) 497198a1ca3SMark Fasheh return OCFS2_DX_LINK_MAX; 498198a1ca3SMark Fasheh return OCFS2_LINK_MAX; 499198a1ca3SMark Fasheh } 500198a1ca3SMark Fasheh 501198a1ca3SMark Fasheh static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 502198a1ca3SMark Fasheh { 503198a1ca3SMark Fasheh u32 nlink = le16_to_cpu(di->i_links_count); 504198a1ca3SMark Fasheh u32 hi = le16_to_cpu(di->i_links_count_hi); 505198a1ca3SMark Fasheh 506198a1ca3SMark Fasheh if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 507198a1ca3SMark Fasheh nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 508198a1ca3SMark Fasheh 509198a1ca3SMark Fasheh return nlink; 510198a1ca3SMark Fasheh } 511198a1ca3SMark Fasheh 512198a1ca3SMark Fasheh static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 513198a1ca3SMark Fasheh { 514198a1ca3SMark Fasheh u16 lo, hi; 515198a1ca3SMark Fasheh 516198a1ca3SMark Fasheh lo = nlink; 517198a1ca3SMark Fasheh hi = nlink >> OCFS2_LINKS_HI_SHIFT; 518198a1ca3SMark Fasheh 519198a1ca3SMark Fasheh di->i_links_count = cpu_to_le16(lo); 520198a1ca3SMark Fasheh di->i_links_count_hi = cpu_to_le16(hi); 521198a1ca3SMark Fasheh } 522198a1ca3SMark Fasheh 523198a1ca3SMark Fasheh static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 524198a1ca3SMark Fasheh { 525198a1ca3SMark Fasheh u32 links = ocfs2_read_links_count(di); 526198a1ca3SMark Fasheh 527198a1ca3SMark Fasheh links += n; 528198a1ca3SMark Fasheh 529198a1ca3SMark Fasheh ocfs2_set_links_count(di, links); 530198a1ca3SMark Fasheh } 531198a1ca3SMark Fasheh 5321aa75feaSTao Ma static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 5331aa75feaSTao Ma { 5341aa75feaSTao Ma if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 5351aa75feaSTao Ma return 1; 5361aa75feaSTao Ma return 0; 5371aa75feaSTao Ma } 5381aa75feaSTao Ma 539ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 540ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 541ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 542ccd979bdSMark Fasheh * too! */ 543ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 544ccd979bdSMark Fasheh unsigned long flag) 545ccd979bdSMark Fasheh { 546ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 547ccd979bdSMark Fasheh osb->osb_flags |= flag; 548ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 549ccd979bdSMark Fasheh } 550ccd979bdSMark Fasheh 551f7b1aa69SJan Kara 552f7b1aa69SJan Kara static inline unsigned long ocfs2_test_osb_flag(struct ocfs2_super *osb, 553f7b1aa69SJan Kara unsigned long flag) 554f7b1aa69SJan Kara { 555f7b1aa69SJan Kara unsigned long ret; 556f7b1aa69SJan Kara 557f7b1aa69SJan Kara spin_lock(&osb->osb_lock); 558f7b1aa69SJan Kara ret = osb->osb_flags & flag; 559f7b1aa69SJan Kara spin_unlock(&osb->osb_lock); 560f7b1aa69SJan Kara return ret; 561f7b1aa69SJan Kara } 562f7b1aa69SJan Kara 563ccd979bdSMark Fasheh static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 564ccd979bdSMark Fasheh int hard) 565ccd979bdSMark Fasheh { 566ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 567ccd979bdSMark Fasheh osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 568ccd979bdSMark Fasheh if (hard) 569ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_HARD_RO; 570ccd979bdSMark Fasheh else 571ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_SOFT_RO; 572ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 573ccd979bdSMark Fasheh } 574ccd979bdSMark Fasheh 575ccd979bdSMark Fasheh static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 576ccd979bdSMark Fasheh { 577ccd979bdSMark Fasheh int ret; 578ccd979bdSMark Fasheh 579ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 580ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 581ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 582ccd979bdSMark Fasheh 583ccd979bdSMark Fasheh return ret; 584ccd979bdSMark Fasheh } 585ccd979bdSMark Fasheh 586ccd979bdSMark Fasheh static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 587ccd979bdSMark Fasheh { 588ccd979bdSMark Fasheh int ret; 589ccd979bdSMark Fasheh 590ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 591ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 592ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 593ccd979bdSMark Fasheh 594ccd979bdSMark Fasheh return ret; 595ccd979bdSMark Fasheh } 596ccd979bdSMark Fasheh 597b61817e1SJoel Becker static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 598b61817e1SJoel Becker { 599b61817e1SJoel Becker return (osb->s_feature_incompat & 600b61817e1SJoel Becker OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK); 601b61817e1SJoel Becker } 602b61817e1SJoel Becker 603c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 604c271c5c2SSunil Mushran { 605c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 606c271c5c2SSunil Mushran } 607c271c5c2SSunil Mushran 608386a2ef8SJoel Becker static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 609386a2ef8SJoel Becker { 610386a2ef8SJoel Becker return (osb->s_feature_incompat & 611386a2ef8SJoel Becker OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 612386a2ef8SJoel Becker } 613386a2ef8SJoel Becker 614386a2ef8SJoel Becker 615ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 616ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 617ccd979bdSMark Fasheh 618ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 619ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 620ccd979bdSMark Fasheh 621ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 622ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 623ccd979bdSMark Fasheh 624ccd979bdSMark Fasheh 625f6087fb7SJoel Becker #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 626f6087fb7SJoel Becker (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 627f6087fb7SJoel Becker 62887d35a74SMark Fasheh #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 62987d35a74SMark Fasheh (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 63087d35a74SMark Fasheh 6319b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 6329b7895efSMark Fasheh (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 6339b7895efSMark Fasheh 6349b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 6359b7895efSMark Fasheh (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 6369b7895efSMark Fasheh 637f2c870e3STao Ma #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 638f2c870e3STao Ma (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 639f2c870e3STao Ma 640ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 641ccd979bdSMark Fasheh u64 blkno) 642ccd979bdSMark Fasheh { 643ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 644ccd979bdSMark Fasheh } 645ccd979bdSMark Fasheh 646ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 647ccd979bdSMark Fasheh u32 clusters) 648ccd979bdSMark Fasheh { 649ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 650ccd979bdSMark Fasheh sb->s_blocksize_bits; 651ccd979bdSMark Fasheh 652ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 653ccd979bdSMark Fasheh } 654ccd979bdSMark Fasheh 655ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 656ccd979bdSMark Fasheh u64 blocks) 657ccd979bdSMark Fasheh { 658ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 659ccd979bdSMark Fasheh sb->s_blocksize_bits; 660ccd979bdSMark Fasheh 661ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 662ccd979bdSMark Fasheh } 663ccd979bdSMark Fasheh 664ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 665ccd979bdSMark Fasheh u64 bytes) 666ccd979bdSMark Fasheh { 667ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 668ccd979bdSMark Fasheh unsigned int clusters; 669ccd979bdSMark Fasheh 670ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 671ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 672ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 673ccd979bdSMark Fasheh 674ccd979bdSMark Fasheh return clusters; 675ccd979bdSMark Fasheh } 676ccd979bdSMark Fasheh 677ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 678ccd979bdSMark Fasheh u64 bytes) 679ccd979bdSMark Fasheh { 680ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 681ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 682ccd979bdSMark Fasheh } 683ccd979bdSMark Fasheh 684ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 685ccd979bdSMark Fasheh u32 clusters) 686ccd979bdSMark Fasheh { 687ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 688ccd979bdSMark Fasheh } 689ccd979bdSMark Fasheh 6901d46dc08SMark Fasheh static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 6911d46dc08SMark Fasheh u64 blocks) 6921d46dc08SMark Fasheh { 6931d46dc08SMark Fasheh int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 6941d46dc08SMark Fasheh unsigned int clusters; 6951d46dc08SMark Fasheh 6961d46dc08SMark Fasheh clusters = ocfs2_blocks_to_clusters(sb, blocks); 6971d46dc08SMark Fasheh return (u64)clusters << bits; 6981d46dc08SMark Fasheh } 6991d46dc08SMark Fasheh 700ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 701ccd979bdSMark Fasheh u64 bytes) 702ccd979bdSMark Fasheh { 703ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 704ccd979bdSMark Fasheh unsigned int clusters; 705ccd979bdSMark Fasheh 706ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 707ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 708ccd979bdSMark Fasheh } 709ccd979bdSMark Fasheh 710ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 711ccd979bdSMark Fasheh u64 bytes) 712ccd979bdSMark Fasheh { 713ccd979bdSMark Fasheh u64 blocks; 714ccd979bdSMark Fasheh 715ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 716ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 717ccd979bdSMark Fasheh } 718ccd979bdSMark Fasheh 719ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 720ccd979bdSMark Fasheh { 721ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 722ccd979bdSMark Fasheh } 723ccd979bdSMark Fasheh 7249517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 7259517bac6SMark Fasheh unsigned long pg_index) 7269517bac6SMark Fasheh { 7279517bac6SMark Fasheh u32 clusters = pg_index; 7289517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7299517bac6SMark Fasheh 7309517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 7319517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 7329517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 7339517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 7349517bac6SMark Fasheh 7359517bac6SMark Fasheh return clusters; 7369517bac6SMark Fasheh } 7379517bac6SMark Fasheh 7389517bac6SMark Fasheh /* 7399517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 7409517bac6SMark Fasheh */ 7417c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 7429517bac6SMark Fasheh u32 clusters) 7439517bac6SMark Fasheh { 7449517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7457c08d70cSMark Fasheh pgoff_t index = clusters; 7469517bac6SMark Fasheh 7479517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 7487c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 7499517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 7507c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 7519517bac6SMark Fasheh } 7529517bac6SMark Fasheh 7539517bac6SMark Fasheh return index; 7549517bac6SMark Fasheh } 7559517bac6SMark Fasheh 75660b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 75760b11392SMark Fasheh { 75860b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 75960b11392SMark Fasheh unsigned int pages_per_cluster = 1; 76060b11392SMark Fasheh 76160b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 76260b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 76360b11392SMark Fasheh 76460b11392SMark Fasheh return pages_per_cluster; 76560b11392SMark Fasheh } 76660b11392SMark Fasheh 767ebcee4b5SMark Fasheh static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 768ebcee4b5SMark Fasheh unsigned int megs) 769ebcee4b5SMark Fasheh { 770ebcee4b5SMark Fasheh BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 771ebcee4b5SMark Fasheh 772ebcee4b5SMark Fasheh return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 773ebcee4b5SMark Fasheh } 774ebcee4b5SMark Fasheh 77573c8a800SMark Fasheh static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 77673c8a800SMark Fasheh unsigned int clusters) 77773c8a800SMark Fasheh { 77873c8a800SMark Fasheh return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 77973c8a800SMark Fasheh } 78073c8a800SMark Fasheh 781b4414eeaSMark Fasheh static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 782b4414eeaSMark Fasheh { 783b4414eeaSMark Fasheh ext2_set_bit(bit, bitmap); 784b4414eeaSMark Fasheh } 785b4414eeaSMark Fasheh #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 786b4414eeaSMark Fasheh 787b4414eeaSMark Fasheh static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 788b4414eeaSMark Fasheh { 789b4414eeaSMark Fasheh ext2_clear_bit(bit, bitmap); 790b4414eeaSMark Fasheh } 791b4414eeaSMark Fasheh #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 792b4414eeaSMark Fasheh 793ccd979bdSMark Fasheh #define ocfs2_test_bit ext2_test_bit 794ccd979bdSMark Fasheh #define ocfs2_find_next_zero_bit ext2_find_next_zero_bit 79570ad1ba7SJoel Becker #define ocfs2_find_next_bit ext2_find_next_bit 796ccd979bdSMark Fasheh #endif /* OCFS2_H */ 797ccd979bdSMark Fasheh 798