mirror of
https://github.com/versity/scoutfs.git
synced 2026-07-23 08:23:15 +00:00
Zach Brown
08a140c8b0
Convert client locking to call the server's lock service instead of using a fs/dlm lockspace. The client code gets some shims to send and receive lock messages to and from the server. Callers use our lock mode constants instead of the DLM's. Locks are now identified by their starting key instead of an additional scoped lock name so that we don't have more mapping structures to track. The global rename lock uses keys that are defined by the format as only used for locking. The biggest change is in the client lock state machine. Instead of calling the dlm and getting callbacks we send messages to our server and get called from incoming message processing. We don't have everything come through a per-lock work queue. Instead we send requests either from the blocking lock caller or from a shrink work queue. Incoming messages are called in the net layer's blocking work contexts so we don't need to do any more work to defer to other contexts. The different processing contexts leads to a slightly different lock life cycle. We refactor and seperate allocation and freeing from tracking and removing locks in data structures. We add a _get and _put to track active use of locks and then async references to locks by holders and requests are tracked seperately. Our lock service's rules are a bit simpler in that we'll only ever send one request at a time and the server will only ever send one request at a time. We do have to do a bit of work to make sure we process back to back grant reponses and invalidation requests from the server. As of this change the lock setup and destruction paths are a little wobbly. They'll be shored up as we add lock recovery between the client and server. Signed-off-by: Zach Brown <zab@versity.com>
92 lines
3.1 KiB
C
92 lines
3.1 KiB
C
#ifndef _SCOUTFS_LOCK_H_
|
|
#define _SCOUTFS_LOCK_H_
|
|
|
|
#include "key.h"
|
|
#include "tseq.h"
|
|
|
|
#define SCOUTFS_LKF_REFRESH_INODE 0x01 /* update stale inode from item */
|
|
#define SCOUTFS_LKF_NONBLOCK 0x02 /* only use already held locks */
|
|
#define SCOUTFS_LKF_INVALID (~((SCOUTFS_LKF_NONBLOCK << 1) - 1))
|
|
|
|
#define SCOUTFS_LOCK_NR_MODES SCOUTFS_LOCK_INVALID
|
|
|
|
/*
|
|
* A few fields (start, end, refresh_gen, granted_mode) are referenced
|
|
* by code outside lock.c.
|
|
*/
|
|
struct scoutfs_lock {
|
|
struct super_block *sb;
|
|
struct scoutfs_key start;
|
|
struct scoutfs_key end;
|
|
struct rb_node node;
|
|
struct rb_node range_node;
|
|
u64 refresh_gen;
|
|
struct list_head lru_head;
|
|
wait_queue_head_t waitq;
|
|
struct work_struct shrink_work;
|
|
ktime_t grace_deadline;
|
|
unsigned long request_pending:1,
|
|
invalidate_pending:1;
|
|
|
|
spinlock_t cov_list_lock;
|
|
struct list_head cov_list;
|
|
|
|
int mode;
|
|
unsigned int waiters[SCOUTFS_LOCK_NR_MODES];
|
|
unsigned int users[SCOUTFS_LOCK_NR_MODES];
|
|
|
|
struct scoutfs_tseq_entry tseq_entry;
|
|
};
|
|
|
|
struct scoutfs_lock_coverage {
|
|
spinlock_t cov_lock;
|
|
struct scoutfs_lock *lock;
|
|
struct list_head head;
|
|
};
|
|
|
|
int scoutfs_lock_grant_response(struct super_block *sb,
|
|
struct scoutfs_net_lock *nl);
|
|
int scoutfs_lock_invalidate_request(struct super_block *sb, u64 net_id,
|
|
struct scoutfs_net_lock *nl);
|
|
|
|
int scoutfs_lock_inode(struct super_block *sb, int mode, int flags,
|
|
struct inode *inode, struct scoutfs_lock **ret_lock);
|
|
int scoutfs_lock_ino(struct super_block *sb, int mode, int flags, u64 ino,
|
|
struct scoutfs_lock **ret_lock);
|
|
void scoutfs_lock_get_index_item_range(u8 type, u64 major, u64 ino,
|
|
struct scoutfs_key *start,
|
|
struct scoutfs_key *end);
|
|
int scoutfs_lock_inode_index(struct super_block *sb, int mode,
|
|
u8 type, u64 major, u64 ino,
|
|
struct scoutfs_lock **ret_lock);
|
|
int scoutfs_lock_inodes(struct super_block *sb, int mode, int flags,
|
|
struct inode *a, struct scoutfs_lock **a_lock,
|
|
struct inode *b, struct scoutfs_lock **b_lock,
|
|
struct inode *c, struct scoutfs_lock **c_lock,
|
|
struct inode *d, struct scoutfs_lock **D_lock);
|
|
int scoutfs_lock_rename(struct super_block *sb, int mode, int flags,
|
|
struct scoutfs_lock **lock);
|
|
int scoutfs_lock_node_id(struct super_block *sb, int mode, int flags,
|
|
u64 node_id, struct scoutfs_lock **lock);
|
|
void scoutfs_unlock(struct super_block *sb, struct scoutfs_lock *lock,
|
|
int level);
|
|
void scoutfs_unlock_flags(struct super_block *sb, struct scoutfs_lock *lock,
|
|
int level, int flags);
|
|
|
|
void scoutfs_lock_init_coverage(struct scoutfs_lock_coverage *cov);
|
|
void scoutfs_lock_add_coverage(struct super_block *sb,
|
|
struct scoutfs_lock *lock,
|
|
struct scoutfs_lock_coverage *cov);
|
|
bool scoutfs_lock_is_covered(struct super_block *sb,
|
|
struct scoutfs_lock_coverage *cov);
|
|
void scoutfs_lock_del_coverage(struct super_block *sb,
|
|
struct scoutfs_lock_coverage *cov);
|
|
|
|
void scoutfs_free_unused_locks(struct super_block *sb, unsigned long nr);
|
|
|
|
int scoutfs_lock_setup(struct super_block *sb);
|
|
void scoutfs_lock_shutdown(struct super_block *sb);
|
|
void scoutfs_lock_destroy(struct super_block *sb);
|
|
|
|
#endif
|