2019-05-24 10:04:05 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2021-05-07 01:06:44 +00:00
|
|
|
/*
|
2005-12-15 22:31:24 +00:00
|
|
|
* ocfs2.h
|
|
|
|
*
|
|
|
|
* Defines macros and structures used in OCFS2
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002, 2004 Oracle. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef OCFS2_H
|
|
|
|
#define OCFS2_H
|
|
|
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/list.h>
|
2014-04-03 21:46:56 +00:00
|
|
|
#include <linux/llist.h>
|
2005-12-15 22:31:24 +00:00
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/kref.h>
|
2006-01-14 05:54:23 +00:00
|
|
|
#include <linux/mutex.h>
|
2009-06-04 13:26:50 +00:00
|
|
|
#include <linux/lockdep.h>
|
2009-11-06 22:50:22 +00:00
|
|
|
#include <linux/jbd2.h>
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2008-02-01 20:16:57 +00:00
|
|
|
/* For union ocfs2_dlm_lksb */
|
|
|
|
#include "stackglue.h"
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
#include "ocfs2_fs.h"
|
|
|
|
#include "ocfs2_lockid.h"
|
2010-03-02 05:59:42 +00:00
|
|
|
#include "ocfs2_ioctl.h"
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2009-01-06 22:57:08 +00:00
|
|
|
/* For struct ocfs2_blockcheck_stats */
|
|
|
|
#include "blockcheck.h"
|
|
|
|
|
2009-12-07 21:10:48 +00:00
|
|
|
#include "reservations.h"
|
2009-02-11 00:05:07 +00:00
|
|
|
|
2018-04-05 23:19:29 +00:00
|
|
|
#include "filecheck.h"
|
|
|
|
|
2009-02-11 00:05:07 +00:00
|
|
|
/* Caching of metadata buffers */
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
/* Most user visible OCFS2 inodes will have very few pieces of
|
|
|
|
* metadata, but larger files (including bitmaps, etc) must be taken
|
|
|
|
* into account when designing an access scheme. We allow a small
|
|
|
|
* amount of inlined blocks to be stored on an array and grow the
|
|
|
|
* structure into a rb tree when necessary. */
|
2009-02-11 00:05:07 +00:00
|
|
|
#define OCFS2_CACHE_INFO_MAX_ARRAY 2
|
|
|
|
|
|
|
|
/* Flags for ocfs2_caching_info */
|
|
|
|
|
|
|
|
enum ocfs2_caching_info_flags {
|
|
|
|
/* Indicates that the metadata cache is using the inline array */
|
|
|
|
OCFS2_CACHE_FL_INLINE = 1<<1,
|
|
|
|
};
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2009-02-11 03:00:37 +00:00
|
|
|
struct ocfs2_caching_operations;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_caching_info {
|
2009-02-11 00:05:07 +00:00
|
|
|
/*
|
|
|
|
* The parent structure provides the locks, but because the
|
2009-02-11 03:00:37 +00:00
|
|
|
* parent structure can differ, it provides locking operations
|
|
|
|
* to struct ocfs2_caching_info.
|
2009-02-11 00:05:07 +00:00
|
|
|
*/
|
2009-02-11 03:00:37 +00:00
|
|
|
const struct ocfs2_caching_operations *ci_ops;
|
2009-02-11 00:05:07 +00:00
|
|
|
|
2009-02-12 23:41:59 +00:00
|
|
|
/* next two are protected by trans_inc_lock */
|
|
|
|
/* which transaction were we created on? Zero if none. */
|
|
|
|
unsigned long ci_created_trans;
|
2009-02-12 23:24:40 +00:00
|
|
|
/* last transaction we were a part of. */
|
|
|
|
unsigned long ci_last_trans;
|
|
|
|
|
|
|
|
/* Cache structures */
|
2009-02-11 00:05:07 +00:00
|
|
|
unsigned int ci_flags;
|
2005-12-15 22:31:24 +00:00
|
|
|
unsigned int ci_num_cached;
|
|
|
|
union {
|
2009-02-11 00:05:07 +00:00
|
|
|
sector_t ci_array[OCFS2_CACHE_INFO_MAX_ARRAY];
|
2005-12-15 22:31:24 +00:00
|
|
|
struct rb_root ci_tree;
|
|
|
|
} ci_cache;
|
|
|
|
};
|
2009-02-13 00:41:25 +00:00
|
|
|
/*
|
|
|
|
* Need this prototype here instead of in uptodate.h because journal.h
|
|
|
|
* uses it.
|
|
|
|
*/
|
|
|
|
struct super_block *ocfs2_metadata_cache_get_super(struct ocfs2_caching_info *ci);
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
/* this limits us to 256 nodes
|
|
|
|
* if we need more, we can do a kmalloc for the map */
|
|
|
|
#define OCFS2_NODE_MAP_MAX_NODES 256
|
|
|
|
struct ocfs2_node_map {
|
|
|
|
u16 num_nodes;
|
|
|
|
unsigned long map[BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES)];
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_ast_action {
|
|
|
|
OCFS2_AST_INVALID = 0,
|
|
|
|
OCFS2_AST_ATTACH,
|
|
|
|
OCFS2_AST_CONVERT,
|
|
|
|
OCFS2_AST_DOWNCONVERT,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* actions for an unlockast function to take. */
|
|
|
|
enum ocfs2_unlock_action {
|
|
|
|
OCFS2_UNLOCK_INVALID = 0,
|
|
|
|
OCFS2_UNLOCK_CANCEL_CONVERT,
|
|
|
|
OCFS2_UNLOCK_DROP_LOCK,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ocfs2_lock_res->l_flags flags. */
|
2008-11-05 07:16:24 +00:00
|
|
|
#define OCFS2_LOCK_ATTACHED (0x00000001) /* we have initialized
|
2005-12-15 22:31:24 +00:00
|
|
|
* the lvb */
|
|
|
|
#define OCFS2_LOCK_BUSY (0x00000002) /* we are currently in
|
|
|
|
* dlm_lock */
|
|
|
|
#define OCFS2_LOCK_BLOCKED (0x00000004) /* blocked waiting to
|
|
|
|
* downconvert*/
|
|
|
|
#define OCFS2_LOCK_LOCAL (0x00000008) /* newly created inode */
|
|
|
|
#define OCFS2_LOCK_NEEDS_REFRESH (0x00000010)
|
|
|
|
#define OCFS2_LOCK_REFRESHING (0x00000020)
|
|
|
|
#define OCFS2_LOCK_INITIALIZED (0x00000040) /* track initialization
|
|
|
|
* for shutdown paths */
|
|
|
|
#define OCFS2_LOCK_FREEING (0x00000080) /* help dlmglue track
|
|
|
|
* when to skip queueing
|
|
|
|
* a lock because it's
|
|
|
|
* about to be
|
|
|
|
* dropped. */
|
|
|
|
#define OCFS2_LOCK_QUEUED (0x00000100) /* queued for downconvert */
|
2007-12-21 00:43:10 +00:00
|
|
|
#define OCFS2_LOCK_NOCACHE (0x00000200) /* don't use a holder count */
|
ocfs2: Remove CANCELGRANT from the view of dlmglue.
o2dlm has the non-standard behavior of providing a cancel callback
(unlock_ast) even when the cancel has failed (the locking operation
succeeded without canceling). This is called CANCELGRANT after the
status code sent to the callback. fs/dlm does not provide this
callback, so dlmglue must be changed to live without it.
o2dlm_unlock_ast_wrapper() in stackglue now ignores CANCELGRANT calls.
Because dlmglue no longer sees CANCELGRANT, ocfs2_unlock_ast() no longer
needs to check for it. ocfs2_locking_ast() must catch that a cancel was
tried and clear the cancel state.
Making these changes opens up a locking race. dlmglue uses the the
OCFS2_LOCK_BUSY flag to ensure only one thread is calling the dlm at any
one time. But dlmglue must unlock the lockres before calling into the
dlm. In the small window of time between unlocking the lockres and
calling the dlm, the downconvert thread can try to cancel the lock. The
downconvert thread is checking the OCFS2_LOCK_BUSY flag - it doesn't
know that ocfs2_dlm_lock() has not yet been called.
Because ocfs2_dlm_lock() has not yet been called, the cancel operation
will just be a no-op. There's nothing to cancel. With CANCELGRANT,
dlmglue uses the CANCELGRANT callback to clear up the cancel state.
When it comes around again, it will retry the cancel. Eventually, the
first thread will have called into ocfs2_dlm_lock(), and either the
lock or the cancel will succeed. The downconvert thread can then do its
downconvert.
Without CANCELGRANT, there is nothing to clean up the cancellation
state. The downconvert thread does not know to retry its operations.
More importantly, the original lock may be blocking on the other node
that is trying to cancel us. With neither able to make progress, the
ast is never called and the cancellation state is never cleaned up that
way. dlmglue is deadlocked.
The OCFS2_LOCK_PENDING flag is introduced to remedy this window. It is
set at the same time OCFS2_LOCK_BUSY is. Thus, the downconvert thread
can check whether the lock is cancelable. If not, it just loops around
to try again. Once ocfs2_dlm_lock() is called, the thread then clears
OCFS2_LOCK_PENDING and wakes the downconvert thread. Now, if the
downconvert thread finds the lock BUSY, it can safely try to cancel it.
Whether the cancel works or not, the state will be properly set and the
lock processing can continue.
Signed-off-by: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-02-01 22:45:08 +00:00
|
|
|
#define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a
|
|
|
|
call to dlm_lock. Only
|
|
|
|
exists with BUSY set. */
|
2010-01-21 18:50:03 +00:00
|
|
|
#define OCFS2_LOCK_UPCONVERT_FINISHING (0x00000800) /* blocks the dc thread
|
|
|
|
* from downconverting
|
|
|
|
* before the upconvert
|
|
|
|
* has completed */
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2014-12-10 23:41:59 +00:00
|
|
|
#define OCFS2_LOCK_NONBLOCK_FINISHED (0x00001000) /* NONBLOCK cluster
|
|
|
|
* lock has already
|
|
|
|
* returned, do not block
|
|
|
|
* dc thread from
|
|
|
|
* downconverting */
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_lock_res_ops;
|
|
|
|
|
|
|
|
typedef void (*ocfs2_lock_callback)(int status, unsigned long data);
|
|
|
|
|
2010-12-29 07:26:03 +00:00
|
|
|
#ifdef CONFIG_OCFS2_FS_STATS
|
|
|
|
struct ocfs2_lock_stats {
|
|
|
|
u64 ls_total; /* Total wait in NSEC */
|
|
|
|
u32 ls_gets; /* Num acquires */
|
|
|
|
u32 ls_fail; /* Num failed acquires */
|
|
|
|
|
|
|
|
/* Storing max wait in usecs saves 24 bytes per inode */
|
|
|
|
u32 ls_max; /* Max wait in USEC */
|
2019-07-12 03:53:02 +00:00
|
|
|
u64 ls_last; /* Last unlock time in USEC */
|
2010-12-29 07:26:03 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_lock_res {
|
|
|
|
void *l_priv;
|
|
|
|
struct ocfs2_lock_res_ops *l_ops;
|
2010-06-10 22:21:36 +00:00
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
struct list_head l_blocked_list;
|
|
|
|
struct list_head l_mask_waiters;
|
ocfs2/dlmglue: prepare tracking logic to avoid recursive cluster lock
We are in the situation that we have to avoid recursive cluster locking,
but there is no way to check if a cluster lock has been taken by a precess
already.
Mostly, we can avoid recursive locking by writing code carefully.
However, we found that it's very hard to handle the routines that are
invoked directly by vfs code. For instance:
const struct inode_operations ocfs2_file_iops = {
.permission = ocfs2_permission,
.get_acl = ocfs2_iop_get_acl,
.set_acl = ocfs2_iop_set_acl,
};
Both ocfs2_permission() and ocfs2_iop_get_acl() call ocfs2_inode_lock(PR):
do_sys_open
may_open
inode_permission
ocfs2_permission
ocfs2_inode_lock() <=== first time
generic_permission
get_acl
ocfs2_iop_get_acl
ocfs2_inode_lock() <=== recursive one
A deadlock will occur if a remote EX request comes in between two of
ocfs2_inode_lock(). Briefly describe how the deadlock is formed:
On one hand, OCFS2_LOCK_BLOCKED flag of this lockres is set in
BAST(ocfs2_generic_handle_bast) when downconvert is started on behalf of
the remote EX lock request. Another hand, the recursive cluster lock
(the second one) will be blocked in in __ocfs2_cluster_lock() because of
OCFS2_LOCK_BLOCKED. But, the downconvert never complete, why? because
there is no chance for the first cluster lock on this node to be
unlocked - we block ourselves in the code path.
The idea to fix this issue is mostly taken from gfs2 code.
1. introduce a new field: struct ocfs2_lock_res.l_holders, to keep track
of the processes' pid who has taken the cluster lock of this lock
resource;
2. introduce a new flag for ocfs2_inode_lock_full:
OCFS2_META_LOCK_GETBH; it means just getting back disk inode bh for
us if we've got cluster lock.
3. export a helper: ocfs2_is_locked_by_me() is used to check if we have
got the cluster lock in the upper code path.
The tracking logic should be used by some of the ocfs2 vfs's callbacks,
to solve the recursive locking issue cuased by the fact that vfs
routines can call into each other.
The performance penalty of processing the holder list should only be
seen at a few cases where the tracking logic is used, such as get/set
acl.
You may ask what if the first time we got a PR lock, and the second time
we want a EX lock? fortunately, this case never happens in the real
world, as far as I can see, including permission check,
(get|set)_(acl|attr), and the gfs2 code also do so.
[sfr@canb.auug.org.au remove some inlines]
Link: http://lkml.kernel.org/r/20170117100948.11657-2-zren@suse.com
Signed-off-by: Eric Ren <zren@suse.com>
Reviewed-by: Junxiao Bi <junxiao.bi@oracle.com>
Reviewed-by: Joseph Qi <jiangqi903@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Mark Fasheh <mfasheh@versity.com>
Cc: Joel Becker <jlbec@evilplan.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-02-22 23:40:41 +00:00
|
|
|
struct list_head l_holders;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
unsigned long l_flags;
|
|
|
|
char l_name[OCFS2_LOCK_ID_MAX_LEN];
|
|
|
|
unsigned int l_ro_holders;
|
|
|
|
unsigned int l_ex_holders;
|
2010-11-18 04:20:11 +00:00
|
|
|
signed char l_level;
|
|
|
|
signed char l_requested;
|
|
|
|
signed char l_blocking;
|
2010-06-10 22:21:36 +00:00
|
|
|
|
|
|
|
/* Data packed - type enum ocfs2_lock_type */
|
|
|
|
unsigned char l_type;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
/* used from AST/BAST funcs. */
|
2010-06-10 22:21:36 +00:00
|
|
|
/* Data packed - enum type ocfs2_ast_action */
|
|
|
|
unsigned char l_action;
|
|
|
|
/* Data packed - enum type ocfs2_unlock_action */
|
|
|
|
unsigned char l_unlock_action;
|
ocfs2: Remove CANCELGRANT from the view of dlmglue.
o2dlm has the non-standard behavior of providing a cancel callback
(unlock_ast) even when the cancel has failed (the locking operation
succeeded without canceling). This is called CANCELGRANT after the
status code sent to the callback. fs/dlm does not provide this
callback, so dlmglue must be changed to live without it.
o2dlm_unlock_ast_wrapper() in stackglue now ignores CANCELGRANT calls.
Because dlmglue no longer sees CANCELGRANT, ocfs2_unlock_ast() no longer
needs to check for it. ocfs2_locking_ast() must catch that a cancel was
tried and clear the cancel state.
Making these changes opens up a locking race. dlmglue uses the the
OCFS2_LOCK_BUSY flag to ensure only one thread is calling the dlm at any
one time. But dlmglue must unlock the lockres before calling into the
dlm. In the small window of time between unlocking the lockres and
calling the dlm, the downconvert thread can try to cancel the lock. The
downconvert thread is checking the OCFS2_LOCK_BUSY flag - it doesn't
know that ocfs2_dlm_lock() has not yet been called.
Because ocfs2_dlm_lock() has not yet been called, the cancel operation
will just be a no-op. There's nothing to cancel. With CANCELGRANT,
dlmglue uses the CANCELGRANT callback to clear up the cancel state.
When it comes around again, it will retry the cancel. Eventually, the
first thread will have called into ocfs2_dlm_lock(), and either the
lock or the cancel will succeed. The downconvert thread can then do its
downconvert.
Without CANCELGRANT, there is nothing to clean up the cancellation
state. The downconvert thread does not know to retry its operations.
More importantly, the original lock may be blocking on the other node
that is trying to cancel us. With neither able to make progress, the
ast is never called and the cancellation state is never cleaned up that
way. dlmglue is deadlocked.
The OCFS2_LOCK_PENDING flag is introduced to remedy this window. It is
set at the same time OCFS2_LOCK_BUSY is. Thus, the downconvert thread
can check whether the lock is cancelable. If not, it just loops around
to try again. Once ocfs2_dlm_lock() is called, the thread then clears
OCFS2_LOCK_PENDING and wakes the downconvert thread. Now, if the
downconvert thread finds the lock BUSY, it can safely try to cancel it.
Whether the cancel works or not, the state will be properly set and the
lock processing can continue.
Signed-off-by: Joel Becker <joel.becker@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-02-01 22:45:08 +00:00
|
|
|
unsigned int l_pending_gen;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2010-06-10 22:21:36 +00:00
|
|
|
spinlock_t l_lock;
|
|
|
|
|
|
|
|
struct ocfs2_dlm_lksb l_lksb;
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
wait_queue_head_t l_event;
|
|
|
|
|
|
|
|
struct list_head l_debug_list;
|
2008-05-13 20:45:15 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_OCFS2_FS_STATS
|
2010-12-29 07:26:03 +00:00
|
|
|
struct ocfs2_lock_stats l_lock_prmode; /* PR mode stats */
|
|
|
|
u32 l_lock_refresh; /* Disk refreshes */
|
2019-07-12 03:53:09 +00:00
|
|
|
u64 l_lock_wait; /* First lock wait time */
|
2010-12-29 07:26:03 +00:00
|
|
|
struct ocfs2_lock_stats l_lock_exmode; /* EX mode stats */
|
2008-05-13 20:45:15 +00:00
|
|
|
#endif
|
2009-06-04 13:26:50 +00:00
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
struct lockdep_map l_lockdep_map;
|
|
|
|
#endif
|
2005-12-15 22:31:24 +00:00
|
|
|
};
|
|
|
|
|
2015-02-16 23:59:57 +00:00
|
|
|
enum ocfs2_orphan_reco_type {
|
|
|
|
ORPHAN_NO_NEED_TRUNCATE = 0,
|
|
|
|
ORPHAN_NEED_TRUNCATE,
|
|
|
|
};
|
|
|
|
|
2009-06-19 23:53:17 +00:00
|
|
|
enum ocfs2_orphan_scan_state {
|
|
|
|
ORPHAN_SCAN_ACTIVE,
|
|
|
|
ORPHAN_SCAN_INACTIVE
|
|
|
|
};
|
|
|
|
|
2009-06-04 00:02:55 +00:00
|
|
|
struct ocfs2_orphan_scan {
|
|
|
|
struct mutex os_lock;
|
|
|
|
struct ocfs2_super *os_osb;
|
|
|
|
struct ocfs2_lock_res os_lockres; /* lock to synchronize scans */
|
|
|
|
struct delayed_work os_orphan_scan_work;
|
2016-12-13 00:41:23 +00:00
|
|
|
time64_t os_scantime; /* time this node ran the scan */
|
2009-06-04 00:02:56 +00:00
|
|
|
u32 os_count; /* tracks node specific scans */
|
|
|
|
u32 os_seqno; /* tracks cluster wide scans */
|
2009-06-19 23:53:17 +00:00
|
|
|
atomic_t os_state; /* ACTIVE or INACTIVE */
|
2009-06-04 00:02:55 +00:00
|
|
|
};
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_dlm_debug {
|
|
|
|
struct kref d_refcnt;
|
2019-07-12 03:53:05 +00:00
|
|
|
u32 d_filter_secs;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct list_head d_lockres_tracking;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_vol_state
|
|
|
|
{
|
|
|
|
VOLUME_INIT = 0,
|
|
|
|
VOLUME_MOUNTED,
|
2008-08-21 18:13:17 +00:00
|
|
|
VOLUME_MOUNTED_QUOTAS,
|
2005-12-15 22:31:24 +00:00
|
|
|
VOLUME_DISMOUNTED,
|
|
|
|
VOLUME_DISABLED
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_alloc_stats
|
|
|
|
{
|
|
|
|
atomic_t moves;
|
|
|
|
atomic_t local_data;
|
|
|
|
atomic_t bitmap_data;
|
|
|
|
atomic_t bg_allocs;
|
|
|
|
atomic_t bg_extends;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_local_alloc_state
|
|
|
|
{
|
ocfs2: throttle back local alloc when low on disk space
Ocfs2's local allocator disables itself for the duration of a mount point
when it has trouble allocating a large enough area from the primary bitmap.
That can cause performance problems, especially for disks which were only
temporarily full or fragmented. This patch allows for the allocator to
shrink it's window first, before being disabled. Later, it can also be
re-enabled so that any performance drop is minimized.
To do this, we allow the value of osb->local_alloc_bits to be shrunk when
needed. The default value is recorded in a mostly read-only variable so that
we can re-initialize when required.
Locking had to be updated so that we could protect changes to
local_alloc_bits. Mostly this involves protecting various local alloc values
with the osb spinlock. A new state is also added, OCFS2_LA_THROTTLED, which
is used when the local allocator is has shrunk, but is not disabled. If the
available space dips below 1 megabyte, the local alloc file is disabled. In
either case, local alloc is re-enabled 30 seconds after the event, or when
an appropriate amount of bits is seen in the primary bitmap.
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-07-29 01:02:53 +00:00
|
|
|
OCFS2_LA_UNUSED = 0, /* Local alloc will never be used for
|
|
|
|
* this mountpoint. */
|
|
|
|
OCFS2_LA_ENABLED, /* Local alloc is in use. */
|
|
|
|
OCFS2_LA_THROTTLED, /* Local alloc is in use, but number
|
|
|
|
* of bits has been reduced. */
|
|
|
|
OCFS2_LA_DISABLED /* Local alloc has temporarily been
|
|
|
|
* disabled. */
|
2005-12-15 22:31:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_mount_options
|
|
|
|
{
|
2010-10-07 22:23:50 +00:00
|
|
|
OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Local heartbeat */
|
2005-12-15 22:31:24 +00:00
|
|
|
OCFS2_MOUNT_BARRIER = 1 << 1, /* Use block barriers */
|
|
|
|
OCFS2_MOUNT_NOINTR = 1 << 2, /* Don't catch signals */
|
|
|
|
OCFS2_MOUNT_ERRORS_PANIC = 1 << 3, /* Panic on errors */
|
|
|
|
OCFS2_MOUNT_DATA_WRITEBACK = 1 << 4, /* No data ordering */
|
2007-12-21 00:49:04 +00:00
|
|
|
OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */
|
2008-08-18 09:11:00 +00:00
|
|
|
OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */
|
2008-09-04 03:03:40 +00:00
|
|
|
OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */
|
2009-10-15 12:54:04 +00:00
|
|
|
OCFS2_MOUNT_POSIX_ACL = 1 << 8, /* Force POSIX access control lists */
|
|
|
|
OCFS2_MOUNT_NO_POSIX_ACL = 1 << 9, /* Disable POSIX access
|
|
|
|
control lists */
|
|
|
|
OCFS2_MOUNT_USRQUOTA = 1 << 10, /* We support user quotas */
|
|
|
|
OCFS2_MOUNT_GRPQUOTA = 1 << 11, /* We support group quotas */
|
2010-10-15 20:03:09 +00:00
|
|
|
OCFS2_MOUNT_COHERENCY_BUFFERED = 1 << 12, /* Allow concurrent O_DIRECT
|
|
|
|
writes */
|
|
|
|
OCFS2_MOUNT_HB_NONE = 1 << 13, /* No heartbeat */
|
|
|
|
OCFS2_MOUNT_HB_GLOBAL = 1 << 14, /* Global heartbeat */
|
2015-02-10 22:09:04 +00:00
|
|
|
|
|
|
|
OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT = 1 << 15, /* Journal Async Commit */
|
2015-09-04 22:44:11 +00:00
|
|
|
OCFS2_MOUNT_ERRORS_CONT = 1 << 16, /* Return EIO to the calling process on error */
|
|
|
|
OCFS2_MOUNT_ERRORS_ROFS = 1 << 17, /* Change filesystem to read-only on error */
|
2020-06-02 04:45:29 +00:00
|
|
|
OCFS2_MOUNT_NOCLUSTER = 1 << 18, /* No cluster aware filesystem mount */
|
2005-12-15 22:31:24 +00:00
|
|
|
};
|
|
|
|
|
2014-04-03 21:46:59 +00:00
|
|
|
#define OCFS2_OSB_SOFT_RO 0x0001
|
|
|
|
#define OCFS2_OSB_HARD_RO 0x0002
|
|
|
|
#define OCFS2_OSB_ERROR_FS 0x0004
|
|
|
|
#define OCFS2_DEFAULT_ATIME_QUANTUM 60
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
struct ocfs2_journal;
|
2008-02-01 20:01:05 +00:00
|
|
|
struct ocfs2_slot_info;
|
2008-02-01 20:03:57 +00:00
|
|
|
struct ocfs2_recovery_map;
|
2009-03-06 22:21:46 +00:00
|
|
|
struct ocfs2_replay_map;
|
2008-10-20 21:50:38 +00:00
|
|
|
struct ocfs2_quota_recovery;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_super
|
|
|
|
{
|
|
|
|
struct task_struct *commit_task;
|
|
|
|
struct super_block *sb;
|
|
|
|
struct inode *root_inode;
|
|
|
|
struct inode *sys_root_inode;
|
ocfs2: Cache system inodes of other slots.
Durring orphan scan, if we are slot 0, and we are replaying
orphan_dir:0001, the general process is that for every file
in this dir:
1. we will iget orphan_dir:0001, since there is no inode for it.
we will have to create an inode and read it from the disk.
2. do the normal work, such as delete_inode and remove it from
the dir if it is allowed.
3. call iput orphan_dir:0001 when we are done. In this case,
since we have no dcache for this inode, i_count will
reach 0, and VFS will have to call clear_inode and in
ocfs2_clear_inode we will checkpoint the inode which will let
ocfs2_cmt and journald begin to work.
4. We loop back to 1 for the next file.
So you see, actually for every deleted file, we have to read the
orphan dir from the disk and checkpoint the journal. It is very
time consuming and cause a lot of journal checkpoint I/O.
A better solution is that we can have another reference for these
inodes in ocfs2_super. So if there is no other race among
nodes(which will let dlmglue to checkpoint the inode), for step 3,
clear_inode won't be called and for step 1, we may only need to
read the inode for the 1st time. This is a big win for us.
So this patch will try to cache system inodes of other slots so
that we will have one more reference for these inodes and avoid
the extra inode read and journal checkpoint.
Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Joel Becker <joel.becker@oracle.com>
2010-08-16 08:58:21 +00:00
|
|
|
struct inode *global_system_inodes[NUM_GLOBAL_SYSTEM_INODES];
|
|
|
|
struct inode **local_system_inodes;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
struct ocfs2_slot_info *slot_info;
|
|
|
|
|
2008-07-15 00:31:10 +00:00
|
|
|
u32 *slot_recovery_generations;
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
spinlock_t node_map_lock;
|
|
|
|
|
|
|
|
u64 root_blkno;
|
|
|
|
u64 system_dir_blkno;
|
|
|
|
u64 bitmap_blkno;
|
|
|
|
u32 bitmap_cpg;
|
|
|
|
char *uuid_str;
|
2008-08-18 09:11:00 +00:00
|
|
|
u32 uuid_hash;
|
2005-12-15 22:31:24 +00:00
|
|
|
u8 *vol_label;
|
|
|
|
u64 first_cluster_group_blkno;
|
|
|
|
u32 fs_generation;
|
|
|
|
|
|
|
|
u32 s_feature_compat;
|
|
|
|
u32 s_feature_incompat;
|
|
|
|
u32 s_feature_ro_compat;
|
|
|
|
|
2008-03-05 08:11:46 +00:00
|
|
|
/* Protects s_next_generation, osb_flags and s_inode_steal_slot.
|
|
|
|
* Could protect more on osb as it's very short lived.
|
|
|
|
*/
|
2005-12-15 22:31:24 +00:00
|
|
|
spinlock_t osb_lock;
|
|
|
|
u32 s_next_generation;
|
|
|
|
unsigned long osb_flags;
|
2020-08-07 06:18:02 +00:00
|
|
|
u16 s_inode_steal_slot;
|
|
|
|
u16 s_meta_steal_slot;
|
2008-03-05 08:11:46 +00:00
|
|
|
atomic_t s_num_inodes_stolen;
|
2010-01-25 06:11:06 +00:00
|
|
|
atomic_t s_num_meta_stolen;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
unsigned long s_mount_opt;
|
2006-11-15 07:48:42 +00:00
|
|
|
unsigned int s_atime_quantum;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2008-02-01 20:04:48 +00:00
|
|
|
unsigned int max_slots;
|
2008-01-30 23:38:24 +00:00
|
|
|
unsigned int node_num;
|
2008-02-01 20:04:48 +00:00
|
|
|
int slot_num;
|
|
|
|
int preferred_slot;
|
2005-12-15 22:31:24 +00:00
|
|
|
int s_sectsize_bits;
|
|
|
|
int s_clustersize;
|
|
|
|
int s_clustersize_bits;
|
2008-08-18 09:08:55 +00:00
|
|
|
unsigned int s_xattr_inline_size;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
|
|
|
atomic_t vol_state;
|
2006-01-14 05:54:23 +00:00
|
|
|
struct mutex recovery_lock;
|
2008-02-01 20:03:57 +00:00
|
|
|
struct ocfs2_recovery_map *recovery_map;
|
2009-03-06 22:21:46 +00:00
|
|
|
struct ocfs2_replay_map *replay_map;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct task_struct *recovery_thread_task;
|
|
|
|
int disable_recovery;
|
|
|
|
wait_queue_head_t checkpoint_event;
|
|
|
|
struct ocfs2_journal *journal;
|
2007-11-07 22:40:36 +00:00
|
|
|
unsigned long osb_commit_interval;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
ocfs2: throttle back local alloc when low on disk space
Ocfs2's local allocator disables itself for the duration of a mount point
when it has trouble allocating a large enough area from the primary bitmap.
That can cause performance problems, especially for disks which were only
temporarily full or fragmented. This patch allows for the allocator to
shrink it's window first, before being disabled. Later, it can also be
re-enabled so that any performance drop is minimized.
To do this, we allow the value of osb->local_alloc_bits to be shrunk when
needed. The default value is recorded in a mostly read-only variable so that
we can re-initialize when required.
Locking had to be updated so that we could protect changes to
local_alloc_bits. Mostly this involves protecting various local alloc values
with the osb spinlock. A new state is also added, OCFS2_LA_THROTTLED, which
is used when the local allocator is has shrunk, but is not disabled. If the
available space dips below 1 megabyte, the local alloc file is disabled. In
either case, local alloc is re-enabled 30 seconds after the event, or when
an appropriate amount of bits is seen in the primary bitmap.
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-07-29 01:02:53 +00:00
|
|
|
struct delayed_work la_enable_wq;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must hold local alloc i_mutex and osb->osb_lock to change
|
|
|
|
* local_alloc_bits. Reads can be done under either lock.
|
|
|
|
*/
|
2008-07-28 21:55:20 +00:00
|
|
|
unsigned int local_alloc_bits;
|
ocfs2: throttle back local alloc when low on disk space
Ocfs2's local allocator disables itself for the duration of a mount point
when it has trouble allocating a large enough area from the primary bitmap.
That can cause performance problems, especially for disks which were only
temporarily full or fragmented. This patch allows for the allocator to
shrink it's window first, before being disabled. Later, it can also be
re-enabled so that any performance drop is minimized.
To do this, we allow the value of osb->local_alloc_bits to be shrunk when
needed. The default value is recorded in a mostly read-only variable so that
we can re-initialize when required.
Locking had to be updated so that we could protect changes to
local_alloc_bits. Mostly this involves protecting various local alloc values
with the osb spinlock. A new state is also added, OCFS2_LA_THROTTLED, which
is used when the local allocator is has shrunk, but is not disabled. If the
available space dips below 1 megabyte, the local alloc file is disabled. In
either case, local alloc is re-enabled 30 seconds after the event, or when
an appropriate amount of bits is seen in the primary bitmap.
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-07-29 01:02:53 +00:00
|
|
|
unsigned int local_alloc_default_bits;
|
2010-04-06 01:17:14 +00:00
|
|
|
/* osb_clusters_at_boot can become stale! Do not trust it to
|
|
|
|
* be up to date. */
|
|
|
|
unsigned int osb_clusters_at_boot;
|
ocfs2: throttle back local alloc when low on disk space
Ocfs2's local allocator disables itself for the duration of a mount point
when it has trouble allocating a large enough area from the primary bitmap.
That can cause performance problems, especially for disks which were only
temporarily full or fragmented. This patch allows for the allocator to
shrink it's window first, before being disabled. Later, it can also be
re-enabled so that any performance drop is minimized.
To do this, we allow the value of osb->local_alloc_bits to be shrunk when
needed. The default value is recorded in a mostly read-only variable so that
we can re-initialize when required.
Locking had to be updated so that we could protect changes to
local_alloc_bits. Mostly this involves protecting various local alloc values
with the osb spinlock. A new state is also added, OCFS2_LA_THROTTLED, which
is used when the local allocator is has shrunk, but is not disabled. If the
available space dips below 1 megabyte, the local alloc file is disabled. In
either case, local alloc is re-enabled 30 seconds after the event, or when
an appropriate amount of bits is seen in the primary bitmap.
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-07-29 01:02:53 +00:00
|
|
|
|
|
|
|
enum ocfs2_local_alloc_state local_alloc_state; /* protected
|
|
|
|
* by osb_lock */
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
struct buffer_head *local_alloc_bh;
|
ocfs2: throttle back local alloc when low on disk space
Ocfs2's local allocator disables itself for the duration of a mount point
when it has trouble allocating a large enough area from the primary bitmap.
That can cause performance problems, especially for disks which were only
temporarily full or fragmented. This patch allows for the allocator to
shrink it's window first, before being disabled. Later, it can also be
re-enabled so that any performance drop is minimized.
To do this, we allow the value of osb->local_alloc_bits to be shrunk when
needed. The default value is recorded in a mostly read-only variable so that
we can re-initialize when required.
Locking had to be updated so that we could protect changes to
local_alloc_bits. Mostly this involves protecting various local alloc values
with the osb spinlock. A new state is also added, OCFS2_LA_THROTTLED, which
is used when the local allocator is has shrunk, but is not disabled. If the
available space dips below 1 megabyte, the local alloc file is disabled. In
either case, local alloc is re-enabled 30 seconds after the event, or when
an appropriate amount of bits is seen in the primary bitmap.
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
2008-07-29 01:02:53 +00:00
|
|
|
|
2006-06-05 20:41:00 +00:00
|
|
|
u64 la_last_gd;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2009-12-07 21:10:48 +00:00
|
|
|
struct ocfs2_reservation_map osb_la_resmap;
|
|
|
|
|
|
|
|
unsigned int osb_resv_level;
|
2010-04-06 01:17:16 +00:00
|
|
|
unsigned int osb_dir_resv_level;
|
2009-12-07 21:10:48 +00:00
|
|
|
|
2017-09-06 23:19:11 +00:00
|
|
|
/* Next two fields are for local node slot recovery during
|
2005-12-15 22:31:24 +00:00
|
|
|
* mount. */
|
|
|
|
struct ocfs2_dinode *local_alloc_copy;
|
2008-10-20 21:50:38 +00:00
|
|
|
struct ocfs2_quota_recovery *quota_rec;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2009-01-06 22:57:08 +00:00
|
|
|
struct ocfs2_blockcheck_stats osb_ecc_stats;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_alloc_stats alloc_stats;
|
|
|
|
char dev_str[20]; /* "major,minor" of the device */
|
|
|
|
|
2010-10-09 17:24:46 +00:00
|
|
|
u8 osb_stackflags;
|
|
|
|
|
2008-02-01 23:08:23 +00:00
|
|
|
char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
|
2014-01-21 23:48:21 +00:00
|
|
|
char osb_cluster_name[OCFS2_CLUSTER_NAME_LEN + 1];
|
2008-02-01 22:39:35 +00:00
|
|
|
struct ocfs2_cluster_connection *cconn;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_lock_res osb_super_lockres;
|
|
|
|
struct ocfs2_lock_res osb_rename_lockres;
|
2009-03-06 13:29:10 +00:00
|
|
|
struct ocfs2_lock_res osb_nfs_sync_lockres;
|
2020-06-26 03:29:30 +00:00
|
|
|
struct rw_semaphore nfs_sync_rwlock;
|
2018-02-01 00:15:10 +00:00
|
|
|
struct ocfs2_lock_res osb_trim_fs_lockres;
|
2019-03-05 23:41:45 +00:00
|
|
|
struct mutex obs_trim_fs_mutex;
|
2005-12-15 22:31:24 +00:00
|
|
|
struct ocfs2_dlm_debug *osb_dlm_debug;
|
|
|
|
|
|
|
|
struct dentry *osb_debug_root;
|
|
|
|
|
|
|
|
wait_queue_head_t recovery_event;
|
|
|
|
|
2007-09-24 22:56:19 +00:00
|
|
|
spinlock_t dc_task_lock;
|
|
|
|
struct task_struct *dc_task;
|
|
|
|
wait_queue_head_t dc_event;
|
|
|
|
unsigned long dc_wake_sequence;
|
|
|
|
unsigned long dc_work_sequence;
|
2005-12-15 22:31:24 +00:00
|
|
|
|
2008-01-24 00:54:48 +00:00
|
|
|
/*
|
|
|
|
* Any thread can add locks to the list, but the downconvert
|
|
|
|
* thread is the only one allowed to remove locks. Any change
|
|
|
|
* to this rule requires updating
|
|
|
|
* ocfs2_downconvert_thread_do_work().
|
|
|
|
*/
|
2005-12-15 22:31:24 +00:00
|
|
|
struct list_head blocked_lock_list;
|
|
|
|
unsigned long blocked_lock_count;
|
|
|
|
|
2014-04-03 21:46:56 +00:00
|
|
|
/* List of dquot structures to drop last reference to */
|
|
|
|
struct llist_head dquot_drop_list;
|
|
|
|
struct work_struct dquot_drop_work;
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
wait_queue_head_t osb_mount_event;
|
|
|
|
|
|
|
|
/* Truncate log info */
|
|
|
|
struct inode *osb_tl_inode;
|
|
|
|
struct buffer_head *osb_tl_bh;
|
2006-11-22 14:57:56 +00:00
|
|
|
struct delayed_work osb_truncate_log_wq;
|
2014-06-04 23:06:13 +00:00
|
|
|
atomic_t osb_tl_disable;
|
2010-11-04 07:14:11 +00:00
|
|
|
/*
|
|
|
|
* How many clusters in our truncate log.
|
|
|
|
* It must be protected by osb_tl_inode->i_mutex.
|
|
|
|
*/
|
|
|
|
unsigned int truncated_clusters;
|
2006-02-23 01:35:08 +00:00
|
|
|
|
|
|
|
struct ocfs2_node_map osb_recovering_orphan_dirs;
|
|
|
|
unsigned int *osb_orphan_wipes;
|
|
|
|
wait_queue_head_t osb_wipe_event;
|
2009-02-25 01:40:26 +00:00
|
|
|
|
2009-06-04 00:02:55 +00:00
|
|
|
struct ocfs2_orphan_scan osb_orphan_scan;
|
|
|
|
|
2009-02-25 01:40:26 +00:00
|
|
|
/* used to protect metaecc calculation check of xattr. */
|
|
|
|
spinlock_t osb_xattr_lock;
|
2008-11-13 00:27:44 +00:00
|
|
|
|
|
|
|
unsigned int osb_dx_mask;
|
|
|
|
u32 osb_dx_seed[4];
|
2009-02-24 16:53:25 +00:00
|
|
|
|
|
|
|
/* the group we used to allocate inodes. */
|
|
|
|
u64 osb_inode_alloc_group;
|
2009-08-24 03:13:37 +00:00
|
|
|
|
|
|
|
/* rb tree root for refcount lock. */
|
|
|
|
struct rb_root osb_rf_lock_tree;
|
|
|
|
struct ocfs2_refcount_tree *osb_ref_tree_lru;
|
2014-04-03 21:47:13 +00:00
|
|
|
|
|
|
|
struct mutex system_file_mutex;
|
ocfs2: fix occurring deadlock by changing ocfs2_wq from global to local
This patch fixes a deadlock, as follows:
Node 1 Node 2 Node 3
1)volume a and b are only mount vol a only mount vol b
mounted
2) start to mount b start to mount a
3) check hb of Node 3 check hb of Node 2
in vol a, qs_holds++ in vol b, qs_holds++
4) -------------------- all nodes' network down --------------------
5) progress of mount b the same situation as
failed, and then call Node 2
ocfs2_dismount_volume.
but the process is hung,
since there is a work
in ocfs2_wq cannot beo
completed. This work is
about vol a, because
ocfs2_wq is global wq.
BTW, this work which is
scheduled in ocfs2_wq is
ocfs2_orphan_scan_work,
and the context in this work
needs to take inode lock
of orphan_dir, because
lockres owner are Node 1 and
all nodes' nework has been down
at the same time, so it can't
get the inode lock.
6) Why can't this node be fenced
when network disconnected?
Because the process of
mount is hung what caused qs_holds
is not equal 0.
Because all works in the ocfs2_wq are relative to the super block.
The solution is to change the ocfs2_wq from global to local. In other
words, move it into struct ocfs2_super.
Signed-off-by: Yiwen Jiang <jiangyiwen@huawei.com>
Reviewed-by: Joseph Qi <joseph.qi@huawei.com>
Cc: Xue jiufei <xuejiufei@huawei.com>
Cc: Mark Fasheh <mfasheh@suse.de>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Cc: Junxiao Bi <junxiao.bi@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-25 21:21:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OCFS2 needs to schedule several different types of work which
|
|
|
|
* require cluster locking, disk I/O, recovery waits, etc. Since these
|
|
|
|
* types of work tend to be heavy we avoid using the kernel events
|
|
|
|
* workqueue and schedule on our own.
|
|
|
|
*/
|
|
|
|
struct workqueue_struct *ocfs2_wq;
|
2018-04-05 23:19:29 +00:00
|
|
|
|
|
|
|
/* sysfs directory per partition */
|
|
|
|
struct kset *osb_dev_kset;
|
|
|
|
|
|
|
|
/* file check related stuff */
|
|
|
|
struct ocfs2_filecheck_sysfs_entry osb_fc_ent;
|
2005-12-15 22:31:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info)
|
|
|
|
|
2008-10-18 02:25:01 +00:00
|
|
|
/* Useful typedef for passing around journal access functions */
|
2009-02-13 00:41:25 +00:00
|
|
|
typedef int (*ocfs2_journal_access_func)(handle_t *handle,
|
|
|
|
struct ocfs2_caching_info *ci,
|
2008-10-18 02:25:01 +00:00
|
|
|
struct buffer_head *bh, int type);
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
static inline int ocfs2_should_order_data(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (!S_ISREG(inode->i_mode))
|
|
|
|
return 0;
|
|
|
|
if (OCFS2_SB(inode->i_sb)->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-01-16 19:32:23 +00:00
|
|
|
static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-18 17:48:04 +00:00
|
|
|
static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Support for sparse files is a pre-requisite
|
|
|
|
*/
|
|
|
|
if (!ocfs2_sparse_alloc(osb))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-17 00:00:15 +00:00
|
|
|
static inline int ocfs2_supports_append_dio(struct ocfs2_super *osb)
|
|
|
|
{
|
2015-03-12 23:25:46 +00:00
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_APPEND_DIO)
|
2015-02-17 00:00:15 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-07 20:58:15 +00:00
|
|
|
static inline int ocfs2_supports_inline_data(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INLINE_DATA)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-18 09:11:46 +00:00
|
|
|
static inline int ocfs2_supports_xattr(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-17 00:54:25 +00:00
|
|
|
static inline int ocfs2_meta_ecc(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_META_ECC)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-13 00:27:44 +00:00
|
|
|
static inline int ocfs2_supports_indexed_dirs(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-22 06:09:15 +00:00
|
|
|
static inline int ocfs2_supports_discontig_bg(struct ocfs2_super *osb)
|
2010-04-13 06:26:32 +00:00
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-21 01:54:57 +00:00
|
|
|
static inline unsigned int ocfs2_link_max(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (ocfs2_supports_indexed_dirs(osb))
|
|
|
|
return OCFS2_DX_LINK_MAX;
|
|
|
|
return OCFS2_LINK_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int ocfs2_read_links_count(struct ocfs2_dinode *di)
|
|
|
|
{
|
|
|
|
u32 nlink = le16_to_cpu(di->i_links_count);
|
|
|
|
u32 hi = le16_to_cpu(di->i_links_count_hi);
|
|
|
|
|
|
|
|
if (di->i_dyn_features & cpu_to_le16(OCFS2_INDEXED_DIR_FL))
|
|
|
|
nlink |= (hi << OCFS2_LINKS_HI_SHIFT);
|
|
|
|
|
|
|
|
return nlink;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_set_links_count(struct ocfs2_dinode *di, u32 nlink)
|
|
|
|
{
|
|
|
|
u16 lo, hi;
|
|
|
|
|
|
|
|
lo = nlink;
|
|
|
|
hi = nlink >> OCFS2_LINKS_HI_SHIFT;
|
|
|
|
|
|
|
|
di->i_links_count = cpu_to_le16(lo);
|
|
|
|
di->i_links_count_hi = cpu_to_le16(hi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_add_links_count(struct ocfs2_dinode *di, int n)
|
|
|
|
{
|
|
|
|
u32 links = ocfs2_read_links_count(di);
|
|
|
|
|
|
|
|
links += n;
|
|
|
|
|
|
|
|
ocfs2_set_links_count(di, links);
|
|
|
|
}
|
|
|
|
|
2009-08-18 03:28:39 +00:00
|
|
|
static inline int ocfs2_refcount_tree(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_REFCOUNT_TREE)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
/* set / clear functions because cluster events can make these happen
|
|
|
|
* in parallel so we want the transitions to be atomic. this also
|
|
|
|
* means that any future flags osb_flags must be protected by spinlock
|
|
|
|
* too! */
|
|
|
|
static inline void ocfs2_set_osb_flag(struct ocfs2_super *osb,
|
|
|
|
unsigned long flag)
|
|
|
|
{
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
osb->osb_flags |= flag;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_set_ro_flag(struct ocfs2_super *osb,
|
|
|
|
int hard)
|
|
|
|
{
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
osb->osb_flags &= ~(OCFS2_OSB_SOFT_RO|OCFS2_OSB_HARD_RO);
|
|
|
|
if (hard)
|
|
|
|
osb->osb_flags |= OCFS2_OSB_HARD_RO;
|
|
|
|
else
|
|
|
|
osb->osb_flags |= OCFS2_OSB_SOFT_RO;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_is_hard_readonly(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
ret = osb->osb_flags & OCFS2_OSB_HARD_RO;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_is_soft_readonly(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
ret = osb->osb_flags & OCFS2_OSB_SOFT_RO;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-10-09 17:24:46 +00:00
|
|
|
static inline int ocfs2_clusterinfo_valid(struct ocfs2_super *osb)
|
2008-02-01 23:08:23 +00:00
|
|
|
{
|
|
|
|
return (osb->s_feature_incompat &
|
2010-10-09 17:24:46 +00:00
|
|
|
(OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK |
|
|
|
|
OCFS2_FEATURE_INCOMPAT_CLUSTERINFO));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_userspace_stack(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (ocfs2_clusterinfo_valid(osb) &&
|
|
|
|
memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
|
|
|
|
OCFS2_STACK_LABEL_LEN))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_o2cb_stack(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (ocfs2_clusterinfo_valid(osb) &&
|
|
|
|
!memcmp(osb->osb_cluster_stack, OCFS2_CLASSIC_CLUSTER_STACK,
|
|
|
|
OCFS2_STACK_LABEL_LEN))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_cluster_o2cb_global_heartbeat(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
return ocfs2_o2cb_stack(osb) &&
|
|
|
|
(osb->osb_stackflags & OCFS2_CLUSTER_O2CB_GLOBAL_HEARTBEAT);
|
2008-02-01 23:08:23 +00:00
|
|
|
}
|
|
|
|
|
2006-12-06 01:56:35 +00:00
|
|
|
static inline int ocfs2_mount_local(struct ocfs2_super *osb)
|
|
|
|
{
|
2020-06-02 04:45:29 +00:00
|
|
|
return ((osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT)
|
|
|
|
|| (osb->s_mount_opt & OCFS2_MOUNT_NOCLUSTER));
|
2006-12-06 01:56:35 +00:00
|
|
|
}
|
|
|
|
|
2008-02-01 20:06:54 +00:00
|
|
|
static inline int ocfs2_uses_extended_slot_map(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
return (osb->s_feature_incompat &
|
|
|
|
OCFS2_FEATURE_INCOMPAT_EXTENDED_SLOT_MAP);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
#define OCFS2_IS_VALID_DINODE(ptr) \
|
|
|
|
(!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \
|
|
|
|
(!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_IS_VALID_GROUP_DESC(ptr) \
|
|
|
|
(!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE))
|
|
|
|
|
|
|
|
|
2008-10-21 01:20:43 +00:00
|
|
|
#define OCFS2_IS_VALID_XATTR_BLOCK(ptr) \
|
|
|
|
(!strcmp((ptr)->xb_signature, OCFS2_XATTR_BLOCK_SIGNATURE))
|
|
|
|
|
2008-12-11 01:36:25 +00:00
|
|
|
#define OCFS2_IS_VALID_DIR_TRAILER(ptr) \
|
|
|
|
(!strcmp((ptr)->db_signature, OCFS2_DIR_TRAILER_SIGNATURE))
|
|
|
|
|
2008-11-13 00:27:44 +00:00
|
|
|
#define OCFS2_IS_VALID_DX_ROOT(ptr) \
|
|
|
|
(!strcmp((ptr)->dr_signature, OCFS2_DX_ROOT_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_IS_VALID_DX_LEAF(ptr) \
|
|
|
|
(!strcmp((ptr)->dl_signature, OCFS2_DX_LEAF_SIGNATURE))
|
|
|
|
|
2009-08-18 03:19:26 +00:00
|
|
|
#define OCFS2_IS_VALID_REFCOUNT_BLOCK(ptr) \
|
|
|
|
(!strcmp((ptr)->rf_signature, OCFS2_REFCOUNT_BLOCK_SIGNATURE))
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
static inline unsigned long ino_from_blkno(struct super_block *sb,
|
|
|
|
u64 blkno)
|
|
|
|
{
|
|
|
|
return (unsigned long)(blkno & (u64)ULONG_MAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 ocfs2_clusters_to_blocks(struct super_block *sb,
|
|
|
|
u32 clusters)
|
|
|
|
{
|
|
|
|
int c_to_b_bits = OCFS2_SB(sb)->s_clustersize_bits -
|
|
|
|
sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
return (u64)clusters << c_to_b_bits;
|
|
|
|
}
|
|
|
|
|
2015-06-24 23:55:23 +00:00
|
|
|
static inline u32 ocfs2_clusters_for_blocks(struct super_block *sb,
|
|
|
|
u64 blocks)
|
|
|
|
{
|
|
|
|
int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
|
|
|
|
sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
blocks += (1 << b_to_c_bits) - 1;
|
|
|
|
return (u32)(blocks >> b_to_c_bits);
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
static inline u32 ocfs2_blocks_to_clusters(struct super_block *sb,
|
|
|
|
u64 blocks)
|
|
|
|
{
|
|
|
|
int b_to_c_bits = OCFS2_SB(sb)->s_clustersize_bits -
|
|
|
|
sb->s_blocksize_bits;
|
|
|
|
|
|
|
|
return (u32)(blocks >> b_to_c_bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int ocfs2_clusters_for_bytes(struct super_block *sb,
|
|
|
|
u64 bytes)
|
|
|
|
{
|
|
|
|
int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
unsigned int clusters;
|
|
|
|
|
|
|
|
bytes += OCFS2_SB(sb)->s_clustersize - 1;
|
|
|
|
/* OCFS2 just cannot have enough clusters to overflow this */
|
|
|
|
clusters = (unsigned int)(bytes >> cl_bits);
|
|
|
|
|
|
|
|
return clusters;
|
|
|
|
}
|
|
|
|
|
2015-02-17 00:00:00 +00:00
|
|
|
static inline unsigned int ocfs2_bytes_to_clusters(struct super_block *sb,
|
|
|
|
u64 bytes)
|
|
|
|
{
|
|
|
|
int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
unsigned int clusters;
|
|
|
|
|
|
|
|
clusters = (unsigned int)(bytes >> cl_bits);
|
|
|
|
return clusters;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
static inline u64 ocfs2_blocks_for_bytes(struct super_block *sb,
|
|
|
|
u64 bytes)
|
|
|
|
{
|
|
|
|
bytes += sb->s_blocksize - 1;
|
|
|
|
return bytes >> sb->s_blocksize_bits;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 ocfs2_clusters_to_bytes(struct super_block *sb,
|
|
|
|
u32 clusters)
|
|
|
|
{
|
|
|
|
return (u64)clusters << OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
}
|
|
|
|
|
2009-02-19 21:17:05 +00:00
|
|
|
static inline u64 ocfs2_block_to_cluster_start(struct super_block *sb,
|
|
|
|
u64 blocks)
|
|
|
|
{
|
|
|
|
int bits = OCFS2_SB(sb)->s_clustersize_bits - sb->s_blocksize_bits;
|
|
|
|
unsigned int clusters;
|
|
|
|
|
|
|
|
clusters = ocfs2_blocks_to_clusters(sb, blocks);
|
|
|
|
return (u64)clusters << bits;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
static inline u64 ocfs2_align_bytes_to_clusters(struct super_block *sb,
|
|
|
|
u64 bytes)
|
|
|
|
{
|
|
|
|
int cl_bits = OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
unsigned int clusters;
|
|
|
|
|
|
|
|
clusters = ocfs2_clusters_for_bytes(sb, bytes);
|
|
|
|
return (u64)clusters << cl_bits;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 ocfs2_align_bytes_to_blocks(struct super_block *sb,
|
|
|
|
u64 bytes)
|
|
|
|
{
|
|
|
|
u64 blocks;
|
|
|
|
|
|
|
|
blocks = ocfs2_blocks_for_bytes(sb, bytes);
|
|
|
|
return blocks << sb->s_blocksize_bits;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long ocfs2_align_bytes_to_sectors(u64 bytes)
|
|
|
|
{
|
|
|
|
return (unsigned long)((bytes + 511) >> 9);
|
|
|
|
}
|
|
|
|
|
2007-02-10 04:24:12 +00:00
|
|
|
static inline unsigned int ocfs2_page_index_to_clusters(struct super_block *sb,
|
|
|
|
unsigned long pg_index)
|
|
|
|
{
|
|
|
|
u32 clusters = pg_index;
|
|
|
|
unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
if (unlikely(PAGE_SHIFT > cbits))
|
|
|
|
clusters = pg_index << (PAGE_SHIFT - cbits);
|
|
|
|
else if (PAGE_SHIFT < cbits)
|
|
|
|
clusters = pg_index >> (cbits - PAGE_SHIFT);
|
2007-02-10 04:24:12 +00:00
|
|
|
|
|
|
|
return clusters;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the 1st page index which covers the given clusters.
|
|
|
|
*/
|
2007-07-20 18:58:36 +00:00
|
|
|
static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb,
|
2007-02-10 04:24:12 +00:00
|
|
|
u32 clusters)
|
|
|
|
{
|
|
|
|
unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
|
2007-07-20 18:58:36 +00:00
|
|
|
pgoff_t index = clusters;
|
2007-02-10 04:24:12 +00:00
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
if (PAGE_SHIFT > cbits) {
|
|
|
|
index = (pgoff_t)clusters >> (PAGE_SHIFT - cbits);
|
|
|
|
} else if (PAGE_SHIFT < cbits) {
|
|
|
|
index = (pgoff_t)clusters << (cbits - PAGE_SHIFT);
|
2007-02-10 04:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2007-02-16 19:46:50 +00:00
|
|
|
static inline unsigned int ocfs2_pages_per_cluster(struct super_block *sb)
|
|
|
|
{
|
|
|
|
unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
|
|
|
|
unsigned int pages_per_cluster = 1;
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
if (PAGE_SHIFT < cbits)
|
|
|
|
pages_per_cluster = 1 << (cbits - PAGE_SHIFT);
|
2007-02-16 19:46:50 +00:00
|
|
|
|
|
|
|
return pages_per_cluster;
|
|
|
|
}
|
|
|
|
|
2008-07-28 21:55:20 +00:00
|
|
|
static inline unsigned int ocfs2_megabytes_to_clusters(struct super_block *sb,
|
|
|
|
unsigned int megs)
|
|
|
|
{
|
|
|
|
BUILD_BUG_ON(OCFS2_MAX_CLUSTERSIZE > 1048576);
|
|
|
|
|
|
|
|
return megs << (20 - OCFS2_SB(sb)->s_clustersize_bits);
|
|
|
|
}
|
|
|
|
|
2010-04-06 01:17:13 +00:00
|
|
|
static inline unsigned int ocfs2_clusters_to_megabytes(struct super_block *sb,
|
|
|
|
unsigned int clusters)
|
|
|
|
{
|
|
|
|
return clusters >> (20 - OCFS2_SB(sb)->s_clustersize_bits);
|
|
|
|
}
|
|
|
|
|
2010-03-12 02:31:09 +00:00
|
|
|
static inline void _ocfs2_set_bit(unsigned int bit, unsigned long *bitmap)
|
|
|
|
{
|
2011-05-30 12:58:05 +00:00
|
|
|
__set_bit_le(bit, bitmap);
|
2010-03-12 02:31:09 +00:00
|
|
|
}
|
|
|
|
#define ocfs2_set_bit(bit, addr) _ocfs2_set_bit((bit), (unsigned long *)(addr))
|
|
|
|
|
|
|
|
static inline void _ocfs2_clear_bit(unsigned int bit, unsigned long *bitmap)
|
|
|
|
{
|
2011-05-30 12:58:05 +00:00
|
|
|
__clear_bit_le(bit, bitmap);
|
2010-03-12 02:31:09 +00:00
|
|
|
}
|
|
|
|
#define ocfs2_clear_bit(bit, addr) _ocfs2_clear_bit((bit), (unsigned long *)(addr))
|
|
|
|
|
2011-03-23 23:42:08 +00:00
|
|
|
#define ocfs2_test_bit test_bit_le
|
|
|
|
#define ocfs2_find_next_zero_bit find_next_zero_bit_le
|
|
|
|
#define ocfs2_find_next_bit find_next_bit_le
|
2011-11-15 22:56:34 +00:00
|
|
|
|
|
|
|
static inline void *correct_addr_and_bit_unaligned(int *bit, void *addr)
|
|
|
|
{
|
|
|
|
#if BITS_PER_LONG == 64
|
|
|
|
*bit += ((unsigned long) addr & 7UL) << 3;
|
|
|
|
addr = (void *) ((unsigned long) addr & ~7UL);
|
|
|
|
#elif BITS_PER_LONG == 32
|
|
|
|
*bit += ((unsigned long) addr & 3UL) << 3;
|
|
|
|
addr = (void *) ((unsigned long) addr & ~3UL);
|
|
|
|
#else
|
|
|
|
#error "how many bits you are?!"
|
|
|
|
#endif
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_set_bit_unaligned(int bit, void *bitmap)
|
|
|
|
{
|
|
|
|
bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
|
|
|
|
ocfs2_set_bit(bit, bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_clear_bit_unaligned(int bit, void *bitmap)
|
|
|
|
{
|
|
|
|
bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
|
|
|
|
ocfs2_clear_bit(bit, bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_test_bit_unaligned(int bit, void *bitmap)
|
|
|
|
{
|
|
|
|
bitmap = correct_addr_and_bit_unaligned(&bit, bitmap);
|
|
|
|
return ocfs2_test_bit(bit, bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ocfs2_find_next_zero_bit_unaligned(void *bitmap, int max,
|
|
|
|
int start)
|
|
|
|
{
|
|
|
|
int fix = 0, ret, tmpmax;
|
|
|
|
bitmap = correct_addr_and_bit_unaligned(&fix, bitmap);
|
|
|
|
tmpmax = max + fix;
|
|
|
|
start += fix;
|
|
|
|
|
|
|
|
ret = ocfs2_find_next_zero_bit(bitmap, tmpmax, start) - fix;
|
|
|
|
if (ret > max)
|
|
|
|
return max;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:24 +00:00
|
|
|
#endif /* OCFS2_H */
|
|
|
|
|