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; 15383fd9c7fSGoldwyn Rodrigues 154ccd979bdSMark Fasheh 155ccd979bdSMark Fasheh struct list_head l_blocked_list; 156ccd979bdSMark Fasheh struct list_head l_mask_waiters; 157ccd979bdSMark Fasheh 158ccd979bdSMark Fasheh unsigned long l_flags; 159ccd979bdSMark Fasheh char l_name[OCFS2_LOCK_ID_MAX_LEN]; 160ccd979bdSMark Fasheh unsigned int l_ro_holders; 161ccd979bdSMark Fasheh unsigned int l_ex_holders; 162a2a2f552SMilton Miller signed char l_level; 163a2a2f552SMilton Miller signed char l_requested; 164a2a2f552SMilton Miller signed char l_blocking; 16583fd9c7fSGoldwyn Rodrigues 16683fd9c7fSGoldwyn Rodrigues /* Data packed - type enum ocfs2_lock_type */ 16783fd9c7fSGoldwyn Rodrigues unsigned char l_type; 168ccd979bdSMark Fasheh 169ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 17083fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_ast_action */ 17183fd9c7fSGoldwyn Rodrigues unsigned char l_action; 17283fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_unlock_action */ 17383fd9c7fSGoldwyn Rodrigues unsigned char l_unlock_action; 174de551246SJoel Becker unsigned int l_pending_gen; 175ccd979bdSMark Fasheh 17683fd9c7fSGoldwyn Rodrigues spinlock_t l_lock; 17783fd9c7fSGoldwyn Rodrigues 17883fd9c7fSGoldwyn Rodrigues struct ocfs2_dlm_lksb l_lksb; 17983fd9c7fSGoldwyn Rodrigues 180ccd979bdSMark Fasheh wait_queue_head_t l_event; 181ccd979bdSMark Fasheh 182ccd979bdSMark Fasheh struct list_head l_debug_list; 1838ddb7b00SSunil Mushran 1848ddb7b00SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 1858ddb7b00SSunil Mushran unsigned long long l_lock_num_prmode; /* PR acquires */ 1868ddb7b00SSunil Mushran unsigned long long l_lock_num_exmode; /* EX acquires */ 1878ddb7b00SSunil Mushran unsigned int l_lock_num_prmode_failed; /* Failed PR gets */ 1888ddb7b00SSunil Mushran unsigned int l_lock_num_exmode_failed; /* Failed EX gets */ 1898ddb7b00SSunil Mushran unsigned long long l_lock_total_prmode; /* Tot wait for PR */ 1908ddb7b00SSunil Mushran unsigned long long l_lock_total_exmode; /* Tot wait for EX */ 1918ddb7b00SSunil Mushran unsigned int l_lock_max_prmode; /* Max wait for PR */ 1928ddb7b00SSunil Mushran unsigned int l_lock_max_exmode; /* Max wait for EX */ 1938ddb7b00SSunil Mushran unsigned int l_lock_refresh; /* Disk refreshes */ 1948ddb7b00SSunil Mushran #endif 195cb25797dSJan Kara #ifdef CONFIG_DEBUG_LOCK_ALLOC 196cb25797dSJan Kara struct lockdep_map l_lockdep_map; 197cb25797dSJan Kara #endif 198ccd979bdSMark Fasheh }; 199ccd979bdSMark Fasheh 200692684e1SSunil Mushran enum ocfs2_orphan_scan_state { 201692684e1SSunil Mushran ORPHAN_SCAN_ACTIVE, 202692684e1SSunil Mushran ORPHAN_SCAN_INACTIVE 203692684e1SSunil Mushran }; 204692684e1SSunil Mushran 20583273932SSrinivas Eeda struct ocfs2_orphan_scan { 20683273932SSrinivas Eeda struct mutex os_lock; 20783273932SSrinivas Eeda struct ocfs2_super *os_osb; 20883273932SSrinivas Eeda struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */ 20983273932SSrinivas Eeda struct delayed_work os_orphan_scan_work; 21015633a22SSrinivas Eeda struct timespec os_scantime; /* time this node ran the scan */ 21115633a22SSrinivas Eeda u32 os_count; /* tracks node specific scans */ 21215633a22SSrinivas Eeda u32 os_seqno; /* tracks cluster wide scans */ 213692684e1SSunil Mushran atomic_t os_state; /* ACTIVE or INACTIVE */ 21483273932SSrinivas Eeda }; 21583273932SSrinivas Eeda 216ccd979bdSMark Fasheh struct ocfs2_dlm_debug { 217ccd979bdSMark Fasheh struct kref d_refcnt; 218ccd979bdSMark Fasheh struct dentry *d_locking_state; 219ccd979bdSMark Fasheh struct list_head d_lockres_tracking; 220ccd979bdSMark Fasheh }; 221ccd979bdSMark Fasheh 222ccd979bdSMark Fasheh enum ocfs2_vol_state 223ccd979bdSMark Fasheh { 224ccd979bdSMark Fasheh VOLUME_INIT = 0, 225ccd979bdSMark Fasheh VOLUME_MOUNTED, 22619ece546SJan Kara VOLUME_MOUNTED_QUOTAS, 227ccd979bdSMark Fasheh VOLUME_DISMOUNTED, 228ccd979bdSMark Fasheh VOLUME_DISABLED 229ccd979bdSMark Fasheh }; 230ccd979bdSMark Fasheh 231ccd979bdSMark Fasheh struct ocfs2_alloc_stats 232ccd979bdSMark Fasheh { 233ccd979bdSMark Fasheh atomic_t moves; 234ccd979bdSMark Fasheh atomic_t local_data; 235ccd979bdSMark Fasheh atomic_t bitmap_data; 236ccd979bdSMark Fasheh atomic_t bg_allocs; 237ccd979bdSMark Fasheh atomic_t bg_extends; 238ccd979bdSMark Fasheh }; 239ccd979bdSMark Fasheh 240ccd979bdSMark Fasheh enum ocfs2_local_alloc_state 241ccd979bdSMark Fasheh { 2429c7af40bSMark Fasheh OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for 2439c7af40bSMark Fasheh * this mountpoint. */ 2449c7af40bSMark Fasheh OCFS2_LA_ENABLED, /* Local alloc is in use. */ 2459c7af40bSMark Fasheh OCFS2_LA_THROTTLED, /* Local alloc is in use, but number 2469c7af40bSMark Fasheh * of bits has been reduced. */ 2479c7af40bSMark Fasheh OCFS2_LA_DISABLED /* Local alloc has temporarily been 2489c7af40bSMark Fasheh * disabled. */ 249ccd979bdSMark Fasheh }; 250ccd979bdSMark Fasheh 251ccd979bdSMark Fasheh enum ocfs2_mount_options 252ccd979bdSMark Fasheh { 2532c442719SSunil Mushran OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */ 254ccd979bdSMark Fasheh OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 255ccd979bdSMark Fasheh OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 256ccd979bdSMark Fasheh OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 257ccd979bdSMark Fasheh OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 25853fc622bSMark Fasheh OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */ 259cf1d6c76STiger Yang OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */ 26012462f1dSJoel Becker OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */ 2615297aad8SJan Kara OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */ 2625297aad8SJan Kara OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access 2635297aad8SJan Kara control lists */ 2645297aad8SJan Kara OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */ 2655297aad8SJan Kara OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */ 266fc371891SJoel Becker OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT 2677bdb0d18STristan Ye writes */ 268fc371891SJoel Becker OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */ 269fc371891SJoel Becker OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */ 270ccd979bdSMark Fasheh }; 271ccd979bdSMark Fasheh 272ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 273ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 274ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 275f7b1aa69SJan Kara #define OCFS2_OSB_DROP_DENTRY_LOCK_IMMED 0x0008 276f7b1aa69SJan Kara 2777f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 278ccd979bdSMark Fasheh 279ccd979bdSMark Fasheh struct ocfs2_journal; 280d85b20e4SJoel Becker struct ocfs2_slot_info; 281553abd04SJoel Becker struct ocfs2_recovery_map; 2829140db04SSrinivas Eeda struct ocfs2_replay_map; 2832205363dSJan Kara struct ocfs2_quota_recovery; 284ea455f8aSJan Kara struct ocfs2_dentry_lock; 285ccd979bdSMark Fasheh struct ocfs2_super 286ccd979bdSMark Fasheh { 287ccd979bdSMark Fasheh struct task_struct *commit_task; 288ccd979bdSMark Fasheh struct super_block *sb; 289ccd979bdSMark Fasheh struct inode *root_inode; 290ccd979bdSMark Fasheh struct inode *sys_root_inode; 291b4d693fcSTao Ma struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES]; 292b4d693fcSTao Ma struct inode **local_system_inodes; 293ccd979bdSMark Fasheh 294ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 295ccd979bdSMark Fasheh 296539d8264SSunil Mushran u32 *slot_recovery_generations; 297539d8264SSunil Mushran 298ccd979bdSMark Fasheh spinlock_t node_map_lock; 299ccd979bdSMark Fasheh 300ccd979bdSMark Fasheh u64 root_blkno; 301ccd979bdSMark Fasheh u64 system_dir_blkno; 302ccd979bdSMark Fasheh u64 bitmap_blkno; 303ccd979bdSMark Fasheh u32 bitmap_cpg; 304ccd979bdSMark Fasheh u8 *uuid; 305ccd979bdSMark Fasheh char *uuid_str; 306cf1d6c76STiger Yang u32 uuid_hash; 307ccd979bdSMark Fasheh u8 *vol_label; 308ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 309ccd979bdSMark Fasheh u32 fs_generation; 310ccd979bdSMark Fasheh 311ccd979bdSMark Fasheh u32 s_feature_compat; 312ccd979bdSMark Fasheh u32 s_feature_incompat; 313ccd979bdSMark Fasheh u32 s_feature_ro_compat; 314ccd979bdSMark Fasheh 3154d0ddb2cSTao Ma /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 3164d0ddb2cSTao Ma * Could protect more on osb as it's very short lived. 3174d0ddb2cSTao Ma */ 318ccd979bdSMark Fasheh spinlock_t osb_lock; 319ccd979bdSMark Fasheh u32 s_next_generation; 320ccd979bdSMark Fasheh unsigned long osb_flags; 3214d0ddb2cSTao Ma s16 s_inode_steal_slot; 322b89c5428STiger Yang s16 s_meta_steal_slot; 3234d0ddb2cSTao Ma atomic_t s_num_inodes_stolen; 324b89c5428STiger Yang atomic_t s_num_meta_stolen; 325ccd979bdSMark Fasheh 326ccd979bdSMark Fasheh unsigned long s_mount_opt; 3277f1a37e3STiger Yang unsigned int s_atime_quantum; 328ccd979bdSMark Fasheh 329fc881fa0SJoel Becker unsigned int max_slots; 33019fdb624SJoel Becker unsigned int node_num; 331fc881fa0SJoel Becker int slot_num; 332fc881fa0SJoel Becker int preferred_slot; 333ccd979bdSMark Fasheh int s_sectsize_bits; 334ccd979bdSMark Fasheh int s_clustersize; 335ccd979bdSMark Fasheh int s_clustersize_bits; 336fdd77704STiger Yang unsigned int s_xattr_inline_size; 337ccd979bdSMark Fasheh 338ccd979bdSMark Fasheh atomic_t vol_state; 339c74ec2f7SArjan van de Ven struct mutex recovery_lock; 340553abd04SJoel Becker struct ocfs2_recovery_map *recovery_map; 3419140db04SSrinivas Eeda struct ocfs2_replay_map *replay_map; 342ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 343ccd979bdSMark Fasheh int disable_recovery; 344ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 345ccd979bdSMark Fasheh atomic_t needs_checkpoint; 346ccd979bdSMark Fasheh struct ocfs2_journal *journal; 347d147b3d6SMark Fasheh unsigned long osb_commit_interval; 348ccd979bdSMark Fasheh 3499c7af40bSMark Fasheh struct delayed_work la_enable_wq; 3509c7af40bSMark Fasheh 3519c7af40bSMark Fasheh /* 3529c7af40bSMark Fasheh * Must hold local alloc i_mutex and osb->osb_lock to change 3539c7af40bSMark Fasheh * local_alloc_bits. Reads can be done under either lock. 3549c7af40bSMark Fasheh */ 355ebcee4b5SMark Fasheh unsigned int local_alloc_bits; 3569c7af40bSMark Fasheh unsigned int local_alloc_default_bits; 3576b82021bSMark Fasheh /* osb_clusters_at_boot can become stale! Do not trust it to 3586b82021bSMark Fasheh * be up to date. */ 3596b82021bSMark Fasheh unsigned int osb_clusters_at_boot; 3609c7af40bSMark Fasheh 3619c7af40bSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; /* protected 3629c7af40bSMark Fasheh * by osb_lock */ 3639c7af40bSMark Fasheh 364ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 3659c7af40bSMark Fasheh 366883d4caeSMark Fasheh u64 la_last_gd; 367ccd979bdSMark Fasheh 368d02f00ccSMark Fasheh struct ocfs2_reservation_map osb_la_resmap; 369d02f00ccSMark Fasheh 370d02f00ccSMark Fasheh unsigned int osb_resv_level; 37183f92318SMark Fasheh unsigned int osb_dir_resv_level; 372d02f00ccSMark Fasheh 3732205363dSJan Kara /* Next three fields are for local node slot recovery during 374ccd979bdSMark Fasheh * mount. */ 375ccd979bdSMark Fasheh int dirty; 376ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 3772205363dSJan Kara struct ocfs2_quota_recovery *quota_rec; 378ccd979bdSMark Fasheh 37973be192bSJoel Becker struct ocfs2_blockcheck_stats osb_ecc_stats; 380ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 381ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 382ccd979bdSMark Fasheh 38398f486f2SSunil Mushran u8 osb_stackflags; 38498f486f2SSunil Mushran 385b61817e1SJoel Becker char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 3864670c46dSJoel Becker struct ocfs2_cluster_connection *cconn; 387ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 388ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 3896ca497a8Swengang wang struct ocfs2_lock_res osb_nfs_sync_lockres; 390ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 391ccd979bdSMark Fasheh 392ccd979bdSMark Fasheh struct dentry *osb_debug_root; 39350397507SSunil Mushran struct dentry *osb_ctxt; 394ccd979bdSMark Fasheh 395ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 396ccd979bdSMark Fasheh 39734d024f8SMark Fasheh spinlock_t dc_task_lock; 39834d024f8SMark Fasheh struct task_struct *dc_task; 39934d024f8SMark Fasheh wait_queue_head_t dc_event; 40034d024f8SMark Fasheh unsigned long dc_wake_sequence; 40134d024f8SMark Fasheh unsigned long dc_work_sequence; 402ccd979bdSMark Fasheh 4037ec373cfSMark Fasheh /* 4047ec373cfSMark Fasheh * Any thread can add locks to the list, but the downconvert 4057ec373cfSMark Fasheh * thread is the only one allowed to remove locks. Any change 4067ec373cfSMark Fasheh * to this rule requires updating 4077ec373cfSMark Fasheh * ocfs2_downconvert_thread_do_work(). 4087ec373cfSMark Fasheh */ 409ccd979bdSMark Fasheh struct list_head blocked_lock_list; 410ccd979bdSMark Fasheh unsigned long blocked_lock_count; 411ccd979bdSMark Fasheh 412ea455f8aSJan Kara /* List of dentry locks to release. Anyone can add locks to 413ea455f8aSJan Kara * the list, ocfs2_wq processes the list */ 414ea455f8aSJan Kara struct ocfs2_dentry_lock *dentry_lock_list; 415ea455f8aSJan Kara struct work_struct dentry_lock_work; 416ea455f8aSJan Kara 417ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 418ccd979bdSMark Fasheh 419ccd979bdSMark Fasheh /* Truncate log info */ 420ccd979bdSMark Fasheh struct inode *osb_tl_inode; 421ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 422c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 42350308d81STao Ma /* 42450308d81STao Ma * How many clusters in our truncate log. 42550308d81STao Ma * It must be protected by osb_tl_inode->i_mutex. 42650308d81STao Ma */ 42750308d81STao Ma unsigned int truncated_clusters; 428b4df6ed8SMark Fasheh 429b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 430b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 431b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 432c8b9cf9aSTao Ma 43383273932SSrinivas Eeda struct ocfs2_orphan_scan osb_orphan_scan; 43483273932SSrinivas Eeda 435c8b9cf9aSTao Ma /* used to protect metaecc calculation check of xattr. */ 436c8b9cf9aSTao Ma spinlock_t osb_xattr_lock; 4379b7895efSMark Fasheh 4389b7895efSMark Fasheh unsigned int osb_dx_mask; 4399b7895efSMark Fasheh u32 osb_dx_seed[4]; 440feb473a6STao Ma 441feb473a6STao Ma /* the group we used to allocate inodes. */ 442feb473a6STao Ma u64 osb_inode_alloc_group; 443374a263eSTao Ma 444374a263eSTao Ma /* rb tree root for refcount lock. */ 445374a263eSTao Ma struct rb_root osb_rf_lock_tree; 446374a263eSTao Ma struct ocfs2_refcount_tree *osb_ref_tree_lru; 447ccd979bdSMark Fasheh }; 448ccd979bdSMark Fasheh 449ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 450ccd979bdSMark Fasheh 45113723d00SJoel Becker /* Useful typedef for passing around journal access functions */ 4520cf2f763SJoel Becker typedef int (*ocfs2_journal_access_func)(handle_t *handle, 4530cf2f763SJoel Becker struct ocfs2_caching_info *ci, 45413723d00SJoel Becker struct buffer_head *bh, int type); 45513723d00SJoel Becker 456ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 457ccd979bdSMark Fasheh { 458ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 459ccd979bdSMark Fasheh return 0; 460ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 461ccd979bdSMark Fasheh return 0; 462ccd979bdSMark Fasheh return 1; 463ccd979bdSMark Fasheh } 464ccd979bdSMark Fasheh 465dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 466dcd0538fSMark Fasheh { 467dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 468dcd0538fSMark Fasheh return 1; 469dcd0538fSMark Fasheh return 0; 470dcd0538fSMark Fasheh } 471dcd0538fSMark Fasheh 472328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 473328d5752SMark Fasheh { 474328d5752SMark Fasheh /* 475328d5752SMark Fasheh * Support for sparse files is a pre-requisite 476328d5752SMark Fasheh */ 477328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 478328d5752SMark Fasheh return 0; 479328d5752SMark Fasheh 480328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 481328d5752SMark Fasheh return 1; 482328d5752SMark Fasheh return 0; 483328d5752SMark Fasheh } 484328d5752SMark Fasheh 48515b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 48615b1e36bSMark Fasheh { 48715b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 48815b1e36bSMark Fasheh return 1; 48915b1e36bSMark Fasheh return 0; 49015b1e36bSMark Fasheh } 49115b1e36bSMark Fasheh 4928154da3dSTiger Yang static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 4938154da3dSTiger Yang { 4948154da3dSTiger Yang if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 4958154da3dSTiger Yang return 1; 4968154da3dSTiger Yang return 0; 4978154da3dSTiger Yang } 4988154da3dSTiger Yang 49970ad1ba7SJoel Becker static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 50070ad1ba7SJoel Becker { 50170ad1ba7SJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 50270ad1ba7SJoel Becker return 1; 50370ad1ba7SJoel Becker return 0; 50470ad1ba7SJoel Becker } 50570ad1ba7SJoel Becker 5069b7895efSMark Fasheh static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 5079b7895efSMark Fasheh { 5089b7895efSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 5099b7895efSMark Fasheh return 1; 5109b7895efSMark Fasheh return 0; 5119b7895efSMark Fasheh } 5129b7895efSMark Fasheh 5134711954eSTao Ma static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 514798db35fSJoel Becker { 515798db35fSJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 516798db35fSJoel Becker return 1; 517798db35fSJoel Becker return 0; 518798db35fSJoel Becker } 519798db35fSJoel Becker 520198a1ca3SMark Fasheh static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 521198a1ca3SMark Fasheh { 522198a1ca3SMark Fasheh if (ocfs2_supports_indexed_dirs(osb)) 523198a1ca3SMark Fasheh return OCFS2_DX_LINK_MAX; 524198a1ca3SMark Fasheh return OCFS2_LINK_MAX; 525198a1ca3SMark Fasheh } 526198a1ca3SMark Fasheh 527198a1ca3SMark Fasheh static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 528198a1ca3SMark Fasheh { 529198a1ca3SMark Fasheh u32 nlink = le16_to_cpu(di->i_links_count); 530198a1ca3SMark Fasheh u32 hi = le16_to_cpu(di->i_links_count_hi); 531198a1ca3SMark Fasheh 532198a1ca3SMark Fasheh if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 533198a1ca3SMark Fasheh nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 534198a1ca3SMark Fasheh 535198a1ca3SMark Fasheh return nlink; 536198a1ca3SMark Fasheh } 537198a1ca3SMark Fasheh 538198a1ca3SMark Fasheh static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 539198a1ca3SMark Fasheh { 540198a1ca3SMark Fasheh u16 lo, hi; 541198a1ca3SMark Fasheh 542198a1ca3SMark Fasheh lo = nlink; 543198a1ca3SMark Fasheh hi = nlink >> OCFS2_LINKS_HI_SHIFT; 544198a1ca3SMark Fasheh 545198a1ca3SMark Fasheh di->i_links_count = cpu_to_le16(lo); 546198a1ca3SMark Fasheh di->i_links_count_hi = cpu_to_le16(hi); 547198a1ca3SMark Fasheh } 548198a1ca3SMark Fasheh 549198a1ca3SMark Fasheh static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 550198a1ca3SMark Fasheh { 551198a1ca3SMark Fasheh u32 links = ocfs2_read_links_count(di); 552198a1ca3SMark Fasheh 553198a1ca3SMark Fasheh links += n; 554198a1ca3SMark Fasheh 555198a1ca3SMark Fasheh ocfs2_set_links_count(di, links); 556198a1ca3SMark Fasheh } 557198a1ca3SMark Fasheh 5581aa75feaSTao Ma static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 5591aa75feaSTao Ma { 5601aa75feaSTao Ma if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 5611aa75feaSTao Ma return 1; 5621aa75feaSTao Ma return 0; 5631aa75feaSTao Ma } 5641aa75feaSTao Ma 565ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 566ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 567ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 568ccd979bdSMark Fasheh * too! */ 569ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 570ccd979bdSMark Fasheh unsigned long flag) 571ccd979bdSMark Fasheh { 572ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 573ccd979bdSMark Fasheh osb->osb_flags |= flag; 574ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 575ccd979bdSMark Fasheh } 576ccd979bdSMark Fasheh 577f7b1aa69SJan Kara 578f7b1aa69SJan Kara static inline unsigned long ocfs2_test_osb_flag(struct ocfs2_super *osb, 579f7b1aa69SJan Kara unsigned long flag) 580f7b1aa69SJan Kara { 581f7b1aa69SJan Kara unsigned long ret; 582f7b1aa69SJan Kara 583f7b1aa69SJan Kara spin_lock(&osb->osb_lock); 584f7b1aa69SJan Kara ret = osb->osb_flags & flag; 585f7b1aa69SJan Kara spin_unlock(&osb->osb_lock); 586f7b1aa69SJan Kara return ret; 587f7b1aa69SJan Kara } 588f7b1aa69SJan Kara 589ccd979bdSMark Fasheh static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 590ccd979bdSMark Fasheh int hard) 591ccd979bdSMark Fasheh { 592ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 593ccd979bdSMark Fasheh osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 594ccd979bdSMark Fasheh if (hard) 595ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_HARD_RO; 596ccd979bdSMark Fasheh else 597ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_SOFT_RO; 598ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 599ccd979bdSMark Fasheh } 600ccd979bdSMark Fasheh 601ccd979bdSMark Fasheh static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 602ccd979bdSMark Fasheh { 603ccd979bdSMark Fasheh int ret; 604ccd979bdSMark Fasheh 605ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 606ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 607ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 608ccd979bdSMark Fasheh 609ccd979bdSMark Fasheh return ret; 610ccd979bdSMark Fasheh } 611ccd979bdSMark Fasheh 612ccd979bdSMark Fasheh static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 613ccd979bdSMark Fasheh { 614ccd979bdSMark Fasheh int ret; 615ccd979bdSMark Fasheh 616ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 617ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 618ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 619ccd979bdSMark Fasheh 620ccd979bdSMark Fasheh return ret; 621ccd979bdSMark Fasheh } 622ccd979bdSMark Fasheh 62398f486f2SSunil Mushran static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb) 624b61817e1SJoel Becker { 625b61817e1SJoel Becker return (osb->s_feature_incompat & 62698f486f2SSunil Mushran (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK | 62798f486f2SSunil Mushran OCFS2_FEATURE_INCOMPAT_CLUSTERINFO)); 62898f486f2SSunil Mushran } 62998f486f2SSunil Mushran 63098f486f2SSunil Mushran static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 63198f486f2SSunil Mushran { 63298f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 63398f486f2SSunil Mushran memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 63498f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 63598f486f2SSunil Mushran return 1; 63698f486f2SSunil Mushran return 0; 63798f486f2SSunil Mushran } 63898f486f2SSunil Mushran 63998f486f2SSunil Mushran static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb) 64098f486f2SSunil Mushran { 64198f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 64298f486f2SSunil Mushran !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 64398f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 64498f486f2SSunil Mushran return 1; 64598f486f2SSunil Mushran return 0; 64698f486f2SSunil Mushran } 64798f486f2SSunil Mushran 64898f486f2SSunil Mushran static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb) 64998f486f2SSunil Mushran { 65098f486f2SSunil Mushran return ocfs2_o2cb_stack(osb) && 65198f486f2SSunil Mushran (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT); 652b61817e1SJoel Becker } 653b61817e1SJoel Becker 654c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 655c271c5c2SSunil Mushran { 656c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 657c271c5c2SSunil Mushran } 658c271c5c2SSunil Mushran 659386a2ef8SJoel Becker static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 660386a2ef8SJoel Becker { 661386a2ef8SJoel Becker return (osb->s_feature_incompat & 662386a2ef8SJoel Becker OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 663386a2ef8SJoel Becker } 664386a2ef8SJoel Becker 665386a2ef8SJoel Becker 666ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 667ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 668ccd979bdSMark Fasheh 669ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 670ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 671ccd979bdSMark Fasheh 672ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 673ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 674ccd979bdSMark Fasheh 675ccd979bdSMark Fasheh 676f6087fb7SJoel Becker #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 677f6087fb7SJoel Becker (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 678f6087fb7SJoel Becker 67987d35a74SMark Fasheh #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 68087d35a74SMark Fasheh (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 68187d35a74SMark Fasheh 6829b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 6839b7895efSMark Fasheh (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 6849b7895efSMark Fasheh 6859b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 6869b7895efSMark Fasheh (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 6879b7895efSMark Fasheh 688f2c870e3STao Ma #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 689f2c870e3STao Ma (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 690f2c870e3STao Ma 691ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 692ccd979bdSMark Fasheh u64 blkno) 693ccd979bdSMark Fasheh { 694ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 695ccd979bdSMark Fasheh } 696ccd979bdSMark Fasheh 697ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 698ccd979bdSMark Fasheh u32 clusters) 699ccd979bdSMark Fasheh { 700ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 701ccd979bdSMark Fasheh sb->s_blocksize_bits; 702ccd979bdSMark Fasheh 703ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 704ccd979bdSMark Fasheh } 705ccd979bdSMark Fasheh 706ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 707ccd979bdSMark Fasheh u64 blocks) 708ccd979bdSMark Fasheh { 709ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 710ccd979bdSMark Fasheh sb->s_blocksize_bits; 711ccd979bdSMark Fasheh 712ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 713ccd979bdSMark Fasheh } 714ccd979bdSMark Fasheh 715ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 716ccd979bdSMark Fasheh u64 bytes) 717ccd979bdSMark Fasheh { 718ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 719ccd979bdSMark Fasheh unsigned int clusters; 720ccd979bdSMark Fasheh 721ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 722ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 723ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 724ccd979bdSMark Fasheh 725ccd979bdSMark Fasheh return clusters; 726ccd979bdSMark Fasheh } 727ccd979bdSMark Fasheh 728ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 729ccd979bdSMark Fasheh u64 bytes) 730ccd979bdSMark Fasheh { 731ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 732ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 733ccd979bdSMark Fasheh } 734ccd979bdSMark Fasheh 735ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 736ccd979bdSMark Fasheh u32 clusters) 737ccd979bdSMark Fasheh { 738ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 739ccd979bdSMark Fasheh } 740ccd979bdSMark Fasheh 7411d46dc08SMark Fasheh static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 7421d46dc08SMark Fasheh u64 blocks) 7431d46dc08SMark Fasheh { 7441d46dc08SMark Fasheh int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 7451d46dc08SMark Fasheh unsigned int clusters; 7461d46dc08SMark Fasheh 7471d46dc08SMark Fasheh clusters = ocfs2_blocks_to_clusters(sb, blocks); 7481d46dc08SMark Fasheh return (u64)clusters << bits; 7491d46dc08SMark Fasheh } 7501d46dc08SMark Fasheh 751ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 752ccd979bdSMark Fasheh u64 bytes) 753ccd979bdSMark Fasheh { 754ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 755ccd979bdSMark Fasheh unsigned int clusters; 756ccd979bdSMark Fasheh 757ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 758ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 759ccd979bdSMark Fasheh } 760ccd979bdSMark Fasheh 761ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 762ccd979bdSMark Fasheh u64 bytes) 763ccd979bdSMark Fasheh { 764ccd979bdSMark Fasheh u64 blocks; 765ccd979bdSMark Fasheh 766ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 767ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 768ccd979bdSMark Fasheh } 769ccd979bdSMark Fasheh 770ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 771ccd979bdSMark Fasheh { 772ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 773ccd979bdSMark Fasheh } 774ccd979bdSMark Fasheh 7759517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 7769517bac6SMark Fasheh unsigned long pg_index) 7779517bac6SMark Fasheh { 7789517bac6SMark Fasheh u32 clusters = pg_index; 7799517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7809517bac6SMark Fasheh 7819517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 7829517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 7839517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 7849517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 7859517bac6SMark Fasheh 7869517bac6SMark Fasheh return clusters; 7879517bac6SMark Fasheh } 7889517bac6SMark Fasheh 7899517bac6SMark Fasheh /* 7909517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 7919517bac6SMark Fasheh */ 7927c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 7939517bac6SMark Fasheh u32 clusters) 7949517bac6SMark Fasheh { 7959517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7967c08d70cSMark Fasheh pgoff_t index = clusters; 7979517bac6SMark Fasheh 7989517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 7997c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 8009517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 8017c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 8029517bac6SMark Fasheh } 8039517bac6SMark Fasheh 8049517bac6SMark Fasheh return index; 8059517bac6SMark Fasheh } 8069517bac6SMark Fasheh 80760b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 80860b11392SMark Fasheh { 80960b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 81060b11392SMark Fasheh unsigned int pages_per_cluster = 1; 81160b11392SMark Fasheh 81260b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 81360b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 81460b11392SMark Fasheh 81560b11392SMark Fasheh return pages_per_cluster; 81660b11392SMark Fasheh } 81760b11392SMark Fasheh 818ebcee4b5SMark Fasheh static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 819ebcee4b5SMark Fasheh unsigned int megs) 820ebcee4b5SMark Fasheh { 821ebcee4b5SMark Fasheh BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 822ebcee4b5SMark Fasheh 823ebcee4b5SMark Fasheh return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 824ebcee4b5SMark Fasheh } 825ebcee4b5SMark Fasheh 82673c8a800SMark Fasheh static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 82773c8a800SMark Fasheh unsigned int clusters) 82873c8a800SMark Fasheh { 82973c8a800SMark Fasheh return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 83073c8a800SMark Fasheh } 83173c8a800SMark Fasheh 832b4414eeaSMark Fasheh static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 833b4414eeaSMark Fasheh { 834c4354d0dSAkinobu Mita __test_and_set_bit_le(bit, bitmap); 835b4414eeaSMark Fasheh } 836b4414eeaSMark Fasheh #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 837b4414eeaSMark Fasheh 838b4414eeaSMark Fasheh static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 839b4414eeaSMark Fasheh { 840c4354d0dSAkinobu Mita __test_and_clear_bit_le(bit, bitmap); 841b4414eeaSMark Fasheh } 842b4414eeaSMark Fasheh #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 843b4414eeaSMark Fasheh 844c4354d0dSAkinobu Mita #define ocfs2_test_bit test_bit_le 845c4354d0dSAkinobu Mita #define ocfs2_find_next_zero_bit find_next_zero_bit_le 846c4354d0dSAkinobu Mita #define ocfs2_find_next_bit find_next_bit_le 847ccd979bdSMark Fasheh #endif /* OCFS2_H */ 848ccd979bdSMark Fasheh 849