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 147ccd979bdSMark Fasheh struct ocfs2_lock_res_ops; 148ccd979bdSMark Fasheh 149ccd979bdSMark Fasheh typedef void (*ocfs2_lock_callback)(int status, unsigned long data); 150ccd979bdSMark Fasheh 1515bc970e8SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 1525bc970e8SSunil Mushran struct ocfs2_lock_stats { 1535bc970e8SSunil Mushran u64 ls_total; /* Total wait in NSEC */ 1545bc970e8SSunil Mushran u32 ls_gets; /* Num acquires */ 1555bc970e8SSunil Mushran u32 ls_fail; /* Num failed acquires */ 1565bc970e8SSunil Mushran 1575bc970e8SSunil Mushran /* Storing max wait in usecs saves 24 bytes per inode */ 1585bc970e8SSunil Mushran u32 ls_max; /* Max wait in USEC */ 1595bc970e8SSunil Mushran }; 1605bc970e8SSunil Mushran #endif 1615bc970e8SSunil Mushran 162ccd979bdSMark Fasheh struct ocfs2_lock_res { 163ccd979bdSMark Fasheh void *l_priv; 164ccd979bdSMark Fasheh struct ocfs2_lock_res_ops *l_ops; 16583fd9c7fSGoldwyn Rodrigues 166ccd979bdSMark Fasheh 167ccd979bdSMark Fasheh struct list_head l_blocked_list; 168ccd979bdSMark Fasheh struct list_head l_mask_waiters; 169ccd979bdSMark Fasheh 170ccd979bdSMark Fasheh unsigned long l_flags; 171ccd979bdSMark Fasheh char l_name[OCFS2_LOCK_ID_MAX_LEN]; 172ccd979bdSMark Fasheh unsigned int l_ro_holders; 173ccd979bdSMark Fasheh unsigned int l_ex_holders; 174a2a2f552SMilton Miller signed char l_level; 175a2a2f552SMilton Miller signed char l_requested; 176a2a2f552SMilton Miller signed char l_blocking; 17783fd9c7fSGoldwyn Rodrigues 17883fd9c7fSGoldwyn Rodrigues /* Data packed - type enum ocfs2_lock_type */ 17983fd9c7fSGoldwyn Rodrigues unsigned char l_type; 180ccd979bdSMark Fasheh 181ccd979bdSMark Fasheh /* used from AST/BAST funcs. */ 18283fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_ast_action */ 18383fd9c7fSGoldwyn Rodrigues unsigned char l_action; 18483fd9c7fSGoldwyn Rodrigues /* Data packed - enum type ocfs2_unlock_action */ 18583fd9c7fSGoldwyn Rodrigues unsigned char l_unlock_action; 186de551246SJoel Becker unsigned int l_pending_gen; 187ccd979bdSMark Fasheh 18883fd9c7fSGoldwyn Rodrigues spinlock_t l_lock; 18983fd9c7fSGoldwyn Rodrigues 19083fd9c7fSGoldwyn Rodrigues struct ocfs2_dlm_lksb l_lksb; 19183fd9c7fSGoldwyn Rodrigues 192ccd979bdSMark Fasheh wait_queue_head_t l_event; 193ccd979bdSMark Fasheh 194ccd979bdSMark Fasheh struct list_head l_debug_list; 1958ddb7b00SSunil Mushran 1968ddb7b00SSunil Mushran #ifdef CONFIG_OCFS2_FS_STATS 1975bc970e8SSunil Mushran struct ocfs2_lock_stats l_lock_prmode; /* PR mode stats */ 1985bc970e8SSunil Mushran u32 l_lock_refresh; /* Disk refreshes */ 1995bc970e8SSunil Mushran struct ocfs2_lock_stats l_lock_exmode; /* EX mode stats */ 2008ddb7b00SSunil Mushran #endif 201cb25797dSJan Kara #ifdef CONFIG_DEBUG_LOCK_ALLOC 202cb25797dSJan Kara struct lockdep_map l_lockdep_map; 203cb25797dSJan Kara #endif 204ccd979bdSMark Fasheh }; 205ccd979bdSMark Fasheh 206692684e1SSunil Mushran enum ocfs2_orphan_scan_state { 207692684e1SSunil Mushran ORPHAN_SCAN_ACTIVE, 208692684e1SSunil Mushran ORPHAN_SCAN_INACTIVE 209692684e1SSunil Mushran }; 210692684e1SSunil Mushran 21183273932SSrinivas Eeda struct ocfs2_orphan_scan { 21283273932SSrinivas Eeda struct mutex os_lock; 21383273932SSrinivas Eeda struct ocfs2_super *os_osb; 21483273932SSrinivas Eeda struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */ 21583273932SSrinivas Eeda struct delayed_work os_orphan_scan_work; 21615633a22SSrinivas Eeda struct timespec os_scantime; /* time this node ran the scan */ 21715633a22SSrinivas Eeda u32 os_count; /* tracks node specific scans */ 21815633a22SSrinivas Eeda u32 os_seqno; /* tracks cluster wide scans */ 219692684e1SSunil Mushran atomic_t os_state; /* ACTIVE or INACTIVE */ 22083273932SSrinivas Eeda }; 22183273932SSrinivas Eeda 222ccd979bdSMark Fasheh struct ocfs2_dlm_debug { 223ccd979bdSMark Fasheh struct kref d_refcnt; 224ccd979bdSMark Fasheh struct dentry *d_locking_state; 225ccd979bdSMark Fasheh struct list_head d_lockres_tracking; 226ccd979bdSMark Fasheh }; 227ccd979bdSMark Fasheh 228ccd979bdSMark Fasheh enum ocfs2_vol_state 229ccd979bdSMark Fasheh { 230ccd979bdSMark Fasheh VOLUME_INIT = 0, 231ccd979bdSMark Fasheh VOLUME_MOUNTED, 23219ece546SJan Kara VOLUME_MOUNTED_QUOTAS, 233ccd979bdSMark Fasheh VOLUME_DISMOUNTED, 234ccd979bdSMark Fasheh VOLUME_DISABLED 235ccd979bdSMark Fasheh }; 236ccd979bdSMark Fasheh 237ccd979bdSMark Fasheh struct ocfs2_alloc_stats 238ccd979bdSMark Fasheh { 239ccd979bdSMark Fasheh atomic_t moves; 240ccd979bdSMark Fasheh atomic_t local_data; 241ccd979bdSMark Fasheh atomic_t bitmap_data; 242ccd979bdSMark Fasheh atomic_t bg_allocs; 243ccd979bdSMark Fasheh atomic_t bg_extends; 244ccd979bdSMark Fasheh }; 245ccd979bdSMark Fasheh 246ccd979bdSMark Fasheh enum ocfs2_local_alloc_state 247ccd979bdSMark Fasheh { 2489c7af40bSMark Fasheh OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for 2499c7af40bSMark Fasheh * this mountpoint. */ 2509c7af40bSMark Fasheh OCFS2_LA_ENABLED, /* Local alloc is in use. */ 2519c7af40bSMark Fasheh OCFS2_LA_THROTTLED, /* Local alloc is in use, but number 2529c7af40bSMark Fasheh * of bits has been reduced. */ 2539c7af40bSMark Fasheh OCFS2_LA_DISABLED /* Local alloc has temporarily been 2549c7af40bSMark Fasheh * disabled. */ 255ccd979bdSMark Fasheh }; 256ccd979bdSMark Fasheh 257ccd979bdSMark Fasheh enum ocfs2_mount_options 258ccd979bdSMark Fasheh { 2592c442719SSunil Mushran OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */ 260ccd979bdSMark Fasheh OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 261ccd979bdSMark Fasheh OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 262ccd979bdSMark Fasheh OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 263ccd979bdSMark Fasheh OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 26453fc622bSMark Fasheh OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */ 265cf1d6c76STiger Yang OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */ 26612462f1dSJoel Becker OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */ 2675297aad8SJan Kara OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */ 2685297aad8SJan Kara OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access 2695297aad8SJan Kara control lists */ 2705297aad8SJan Kara OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */ 2715297aad8SJan Kara OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */ 272fc371891SJoel Becker OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT 2737bdb0d18STristan Ye writes */ 274fc371891SJoel Becker OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */ 275fc371891SJoel Becker OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */ 276ccd979bdSMark Fasheh }; 277ccd979bdSMark Fasheh 278ccd979bdSMark Fasheh #define OCFS2_OSB_SOFT_RO 0x0001 279ccd979bdSMark Fasheh #define OCFS2_OSB_HARD_RO 0x0002 280ccd979bdSMark Fasheh #define OCFS2_OSB_ERROR_FS 0x0004 2817f1a37e3STiger Yang #define OCFS2_DEFAULT_ATIME_QUANTUM 60 282ccd979bdSMark Fasheh 283ccd979bdSMark Fasheh struct ocfs2_journal; 284d85b20e4SJoel Becker struct ocfs2_slot_info; 285553abd04SJoel Becker struct ocfs2_recovery_map; 2869140db04SSrinivas Eeda struct ocfs2_replay_map; 2872205363dSJan Kara struct ocfs2_quota_recovery; 288ccd979bdSMark Fasheh struct ocfs2_super 289ccd979bdSMark Fasheh { 290ccd979bdSMark Fasheh struct task_struct *commit_task; 291ccd979bdSMark Fasheh struct super_block *sb; 292ccd979bdSMark Fasheh struct inode *root_inode; 293ccd979bdSMark Fasheh struct inode *sys_root_inode; 294b4d693fcSTao Ma struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES]; 295b4d693fcSTao Ma struct inode **local_system_inodes; 296ccd979bdSMark Fasheh 297ccd979bdSMark Fasheh struct ocfs2_slot_info *slot_info; 298ccd979bdSMark Fasheh 299539d8264SSunil Mushran u32 *slot_recovery_generations; 300539d8264SSunil Mushran 301ccd979bdSMark Fasheh spinlock_t node_map_lock; 302ccd979bdSMark Fasheh 303ccd979bdSMark Fasheh u64 root_blkno; 304ccd979bdSMark Fasheh u64 system_dir_blkno; 305ccd979bdSMark Fasheh u64 bitmap_blkno; 306ccd979bdSMark Fasheh u32 bitmap_cpg; 307ccd979bdSMark Fasheh u8 *uuid; 308ccd979bdSMark Fasheh char *uuid_str; 309cf1d6c76STiger Yang u32 uuid_hash; 310ccd979bdSMark Fasheh u8 *vol_label; 311ccd979bdSMark Fasheh u64 first_cluster_group_blkno; 312ccd979bdSMark Fasheh u32 fs_generation; 313ccd979bdSMark Fasheh 314ccd979bdSMark Fasheh u32 s_feature_compat; 315ccd979bdSMark Fasheh u32 s_feature_incompat; 316ccd979bdSMark Fasheh u32 s_feature_ro_compat; 317ccd979bdSMark Fasheh 3184d0ddb2cSTao Ma /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 3194d0ddb2cSTao Ma * Could protect more on osb as it's very short lived. 3204d0ddb2cSTao Ma */ 321ccd979bdSMark Fasheh spinlock_t osb_lock; 322ccd979bdSMark Fasheh u32 s_next_generation; 323ccd979bdSMark Fasheh unsigned long osb_flags; 3244d0ddb2cSTao Ma s16 s_inode_steal_slot; 325b89c5428STiger Yang s16 s_meta_steal_slot; 3264d0ddb2cSTao Ma atomic_t s_num_inodes_stolen; 327b89c5428STiger Yang atomic_t s_num_meta_stolen; 328ccd979bdSMark Fasheh 329ccd979bdSMark Fasheh unsigned long s_mount_opt; 3307f1a37e3STiger Yang unsigned int s_atime_quantum; 331ccd979bdSMark Fasheh 332fc881fa0SJoel Becker unsigned int max_slots; 33319fdb624SJoel Becker unsigned int node_num; 334fc881fa0SJoel Becker int slot_num; 335fc881fa0SJoel Becker int preferred_slot; 336ccd979bdSMark Fasheh int s_sectsize_bits; 337ccd979bdSMark Fasheh int s_clustersize; 338ccd979bdSMark Fasheh int s_clustersize_bits; 339fdd77704STiger Yang unsigned int s_xattr_inline_size; 340ccd979bdSMark Fasheh 341ccd979bdSMark Fasheh atomic_t vol_state; 342c74ec2f7SArjan van de Ven struct mutex recovery_lock; 343553abd04SJoel Becker struct ocfs2_recovery_map *recovery_map; 3449140db04SSrinivas Eeda struct ocfs2_replay_map *replay_map; 345ccd979bdSMark Fasheh struct task_struct *recovery_thread_task; 346ccd979bdSMark Fasheh int disable_recovery; 347ccd979bdSMark Fasheh wait_queue_head_t checkpoint_event; 348ccd979bdSMark Fasheh struct ocfs2_journal *journal; 349d147b3d6SMark Fasheh unsigned long osb_commit_interval; 350ccd979bdSMark Fasheh 3519c7af40bSMark Fasheh struct delayed_work la_enable_wq; 3529c7af40bSMark Fasheh 3539c7af40bSMark Fasheh /* 3549c7af40bSMark Fasheh * Must hold local alloc i_mutex and osb->osb_lock to change 3559c7af40bSMark Fasheh * local_alloc_bits. Reads can be done under either lock. 3569c7af40bSMark Fasheh */ 357ebcee4b5SMark Fasheh unsigned int local_alloc_bits; 3589c7af40bSMark Fasheh unsigned int local_alloc_default_bits; 3596b82021bSMark Fasheh /* osb_clusters_at_boot can become stale! Do not trust it to 3606b82021bSMark Fasheh * be up to date. */ 3616b82021bSMark Fasheh unsigned int osb_clusters_at_boot; 3629c7af40bSMark Fasheh 3639c7af40bSMark Fasheh enum ocfs2_local_alloc_state local_alloc_state; /* protected 3649c7af40bSMark Fasheh * by osb_lock */ 3659c7af40bSMark Fasheh 366ccd979bdSMark Fasheh struct buffer_head *local_alloc_bh; 3679c7af40bSMark Fasheh 368883d4caeSMark Fasheh u64 la_last_gd; 369ccd979bdSMark Fasheh 370d02f00ccSMark Fasheh struct ocfs2_reservation_map osb_la_resmap; 371d02f00ccSMark Fasheh 372d02f00ccSMark Fasheh unsigned int osb_resv_level; 37383f92318SMark Fasheh unsigned int osb_dir_resv_level; 374d02f00ccSMark Fasheh 3752205363dSJan Kara /* Next three fields are for local node slot recovery during 376ccd979bdSMark Fasheh * mount. */ 377ccd979bdSMark Fasheh int dirty; 378ccd979bdSMark Fasheh struct ocfs2_dinode *local_alloc_copy; 3792205363dSJan Kara struct ocfs2_quota_recovery *quota_rec; 380ccd979bdSMark Fasheh 38173be192bSJoel Becker struct ocfs2_blockcheck_stats osb_ecc_stats; 382ccd979bdSMark Fasheh struct ocfs2_alloc_stats alloc_stats; 383ccd979bdSMark Fasheh char dev_str[20]; /* "major,minor" of the device */ 384ccd979bdSMark Fasheh 38598f486f2SSunil Mushran u8 osb_stackflags; 38698f486f2SSunil Mushran 387b61817e1SJoel Becker char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 388c74a3bddSGoldwyn Rodrigues char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1]; 3894670c46dSJoel Becker struct ocfs2_cluster_connection *cconn; 390ccd979bdSMark Fasheh struct ocfs2_lock_res osb_super_lockres; 391ccd979bdSMark Fasheh struct ocfs2_lock_res osb_rename_lockres; 3926ca497a8Swengang wang struct ocfs2_lock_res osb_nfs_sync_lockres; 393ccd979bdSMark Fasheh struct ocfs2_dlm_debug *osb_dlm_debug; 394ccd979bdSMark Fasheh 395ccd979bdSMark Fasheh struct dentry *osb_debug_root; 39650397507SSunil Mushran struct dentry *osb_ctxt; 397ccd979bdSMark Fasheh 398ccd979bdSMark Fasheh wait_queue_head_t recovery_event; 399ccd979bdSMark Fasheh 40034d024f8SMark Fasheh spinlock_t dc_task_lock; 40134d024f8SMark Fasheh struct task_struct *dc_task; 40234d024f8SMark Fasheh wait_queue_head_t dc_event; 40334d024f8SMark Fasheh unsigned long dc_wake_sequence; 40434d024f8SMark Fasheh unsigned long dc_work_sequence; 405ccd979bdSMark Fasheh 4067ec373cfSMark Fasheh /* 4077ec373cfSMark Fasheh * Any thread can add locks to the list, but the downconvert 4087ec373cfSMark Fasheh * thread is the only one allowed to remove locks. Any change 4097ec373cfSMark Fasheh * to this rule requires updating 4107ec373cfSMark Fasheh * ocfs2_downconvert_thread_do_work(). 4117ec373cfSMark Fasheh */ 412ccd979bdSMark Fasheh struct list_head blocked_lock_list; 413ccd979bdSMark Fasheh unsigned long blocked_lock_count; 414ccd979bdSMark Fasheh 415e3a767b6SJan Kara /* List of dquot structures to drop last reference to */ 416e3a767b6SJan Kara struct llist_head dquot_drop_list; 417e3a767b6SJan Kara struct work_struct dquot_drop_work; 418e3a767b6SJan Kara 419ccd979bdSMark Fasheh wait_queue_head_t osb_mount_event; 420ccd979bdSMark Fasheh 421ccd979bdSMark Fasheh /* Truncate log info */ 422ccd979bdSMark Fasheh struct inode *osb_tl_inode; 423ccd979bdSMark Fasheh struct buffer_head *osb_tl_bh; 424c4028958SDavid Howells struct delayed_work osb_truncate_log_wq; 42550308d81STao Ma /* 42650308d81STao Ma * How many clusters in our truncate log. 42750308d81STao Ma * It must be protected by osb_tl_inode->i_mutex. 42850308d81STao Ma */ 42950308d81STao Ma unsigned int truncated_clusters; 430b4df6ed8SMark Fasheh 431b4df6ed8SMark Fasheh struct ocfs2_node_map osb_recovering_orphan_dirs; 432b4df6ed8SMark Fasheh unsigned int *osb_orphan_wipes; 433b4df6ed8SMark Fasheh wait_queue_head_t osb_wipe_event; 434c8b9cf9aSTao Ma 43583273932SSrinivas Eeda struct ocfs2_orphan_scan osb_orphan_scan; 43683273932SSrinivas Eeda 437c8b9cf9aSTao Ma /* used to protect metaecc calculation check of xattr. */ 438c8b9cf9aSTao Ma spinlock_t osb_xattr_lock; 4399b7895efSMark Fasheh 4409b7895efSMark Fasheh unsigned int osb_dx_mask; 4419b7895efSMark Fasheh u32 osb_dx_seed[4]; 442feb473a6STao Ma 443feb473a6STao Ma /* the group we used to allocate inodes. */ 444feb473a6STao Ma u64 osb_inode_alloc_group; 445374a263eSTao Ma 446374a263eSTao Ma /* rb tree root for refcount lock. */ 447374a263eSTao Ma struct rb_root osb_rf_lock_tree; 448374a263eSTao Ma struct ocfs2_refcount_tree *osb_ref_tree_lru; 44943b10a20Sjiangyiwen 45043b10a20Sjiangyiwen struct mutex system_file_mutex; 451ccd979bdSMark Fasheh }; 452ccd979bdSMark Fasheh 453ccd979bdSMark Fasheh #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 454ccd979bdSMark Fasheh 45513723d00SJoel Becker /* Useful typedef for passing around journal access functions */ 4560cf2f763SJoel Becker typedef int (*ocfs2_journal_access_func)(handle_t *handle, 4570cf2f763SJoel Becker struct ocfs2_caching_info *ci, 45813723d00SJoel Becker struct buffer_head *bh, int type); 45913723d00SJoel Becker 460ccd979bdSMark Fasheh static inline int ocfs2_should_order_data(struct inode *inode) 461ccd979bdSMark Fasheh { 462ccd979bdSMark Fasheh if (!S_ISREG(inode->i_mode)) 463ccd979bdSMark Fasheh return 0; 464ccd979bdSMark Fasheh if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 465ccd979bdSMark Fasheh return 0; 466ccd979bdSMark Fasheh return 1; 467ccd979bdSMark Fasheh } 468ccd979bdSMark Fasheh 469dcd0538fSMark Fasheh static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 470dcd0538fSMark Fasheh { 471dcd0538fSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 472dcd0538fSMark Fasheh return 1; 473dcd0538fSMark Fasheh return 0; 474dcd0538fSMark Fasheh } 475dcd0538fSMark Fasheh 476328d5752SMark Fasheh static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 477328d5752SMark Fasheh { 478328d5752SMark Fasheh /* 479328d5752SMark Fasheh * Support for sparse files is a pre-requisite 480328d5752SMark Fasheh */ 481328d5752SMark Fasheh if (!ocfs2_sparse_alloc(osb)) 482328d5752SMark Fasheh return 0; 483328d5752SMark Fasheh 484328d5752SMark Fasheh if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 485328d5752SMark Fasheh return 1; 486328d5752SMark Fasheh return 0; 487328d5752SMark Fasheh } 488328d5752SMark Fasheh 48915b1e36bSMark Fasheh static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 49015b1e36bSMark Fasheh { 49115b1e36bSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 49215b1e36bSMark Fasheh return 1; 49315b1e36bSMark Fasheh return 0; 49415b1e36bSMark Fasheh } 49515b1e36bSMark Fasheh 4968154da3dSTiger Yang static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 4978154da3dSTiger Yang { 4988154da3dSTiger Yang if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 4998154da3dSTiger Yang return 1; 5008154da3dSTiger Yang return 0; 5018154da3dSTiger Yang } 5028154da3dSTiger Yang 50370ad1ba7SJoel Becker static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 50470ad1ba7SJoel Becker { 50570ad1ba7SJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 50670ad1ba7SJoel Becker return 1; 50770ad1ba7SJoel Becker return 0; 50870ad1ba7SJoel Becker } 50970ad1ba7SJoel Becker 5109b7895efSMark Fasheh static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 5119b7895efSMark Fasheh { 5129b7895efSMark Fasheh if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 5139b7895efSMark Fasheh return 1; 5149b7895efSMark Fasheh return 0; 5159b7895efSMark Fasheh } 5169b7895efSMark Fasheh 5174711954eSTao Ma static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 518798db35fSJoel Becker { 519798db35fSJoel Becker if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 520798db35fSJoel Becker return 1; 521798db35fSJoel Becker return 0; 522798db35fSJoel Becker } 523798db35fSJoel Becker 524198a1ca3SMark Fasheh static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 525198a1ca3SMark Fasheh { 526198a1ca3SMark Fasheh if (ocfs2_supports_indexed_dirs(osb)) 527198a1ca3SMark Fasheh return OCFS2_DX_LINK_MAX; 528198a1ca3SMark Fasheh return OCFS2_LINK_MAX; 529198a1ca3SMark Fasheh } 530198a1ca3SMark Fasheh 531198a1ca3SMark Fasheh static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 532198a1ca3SMark Fasheh { 533198a1ca3SMark Fasheh u32 nlink = le16_to_cpu(di->i_links_count); 534198a1ca3SMark Fasheh u32 hi = le16_to_cpu(di->i_links_count_hi); 535198a1ca3SMark Fasheh 536198a1ca3SMark Fasheh if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 537198a1ca3SMark Fasheh nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 538198a1ca3SMark Fasheh 539198a1ca3SMark Fasheh return nlink; 540198a1ca3SMark Fasheh } 541198a1ca3SMark Fasheh 542198a1ca3SMark Fasheh static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 543198a1ca3SMark Fasheh { 544198a1ca3SMark Fasheh u16 lo, hi; 545198a1ca3SMark Fasheh 546198a1ca3SMark Fasheh lo = nlink; 547198a1ca3SMark Fasheh hi = nlink >> OCFS2_LINKS_HI_SHIFT; 548198a1ca3SMark Fasheh 549198a1ca3SMark Fasheh di->i_links_count = cpu_to_le16(lo); 550198a1ca3SMark Fasheh di->i_links_count_hi = cpu_to_le16(hi); 551198a1ca3SMark Fasheh } 552198a1ca3SMark Fasheh 553198a1ca3SMark Fasheh static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 554198a1ca3SMark Fasheh { 555198a1ca3SMark Fasheh u32 links = ocfs2_read_links_count(di); 556198a1ca3SMark Fasheh 557198a1ca3SMark Fasheh links += n; 558198a1ca3SMark Fasheh 559198a1ca3SMark Fasheh ocfs2_set_links_count(di, links); 560198a1ca3SMark Fasheh } 561198a1ca3SMark Fasheh 5621aa75feaSTao Ma static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 5631aa75feaSTao Ma { 5641aa75feaSTao Ma if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 5651aa75feaSTao Ma return 1; 5661aa75feaSTao Ma return 0; 5671aa75feaSTao Ma } 5681aa75feaSTao Ma 569ccd979bdSMark Fasheh /* set / clear functions because cluster events can make these happen 570ccd979bdSMark Fasheh * in parallel so we want the transitions to be atomic. this also 571ccd979bdSMark Fasheh * means that any future flags osb_flags must be protected by spinlock 572ccd979bdSMark Fasheh * too! */ 573ccd979bdSMark Fasheh static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 574ccd979bdSMark Fasheh unsigned long flag) 575ccd979bdSMark Fasheh { 576ccd979bdSMark Fasheh spin_lock(&osb->osb_lock); 577ccd979bdSMark Fasheh osb->osb_flags |= flag; 578ccd979bdSMark Fasheh spin_unlock(&osb->osb_lock); 579ccd979bdSMark Fasheh } 580ccd979bdSMark Fasheh 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 61598f486f2SSunil Mushran static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb) 616b61817e1SJoel Becker { 617b61817e1SJoel Becker return (osb->s_feature_incompat & 61898f486f2SSunil Mushran (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK | 61998f486f2SSunil Mushran OCFS2_FEATURE_INCOMPAT_CLUSTERINFO)); 62098f486f2SSunil Mushran } 62198f486f2SSunil Mushran 62298f486f2SSunil Mushran static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 62398f486f2SSunil Mushran { 62498f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 62598f486f2SSunil Mushran memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 62698f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 62798f486f2SSunil Mushran return 1; 62898f486f2SSunil Mushran return 0; 62998f486f2SSunil Mushran } 63098f486f2SSunil Mushran 63198f486f2SSunil Mushran static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb) 63298f486f2SSunil Mushran { 63398f486f2SSunil Mushran if (ocfs2_clusterinfo_valid(osb) && 63498f486f2SSunil Mushran !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 63598f486f2SSunil Mushran OCFS2_STACK_LABEL_LEN)) 63698f486f2SSunil Mushran return 1; 63798f486f2SSunil Mushran return 0; 63898f486f2SSunil Mushran } 63998f486f2SSunil Mushran 64098f486f2SSunil Mushran static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb) 64198f486f2SSunil Mushran { 64298f486f2SSunil Mushran return ocfs2_o2cb_stack(osb) && 64398f486f2SSunil Mushran (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT); 644b61817e1SJoel Becker } 645b61817e1SJoel Becker 646c271c5c2SSunil Mushran static inline int ocfs2_mount_local(struct ocfs2_super *osb) 647c271c5c2SSunil Mushran { 648c271c5c2SSunil Mushran return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 649c271c5c2SSunil Mushran } 650c271c5c2SSunil Mushran 651386a2ef8SJoel Becker static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 652386a2ef8SJoel Becker { 653386a2ef8SJoel Becker return (osb->s_feature_incompat & 654386a2ef8SJoel Becker OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 655386a2ef8SJoel Becker } 656386a2ef8SJoel Becker 657386a2ef8SJoel Becker 658ccd979bdSMark Fasheh #define OCFS2_IS_VALID_DINODE(ptr) \ 659ccd979bdSMark Fasheh (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 660ccd979bdSMark Fasheh 661ccd979bdSMark Fasheh #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 662ccd979bdSMark Fasheh (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 663ccd979bdSMark Fasheh 664ccd979bdSMark Fasheh #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 665ccd979bdSMark Fasheh (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 666ccd979bdSMark Fasheh 667ccd979bdSMark Fasheh 668f6087fb7SJoel Becker #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 669f6087fb7SJoel Becker (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 670f6087fb7SJoel Becker 67187d35a74SMark Fasheh #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 67287d35a74SMark Fasheh (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 67387d35a74SMark Fasheh 6749b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 6759b7895efSMark Fasheh (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 6769b7895efSMark Fasheh 6779b7895efSMark Fasheh #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 6789b7895efSMark Fasheh (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 6799b7895efSMark Fasheh 680f2c870e3STao Ma #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 681f2c870e3STao Ma (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 682f2c870e3STao Ma 683ccd979bdSMark Fasheh static inline unsigned long ino_from_blkno(struct super_block *sb, 684ccd979bdSMark Fasheh u64 blkno) 685ccd979bdSMark Fasheh { 686ccd979bdSMark Fasheh return (unsigned long)(blkno & (u64)ULONG_MAX); 687ccd979bdSMark Fasheh } 688ccd979bdSMark Fasheh 689ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 690ccd979bdSMark Fasheh u32 clusters) 691ccd979bdSMark Fasheh { 692ccd979bdSMark Fasheh int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 693ccd979bdSMark Fasheh sb->s_blocksize_bits; 694ccd979bdSMark Fasheh 695ccd979bdSMark Fasheh return (u64)clusters << c_to_b_bits; 696ccd979bdSMark Fasheh } 697ccd979bdSMark Fasheh 698ccd979bdSMark Fasheh static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 699ccd979bdSMark Fasheh u64 blocks) 700ccd979bdSMark Fasheh { 701ccd979bdSMark Fasheh int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 702ccd979bdSMark Fasheh sb->s_blocksize_bits; 703ccd979bdSMark Fasheh 704ccd979bdSMark Fasheh return (u32)(blocks >> b_to_c_bits); 705ccd979bdSMark Fasheh } 706ccd979bdSMark Fasheh 707ccd979bdSMark Fasheh static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 708ccd979bdSMark Fasheh u64 bytes) 709ccd979bdSMark Fasheh { 710ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 711ccd979bdSMark Fasheh unsigned int clusters; 712ccd979bdSMark Fasheh 713ccd979bdSMark Fasheh bytes += OCFS2_SB(sb)->s_clustersize - 1; 714ccd979bdSMark Fasheh /* OCFS2 just cannot have enough clusters to overflow this */ 715ccd979bdSMark Fasheh clusters = (unsigned int)(bytes >> cl_bits); 716ccd979bdSMark Fasheh 717ccd979bdSMark Fasheh return clusters; 718ccd979bdSMark Fasheh } 719ccd979bdSMark Fasheh 720ccd979bdSMark Fasheh static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 721ccd979bdSMark Fasheh u64 bytes) 722ccd979bdSMark Fasheh { 723ccd979bdSMark Fasheh bytes += sb->s_blocksize - 1; 724ccd979bdSMark Fasheh return bytes >> sb->s_blocksize_bits; 725ccd979bdSMark Fasheh } 726ccd979bdSMark Fasheh 727ccd979bdSMark Fasheh static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 728ccd979bdSMark Fasheh u32 clusters) 729ccd979bdSMark Fasheh { 730ccd979bdSMark Fasheh return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 731ccd979bdSMark Fasheh } 732ccd979bdSMark Fasheh 7331d46dc08SMark Fasheh static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 7341d46dc08SMark Fasheh u64 blocks) 7351d46dc08SMark Fasheh { 7361d46dc08SMark Fasheh int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 7371d46dc08SMark Fasheh unsigned int clusters; 7381d46dc08SMark Fasheh 7391d46dc08SMark Fasheh clusters = ocfs2_blocks_to_clusters(sb, blocks); 7401d46dc08SMark Fasheh return (u64)clusters << bits; 7411d46dc08SMark Fasheh } 7421d46dc08SMark Fasheh 743ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 744ccd979bdSMark Fasheh u64 bytes) 745ccd979bdSMark Fasheh { 746ccd979bdSMark Fasheh int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 747ccd979bdSMark Fasheh unsigned int clusters; 748ccd979bdSMark Fasheh 749ccd979bdSMark Fasheh clusters = ocfs2_clusters_for_bytes(sb, bytes); 750ccd979bdSMark Fasheh return (u64)clusters << cl_bits; 751ccd979bdSMark Fasheh } 752ccd979bdSMark Fasheh 753ccd979bdSMark Fasheh static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 754ccd979bdSMark Fasheh u64 bytes) 755ccd979bdSMark Fasheh { 756ccd979bdSMark Fasheh u64 blocks; 757ccd979bdSMark Fasheh 758ccd979bdSMark Fasheh blocks = ocfs2_blocks_for_bytes(sb, bytes); 759ccd979bdSMark Fasheh return blocks << sb->s_blocksize_bits; 760ccd979bdSMark Fasheh } 761ccd979bdSMark Fasheh 762ccd979bdSMark Fasheh static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 763ccd979bdSMark Fasheh { 764ccd979bdSMark Fasheh return (unsigned long)((bytes + 511) >> 9); 765ccd979bdSMark Fasheh } 766ccd979bdSMark Fasheh 7679517bac6SMark Fasheh static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 7689517bac6SMark Fasheh unsigned long pg_index) 7699517bac6SMark Fasheh { 7709517bac6SMark Fasheh u32 clusters = pg_index; 7719517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7729517bac6SMark Fasheh 7739517bac6SMark Fasheh if (unlikely(PAGE_CACHE_SHIFT > cbits)) 7749517bac6SMark Fasheh clusters = pg_index << (PAGE_CACHE_SHIFT - cbits); 7759517bac6SMark Fasheh else if (PAGE_CACHE_SHIFT < cbits) 7769517bac6SMark Fasheh clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT); 7779517bac6SMark Fasheh 7789517bac6SMark Fasheh return clusters; 7799517bac6SMark Fasheh } 7809517bac6SMark Fasheh 7819517bac6SMark Fasheh /* 7829517bac6SMark Fasheh * Find the 1st page index which covers the given clusters. 7839517bac6SMark Fasheh */ 7847c08d70cSMark Fasheh static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 7859517bac6SMark Fasheh u32 clusters) 7869517bac6SMark Fasheh { 7879517bac6SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 7887c08d70cSMark Fasheh pgoff_t index = clusters; 7899517bac6SMark Fasheh 7909517bac6SMark Fasheh if (PAGE_CACHE_SHIFT > cbits) { 7917c08d70cSMark Fasheh index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits); 7929517bac6SMark Fasheh } else if (PAGE_CACHE_SHIFT < cbits) { 7937c08d70cSMark Fasheh index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT); 7949517bac6SMark Fasheh } 7959517bac6SMark Fasheh 7969517bac6SMark Fasheh return index; 7979517bac6SMark Fasheh } 7989517bac6SMark Fasheh 79960b11392SMark Fasheh static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 80060b11392SMark Fasheh { 80160b11392SMark Fasheh unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 80260b11392SMark Fasheh unsigned int pages_per_cluster = 1; 80360b11392SMark Fasheh 80460b11392SMark Fasheh if (PAGE_CACHE_SHIFT < cbits) 80560b11392SMark Fasheh pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT); 80660b11392SMark Fasheh 80760b11392SMark Fasheh return pages_per_cluster; 80860b11392SMark Fasheh } 80960b11392SMark Fasheh 810ebcee4b5SMark Fasheh static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 811ebcee4b5SMark Fasheh unsigned int megs) 812ebcee4b5SMark Fasheh { 813ebcee4b5SMark Fasheh BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 814ebcee4b5SMark Fasheh 815ebcee4b5SMark Fasheh return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 816ebcee4b5SMark Fasheh } 817ebcee4b5SMark Fasheh 81873c8a800SMark Fasheh static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 81973c8a800SMark Fasheh unsigned int clusters) 82073c8a800SMark Fasheh { 82173c8a800SMark Fasheh return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 82273c8a800SMark Fasheh } 82373c8a800SMark Fasheh 824b4414eeaSMark Fasheh static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 825b4414eeaSMark Fasheh { 826730e663bSAkinobu Mita __set_bit_le(bit, bitmap); 827b4414eeaSMark Fasheh } 828b4414eeaSMark Fasheh #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 829b4414eeaSMark Fasheh 830b4414eeaSMark Fasheh static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 831b4414eeaSMark Fasheh { 832730e663bSAkinobu Mita __clear_bit_le(bit, bitmap); 833b4414eeaSMark Fasheh } 834b4414eeaSMark Fasheh #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 835b4414eeaSMark Fasheh 836c4354d0dSAkinobu Mita #define ocfs2_test_bit test_bit_le 837c4354d0dSAkinobu Mita #define ocfs2_find_next_zero_bit find_next_zero_bit_le 838c4354d0dSAkinobu Mita #define ocfs2_find_next_bit find_next_bit_le 83993925579SAkinobu Mita 84093925579SAkinobu Mita static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr) 84193925579SAkinobu Mita { 84293925579SAkinobu Mita #if BITS_PER_LONG == 64 84393925579SAkinobu Mita *bit += ((unsigned long) addr & 7UL) << 3; 84493925579SAkinobu Mita addr = (void *) ((unsigned long) addr & ~7UL); 84593925579SAkinobu Mita #elif BITS_PER_LONG == 32 84693925579SAkinobu Mita *bit += ((unsigned long) addr & 3UL) << 3; 84793925579SAkinobu Mita addr = (void *) ((unsigned long) addr & ~3UL); 84893925579SAkinobu Mita #else 84993925579SAkinobu Mita #error "how many bits you are?!" 85093925579SAkinobu Mita #endif 85193925579SAkinobu Mita return addr; 85293925579SAkinobu Mita } 85393925579SAkinobu Mita 85493925579SAkinobu Mita static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap) 85593925579SAkinobu Mita { 85693925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 85793925579SAkinobu Mita ocfs2_set_bit(bit, bitmap); 85893925579SAkinobu Mita } 85993925579SAkinobu Mita 86093925579SAkinobu Mita static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap) 86193925579SAkinobu Mita { 86293925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 86393925579SAkinobu Mita ocfs2_clear_bit(bit, bitmap); 86493925579SAkinobu Mita } 86593925579SAkinobu Mita 86693925579SAkinobu Mita static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap) 86793925579SAkinobu Mita { 86893925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 86993925579SAkinobu Mita return ocfs2_test_bit(bit, bitmap); 87093925579SAkinobu Mita } 87193925579SAkinobu Mita 87293925579SAkinobu Mita static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max, 87393925579SAkinobu Mita int start) 87493925579SAkinobu Mita { 87593925579SAkinobu Mita int fix = 0, ret, tmpmax; 87693925579SAkinobu Mita bitmap = correct_addr_and_bit_unaligned(&fix, bitmap); 87793925579SAkinobu Mita tmpmax = max + fix; 87893925579SAkinobu Mita start += fix; 87993925579SAkinobu Mita 88093925579SAkinobu Mita ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix; 88193925579SAkinobu Mita if (ret > max) 88293925579SAkinobu Mita return max; 88393925579SAkinobu Mita return ret; 88493925579SAkinobu Mita } 88593925579SAkinobu Mita 886ccd979bdSMark Fasheh #endif /* OCFS2_H */ 887ccd979bdSMark Fasheh 888