2005-12-15 23:31:24 +01:00
|
|
|
/* -*- mode: c; c-basic-offset: 8; -*-
|
|
|
|
* vim: noexpandtab sw=8 ts=8 sts=0:
|
|
|
|
*
|
|
|
|
* ocfs2.h
|
|
|
|
*
|
|
|
|
* Defines macros and structures used in OCFS2
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002, 2004 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef OCFS2_H
|
|
|
|
#define OCFS2_H
|
|
|
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/kref.h>
|
2006-01-14 06:54:23 +01:00
|
|
|
#include <linux/mutex.h>
|
2008-09-04 05:03:41 +02:00
|
|
|
#ifndef CONFIG_OCFS2_COMPAT_JBD
|
|
|
|
# include <linux/jbd2.h>
|
|
|
|
#else
|
|
|
|
# include <linux/jbd.h>
|
|
|
|
# include "ocfs2_jbd_compat.h"
|
|
|
|
#endif
|
2005-12-15 23:31:24 +01:00
|
|
|
|
2008-02-01 21:16:57 +01:00
|
|
|
/* For union ocfs2_dlm_lksb */
|
|
|
|
#include "stackglue.h"
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
#include "ocfs2_fs.h"
|
|
|
|
#include "ocfs2_lockid.h"
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
#define OCFS2_INODE_MAX_CACHE_ARRAY 2
|
|
|
|
|
|
|
|
struct ocfs2_caching_info {
|
|
|
|
unsigned int ci_num_cached;
|
|
|
|
union {
|
|
|
|
sector_t ci_array[OCFS2_INODE_MAX_CACHE_ARRAY];
|
|
|
|
struct rb_root ci_tree;
|
|
|
|
} ci_cache;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
#define OCFS2_LOCK_ATTACHED (0x00000001) /* have we initialized
|
|
|
|
* 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 01:43:10 +01: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 23:45:08 +01:00
|
|
|
#define OCFS2_LOCK_PENDING (0x00000400) /* This lockres is pending a
|
|
|
|
call to dlm_lock. Only
|
|
|
|
exists with BUSY set. */
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
struct ocfs2_lock_res_ops;
|
|
|
|
|
|
|
|
typedef void (*ocfs2_lock_callback)(int status, unsigned long data);
|
|
|
|
|
|
|
|
struct ocfs2_lock_res {
|
|
|
|
void *l_priv;
|
|
|
|
struct ocfs2_lock_res_ops *l_ops;
|
|
|
|
spinlock_t l_lock;
|
|
|
|
|
|
|
|
struct list_head l_blocked_list;
|
|
|
|
struct list_head l_mask_waiters;
|
|
|
|
|
|
|
|
enum ocfs2_lock_type l_type;
|
|
|
|
unsigned long l_flags;
|
|
|
|
char l_name[OCFS2_LOCK_ID_MAX_LEN];
|
|
|
|
int l_level;
|
|
|
|
unsigned int l_ro_holders;
|
|
|
|
unsigned int l_ex_holders;
|
2008-02-01 21:16:57 +01:00
|
|
|
union ocfs2_dlm_lksb l_lksb;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
/* used from AST/BAST funcs. */
|
|
|
|
enum ocfs2_ast_action l_action;
|
|
|
|
enum ocfs2_unlock_action l_unlock_action;
|
|
|
|
int l_requested;
|
|
|
|
int l_blocking;
|
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 23:45:08 +01:00
|
|
|
unsigned int l_pending_gen;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
wait_queue_head_t l_event;
|
|
|
|
|
|
|
|
struct list_head l_debug_list;
|
2008-05-13 22:45:15 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_OCFS2_FS_STATS
|
|
|
|
unsigned long long l_lock_num_prmode; /* PR acquires */
|
|
|
|
unsigned long long l_lock_num_exmode; /* EX acquires */
|
|
|
|
unsigned int l_lock_num_prmode_failed; /* Failed PR gets */
|
|
|
|
unsigned int l_lock_num_exmode_failed; /* Failed EX gets */
|
|
|
|
unsigned long long l_lock_total_prmode; /* Tot wait for PR */
|
|
|
|
unsigned long long l_lock_total_exmode; /* Tot wait for EX */
|
|
|
|
unsigned int l_lock_max_prmode; /* Max wait for PR */
|
|
|
|
unsigned int l_lock_max_exmode; /* Max wait for EX */
|
|
|
|
unsigned int l_lock_refresh; /* Disk refreshes */
|
|
|
|
#endif
|
2005-12-15 23:31:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ocfs2_dlm_debug {
|
|
|
|
struct kref d_refcnt;
|
|
|
|
struct dentry *d_locking_state;
|
|
|
|
struct list_head d_lockres_tracking;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_vol_state
|
|
|
|
{
|
|
|
|
VOLUME_INIT = 0,
|
|
|
|
VOLUME_MOUNTED,
|
|
|
|
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 03:02:53 +02: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 23:31:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
enum ocfs2_mount_options
|
|
|
|
{
|
|
|
|
OCFS2_MOUNT_HB_LOCAL = 1 << 0, /* Heartbeat started in local mode */
|
|
|
|
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 01:49:04 +01:00
|
|
|
OCFS2_MOUNT_LOCALFLOCKS = 1 << 5, /* No cluster aware user file locks */
|
2008-08-18 11:11:00 +02:00
|
|
|
OCFS2_MOUNT_NOUSERXATTR = 1 << 6, /* No user xattr */
|
2008-09-04 05:03:40 +02:00
|
|
|
OCFS2_MOUNT_INODE64 = 1 << 7, /* Allow inode numbers > 2^32 */
|
2005-12-15 23:31:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define OCFS2_OSB_SOFT_RO 0x0001
|
|
|
|
#define OCFS2_OSB_HARD_RO 0x0002
|
|
|
|
#define OCFS2_OSB_ERROR_FS 0x0004
|
2006-11-15 08:48:42 +01:00
|
|
|
#define OCFS2_DEFAULT_ATIME_QUANTUM 60
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
struct ocfs2_journal;
|
2008-02-01 21:01:05 +01:00
|
|
|
struct ocfs2_slot_info;
|
2008-02-01 21:03:57 +01:00
|
|
|
struct ocfs2_recovery_map;
|
2005-12-15 23:31:24 +01:00
|
|
|
struct ocfs2_super
|
|
|
|
{
|
|
|
|
struct task_struct *commit_task;
|
|
|
|
struct super_block *sb;
|
|
|
|
struct inode *root_inode;
|
|
|
|
struct inode *sys_root_inode;
|
|
|
|
struct inode *system_inodes[NUM_SYSTEM_INODES];
|
|
|
|
|
|
|
|
struct ocfs2_slot_info *slot_info;
|
|
|
|
|
2008-07-15 02:31:10 +02:00
|
|
|
u32 *slot_recovery_generations;
|
|
|
|
|
2005-12-15 23:31:24 +01:00
|
|
|
spinlock_t node_map_lock;
|
|
|
|
|
|
|
|
u64 root_blkno;
|
|
|
|
u64 system_dir_blkno;
|
|
|
|
u64 bitmap_blkno;
|
|
|
|
u32 bitmap_cpg;
|
|
|
|
u8 *uuid;
|
|
|
|
char *uuid_str;
|
2008-08-18 11:11:00 +02:00
|
|
|
u32 uuid_hash;
|
2005-12-15 23:31:24 +01: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 09:11:46 +01: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 23:31:24 +01:00
|
|
|
spinlock_t osb_lock;
|
|
|
|
u32 s_next_generation;
|
|
|
|
unsigned long osb_flags;
|
2008-03-05 09:11:46 +01:00
|
|
|
s16 s_inode_steal_slot;
|
|
|
|
atomic_t s_num_inodes_stolen;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
unsigned long s_mount_opt;
|
2006-11-15 08:48:42 +01:00
|
|
|
unsigned int s_atime_quantum;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
2008-02-01 21:04:48 +01:00
|
|
|
unsigned int max_slots;
|
2008-01-31 00:38:24 +01:00
|
|
|
unsigned int node_num;
|
2008-02-01 21:04:48 +01:00
|
|
|
int slot_num;
|
|
|
|
int preferred_slot;
|
2005-12-15 23:31:24 +01:00
|
|
|
int s_sectsize_bits;
|
|
|
|
int s_clustersize;
|
|
|
|
int s_clustersize_bits;
|
2008-08-18 11:08:55 +02:00
|
|
|
unsigned int s_xattr_inline_size;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
atomic_t vol_state;
|
2006-01-14 06:54:23 +01:00
|
|
|
struct mutex recovery_lock;
|
2008-02-01 21:03:57 +01:00
|
|
|
struct ocfs2_recovery_map *recovery_map;
|
2005-12-15 23:31:24 +01:00
|
|
|
struct task_struct *recovery_thread_task;
|
|
|
|
int disable_recovery;
|
|
|
|
wait_queue_head_t checkpoint_event;
|
|
|
|
atomic_t needs_checkpoint;
|
|
|
|
struct ocfs2_journal *journal;
|
2007-11-07 23:40:36 +01:00
|
|
|
unsigned long osb_commit_interval;
|
2005-12-15 23:31:24 +01: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 03:02:53 +02: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 23:55:20 +02: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 03:02:53 +02:00
|
|
|
unsigned int local_alloc_default_bits;
|
|
|
|
|
|
|
|
enum ocfs2_local_alloc_state local_alloc_state; /* protected
|
|
|
|
* by osb_lock */
|
|
|
|
|
2005-12-15 23:31:24 +01: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 03:02:53 +02:00
|
|
|
|
2006-06-05 22:41:00 +02:00
|
|
|
u64 la_last_gd;
|
2005-12-15 23:31:24 +01:00
|
|
|
|
2008-07-30 03:29:18 +02:00
|
|
|
#ifdef CONFIG_OCFS2_FS_STATS
|
|
|
|
struct dentry *local_alloc_debug;
|
|
|
|
char *local_alloc_debug_buf;
|
|
|
|
#endif
|
|
|
|
|
2005-12-15 23:31:24 +01:00
|
|
|
/* Next two fields are for local node slot recovery during
|
|
|
|
* mount. */
|
|
|
|
int dirty;
|
|
|
|
struct ocfs2_dinode *local_alloc_copy;
|
|
|
|
|
|
|
|
struct ocfs2_alloc_stats alloc_stats;
|
|
|
|
char dev_str[20]; /* "major,minor" of the device */
|
|
|
|
|
2008-02-02 00:08:23 +01:00
|
|
|
char osb_cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
|
2008-02-01 23:39:35 +01:00
|
|
|
struct ocfs2_cluster_connection *cconn;
|
2005-12-15 23:31:24 +01:00
|
|
|
struct ocfs2_lock_res osb_super_lockres;
|
|
|
|
struct ocfs2_lock_res osb_rename_lockres;
|
|
|
|
struct ocfs2_dlm_debug *osb_dlm_debug;
|
|
|
|
|
|
|
|
struct dentry *osb_debug_root;
|
|
|
|
|
|
|
|
wait_queue_head_t recovery_event;
|
|
|
|
|
2007-09-25 00:56:19 +02: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 23:31:24 +01:00
|
|
|
|
2008-01-24 01:54:48 +01: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 23:31:24 +01:00
|
|
|
struct list_head blocked_lock_list;
|
|
|
|
unsigned long blocked_lock_count;
|
|
|
|
|
|
|
|
wait_queue_head_t osb_mount_event;
|
|
|
|
|
|
|
|
/* Truncate log info */
|
|
|
|
struct inode *osb_tl_inode;
|
|
|
|
struct buffer_head *osb_tl_bh;
|
2006-11-22 15:57:56 +01:00
|
|
|
struct delayed_work osb_truncate_log_wq;
|
2006-02-23 02:35:08 +01:00
|
|
|
|
|
|
|
struct ocfs2_node_map osb_recovering_orphan_dirs;
|
|
|
|
unsigned int *osb_orphan_wipes;
|
|
|
|
wait_queue_head_t osb_wipe_event;
|
2005-12-15 23:31:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define OCFS2_SB(sb) ((struct ocfs2_super *)(sb)->s_fs_info)
|
|
|
|
|
|
|
|
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 20:32:23 +01: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 19:48:04 +02: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;
|
|
|
|
}
|
|
|
|
|
2007-09-07 22:58:15 +02: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 11:11:46 +02:00
|
|
|
static inline int ocfs2_supports_xattr(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
if (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_XATTR)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-15 23:31:24 +01: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;
|
|
|
|
}
|
|
|
|
|
2008-02-02 00:08:23 +01:00
|
|
|
static inline int ocfs2_userspace_stack(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
return (osb->s_feature_incompat &
|
|
|
|
OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK);
|
|
|
|
}
|
|
|
|
|
2006-12-06 02:56:35 +01:00
|
|
|
static inline int ocfs2_mount_local(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
return (osb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT);
|
|
|
|
}
|
|
|
|
|
2008-02-01 21:06:54 +01: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 23:31:24 +01:00
|
|
|
#define OCFS2_IS_VALID_DINODE(ptr) \
|
|
|
|
(!strcmp((ptr)->i_signature, OCFS2_INODE_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_RO_ON_INVALID_DINODE(__sb, __di) do { \
|
|
|
|
typeof(__di) ____di = (__di); \
|
|
|
|
ocfs2_error((__sb), \
|
2006-03-03 19:24:33 +01:00
|
|
|
"Dinode # %llu has bad signature %.*s", \
|
2007-04-28 01:01:25 +02:00
|
|
|
(unsigned long long)le64_to_cpu((____di)->i_blkno), 7, \
|
2005-12-15 23:31:24 +01:00
|
|
|
(____di)->i_signature); \
|
2007-04-28 01:01:25 +02:00
|
|
|
} while (0)
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
#define OCFS2_IS_VALID_EXTENT_BLOCK(ptr) \
|
|
|
|
(!strcmp((ptr)->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_RO_ON_INVALID_EXTENT_BLOCK(__sb, __eb) do { \
|
|
|
|
typeof(__eb) ____eb = (__eb); \
|
|
|
|
ocfs2_error((__sb), \
|
2006-03-03 19:24:33 +01:00
|
|
|
"Extent Block # %llu has bad signature %.*s", \
|
2007-04-28 01:01:25 +02:00
|
|
|
(unsigned long long)le64_to_cpu((____eb)->h_blkno), 7, \
|
2005-12-15 23:31:24 +01:00
|
|
|
(____eb)->h_signature); \
|
2007-04-28 01:01:25 +02:00
|
|
|
} while (0)
|
2005-12-15 23:31:24 +01:00
|
|
|
|
|
|
|
#define OCFS2_IS_VALID_GROUP_DESC(ptr) \
|
|
|
|
(!strcmp((ptr)->bg_signature, OCFS2_GROUP_DESC_SIGNATURE))
|
|
|
|
|
|
|
|
#define OCFS2_RO_ON_INVALID_GROUP_DESC(__sb, __gd) do { \
|
|
|
|
typeof(__gd) ____gd = (__gd); \
|
|
|
|
ocfs2_error((__sb), \
|
2006-03-03 19:24:33 +01:00
|
|
|
"Group Descriptor # %llu has bad signature %.*s", \
|
2007-04-28 01:01:25 +02:00
|
|
|
(unsigned long long)le64_to_cpu((____gd)->bg_blkno), 7, \
|
2005-12-15 23:31:24 +01:00
|
|
|
(____gd)->bg_signature); \
|
2007-04-28 01:01:25 +02:00
|
|
|
} while (0)
|
2005-12-15 23:31:24 +01: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 05:24:12 +01: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;
|
|
|
|
|
|
|
|
if (unlikely(PAGE_CACHE_SHIFT > cbits))
|
|
|
|
clusters = pg_index << (PAGE_CACHE_SHIFT - cbits);
|
|
|
|
else if (PAGE_CACHE_SHIFT < cbits)
|
|
|
|
clusters = pg_index >> (cbits - PAGE_CACHE_SHIFT);
|
|
|
|
|
|
|
|
return clusters;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the 1st page index which covers the given clusters.
|
|
|
|
*/
|
2007-07-20 20:58:36 +02:00
|
|
|
static inline pgoff_t ocfs2_align_clusters_to_page_index(struct super_block *sb,
|
2007-02-10 05:24:12 +01:00
|
|
|
u32 clusters)
|
|
|
|
{
|
|
|
|
unsigned int cbits = OCFS2_SB(sb)->s_clustersize_bits;
|
2007-07-20 20:58:36 +02:00
|
|
|
pgoff_t index = clusters;
|
2007-02-10 05:24:12 +01:00
|
|
|
|
|
|
|
if (PAGE_CACHE_SHIFT > cbits) {
|
2007-07-20 20:58:36 +02:00
|
|
|
index = (pgoff_t)clusters >> (PAGE_CACHE_SHIFT - cbits);
|
2007-02-10 05:24:12 +01:00
|
|
|
} else if (PAGE_CACHE_SHIFT < cbits) {
|
2007-07-20 20:58:36 +02:00
|
|
|
index = (pgoff_t)clusters << (cbits - PAGE_CACHE_SHIFT);
|
2007-02-10 05:24:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2007-02-16 20:46:50 +01: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;
|
|
|
|
|
|
|
|
if (PAGE_CACHE_SHIFT < cbits)
|
|
|
|
pages_per_cluster = 1 << (cbits - PAGE_CACHE_SHIFT);
|
|
|
|
|
|
|
|
return pages_per_cluster;
|
|
|
|
}
|
|
|
|
|
2008-07-28 23:55:20 +02: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);
|
|
|
|
}
|
|
|
|
|
2008-03-05 09:11:46 +01:00
|
|
|
static inline void ocfs2_init_inode_steal_slot(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
osb->s_inode_steal_slot = OCFS2_INVALID_SLOT;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
atomic_set(&osb->s_num_inodes_stolen, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ocfs2_set_inode_steal_slot(struct ocfs2_super *osb,
|
|
|
|
s16 slot)
|
|
|
|
{
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
osb->s_inode_steal_slot = slot;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline s16 ocfs2_get_inode_steal_slot(struct ocfs2_super *osb)
|
|
|
|
{
|
|
|
|
s16 slot;
|
|
|
|
|
|
|
|
spin_lock(&osb->osb_lock);
|
|
|
|
slot = osb->s_inode_steal_slot;
|
|
|
|
spin_unlock(&osb->osb_lock);
|
|
|
|
|
|
|
|
return slot;
|
|
|
|
}
|
|
|
|
|
2005-12-15 23:31:24 +01:00
|
|
|
#define ocfs2_set_bit ext2_set_bit
|
|
|
|
#define ocfs2_clear_bit ext2_clear_bit
|
|
|
|
#define ocfs2_test_bit ext2_test_bit
|
|
|
|
#define ocfs2_find_next_zero_bit ext2_find_next_zero_bit
|
|
|
|
#endif /* OCFS2_H */
|
|
|
|
|