mirror of
https://github.com/versity/scoutfs.git
synced 2026-07-24 00:53:01 +00:00
Zach Brown
b7bbad1fba
We had a simple mechanism for ensuring that transaction didn't create more items than would fit in a single written segment. We calculated the most dirty items that a holder could generate and assumed that all holders dirtied that much. This had two big problems. The first was that it wasn't accounting for nested holds. write_begin/end calls the generic inode dirtying path whild holding a transaction. This ended up deadlocking as the dirty inode waited to be able to write while its trans held back in write_begin prevented writeout. The second was that the worst case (full size xattr) item dirtying is enormous and meaningfully restricts concurrent transaction holders. With no currently dirty items you can have less than 16 full size xattr writes. This concurrency limit only gets worse as the transaction fills up with dirty items. This fixes those problems. It adds precise accounting of the dirty items that can be created while a transaction is held. These reservations are tracked in journal_info so that they can be used by nested holds. The precision allows much greater concurrency as something like a create will try to reserve a few hundreds bytes instead of 64k. Normal sized xattr operations won't try to reserve the largest possible space. We add some feedback from the item cache to the transaction to issue warnings if a holder dirties more items than it reserved. Now that we have precise item/key/value counts (segment space consumption is a function of all three :/) we can't have a single atomic track transaction holders. We add a long-overdue trans_info and put a proper lock and fields there and much more clearly track transaction serialization amongst the holders and writer. Signed-off-by: Zach Brown <zab@versity.com>
69 lines
1.4 KiB
C
69 lines
1.4 KiB
C
#ifndef _SCOUTFS_SUPER_H_
|
|
#define _SCOUTFS_SUPER_H_
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/rbtree.h>
|
|
|
|
#include "format.h"
|
|
|
|
struct scoutfs_counters;
|
|
struct item_cache;
|
|
struct manifest;
|
|
struct segment_cache;
|
|
struct compact_info;
|
|
struct data_info;
|
|
struct trans_info;
|
|
struct lock_info;
|
|
struct net_info;
|
|
struct inode_sb_info;
|
|
|
|
struct scoutfs_sb_info {
|
|
struct super_block *sb;
|
|
|
|
u64 node_id;
|
|
|
|
struct scoutfs_super_block super;
|
|
|
|
spinlock_t next_ino_lock;
|
|
|
|
struct manifest *manifest;
|
|
struct item_cache *item_cache;
|
|
struct segment_cache *segment_cache;
|
|
struct seg_alloc *seg_alloc;
|
|
struct compact_info *compact_info;
|
|
struct data_info *data_info;
|
|
struct inode_sb_info *inode_sb_info;
|
|
|
|
wait_queue_head_t trans_hold_wq;
|
|
struct task_struct *trans_task;
|
|
|
|
spinlock_t trans_write_lock;
|
|
u64 trans_write_count;
|
|
u64 trans_seq;
|
|
int trans_write_ret;
|
|
struct delayed_work trans_write_work;
|
|
wait_queue_head_t trans_write_wq;
|
|
struct workqueue_struct *trans_write_workq;
|
|
bool trans_deadline_expired;
|
|
|
|
struct trans_info *trans_info;
|
|
struct lock_info *lock_info;
|
|
struct net_info *net_info;
|
|
|
|
/* $sysfs/fs/scoutfs/$id/ */
|
|
struct kset *kset;
|
|
|
|
struct scoutfs_counters *counters;
|
|
};
|
|
|
|
static inline struct scoutfs_sb_info *SCOUTFS_SB(struct super_block *sb)
|
|
{
|
|
return sb->s_fs_info;
|
|
}
|
|
|
|
int scoutfs_read_supers(struct super_block *sb);
|
|
void scoutfs_advance_dirty_super(struct super_block *sb);
|
|
int scoutfs_write_dirty_super(struct super_block *sb);
|
|
|
|
#endif
|