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

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

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ 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.73 ] ~ [ 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 #define OCFS2_LOCK_NONBLOCK_FINISHED (0x00001000) /* NONBLOCK cluster
148                                                    * lock has already
149                                                    * returned, do not block
150                                                    * dc thread from
151                                                    * downconverting */
152 
153 struct ocfs2_lock_res_ops;
154 
155 typedef void (*ocfs2_lock_callback)(int status, unsigned long data);
156 
157 #ifdef CONFIG_OCFS2_FS_STATS
158 struct ocfs2_lock_stats {
159         u64             ls_total;       /* Total wait in NSEC */
160         u32             ls_gets;        /* Num acquires */
161         u32             ls_fail;        /* Num failed acquires */
162 
163         /* Storing max wait in usecs saves 24 bytes per inode */
164         u32             ls_max;         /* Max wait in USEC */
165 };
166 #endif
167 
168 struct ocfs2_lock_res {
169         void                    *l_priv;
170         struct ocfs2_lock_res_ops *l_ops;
171 
172 
173         struct list_head         l_blocked_list;
174         struct list_head         l_mask_waiters;
175         struct list_head         l_holders;
176 
177         unsigned long            l_flags;
178         char                     l_name[OCFS2_LOCK_ID_MAX_LEN];
179         unsigned int             l_ro_holders;
180         unsigned int             l_ex_holders;
181         signed char              l_level;
182         signed char              l_requested;
183         signed char              l_blocking;
184 
185         /* Data packed - type enum ocfs2_lock_type */
186         unsigned char            l_type;
187 
188         /* used from AST/BAST funcs. */
189         /* Data packed - enum type ocfs2_ast_action */
190         unsigned char            l_action;
191         /* Data packed - enum type ocfs2_unlock_action */
192         unsigned char            l_unlock_action;
193         unsigned int             l_pending_gen;
194 
195         spinlock_t               l_lock;
196 
197         struct ocfs2_dlm_lksb    l_lksb;
198 
199         wait_queue_head_t        l_event;
200 
201         struct list_head         l_debug_list;
202 
203 #ifdef CONFIG_OCFS2_FS_STATS
204         struct ocfs2_lock_stats  l_lock_prmode;         /* PR mode stats */
205         u32                      l_lock_refresh;        /* Disk refreshes */
206         struct ocfs2_lock_stats  l_lock_exmode;         /* EX mode stats */
207 #endif
208 #ifdef CONFIG_DEBUG_LOCK_ALLOC
209         struct lockdep_map       l_lockdep_map;
210 #endif
211 };
212 
213 enum ocfs2_orphan_reco_type {
214         ORPHAN_NO_NEED_TRUNCATE = 0,
215         ORPHAN_NEED_TRUNCATE,
216 };
217 
218 enum ocfs2_orphan_scan_state {
219         ORPHAN_SCAN_ACTIVE,
220         ORPHAN_SCAN_INACTIVE
221 };
222 
223 struct ocfs2_orphan_scan {
224         struct mutex            os_lock;
225         struct ocfs2_super      *os_osb;
226         struct ocfs2_lock_res   os_lockres;     /* lock to synchronize scans */
227         struct delayed_work     os_orphan_scan_work;
228         time64_t                os_scantime;  /* time this node ran the scan */
229         u32                     os_count;      /* tracks node specific scans */
230         u32                     os_seqno;       /* tracks cluster wide scans */
231         atomic_t                os_state;              /* ACTIVE or INACTIVE */
232 };
233 
234 struct ocfs2_dlm_debug {
235         struct kref d_refcnt;
236         struct dentry *d_locking_state;
237         struct list_head d_lockres_tracking;
238 };
239 
240 enum ocfs2_vol_state
241 {
242         VOLUME_INIT = 0,
243         VOLUME_MOUNTED,
244         VOLUME_MOUNTED_QUOTAS,
245         VOLUME_DISMOUNTED,
246         VOLUME_DISABLED
247 };
248 
249 struct ocfs2_alloc_stats
250 {
251         atomic_t moves;
252         atomic_t local_data;
253         atomic_t bitmap_data;
254         atomic_t bg_allocs;
255         atomic_t bg_extends;
256 };
257 
258 enum ocfs2_local_alloc_state
259 {
260         OCFS2_LA_UNUSED = 0,    /* Local alloc will never be used for
261                                  * this mountpoint. */
262         OCFS2_LA_ENABLED,       /* Local alloc is in use. */
263         OCFS2_LA_THROTTLED,     /* Local alloc is in use, but number
264                                  * of bits has been reduced. */
265         OCFS2_LA_DISABLED       /* Local alloc has temporarily been
266                                  * disabled. */
267 };
268 
269 enum ocfs2_mount_options
270 {
271         OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */
272         OCFS2_MOUNT_BARRIER = 1 << 1,   /* Use block barriers */
273         OCFS2_MOUNT_NOINTR  = 1 << 2,   /* Don't catch signals */
274         OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */
275         OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */
276         OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */
277         OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */
278         OCFS2_MOUNT_INODE64 = 1 << 7,   /* Allow inode numbers > 2^32 */
279         OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */
280         OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9,      /* Disable POSIX access
281                                                    control lists */
282         OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */
283         OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */
284         OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT
285                                                      writes */
286         OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */
287         OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */
288 
289         OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT = 1 << 15,  /* Journal Async Commit */
290         OCFS2_MOUNT_ERRORS_CONT = 1 << 16, /* Return EIO to the calling process on error */
291         OCFS2_MOUNT_ERRORS_ROFS = 1 << 17, /* Change filesystem to read-only on error */
292 };
293 
294 #define OCFS2_OSB_SOFT_RO       0x0001
295 #define OCFS2_OSB_HARD_RO       0x0002
296 #define OCFS2_OSB_ERROR_FS      0x0004
297 #define OCFS2_DEFAULT_ATIME_QUANTUM     60
298 
299 struct ocfs2_journal;
300 struct ocfs2_slot_info;
301 struct ocfs2_recovery_map;
302 struct ocfs2_replay_map;
303 struct ocfs2_quota_recovery;
304 struct ocfs2_super
305 {
306         struct task_struct *commit_task;
307         struct super_block *sb;
308         struct inode *root_inode;
309         struct inode *sys_root_inode;
310         struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES];
311         struct inode **local_system_inodes;
312 
313         struct ocfs2_slot_info *slot_info;
314 
315         u32 *slot_recovery_generations;
316 
317         spinlock_t node_map_lock;
318 
319         u64 root_blkno;
320         u64 system_dir_blkno;
321         u64 bitmap_blkno;
322         u32 bitmap_cpg;
323         u8 *uuid;
324         char *uuid_str;
325         u32 uuid_hash;
326         u8 *vol_label;
327         u64 first_cluster_group_blkno;
328         u32 fs_generation;
329 
330         u32 s_feature_compat;
331         u32 s_feature_incompat;
332         u32 s_feature_ro_compat;
333 
334         /* Protects s_next_generation, osb_flags and s_inode_steal_slot.
335          * Could protect more on osb as it's very short lived.
336          */
337         spinlock_t osb_lock;
338         u32 s_next_generation;
339         unsigned long osb_flags;
340         s16 s_inode_steal_slot;
341         s16 s_meta_steal_slot;
342         atomic_t s_num_inodes_stolen;
343         atomic_t s_num_meta_stolen;
344 
345         unsigned long s_mount_opt;
346         unsigned int s_atime_quantum;
347 
348         unsigned int max_slots;
349         unsigned int node_num;
350         int slot_num;
351         int preferred_slot;
352         int s_sectsize_bits;
353         int s_clustersize;
354         int s_clustersize_bits;
355         unsigned int s_xattr_inline_size;
356 
357         atomic_t vol_state;
358         struct mutex recovery_lock;
359         struct ocfs2_recovery_map *recovery_map;
360         struct ocfs2_replay_map *replay_map;
361         struct task_struct *recovery_thread_task;
362         int disable_recovery;
363         wait_queue_head_t checkpoint_event;
364         struct ocfs2_journal *journal;
365         unsigned long osb_commit_interval;
366 
367         struct delayed_work             la_enable_wq;
368 
369         /*
370          * Must hold local alloc i_mutex and osb->osb_lock to change
371          * local_alloc_bits. Reads can be done under either lock.
372          */
373         unsigned int local_alloc_bits;
374         unsigned int local_alloc_default_bits;
375         /* osb_clusters_at_boot can become stale! Do not trust it to
376          * be up to date. */
377         unsigned int osb_clusters_at_boot;
378 
379         enum ocfs2_local_alloc_state local_alloc_state; /* protected
380                                                          * by osb_lock */
381 
382         struct buffer_head *local_alloc_bh;
383 
384         u64 la_last_gd;
385 
386         struct ocfs2_reservation_map    osb_la_resmap;
387 
388         unsigned int    osb_resv_level;
389         unsigned int    osb_dir_resv_level;
390 
391         /* Next three fields are for local node slot recovery during
392          * mount. */
393         int dirty;
394         struct ocfs2_dinode *local_alloc_copy;
395         struct ocfs2_quota_recovery *quota_rec;
396 
397         struct ocfs2_blockcheck_stats osb_ecc_stats;
398         struct ocfs2_alloc_stats alloc_stats;
399         char dev_str[20];               /* "major,minor" of the device */
400 
401         u8 osb_stackflags;
402 
403         char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
404         char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1];
405         struct ocfs2_cluster_connection *cconn;
406         struct ocfs2_lock_res osb_super_lockres;
407         struct ocfs2_lock_res osb_rename_lockres;
408         struct ocfs2_lock_res osb_nfs_sync_lockres;
409         struct ocfs2_dlm_debug *osb_dlm_debug;
410 
411         struct dentry *osb_debug_root;
412         struct dentry *osb_ctxt;
413 
414         wait_queue_head_t recovery_event;
415 
416         spinlock_t dc_task_lock;
417         struct task_struct *dc_task;
418         wait_queue_head_t dc_event;
419         unsigned long dc_wake_sequence;
420         unsigned long dc_work_sequence;
421 
422         /*
423          * Any thread can add locks to the list, but the downconvert
424          * thread is the only one allowed to remove locks. Any change
425          * to this rule requires updating
426          * ocfs2_downconvert_thread_do_work().
427          */
428         struct list_head blocked_lock_list;
429         unsigned long blocked_lock_count;
430 
431         /* List of dquot structures to drop last reference to */
432         struct llist_head dquot_drop_list;
433         struct work_struct dquot_drop_work;
434 
435         wait_queue_head_t               osb_mount_event;
436 
437         /* Truncate log info */
438         struct inode                    *osb_tl_inode;
439         struct buffer_head              *osb_tl_bh;
440         struct delayed_work             osb_truncate_log_wq;
441         atomic_t                        osb_tl_disable;
442         /*
443          * How many clusters in our truncate log.
444          * It must be protected by osb_tl_inode->i_mutex.
445          */
446         unsigned int truncated_clusters;
447 
448         struct ocfs2_node_map           osb_recovering_orphan_dirs;
449         unsigned int                    *osb_orphan_wipes;
450         wait_queue_head_t               osb_wipe_event;
451 
452         struct ocfs2_orphan_scan        osb_orphan_scan;
453 
454         /* used to protect metaecc calculation check of xattr. */
455         spinlock_t osb_xattr_lock;
456 
457         unsigned int                    osb_dx_mask;
458         u32                             osb_dx_seed[4];
459 
460         /* the group we used to allocate inodes. */
461         u64                             osb_inode_alloc_group;
462 
463         /* rb tree root for refcount lock. */
464         struct rb_root  osb_rf_lock_tree;
465         struct ocfs2_refcount_tree *osb_ref_tree_lru;
466 
467         struct mutex system_file_mutex;
468 
469         /*
470          * OCFS2 needs to schedule several different types of work which
471          * require cluster locking, disk I/O, recovery waits, etc. Since these
472          * types of work tend to be heavy we avoid using the kernel events
473          * workqueue and schedule on our own.
474          */
475         struct workqueue_struct *ocfs2_wq;
476 };
477 
478 #define OCFS2_SB(sb)        ((struct ocfs2_super *)(sb)->s_fs_info)
479 
480 /* Useful typedef for passing around journal access functions */
481 typedef int (*ocfs2_journal_access_func)(handle_t *handle,
482                                          struct ocfs2_caching_info *ci,
483                                          struct buffer_head *bh, int type);
484 
485 static inline int ocfs2_should_order_data(struct inode *inode)
486 {
487         if (!S_ISREG(inode->i_mode))
488                 return 0;
489         if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)
490                 return 0;
491         return 1;
492 }
493 
494 static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb)
495 {
496         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC)
497                 return 1;
498         return 0;
499 }
500 
501 static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb)
502 {
503         /*
504          * Support for sparse files is a pre-requisite
505          */
506         if (!ocfs2_sparse_alloc(osb))
507                 return 0;
508 
509         if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN)
510                 return 1;
511         return 0;
512 }
513 
514 static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb)
515 {
516         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_APPEND_DIO)
517                 return 1;
518         return 0;
519 }
520 
521 
522 static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb)
523 {
524         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA)
525                 return 1;
526         return 0;
527 }
528 
529 static inline int ocfs2_supports_xattr(struct ocfs2_super *osb)
530 {
531         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR)
532                 return 1;
533         return 0;
534 }
535 
536 static inline int ocfs2_meta_ecc(struct ocfs2_super *osb)
537 {
538         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC)
539                 return 1;
540         return 0;
541 }
542 
543 static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb)
544 {
545         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS)
546                 return 1;
547         return 0;
548 }
549 
550 static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb)
551 {
552         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG)
553                 return 1;
554         return 0;
555 }
556 
557 static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb)
558 {
559         if (ocfs2_supports_indexed_dirs(osb))
560                 return OCFS2_DX_LINK_MAX;
561         return OCFS2_LINK_MAX;
562 }
563 
564 static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di)
565 {
566         u32 nlink = le16_to_cpu(di->i_links_count);
567         u32 hi = le16_to_cpu(di->i_links_count_hi);
568 
569         if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL))
570                 nlink |= (hi << OCFS2_LINKS_HI_SHIFT);
571 
572         return nlink;
573 }
574 
575 static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink)
576 {
577         u16 lo, hi;
578 
579         lo = nlink;
580         hi = nlink >> OCFS2_LINKS_HI_SHIFT;
581 
582         di->i_links_count = cpu_to_le16(lo);
583         di->i_links_count_hi = cpu_to_le16(hi);
584 }
585 
586 static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n)
587 {
588         u32 links = ocfs2_read_links_count(di);
589 
590         links += n;
591 
592         ocfs2_set_links_count(di, links);
593 }
594 
595 static inline int ocfs2_refcount_tree(struct ocfs2_super *osb)
596 {
597         if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE)
598                 return 1;
599         return 0;
600 }
601 
602 /* set / clear functions because cluster events can make these happen
603  * in parallel so we want the transitions to be atomic. this also
604  * means that any future flags osb_flags must be protected by spinlock
605  * too! */
606 static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb,
607                                       unsigned long flag)
608 {
609         spin_lock(&osb->osb_lock);
610         osb->osb_flags |= flag;
611         spin_unlock(&osb->osb_lock);
612 }
613 
614 static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb,
615                                      int hard)
616 {
617         spin_lock(&osb->osb_lock);
618         osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO);
619         if (hard)
620                 osb->osb_flags |= OCFS2_OSB_HARD_RO;
621         else
622                 osb->osb_flags |= OCFS2_OSB_SOFT_RO;
623         spin_unlock(&osb->osb_lock);
624 }
625 
626 static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb)
627 {
628         int ret;
629 
630         spin_lock(&osb->osb_lock);
631         ret = osb->osb_flags & OCFS2_OSB_HARD_RO;
632         spin_unlock(&osb->osb_lock);
633 
634         return ret;
635 }
636 
637 static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb)
638 {
639         int ret;
640 
641         spin_lock(&osb->osb_lock);
642         ret = osb->osb_flags & OCFS2_OSB_SOFT_RO;
643         spin_unlock(&osb->osb_lock);
644 
645         return ret;
646 }
647 
648 static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb)
649 {
650         return (osb->s_feature_incompat &
651                 (OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK |
652                  OCFS2_FEATURE_INCOMPAT_CLUSTERINFO));
653 }
654 
655 static inline int ocfs2_userspace_stack(struct ocfs2_super *osb)
656 {
657         if (ocfs2_clusterinfo_valid(osb) &&
658             memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
659                    OCFS2_STACK_LABEL_LEN))
660                 return 1;
661         return 0;
662 }
663 
664 static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb)
665 {
666         if (ocfs2_clusterinfo_valid(osb) &&
667             !memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
668                    OCFS2_STACK_LABEL_LEN))
669                 return 1;
670         return 0;
671 }
672 
673 static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb)
674 {
675         return ocfs2_o2cb_stack(osb) &&
676                 (osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT);
677 }
678 
679 static inline int ocfs2_mount_local(struct ocfs2_super *osb)
680 {
681         return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT);
682 }
683 
684 static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb)
685 {
686         return (osb->s_feature_incompat &
687                 OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP);
688 }
689 
690 
691 #define OCFS2_IS_VALID_DINODE(ptr)                                      \
692         (!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE))
693 
694 #define OCFS2_IS_VALID_EXTENT_BLOCK(ptr)                                \
695         (!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE))
696 
697 #define OCFS2_IS_VALID_GROUP_DESC(ptr)                                  \
698         (!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE))
699 
700 
701 #define OCFS2_IS_VALID_XATTR_BLOCK(ptr)                                 \
702         (!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE))
703 
704 #define OCFS2_IS_VALID_DIR_TRAILER(ptr)                                 \
705         (!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE))
706 
707 #define OCFS2_IS_VALID_DX_ROOT(ptr)                                     \
708         (!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE))
709 
710 #define OCFS2_IS_VALID_DX_LEAF(ptr)                                     \
711         (!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE))
712 
713 #define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr)                              \
714         (!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE))
715 
716 static inline unsigned long ino_from_blkno(struct super_block *sb,
717                                            u64 blkno)
718 {
719         return (unsigned long)(blkno & (u64)ULONG_MAX);
720 }
721 
722 static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb,
723                                            u32 clusters)
724 {
725         int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits -
726                 sb->s_blocksize_bits;
727 
728         return (u64)clusters << c_to_b_bits;
729 }
730 
731 static inline u32 ocfs2_clusters_for_blocks(struct super_block *sb,
732                 u64 blocks)
733 {
734         int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
735                         sb->s_blocksize_bits;
736 
737         blocks += (1 << b_to_c_bits) - 1;
738         return (u32)(blocks >> b_to_c_bits);
739 }
740 
741 static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb,
742                                            u64 blocks)
743 {
744         int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
745                 sb->s_blocksize_bits;
746 
747         return (u32)(blocks >> b_to_c_bits);
748 }
749 
750 static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb,
751                                                     u64 bytes)
752 {
753         int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
754         unsigned int clusters;
755 
756         bytes += OCFS2_SB(sb)->s_clustersize - 1;
757         /* OCFS2 just cannot have enough clusters to overflow this */
758         clusters = (unsigned int)(bytes >> cl_bits);
759 
760         return clusters;
761 }
762 
763 static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb,
764                 u64 bytes)
765 {
766         int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
767         unsigned int clusters;
768 
769         clusters = (unsigned int)(bytes >> cl_bits);
770         return clusters;
771 }
772 
773 static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb,
774                                          u64 bytes)
775 {
776         bytes += sb->s_blocksize - 1;
777         return bytes >> sb->s_blocksize_bits;
778 }
779 
780 static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb,
781                                           u32 clusters)
782 {
783         return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits;
784 }
785 
786 static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb,
787                                                u64 blocks)
788 {
789         int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits;
790         unsigned int clusters;
791 
792         clusters = ocfs2_blocks_to_clusters(sb, blocks);
793         return (u64)clusters << bits;
794 }
795 
796 static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb,
797                                                 u64 bytes)
798 {
799         int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
800         unsigned int clusters;
801 
802         clusters = ocfs2_clusters_for_bytes(sb, bytes);
803         return (u64)clusters << cl_bits;
804 }
805 
806 static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb,
807                                               u64 bytes)
808 {
809         u64 blocks;
810 
811         blocks = ocfs2_blocks_for_bytes(sb, bytes);
812         return blocks << sb->s_blocksize_bits;
813 }
814 
815 static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes)
816 {
817         return (unsigned long)((bytes + 511) >> 9);
818 }
819 
820 static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb,
821                                                         unsigned long pg_index)
822 {
823         u32 clusters = pg_index;
824         unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
825 
826         if (unlikely(PAGE_SHIFT > cbits))
827                 clusters = pg_index << (PAGE_SHIFT - cbits);
828         else if (PAGE_SHIFT < cbits)
829                 clusters = pg_index >> (cbits - PAGE_SHIFT);
830 
831         return clusters;
832 }
833 
834 /*
835  * Find the 1st page index which covers the given clusters.
836  */
837 static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb,
838                                                         u32 clusters)
839 {
840         unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
841         pgoff_t index = clusters;
842 
843         if (PAGE_SHIFT > cbits) {
844                 index = (pgoff_t)clusters >> (PAGE_SHIFT - cbits);
845         } else if (PAGE_SHIFT < cbits) {
846                 index = (pgoff_t)clusters << (cbits - PAGE_SHIFT);
847         }
848 
849         return index;
850 }
851 
852 static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb)
853 {
854         unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
855         unsigned int pages_per_cluster = 1;
856 
857         if (PAGE_SHIFT < cbits)
858                 pages_per_cluster = 1 << (cbits - PAGE_SHIFT);
859 
860         return pages_per_cluster;
861 }
862 
863 static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb,
864                                                        unsigned int megs)
865 {
866         BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576);
867 
868         return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits);
869 }
870 
871 static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb,
872                                                        unsigned int clusters)
873 {
874         return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits);
875 }
876 
877 static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap)
878 {
879         __set_bit_le(bit, bitmap);
880 }
881 #define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr))
882 
883 static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap)
884 {
885         __clear_bit_le(bit, bitmap);
886 }
887 #define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr))
888 
889 #define ocfs2_test_bit test_bit_le
890 #define ocfs2_find_next_zero_bit find_next_zero_bit_le
891 #define ocfs2_find_next_bit find_next_bit_le
892 
893 static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr)
894 {
895 #if BITS_PER_LONG == 64
896         *bit += ((unsigned long) addr & 7UL) << 3;
897         addr = (void *) ((unsigned long) addr & ~7UL);
898 #elif BITS_PER_LONG == 32
899         *bit += ((unsigned long) addr & 3UL) << 3;
900         addr = (void *) ((unsigned long) addr & ~3UL);
901 #else
902 #error "how many bits you are?!"
903 #endif
904         return addr;
905 }
906 
907 static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap)
908 {
909         bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
910         ocfs2_set_bit(bit, bitmap);
911 }
912 
913 static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap)
914 {
915         bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
916         ocfs2_clear_bit(bit, bitmap);
917 }
918 
919 static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap)
920 {
921         bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
922         return ocfs2_test_bit(bit, bitmap);
923 }
924 
925 static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max,
926                                                         int start)
927 {
928         int fix = 0, ret, tmpmax;
929         bitmap = correct_addr_and_bit_unaligned(&fix, bitmap);
930         tmpmax = max + fix;
931         start += fix;
932 
933         ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix;
934         if (ret > max)
935                 return max;
936         return ret;
937 }
938 
939 #endif  /* OCFS2_H */
940 
941 

~ [ 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