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