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 mutex obs_trim_fs_mutex; 411 struct ocfs2_dlm_debug *osb_dlm_debug; 412 413 struct dentry *osb_debug_root; 414 struct dentry *osb_ctxt; 415 416 wait_queue_head_t recovery_event; 417 418 spinlock_t dc_task_lock; 419 struct task_struct *dc_task; 420 wait_queue_head_t dc_event; 421 unsigned long dc_wake_sequence; 422 unsigned long dc_work_sequence; 423 424 /* 425 * Any thread can add locks to the list, but the downconvert 426 * thread is the only one allowed to remove locks. Any change 427 * to this rule requires updating 428 * ocfs2_downconvert_thread_do_work(). 429 */ 430 struct list_head blocked_lock_list; 431 unsigned long blocked_lock_count; 432 433 /* List of dquot structures to drop last reference to */ 434 struct llist_head dquot_drop_list; 435 struct work_struct dquot_drop_work; 436 437 wait_queue_head_t osb_mount_event; 438 439 /* Truncate log info */ 440 struct inode *osb_tl_inode; 441 struct buffer_head *osb_tl_bh; 442 struct delayed_work osb_truncate_log_wq; 443 atomic_t osb_tl_disable; 444 /* 445 * How many clusters in our truncate log. 446 * It must be protected by osb_tl_inode->i_mutex. 447 */ 448 unsigned int truncated_clusters; 449 450 struct ocfs2_node_map osb_recovering_orphan_dirs; 451 unsigned int *osb_orphan_wipes; 452 wait_queue_head_t osb_wipe_event; 453 454 struct ocfs2_orphan_scan osb_orphan_scan; 455 456 /* used to protect metaecc calculation check of xattr. */ 457 spinlock_t osb_xattr_lock; 458 459 unsigned int osb_dx_mask; 460 u32 osb_dx_seed[4]; 461 462 /* the group we used to allocate inodes. */ 463 u64 osb_inode_alloc_group; 464 465 /* rb tree root for refcount lock. */ 466 struct rb_root osb_rf_lock_tree; 467 struct ocfs2_refcount_tree *osb_ref_tree_lru; 468 469 struct mutex system_file_mutex; 470 471 /* 472 * OCFS2 needs to schedule several different types of work which 473 * require cluster locking, disk I/O, recovery waits, etc. Since these 474 * types of work tend to be heavy we avoid using the kernel events 475 * workqueue and schedule on our own. 476 */ 477 struct workqueue_struct *ocfs2_wq; 478 479 /* sysfs directory per partition */ 480 struct kset *osb_dev_kset; 481 482 /* file check related stuff */ 483 struct ocfs2_filecheck_sysfs_entry osb_fc_ent; 484 }; 485 486 #define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info) 487 488 /* Useful typedef for passing around journal access functions */ 489 typedef int (*ocfs2_journal_access_func)(handle_t *handle, 490 struct ocfs2_caching_info *ci, 491 struct buffer_head *bh, int type); 492 493 static inline int ocfs2_should_order_data(struct inode *inode) 494 { 495 if (!S_ISREG(inode->i_mode)) 496 return 0; 497 if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) 498 return 0; 499 return 1; 500 } 501 502 static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb) 503 { 504 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC) 505 return 1; 506 return 0; 507 } 508 509 static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb) 510 { 511 /* 512 * Support for sparse files is a pre-requisite 513 */ 514 if (!ocfs2_sparse_alloc(osb)) 515 return 0; 516 517 if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN) 518 return 1; 519 return 0; 520 } 521 522 static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb) 523 { 524 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_APPEND_DIO) 525 return 1; 526 return 0; 527 } 528 529 530 static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb) 531 { 532 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA) 533 return 1; 534 return 0; 535 } 536 537 static inline int ocfs2_supports_xattr(struct ocfs2_super *osb) 538 { 539 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR) 540 return 1; 541 return 0; 542 } 543 544 static inline int ocfs2_meta_ecc(struct ocfs2_super *osb) 545 { 546 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC) 547 return 1; 548 return 0; 549 } 550 551 static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb) 552 { 553 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS) 554 return 1; 555 return 0; 556 } 557 558 static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb) 559 { 560 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG) 561 return 1; 562 return 0; 563 } 564 565 static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb) 566 { 567 if (ocfs2_supports_indexed_dirs(osb)) 568 return OCFS2_DX_LINK_MAX; 569 return OCFS2_LINK_MAX; 570 } 571 572 static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di) 573 { 574 u32 nlink = le16_to_cpu(di->i_links_count); 575 u32 hi = le16_to_cpu(di->i_links_count_hi); 576 577 if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL)) 578 nlink |= (hi << OCFS2_LINKS_HI_SHIFT); 579 580 return nlink; 581 } 582 583 static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink) 584 { 585 u16 lo, hi; 586 587 lo = nlink; 588 hi = nlink >> OCFS2_LINKS_HI_SHIFT; 589 590 di->i_links_count = cpu_to_le16(lo); 591 di->i_links_count_hi = cpu_to_le16(hi); 592 } 593 594 static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n) 595 { 596 u32 links = ocfs2_read_links_count(di); 597 598 links += n; 599 600 ocfs2_set_links_count(di, links); 601 } 602 603 static inline int ocfs2_refcount_tree(struct ocfs2_super *osb) 604 { 605 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE) 606 return 1; 607 return 0; 608 } 609 610 /* set / clear functions because cluster events can make these happen 611 * in parallel so we want the transitions to be atomic. this also 612 * means that any future flags osb_flags must be protected by spinlock 613 * too! */ 614 static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb, 615 unsigned long flag) 616 { 617 spin_lock(&osb->osb_lock); 618 osb->osb_flags |= flag; 619 spin_unlock(&osb->osb_lock); 620 } 621 622 static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb, 623 int hard) 624 { 625 spin_lock(&osb->osb_lock); 626 osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO); 627 if (hard) 628 osb->osb_flags |= OCFS2_OSB_HARD_RO; 629 else 630 osb->osb_flags |= OCFS2_OSB_SOFT_RO; 631 spin_unlock(&osb->osb_lock); 632 } 633 634 static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb) 635 { 636 int ret; 637 638 spin_lock(&osb->osb_lock); 639 ret = osb->osb_flags & OCFS2_OSB_HARD_RO; 640 spin_unlock(&osb->osb_lock); 641 642 return ret; 643 } 644 645 static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb) 646 { 647 int ret; 648 649 spin_lock(&osb->osb_lock); 650 ret = osb->osb_flags & OCFS2_OSB_SOFT_RO; 651 spin_unlock(&osb->osb_lock); 652 653 return ret; 654 } 655 656 static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb) 657 { 658 return (osb->s_feature_incompat & 659 (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK | 660 OCFS2_FEATURE_INCOMPAT_CLUSTERINFO)); 661 } 662 663 static inline int ocfs2_userspace_stack(struct ocfs2_super *osb) 664 { 665 if (ocfs2_clusterinfo_valid(osb) && 666 memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 667 OCFS2_STACK_LABEL_LEN)) 668 return 1; 669 return 0; 670 } 671 672 static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb) 673 { 674 if (ocfs2_clusterinfo_valid(osb) && 675 !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK, 676 OCFS2_STACK_LABEL_LEN)) 677 return 1; 678 return 0; 679 } 680 681 static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb) 682 { 683 return ocfs2_o2cb_stack(osb) && 684 (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT); 685 } 686 687 static inline int ocfs2_mount_local(struct ocfs2_super *osb) 688 { 689 return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT); 690 } 691 692 static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb) 693 { 694 return (osb->s_feature_incompat & 695 OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP); 696 } 697 698 699 #define OCFS2_IS_VALID_DINODE(ptr) \ 700 (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE)) 701 702 #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \ 703 (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE)) 704 705 #define OCFS2_IS_VALID_GROUP_DESC(ptr) \ 706 (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE)) 707 708 709 #define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \ 710 (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE)) 711 712 #define OCFS2_IS_VALID_DIR_TRAILER(ptr) \ 713 (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE)) 714 715 #define OCFS2_IS_VALID_DX_ROOT(ptr) \ 716 (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE)) 717 718 #define OCFS2_IS_VALID_DX_LEAF(ptr) \ 719 (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE)) 720 721 #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \ 722 (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE)) 723 724 static inline unsigned long ino_from_blkno(struct super_block *sb, 725 u64 blkno) 726 { 727 return (unsigned long)(blkno & (u64)ULONG_MAX); 728 } 729 730 static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb, 731 u32 clusters) 732 { 733 int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits - 734 sb->s_blocksize_bits; 735 736 return (u64)clusters << c_to_b_bits; 737 } 738 739 static inline u32 ocfs2_clusters_for_blocks(struct super_block *sb, 740 u64 blocks) 741 { 742 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 743 sb->s_blocksize_bits; 744 745 blocks += (1 << b_to_c_bits) - 1; 746 return (u32)(blocks >> b_to_c_bits); 747 } 748 749 static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb, 750 u64 blocks) 751 { 752 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits - 753 sb->s_blocksize_bits; 754 755 return (u32)(blocks >> b_to_c_bits); 756 } 757 758 static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb, 759 u64 bytes) 760 { 761 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 762 unsigned int clusters; 763 764 bytes += OCFS2_SB(sb)->s_clustersize - 1; 765 /* OCFS2 just cannot have enough clusters to overflow this */ 766 clusters = (unsigned int)(bytes >> cl_bits); 767 768 return clusters; 769 } 770 771 static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb, 772 u64 bytes) 773 { 774 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 775 unsigned int clusters; 776 777 clusters = (unsigned int)(bytes >> cl_bits); 778 return clusters; 779 } 780 781 static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb, 782 u64 bytes) 783 { 784 bytes += sb->s_blocksize - 1; 785 return bytes >> sb->s_blocksize_bits; 786 } 787 788 static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb, 789 u32 clusters) 790 { 791 return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits; 792 } 793 794 static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb, 795 u64 blocks) 796 { 797 int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits; 798 unsigned int clusters; 799 800 clusters = ocfs2_blocks_to_clusters(sb, blocks); 801 return (u64)clusters << bits; 802 } 803 804 static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb, 805 u64 bytes) 806 { 807 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits; 808 unsigned int clusters; 809 810 clusters = ocfs2_clusters_for_bytes(sb, bytes); 811 return (u64)clusters << cl_bits; 812 } 813 814 static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb, 815 u64 bytes) 816 { 817 u64 blocks; 818 819 blocks = ocfs2_blocks_for_bytes(sb, bytes); 820 return blocks << sb->s_blocksize_bits; 821 } 822 823 static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes) 824 { 825 return (unsigned long)((bytes + 511) >> 9); 826 } 827 828 static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb, 829 unsigned long pg_index) 830 { 831 u32 clusters = pg_index; 832 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 833 834 if (unlikely(PAGE_SHIFT > cbits)) 835 clusters = pg_index << (PAGE_SHIFT - cbits); 836 else if (PAGE_SHIFT < cbits) 837 clusters = pg_index >> (cbits - PAGE_SHIFT); 838 839 return clusters; 840 } 841 842 /* 843 * Find the 1st page index which covers the given clusters. 844 */ 845 static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb, 846 u32 clusters) 847 { 848 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 849 pgoff_t index = clusters; 850 851 if (PAGE_SHIFT > cbits) { 852 index = (pgoff_t)clusters >> (PAGE_SHIFT - cbits); 853 } else if (PAGE_SHIFT < cbits) { 854 index = (pgoff_t)clusters << (cbits - PAGE_SHIFT); 855 } 856 857 return index; 858 } 859 860 static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb) 861 { 862 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits; 863 unsigned int pages_per_cluster = 1; 864 865 if (PAGE_SHIFT < cbits) 866 pages_per_cluster = 1 << (cbits - PAGE_SHIFT); 867 868 return pages_per_cluster; 869 } 870 871 static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb, 872 unsigned int megs) 873 { 874 BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576); 875 876 return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits); 877 } 878 879 static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb, 880 unsigned int clusters) 881 { 882 return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits); 883 } 884 885 static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap) 886 { 887 __set_bit_le(bit, bitmap); 888 } 889 #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr)) 890 891 static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap) 892 { 893 __clear_bit_le(bit, bitmap); 894 } 895 #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr)) 896 897 #define ocfs2_test_bit test_bit_le 898 #define ocfs2_find_next_zero_bit find_next_zero_bit_le 899 #define ocfs2_find_next_bit find_next_bit_le 900 901 static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr) 902 { 903 #if BITS_PER_LONG == 64 904 *bit += ((unsigned long) addr & 7UL) << 3; 905 addr = (void *) ((unsigned long) addr & ~7UL); 906 #elif BITS_PER_LONG == 32 907 *bit += ((unsigned long) addr & 3UL) << 3; 908 addr = (void *) ((unsigned long) addr & ~3UL); 909 #else 910 #error "how many bits you are?!" 911 #endif 912 return addr; 913 } 914 915 static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap) 916 { 917 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 918 ocfs2_set_bit(bit, bitmap); 919 } 920 921 static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap) 922 { 923 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 924 ocfs2_clear_bit(bit, bitmap); 925 } 926 927 static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap) 928 { 929 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap); 930 return ocfs2_test_bit(bit, bitmap); 931 } 932 933 static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max, 934 int start) 935 { 936 int fix = 0, ret, tmpmax; 937 bitmap = correct_addr_and_bit_unaligned(&fix, bitmap); 938 tmpmax = max + fix; 939 start += fix; 940 941 ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix; 942 if (ret > max) 943 return max; 944 return ret; 945 } 946 947 #endif /* OCFS2_H */ 948 949