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; 16283fd9c7fSGoldwyn Rodrigues unsigned char l_level; 16383fd9c7fSGoldwyn Rodrigues 16483fd9c7fSGoldwyn Rodrigues /* Data packed - type enum ocfs2_lock_type */ 16583fd9c7fSGoldwyn Rodrigues unsigned char l_type; 166ccd979bdSMark Fasheh 167ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 16883fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_ast_action */ 16983fd9c7fSGoldwyn Rodrigues unsigned char l_action; 17083fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_unlock_action */ 17183fd9c7fSGoldwyn Rodrigues unsigned char l_unlock_action; 17283fd9c7fSGoldwyn Rodrigues unsigned char l_requested; 17383fd9c7fSGoldwyn Rodrigues unsigned char l_blocking; 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 { 253ccd979bdSMark Fasheh OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Heartbeat started in local mode */ 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 */ 2667bdb0d18STristan Ye 2677bdb0d18STristan Ye OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12 /* Allow concurrent O_DIRECT 2687bdb0d18STristan Ye writes */ 269ccd979bdSMark Fasheh }; 270ccd979bdSMark Fasheh 271ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 272ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 273ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 274f7b1aa69SJan Kara #define OCFS2_OSB_DROP_DENTRY_LOCK_IMMED 0x0008 275f7b1aa69SJan Kara 2767f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 277ccd979bdSMark Fasheh 278ccd979bdSMark Fasheh struct ocfs2_journal; 279d85b20e4SJoel Becker struct ocfs2_slot_info; 280553abd04SJoel Becker struct ocfs2_recovery_map; 2819140db04SSrinivas Eeda struct ocfs2_replay_map; 2822205363dSJan Kara struct ocfs2_quota_recovery; 283ea455f8aSJan Kara struct ocfs2_dentry_lock; 284ccd979bdSMark Fasheh struct ocfs2_super 285ccd979bdSMark Fasheh { 286ccd979bdSMark Fasheh struct task_struct *commit_task; 287ccd979bdSMark Fasheh struct super_block *sb; 288ccd979bdSMark Fasheh struct inode *root_inode; 289ccd979bdSMark Fasheh struct inode *sys_root_inode; 290b4d693fcSTao Ma struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES]; 291b4d693fcSTao Ma struct inode **local_system_inodes; 292ccd979bdSMark Fasheh 293ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 294ccd979bdSMark Fasheh 295539d8264SSunil Mushran u32 *slot_recovery_generations; 296539d8264SSunil Mushran 297ccd979bdSMark Fasheh spinlock_t node_map_lock; 298ccd979bdSMark Fasheh 299ccd979bdSMark Fasheh u64 root_blkno; 300ccd979bdSMark Fasheh u64 system_dir_blkno; 301ccd979bdSMark Fasheh u64 bitmap_blkno; 302ccd979bdSMark Fasheh u32 bitmap_cpg; 303ccd979bdSMark Fasheh u8 *uuid; 304ccd979bdSMark Fasheh char *uuid_str; 305cf1d6c76STiger Yang u32 uuid_hash; 306ccd979bdSMark Fasheh u8 *vol_label; 307ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 308ccd979bdSMark Fasheh u32 fs_generation; 309ccd979bdSMark Fasheh 310ccd979bdSMark Fasheh u32 s_feature_compat; 311ccd979bdSMark Fasheh u32 s_feature_incompat; 312ccd979bdSMark Fasheh u32 s_feature_ro_compat; 313ccd979bdSMark Fasheh 3144d0ddb2cSTao Ma /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 3154d0ddb2cSTao Ma * Could protect more on osb as it's very short lived. 3164d0ddb2cSTao Ma */ 317ccd979bdSMark Fasheh spinlock_t osb_lock; 318ccd979bdSMark Fasheh u32 s_next_generation; 319ccd979bdSMark Fasheh unsigned long osb_flags; 3204d0ddb2cSTao Ma s16 s_inode_steal_slot; 321b89c5428STiger Yang s16 s_meta_steal_slot; 3224d0ddb2cSTao Ma atomic_t s_num_inodes_stolen; 323b89c5428STiger Yang atomic_t s_num_meta_stolen; 324ccd979bdSMark Fasheh 325ccd979bdSMark Fasheh unsigned long s_mount_opt; 3267f1a37e3STiger Yang unsigned int s_atime_quantum; 327ccd979bdSMark Fasheh 328fc881fa0SJoel Becker unsigned int max_slots; 32919fdb624SJoel Becker unsigned int node_num; 330fc881fa0SJoel Becker int slot_num; 331fc881fa0SJoel Becker int preferred_slot; 332ccd979bdSMark Fasheh int s_sectsize_bits; 333ccd979bdSMark Fasheh int s_clustersize; 334ccd979bdSMark Fasheh int s_clustersize_bits; 335fdd77704STiger Yang unsigned int s_xattr_inline_size; 336ccd979bdSMark Fasheh 337ccd979bdSMark Fasheh atomic_t vol_state; 338c74ec2f7SArjan van de Ven struct mutex recovery_lock; 339553abd04SJoel Becker struct ocfs2_recovery_map *recovery_map; 3409140db04SSrinivas Eeda struct ocfs2_replay_map *replay_map; 341ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 342ccd979bdSMark Fasheh int disable_recovery; 343ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 344ccd979bdSMark Fasheh atomic_t needs_checkpoint; 345ccd979bdSMark Fasheh struct ocfs2_journal *journal; 346d147b3d6SMark Fasheh unsigned long osb_commit_interval; 347ccd979bdSMark Fasheh 3489c7af40bSMark Fasheh struct delayed_work la_enable_wq; 3499c7af40bSMark Fasheh 3509c7af40bSMark Fasheh /* 3519c7af40bSMark Fasheh * Must hold local alloc i_mutex and osb->osb_lock to change 3529c7af40bSMark Fasheh * local_alloc_bits. Reads can be done under either lock. 3539c7af40bSMark Fasheh */ 354ebcee4b5SMark Fasheh unsigned int local_alloc_bits; 3559c7af40bSMark Fasheh unsigned int local_alloc_default_bits; 3566b82021bSMark Fasheh /* osb_clusters_at_boot can become stale! Do not trust it to 3576b82021bSMark Fasheh * be up to date. */ 3586b82021bSMark Fasheh unsigned int osb_clusters_at_boot; 3599c7af40bSMark Fasheh 3609c7af40bSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; /* protected 3619c7af40bSMark Fasheh * by osb_lock */ 3629c7af40bSMark Fasheh 363ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 3649c7af40bSMark Fasheh 365883d4caeSMark Fasheh u64 la_last_gd; 366ccd979bdSMark Fasheh 367d02f00ccSMark Fasheh struct ocfs2_reservation_map osb_la_resmap; 368d02f00ccSMark Fasheh 369d02f00ccSMark Fasheh unsigned int osb_resv_level; 37083f92318SMark Fasheh unsigned int osb_dir_resv_level; 371d02f00ccSMark Fasheh 3722205363dSJan Kara /* Next three fields are for local node slot recovery during 373ccd979bdSMark Fasheh * mount. */ 374ccd979bdSMark Fasheh int dirty; 375ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 3762205363dSJan Kara struct ocfs2_quota_recovery *quota_rec; 377ccd979bdSMark Fasheh 37873be192bSJoel Becker struct ocfs2_blockcheck_stats osb_ecc_stats; 379ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 380ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 381ccd979bdSMark Fasheh 382b61817e1SJoel Becker char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 3834670c46dSJoel Becker struct ocfs2_cluster_connection *cconn; 384ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 385ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 3866ca497a8Swengang wang struct ocfs2_lock_res osb_nfs_sync_lockres; 387ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 388ccd979bdSMark Fasheh 389ccd979bdSMark Fasheh struct dentry *osb_debug_root; 39050397507SSunil Mushran struct dentry *osb_ctxt; 391ccd979bdSMark Fasheh 392ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 393ccd979bdSMark Fasheh 39434d024f8SMark Fasheh spinlock_t dc_task_lock; 39534d024f8SMark Fasheh struct task_struct *dc_task; 39634d024f8SMark Fasheh wait_queue_head_t dc_event; 39734d024f8SMark Fasheh unsigned long dc_wake_sequence; 39834d024f8SMark Fasheh unsigned long dc_work_sequence; 399ccd979bdSMark Fasheh 4007ec373cfSMark Fasheh /* 4017ec373cfSMark Fasheh * Any thread can add locks to the list, but the downconvert 4027ec373cfSMark Fasheh * thread is the only one allowed to remove locks. Any change 4037ec373cfSMark Fasheh * to this rule requires updating 4047ec373cfSMark Fasheh * ocfs2_downconvert_thread_do_work(). 4057ec373cfSMark Fasheh */ 406ccd979bdSMark Fasheh struct list_head blocked_lock_list; 407ccd979bdSMark Fasheh unsigned long blocked_lock_count; 408ccd979bdSMark Fasheh 409ea455f8aSJan Kara /* List of dentry locks to release. Anyone can add locks to 410ea455f8aSJan Kara * the list, ocfs2_wq processes the list */ 411ea455f8aSJan Kara struct ocfs2_dentry_lock *dentry_lock_list; 412ea455f8aSJan Kara struct work_struct dentry_lock_work; 413ea455f8aSJan Kara 414ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 415ccd979bdSMark Fasheh 416ccd979bdSMark Fasheh /* Truncate log info */ 417ccd979bdSMark Fasheh struct inode *osb_tl_inode; 418ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 419c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 420b4df6ed8SMark Fasheh 421b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 422b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 423b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 424c8b9cf9aSTao Ma 42583273932SSrinivas Eeda struct ocfs2_orphan_scan osb_orphan_scan; 42683273932SSrinivas Eeda 427c8b9cf9aSTao Ma /* used to protect metaecc calculation check of xattr. */ 428c8b9cf9aSTao Ma spinlock_t osb_xattr_lock; 4299b7895efSMark Fasheh 4309b7895efSMark Fasheh unsigned int osb_dx_mask; 4319b7895efSMark Fasheh u32 osb_dx_seed[4]; 432feb473a6STao Ma 433feb473a6STao Ma /* the group we used to allocate inodes. */ 434feb473a6STao Ma u64 osb_inode_alloc_group; 435374a263eSTao Ma 436374a263eSTao Ma /* rb tree root for refcount lock. */ 437374a263eSTao Ma struct rb_root osb_rf_lock_tree; 438374a263eSTao Ma struct ocfs2_refcount_tree *osb_ref_tree_lru; 439ccd979bdSMark Fasheh }; 440ccd979bdSMark Fasheh 441ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 442ccd979bdSMark Fasheh 44313723d00SJoel Becker /* Useful typedef for passing around journal access functions */ 4440cf2f763SJoel Becker typedef int (*ocfs2_journal_access_func)(handle_t *handle, 4450cf2f763SJoel Becker struct ocfs2_caching_info *ci, 44613723d00SJoel Becker struct buffer_head *bh, int type); 44713723d00SJoel Becker 448ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 449ccd979bdSMark Fasheh { 450ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 451ccd979bdSMark Fasheh return 0; 452ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 453ccd979bdSMark Fasheh return 0; 454ccd979bdSMark Fasheh return 1; 455ccd979bdSMark Fasheh } 456ccd979bdSMark Fasheh 457dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 458dcd0538fSMark Fasheh { 459dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 460dcd0538fSMark Fasheh return 1; 461dcd0538fSMark Fasheh return 0; 462dcd0538fSMark Fasheh } 463dcd0538fSMark Fasheh 464328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 465328d5752SMark Fasheh { 466328d5752SMark Fasheh /* 467328d5752SMark Fasheh * Support for sparse files is a pre-requisite 468328d5752SMark Fasheh */ 469328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 470328d5752SMark Fasheh return 0; 471328d5752SMark Fasheh 472328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 473328d5752SMark Fasheh return 1; 474328d5752SMark Fasheh return 0; 475328d5752SMark Fasheh } 476328d5752SMark Fasheh 47715b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 47815b1e36bSMark Fasheh { 47915b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 48015b1e36bSMark Fasheh return 1; 48115b1e36bSMark Fasheh return 0; 48215b1e36bSMark Fasheh } 48315b1e36bSMark Fasheh 4848154da3dSTiger Yang static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 4858154da3dSTiger Yang { 4868154da3dSTiger Yang if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 4878154da3dSTiger Yang return 1; 4888154da3dSTiger Yang return 0; 4898154da3dSTiger Yang } 4908154da3dSTiger Yang 49170ad1ba7SJoel Becker static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 49270ad1ba7SJoel Becker { 49370ad1ba7SJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 49470ad1ba7SJoel Becker return 1; 49570ad1ba7SJoel Becker return 0; 49670ad1ba7SJoel Becker } 49770ad1ba7SJoel Becker 4989b7895efSMark Fasheh static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 4999b7895efSMark Fasheh { 5009b7895efSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 5019b7895efSMark Fasheh return 1; 5029b7895efSMark Fasheh return 0; 5039b7895efSMark Fasheh } 5049b7895efSMark Fasheh 5054711954eSTao Ma static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 506798db35fSJoel Becker { 507798db35fSJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 508798db35fSJoel Becker return 1; 509798db35fSJoel Becker return 0; 510798db35fSJoel Becker } 511798db35fSJoel Becker 512198a1ca3SMark Fasheh static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 513198a1ca3SMark Fasheh { 514198a1ca3SMark Fasheh if (ocfs2_supports_indexed_dirs(osb)) 515198a1ca3SMark Fasheh return OCFS2_DX_LINK_MAX; 516198a1ca3SMark Fasheh return OCFS2_LINK_MAX; 517198a1ca3SMark Fasheh } 518198a1ca3SMark Fasheh 519198a1ca3SMark Fasheh static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 520198a1ca3SMark Fasheh { 521198a1ca3SMark Fasheh u32 nlink = le16_to_cpu(di->i_links_count); 522198a1ca3SMark Fasheh u32 hi = le16_to_cpu(di->i_links_count_hi); 523198a1ca3SMark Fasheh 524198a1ca3SMark Fasheh if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 525198a1ca3SMark Fasheh nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 526198a1ca3SMark Fasheh 527198a1ca3SMark Fasheh return nlink; 528198a1ca3SMark Fasheh } 529198a1ca3SMark Fasheh 530198a1ca3SMark Fasheh static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 531198a1ca3SMark Fasheh { 532198a1ca3SMark Fasheh u16 lo, hi; 533198a1ca3SMark Fasheh 534198a1ca3SMark Fasheh lo = nlink; 535198a1ca3SMark Fasheh hi = nlink >> OCFS2_LINKS_HI_SHIFT; 536198a1ca3SMark Fasheh 537198a1ca3SMark Fasheh di->i_links_count = cpu_to_le16(lo); 538198a1ca3SMark Fasheh di->i_links_count_hi = cpu_to_le16(hi); 539198a1ca3SMark Fasheh } 540198a1ca3SMark Fasheh 541198a1ca3SMark Fasheh static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 542198a1ca3SMark Fasheh { 543198a1ca3SMark Fasheh u32 links = ocfs2_read_links_count(di); 544198a1ca3SMark Fasheh 545198a1ca3SMark Fasheh links += n; 546198a1ca3SMark Fasheh 547198a1ca3SMark Fasheh ocfs2_set_links_count(di, links); 548198a1ca3SMark Fasheh } 549198a1ca3SMark Fasheh 5501aa75feaSTao Ma static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 5511aa75feaSTao Ma { 5521aa75feaSTao Ma if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 5531aa75feaSTao Ma return 1; 5541aa75feaSTao Ma return 0; 5551aa75feaSTao Ma } 5561aa75feaSTao Ma 557ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 558ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 559ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 560ccd979bdSMark Fasheh * too! */ 561ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 562ccd979bdSMark Fasheh unsigned long flag) 563ccd979bdSMark Fasheh { 564ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 565ccd979bdSMark Fasheh osb->osb_flags |= flag; 566ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 567ccd979bdSMark Fasheh } 568ccd979bdSMark Fasheh 569f7b1aa69SJan Kara 570f7b1aa69SJan Kara static inline unsigned long ocfs2_test_osb_flag(struct ocfs2_super *osb, 571f7b1aa69SJan Kara unsigned long flag) 572f7b1aa69SJan Kara { 573f7b1aa69SJan Kara unsigned long ret; 574f7b1aa69SJan Kara 575f7b1aa69SJan Kara spin_lock(&osb->osb_lock); 576f7b1aa69SJan Kara ret = osb->osb_flags & flag; 577f7b1aa69SJan Kara spin_unlock(&osb->osb_lock); 578f7b1aa69SJan Kara return ret; 579f7b1aa69SJan Kara } 580f7b1aa69SJan Kara 581ccd979bdSMark Fasheh static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 582ccd979bdSMark Fasheh int hard) 583ccd979bdSMark Fasheh { 584ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 585ccd979bdSMark Fasheh osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 586ccd979bdSMark Fasheh if (hard) 587ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_HARD_RO; 588ccd979bdSMark Fasheh else 589ccd979bdSMark Fasheh osb->osb_flags |= OCFS2_OSB_SOFT_RO; 590ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 591ccd979bdSMark Fasheh } 592ccd979bdSMark Fasheh 593ccd979bdSMark Fasheh static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 594ccd979bdSMark Fasheh { 595ccd979bdSMark Fasheh int ret; 596ccd979bdSMark Fasheh 597ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 598ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 599ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 600ccd979bdSMark Fasheh 601ccd979bdSMark Fasheh return ret; 602ccd979bdSMark Fasheh } 603ccd979bdSMark Fasheh 604ccd979bdSMark Fasheh static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 605ccd979bdSMark Fasheh { 606ccd979bdSMark Fasheh int ret; 607ccd979bdSMark Fasheh 608ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 609ccd979bdSMark Fasheh ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 610ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 611ccd979bdSMark Fasheh 612ccd979bdSMark Fasheh return ret; 613ccd979bdSMark Fasheh } 614ccd979bdSMark Fasheh 615b61817e1SJoel Becker static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 616b61817e1SJoel Becker { 617b61817e1SJoel Becker return (osb->s_feature_incompat & 618b61817e1SJoel Becker OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK); 619b61817e1SJoel Becker } 620b61817e1SJoel Becker 621c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 622c271c5c2SSunil Mushran { 623c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 624c271c5c2SSunil Mushran } 625c271c5c2SSunil Mushran 626386a2ef8SJoel Becker static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 627386a2ef8SJoel Becker { 628386a2ef8SJoel Becker return (osb->s_feature_incompat & 629386a2ef8SJoel Becker OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 630386a2ef8SJoel Becker } 631386a2ef8SJoel Becker 632386a2ef8SJoel Becker 633ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 634ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 635ccd979bdSMark Fasheh 636ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 637ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 638ccd979bdSMark Fasheh 639ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 640ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 641ccd979bdSMark Fasheh 642ccd979bdSMark Fasheh 643f6087fb7SJoel Becker #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 644f6087fb7SJoel Becker (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 645f6087fb7SJoel Becker 64687d35a74SMark Fasheh #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 64787d35a74SMark Fasheh (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 64887d35a74SMark Fasheh 6499b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 6509b7895efSMark Fasheh (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 6519b7895efSMark Fasheh 6529b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 6539b7895efSMark Fasheh (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 6549b7895efSMark Fasheh 655f2c870e3STao Ma #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 656f2c870e3STao Ma (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 657f2c870e3STao Ma 658ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 659ccd979bdSMark Fasheh u64 blkno) 660ccd979bdSMark Fasheh { 661ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 662ccd979bdSMark Fasheh } 663ccd979bdSMark Fasheh 664ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 665ccd979bdSMark Fasheh u32 clusters) 666ccd979bdSMark Fasheh { 667ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 668ccd979bdSMark Fasheh sb->s_blocksize_bits; 669ccd979bdSMark Fasheh 670ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 671ccd979bdSMark Fasheh } 672ccd979bdSMark Fasheh 673ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 674ccd979bdSMark Fasheh u64 blocks) 675ccd979bdSMark Fasheh { 676ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 677ccd979bdSMark Fasheh sb->s_blocksize_bits; 678ccd979bdSMark Fasheh 679ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 680ccd979bdSMark Fasheh } 681ccd979bdSMark Fasheh 682ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 683ccd979bdSMark Fasheh u64 bytes) 684ccd979bdSMark Fasheh { 685ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 686ccd979bdSMark Fasheh unsigned int clusters; 687ccd979bdSMark Fasheh 688ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 689ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 690ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 691ccd979bdSMark Fasheh 692ccd979bdSMark Fasheh return clusters; 693ccd979bdSMark Fasheh } 694ccd979bdSMark Fasheh 695ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 696ccd979bdSMark Fasheh u64 bytes) 697ccd979bdSMark Fasheh { 698ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 699ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 700ccd979bdSMark Fasheh } 701ccd979bdSMark Fasheh 702ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 703ccd979bdSMark Fasheh u32 clusters) 704ccd979bdSMark Fasheh { 705ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 706ccd979bdSMark Fasheh } 707ccd979bdSMark Fasheh 7081d46dc08SMark Fasheh static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 7091d46dc08SMark Fasheh u64 blocks) 7101d46dc08SMark Fasheh { 7111d46dc08SMark Fasheh int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 7121d46dc08SMark Fasheh unsigned int clusters; 7131d46dc08SMark Fasheh 7141d46dc08SMark Fasheh clusters = ocfs2_blocks_to_clusters(sb, blocks); 7151d46dc08SMark Fasheh return (u64)clusters << bits; 7161d46dc08SMark Fasheh } 7171d46dc08SMark Fasheh 718ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 719ccd979bdSMark Fasheh u64 bytes) 720ccd979bdSMark Fasheh { 721ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 722ccd979bdSMark Fasheh unsigned int clusters; 723ccd979bdSMark Fasheh 724ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 725ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 726ccd979bdSMark Fasheh } 727ccd979bdSMark Fasheh 728ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 729ccd979bdSMark Fasheh u64 bytes) 730ccd979bdSMark Fasheh { 731ccd979bdSMark Fasheh u64 blocks; 732ccd979bdSMark Fasheh 733ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 734ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 735ccd979bdSMark Fasheh } 736ccd979bdSMark Fasheh 737ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 738ccd979bdSMark Fasheh { 739ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 740ccd979bdSMark Fasheh } 741ccd979bdSMark Fasheh 7429517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 7439517bac6SMark Fasheh unsigned long pg_index) 7449517bac6SMark Fasheh { 7459517bac6SMark Fasheh u32 clusters = pg_index; 7469517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7479517bac6SMark Fasheh 7489517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 7499517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 7509517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 7519517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 7529517bac6SMark Fasheh 7539517bac6SMark Fasheh return clusters; 7549517bac6SMark Fasheh } 7559517bac6SMark Fasheh 7569517bac6SMark Fasheh /* 7579517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 7589517bac6SMark Fasheh */ 7597c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 7609517bac6SMark Fasheh u32 clusters) 7619517bac6SMark Fasheh { 7629517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7637c08d70cSMark Fasheh pgoff_t index = clusters; 7649517bac6SMark Fasheh 7659517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 7667c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 7679517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 7687c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 7699517bac6SMark Fasheh } 7709517bac6SMark Fasheh 7719517bac6SMark Fasheh return index; 7729517bac6SMark Fasheh } 7739517bac6SMark Fasheh 77460b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 77560b11392SMark Fasheh { 77660b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 77760b11392SMark Fasheh unsigned int pages_per_cluster = 1; 77860b11392SMark Fasheh 77960b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 78060b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 78160b11392SMark Fasheh 78260b11392SMark Fasheh return pages_per_cluster; 78360b11392SMark Fasheh } 78460b11392SMark Fasheh 785ebcee4b5SMark Fasheh static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 786ebcee4b5SMark Fasheh unsigned int megs) 787ebcee4b5SMark Fasheh { 788ebcee4b5SMark Fasheh BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 789ebcee4b5SMark Fasheh 790ebcee4b5SMark Fasheh return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 791ebcee4b5SMark Fasheh } 792ebcee4b5SMark Fasheh 79373c8a800SMark Fasheh static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 79473c8a800SMark Fasheh unsigned int clusters) 79573c8a800SMark Fasheh { 79673c8a800SMark Fasheh return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 79773c8a800SMark Fasheh } 79873c8a800SMark Fasheh 799b4414eeaSMark Fasheh static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 800b4414eeaSMark Fasheh { 801b4414eeaSMark Fasheh ext2_set_bit(bit, bitmap); 802b4414eeaSMark Fasheh } 803b4414eeaSMark Fasheh #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 804b4414eeaSMark Fasheh 805b4414eeaSMark Fasheh static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 806b4414eeaSMark Fasheh { 807b4414eeaSMark Fasheh ext2_clear_bit(bit, bitmap); 808b4414eeaSMark Fasheh } 809b4414eeaSMark Fasheh #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 810b4414eeaSMark Fasheh 811ccd979bdSMark Fasheh #define ocfs2_test_bit ext2_test_bit 812ccd979bdSMark Fasheh #define ocfs2_find_next_zero_bit ext2_find_next_zero_bit 81370ad1ba7SJoel Becker #define ocfs2_find_next_bit ext2_find_next_bit 814ccd979bdSMark Fasheh #endif /* OCFS2_H */ 815ccd979bdSMark Fasheh 816