~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ocfs2/ocfs2.h

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp