shapor / tux3 / changeset / d5a5e6bba24e

@@ -49,7 +49,7 @@ int main(int argc, char *argv[])
 		free(bitmap);
+	}
 	struct dev *dev = &(struct dev){ .bits = 3 };
-	struct sb *sb = &(struct sb){ INIT_SB(dev), .super = { .volblocks = to_be_u64(150) }, };
+	struct sb *sb = rapid_sb(dev, .super = { .volblocks = to_be_u64(150) });
 	struct inode *bitmap = rapid_open_inode(sb, NULL, 0);
 	sb->freeblocks = from_be_u64(sb->super.volblocks);
 	sb->nextalloc = from_be_u64(sb->super.volblocks); // this should wrap around to zero

@@ -161,7 +161,7 @@ static void tree_expand_test(struct curs
 int main(int argc, char *argv[])
+{
 	struct dev *dev = &(struct dev){ .bits = 6 };
-	struct sb *sb = &(struct sb){ INIT_SB(dev), };
+	struct sb *sb = rapid_sb(dev);
 	sb->volmap = rapid_open_inode(sb, NULL, 0);
 	sb->logmap = rapid_open_inode(sb, dev_errio, 0);
 	init_buffers(dev, 1 << 20, 0);

@@ -135,12 +135,10 @@ int main(int argc, char *argv[])
 	assert(!ftruncate(fd, volsize));
 	struct dev *dev = &(struct dev){ .fd = fd, .bits = 12 };
 	init_buffers(dev, 1 << 20, 0);
 	struct sb *sb = &(struct sb){
 		INIT_SB(dev),
 	struct sb *sb = rapid_sb(dev,
 		.max_inodes_per_block = 64,
 		.entries_per_node = 20,
 		.volblocks = volsize >> dev->bits,
 	};
 		.volblocks = volsize >> dev->bits);
 	sb->volmap = rapid_open_inode(sb, NULL, 0);
 	sb->logmap = rapid_open_inode(sb, dev_errio, 0);
 	assert(!make_tux3(sb));

 #include "tux3.h"	/* include user/tux3.h, not user/kernel/tux3.h */
 #include "hexdump.c"
 #define mark_inode_dirty(x)
 #ifndef trace
 #define trace trace_off
 #endif
@@ -82,7 +80,7 @@ int filldir(void *entry, char *name, uns
 int main(int argc, char *argv[])
+{
 	struct dev *dev = &(struct dev){ .bits = 8 };
-	struct sb *sb = &(struct sb){ INIT_SB(dev), .super = { .volblocks = to_be_u64(150) }, };
+	struct sb *sb = rapid_sb(dev, .super = { .volblocks = to_be_u64(150) });
 	struct inode *dir = rapid_open_inode(sb, NULL, S_IFDIR);
 	init_buffers(dev, 1 << 20, 0);
 	struct buffer_head *buffer;

@@ -175,12 +175,10 @@ int main(int argc, char *argv[])
 	if (fdsize64(fd, &size))
 		error("fdsize64 failed for '%s' (%s)", name, strerror(errno));
 	struct dev *dev = &(struct dev){ .fd = fd, .bits = 8 };
 	struct sb *sb = &(struct sb){
 		INIT_SB(dev),
 	struct sb *sb = rapid_sb(dev,
 		.max_inodes_per_block = 64,
 		.entries_per_node = 20,
 		.volblocks = size >> dev->bits,
 	};
 		.volblocks = size >> dev->bits);
 	sb->volmap = rapid_open_inode(sb, NULL, 0);
 	sb->logmap = rapid_open_inode(sb, NULL, 0);
 	sb->bitmap = rapid_open_inode(sb, filemap_extent_io, 0);

 int main(int argc, char *argv[])
+{
 	unsigned abits = DATA_BTREE_BIT|CTIME_SIZE_BIT|MODE_OWNER_BIT|LINK_COUNT_BIT|MTIME_BIT;
 	struct sb *sb = &(struct sb){ .version = 0, .blocksize = 1 << 9, };
 	struct inode *inode = &(struct inode){
-		INIT_INODE(sb, 0x666),
+	struct dev *dev = &(struct dev){ .bits = 9 };
 	struct sb *sb = rapid_sb(dev, .version = 0);
 	struct inode *inode = rapid_open_inode(sb, NULL, 0x666,
 		.present = abits, .i_uid = 0x12121212, .i_gid = 0x34343434,
 		.btree = { .root = { .block = 0xcaba1f00dULL, .depth = 3 } },
 		.i_size = 0x123456789ULL,
 		.i_ctime = spectime(0xdec0debeadULL),
-		.i_mtime = spectime(0xbadfaced00dULL) };
+		.i_mtime = spectime(0xbadfaced00dULL));
 	inode->btree = (struct btree){
 		.root = { .block = 0xcaba1f00dULL, .depth = 3 }
 	};
 	char attrs[1000] = { };
 	printf("%i attributes starting from %i\n", MAX_ATTRS - MIN_ATTR, MIN_ATTR);

@@ -21,7 +21,7 @@ struct inode *new_inode(struct sb *sb)
 	struct inode *inode = malloc(sizeof(*inode));
 	if (!inode)
 		goto error;
-	*inode = (struct inode){ INIT_INODE(sb, 0), };
+	*inode = (struct inode){ INIT_INODE(*inode, sb, 0), };
 	inode->map = new_map(sb->dev, NULL);
 	if (!inode->map)
 		goto error_map;
@@ -274,7 +274,15 @@ int tuxsync(struct inode *inode)
 	int err;
 	if ((err = tuxflush(inode)))
 		return err;
 #if 0
 	if (!list_empty(&inode->dirty)) {
 		list_del_init(&inode->dirty);
 		return save_inode(inode);
+	}
 	return 0;
 #else
 	return save_inode(inode);
 #endif
+}
 void tuxclose(struct inode *inode)
@@ -302,12 +310,10 @@ int main(int argc, char *argv[])
 		error("fdsize64 failed for '%s' (%s)", name, strerror(errno));
 	struct dev *dev = &(struct dev){ .fd = fd, .bits = 12 };
 	init_buffers(dev, 1 << 20, 0);
 	struct sb *sb = &(struct sb){
 		INIT_SB(dev),
 	struct sb *sb = rapid_sb(dev,
 		.max_inodes_per_block = 64,
 		.entries_per_node = 20,
 		.volblocks = size >> dev->bits,
 	};
 		.volblocks = size >> dev->bits);
 	sb->volmap = rapid_open_inode(sb, NULL, 0);
 	sb->logmap = rapid_open_inode(sb, NULL, 0);

@@ -12,7 +12,9 @@ static struct kmem_cache *tux_inode_cach
 static void tux3_inode_init_once(void *mem)
+{
-	inode_init_once(&((tuxnode_t *)mem)->vfs_inode);
+	tuxnode_t *tuxi = mem;
 	INIT_LIST_HEAD(&tuxi->dirty);
 	inode_init_once(&tuxi->vfs_inode);
+}
 static int __init tux3_init_inodecache(void)
@@ -39,6 +41,7 @@ static struct inode *tux3_alloc_inode(st
 	tuxi->btree = (struct btree){ };
 	tuxi->present = 0;
 	tuxi->xcache = NULL;
 	BUG_ON(!list_empty(&tuxi->dirty));
 	/* uninitialized stuff by alloc_inode() */
 	tuxi->vfs_inode.i_version = 1;
@@ -157,6 +160,7 @@ static int tux3_fill_super(struct super_
 	sb->s_time_gran = 1;
 	mutex_init(&sbi->loglock);
 	INIT_LIST_HEAD(&sbi->dirty_inodes);
 	err = -EIO;
 	blocksize = sb_min_blocksize(sb, BLOCK_SIZE);

@@ -321,6 +321,7 @@ struct sb {
 	unsigned char *logpos, *logtop; /* Where to emit next log entry */
 	struct mutex loglock;	/* serialize log entries (spinlock me) */
 	struct stash defree;	/* defer extent frees until affer commit */
 	struct list_head dirty_inodes; /* dirty inodes list */
 #ifdef __KERNEL__
 	struct super_block *vfs_sb; /* Generic kernel superblock */
 #else
@@ -350,6 +351,7 @@ typedef struct {
 	inum_t inum;		/* Inode number.  Fixme: also in generic inode */
 	unsigned present;	/* Attributes decoded from or to be encoded to inode table */
 	struct xcache *xcache;	/* Extended attribute cache */
 	struct list_head dirty; /* link for dirty inodes */
 	struct inode vfs_inode;	/* Generic kernel inode */
 } tuxnode_t;
@@ -396,6 +398,7 @@ typedef struct inode {
 	inum_t inum;
 	unsigned present;
 	struct xcache *xcache;
 	struct list_head dirty;
 	struct sb *i_sb;
 	map_t *map;
 	loff_t i_size;

@@ -75,7 +75,7 @@ static int clear_other_magic(struct sb *
 int make_tux3(struct sb *sb)
+{
-	struct inode *dir = &(struct inode){ INIT_INODE(sb, S_IFDIR | 0755) };
+	struct inode *dir = &(struct inode){ .i_sb = sb, .i_mode = S_IFDIR | 0755 };
 	int err = clear_other_magic(sb);
 	if (err)

@@ -70,13 +70,11 @@ int main(int argc, const char *argv[])
 	struct dev *dev = &(struct dev){ fd, .bits = blockbits };
 	init_buffers(dev, 1 << 20, 1);
 	struct sb *sb = &(struct sb){
 		INIT_SB(dev),
 	struct sb *sb = rapid_sb(dev,
 		.max_inodes_per_block = 64,
 		.entries_per_node = 20,
 		.volblocks = volsize >> dev->bits,
 		.freeblocks = volsize >> dev->bits,
 	};
 		.freeblocks = volsize >> dev->bits);
 	sb->volmap = tux_new_volmap(sb);
 	if (!sb->volmap)
 		goto eek;

@@ -178,35 +178,54 @@ struct tux_iattr {
 void change_begin(struct sb *sb);
 void change_end(struct sb *sb);
-#define INIT_INODE(sb, mode)				\
+#define INIT_INODE(inode, sb, mode)			\
 	.i_sb = sb,					\
 	.i_mode = mode,					\
 	.i_mutex = __MUTEX_INITIALIZER,			\
 	.i_version = 1,					\
-	.i_nlink = 1
+	.i_nlink = 1,					\
 	.dirty = LIST_HEAD_INIT((inode).dirty)
 #define rapid_open_inode(sb, io, mode)	({		\
 	struct inode *__inode = &(struct inode){	\
 		INIT_INODE(sb, mode),			\
 		.btree = {				\
 			.lock = __RWSEM_INITIALIZER,	\
 		},					\
 	};						\
 	__inode->map = new_map((sb)->dev, io);		\
 	assert(__inode->map);				\
 	__inode->map->inode = __inode;			\
 	__inode;					\
 })
 #define INIT_SB(sb, dev)					\
 	.dev = dev,						\
 	.blockbits = (dev)->bits,				\
 	.blocksize = 1 << (dev)->bits,				\
 	.blockmask = ((1 << (dev)->bits) - 1),			\
 	.delta_lock = __RWSEM_INITIALIZER,			\
 	.loglock = __MUTEX_INITIALIZER,				\
 	.dirty_inodes = LIST_HEAD_INIT((sb).dirty_inodes)
 #define INIT_SB(dev)					\
 	.dev = dev,					\
 	.blockbits = (dev)->bits,			\
 	.blocksize = 1 << (dev)->bits,			\
 	.blockmask = ((1 << (dev)->bits) - 1),		\
 	.delta_lock = __RWSEM_INITIALIZER,		\
 	.loglock = __MUTEX_INITIALIZER
 #define rapid_open_inode(sb, io, mode, init_defs...) ({		\
 	struct inode *__inode = &(struct inode){};		\
 	*__inode = (struct inode){				\
 		INIT_INODE(*__inode, sb, mode),			\
 		.btree = {					\
 			.lock = __RWSEM_INITIALIZER,		\
 		},						\
 		init_defs					\
 	};							\
 	__inode->map = new_map((sb)->dev, io);			\
 	assert(__inode->map);					\
 	__inode->map->inode = __inode;				\
 	__inode;						\
 	})
 #define rapid_sb(dev, init_defs...) ({				\
 	struct sb *__sb = &(struct sb){};			\
 	*__sb = (struct sb){					\
 		INIT_SB(*__sb, dev),				\
 		init_defs					\
 	};							\
 	__sb;							\
 	});
 enum { DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK };
 typedef int (filldir_t)(void *dirent, char *name, unsigned namelen, loff_t offset, unsigned inode, unsigned type);
 static inline void mark_inode_dirty(struct inode *inode)
+{
 	if (list_empty(&inode->dirty))
 		list_add_tail(&inode->dirty, &inode->i_sb->dirty_inodes);
+}
 #endif

@@ -367,7 +367,7 @@ static void tux3_init(void *data, struct
 	*dev = (struct dev){ .fd = fd, .bits = 12 };
 	init_buffers(dev, 1<<20, 1);
 	sb = malloc(sizeof(*sb));
-	*sb = (struct sb){ INIT_SB(dev), };
+	*sb = (struct sb){ INIT_SB(*sb, dev), };
 	sb->volmap = tux_new_volmap(sb);
 	if (!sb->volmap)
 		goto eek;

@@ -744,7 +744,7 @@ int main(int argc, const char *argv[])
 	};
 	init_buffers(dev, 1 << 20, 1);
-	struct sb *sb = &(struct sb){ INIT_SB(dev), };
+	struct sb *sb = rapid_sb(dev);
 	sb->volmap = tux_new_volmap(sb);
 	if (!sb->volmap)

@@ -30,21 +30,18 @@ int main(int argc, char *argv[])
 	struct dev *dev = &(struct dev){ .bits = 8, .fd = open(argv[1], O_CREAT|O_RDWR, S_IRWXU) };
 	ftruncate(dev->fd, 1 << 24);
 	init_buffers(dev, 1 << 20, 0);
 	struct sb *sb = &(struct sb){
 		INIT_SB(dev),
 	struct sb *sb = rapid_sb(dev,
 		.version = 0,
 		.atomref_base = 1 << 10,
 		.unatom_base = 1 << 11,
-		.atomgen = 1,
+		.atomgen = 1);
 	struct inode *inode = rapid_open_inode(sb, NULL, S_IFDIR | 0x666,
 		.present = abits, .i_uid = 0x12121212, .i_gid = 0x34343434,
 		.i_ctime = spectime(0xdec0debeadULL),
 		.i_mtime = spectime(0xbadfaced00dULL));
 	inode->btree = (struct btree){
 		.root = { .block = 0xcaba1f00dULL, .depth = 3 }
 	};
 	struct inode *inode = &(struct inode){
 		INIT_INODE(sb, S_IFDIR | 0x666),
 		.present = abits, .i_uid = 0x12121212, .i_gid = 0x34343434,
 		.btree = { .root = { .block = 0xcaba1f00dULL, .depth = 3 } },
 		.i_ctime = spectime(0xdec0debeadULL),
 		.i_mtime = spectime(0xbadfaced00dULL) };
 	inode->map = new_map(dev, NULL);
 	inode->map->inode = inode;
 	sb->atable = inode;
 	for (int i = 0; i < 2; i++) {

commit 955:	d5a5e6bba24e
parent 954:	ad641145241f
branch:	default

shapor / tux3 (http://shapor.com/tux3)