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

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

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

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