Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit c4354d0d6812ad6729ac33d3c8bc64585cfdb890

Authored by Akinobu Mita
Committed by Linus Torvalds
1 parent 50e0168cc3
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

ocfs2: use little-endian bitops 

As a preparation for removing ext2 non-atomic bit operations from
asm/bitops.h.  This converts ext2 non-atomic bit operations to
little-endian bit operations.

Signed-off-by: Akinobu Mita <akinobu.mita@gmail.com>
Acked-by: Joel Becker <joel.becker@oracle.com>
Cc: Mark Fasheh <mfasheh@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 5 additions and 5 deletions Inline Diff

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