1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * ocfs2.h 5 * 6 * Defines macros and structures used in OCFS2 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #ifndef OCFS2_H 27 #define OCFS2_H 28 29 #include <linux/spinlock.h> 30 #include <linux/sched.h> 31 #include <linux/wait.h> 32 #include <linux/list.h> 33 #include <linux/llist.h> 34 #include <linux/rbtree.h> 35 #include <linux/workqueue.h> 36 #include <linux/kref.h> 37 #include <linux/mutex.h> 38 #include <linux/lockdep.h> 39 #include <linux/jbd2.h> 40 41 /* For union ocfs2_dlm_lksb */ 42 #include "stackglue.h" 43 44 #include "ocfs2_fs.h" 45 #include "ocfs2_lockid.h" 46 #include "ocfs2_ioctl.h" 47 48 /* For struct ocfs2_blockcheck_stats */ 49 #include "blockcheck.h" 50 51 #include "reservations.h" 52 53 #include "filecheck.h" 54 55 /* Caching of metadata buffers */ 56 57 /* Most user visible OCFS2 inodes will have very few pieces of 58 * metadata, but larger files (including bitmaps, etc) must be taken 59 * into account when designing an access scheme. We allow a small 60 * amount of inlined blocks to be stored on an array and grow the 61 * structure into a rb tree when necessary. */ 62 #define OCFS2_CACHE_INFO_MAX_ARRAY 2 63 64 /* Flags for ocfs2_caching_info */ 65 66 enum ocfs2_caching_info_flags { 67 /* Indicates that the metadata cache is using the inline array */ 68 OCFS2_CACHE_FL_INLINE = 1<<1, 69 }; 70 71 struct ocfs2_caching_operations; 72 struct ocfs2_caching_info { 73 /* 74 * The parent structure provides the locks, but because the 75 * parent structure can differ, it provides locking operations 76 * to struct ocfs2_caching_info. 77 */ 78 const struct ocfs2_caching_operations *ci_ops; 79 80 /* next two are protected by trans_inc_lock */ 81 /* which transaction were we created on? Zero if none. */ 82 unsigned long ci_created_trans; 83 /* last transaction we were a part of. */ 84 unsigned long ci_last_trans; 85 86 /* Cache structures */ 87 unsigned int ci_flags; 88 unsigned int ci_num_cached; 89 union { 90 sector_t ci_array[OCFS2_CACHE_INFO_MAX_ARRAY]; 91 struct rb_root ci_tree; 92 } ci_cache; 93 }; 94 /* 95 * Need this prototype here instead of in uptodate.h because journal.h 96 * uses it. 97 */ 98 struct super_block *ocfs2_metadata_cache_get_super(struct ocfs2_caching_info *ci); 99 100 /* this limits us to 256 nodes 101 * if we need more, we can do a kmalloc for the map */ 102 #define OCFS2_NODE_MAP_MAX_NODES 256 103 struct ocfs2_node_map { 104 u16 num_nodes; 105 unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)]; 106 }; 107 108 enum ocfs2_ast_action { 109 OCFS2_AST_INVALID = 0, 110 OCFS2_AST_ATTACH, 111 OCFS2_AST_CONVERT, 112 OCFS2_AST_DOWNCONVERT, 113 }; 114 115 /* actions for an unlockast function to take. */ 116 enum ocfs2_unlock_action { 117 OCFS2_UNLOCK_INVALID = 0, 118 OCFS2_UNLOCK_CANCEL_CONVERT, 119 OCFS2_UNLOCK_DROP_LOCK, 120 }; 121 122 /* ocfs2_lock_res->l_flags flags. */ 123 #define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized 124 * the lvb */ 125 #define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in 126 * dlm_lock */ 127 #define OCFS2_LOCK_BLOCKED (0x00000004) /* blocked waiting to 128 * downconvert*/ 129 #define OCFS2_LOCK_LOCAL (0x00000008) /* newly created inode */ 130 #define OCFS2_LOCK_NEEDS_REFRESH (0x00000010) 131 #define OCFS2_LOCK_REFRESHING (0x00000020) 132 #define OCFS2_LOCK_INITIALIZED (0x00000040) /* track initialization 133 * for shutdown paths */ 134 #define OCFS2_LOCK_FREEING (0x00000080) /* help dlmglue track 135 * when to skip queueing 136 * a lock because it's 137 * about to be 138 * dropped. */ 139 #define OCFS2_LOCK_QUEUED (0x00000100) /* queued for downconvert */ 140 #define OCFS2_LOCK_NOCACHE (0x00000200) /* don't use a holder count */ 141 #define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a 142 call to dlm_lock. Only 143 exists with BUSY set. */ 144 #define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread 145 * from downconverting 146 * before the upconvert 147 * has completed */ 148 149 #define OCFS2_LOCK_NONBLOCK_FINISHED (0x00001000) /* NONBLOCK cluster 150 * lock has already 151 * returned, do not block 152 * dc thread from 153 * downconverting */ 154 155 struct ocfs2_lock_res_ops; 156 157 typedef void (*ocfs2_lock_callback)(int status, unsigned long data); 158 159 #ifdef CONFIG_OCFS2_FS_STATS 160 struct ocfs2_lock_stats { 161 u64 ls_total; /* Total wait in NSEC */ 162 u32 ls_gets; /* Num acquires */ 163 u32 ls_fail; /* Num failed acquires */ 164 165 /* Storing max wait in usecs saves 24 bytes per inode */ 166 u32 ls_max; /* Max wait in USEC */ 167 }; 168 #endif 169 170 struct ocfs2_lock_res { 171 void *l_priv; 172 struct ocfs2_lock_res_ops *l_ops; 173 174 175 struct list_head l_blocked_list; 176 struct list_head l_mask_waiters; 177 struct list_head l_holders; 178 179 unsigned long l_flags; 180 char l_name[OCFS2_LOCK_ID_MAX_LEN]; 181 unsigned int l_ro_holders; 182 unsigned int l_ex_holders; 183 signed char l_level; 184 signed char l_requested; 185 signed char l_blocking; 186 187 /* Data packed - type enum ocfs2_lock_type */ 188 unsigned char l_type; 189 190 /* used from AST/BAST funcs. */ 191 /* Data packed - enum type ocfs2_ast_action */ 192 unsigned char l_action; 193 /* Data packed - enum type ocfs2_unlock_action */ 194 unsigned char l_unlock_action; 195 unsigned int l_pending_gen; 196 197 spinlock_t l_lock; 198 199 struct ocfs2_dlm_lksb l_lksb; 200 201 wait_queue_head_t l_event; 202 203 struct list_head l_debug_list; 204 205 #ifdef CONFIG_OCFS2_FS_STATS 206 struct ocfs2_lock_stats l_lock_prmode; /* PR mode stats */ 207 u32 l_lock_refresh; /* Disk refreshes */ 208 struct ocfs2_lock_stats l_lock_exmode; /* EX mode stats */ 209 #endif 210 #ifdef CONFIG_DEBUG_LOCK_ALLOC 211 struct lockdep_map l_lockdep_map; 212 #endif 213 }; 214 215 enum ocfs2_orphan_reco_type { 216 ORPHAN_NO_NEED_TRUNCATE = 0, 217 ORPHAN_NEED_TRUNCATE, 218 }; 219 220 enum ocfs2_orphan_scan_state { 221 ORPHAN_SCAN_ACTIVE, 222 ORPHAN_SCAN_INACTIVE 223 }; 224 225 struct ocfs2_orphan_scan { 226 struct mutex os_lock; 227 struct ocfs2_super *os_osb; 228 struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */ 229 struct delayed_work os_orphan_scan_work; 230 time64_t os_scantime; /* time this node ran the scan */ 231 u32 os_count; /* tracks node specific scans */ 232 u32 os_seqno; /* tracks cluster wide scans */ 233 atomic_t os_state; /* ACTIVE or INACTIVE */ 234 }; 235 236 struct ocfs2_dlm_debug { 237 struct kref d_refcnt; 238 struct dentry *d_locking_state; 239 struct list_head d_lockres_tracking; 240 }; 241 242 enum ocfs2_vol_state 243 { 244 VOLUME_INIT = 0, 245 VOLUME_MOUNTED, 246 VOLUME_MOUNTED_QUOTAS, 247 VOLUME_DISMOUNTED, 248 VOLUME_DISABLED 249 }; 250 251 struct ocfs2_alloc_stats 252 { 253 atomic_t moves; 254 atomic_t local_data; 255 atomic_t bitmap_data; 256 atomic_t bg_allocs; 257 atomic_t bg_extends; 258 }; 259 260 enum ocfs2_local_alloc_state 261 { 262 OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for 263 * this mountpoint. */ 264 OCFS2_LA_ENABLED, /* Local alloc is in use. */ 265 OCFS2_LA_THROTTLED, /* Local alloc is in use, but number 266 * of bits has been reduced. */ 267 OCFS2_LA_DISABLED /* Local alloc has temporarily been 268 * disabled. */ 269 }; 270 271 enum ocfs2_mount_options 272 { 273 OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */ 274 OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */ 275 OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */ 276 OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */ 277 OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */ 278 OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */ 279 OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */ 280 OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */ 281 OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */ 282 OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access 283 control lists */ 284 OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */ 285 OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */ 286 OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT 287 writes */ 288 OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */ 289 OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */ 290 291 OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT = 1 << 15, /* Journal Async Commit */ 292 OCFS2_MOUNT_ERRORS_CONT = 1 << 16, /* Return EIO to the calling process on error */ 293 OCFS2_MOUNT_ERRORS_ROFS = 1 << 17, /* Change filesystem to read-only on error */ 294 }; 295 296 #define OCFS2_OSB_SOFT_RO 0x0001 297 #define OCFS2_OSB_HARD_RO 0x0002 298 #define OCFS2_OSB_ERROR_FS 0x0004 299 #define OCFS2_DEFAULT_ATIME_QUANTUM 60 300 301 struct ocfs2_journal; 302 struct ocfs2_slot_info; 303 struct ocfs2_recovery_map; 304 struct ocfs2_replay_map; 305 struct ocfs2_quota_recovery; 306 struct ocfs2_super 307 { 308 struct task_struct *commit_task; 309 struct super_block *sb; 310 struct inode *root_inode; 311 struct inode *sys_root_inode; 312 struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES]; 313 struct inode **local_system_inodes; 314 315 struct ocfs2_slot_info *slot_info; 316 317 u32 *slot_recovery_generations; 318 319 spinlock_t node_map_lock; 320 321 u64 root_blkno; 322 u64 system_dir_blkno; 323 u64 bitmap_blkno; 324 u32 bitmap_cpg; 325 char *uuid_str; 326 u32 uuid_hash; 327 u8 *vol_label; 328 u64 first_cluster_group_blkno; 329 u32 fs_generation; 330 331 u32 s_feature_compat; 332 u32 s_feature_incompat; 333 u32 s_feature_ro_compat; 334 335 /* Protects s_next_generation, osb_flags and s_inode_steal_slot. 336 * Could protect more on osb as it's very short lived. 337 */ 338 spinlock_t osb_lock; 339 u32 s_next_generation; 340 unsigned long osb_flags; 341 s16 s_inode_steal_slot; 342 s16 s_meta_steal_slot; 343 atomic_t s_num_inodes_stolen; 344 atomic_t s_num_meta_stolen; 345 346 unsigned long s_mount_opt; 347 unsigned int s_atime_quantum; 348 349 unsigned int max_slots; 350 unsigned int node_num; 351 int slot_num; 352 int preferred_slot; 353 int s_sectsize_bits; 354 int s_clustersize; 355 int s_clustersize_bits; 356 unsigned int s_xattr_inline_size; 357 358 atomic_t vol_state; 359 struct mutex recovery_lock; 360 struct ocfs2_recovery_map *recovery_map; 361 struct ocfs2_replay_map *replay_map; 362 struct task_struct *recovery_thread_task; 363 int disable_recovery; 364 wait_queue_head_t checkpoint_event; 365 struct ocfs2_journal *journal; 366 unsigned long osb_commit_interval; 367 368 struct delayed_work la_enable_wq; 369 370 /* 371 * Must hold local alloc i_mutex and osb->osb_lock to change 372 * local_alloc_bits. Reads can be done under either lock. 373 */ 374 unsigned int local_alloc_bits; 375 unsigned int local_alloc_default_bits; 376 /* osb_clusters_at_boot can become stale! Do not trust it to 377 * be up to date. */ 378 unsigned int osb_clusters_at_boot; 379 380 enum ocfs2_local_alloc_state local_alloc_state; /* protected 381 * by osb_lock */ 382 383 struct buffer_head *local_alloc_bh; 384 385 u64 la_last_gd; 386 387 struct ocfs2_reservation_map osb_la_resmap; 388 389 unsigned int osb_resv_level; 390 unsigned int osb_dir_resv_level; 391 392 /* Next two fields are for local node slot recovery during 393 * mount. */ 394 struct ocfs2_dinode *local_alloc_copy; 395 struct ocfs2_quota_recovery *quota_rec; 396 397 struct ocfs2_blockcheck_stats osb_ecc_stats; 398 struct ocfs2_alloc_stats alloc_stats; 399 char dev_str[20]; /* "major,minor" of the device */ 400 401 u8 osb_stackflags; 402 403 char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 404 char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1]; 405 struct ocfs2_cluster_connection *cconn; 406 struct ocfs2_lock_res osb_super_lockres; 407 struct ocfs2_lock_res osb_rename_lockres; 408 struct ocfs2_lock_res osb_nfs_sync_lockres; 409 struct ocfs2_lock_res osb_trim_fs_lockres; 410 struct ocfs2_dlm_debug *osb_dlm_debug; 411 412 struct dentry *osb_debug_root; 413 struct dentry *osb_ctxt; 414 415 wait_queue_head_t recovery_event; 416 417 spinlock_t dc_task_lock; 418 struct task_struct *dc_task; 419 wait_queue_head_t dc_event; 420 unsigned long dc_wake_sequence; 421 unsigned long dc_work_sequence; 422 423 /* 424 * Any thread can add locks to the list, but the downconvert 425 * thread is the only one allowed to remove locks. Any change 426 * to this rule requires updating 427 * ocfs2_downconvert_thread_do_work(). 428 */ 429 struct list_head blocked_lock_list; 430 unsigned long blocked_lock_count; 431 432 /* List of dquot structures to drop last reference to */ 433 struct llist_head dquot_drop_list; 434 struct work_struct dquot_drop_work; 435 436 wait_queue_head_t osb_mount_event; 437 438 /* Truncate log info */ 439 struct inode *osb_tl_inode; 440 struct buffer_head *osb_tl_bh; 441 struct delayed_work osb_truncate_log_wq; 442 atomic_t osb_tl_disable; 443 /* 444 * How many clusters in our truncate log. 445 * It must be protected by osb_tl_inode->i_mutex. 446 */ 447 unsigned int truncated_clusters; 448 449 struct ocfs2_node_map osb_recovering_orphan_dirs; 450 unsigned int *osb_orphan_wipes; 451 wait_queue_head_t osb_wipe_event; 452 453 struct ocfs2_orphan_scan osb_orphan_scan; 454 455 /* used to protect metaecc calculation check of xattr. */ 456 spinlock_t osb_xattr_lock; 457 458 unsigned int osb_dx_mask; 459 u32 osb_dx_seed[4]; 460 461 /* the group we used to allocate inodes. */ 462 u64 osb_inode_alloc_group; 463 464 /* rb tree root for refcount lock. */ 465 struct rb_root osb_rf_lock_tree; 466 struct ocfs2_refcount_tree *osb_ref_tree_lru; 467 468 struct mutex system_file_mutex; 469 470 /* 471 * OCFS2 needs to schedule several different types of work which 472 * require cluster locking, disk I/O, recovery waits, etc. Since these 473 * types of work tend to be heavy we avoid using the kernel events 474 * workqueue and schedule on our own. 475 */ 476 struct workqueue_struct *ocfs2_wq; 477 478 /* sysfs directory per partition */ 479 struct kset *osb_dev_kset; 480 481 /* file check related stuff */ 482 struct ocfs2_filecheck_sysfs_entry osb_fc_ent; 483 }; 484 485 #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 486 487 /* Useful typedef for passing around journal access functions */ 488 typedef int (*ocfs2_journal_access_func)(handle_t *handle, 489 struct ocfs2_caching_info *ci, 490 struct buffer_head *bh, int type); 491 492 static inline int ocfs2_should_order_data(struct inode *inode) 493 { 494 if (!S_ISREG(inode->i_mode)) 495 return 0; 496 if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 497 return 0; 498 return 1; 499 } 500 501 static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 502 { 503 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 504 return 1; 505 return 0; 506 } 507 508 static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 509 { 510 /* 511 * Support for sparse files is a pre-requisite 512 */ 513 if (!ocfs2_sparse_alloc(osb)) 514 return 0; 515 516 if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 517 return 1; 518 return 0; 519 } 520 521 static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb) 522 { 523 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_APPEND_DIO) 524 return 1; 525 return 0; 526 } 527 528 529 static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 530 { 531 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 532 return 1; 533 return 0; 534 } 535 536 static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 537 { 538 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 539 return 1; 540 return 0; 541 } 542 543 static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 544 { 545 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 546 return 1; 547 return 0; 548 } 549 550 static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 551 { 552 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 553 return 1; 554 return 0; 555 } 556 557 static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 558 { 559 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 560 return 1; 561 return 0; 562 } 563 564 static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 565 { 566 if (ocfs2_supports_indexed_dirs(osb)) 567 return OCFS2_DX_LINK_MAX; 568 return OCFS2_LINK_MAX; 569 } 570 571 static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 572 { 573 u32 nlink = le16_to_cpu(di->i_links_count); 574 u32 hi = le16_to_cpu(di->i_links_count_hi); 575 576 if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 577 nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 578 579 return nlink; 580 } 581 582 static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 583 { 584 u16 lo, hi; 585 586 lo = nlink; 587 hi = nlink >> OCFS2_LINKS_HI_SHIFT; 588 589 di->i_links_count = cpu_to_le16(lo); 590 di->i_links_count_hi = cpu_to_le16(hi); 591 } 592 593 static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 594 { 595 u32 links = ocfs2_read_links_count(di); 596 597 links += n; 598 599 ocfs2_set_links_count(di, links); 600 } 601 602 static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 603 { 604 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 605 return 1; 606 return 0; 607 } 608 609 /* set / clear functions because cluster events can make these happen 610 * in parallel so we want the transitions to be atomic. this also 611 * means that any future flags osb_flags must be protected by spinlock 612 * too! */ 613 static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 614 unsigned long flag) 615 { 616 spin_lock(&osb->osb_lock); 617 osb->osb_flags |= flag; 618 spin_unlock(&osb->osb_lock); 619 } 620 621 static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 622 int hard) 623 { 624 spin_lock(&osb->osb_lock); 625 osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 626 if (hard) 627 osb->osb_flags |= OCFS2_OSB_HARD_RO; 628 else 629 osb->osb_flags |= OCFS2_OSB_SOFT_RO; 630 spin_unlock(&osb->osb_lock); 631 } 632 633 static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 634 { 635 int ret; 636 637 spin_lock(&osb->osb_lock); 638 ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 639 spin_unlock(&osb->osb_lock); 640 641 return ret; 642 } 643 644 static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 645 { 646 int ret; 647 648 spin_lock(&osb->osb_lock); 649 ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 650 spin_unlock(&osb->osb_lock); 651 652 return ret; 653 } 654 655 static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb) 656 { 657 return (osb->s_feature_incompat & 658 (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK | 659 OCFS2_FEATURE_INCOMPAT_CLUSTERINFO)); 660 } 661 662 static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 663 { 664 if (ocfs2_clusterinfo_valid(osb) && 665 memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 666 OCFS2_STACK_LABEL_LEN)) 667 return 1; 668 return 0; 669 } 670 671 static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb) 672 { 673 if (ocfs2_clusterinfo_valid(osb) && 674 !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 675 OCFS2_STACK_LABEL_LEN)) 676 return 1; 677 return 0; 678 } 679 680 static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb) 681 { 682 return ocfs2_o2cb_stack(osb) && 683 (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT); 684 } 685 686 static inline int ocfs2_mount_local(struct ocfs2_super *osb) 687 { 688 return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 689 } 690 691 static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 692 { 693 return (osb->s_feature_incompat & 694 OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 695 } 696 697 698 #define OCFS2_IS_VALID_DINODE(ptr) \ 699 (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 700 701 #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 702 (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 703 704 #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 705 (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 706 707 708 #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 709 (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 710 711 #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 712 (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 713 714 #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 715 (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 716 717 #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 718 (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 719 720 #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 721 (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 722 723 static inline unsigned long ino_from_blkno(struct super_block *sb, 724 u64 blkno) 725 { 726 return (unsigned long)(blkno & (u64)ULONG_MAX); 727 } 728 729 static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 730 u32 clusters) 731 { 732 int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 733 sb->s_blocksize_bits; 734 735 return (u64)clusters << c_to_b_bits; 736 } 737 738 static inline u32 ocfs2_clusters_for_blocks(struct super_block *sb, 739 u64 blocks) 740 { 741 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 742 sb->s_blocksize_bits; 743 744 blocks += (1 << b_to_c_bits) - 1; 745 return (u32)(blocks >> b_to_c_bits); 746 } 747 748 static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 749 u64 blocks) 750 { 751 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 752 sb->s_blocksize_bits; 753 754 return (u32)(blocks >> b_to_c_bits); 755 } 756 757 static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 758 u64 bytes) 759 { 760 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 761 unsigned int clusters; 762 763 bytes += OCFS2_SB(sb)->s_clustersize - 1; 764 /* OCFS2 just cannot have enough clusters to overflow this */ 765 clusters = (unsigned int)(bytes >> cl_bits); 766 767 return clusters; 768 } 769 770 static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb, 771 u64 bytes) 772 { 773 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 774 unsigned int clusters; 775 776 clusters = (unsigned int)(bytes >> cl_bits); 777 return clusters; 778 } 779 780 static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 781 u64 bytes) 782 { 783 bytes += sb->s_blocksize - 1; 784 return bytes >> sb->s_blocksize_bits; 785 } 786 787 static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 788 u32 clusters) 789 { 790 return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 791 } 792 793 static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 794 u64 blocks) 795 { 796 int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 797 unsigned int clusters; 798 799 clusters = ocfs2_blocks_to_clusters(sb, blocks); 800 return (u64)clusters << bits; 801 } 802 803 static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 804 u64 bytes) 805 { 806 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 807 unsigned int clusters; 808 809 clusters = ocfs2_clusters_for_bytes(sb, bytes); 810 return (u64)clusters << cl_bits; 811 } 812 813 static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 814 u64 bytes) 815 { 816 u64 blocks; 817 818 blocks = ocfs2_blocks_for_bytes(sb, bytes); 819 return blocks << sb->s_blocksize_bits; 820 } 821 822 static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 823 { 824 return (unsigned long)((bytes + 511) >> 9); 825 } 826 827 static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 828 unsigned long pg_index) 829 { 830 u32 clusters = pg_index; 831 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 832 833 if (unlikely(PAGE_SHIFT > cbits)) 834 clusters = pg_index << (PAGE_SHIFT - cbits); 835 else if (PAGE_SHIFT < cbits) 836 clusters = pg_index >> (cbits - PAGE_SHIFT); 837 838 return clusters; 839 } 840 841 /* 842 * Find the 1st page index which covers the given clusters. 843 */ 844 static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 845 u32 clusters) 846 { 847 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 848 pgoff_t index = clusters; 849 850 if (PAGE_SHIFT > cbits) { 851 index = (pgoff_t)clusters >> (PAGE_SHIFT - cbits); 852 } else if (PAGE_SHIFT < cbits) { 853 index = (pgoff_t)clusters << (cbits - PAGE_SHIFT); 854 } 855 856 return index; 857 } 858 859 static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 860 { 861 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 862 unsigned int pages_per_cluster = 1; 863 864 if (PAGE_SHIFT < cbits) 865 pages_per_cluster = 1 << (cbits - PAGE_SHIFT); 866 867 return pages_per_cluster; 868 } 869 870 static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 871 unsigned int megs) 872 { 873 BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 874 875 return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 876 } 877 878 static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 879 unsigned int clusters) 880 { 881 return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 882 } 883 884 static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 885 { 886 __set_bit_le(bit, bitmap); 887 } 888 #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 889 890 static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 891 { 892 __clear_bit_le(bit, bitmap); 893 } 894 #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 895 896 #define ocfs2_test_bit test_bit_le 897 #define ocfs2_find_next_zero_bit find_next_zero_bit_le 898 #define ocfs2_find_next_bit find_next_bit_le 899 900 static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr) 901 { 902 #if BITS_PER_LONG == 64 903 *bit += ((unsigned long) addr & 7UL) << 3; 904 addr = (void *) ((unsigned long) addr & ~7UL); 905 #elif BITS_PER_LONG == 32 906 *bit += ((unsigned long) addr & 3UL) << 3; 907 addr = (void *) ((unsigned long) addr & ~3UL); 908 #else 909 #error "how many bits you are?!" 910 #endif 911 return addr; 912 } 913 914 static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap) 915 { 916 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 917 ocfs2_set_bit(bit, bitmap); 918 } 919 920 static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap) 921 { 922 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 923 ocfs2_clear_bit(bit, bitmap); 924 } 925 926 static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap) 927 { 928 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 929 return ocfs2_test_bit(bit, bitmap); 930 } 931 932 static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max, 933 int start) 934 { 935 int fix = 0, ret, tmpmax; 936 bitmap = correct_addr_and_bit_unaligned(&fix, bitmap); 937 tmpmax = max + fix; 938 start += fix; 939 940 ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix; 941 if (ret > max) 942 return max; 943 return ret; 944 } 945 946 #endif /* OCFS2_H */ 947 948