ocfs2.h

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