ocfs2.h 25 KB

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