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> 33e3a767b6SJan Kara #include <linux/llist.h> 34ccd979bdSMark Fasheh #include <linux/rbtree.h> 35ccd979bdSMark Fasheh #include <linux/workqueue.h> 36ccd979bdSMark Fasheh #include <linux/kref.h> 37c74ec2f7SArjan van de Ven #include <linux/mutex.h> 38cb25797dSJan Kara #include <linux/lockdep.h> 392b4e30fbSJoel Becker #include <linux/jbd2.h> 40ccd979bdSMark Fasheh 418f2c9c1bSJoel Becker /* For union ocfs2_dlm_lksb */ 428f2c9c1bSJoel Becker #include "stackglue.h" 43ccd979bdSMark Fasheh 44ccd979bdSMark Fasheh #include "ocfs2_fs.h" 45ccd979bdSMark Fasheh #include "ocfs2_lockid.h" 469df5778eSTristan Ye #include "ocfs2_ioctl.h" 47ccd979bdSMark Fasheh 4873be192bSJoel Becker /* For struct ocfs2_blockcheck_stats */ 4973be192bSJoel Becker #include "blockcheck.h" 5073be192bSJoel Becker 51d02f00ccSMark Fasheh #include "reservations.h" 5247460d65SJoel Becker 5347460d65SJoel Becker /* Caching of metadata buffers */ 5447460d65SJoel Becker 55ccd979bdSMark Fasheh /* Most user visible OCFS2 inodes will have very few pieces of 56ccd979bdSMark Fasheh * metadata, but larger files (including bitmaps, etc) must be taken 57ccd979bdSMark Fasheh * into account when designing an access scheme. We allow a small 58ccd979bdSMark Fasheh * amount of inlined blocks to be stored on an array and grow the 59ccd979bdSMark Fasheh * structure into a rb tree when necessary. */ 6047460d65SJoel Becker #define OCFS2_CACHE_INFO_MAX_ARRAY 2 6147460d65SJoel Becker 6247460d65SJoel Becker /* Flags for ocfs2_caching_info */ 6347460d65SJoel Becker 6447460d65SJoel Becker enum ocfs2_caching_info_flags { 6547460d65SJoel Becker /* Indicates that the metadata cache is using the inline array */ 6647460d65SJoel Becker OCFS2_CACHE_FL_INLINE = 1<<1, 6747460d65SJoel Becker }; 68ccd979bdSMark Fasheh 696e5a3d75SJoel Becker struct ocfs2_caching_operations; 70ccd979bdSMark Fasheh struct ocfs2_caching_info { 7147460d65SJoel Becker /* 7247460d65SJoel Becker * The parent structure provides the locks, but because the 736e5a3d75SJoel Becker * parent structure can differ, it provides locking operations 746e5a3d75SJoel Becker * to struct ocfs2_caching_info. 7547460d65SJoel Becker */ 766e5a3d75SJoel Becker const struct ocfs2_caching_operations *ci_ops; 7747460d65SJoel Becker 78292dd27eSJoel Becker /* next two are protected by trans_inc_lock */ 79292dd27eSJoel Becker /* which transaction were we created on? Zero if none. */ 80292dd27eSJoel Becker unsigned long ci_created_trans; 8166fb345dSJoel Becker /* last transaction we were a part of. */ 8266fb345dSJoel Becker unsigned long ci_last_trans; 8366fb345dSJoel Becker 8466fb345dSJoel Becker /* Cache structures */ 8547460d65SJoel Becker unsigned int ci_flags; 86ccd979bdSMark Fasheh unsigned int ci_num_cached; 87ccd979bdSMark Fasheh union { 8847460d65SJoel Becker sector_t ci_array[OCFS2_CACHE_INFO_MAX_ARRAY]; 89ccd979bdSMark Fasheh struct rb_root ci_tree; 90ccd979bdSMark Fasheh } ci_cache; 91ccd979bdSMark Fasheh }; 920cf2f763SJoel Becker /* 930cf2f763SJoel Becker * Need this prototype here instead of in uptodate.h because journal.h 940cf2f763SJoel Becker * uses it. 950cf2f763SJoel Becker */ 960cf2f763SJoel Becker struct super_block *ocfs2_metadata_cache_get_super(struct ocfs2_caching_info *ci); 97ccd979bdSMark Fasheh 98ccd979bdSMark Fasheh /* this limits us to 256 nodes 99ccd979bdSMark Fasheh * if we need more, we can do a kmalloc for the map */ 100ccd979bdSMark Fasheh #define OCFS2_NODE_MAP_MAX_NODES 256 101ccd979bdSMark Fasheh struct ocfs2_node_map { 102ccd979bdSMark Fasheh u16 num_nodes; 103ccd979bdSMark Fasheh unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)]; 104ccd979bdSMark Fasheh }; 105ccd979bdSMark Fasheh 106ccd979bdSMark Fasheh enum ocfs2_ast_action { 107ccd979bdSMark Fasheh OCFS2_AST_INVALID = 0, 108ccd979bdSMark Fasheh OCFS2_AST_ATTACH, 109ccd979bdSMark Fasheh OCFS2_AST_CONVERT, 110ccd979bdSMark Fasheh OCFS2_AST_DOWNCONVERT, 111ccd979bdSMark Fasheh }; 112ccd979bdSMark Fasheh 113ccd979bdSMark Fasheh /* actions for an unlockast function to take. */ 114ccd979bdSMark Fasheh enum ocfs2_unlock_action { 115ccd979bdSMark Fasheh OCFS2_UNLOCK_INVALID = 0, 116ccd979bdSMark Fasheh OCFS2_UNLOCK_CANCEL_CONVERT, 117ccd979bdSMark Fasheh OCFS2_UNLOCK_DROP_LOCK, 118ccd979bdSMark Fasheh }; 119ccd979bdSMark Fasheh 120ccd979bdSMark Fasheh /* ocfs2_lock_res->l_flags flags. */ 1213b5da018SColy Li #define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized 122ccd979bdSMark Fasheh * the lvb */ 123ccd979bdSMark Fasheh #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in 124ccd979bdSMark Fasheh * dlm_lock */ 125ccd979bdSMark Fasheh #define OCFS2_LOCK_BLOCKED (0x00000004) /* blocked waiting to 126ccd979bdSMark Fasheh * downconvert*/ 127ccd979bdSMark Fasheh #define OCFS2_LOCK_LOCAL (0x00000008) /* newly created inode */ 128ccd979bdSMark Fasheh #define OCFS2_LOCK_NEEDS_REFRESH (0x00000010) 129ccd979bdSMark Fasheh #define OCFS2_LOCK_REFRESHING (0x00000020) 130ccd979bdSMark Fasheh #define OCFS2_LOCK_INITIALIZED (0x00000040) /* track initialization 131ccd979bdSMark Fasheh * for shutdown paths */ 132ccd979bdSMark Fasheh #define OCFS2_LOCK_FREEING (0x00000080) /* help dlmglue track 133ccd979bdSMark Fasheh * when to skip queueing 134ccd979bdSMark Fasheh * a lock because it's 135ccd979bdSMark Fasheh * about to be 136ccd979bdSMark Fasheh * dropped. */ 137ccd979bdSMark Fasheh #define OCFS2_LOCK_QUEUED (0x00000100) /* queued for downconvert */ 138cf8e06f1SMark Fasheh #define OCFS2_LOCK_NOCACHE (0x00000200) /* don't use a holder count */ 139de551246SJoel Becker #define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a 140de551246SJoel Becker call to dlm_lock. Only 141de551246SJoel Becker exists with BUSY set. */ 142a1912826SSunil Mushran #define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread 143a1912826SSunil Mushran * from downconverting 144a1912826SSunil Mushran * before the upconvert 145a1912826SSunil Mushran * has completed */ 146ccd979bdSMark Fasheh 147d1e78238SXue jiufei #define OCFS2_LOCK_NONBLOCK_FINISHED (0x00001000) /* NONBLOCK cluster 148d1e78238SXue jiufei * lock has already 149d1e78238SXue jiufei * returned, do not block 150d1e78238SXue jiufei * dc thread from 151d1e78238SXue jiufei * downconverting */ 152d1e78238SXue jiufei 153ccd979bdSMark Fasheh struct ocfs2_lock_res_ops; 154ccd979bdSMark Fasheh 155ccd979bdSMark Fasheh typedef void (*ocfs2_lock_callback)(int status, unsigned long data); 156ccd979bdSMark Fasheh 1575bc970e8SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 1585bc970e8SSunil Mushran struct ocfs2_lock_stats { 1595bc970e8SSunil Mushran u64 ls_total; /* Total wait in NSEC */ 1605bc970e8SSunil Mushran u32 ls_gets; /* Num acquires */ 1615bc970e8SSunil Mushran u32 ls_fail; /* Num failed acquires */ 1625bc970e8SSunil Mushran 1635bc970e8SSunil Mushran /* Storing max wait in usecs saves 24 bytes per inode */ 1645bc970e8SSunil Mushran u32 ls_max; /* Max wait in USEC */ 1655bc970e8SSunil Mushran }; 1665bc970e8SSunil Mushran #endif 1675bc970e8SSunil Mushran 168ccd979bdSMark Fasheh struct ocfs2_lock_res { 169ccd979bdSMark Fasheh void *l_priv; 170ccd979bdSMark Fasheh struct ocfs2_lock_res_ops *l_ops; 17183fd9c7fSGoldwyn Rodrigues 172ccd979bdSMark Fasheh 173ccd979bdSMark Fasheh struct list_head l_blocked_list; 174ccd979bdSMark Fasheh struct list_head l_mask_waiters; 175ccd979bdSMark Fasheh 176ccd979bdSMark Fasheh unsigned long l_flags; 177ccd979bdSMark Fasheh char l_name[OCFS2_LOCK_ID_MAX_LEN]; 178ccd979bdSMark Fasheh unsigned int l_ro_holders; 179ccd979bdSMark Fasheh unsigned int l_ex_holders; 180a2a2f552SMilton Miller signed char l_level; 181a2a2f552SMilton Miller signed char l_requested; 182a2a2f552SMilton Miller signed char l_blocking; 18383fd9c7fSGoldwyn Rodrigues 18483fd9c7fSGoldwyn Rodrigues /* Data packed - type enum ocfs2_lock_type */ 18583fd9c7fSGoldwyn Rodrigues unsigned char l_type; 186ccd979bdSMark Fasheh 187ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 18883fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_ast_action */ 18983fd9c7fSGoldwyn Rodrigues unsigned char l_action; 19083fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_unlock_action */ 19183fd9c7fSGoldwyn Rodrigues unsigned char l_unlock_action; 192de551246SJoel Becker unsigned int l_pending_gen; 193ccd979bdSMark Fasheh 19483fd9c7fSGoldwyn Rodrigues spinlock_t l_lock; 19583fd9c7fSGoldwyn Rodrigues 19683fd9c7fSGoldwyn Rodrigues struct ocfs2_dlm_lksb l_lksb; 19783fd9c7fSGoldwyn Rodrigues 198ccd979bdSMark Fasheh wait_queue_head_t l_event; 199ccd979bdSMark Fasheh 200ccd979bdSMark Fasheh struct list_head l_debug_list; 2018ddb7b00SSunil Mushran 2028ddb7b00SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 2035bc970e8SSunil Mushran struct ocfs2_lock_stats l_lock_prmode; /* PR mode stats */ 2045bc970e8SSunil Mushran u32 l_lock_refresh; /* Disk refreshes */ 2055bc970e8SSunil Mushran struct ocfs2_lock_stats l_lock_exmode; /* EX mode stats */ 2068ddb7b00SSunil Mushran #endif 207cb25797dSJan Kara #ifdef CONFIG_DEBUG_LOCK_ALLOC 208cb25797dSJan Kara struct lockdep_map l_lockdep_map; 209cb25797dSJan Kara #endif 210ccd979bdSMark Fasheh }; 211ccd979bdSMark Fasheh 212ed460cffSJoseph Qi enum ocfs2_orphan_reco_type { 213ed460cffSJoseph Qi ORPHAN_NO_NEED_TRUNCATE = 0, 214ed460cffSJoseph Qi ORPHAN_NEED_TRUNCATE, 215ed460cffSJoseph Qi }; 216ed460cffSJoseph Qi 217692684e1SSunil Mushran enum ocfs2_orphan_scan_state { 218692684e1SSunil Mushran ORPHAN_SCAN_ACTIVE, 219692684e1SSunil Mushran ORPHAN_SCAN_INACTIVE 220692684e1SSunil Mushran }; 221692684e1SSunil Mushran 22283273932SSrinivas Eeda struct ocfs2_orphan_scan { 22383273932SSrinivas Eeda struct mutex os_lock; 22483273932SSrinivas Eeda struct ocfs2_super *os_osb; 22583273932SSrinivas Eeda struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */ 22683273932SSrinivas Eeda struct delayed_work os_orphan_scan_work; 22715633a22SSrinivas Eeda struct timespec os_scantime; /* time this node ran the scan */ 22815633a22SSrinivas Eeda u32 os_count; /* tracks node specific scans */ 22915633a22SSrinivas Eeda u32 os_seqno; /* tracks cluster wide scans */ 230692684e1SSunil Mushran atomic_t os_state; /* ACTIVE or INACTIVE */ 23183273932SSrinivas Eeda }; 23283273932SSrinivas Eeda 233ccd979bdSMark Fasheh struct ocfs2_dlm_debug { 234ccd979bdSMark Fasheh struct kref d_refcnt; 235ccd979bdSMark Fasheh struct dentry *d_locking_state; 236ccd979bdSMark Fasheh struct list_head d_lockres_tracking; 237ccd979bdSMark Fasheh }; 238ccd979bdSMark Fasheh 239ccd979bdSMark Fasheh enum ocfs2_vol_state 240ccd979bdSMark Fasheh { 241ccd979bdSMark Fasheh VOLUME_INIT = 0, 242ccd979bdSMark Fasheh VOLUME_MOUNTED, 24319ece546SJan Kara VOLUME_MOUNTED_QUOTAS, 244ccd979bdSMark Fasheh VOLUME_DISMOUNTED, 245ccd979bdSMark Fasheh VOLUME_DISABLED 246ccd979bdSMark Fasheh }; 247ccd979bdSMark Fasheh 248ccd979bdSMark Fasheh struct ocfs2_alloc_stats 249ccd979bdSMark Fasheh { 250ccd979bdSMark Fasheh atomic_t moves; 251ccd979bdSMark Fasheh atomic_t local_data; 252ccd979bdSMark Fasheh atomic_t bitmap_data; 253ccd979bdSMark Fasheh atomic_t bg_allocs; 254ccd979bdSMark Fasheh atomic_t bg_extends; 255ccd979bdSMark Fasheh }; 256ccd979bdSMark Fasheh 257ccd979bdSMark Fasheh enum ocfs2_local_alloc_state 258ccd979bdSMark Fasheh { 2599c7af40bSMark Fasheh OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for 2609c7af40bSMark Fasheh * this mountpoint. */ 2619c7af40bSMark Fasheh OCFS2_LA_ENABLED, /* Local alloc is in use. */ 2629c7af40bSMark Fasheh OCFS2_LA_THROTTLED, /* Local alloc is in use, but number 2639c7af40bSMark Fasheh * of bits has been reduced. */ 2649c7af40bSMark Fasheh OCFS2_LA_DISABLED /* Local alloc has temporarily been 2659c7af40bSMark Fasheh * disabled. */ 266ccd979bdSMark Fasheh }; 267ccd979bdSMark Fasheh 268ccd979bdSMark Fasheh enum ocfs2_mount_options 269ccd979bdSMark Fasheh { 2702c442719SSunil Mushran OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */ 271ccd979bdSMark Fasheh OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 272ccd979bdSMark Fasheh OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 273ccd979bdSMark Fasheh OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 274ccd979bdSMark Fasheh OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 27553fc622bSMark Fasheh OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */ 276cf1d6c76STiger Yang OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */ 27712462f1dSJoel Becker OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */ 2785297aad8SJan Kara OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */ 2795297aad8SJan Kara OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access 2805297aad8SJan Kara control lists */ 2815297aad8SJan Kara OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */ 2825297aad8SJan Kara OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */ 283fc371891SJoel Becker OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT 2847bdb0d18STristan Ye writes */ 285fc371891SJoel Becker OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */ 286fc371891SJoel Becker OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */ 2871dfeb768Salex chen 2881dfeb768Salex chen OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT = 1 << 15, /* Journal Async Commit */ 289ccd979bdSMark Fasheh }; 290ccd979bdSMark Fasheh 291ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 292ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 293ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 2947f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 295ccd979bdSMark Fasheh 296ccd979bdSMark Fasheh struct ocfs2_journal; 297d85b20e4SJoel Becker struct ocfs2_slot_info; 298553abd04SJoel Becker struct ocfs2_recovery_map; 2999140db04SSrinivas Eeda struct ocfs2_replay_map; 3002205363dSJan Kara struct ocfs2_quota_recovery; 301ccd979bdSMark Fasheh struct ocfs2_super 302ccd979bdSMark Fasheh { 303ccd979bdSMark Fasheh struct task_struct *commit_task; 304ccd979bdSMark Fasheh struct super_block *sb; 305ccd979bdSMark Fasheh struct inode *root_inode; 306ccd979bdSMark Fasheh struct inode *sys_root_inode; 307b4d693fcSTao Ma struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES]; 308b4d693fcSTao Ma struct inode **local_system_inodes; 309ccd979bdSMark Fasheh 310ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 311ccd979bdSMark Fasheh 312539d8264SSunil Mushran u32 *slot_recovery_generations; 313539d8264SSunil Mushran 314ccd979bdSMark Fasheh spinlock_t node_map_lock; 315ccd979bdSMark Fasheh 316ccd979bdSMark Fasheh u64 root_blkno; 317ccd979bdSMark Fasheh u64 system_dir_blkno; 318ccd979bdSMark Fasheh u64 bitmap_blkno; 319ccd979bdSMark Fasheh u32 bitmap_cpg; 320ccd979bdSMark Fasheh u8 *uuid; 321ccd979bdSMark Fasheh char *uuid_str; 322cf1d6c76STiger Yang u32 uuid_hash; 323ccd979bdSMark Fasheh u8 *vol_label; 324ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 325ccd979bdSMark Fasheh u32 fs_generation; 326ccd979bdSMark Fasheh 327ccd979bdSMark Fasheh u32 s_feature_compat; 328ccd979bdSMark Fasheh u32 s_feature_incompat; 329ccd979bdSMark Fasheh u32 s_feature_ro_compat; 330ccd979bdSMark Fasheh 3314d0ddb2cSTao Ma /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 3324d0ddb2cSTao Ma * Could protect more on osb as it's very short lived. 3334d0ddb2cSTao Ma */ 334ccd979bdSMark Fasheh spinlock_t osb_lock; 335ccd979bdSMark Fasheh u32 s_next_generation; 336ccd979bdSMark Fasheh unsigned long osb_flags; 3374d0ddb2cSTao Ma s16 s_inode_steal_slot; 338b89c5428STiger Yang s16 s_meta_steal_slot; 3394d0ddb2cSTao Ma atomic_t s_num_inodes_stolen; 340b89c5428STiger Yang atomic_t s_num_meta_stolen; 341ccd979bdSMark Fasheh 342ccd979bdSMark Fasheh unsigned long s_mount_opt; 3437f1a37e3STiger Yang unsigned int s_atime_quantum; 344ccd979bdSMark Fasheh 345fc881fa0SJoel Becker unsigned int max_slots; 34619fdb624SJoel Becker unsigned int node_num; 347fc881fa0SJoel Becker int slot_num; 348fc881fa0SJoel Becker int preferred_slot; 349ccd979bdSMark Fasheh int s_sectsize_bits; 350ccd979bdSMark Fasheh int s_clustersize; 351ccd979bdSMark Fasheh int s_clustersize_bits; 352fdd77704STiger Yang unsigned int s_xattr_inline_size; 353ccd979bdSMark Fasheh 354ccd979bdSMark Fasheh atomic_t vol_state; 355c74ec2f7SArjan van de Ven struct mutex recovery_lock; 356553abd04SJoel Becker struct ocfs2_recovery_map *recovery_map; 3579140db04SSrinivas Eeda struct ocfs2_replay_map *replay_map; 358ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 359ccd979bdSMark Fasheh int disable_recovery; 360ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 361ccd979bdSMark Fasheh struct ocfs2_journal *journal; 362d147b3d6SMark Fasheh unsigned long osb_commit_interval; 363ccd979bdSMark Fasheh 3649c7af40bSMark Fasheh struct delayed_work la_enable_wq; 3659c7af40bSMark Fasheh 3669c7af40bSMark Fasheh /* 3679c7af40bSMark Fasheh * Must hold local alloc i_mutex and osb->osb_lock to change 3689c7af40bSMark Fasheh * local_alloc_bits. Reads can be done under either lock. 3699c7af40bSMark Fasheh */ 370ebcee4b5SMark Fasheh unsigned int local_alloc_bits; 3719c7af40bSMark Fasheh unsigned int local_alloc_default_bits; 3726b82021bSMark Fasheh /* osb_clusters_at_boot can become stale! Do not trust it to 3736b82021bSMark Fasheh * be up to date. */ 3746b82021bSMark Fasheh unsigned int osb_clusters_at_boot; 3759c7af40bSMark Fasheh 3769c7af40bSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; /* protected 3779c7af40bSMark Fasheh * by osb_lock */ 3789c7af40bSMark Fasheh 379ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 3809c7af40bSMark Fasheh 381883d4caeSMark Fasheh u64 la_last_gd; 382ccd979bdSMark Fasheh 383d02f00ccSMark Fasheh struct ocfs2_reservation_map osb_la_resmap; 384d02f00ccSMark Fasheh 385d02f00ccSMark Fasheh unsigned int osb_resv_level; 38683f92318SMark Fasheh unsigned int osb_dir_resv_level; 387d02f00ccSMark Fasheh 3882205363dSJan Kara /* Next three fields are for local node slot recovery during 389ccd979bdSMark Fasheh * mount. */ 390ccd979bdSMark Fasheh int dirty; 391ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 3922205363dSJan Kara struct ocfs2_quota_recovery *quota_rec; 393ccd979bdSMark Fasheh 39473be192bSJoel Becker struct ocfs2_blockcheck_stats osb_ecc_stats; 395ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 396ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 397ccd979bdSMark Fasheh 39898f486f2SSunil Mushran u8 osb_stackflags; 39998f486f2SSunil Mushran 400b61817e1SJoel Becker char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 401c74a3bddSGoldwyn Rodrigues char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1]; 4024670c46dSJoel Becker struct ocfs2_cluster_connection *cconn; 403ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 404ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 4056ca497a8Swengang wang struct ocfs2_lock_res osb_nfs_sync_lockres; 406ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 407ccd979bdSMark Fasheh 408ccd979bdSMark Fasheh struct dentry *osb_debug_root; 40950397507SSunil Mushran struct dentry *osb_ctxt; 410ccd979bdSMark Fasheh 411ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 412ccd979bdSMark Fasheh 41334d024f8SMark Fasheh spinlock_t dc_task_lock; 41434d024f8SMark Fasheh struct task_struct *dc_task; 41534d024f8SMark Fasheh wait_queue_head_t dc_event; 41634d024f8SMark Fasheh unsigned long dc_wake_sequence; 41734d024f8SMark Fasheh unsigned long dc_work_sequence; 418ccd979bdSMark Fasheh 4197ec373cfSMark Fasheh /* 4207ec373cfSMark Fasheh * Any thread can add locks to the list, but the downconvert 4217ec373cfSMark Fasheh * thread is the only one allowed to remove locks. Any change 4227ec373cfSMark Fasheh * to this rule requires updating 4237ec373cfSMark Fasheh * ocfs2_downconvert_thread_do_work(). 4247ec373cfSMark Fasheh */ 425ccd979bdSMark Fasheh struct list_head blocked_lock_list; 426ccd979bdSMark Fasheh unsigned long blocked_lock_count; 427ccd979bdSMark Fasheh 428e3a767b6SJan Kara /* List of dquot structures to drop last reference to */ 429e3a767b6SJan Kara struct llist_head dquot_drop_list; 430e3a767b6SJan Kara struct work_struct dquot_drop_work; 431e3a767b6SJan Kara 432ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 433ccd979bdSMark Fasheh 434ccd979bdSMark Fasheh /* Truncate log info */ 435ccd979bdSMark Fasheh struct inode *osb_tl_inode; 436ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 437c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 438a9e9acaeSXue jiufei atomic_t osb_tl_disable; 43950308d81STao Ma /* 44050308d81STao Ma * How many clusters in our truncate log. 44150308d81STao Ma * It must be protected by osb_tl_inode->i_mutex. 44250308d81STao Ma */ 44350308d81STao Ma unsigned int truncated_clusters; 444b4df6ed8SMark Fasheh 445b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 446b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 447b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 448c8b9cf9aSTao Ma 44983273932SSrinivas Eeda struct ocfs2_orphan_scan osb_orphan_scan; 45083273932SSrinivas Eeda 451c8b9cf9aSTao Ma /* used to protect metaecc calculation check of xattr. */ 452c8b9cf9aSTao Ma spinlock_t osb_xattr_lock; 4539b7895efSMark Fasheh 4549b7895efSMark Fasheh unsigned int osb_dx_mask; 4559b7895efSMark Fasheh u32 osb_dx_seed[4]; 456feb473a6STao Ma 457feb473a6STao Ma /* the group we used to allocate inodes. */ 458feb473a6STao Ma u64 osb_inode_alloc_group; 459374a263eSTao Ma 460374a263eSTao Ma /* rb tree root for refcount lock. */ 461374a263eSTao Ma struct rb_root osb_rf_lock_tree; 462374a263eSTao Ma struct ocfs2_refcount_tree *osb_ref_tree_lru; 46343b10a20Sjiangyiwen 46443b10a20Sjiangyiwen struct mutex system_file_mutex; 465ccd979bdSMark Fasheh }; 466ccd979bdSMark Fasheh 467ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 468ccd979bdSMark Fasheh 46913723d00SJoel Becker /* Useful typedef for passing around journal access functions */ 4700cf2f763SJoel Becker typedef int (*ocfs2_journal_access_func)(handle_t *handle, 4710cf2f763SJoel Becker struct ocfs2_caching_info *ci, 47213723d00SJoel Becker struct buffer_head *bh, int type); 47313723d00SJoel Becker 474ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 475ccd979bdSMark Fasheh { 476ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 477ccd979bdSMark Fasheh return 0; 478ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 479ccd979bdSMark Fasheh return 0; 480ccd979bdSMark Fasheh return 1; 481ccd979bdSMark Fasheh } 482ccd979bdSMark Fasheh 483dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 484dcd0538fSMark Fasheh { 485dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 486dcd0538fSMark Fasheh return 1; 487dcd0538fSMark Fasheh return 0; 488dcd0538fSMark Fasheh } 489dcd0538fSMark Fasheh 490328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 491328d5752SMark Fasheh { 492328d5752SMark Fasheh /* 493328d5752SMark Fasheh * Support for sparse files is a pre-requisite 494328d5752SMark Fasheh */ 495328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 496328d5752SMark Fasheh return 0; 497328d5752SMark Fasheh 498328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 499328d5752SMark Fasheh return 1; 500328d5752SMark Fasheh return 0; 501328d5752SMark Fasheh } 502328d5752SMark Fasheh 503160cc266SJoseph Qi static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb) 504160cc266SJoseph Qi { 505160cc266SJoseph Qi if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_APPEND_DIO) 506160cc266SJoseph Qi return 1; 507160cc266SJoseph Qi return 0; 508160cc266SJoseph Qi } 509160cc266SJoseph Qi 510160cc266SJoseph Qi 51115b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 51215b1e36bSMark Fasheh { 51315b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 51415b1e36bSMark Fasheh return 1; 51515b1e36bSMark Fasheh return 0; 51615b1e36bSMark Fasheh } 51715b1e36bSMark Fasheh 5188154da3dSTiger Yang static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 5198154da3dSTiger Yang { 5208154da3dSTiger Yang if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 5218154da3dSTiger Yang return 1; 5228154da3dSTiger Yang return 0; 5238154da3dSTiger Yang } 5248154da3dSTiger Yang 52570ad1ba7SJoel Becker static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 52670ad1ba7SJoel Becker { 52770ad1ba7SJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 52870ad1ba7SJoel Becker return 1; 52970ad1ba7SJoel Becker return 0; 53070ad1ba7SJoel Becker } 53170ad1ba7SJoel Becker 5329b7895efSMark Fasheh static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 5339b7895efSMark Fasheh { 5349b7895efSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 5359b7895efSMark Fasheh return 1; 5369b7895efSMark Fasheh return 0; 5379b7895efSMark Fasheh } 5389b7895efSMark Fasheh 5394711954eSTao Ma static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 540798db35fSJoel Becker { 541798db35fSJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 542798db35fSJoel Becker return 1; 543798db35fSJoel Becker return 0; 544798db35fSJoel Becker } 545798db35fSJoel Becker 546198a1ca3SMark Fasheh static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 547198a1ca3SMark Fasheh { 548198a1ca3SMark Fasheh if (ocfs2_supports_indexed_dirs(osb)) 549198a1ca3SMark Fasheh return OCFS2_DX_LINK_MAX; 550198a1ca3SMark Fasheh return OCFS2_LINK_MAX; 551198a1ca3SMark Fasheh } 552198a1ca3SMark Fasheh 553198a1ca3SMark Fasheh static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 554198a1ca3SMark Fasheh { 555198a1ca3SMark Fasheh u32 nlink = le16_to_cpu(di->i_links_count); 556198a1ca3SMark Fasheh u32 hi = le16_to_cpu(di->i_links_count_hi); 557198a1ca3SMark Fasheh 558198a1ca3SMark Fasheh if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 559198a1ca3SMark Fasheh nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 560198a1ca3SMark Fasheh 561198a1ca3SMark Fasheh return nlink; 562198a1ca3SMark Fasheh } 563198a1ca3SMark Fasheh 564198a1ca3SMark Fasheh static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 565198a1ca3SMark Fasheh { 566198a1ca3SMark Fasheh u16 lo, hi; 567198a1ca3SMark Fasheh 568198a1ca3SMark Fasheh lo = nlink; 569198a1ca3SMark Fasheh hi = nlink >> OCFS2_LINKS_HI_SHIFT; 570198a1ca3SMark Fasheh 571198a1ca3SMark Fasheh di->i_links_count = cpu_to_le16(lo); 572198a1ca3SMark Fasheh di->i_links_count_hi = cpu_to_le16(hi); 573198a1ca3SMark Fasheh } 574198a1ca3SMark Fasheh 575198a1ca3SMark Fasheh static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 576198a1ca3SMark Fasheh { 577198a1ca3SMark Fasheh u32 links = ocfs2_read_links_count(di); 578198a1ca3SMark Fasheh 579198a1ca3SMark Fasheh links += n; 580198a1ca3SMark Fasheh 581198a1ca3SMark Fasheh ocfs2_set_links_count(di, links); 582198a1ca3SMark Fasheh } 583198a1ca3SMark Fasheh 5841aa75feaSTao Ma static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 5851aa75feaSTao Ma { 5861aa75feaSTao Ma if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 5871aa75feaSTao Ma return 1; 5881aa75feaSTao Ma return 0; 5891aa75feaSTao Ma } 5901aa75feaSTao Ma 591ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 592ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 593ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 594ccd979bdSMark Fasheh * too! */ 595ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 596ccd979bdSMark Fasheh unsigned long flag) 597ccd979bdSMark Fasheh { 598ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 599ccd979bdSMark Fasheh osb->osb_flags |= flag; 600ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 601ccd979bdSMark Fasheh } 602ccd979bdSMark Fasheh 603ccd979bdSMark Fasheh static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 604ccd979bdSMark Fasheh int hard) 605ccd979bdSMark Fasheh { 606ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 607ccd979bdSMark Fasheh osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 608ccd979bdSMark Fasheh if (hard) 609ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_HARD_RO; 610ccd979bdSMark Fasheh else 611ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_SOFT_RO; 612ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 613ccd979bdSMark Fasheh } 614ccd979bdSMark Fasheh 615ccd979bdSMark Fasheh static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 616ccd979bdSMark Fasheh { 617ccd979bdSMark Fasheh int ret; 618ccd979bdSMark Fasheh 619ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 620ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 621ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 622ccd979bdSMark Fasheh 623ccd979bdSMark Fasheh return ret; 624ccd979bdSMark Fasheh } 625ccd979bdSMark Fasheh 626ccd979bdSMark Fasheh static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 627ccd979bdSMark Fasheh { 628ccd979bdSMark Fasheh int ret; 629ccd979bdSMark Fasheh 630ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 631ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 632ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 633ccd979bdSMark Fasheh 634ccd979bdSMark Fasheh return ret; 635ccd979bdSMark Fasheh } 636ccd979bdSMark Fasheh 63798f486f2SSunil Mushran static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb) 638b61817e1SJoel Becker { 639b61817e1SJoel Becker return (osb->s_feature_incompat & 64098f486f2SSunil Mushran (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK | 64198f486f2SSunil Mushran OCFS2_FEATURE_INCOMPAT_CLUSTERINFO)); 64298f486f2SSunil Mushran } 64398f486f2SSunil Mushran 64498f486f2SSunil Mushran static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 64598f486f2SSunil Mushran { 64698f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 64798f486f2SSunil Mushran memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 64898f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 64998f486f2SSunil Mushran return 1; 65098f486f2SSunil Mushran return 0; 65198f486f2SSunil Mushran } 65298f486f2SSunil Mushran 65398f486f2SSunil Mushran static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb) 65498f486f2SSunil Mushran { 65598f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 65698f486f2SSunil Mushran !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 65798f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 65898f486f2SSunil Mushran return 1; 65998f486f2SSunil Mushran return 0; 66098f486f2SSunil Mushran } 66198f486f2SSunil Mushran 66298f486f2SSunil Mushran static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb) 66398f486f2SSunil Mushran { 66498f486f2SSunil Mushran return ocfs2_o2cb_stack(osb) && 66598f486f2SSunil Mushran (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT); 666b61817e1SJoel Becker } 667b61817e1SJoel Becker 668c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 669c271c5c2SSunil Mushran { 670c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 671c271c5c2SSunil Mushran } 672c271c5c2SSunil Mushran 673386a2ef8SJoel Becker static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 674386a2ef8SJoel Becker { 675386a2ef8SJoel Becker return (osb->s_feature_incompat & 676386a2ef8SJoel Becker OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 677386a2ef8SJoel Becker } 678386a2ef8SJoel Becker 679386a2ef8SJoel Becker 680ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 681ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 682ccd979bdSMark Fasheh 683ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 684ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 685ccd979bdSMark Fasheh 686ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 687ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 688ccd979bdSMark Fasheh 689ccd979bdSMark Fasheh 690f6087fb7SJoel Becker #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 691f6087fb7SJoel Becker (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 692f6087fb7SJoel Becker 69387d35a74SMark Fasheh #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 69487d35a74SMark Fasheh (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 69587d35a74SMark Fasheh 6969b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 6979b7895efSMark Fasheh (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 6989b7895efSMark Fasheh 6999b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 7009b7895efSMark Fasheh (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 7019b7895efSMark Fasheh 702f2c870e3STao Ma #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 703f2c870e3STao Ma (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 704f2c870e3STao Ma 705ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 706ccd979bdSMark Fasheh u64 blkno) 707ccd979bdSMark Fasheh { 708ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 709ccd979bdSMark Fasheh } 710ccd979bdSMark Fasheh 711ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 712ccd979bdSMark Fasheh u32 clusters) 713ccd979bdSMark Fasheh { 714ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 715ccd979bdSMark Fasheh sb->s_blocksize_bits; 716ccd979bdSMark Fasheh 717ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 718ccd979bdSMark Fasheh } 719ccd979bdSMark Fasheh 720ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 721ccd979bdSMark Fasheh u64 blocks) 722ccd979bdSMark Fasheh { 723ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 724ccd979bdSMark Fasheh sb->s_blocksize_bits; 725ccd979bdSMark Fasheh 726ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 727ccd979bdSMark Fasheh } 728ccd979bdSMark Fasheh 729ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 730ccd979bdSMark Fasheh u64 bytes) 731ccd979bdSMark Fasheh { 732ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 733ccd979bdSMark Fasheh unsigned int clusters; 734ccd979bdSMark Fasheh 735ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 736ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 737ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 738ccd979bdSMark Fasheh 739ccd979bdSMark Fasheh return clusters; 740ccd979bdSMark Fasheh } 741ccd979bdSMark Fasheh 74224c40b32SJoseph Qi static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb, 74324c40b32SJoseph Qi u64 bytes) 74424c40b32SJoseph Qi { 74524c40b32SJoseph Qi int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 74624c40b32SJoseph Qi unsigned int clusters; 74724c40b32SJoseph Qi 74824c40b32SJoseph Qi clusters = (unsigned int)(bytes >> cl_bits); 74924c40b32SJoseph Qi return clusters; 75024c40b32SJoseph Qi } 75124c40b32SJoseph Qi 752ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 753ccd979bdSMark Fasheh u64 bytes) 754ccd979bdSMark Fasheh { 755ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 756ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 757ccd979bdSMark Fasheh } 758ccd979bdSMark Fasheh 759ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 760ccd979bdSMark Fasheh u32 clusters) 761ccd979bdSMark Fasheh { 762ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 763ccd979bdSMark Fasheh } 764ccd979bdSMark Fasheh 7651d46dc08SMark Fasheh static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 7661d46dc08SMark Fasheh u64 blocks) 7671d46dc08SMark Fasheh { 7681d46dc08SMark Fasheh int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 7691d46dc08SMark Fasheh unsigned int clusters; 7701d46dc08SMark Fasheh 7711d46dc08SMark Fasheh clusters = ocfs2_blocks_to_clusters(sb, blocks); 7721d46dc08SMark Fasheh return (u64)clusters << bits; 7731d46dc08SMark Fasheh } 7741d46dc08SMark Fasheh 775ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 776ccd979bdSMark Fasheh u64 bytes) 777ccd979bdSMark Fasheh { 778ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 779ccd979bdSMark Fasheh unsigned int clusters; 780ccd979bdSMark Fasheh 781ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 782ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 783ccd979bdSMark Fasheh } 784ccd979bdSMark Fasheh 785ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 786ccd979bdSMark Fasheh u64 bytes) 787ccd979bdSMark Fasheh { 788ccd979bdSMark Fasheh u64 blocks; 789ccd979bdSMark Fasheh 790ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 791ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 792ccd979bdSMark Fasheh } 793ccd979bdSMark Fasheh 794ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 795ccd979bdSMark Fasheh { 796ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 797ccd979bdSMark Fasheh } 798ccd979bdSMark Fasheh 7999517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 8009517bac6SMark Fasheh unsigned long pg_index) 8019517bac6SMark Fasheh { 8029517bac6SMark Fasheh u32 clusters = pg_index; 8039517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 8049517bac6SMark Fasheh 8059517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 8069517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 8079517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 8089517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 8099517bac6SMark Fasheh 8109517bac6SMark Fasheh return clusters; 8119517bac6SMark Fasheh } 8129517bac6SMark Fasheh 8139517bac6SMark Fasheh /* 8149517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 8159517bac6SMark Fasheh */ 8167c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 8179517bac6SMark Fasheh u32 clusters) 8189517bac6SMark Fasheh { 8199517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 8207c08d70cSMark Fasheh pgoff_t index = clusters; 8219517bac6SMark Fasheh 8229517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 8237c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 8249517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 8257c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 8269517bac6SMark Fasheh } 8279517bac6SMark Fasheh 8289517bac6SMark Fasheh return index; 8299517bac6SMark Fasheh } 8309517bac6SMark Fasheh 83160b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 83260b11392SMark Fasheh { 83360b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 83460b11392SMark Fasheh unsigned int pages_per_cluster = 1; 83560b11392SMark Fasheh 83660b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 83760b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 83860b11392SMark Fasheh 83960b11392SMark Fasheh return pages_per_cluster; 84060b11392SMark Fasheh } 84160b11392SMark Fasheh 842ebcee4b5SMark Fasheh static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 843ebcee4b5SMark Fasheh unsigned int megs) 844ebcee4b5SMark Fasheh { 845ebcee4b5SMark Fasheh BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 846ebcee4b5SMark Fasheh 847ebcee4b5SMark Fasheh return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 848ebcee4b5SMark Fasheh } 849ebcee4b5SMark Fasheh 85073c8a800SMark Fasheh static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 85173c8a800SMark Fasheh unsigned int clusters) 85273c8a800SMark Fasheh { 85373c8a800SMark Fasheh return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 85473c8a800SMark Fasheh } 85573c8a800SMark Fasheh 856b4414eeaSMark Fasheh static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 857b4414eeaSMark Fasheh { 858730e663bSAkinobu Mita __set_bit_le(bit, bitmap); 859b4414eeaSMark Fasheh } 860b4414eeaSMark Fasheh #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 861b4414eeaSMark Fasheh 862b4414eeaSMark Fasheh static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 863b4414eeaSMark Fasheh { 864730e663bSAkinobu Mita __clear_bit_le(bit, bitmap); 865b4414eeaSMark Fasheh } 866b4414eeaSMark Fasheh #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 867b4414eeaSMark Fasheh 868c4354d0dSAkinobu Mita #define ocfs2_test_bit test_bit_le 869c4354d0dSAkinobu Mita #define ocfs2_find_next_zero_bit find_next_zero_bit_le 870c4354d0dSAkinobu Mita #define ocfs2_find_next_bit find_next_bit_le 87193925579SAkinobu Mita 87293925579SAkinobu Mita static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr) 87393925579SAkinobu Mita { 87493925579SAkinobu Mita #if BITS_PER_LONG == 64 87593925579SAkinobu Mita *bit += ((unsigned long) addr & 7UL) << 3; 87693925579SAkinobu Mita addr = (void *) ((unsigned long) addr & ~7UL); 87793925579SAkinobu Mita #elif BITS_PER_LONG == 32 87893925579SAkinobu Mita *bit += ((unsigned long) addr & 3UL) << 3; 87993925579SAkinobu Mita addr = (void *) ((unsigned long) addr & ~3UL); 88093925579SAkinobu Mita #else 88193925579SAkinobu Mita #error "how many bits you are?!" 88293925579SAkinobu Mita #endif 88393925579SAkinobu Mita return addr; 88493925579SAkinobu Mita } 88593925579SAkinobu Mita 88693925579SAkinobu Mita static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap) 88793925579SAkinobu Mita { 88893925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 88993925579SAkinobu Mita ocfs2_set_bit(bit, bitmap); 89093925579SAkinobu Mita } 89193925579SAkinobu Mita 89293925579SAkinobu Mita static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap) 89393925579SAkinobu Mita { 89493925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 89593925579SAkinobu Mita ocfs2_clear_bit(bit, bitmap); 89693925579SAkinobu Mita } 89793925579SAkinobu Mita 89893925579SAkinobu Mita static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap) 89993925579SAkinobu Mita { 90093925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 90193925579SAkinobu Mita return ocfs2_test_bit(bit, bitmap); 90293925579SAkinobu Mita } 90393925579SAkinobu Mita 90493925579SAkinobu Mita static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max, 90593925579SAkinobu Mita int start) 90693925579SAkinobu Mita { 90793925579SAkinobu Mita int fix = 0, ret, tmpmax; 90893925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&fix, bitmap); 90993925579SAkinobu Mita tmpmax = max + fix; 91093925579SAkinobu Mita start += fix; 91193925579SAkinobu Mita 91293925579SAkinobu Mita ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix; 91393925579SAkinobu Mita if (ret > max) 91493925579SAkinobu Mita return max; 91593925579SAkinobu Mita return ret; 91693925579SAkinobu Mita } 91793925579SAkinobu Mita 918ccd979bdSMark Fasheh #endif /* OCFS2_H */ 919ccd979bdSMark Fasheh 920