blob: 4f86ac0027b5ba376495e3bf859c8e8f57ccf452 [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- 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>
Jan Karae3a767b2014-04-03 14:46:56 -070033#include <linux/llist.h>
Mark Fashehccd979b2005-12-15 14:31:24 -080034#include <linux/rbtree.h>
35#include <linux/workqueue.h>
36#include <linux/kref.h>
Arjan van de Venc74ec2f2006-01-13 21:54:23 -080037#include <linux/mutex.h>
Jan Karacb257972009-06-04 15:26:50 +020038#include <linux/lockdep.h>
Sunil Mushran7aee47b2009-11-06 14:50:22 -080039#include <linux/jbd2.h>
Mark Fashehccd979b2005-12-15 14:31:24 -080040
Joel Becker8f2c9c12008-02-01 12:16:57 -080041/* For union ocfs2_dlm_lksb */
42#include "stackglue.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080043
44#include "ocfs2_fs.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080045#include "ocfs2_lockid.h"
Tristan Ye9df57782010-03-02 13:59:42 +080046#include "ocfs2_ioctl.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080047
Joel Becker73be1922009-01-06 14:57:08 -080048/* For struct ocfs2_blockcheck_stats */
49#include "blockcheck.h"
50
Mark Fashehd02f00c2009-12-07 13:10:48 -080051#include "reservations.h"
Joel Becker47460d62009-02-10 16:05:07 -080052
Gang He5f483c42018-04-05 16:19:29 -070053#include "filecheck.h"
54
Joel Becker47460d62009-02-10 16:05:07 -080055/* Caching of metadata buffers */
56
Mark Fashehccd979b2005-12-15 14:31:24 -080057/* 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. */
Joel Becker47460d62009-02-10 16:05:07 -080062#define OCFS2_CACHE_INFO_MAX_ARRAY 2
63
64/* Flags for ocfs2_caching_info */
65
66enum ocfs2_caching_info_flags {
67 /* Indicates that the metadata cache is using the inline array */
68 OCFS2_CACHE_FL_INLINE = 1<<1,
69};
Mark Fashehccd979b2005-12-15 14:31:24 -080070
Joel Becker6e5a3d72009-02-10 19:00:37 -080071struct ocfs2_caching_operations;
Mark Fashehccd979b2005-12-15 14:31:24 -080072struct ocfs2_caching_info {
Joel Becker47460d62009-02-10 16:05:07 -080073 /*
74 * The parent structure provides the locks, but because the
Joel Becker6e5a3d72009-02-10 19:00:37 -080075 * parent structure can differ, it provides locking operations
76 * to struct ocfs2_caching_info.
Joel Becker47460d62009-02-10 16:05:07 -080077 */
Joel Becker6e5a3d72009-02-10 19:00:37 -080078 const struct ocfs2_caching_operations *ci_ops;
Joel Becker47460d62009-02-10 16:05:07 -080079
Joel Becker292dd272009-02-12 15:41:59 -080080 /* next two are protected by trans_inc_lock */
81 /* which transaction were we created on? Zero if none. */
82 unsigned long ci_created_trans;
Joel Becker66fb3452009-02-12 15:24:40 -080083 /* last transaction we were a part of. */
84 unsigned long ci_last_trans;
85
86 /* Cache structures */
Joel Becker47460d62009-02-10 16:05:07 -080087 unsigned int ci_flags;
Mark Fashehccd979b2005-12-15 14:31:24 -080088 unsigned int ci_num_cached;
89 union {
Joel Becker47460d62009-02-10 16:05:07 -080090 sector_t ci_array[OCFS2_CACHE_INFO_MAX_ARRAY];
Mark Fashehccd979b2005-12-15 14:31:24 -080091 struct rb_root ci_tree;
92 } ci_cache;
93};
Joel Becker0cf2f762009-02-12 16:41:25 -080094/*
95 * Need this prototype here instead of in uptodate.h because journal.h
96 * uses it.
97 */
98struct super_block *ocfs2_metadata_cache_get_super(struct ocfs2_caching_info *ci);
Mark Fashehccd979b2005-12-15 14:31:24 -080099
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
103struct ocfs2_node_map {
104 u16 num_nodes;
105 unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)];
106};
107
108enum 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. */
116enum 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. */
Coly Li3b5da012008-11-05 15:16:24 +0800123#define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized
Mark Fashehccd979b2005-12-15 14:31:24 -0800124 * 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 */
Mark Fashehcf8e06f2007-12-20 16:43:10 -0800140#define OCFS2_LOCK_NOCACHE (0x00000200) /* don't use a holder count */
Joel Beckerde551242008-02-01 14:45:08 -0800141#define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a
142 call to dlm_lock. Only
143 exists with BUSY set. */
Sunil Mushrana1912822010-01-21 10:50:03 -0800144#define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread
145 * from downconverting
146 * before the upconvert
147 * has completed */
Mark Fashehccd979b2005-12-15 14:31:24 -0800148
Xue jiufeid1e782382014-12-10 15:41:59 -0800149#define OCFS2_LOCK_NONBLOCK_FINISHED (0x00001000) /* NONBLOCK cluster
150 * lock has already
151 * returned, do not block
152 * dc thread from
153 * downconverting */
154
Mark Fashehccd979b2005-12-15 14:31:24 -0800155struct ocfs2_lock_res_ops;
156
157typedef void (*ocfs2_lock_callback)(int status, unsigned long data);
158
Sunil Mushran5bc970e2010-12-28 23:26:03 -0800159#ifdef CONFIG_OCFS2_FS_STATS
160struct 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
Mark Fashehccd979b2005-12-15 14:31:24 -0800170struct ocfs2_lock_res {
171 void *l_priv;
172 struct ocfs2_lock_res_ops *l_ops;
Goldwyn Rodrigues83fd9c72010-06-10 17:21:36 -0500173
Mark Fashehccd979b2005-12-15 14:31:24 -0800174
175 struct list_head l_blocked_list;
176 struct list_head l_mask_waiters;
Eric Ren439a36b2017-02-22 15:40:41 -0800177 struct list_head l_holders;
Mark Fashehccd979b2005-12-15 14:31:24 -0800178
Mark Fashehccd979b2005-12-15 14:31:24 -0800179 unsigned long l_flags;
180 char l_name[OCFS2_LOCK_ID_MAX_LEN];
Mark Fashehccd979b2005-12-15 14:31:24 -0800181 unsigned int l_ro_holders;
182 unsigned int l_ex_holders;
Milton Millera2a2f552010-11-17 22:20:11 -0600183 signed char l_level;
184 signed char l_requested;
185 signed char l_blocking;
Goldwyn Rodrigues83fd9c72010-06-10 17:21:36 -0500186
187 /* Data packed - type enum ocfs2_lock_type */
188 unsigned char l_type;
Mark Fashehccd979b2005-12-15 14:31:24 -0800189
190 /* used from AST/BAST funcs. */
Goldwyn Rodrigues83fd9c72010-06-10 17:21:36 -0500191 /* 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;
Joel Beckerde551242008-02-01 14:45:08 -0800195 unsigned int l_pending_gen;
Mark Fashehccd979b2005-12-15 14:31:24 -0800196
Goldwyn Rodrigues83fd9c72010-06-10 17:21:36 -0500197 spinlock_t l_lock;
198
199 struct ocfs2_dlm_lksb l_lksb;
200
Mark Fashehccd979b2005-12-15 14:31:24 -0800201 wait_queue_head_t l_event;
202
203 struct list_head l_debug_list;
Sunil Mushran8ddb7b02008-05-13 13:45:15 -0700204
205#ifdef CONFIG_OCFS2_FS_STATS
Sunil Mushran5bc970e2010-12-28 23:26:03 -0800206 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 */
Sunil Mushran8ddb7b02008-05-13 13:45:15 -0700209#endif
Jan Karacb257972009-06-04 15:26:50 +0200210#ifdef CONFIG_DEBUG_LOCK_ALLOC
211 struct lockdep_map l_lockdep_map;
212#endif
Mark Fashehccd979b2005-12-15 14:31:24 -0800213};
214
Joseph Qied460cf2015-02-16 15:59:57 -0800215enum ocfs2_orphan_reco_type {
216 ORPHAN_NO_NEED_TRUNCATE = 0,
217 ORPHAN_NEED_TRUNCATE,
218};
219
Sunil Mushran692684e2009-06-19 16:53:17 -0700220enum ocfs2_orphan_scan_state {
221 ORPHAN_SCAN_ACTIVE,
222 ORPHAN_SCAN_INACTIVE
223};
224
Srinivas Eeda83273932009-06-03 17:02:55 -0700225struct 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;
Deepa Dinamani395627b2016-12-12 16:41:23 -0800230 time64_t os_scantime; /* time this node ran the scan */
Srinivas Eeda15633a22009-06-03 17:02:56 -0700231 u32 os_count; /* tracks node specific scans */
232 u32 os_seqno; /* tracks cluster wide scans */
Sunil Mushran692684e2009-06-19 16:53:17 -0700233 atomic_t os_state; /* ACTIVE or INACTIVE */
Srinivas Eeda83273932009-06-03 17:02:55 -0700234};
235
Mark Fashehccd979b2005-12-15 14:31:24 -0800236struct ocfs2_dlm_debug {
237 struct kref d_refcnt;
238 struct dentry *d_locking_state;
239 struct list_head d_lockres_tracking;
240};
241
242enum ocfs2_vol_state
243{
244 VOLUME_INIT = 0,
245 VOLUME_MOUNTED,
Jan Kara19ece542008-08-21 20:13:17 +0200246 VOLUME_MOUNTED_QUOTAS,
Mark Fashehccd979b2005-12-15 14:31:24 -0800247 VOLUME_DISMOUNTED,
248 VOLUME_DISABLED
249};
250
251struct 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
260enum ocfs2_local_alloc_state
261{
Mark Fasheh9c7af402008-07-28 18:02:53 -0700262 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. */
Mark Fashehccd979b2005-12-15 14:31:24 -0800269};
270
271enum ocfs2_mount_options
272{
Sunil Mushran2c442712010-10-07 15:23:50 -0700273 OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */
Mark Fashehccd979b2005-12-15 14:31:24 -0800274 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 */
Mark Fasheh53fc6222007-12-20 16:49:04 -0800278 OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */
Tiger Yangcf1d6c72008-08-18 17:11:00 +0800279 OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */
Joel Becker12462f12008-09-03 20:03:40 -0700280 OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */
Jan Kara5297aad2009-10-15 14:54:04 +0200281 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 */
Joel Beckerfc371892010-10-15 13:03:09 -0700286 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 */
alex chen1dfeb762015-02-10 14:09:04 -0800290
291 OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT = 1 << 15, /* Journal Async Commit */
Goldwyn Rodrigues7d0fb912015-09-04 15:44:11 -0700292 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 */
Mark Fashehccd979b2005-12-15 14:31:24 -0800294};
295
Goldwyn Rodrigues8ed6b232014-04-03 14:46:59 -0700296#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
Mark Fashehccd979b2005-12-15 14:31:24 -0800300
301struct ocfs2_journal;
Joel Beckerd85b20e2008-02-01 12:01:05 -0800302struct ocfs2_slot_info;
Joel Becker553abd02008-02-01 12:03:57 -0800303struct ocfs2_recovery_map;
Srinivas Eeda9140db02009-03-06 14:21:46 -0800304struct ocfs2_replay_map;
Jan Kara22053632008-10-20 23:50:38 +0200305struct ocfs2_quota_recovery;
Mark Fashehccd979b2005-12-15 14:31:24 -0800306struct ocfs2_super
307{
Mark Fashehccd979b2005-12-15 14:31:24 -0800308 struct task_struct *commit_task;
309 struct super_block *sb;
310 struct inode *root_inode;
311 struct inode *sys_root_inode;
Tao Mab4d693f2010-08-16 16:58:21 +0800312 struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES];
313 struct inode **local_system_inodes;
Mark Fashehccd979b2005-12-15 14:31:24 -0800314
315 struct ocfs2_slot_info *slot_info;
316
Sunil Mushran539d8262008-07-14 17:31:10 -0700317 u32 *slot_recovery_generations;
318
Mark Fashehccd979b2005-12-15 14:31:24 -0800319 spinlock_t node_map_lock;
Mark Fashehccd979b2005-12-15 14:31:24 -0800320
Mark Fashehccd979b2005-12-15 14:31:24 -0800321 u64 root_blkno;
322 u64 system_dir_blkno;
323 u64 bitmap_blkno;
324 u32 bitmap_cpg;
Mark Fashehccd979b2005-12-15 14:31:24 -0800325 char *uuid_str;
Tiger Yangcf1d6c72008-08-18 17:11:00 +0800326 u32 uuid_hash;
Mark Fashehccd979b2005-12-15 14:31:24 -0800327 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
Tao Ma4d0ddb22008-03-05 16:11:46 +0800335 /* Protects s_next_generation, osb_flags and s_inode_steal_slot.
336 * Could protect more on osb as it's very short lived.
337 */
Mark Fashehccd979b2005-12-15 14:31:24 -0800338 spinlock_t osb_lock;
339 u32 s_next_generation;
340 unsigned long osb_flags;
Tao Ma4d0ddb22008-03-05 16:11:46 +0800341 s16 s_inode_steal_slot;
Tiger Yangb89c5422010-01-25 14:11:06 +0800342 s16 s_meta_steal_slot;
Tao Ma4d0ddb22008-03-05 16:11:46 +0800343 atomic_t s_num_inodes_stolen;
Tiger Yangb89c5422010-01-25 14:11:06 +0800344 atomic_t s_num_meta_stolen;
Mark Fashehccd979b2005-12-15 14:31:24 -0800345
346 unsigned long s_mount_opt;
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800347 unsigned int s_atime_quantum;
Mark Fashehccd979b2005-12-15 14:31:24 -0800348
Joel Beckerfc881fa2008-02-01 12:04:48 -0800349 unsigned int max_slots;
Joel Becker19fdb622008-01-30 15:38:24 -0800350 unsigned int node_num;
Joel Beckerfc881fa2008-02-01 12:04:48 -0800351 int slot_num;
352 int preferred_slot;
Mark Fashehccd979b2005-12-15 14:31:24 -0800353 int s_sectsize_bits;
354 int s_clustersize;
355 int s_clustersize_bits;
Tiger Yangfdd77702008-08-18 17:08:55 +0800356 unsigned int s_xattr_inline_size;
Mark Fashehccd979b2005-12-15 14:31:24 -0800357
358 atomic_t vol_state;
Arjan van de Venc74ec2f2006-01-13 21:54:23 -0800359 struct mutex recovery_lock;
Joel Becker553abd02008-02-01 12:03:57 -0800360 struct ocfs2_recovery_map *recovery_map;
Srinivas Eeda9140db02009-03-06 14:21:46 -0800361 struct ocfs2_replay_map *replay_map;
Mark Fashehccd979b2005-12-15 14:31:24 -0800362 struct task_struct *recovery_thread_task;
363 int disable_recovery;
364 wait_queue_head_t checkpoint_event;
Mark Fashehccd979b2005-12-15 14:31:24 -0800365 struct ocfs2_journal *journal;
Mark Fashehd147b3d2007-11-07 14:40:36 -0800366 unsigned long osb_commit_interval;
Mark Fashehccd979b2005-12-15 14:31:24 -0800367
Mark Fasheh9c7af402008-07-28 18:02:53 -0700368 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 */
Mark Fashehebcee4b2008-07-28 14:55:20 -0700374 unsigned int local_alloc_bits;
Mark Fasheh9c7af402008-07-28 18:02:53 -0700375 unsigned int local_alloc_default_bits;
Mark Fasheh6b820212010-04-05 18:17:14 -0700376 /* osb_clusters_at_boot can become stale! Do not trust it to
377 * be up to date. */
378 unsigned int osb_clusters_at_boot;
Mark Fasheh9c7af402008-07-28 18:02:53 -0700379
380 enum ocfs2_local_alloc_state local_alloc_state; /* protected
381 * by osb_lock */
382
Mark Fashehccd979b2005-12-15 14:31:24 -0800383 struct buffer_head *local_alloc_bh;
Mark Fasheh9c7af402008-07-28 18:02:53 -0700384
Mark Fasheh883d4ca2006-06-05 16:41:00 -0400385 u64 la_last_gd;
Mark Fashehccd979b2005-12-15 14:31:24 -0800386
Mark Fashehd02f00c2009-12-07 13:10:48 -0800387 struct ocfs2_reservation_map osb_la_resmap;
388
389 unsigned int osb_resv_level;
Mark Fasheh83f92312010-04-05 18:17:16 -0700390 unsigned int osb_dir_resv_level;
Mark Fashehd02f00c2009-12-07 13:10:48 -0800391
Jun Piao964f14a2017-09-06 16:19:11 -0700392 /* Next two fields are for local node slot recovery during
Mark Fashehccd979b2005-12-15 14:31:24 -0800393 * mount. */
Mark Fashehccd979b2005-12-15 14:31:24 -0800394 struct ocfs2_dinode *local_alloc_copy;
Jan Kara22053632008-10-20 23:50:38 +0200395 struct ocfs2_quota_recovery *quota_rec;
Mark Fashehccd979b2005-12-15 14:31:24 -0800396
Joel Becker73be1922009-01-06 14:57:08 -0800397 struct ocfs2_blockcheck_stats osb_ecc_stats;
Mark Fashehccd979b2005-12-15 14:31:24 -0800398 struct ocfs2_alloc_stats alloc_stats;
399 char dev_str[20]; /* "major,minor" of the device */
400
Sunil Mushran98f486f22010-10-09 10:24:46 -0700401 u8 osb_stackflags;
402
Joel Beckerb61817e2008-02-01 15:08:23 -0800403 char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
Goldwyn Rodriguesc74a3bd2014-01-21 15:48:21 -0800404 char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1];
Joel Becker4670c462008-02-01 14:39:35 -0800405 struct ocfs2_cluster_connection *cconn;
Mark Fashehccd979b2005-12-15 14:31:24 -0800406 struct ocfs2_lock_res osb_super_lockres;
407 struct ocfs2_lock_res osb_rename_lockres;
wengang wang6ca497a2009-03-06 21:29:10 +0800408 struct ocfs2_lock_res osb_nfs_sync_lockres;
Gang He4882abe2018-01-31 16:15:10 -0800409 struct ocfs2_lock_res osb_trim_fs_lockres;
Mark Fashehccd979b2005-12-15 14:31:24 -0800410 struct ocfs2_dlm_debug *osb_dlm_debug;
411
412 struct dentry *osb_debug_root;
Sunil Mushran50397502008-12-17 14:17:43 -0800413 struct dentry *osb_ctxt;
Mark Fashehccd979b2005-12-15 14:31:24 -0800414
415 wait_queue_head_t recovery_event;
416
Mark Fasheh34d024f2007-09-24 15:56:19 -0700417 spinlock_t dc_task_lock;
418 struct task_struct *dc_task;
419 wait_queue_head_t dc_event;
420 unsigned long dc_wake_sequence;
421 unsigned long dc_work_sequence;
Mark Fashehccd979b2005-12-15 14:31:24 -0800422
Mark Fasheh7ec373c2008-01-23 16:54:48 -0800423 /*
424 * Any thread can add locks to the list, but the downconvert
425 * thread is the only one allowed to remove locks. Any change
426 * to this rule requires updating
427 * ocfs2_downconvert_thread_do_work().
428 */
Mark Fashehccd979b2005-12-15 14:31:24 -0800429 struct list_head blocked_lock_list;
430 unsigned long blocked_lock_count;
431
Jan Karae3a767b2014-04-03 14:46:56 -0700432 /* List of dquot structures to drop last reference to */
433 struct llist_head dquot_drop_list;
434 struct work_struct dquot_drop_work;
435
Mark Fashehccd979b2005-12-15 14:31:24 -0800436 wait_queue_head_t osb_mount_event;
437
438 /* Truncate log info */
439 struct inode *osb_tl_inode;
440 struct buffer_head *osb_tl_bh;
David Howellsc4028952006-11-22 14:57:56 +0000441 struct delayed_work osb_truncate_log_wq;
Xue jiufeia9e9aca2014-06-04 16:06:13 -0700442 atomic_t osb_tl_disable;
Tao Ma50308d82010-11-04 15:14:11 +0800443 /*
444 * How many clusters in our truncate log.
445 * It must be protected by osb_tl_inode->i_mutex.
446 */
447 unsigned int truncated_clusters;
Mark Fashehb4df6ed2006-02-22 17:35:08 -0800448
449 struct ocfs2_node_map osb_recovering_orphan_dirs;
450 unsigned int *osb_orphan_wipes;
451 wait_queue_head_t osb_wipe_event;
Tao Mac8b9cf92009-02-24 17:40:26 -0800452
Srinivas Eeda83273932009-06-03 17:02:55 -0700453 struct ocfs2_orphan_scan osb_orphan_scan;
454
Tao Mac8b9cf92009-02-24 17:40:26 -0800455 /* used to protect metaecc calculation check of xattr. */
456 spinlock_t osb_xattr_lock;
Mark Fasheh9b7895e2008-11-12 16:27:44 -0800457
458 unsigned int osb_dx_mask;
459 u32 osb_dx_seed[4];
Tao Mafeb473a2009-02-25 00:53:25 +0800460
461 /* the group we used to allocate inodes. */
462 u64 osb_inode_alloc_group;
Tao Ma374a2632009-08-24 11:13:37 +0800463
464 /* rb tree root for refcount lock. */
465 struct rb_root osb_rf_lock_tree;
466 struct ocfs2_refcount_tree *osb_ref_tree_lru;
jiangyiwen43b10a202014-04-03 14:47:13 -0700467
468 struct mutex system_file_mutex;
jiangyiwen35ddf782016-03-25 14:21:32 -0700469
470 /*
471 * OCFS2 needs to schedule several different types of work which
472 * require cluster locking, disk I/O, recovery waits, etc. Since these
473 * types of work tend to be heavy we avoid using the kernel events
474 * workqueue and schedule on our own.
475 */
476 struct workqueue_struct *ocfs2_wq;
Gang He5f483c42018-04-05 16:19:29 -0700477
478 /* sysfs directory per partition */
479 struct kset *osb_dev_kset;
480
481 /* file check related stuff */
482 struct ocfs2_filecheck_sysfs_entry osb_fc_ent;
Mark Fashehccd979b2005-12-15 14:31:24 -0800483};
484
485#define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info)
Mark Fashehccd979b2005-12-15 14:31:24 -0800486
Joel Becker13723d02008-10-17 19:25:01 -0700487/* Useful typedef for passing around journal access functions */
Joel Becker0cf2f762009-02-12 16:41:25 -0800488typedef int (*ocfs2_journal_access_func)(handle_t *handle,
489 struct ocfs2_caching_info *ci,
Joel Becker13723d02008-10-17 19:25:01 -0700490 struct buffer_head *bh, int type);
491
Mark Fashehccd979b2005-12-15 14:31:24 -0800492static inline int ocfs2_should_order_data(struct inode *inode)
493{
494 if (!S_ISREG(inode->i_mode))
495 return 0;
496 if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)
497 return 0;
498 return 1;
499}
500
Mark Fashehdcd05382007-01-16 11:32:23 -0800501static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb)
502{
503 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC)
504 return 1;
505 return 0;
506}
507
Mark Fasheh328d5752007-06-18 10:48:04 -0700508static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb)
509{
510 /*
511 * Support for sparse files is a pre-requisite
512 */
513 if (!ocfs2_sparse_alloc(osb))
514 return 0;
515
516 if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN)
517 return 1;
518 return 0;
519}
520
Joseph Qi160cc262015-02-16 16:00:15 -0800521static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb)
522{
Mark Fasheh18d585f2015-03-12 16:25:46 -0700523 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_APPEND_DIO)
Joseph Qi160cc262015-02-16 16:00:15 -0800524 return 1;
525 return 0;
526}
527
528
Mark Fasheh15b1e362007-09-07 13:58:15 -0700529static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb)
530{
531 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA)
532 return 1;
533 return 0;
534}
535
Tiger Yang8154da32008-08-18 17:11:46 +0800536static inline int ocfs2_supports_xattr(struct ocfs2_super *osb)
537{
538 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR)
539 return 1;
540 return 0;
541}
542
Joel Becker70ad1ba2008-10-16 17:54:25 -0700543static inline int ocfs2_meta_ecc(struct ocfs2_super *osb)
544{
545 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC)
546 return 1;
547 return 0;
548}
549
Mark Fasheh9b7895e2008-11-12 16:27:44 -0800550static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb)
551{
552 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS)
553 return 1;
554 return 0;
555}
556
Tao Ma47119542010-04-22 14:09:15 +0800557static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb)
Joel Becker798db352010-04-13 14:26:32 +0800558{
559 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG)
560 return 1;
561 return 0;
562}
563
Mark Fasheh198a1ca2008-11-20 17:54:57 -0800564static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb)
565{
566 if (ocfs2_supports_indexed_dirs(osb))
567 return OCFS2_DX_LINK_MAX;
568 return OCFS2_LINK_MAX;
569}
570
571static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di)
572{
573 u32 nlink = le16_to_cpu(di->i_links_count);
574 u32 hi = le16_to_cpu(di->i_links_count_hi);
575
576 if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL))
577 nlink |= (hi << OCFS2_LINKS_HI_SHIFT);
578
579 return nlink;
580}
581
582static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink)
583{
584 u16 lo, hi;
585
586 lo = nlink;
587 hi = nlink >> OCFS2_LINKS_HI_SHIFT;
588
589 di->i_links_count = cpu_to_le16(lo);
590 di->i_links_count_hi = cpu_to_le16(hi);
591}
592
593static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n)
594{
595 u32 links = ocfs2_read_links_count(di);
596
597 links += n;
598
599 ocfs2_set_links_count(di, links);
600}
601
Tao Ma1aa75fe2009-08-18 11:28:39 +0800602static inline int ocfs2_refcount_tree(struct ocfs2_super *osb)
603{
604 if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE)
605 return 1;
606 return 0;
607}
608
Mark Fashehccd979b2005-12-15 14:31:24 -0800609/* set / clear functions because cluster events can make these happen
610 * in parallel so we want the transitions to be atomic. this also
611 * means that any future flags osb_flags must be protected by spinlock
612 * too! */
613static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb,
614 unsigned long flag)
615{
616 spin_lock(&osb->osb_lock);
617 osb->osb_flags |= flag;
618 spin_unlock(&osb->osb_lock);
619}
620
621static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb,
622 int hard)
623{
624 spin_lock(&osb->osb_lock);
625 osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO);
626 if (hard)
627 osb->osb_flags |= OCFS2_OSB_HARD_RO;
628 else
629 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
630 spin_unlock(&osb->osb_lock);
631}
632
633static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb)
634{
635 int ret;
636
637 spin_lock(&osb->osb_lock);
638 ret = osb->osb_flags & OCFS2_OSB_HARD_RO;
639 spin_unlock(&osb->osb_lock);
640
641 return ret;
642}
643
644static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb)
645{
646 int ret;
647
648 spin_lock(&osb->osb_lock);
649 ret = osb->osb_flags & OCFS2_OSB_SOFT_RO;
650 spin_unlock(&osb->osb_lock);
651
652 return ret;
653}
654
Sunil Mushran98f486f22010-10-09 10:24:46 -0700655static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb)
Joel Beckerb61817e2008-02-01 15:08:23 -0800656{
657 return (osb->s_feature_incompat &
Sunil Mushran98f486f22010-10-09 10:24:46 -0700658 (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK |
659 OCFS2_FEATURE_INCOMPAT_CLUSTERINFO));
660}
661
662static inline int ocfs2_userspace_stack(struct ocfs2_super *osb)
663{
664 if (ocfs2_clusterinfo_valid(osb) &&
665 memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
666 OCFS2_STACK_LABEL_LEN))
667 return 1;
668 return 0;
669}
670
671static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb)
672{
673 if (ocfs2_clusterinfo_valid(osb) &&
674 !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
675 OCFS2_STACK_LABEL_LEN))
676 return 1;
677 return 0;
678}
679
680static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb)
681{
682 return ocfs2_o2cb_stack(osb) &&
683 (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT);
Joel Beckerb61817e2008-02-01 15:08:23 -0800684}
685
Sunil Mushranc271c5c2006-12-05 17:56:35 -0800686static inline int ocfs2_mount_local(struct ocfs2_super *osb)
687{
688 return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT);
689}
690
Joel Becker386a2ef2008-02-01 12:06:54 -0800691static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb)
692{
693 return (osb->s_feature_incompat &
694 OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP);
695}
696
697
Mark Fashehccd979b2005-12-15 14:31:24 -0800698#define OCFS2_IS_VALID_DINODE(ptr) \
699 (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE))
700
Mark Fashehccd979b2005-12-15 14:31:24 -0800701#define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \
702 (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE))
703
Mark Fashehccd979b2005-12-15 14:31:24 -0800704#define OCFS2_IS_VALID_GROUP_DESC(ptr) \
705 (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE))
706
Mark Fashehccd979b2005-12-15 14:31:24 -0800707
Joel Beckerf6087fb2008-10-20 18:20:43 -0700708#define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \
709 (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE))
710
Mark Fasheh87d35a72008-12-10 17:36:25 -0800711#define OCFS2_IS_VALID_DIR_TRAILER(ptr) \
712 (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE))
713
Mark Fasheh9b7895e2008-11-12 16:27:44 -0800714#define OCFS2_IS_VALID_DX_ROOT(ptr) \
715 (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE))
716
717#define OCFS2_IS_VALID_DX_LEAF(ptr) \
718 (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE))
719
Tao Maf2c870e2009-08-18 11:19:26 +0800720#define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \
721 (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE))
722
Mark Fashehccd979b2005-12-15 14:31:24 -0800723static inline unsigned long ino_from_blkno(struct super_block *sb,
724 u64 blkno)
725{
726 return (unsigned long)(blkno & (u64)ULONG_MAX);
727}
728
729static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb,
730 u32 clusters)
731{
732 int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits -
733 sb->s_blocksize_bits;
734
735 return (u64)clusters << c_to_b_bits;
736}
737
Joseph Qiae1f0812015-06-24 16:55:23 -0700738static inline u32 ocfs2_clusters_for_blocks(struct super_block *sb,
739 u64 blocks)
740{
741 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
742 sb->s_blocksize_bits;
743
744 blocks += (1 << b_to_c_bits) - 1;
745 return (u32)(blocks >> b_to_c_bits);
746}
747
Mark Fashehccd979b2005-12-15 14:31:24 -0800748static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb,
749 u64 blocks)
750{
751 int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
752 sb->s_blocksize_bits;
753
754 return (u32)(blocks >> b_to_c_bits);
755}
756
757static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb,
758 u64 bytes)
759{
760 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
761 unsigned int clusters;
762
763 bytes += OCFS2_SB(sb)->s_clustersize - 1;
764 /* OCFS2 just cannot have enough clusters to overflow this */
765 clusters = (unsigned int)(bytes >> cl_bits);
766
767 return clusters;
768}
769
Joseph Qi24c40b32015-02-16 16:00:00 -0800770static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb,
771 u64 bytes)
772{
773 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
774 unsigned int clusters;
775
776 clusters = (unsigned int)(bytes >> cl_bits);
777 return clusters;
778}
779
Mark Fashehccd979b2005-12-15 14:31:24 -0800780static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb,
781 u64 bytes)
782{
783 bytes += sb->s_blocksize - 1;
784 return bytes >> sb->s_blocksize_bits;
785}
786
787static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb,
788 u32 clusters)
789{
790 return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits;
791}
792
Mark Fasheh1d46dc02009-02-19 13:17:05 -0800793static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb,
794 u64 blocks)
795{
796 int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits;
797 unsigned int clusters;
798
799 clusters = ocfs2_blocks_to_clusters(sb, blocks);
800 return (u64)clusters << bits;
801}
802
Mark Fashehccd979b2005-12-15 14:31:24 -0800803static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb,
804 u64 bytes)
805{
806 int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
807 unsigned int clusters;
808
809 clusters = ocfs2_clusters_for_bytes(sb, bytes);
810 return (u64)clusters << cl_bits;
811}
812
813static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb,
814 u64 bytes)
815{
816 u64 blocks;
817
818 blocks = ocfs2_blocks_for_bytes(sb, bytes);
819 return blocks << sb->s_blocksize_bits;
820}
821
822static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes)
823{
824 return (unsigned long)((bytes + 511) >> 9);
825}
826
Mark Fasheh9517bac2007-02-09 20:24:12 -0800827static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb,
828 unsigned long pg_index)
829{
830 u32 clusters = pg_index;
831 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
832
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300833 if (unlikely(PAGE_SHIFT > cbits))
834 clusters = pg_index << (PAGE_SHIFT - cbits);
835 else if (PAGE_SHIFT < cbits)
836 clusters = pg_index >> (cbits - PAGE_SHIFT);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800837
838 return clusters;
839}
840
841/*
842 * Find the 1st page index which covers the given clusters.
843 */
Mark Fasheh7c08d702007-07-20 11:58:36 -0700844static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb,
Mark Fasheh9517bac2007-02-09 20:24:12 -0800845 u32 clusters)
846{
847 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
Mark Fasheh7c08d702007-07-20 11:58:36 -0700848 pgoff_t index = clusters;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800849
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300850 if (PAGE_SHIFT > cbits) {
851 index = (pgoff_t)clusters >> (PAGE_SHIFT - cbits);
852 } else if (PAGE_SHIFT < cbits) {
853 index = (pgoff_t)clusters << (cbits - PAGE_SHIFT);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800854 }
855
856 return index;
857}
858
Mark Fasheh60b11392007-02-16 11:46:50 -0800859static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb)
860{
861 unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
862 unsigned int pages_per_cluster = 1;
863
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300864 if (PAGE_SHIFT < cbits)
865 pages_per_cluster = 1 << (cbits - PAGE_SHIFT);
Mark Fasheh60b11392007-02-16 11:46:50 -0800866
867 return pages_per_cluster;
868}
869
Mark Fashehebcee4b2008-07-28 14:55:20 -0700870static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb,
871 unsigned int megs)
872{
873 BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576);
874
875 return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits);
876}
877
Mark Fasheh73c8a802010-04-05 18:17:13 -0700878static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb,
879 unsigned int clusters)
880{
881 return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits);
882}
883
Mark Fashehb4414ee2010-03-11 18:31:09 -0800884static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap)
885{
Akinobu Mita730e6632011-05-30 21:58:05 +0900886 __set_bit_le(bit, bitmap);
Mark Fashehb4414ee2010-03-11 18:31:09 -0800887}
888#define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr))
889
890static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap)
891{
Akinobu Mita730e6632011-05-30 21:58:05 +0900892 __clear_bit_le(bit, bitmap);
Mark Fashehb4414ee2010-03-11 18:31:09 -0800893}
894#define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr))
895
Akinobu Mitac4354d02011-03-23 16:42:08 -0700896#define ocfs2_test_bit test_bit_le
897#define ocfs2_find_next_zero_bit find_next_zero_bit_le
898#define ocfs2_find_next_bit find_next_bit_le
Akinobu Mita93925572011-11-15 14:56:34 -0800899
900static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr)
901{
902#if BITS_PER_LONG == 64
903 *bit += ((unsigned long) addr & 7UL) << 3;
904 addr = (void *) ((unsigned long) addr & ~7UL);
905#elif BITS_PER_LONG == 32
906 *bit += ((unsigned long) addr & 3UL) << 3;
907 addr = (void *) ((unsigned long) addr & ~3UL);
908#else
909#error "how many bits you are?!"
910#endif
911 return addr;
912}
913
914static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap)
915{
916 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
917 ocfs2_set_bit(bit, bitmap);
918}
919
920static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap)
921{
922 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
923 ocfs2_clear_bit(bit, bitmap);
924}
925
926static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap)
927{
928 bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
929 return ocfs2_test_bit(bit, bitmap);
930}
931
932static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max,
933 int start)
934{
935 int fix = 0, ret, tmpmax;
936 bitmap = correct_addr_and_bit_unaligned(&fix, bitmap);
937 tmpmax = max + fix;
938 start += fix;
939
940 ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix;
941 if (ret > max)
942 return max;
943 return ret;
944}
945
Mark Fashehccd979b2005-12-15 14:31:24 -0800946#endif /* OCFS2_H */
947