hotfix-vmufat.patch

From 6de03ddd0f024c585d2957c58e67b42f602f8f62 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 4 Dec 2025 16:34:29 +0000
Subject: [PATCH 001/101] Documentation update

---
 Documentation/filesystems/vmufat.rst | 105 +++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 Documentation/filesystems/vmufat.rst

diff --git a/Documentation/filesystems/vmufat.rst b/Documentation/filesystems/vmufat.rst
new file mode 100644
index 00000000000000..cde87531e9f607
--- /dev/null
+++ b/Documentation/filesystems/vmufat.rst
@@ -0,0 +1,105 @@
+==================
+VMUFAT FILESYSTEM
+==================
+
+VMUFAT is the simple file allocation table (FAT) based filesystem used in Sega
+Dreamcast Visual Memory Units (VMUs) and various Dreamcast emulators and
+Android apps etc.
+
+It is not recommended for general use, but does not require a Dreamcast.
+
+All the physical VMU devices that were made were of the same size 256 blocks
+of 512 octets - 128KB in total. But the specification supports a wider range
+of sizes and the filesystem in the Linux kernel is capable of handling volumes
+of a size between 4 blocks and 65536 blocks.
+
+The standard 256 block VMU is described below:
+
+========    =======
+BLOCK NO	CONTENT
+========    =======
+0 - 199     Space used by Dreamcast to save files      
+200 - 240   Space which can be used but which the Dreamcast ignores
+241 - 253   Directory (can hold 208 file records)
+254         File Allocation Table (FAT)
+255         Root Block
+========    =======
+
+The standard VMU filesystem has 241 blocks which can be used for file storage
+but a Dreamcast will only use 200 of these. The Linux kernel driver prefers to
+use blocks 0 - 199 when allocating blocks to files, but will use blocks 200 -
+240 if lower numbered blocks are not available.
+
+An executible file (generally a game written in the native machine code of
+the VMU's microcontroller) must begin at block 0 and be stored linearly in
+the volume.
+
+=========
+DIRECTORY
+=========
+
+The directory contains records 32 octets long (format detail below from Marcus
+Comstedt's website - http://mc.pp.se/dc/vms/flashmem.html)
+
+0x00      : file type (0x00 = no file, 0x33 = data, 0xcc = game)
+0x01      : copy protect (0x00 = copy ok, 0xff = copy protected)
+0x02-0x03 : 16 bits (little endian) : location of first block
+0x04-0x0f : ASCII string : filename (12 characters)
+0x10-0x17 : Binary Coded Decimal timestamp: file creation time
+0x18-0x19 : 16 bits (little endian) : file size (in blocks)
+0x1a-0x1b : 16 bits (little endian) : offset of header (in blocks)
+            from file start
+
+Header positioning is a matter for executible files written in native
+code for a physical VMU (an 8 bit Sanyo microcontroller).
+
+BCD dates are encoded as follows:
+
+Century prefix (eg., 20)
+
+Year (eg., 12)
+
+Month (eg., 02)
+
+Day in month (eg., 29)
+
+Hour (eg., 20)
+
+Minute (eg., 49)
+
+Second (eg., 22)
+
+Day of week (Monday is 00, Sunday is 06)
+
+=====================
+FILE ALLOCATION TABLE
+=====================
+
+Every block in the volume is mapped to the FAT eg., block 0 of the VMU maps to
+the first 16 bits of the FAT and so on. Blocks marked 0xFFFC are empty, blocks
+allocated to a file are either numbered with with next block or, if the final
+block are marked 0xFFFA.
+
+**ROOT BLOCK**
+
+The first 16 octets are marked as 0x55 - we use this to provide the *magic
+number* for this filesystem. The octets at 0x10 - 0x14 are used to determine
+the colour the representation of the VMU is displayed in by a Dreamcast and our
+filesystem does not touch these.
+
+Octets 0x30 - 0x37 contain the BCD timestamp of the VMU.
+
+Octets 0x46 - 0x47 contain the location (little endian format) of the FAT
+
+Octets 0x48 - 0x49 contain the size (little endian) of the FAT
+
+Octets 0x4A - 0x4B contain the location (little endian) of the Directory
+
+Octets 0x4C - 0x4D contain the size (little endian) of the Directory
+
+Octets 0x4E - 0x4F is Dreamcast specific (icon shape)
+
+Octets 0x50 - 0x51 contain the number (little endian) of user blocks - NB this
+is marked as 200 in a physical VMU although there are in fact 241 usable
+blocks - the reason appears to be that the Directory is not big enough to
+support 1 block files in all user blocks.
\ No newline at end of file

From 84056c419d5d2f10ee213a78c924b37b26161c16 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 4 Dec 2025 16:44:39 +0000
Subject: [PATCH 002/101] Makefile and related changes

---
 fs/Kconfig         |  1 +
 fs/Makefile        |  1 +
 fs/vmufat/Kconfig  | 14 ++++++++++++++
 fs/vmufat/Makefile |  7 +++++++
 4 files changed, 23 insertions(+)
 create mode 100644 fs/vmufat/Kconfig
 create mode 100644 fs/vmufat/Makefile

diff --git a/fs/Kconfig b/fs/Kconfig
index 0bfdaecaa87751..89a37c9c58a09d 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -332,6 +332,7 @@ source "fs/pstore/Kconfig"
 source "fs/ufs/Kconfig"
 source "fs/erofs/Kconfig"
 source "fs/vboxsf/Kconfig"
+source "fs/vmufat/Kconfig"
 
 endif # MISC_FILESYSTEMS
 
diff --git a/fs/Makefile b/fs/Makefile
index cf4a745e967984..3cdc3d7b804c76 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -129,3 +129,4 @@ obj-$(CONFIG_VBOXSF_FS)		+= vboxsf/
 obj-$(CONFIG_ZONEFS_FS)		+= zonefs/
 obj-$(CONFIG_BPF_LSM)		+= bpf_fs_kfuncs.o
 obj-$(CONFIG_RESCTRL_FS)	+= resctrl/
+obj-$(CONFIG_VMUFAT_FS)		+= vmufat/
diff --git a/fs/vmufat/Kconfig b/fs/vmufat/Kconfig
new file mode 100644
index 00000000000000..cdc7282924b362
--- /dev/null
+++ b/fs/vmufat/Kconfig
@@ -0,0 +1,14 @@
+config VMUFAT_FS
+	tristate "Dreamcast VMU FAT filesystem"
+	depends on BLOCK
+	help
+	  This implements the simple FAT type filesystem found on SEGA
+	  Dreamcast visual memory units.
+
+	  Dreamcast users who want to mount their VMUs to view the native
+	  filesystem will say 'Y' here. The filesystem is hardware independent
+	  but is not recommended for use in other circumstances, so just about
+	  everyone else should say 'N'.
+
+	  To compile this as a module say 'M' here. The module will be called
+	  vmufat
\ No newline at end of file
diff --git a/fs/vmufat/Makefile b/fs/vmufat/Makefile
new file mode 100644
index 00000000000000..da423b0c7eec86
--- /dev/null
+++ b/fs/vmufat/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for VMUFAT filesystem
+#
+
+obj-$(CONFIG_VMUFAT_FS) += vmufat.o
+
+vmufat-y := inode.o super.o

From 7c45c15eb250c13c68ac5da887f2e15741352529 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 4 Dec 2025 16:49:01 +0000
Subject: [PATCH 003/101] vmufat driver code files

---
 fs/vmufat/inode.c  | 902 +++++++++++++++++++++++++++++++++++++++++++++
 fs/vmufat/super.c  | 545 +++++++++++++++++++++++++++
 fs/vmufat/vmufat.h | 116 ++++++
 3 files changed, 1563 insertions(+)
 create mode 100644 fs/vmufat/inode.c
 create mode 100644 fs/vmufat/super.c
 create mode 100644 fs/vmufat/vmufat.h

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
new file mode 100644
index 00000000000000..88903c1678a740
--- /dev/null
+++ b/fs/vmufat/inode.c
@@ -0,0 +1,902 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * VMUFAT file system
+ *
+ * Copyright (C) 2002 - 2012, 2025	Adrian McMenamin
+ * Copyright (C) 2002		        Paul Mundt
+ *
+ * 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 02111-1307, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/magic.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/statfs.h>
+#include <linux/buffer_head.h>
+#include <linux/mpage.h>
+#include "vmufat.h"
+
+const struct inode_operations vmufat_inode_operations;
+const struct file_operations vmufat_file_operations;
+const struct address_space_operations vmufat_address_space_operations;
+const struct file_operations vmufat_file_dir_operations;
+struct kmem_cache *vmufat_blist_cachep;
+/* Linear day numbers of the respective 1sts in non-leap years. */
+int day_n[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
+
+static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
+	unsigned int ignored)
+{
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	struct buffer_head *bh = NULL;
+	struct inode *ino;
+	int i, j, error = 0;
+
+	if (dent->d_name.len > VMUFAT_NAMELEN) {
+		error = -ENAMETOOLONG;
+		goto out;
+	}
+	sb = in->i_sb;
+	vmudetails = sb->s_fs_info;
+
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			error = -EIO;
+			goto out;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			int record_offset = j * VMU_DIR_RECORD_LEN;
+			if (bh->b_data[record_offset] == 0)
+				goto insert_negative;
+			if (memcmp(dent->d_name.name,
+			bh->b_data + record_offset + VMUFAT_NAME_OFFSET,
+			dent->d_name.len) == 0) {
+				ino = vmufat_get_inode(sb,
+					le16_to_cpu(((u16 *) bh->b_data)
+					[record_offset
+					+ VMUFAT_FIRSTBLOCK_OFFSET16]));
+				if (IS_ERR(ino)) {
+					error = PTR_ERR(ino);
+					goto out;
+				} else if (!ino) {
+					error = -EACCES;
+					goto out;
+				}
+				d_add(dent, ino);
+				goto out;
+			}
+		}
+	}
+insert_negative:
+	d_add(dent, NULL); /* Did not find the file */
+out:
+	brelse(bh);
+	return ERR_PTR(error);
+}
+
+static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
+{
+	int i, ret = -1;
+	__le16 fatdata;
+
+	for (i = start; i >= end; i--) {
+		fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
+		if (fatdata == VMUFAT_UNALLOCATED) {
+			ret = i;
+			break;
+		}
+	}
+	return ret;
+}
+
+/*
+ * Find a block marked free in the FAT
+ */
+static int vmufat_find_free(struct super_block *sb)
+{
+	struct memcard *vmudetails;
+	int testblk, fatblk, ret;
+	struct buffer_head *bh_fat;
+
+	vmudetails = sb->s_fs_info;
+
+	for (fatblk = vmudetails->fat_bnum;
+		fatblk > vmudetails->fat_bnum - vmudetails->fat_len;
+		fatblk--) {
+		bh_fat = vmufat_sb_bread(sb, fatblk);
+		if (!bh_fat) {
+			ret = -EIO;
+			goto fail;
+		}
+
+		/* Handle 256 block VMUs like physical devices
+		 * and other VMUs more simply
+		 */
+		if (vmudetails->sb_bnum != VMU_BLK_SZ16) {
+			/* Cannot be physical VMU */
+			testblk = vmufat_get_freeblock(VMU_BLK_SZ16, 0, bh_fat);
+			put_bh(bh_fat);
+			if (testblk >= 0)
+				goto out_of_loop;
+		} else { /* Physical VMU or logical VMU with same size */
+			testblk = vmufat_get_freeblock(VMUFAT_START_ALLOC, 0,
+				bh_fat);
+			if (testblk >= 0) {
+				put_bh(bh_fat);
+				goto out_of_loop;
+			}
+			/* Only allocate to higher blocks if no space left */
+			testblk = vmufat_get_freeblock(VMU_BLK_SZ16,
+				VMUFAT_START_ALLOC + 1, bh_fat);
+			put_bh(bh_fat);
+			if (testblk > VMUFAT_START_ALLOC)
+				goto out_of_loop;
+		}
+	}
+	printk(KERN_INFO "VMUFAT: volume is full\n");
+	ret = -ENOSPC;
+	goto fail;
+
+out_of_loop:
+	ret = (fatblk - 1 - vmudetails->fat_bnum + vmudetails->fat_len)
+			* VMU_BLK_SZ16 + testblk;
+fail:
+	return ret;
+}
+
+/* read the FAT for a given block */
+u16 vmufat_get_fat(struct super_block *sb, long block)
+{
+	struct buffer_head *bufhead;
+	int offset;
+	u16 block_content = VMUFAT_ERROR;
+	struct memcard *vmudetails = sb->s_fs_info;
+
+	/* which block in the FAT */
+	offset = block / VMU_BLK_SZ16;
+	if (offset >= vmudetails->fat_len)
+		goto out;
+
+	/* fat_bnum points to highest block in FAT */
+	bufhead = vmufat_sb_bread(sb, offset + 1 +
+		vmudetails->fat_bnum - vmudetails->fat_len);
+	if (!bufhead)
+		goto out;
+	/* look inside the block */
+	block_content = le16_to_cpu(((u16 *)bufhead->b_data)
+		[block % VMU_BLK_SZ16]);
+	put_bh(bufhead);
+out:
+	return block_content;
+}
+
+/* set the FAT for a given block */
+static int vmufat_set_fat(struct super_block *sb, long block,
+		u16 data_to_set)
+{
+	struct buffer_head *bh;
+	int offset, error = 0;
+	struct memcard *vmudetails = sb->s_fs_info;
+
+	offset = block / VMU_BLK_SZ16;
+	if (offset >= vmudetails->fat_len) {
+		error = -EINVAL;
+		goto out;
+	}
+	bh = vmufat_sb_bread(sb, offset + 1 +
+		vmudetails->fat_bnum - vmudetails->fat_len);
+	if (!bh) {
+		error = -EIO;
+		goto out;
+	}
+	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data_to_set);
+	mark_buffer_dirty(bh);
+	put_bh(bh);
+out:
+	return error;
+}
+
+
+static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
+{
+	long years, days;
+	unsigned char bcd_century, nl_day, bcd_month;
+	unsigned char u8year;
+	time64_t unix_date;
+
+	unix_date = in->i_mtime_sec;
+	days = unix_date / SECONDS_PER_DAY;
+	years = days / DAYS_PER_YEAR;
+	/* 1 Jan gets 1 day later after every leap year */
+	if ((years + 3) / 4 + DAYS_PER_YEAR * years >= days)
+		years--;
+	/* rebase days to account for leap years */
+	days -= (years + 3) / 4 + DAYS_PER_YEAR * years;
+	/* 1 Jan is Day 1 */
+	days++;
+	if (days == (FEB28 + 1) && !(years % 4)) {
+		nl_day = days;
+		bcd_month = 2;
+	} else {
+		nl_day = (years % 4) || days <= FEB28 ? days : days - 1;
+		for (bcd_month = 0; bcd_month < 12; bcd_month++)
+			if (day_n[bcd_month] > nl_day)
+				break;
+	}
+
+	bcd_century = 19;
+	/* TODO:accounts for 21st century but will fail in 2100
+		because of leap days */
+	if (years > 29)
+		bcd_century += 1 + (years - 30)/100;
+
+	bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd(bcd_century);
+	u8year = years + 70; /* account for epoch */
+	if (u8year > 99)
+		u8year = u8year - 100;
+
+	bh[index_to_dir + VMUFAT_DIR_YEAR] = bin2bcd(u8year);
+	bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd(bcd_month);
+	bh[index_to_dir + VMUFAT_DIR_DAY] =
+	    bin2bcd(days - day_n[bcd_month - 1]);
+	bh[index_to_dir + VMUFAT_DIR_HOUR] =
+	    bin2bcd((unix_date / SECONDS_PER_HOUR) % HOURS_PER_DAY);
+	bh[index_to_dir + VMUFAT_DIR_MIN] =
+		bin2bcd((unix_date / SIXTY_MINS_OR_SECS)
+		 % SIXTY_MINS_OR_SECS);
+	bh[index_to_dir + VMUFAT_DIR_SEC] =
+		bin2bcd(unix_date % SIXTY_MINS_OR_SECS);
+}
+
+static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
+	char *bh, int index_to_dir)
+{
+	struct rtc_time now;
+
+	if (rtc_read_time(rtc, &now) < 0)
+		vmufat_save_bcd_nortc(in, bh, index_to_dir);
+	bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)(now.tm_year/100));
+	bh[index_to_dir + VMUFAT_DIR_YEAR] = bin2bcd((char)(now.tm_year % 100));
+	bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd((char)(now.tm_mon));
+	bh[index_to_dir + VMUFAT_DIR_DAY] = bin2bcd((char)(now.tm_mday));
+	bh[index_to_dir + VMUFAT_DIR_HOUR] = bin2bcd((char)(now.tm_hour));
+	bh[index_to_dir + VMUFAT_DIR_MIN] = bin2bcd((char)(now.tm_min));
+	bh[index_to_dir + VMUFAT_DIR_SEC] = bin2bcd((char)(now.tm_sec));
+	bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)(now.tm_wday));
+}
+
+/*
+ * write out the date in bcd format
+ * in the appropriate part of the
+ * directory entry
+ */
+void vmufat_save_bcd(struct inode *in, char *bh, int index_to_dir)
+{
+	struct rtc_device *rtc;
+	rtc = rtc_class_open("rtc0");
+	if (!rtc)
+		vmufat_save_bcd_nortc(in, bh, index_to_dir);
+	else {
+		vmufat_save_bcd_rtc(rtc, in, bh, index_to_dir);
+		rtc_class_close(rtc);
+	}
+}
+
+static int vmufat_allocate_inode(umode_t imode,
+		struct super_block *sb, struct inode *in)
+{
+	int error = 0;
+	/* Executable files must be at the start of the volume */
+	if (imode & EXEC) {
+		in->i_ino = VMUFAT_ZEROBLOCK;
+		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
+			printk(KERN_INFO "VMUFAT: cannot write excutable "
+				"file. Volume block 0 already allocated.\n");
+			error = -ENOSPC;
+			goto out;
+		}
+	} else {
+		error = vmufat_find_free(sb);
+		if (error >= 0)
+			in->i_ino = error;
+	}
+out:
+	return error;
+}
+
+static void vmufat_setup_inode(struct inode *in, umode_t imode,
+		struct super_block *sb)
+{
+	struct timespec64 current_time;
+	in->i_uid = current_fsuid();
+	in->i_gid = current_fsgid();
+	ktime_get_coarse_real_ts64(&current_time);
+	in->i_mtime_sec = in->i_atime_sec = in->i_ctime_sec = current_time.tv_sec;
+	in->i_mode = imode;
+	in->i_blocks = 1;
+	in->i_sb = sb;
+	insert_inode_hash(in);
+	in->i_op = &vmufat_inode_operations;
+	in->i_fop = &vmufat_file_operations;
+	in->i_mapping->a_ops = &vmufat_address_space_operations;
+}
+
+static void vmu_handle_zeroblock(int recno, struct buffer_head *bh, int ino)
+{
+	/* offset and header offset settings */
+	if (ino != VMUFAT_ZEROBLOCK) {
+		((u16 *) bh->b_data)[recno + VMUFAT_START_OFFSET16] =
+			cpu_to_le16(ino);
+		((u16 *) bh->b_data)[recno + VMUFAT_HEADER_OFFSET16] = 0;
+	} else {
+		((u16 *) bh->b_data)[recno + VMUFAT_START_OFFSET16] = 0;
+		((u16 *) bh->b_data)[recno + VMUFAT_HEADER_OFFSET16] =
+			cpu_to_le16(1);
+	}
+}
+
+static void vmu_write_name(int recno, struct buffer_head *bh, char *name,
+	int len)
+{
+	memset((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET), '\0',
+		VMUFAT_NAMELEN);
+	memcpy((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET),
+		name, len);
+}
+
+static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
+	struct dentry *de, umode_t imode, bool excl)
+{
+	int i, j, entry, found = 0, error = 0, freeblock;
+	struct inode *inode;
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	struct buffer_head *bh = NULL;
+
+	sb = dir->i_sb;
+	vmudetails = sb->s_fs_info;
+	inode = new_inode(sb);
+	if (!inode) {
+		error = -ENOSPC;
+		goto out;
+	}
+
+	mutex_lock(&vmudetails->mutex);
+	freeblock = vmufat_allocate_inode(imode, sb, inode);
+	if (freeblock < 0) {
+		mutex_unlock(&vmudetails->mutex);
+		error = freeblock;
+		goto clean_inode;
+	}
+	/* mark as single block file - may grow later */
+	error = vmufat_set_fat(sb, freeblock, VMUFAT_FILE_END);
+	mutex_unlock(&vmudetails->mutex);
+	if (error)
+		goto clean_inode;
+
+	vmufat_setup_inode(inode, imode, sb);
+
+	/* Write to the directory
+	 * Now search for space for the directory entry */
+	mutex_lock(&vmudetails->mutex);
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			mutex_unlock(&vmudetails->mutex);
+			error = -EIO;
+			goto clean_fat;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			entry = j * VMU_DIR_RECORD_LEN;
+			if (((bh->b_data)[entry]) == 0) {
+				found = 1;
+				goto dir_space_found;
+			}
+		}
+	}
+	if (found == 0)
+		goto clean_fat;
+dir_space_found:
+	/* Have the directory entry
+	 * so now update it */
+	if (imode & EXEC)
+		bh->b_data[entry] = VMU_GAME;
+	else
+		bh->b_data[entry] = VMU_DATA;
+
+	/* copy protection settings */
+	if (bh->b_data[entry + 1] != (char) NOCOPY)
+		bh->b_data[entry + 1] = (char) CANCOPY;
+
+	vmu_handle_zeroblock(entry / 2, bh, inode->i_ino);
+	vmu_write_name(entry, bh, (char *) de->d_name.name, de->d_name.len);
+
+	/* BCD timestamp it */
+	vmufat_save_bcd(inode, bh->b_data, entry);
+
+	((u16 *) bh->b_data)[entry / 2 + VMUFAT_SIZE_OFFSET16] =
+	    cpu_to_le16(inode->i_blocks);
+	mark_buffer_dirty(bh);
+	brelse(bh);
+	error = vmufat_list_blocks(inode);
+	if (error)
+		goto clean_fat;
+	mutex_unlock(&vmudetails->mutex);
+	d_instantiate(de, inode);
+	return error;
+
+clean_fat:
+	vmufat_set_fat(sb, freeblock, VMUFAT_UNALLOCATED);
+	mutex_unlock(&vmudetails->mutex);
+clean_inode:
+	iput(inode);
+out:
+	if (error < 0)
+		printk(KERN_INFO "VMUFAT: inode creation fails with error"
+			" %i\n", error);
+	return error;
+}
+
+static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
+{
+	int filenamelen, index, j, k, error = 0;
+	struct vmufat_file_info *saved_file = NULL;
+	struct dentry *dentry;
+	struct inode *inode;
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	struct buffer_head *bh = NULL;
+
+	inode = file_inode(filp);
+	dentry = filp->f_path.dentry;
+	sb = inode->i_sb;
+	vmudetails = sb->s_fs_info;
+	index = filp->f_pos;
+	/* handle . for this directory and .. for parent */
+	switch ((unsigned int) filp->f_pos) {
+	case 0:
+		error = ctx->actor(ctx, ".", 1, index++, inode->i_ino, DT_DIR);
+		if (error < 0)
+			goto out;
+	case 1:
+		error = ctx->actor(ctx, "..", 2, index++,
+			    dentry->d_parent->d_inode->i_ino, DT_DIR);
+		if (error < 0)
+			goto out;
+	default:
+		break;
+	}
+
+	saved_file =
+	    kmalloc(sizeof(struct vmufat_file_info), GFP_KERNEL);
+	if (!saved_file) {
+		error = -ENOMEM;
+		goto out;
+	}
+
+	for (j = vmudetails->dir_bnum -
+		(index - 2) / VMU_DIR_ENTRIES_PER_BLOCK;
+		j > vmudetails->dir_bnum - vmudetails->dir_len; j--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, j);
+		if (!bh) {
+			error = -EIO;
+			goto finish;
+		}
+		for (k = (index - 2) % VMU_DIR_ENTRIES_PER_BLOCK;
+			k < VMU_DIR_ENTRIES_PER_BLOCK; k++) {
+			int pos, pos16;
+			pos = k * VMU_DIR_RECORD_LEN;
+			pos16 = k * VMU_DIR_RECORD_LEN16;
+			saved_file->ftype = bh->b_data[pos];
+			if (saved_file->ftype == 0)
+				goto finish;
+			saved_file->fblk =
+				le16_to_cpu(((u16 *) bh->b_data)[pos16 + 1]);
+			if (saved_file->fblk == 0)
+				saved_file->fblk = VMUFAT_ZEROBLOCK;
+			memcpy(saved_file->fname,
+				bh->b_data + pos + VMUFAT_NAME_OFFSET,
+				VMUFAT_NAMELEN);
+			filenamelen = strlen(saved_file->fname);
+			if (filenamelen > VMUFAT_NAMELEN)
+				filenamelen = VMUFAT_NAMELEN;
+			error = ctx->actor(ctx, saved_file->fname, filenamelen,
+				index++, saved_file->fblk, DT_REG);
+			if (error < 0)
+				goto finish;
+		}
+	}
+
+finish:
+	filp->f_pos = index;
+	kfree(saved_file);
+	brelse(bh);
+out:
+	return error;
+}
+
+
+int vmufat_list_blocks(struct inode *in)
+{
+	struct vmufat_inode *vi;
+	struct super_block *sb;
+	long nextblock;
+	long ino;
+	struct memcard *vmudetails;
+	int error = -EINVAL;
+	struct list_head *iter, *iter2;
+	struct vmufat_block_list *vbl, *nvbl;
+	u16 fatdata;
+
+	vi = VMUFAT_I(in);
+	if (!vi)
+		goto out;
+	sb = in->i_sb;
+	ino = in->i_ino;
+	vmudetails = sb->s_fs_info;
+	error = 0;
+	nextblock = ino;
+	if (nextblock == VMUFAT_ZEROBLOCK)
+		nextblock = 0;
+
+	/* Delete any previous list of blocks */
+	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
+		vbl = list_entry(iter, struct vmufat_block_list, b_list);
+		list_del(iter);
+		kmem_cache_free(vmufat_blist_cachep, vbl);
+	}
+	vi->nblcks = 0;
+	do {
+		vbl = kmem_cache_alloc(vmufat_blist_cachep,
+			GFP_KERNEL);
+		if (!vbl) {
+			error = -ENOMEM;
+			goto unwind_out;
+		}
+		INIT_LIST_HEAD(&vbl->b_list);
+		vbl->bno = nextblock;
+		list_add_tail(&vbl->b_list, &vi->blocks.b_list);
+		vi->nblcks++;
+
+		/* Find next block in the FAT - if there is one */
+		fatdata = vmufat_get_fat(sb, nextblock);
+		if (fatdata == VMUFAT_UNALLOCATED) {
+			printk(KERN_ERR "VMUFAT: FAT table appears to have"
+				" been corrupted.\n");
+			error = -EIO;
+			goto unwind_out;
+		}
+		if (fatdata == VMUFAT_FILE_END)
+			break;
+		nextblock = fatdata;
+	} while (1);
+out:
+	return error;
+
+unwind_out:
+	list_for_each_entry_safe(vbl, nvbl, &vi->blocks.b_list, b_list) {
+		list_del_init(&vbl->b_list);
+		kmem_cache_free(vmufat_blist_cachep, vbl);
+	}
+	return error;
+}
+
+static int vmufat_clean_fat(struct super_block *sb, int inum)
+{
+	int error = 0;
+	u16 fatword, nextword;
+
+	nextword = inum;
+	do {
+		fatword = vmufat_get_fat(sb, nextword);
+		if (fatword == VMUFAT_ERROR) {
+			error = -EIO;
+			break;
+		}
+		error = vmufat_set_fat(sb, nextword, VMUFAT_UNALLOCATED);
+		if (error)
+			break;
+		if (fatword == VMUFAT_FILE_END)
+			break;
+		nextword = fatword;
+	} while (1);
+
+	return error;
+}
+
+/*
+ * Delete inode by marking space as free in FAT
+ * no need to waste time and effort by actually
+ * wiping underlying data on media
+ */
+static void vmufat_remove_inode(struct inode *in)
+{
+	struct buffer_head *bh = NULL, *bh_old = NULL;
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	int i, j, k, l, startpt, found = 0;
+
+	if (in->i_ino == VMUFAT_ZEROBLOCK)
+		in->i_ino = 0;
+	sb = in->i_sb;
+	vmudetails = sb->s_fs_info;
+	if (in->i_ino > vmudetails->fat_len * sb->s_blocksize / 2) {
+		printk(KERN_WARNING "VMUFAT: attempting to delete"
+			"inode beyond device size");
+		goto ret;
+	}
+
+	mutex_lock(&vmudetails->mutex);
+	if (vmufat_clean_fat(sb, in->i_ino)) {
+		mutex_unlock(&vmudetails->mutex);
+		goto failure;
+	}
+
+	/* Now clean the directory entry
+	 * Have to wander through this
+	 * to find the appropriate entry */
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			mutex_unlock(&vmudetails->mutex);
+			goto failure;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			if (bh->b_data[j * VMU_DIR_RECORD_LEN] == 0) {
+				mutex_unlock(&vmudetails->mutex);
+				goto failure;
+			}
+			if (le16_to_cpu(((u16 *) bh->b_data)
+				[j * VMU_DIR_RECORD_LEN16 +
+				VMUFAT_FIRSTBLOCK_OFFSET16]) == in->i_ino) {
+				found = 1;
+				goto found;
+			}
+		}
+	}
+found:
+	if (found == 0) {
+		mutex_unlock(&vmudetails->mutex);
+		goto failure;
+	}
+
+	/* Found directory entry - so NULL it now */
+	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
+		bh->b_data[j * VMU_DIR_RECORD_LEN + k] = 0;
+	mark_buffer_dirty(bh);
+	/* Patch up directory, by moving up last file */
+	found = 0;
+	startpt = j + 1;
+	for (l = i; l > vmudetails->dir_bnum - vmudetails->dir_len; l--) {
+		bh_old = vmufat_sb_bread(sb, l);
+		if (!bh_old) {
+			mutex_unlock(&vmudetails->mutex);
+			goto failure;
+		}
+		for (k = startpt; k < VMU_DIR_ENTRIES_PER_BLOCK; k++) {
+			if (bh_old->b_data[k * VMU_DIR_RECORD_LEN] == 0) {
+				found = 1;
+				brelse(bh_old);
+				goto lastdirfound;
+			}
+		}
+		startpt = 0;
+		brelse(bh_old);
+	}
+lastdirfound:
+	if (found == 0) {	/* full directory */
+		l = vmudetails->dir_bnum - vmudetails->dir_len + 1;
+		k = VMU_DIR_ENTRIES_PER_BLOCK;
+	} else if (l == i && k == j + 1) /* deleted entry was last in dir */
+		goto finish;
+	else if (k == 0) {
+		l = l + 1;
+		k = VMU_DIR_ENTRIES_PER_BLOCK;
+		if (l == i && k == j + 1)
+			goto finish;
+	}
+	/* fill gap first then wipe out old entry */
+	bh_old = vmufat_sb_bread(sb, l);
+	if (!bh_old) {
+		mutex_unlock(&vmudetails->mutex);
+		brelse(bh);
+		goto failure;
+	}
+	for (i = 0; i < VMU_DIR_RECORD_LEN; i++) {
+		bh->b_data[j * VMU_DIR_RECORD_LEN + i] =
+			bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i];
+		bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i] = 0;
+	}
+	mark_buffer_dirty(bh_old);
+	mark_buffer_dirty(bh);
+	brelse(bh_old);
+
+finish:
+	mutex_unlock(&vmudetails->mutex);
+	brelse(bh);
+	return;
+
+failure:
+	printk(KERN_WARNING "VMUFAT: Failure to read volume,"
+		" could not delete inode - filesystem may be damaged\n");
+ret:
+	return;
+}
+
+/*
+ * vmufat_unlink - delete a file pointed to
+ * by the dentry (only one directory in a
+ * vmufat fs so safe to ignore the inode
+ * supplied here
+ */
+static int vmufat_unlink(struct inode *dir, struct dentry *dentry)
+{
+	struct inode *in;
+	in = dentry->d_inode;
+	vmufat_remove_inode(in);
+	return 0;
+}
+
+static int vmufat_get_block(struct inode *inode, sector_t iblock,
+	struct buffer_head *bh_result, int create)
+{
+	struct vmufat_inode *vin;
+	struct vmufat_block_list *vlist, *vblk;
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	int cural;
+	int finblk, nxtblk, exeblk;
+	struct list_head *iter;
+	sector_t cntdwn = iblock;
+	sector_t phys;
+	int error = -EINVAL;
+
+	vin = VMUFAT_I(inode);
+	if (!vin || vin->nblcks <= 0)
+		goto out;
+	vlist = &vin->blocks;
+	sb = inode->i_sb;
+	vmudetails = sb->s_fs_info;
+
+	if (iblock < vin->nblcks) {
+		/* block is already here so read it into the buffer head */
+		list_for_each(iter, &vlist->b_list) {
+			if (cntdwn-- == 0)
+				break;
+		}
+		vblk = list_entry(iter, struct vmufat_block_list, b_list);
+		clear_buffer_new(bh_result);
+		error = 0;
+		phys = vblk->bno;
+		goto got_it;
+	}
+	if (!create)
+		goto out;
+	/*
+	 * check not looking for a block too far
+	 * beyond the end of the existing file
+	 */
+	if (iblock > vin->nblcks)
+		goto out;
+
+	/* if looking for a block that is not current - allocate it */
+	cural = vin->nblcks;
+	list_for_each(iter, &vlist->b_list) {
+		if (cural-- == 1)
+			break;
+	}
+	vblk = list_entry(iter, struct vmufat_block_list, b_list);
+	finblk = vblk->bno;
+
+	mutex_lock(&vmudetails->mutex);
+	/* Exec files have to be linear */
+	if (inode->i_ino == 0) {
+		exeblk = vmufat_get_fat(sb, finblk + 1);
+		if (exeblk != VMUFAT_UNALLOCATED) {
+			mutex_unlock(&vmudetails->mutex);
+			printk(KERN_WARNING "VMUFAT: Cannot allocate linear "
+				"space needed for executible\n");
+			error = -ENOSPC;
+			goto out;
+		}
+		nxtblk = finblk + 1;
+	} else {
+		nxtblk = vmufat_find_free(sb);
+		if (nxtblk < 0) {
+			mutex_unlock(&vmudetails->mutex);
+			error = nxtblk;
+			goto out;
+		}
+	}
+	error = vmufat_set_fat(sb, finblk, nxtblk);
+	if (error) {
+		mutex_unlock(&vmudetails->mutex);
+		goto out;
+	}
+	error = vmufat_set_fat(sb, nxtblk, VMUFAT_FILE_END);
+	mutex_unlock(&vmudetails->mutex);
+	if (error)
+		goto out;
+	error = vmufat_list_blocks(inode);
+	mark_inode_dirty(inode);
+	if (error)
+		goto out;
+	set_buffer_new(bh_result);
+	phys = nxtblk;
+	error = 0;
+got_it:
+	map_bh(bh_result, sb, phys);
+out:
+	return error;
+}
+
+static int vmufat_writepages(struct address_space *mapping, struct writeback_control *wbc)
+{
+	return mpage_writepages(mapping, wbc, vmufat_get_block);
+}
+
+static int vmufat_write_begin(const struct kiocb *iocb, struct address_space *mapping,
+		loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
+{
+	*foliop = NULL;
+	return block_write_begin(mapping, pos, len, foliop, vmufat_get_block);
+}
+
+static int vmufat_read_folio(struct file *file, struct folio *folio)
+{
+	return block_read_full_folio(folio, vmufat_get_block);
+}
+
+const struct address_space_operations
+		vmufat_address_space_operations = {
+	.read_folio =	vmufat_read_folio,
+	.writepages =	vmufat_writepages,
+	.write_begin =	vmufat_write_begin,
+	.write_end =	generic_write_end,
+};
+
+const struct inode_operations vmufat_inode_operations = {
+	.lookup =	vmufat_inode_lookup,
+	.create =	vmufat_inode_create,
+	.unlink =	vmufat_unlink,
+};
+
+const struct file_operations vmufat_file_dir_operations = {
+	.owner =	THIS_MODULE,
+	.read =		generic_read_dir,
+	.iterate_shared =	vmufat_readdir,
+	.fsync =	generic_file_fsync,
+};
+
+const struct file_operations vmufat_file_operations = {
+	.llseek =	generic_file_llseek,
+	.read_iter =	generic_file_read_iter,
+	.write_iter =	generic_file_write_iter,
+	.fsync =	generic_file_fsync,
+};
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
new file mode 100644
index 00000000000000..7c1a40eb279a8b
--- /dev/null
+++ b/fs/vmufat/super.c
@@ -0,0 +1,545 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * VMUFAT file system
+ *
+ * Copyright (C) 2002 - 2012, 2025	Adrian McMenamin
+ * Copyright (C) 2002		        Paul Mundt
+ *
+ * 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 02111-1307, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/magic.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/statfs.h>
+#include <linux/buffer_head.h>
+#include <linux/fs_context.h>
+#include "vmufat.h"
+
+static struct kmem_cache *vmufat_inode_cachep;
+static const struct super_operations vmufat_super_operations;
+extern int *day_n;
+extern const struct inode_operations vmufat_inode_operations;
+extern const struct file_operations vmufat_file_operations;
+extern const struct address_space_operations vmufat_address_space_operations;
+extern const struct file_operations vmufat_file_dir_operations;
+
+static time64_t vmufat_get_date(struct buffer_head *bh, int offset)
+{
+	int century, year, month, day, hour, minute, second;
+	century = bcd2bin(bh->b_data[offset++]);
+	year = bcd2bin(bh->b_data[offset++]);
+	month = bcd2bin(bh->b_data[offset++]);
+	day = bcd2bin(bh->b_data[offset++]);
+	hour = bcd2bin(bh->b_data[offset++]);
+	minute = bcd2bin(bh->b_data[offset++]);
+	second = bcd2bin(bh->b_data[offset]);
+
+	return mktime64(century * 100 + year, month, day, hour, minute,
+		second);
+}
+
+static struct inode *vmufat_alloc_inode(struct super_block *sb)
+{
+	struct vmufat_inode *vi = kmem_cache_alloc(vmufat_inode_cachep,
+		GFP_KERNEL);
+	if (!vi)
+		return NULL;
+
+	INIT_LIST_HEAD(&vi->blocks.b_list);
+	return &vi->vfs_inode;
+}
+
+static void vmufat_destroy_inode(struct inode *in)
+{
+	struct vmufat_inode *vi;
+	struct vmufat_block_list *vb;
+	struct list_head *iter, *iter2;
+	vi = VMUFAT_I(in);
+	if (!vi)
+		return;
+
+	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
+		vb = list_entry(iter, struct vmufat_block_list, b_list);
+		list_del(iter);
+	}
+	kmem_cache_free(vmufat_inode_cachep, vi);
+}
+
+struct inode *vmufat_get_inode(struct super_block *sb, long ino)
+{
+	struct buffer_head *bh = NULL;
+	int error = 0, i, j, found = 0;
+	int offsetindir;
+	struct inode *inode;
+	struct memcard *vmudetails;
+	long superblock_bno;
+	struct timespec64 current_time;
+
+	vmudetails = sb->s_fs_info;
+	inode = iget_locked(sb, ino);
+	if (!inode) {
+		error = -EIO;
+		goto reterror;
+	}
+	superblock_bno = vmudetails->sb_bnum;
+
+	if (inode->i_state & I_NEW) {
+		inode->i_uid = current_fsuid();
+		inode->i_gid = current_fsgid();
+		inode->i_mode &= ~S_IFMT;
+		if (inode->i_ino == superblock_bno) {
+			bh = vmufat_sb_bread(sb, inode->i_ino);
+			if (!bh) {
+				error = -EIO;
+				goto failed;
+			}
+			inode->i_ctime_sec = inode->i_mtime_sec =
+				vmufat_get_date(bh, VMUFAT_SB_DATEOFFSET);
+
+			/* Mark as a directory */
+			inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
+			inode->i_op = &vmufat_inode_operations;
+			inode->i_fop = &vmufat_file_dir_operations;
+		} else {
+			/* Mark file as regular type */
+			inode->i_mode = S_IFREG | S_IRUGO | S_IWUSR;
+
+			/* Scan through the directory to find matching file */
+			for (i = vmudetails->dir_bnum;
+				i > vmudetails->dir_bnum - vmudetails->dir_len;
+				i--) {
+				brelse(bh);
+				bh = vmufat_sb_bread(sb, i);
+				if (!bh) {
+					error = -EIO;
+					goto failed;
+				}
+				for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++)
+				{
+					if (bh->b_data[j * VMU_DIR_RECORD_LEN]
+						== 0)
+						goto notfound;
+					if (le16_to_cpu(((u16 *) bh->b_data)
+					[j * VMU_DIR_RECORD_LEN16 +
+					VMUFAT_FIRSTBLOCK_OFFSET16]) == ino) {
+						found = 1;
+						goto found;
+					}
+				}
+			}
+notfound:
+			error = -ENOENT;
+			goto failed;
+found:
+			/* identified the correct directory entry */
+			offsetindir = j * VMU_DIR_RECORD_LEN;
+			inode->i_ctime_sec = inode->i_mtime_sec =
+				vmufat_get_date(bh,
+					offsetindir + VMUFAT_FILE_DATEOFFSET);
+
+			/* Execute if a game, write if not copy protected */
+			inode->i_mode &= ~(S_IWUGO | S_IXUGO);
+			inode->i_mode |= S_IRUGO;
+
+			/* Mode - is it write protected? */
+			if ((((u8 *) bh->b_data)[0x01 + offsetindir] ==
+			     0x00) & ~(sb->s_flags & SB_RDONLY))
+				inode->i_mode |= S_IWUSR;
+			/* Is file executible - ie a game */
+			if ((((u8 *) bh->b_data)[offsetindir] ==
+			     0xcc) & ~(sb->s_flags & SB_NOEXEC))
+				inode->i_mode |= S_IXUSR;
+
+			inode->i_fop = &vmufat_file_operations;
+
+			inode->i_blocks =
+			    le16_to_cpu(((u16 *) bh->b_data)
+				[offsetindir / 2 + 0x0C]);
+			inode->i_size = inode->i_blocks * sb->s_blocksize;
+
+			inode->i_mapping->a_ops =
+				&vmufat_address_space_operations;
+			inode->i_op = &vmufat_inode_operations;
+			inode->i_fop = &vmufat_file_operations;
+			error = vmufat_list_blocks(inode);
+			if (error)
+				goto failed;
+		}
+		ktime_get_coarse_real_ts64(&current_time);
+		inode->i_atime_sec = current_time.tv_sec;
+		unlock_new_inode(inode);
+	}
+	brelse(bh);
+	return inode;
+
+failed:
+	iget_failed(inode);
+reterror:
+	brelse(bh);
+	return ERR_PTR(error);
+}
+
+static void vmufat_put_super(struct super_block *sb)
+{
+	sb->s_dev = 0;
+	kfree(sb->s_fs_info);
+}
+
+static int vmufat_count_freeblocks(struct super_block *sb,
+					struct kstatfs *kstatbuf)
+{
+	int i, free = 0, error = 0;
+	struct memcard *vmudetails = sb->s_fs_info;
+
+	/* Look through the FAT */
+	for (i = 0; i < vmudetails->numblocks; i++) {
+		if (vmufat_get_fat(sb, i) == VMUFAT_UNALLOCATED)
+			free++;
+	}
+	kstatbuf->f_bfree = free;
+	kstatbuf->f_bavail = free;
+	kstatbuf->f_blocks = vmudetails->numblocks;
+	return error;
+}
+
+static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
+{
+	int error;
+	struct super_block *sb;
+
+	sb = dentry->d_sb;
+	error = vmufat_count_freeblocks(sb, kstatbuf);
+	if (error)
+		goto out;
+	kstatbuf->f_type = VMUFAT_MAGIC;
+	kstatbuf->f_bsize = sb->s_blocksize;
+	kstatbuf->f_namelen = VMUFAT_NAMELEN;
+out:
+	return error;
+}
+
+/* Remove inode from memory */
+static void vmufat_evict_inode(struct inode *in)
+{
+	truncate_inode_pages(&in->i_data, 0);
+	invalidate_inode_buffers(in);
+	in->i_size = 0;
+	clear_inode(in);
+}
+
+/*
+ * There are no inodes on the medium - vmufat_write_inode
+ * updates the directory entry
+ */
+static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
+{
+	struct buffer_head *bh = NULL;
+	unsigned long inode_num;
+	int i, j, found = 0, error = 0;
+	int pos, pos16;
+	struct super_block *sb;
+	struct memcard *vmudetails;
+	struct timespec64 current_time;
+	sb = in->i_sb;
+	vmudetails = sb->s_fs_info;
+
+	/* As most real world devices are flash we
+	 * won't update the superblock every time */
+	if (in->i_ino == vmudetails->sb_bnum)
+		goto out;
+	if (in->i_ino == VMUFAT_ZEROBLOCK)
+		inode_num = 0;
+	else
+		inode_num = in->i_ino;
+
+	/* update the directory and inode details */
+	/* Now search for the directory entry */
+	mutex_lock(&vmudetails->mutex);
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			mutex_unlock(&vmudetails->mutex);
+			error = -EIO;
+			goto out;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			pos = j * VMU_DIR_RECORD_LEN;
+			pos16 = j * VMU_DIR_RECORD_LEN16;
+			if (bh->b_data[pos] == 0) {
+				mutex_unlock(&vmudetails->mutex);
+				brelse(bh);
+				error = -ENOENT;
+				goto out;
+			}
+			if (le16_to_cpu(((u16 *)bh->b_data)
+				[pos16 + VMUFAT_FIRSTBLOCK_OFFSET16])
+				== inode_num) {
+				found = 1;
+				goto found;
+			}
+		}
+		brelse(bh);
+	}
+found:
+	if (found == 0) {
+		mutex_unlock(&vmudetails->mutex);
+		error = -EIO;
+		goto out;
+	}
+
+	/* Have the directory entry
+	 * so now update it */
+	if (inode_num != 0)
+		bh->b_data[pos] = VMU_DATA;
+	else
+		bh->b_data[pos] = VMU_GAME;
+	if (bh->b_data[pos + 1] !=  0 && bh->b_data[pos + 1] != (char) 0xff)
+		bh->b_data[pos + 1] = 0;
+	((u16 *) bh->b_data)[pos16 + 1] = cpu_to_le16(inode_num);
+
+	/* BCD timestamp it */
+	ktime_get_coarse_real_ts64(&current_time);
+	in->i_mtime_sec = current_time.tv_sec;
+	vmufat_save_bcd(in, bh->b_data, pos);
+
+	((u16 *) bh->b_data)[pos16 + VMUFAT_SIZE_OFFSET16] =
+		cpu_to_le16(in->i_blocks);
+	if (inode_num != 0)
+		((u16 *) bh->b_data)[pos16 + VMUFAT_HEADER_OFFSET16] = 0;
+	else /* game */
+		((u16 *) bh->b_data)[pos16 + VMUFAT_HEADER_OFFSET16]
+			= cpu_to_le16(1);
+	mutex_unlock(&vmudetails->mutex);
+	mark_buffer_dirty(bh);
+	brelse(bh);
+out:
+	return error;
+}
+
+static int check_sb_format(struct buffer_head *bh)
+{
+	return (((u32 *) bh->b_data)[0] == VMUFAT_MAGIC &&
+		((u32 *) bh->b_data)[1] == VMUFAT_MAGIC &&
+		((u32 *) bh->b_data)[2] == VMUFAT_MAGIC &&
+		((u32 *) bh->b_data)[3] == VMUFAT_MAGIC);
+}
+
+static void vmufat_populate_vmudata(struct memcard *vmudata,
+		struct buffer_head *bh, int test_sz)
+{
+	vmudata->sb_bnum = test_sz - 1;
+	vmudata->fat_bnum =
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_FAT]);
+	vmudata->fat_len =
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_FATLEN]);
+	vmudata->dir_bnum =
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_DIR]);
+	vmudata->dir_len =
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_DIRLEN]);
+	/* return the true number of user available blocks - physical VMUs
+ 	 * return a neat 200 and ignore 40 blocks of usable space -
+ 	 * we get round that in a hardware neutral way */
+	vmudata->numblocks = vmudata->dir_bnum - vmudata->dir_len + 1;
+}
+
+static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
+{
+	int i;
+
+	for (i = VMUFAT_MIN_BLK; i <= VMUFAT_MAX_BLK; i = i * 2) {
+		brelse(*bh);
+		*bh = vmufat_sb_bread(sb, i - 1);
+		if (*bh == NULL) {
+			i = -EIO;
+			goto out;
+		}
+		if (check_sb_format(*bh))
+			break;
+	}
+	if (i > VMUFAT_MAX_BLK) {
+		brelse(*bh);
+		i = -ENOENT;
+	}
+out:
+	return i;
+}
+
+static int vmufat_set_fs_private(struct fs_context *fc)
+{
+	int err = 0;
+	struct memcard *vmudata;
+
+	vmudata = kmalloc(sizeof(struct memcard), GFP_KERNEL);
+	if (!vmudata) {
+		err = -ENOMEM;
+	}
+	fc->s_fs_info = vmudata;
+	return err;
+}
+
+static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
+{
+	struct buffer_head *bh = NULL;
+	struct memcard *vmudata = fc->s_fs_info;
+	int test_sz;
+	struct inode *root_i;
+	int ret = 0;
+
+	sb_set_blocksize(sb, VMU_BLK_SZ);
+	sb->s_blocksize_bits = ilog2(VMU_BLK_SZ);
+	sb->s_magic = VMUFAT_MAGIC;
+	sb->s_op = &vmufat_super_operations;
+
+	/* 
+	 * Hardware VMUs are 256 blocks in size but
+	 * the specification allows for other sizes
+	 */
+	test_sz = vmufat_get_size(sb, &bh);
+	if (test_sz < VMUFAT_MIN_BLK) {
+		printk(KERN_ERR "VMUFAT: attempted to mount corrupted vmufat "
+			"or non-vmufat violume as vmufat.\n");
+		ret = test_sz;
+		goto out;
+	}
+
+	vmufat_populate_vmudata(vmudata, bh, test_sz);
+	mutex_init(&vmudata->mutex);
+	sb->s_fs_info = vmudata;
+
+	root_i = vmufat_get_inode(sb, vmudata->sb_bnum);
+	if (!root_i) {
+		printk(KERN_ERR "VMUFAT: get root inode failed\n");
+		ret = -ENOMEM;
+		goto freevmudata_out;
+	}
+	if (IS_ERR(root_i)) {
+		printk(KERN_ERR "VMUFAT: get root"
+			" inode failed - error 0x%lX\n",
+			PTR_ERR(root_i));
+		ret = PTR_ERR(root_i);
+		goto freevmudata_out;
+	}
+
+	sb->s_root = d_make_root(root_i);
+	if (!sb->s_root) {
+		ret = -EIO;
+		goto freevmudata_out;
+	}
+	else 
+		goto out;
+
+freevmudata_out:
+	kfree(vmudata);
+	brelse(bh);
+out:
+	return ret;
+}
+
+static void init_once(void *foo)
+{
+	struct vmufat_inode *vi = foo;
+
+	vi->nblcks = 0;
+	inode_init_once(&vi->vfs_inode);
+}
+
+static int init_inodecache(void)
+{
+	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
+		sizeof(struct vmufat_inode), 0,
+			SLAB_RECLAIM_ACCOUNT, init_once);
+	return vmufat_inode_cachep ? 0 : -ENOMEM;
+
+}
+
+static void destroy_inodecache(void)
+{
+	rcu_barrier();
+	kmem_cache_destroy(vmufat_inode_cachep);
+}
+
+static const struct super_operations vmufat_super_operations = {
+	.alloc_inode =		vmufat_alloc_inode,
+	.destroy_inode =	vmufat_destroy_inode,
+	.write_inode =		vmufat_write_inode,
+	.evict_inode =		vmufat_evict_inode,
+	.put_super =		vmufat_put_super,
+	.statfs =		vmufat_statfs,
+};
+
+static int vmufat_get_tree(struct fs_context *fc)
+{
+	return get_tree_bdev(fc, vmufat_fill_super);
+}
+
+static void vmufat_free_fc(struct fs_context *fc)
+{
+	struct memcard *vmudata = fc->s_fs_info;
+	kfree(vmudata);
+}
+
+static const struct fs_context_operations vmufat_fs_context_ops = {
+	.get_tree	= vmufat_get_tree,
+	.free		= vmufat_free_fc,
+};
+
+static int vmufat_init_fs_context(struct fs_context *fc)
+{
+	int err = 0;
+	err = vmufat_set_fs_private(fc);
+	fc->ops = &vmufat_fs_context_ops;
+	return err;
+}
+
+
+
+static struct file_system_type vmufat_fs_type = {
+	.owner		= THIS_MODULE,
+	.name		= "vmufat",
+//	.mount		= vmufat_mount,
+	.kill_sb	= kill_block_super,
+	.fs_flags	= FS_REQUIRES_DEV,
+	.init_fs_context = vmufat_init_fs_context
+
+};
+
+static int __init init_vmufat_fs(void)
+{
+	int err;
+	err = init_inodecache();
+	if (err)
+		return err;
+	return register_filesystem(&vmufat_fs_type);
+}
+
+static void __exit exit_vmufat_fs(void)
+{
+	destroy_inodecache();
+	unregister_filesystem(&vmufat_fs_type);
+}
+
+module_init(init_vmufat_fs);
+module_exit(exit_vmufat_fs);
+
+MODULE_DESCRIPTION("Filesystem used in Sega Dreamcast VMU");
+MODULE_AUTHOR("Adrian McMenamin <adrianmcmenamin@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
new file mode 100644
index 00000000000000..884784cafacc9f
--- /dev/null
+++ b/fs/vmufat/vmufat.h
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-2.0+
+/* Header file for VMUFAT filesystem */
+#ifndef _VMUFAT_H_
+#define _VMUFAT_H_
+
+/* maximum length of file name */
+#define VMUFAT_NAMELEN			12
+
+/* GNU utils won't list files with inode num 0 */
+#define VMUFAT_ZEROBLOCK		0x10000
+#define VMU_BLK_SZ			512
+#define	VMU_BLK_SZ16			256
+
+/* file allocation table markers */
+#define VMUFAT_FILE_END			0xFFFA
+#define VMUFAT_UNALLOCATED		0xFFFC
+#define VMUFAT_ERROR			0xFFFF
+
+/* parameters for possible VMU volume sizes */
+#define VMUFAT_MIN_BLK			0x04
+#define VMUFAT_MAX_BLK			0x10000
+#define VMUFAT_START_ALLOC		199
+
+/* specifcations for directory entries */
+#define VMU_DIR_RECORD_LEN		0x20
+#define VMU_DIR_RECORD_LEN16		0x10
+#define VMU_DIR_ENTRIES_PER_BLOCK	0x10
+#define VMUFAT_NAME_OFFSET		0x04
+#define VMUFAT_FIRSTBLOCK_OFFSET16	0x01
+#define VMUFAT_START_OFFSET16		0x01
+#define VMUFAT_SIZE_OFFSET16		0x0C
+#define VMUFAT_HEADER_OFFSET16		0x0D
+
+/* File types used in directory */
+#define VMU_GAME			0xCC
+#define VMU_DATA			0x33
+
+/* filesystem locations marked in the root block */
+#define VMU_LOCATION_FAT		0x23
+#define VMU_LOCATION_FATLEN		0x24
+#define VMU_LOCATION_DIR		0x25
+#define VMU_LOCATION_DIRLEN		0x26
+#define VMU_LOCATION_USRLEN		0x28 /* reports false figure */
+
+/* date offsets */
+#define VMUFAT_SB_DATEOFFSET		0x30
+#define VMUFAT_FILE_DATEOFFSET		0x10
+
+#define EXEC				0111
+#define NOCOPY				0xFF
+#define CANCOPY				0x00
+
+u16 vmufat_get_fat(struct super_block *sb, long block);
+void vmufat_save_bcd(struct inode *in, char *bh, int index_to_dir);
+struct inode *vmufat_get_inode(struct super_block *sb, long ino);
+int vmufat_list_blocks(struct inode *in);
+
+enum vmufat_date {
+	VMUFAT_DIR_CENT	=		0x10,
+	VMUFAT_DIR_YEAR,
+	VMUFAT_DIR_MONTH,
+	VMUFAT_DIR_DAY,
+	VMUFAT_DIR_HOUR,
+	VMUFAT_DIR_MIN,
+	VMUFAT_DIR_SEC,
+	VMUFAT_DIR_DOW
+};
+
+/* constants for BCD conversion */
+#define SECONDS_PER_DAY			86400
+#define DAYS_PER_YEAR			365
+#define SECONDS_PER_HOUR		3600
+#define HOURS_PER_DAY			24
+#define SIXTY_MINS_OR_SECS		60
+#define FEB28				59
+
+struct memcard {
+	unsigned int sb_bnum;
+	unsigned int fat_bnum;
+	unsigned int fat_len;
+	unsigned int dir_bnum;
+	unsigned int dir_len;
+	unsigned int numblocks;
+	struct mutex mutex;
+};
+
+struct vmufat_block_list {
+	struct list_head b_list;
+	int bno;
+};
+
+struct vmufat_inode {
+	struct vmufat_block_list blocks;
+	unsigned int nblcks;
+	struct inode vfs_inode;
+};
+
+static inline struct vmufat_inode *VMUFAT_I(struct inode *in)
+{
+	return container_of(in, struct vmufat_inode, vfs_inode);
+}
+
+struct vmufat_file_info {
+	u8 ftype;
+	int fblk;
+	char fname[VMUFAT_NAMELEN];
+};
+
+static inline struct buffer_head *vmufat_sb_bread(struct super_block *sb,
+	sector_t block)
+{
+	if (!sb)
+		return NULL;
+	return sb_bread(sb, block);
+}
+#endif

From aeac7617d1b34c9112c70d09f7233b0a22a3d631 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 4 Dec 2025 19:41:17 +0000
Subject: [PATCH 004/101] superblock magic fixes

---
 fs/vmufat/super.c          | 5 ++---
 fs/vmufat/vmufat.h         | 2 +-
 include/uapi/linux/magic.h | 1 +
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 7c1a40eb279a8b..61a8e90b25c41e 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -229,7 +229,7 @@ static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
 	error = vmufat_count_freeblocks(sb, kstatbuf);
 	if (error)
 		goto out;
-	kstatbuf->f_type = VMUFAT_MAGIC;
+	kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
 	kstatbuf->f_bsize = sb->s_blocksize;
 	kstatbuf->f_namelen = VMUFAT_NAMELEN;
 out:
@@ -406,7 +406,7 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	sb_set_blocksize(sb, VMU_BLK_SZ);
 	sb->s_blocksize_bits = ilog2(VMU_BLK_SZ);
-	sb->s_magic = VMUFAT_MAGIC;
+	sb->s_magic = VMUFAT_SUPER_MAGIC;
 	sb->s_op = &vmufat_super_operations;
 
 	/* 
@@ -515,7 +515,6 @@ static int vmufat_init_fs_context(struct fs_context *fc)
 static struct file_system_type vmufat_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "vmufat",
-//	.mount		= vmufat_mount,
 	.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
 	.init_fs_context = vmufat_init_fs_context
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 884784cafacc9f..1d116525646e13 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -106,7 +106,7 @@ struct vmufat_file_info {
 	char fname[VMUFAT_NAMELEN];
 };
 
-static inline struct buffer_head *vmufat_sb_bread(struct super_block *sb,
+static struct buffer_head *vmufat_sb_bread(struct super_block *sb,
 	sector_t block)
 {
 	if (!sb)
diff --git a/include/uapi/linux/magic.h b/include/uapi/linux/magic.h
index 4f2da935a76cca..7a3ab866ef4843 100644
--- a/include/uapi/linux/magic.h
+++ b/include/uapi/linux/magic.h
@@ -54,6 +54,7 @@
 #define QNX4_SUPER_MAGIC	0x002f		/* qnx4 fs detection */
 #define QNX6_SUPER_MAGIC	0x68191122	/* qnx6 fs detection */
 #define AFS_FS_MAGIC		0x6B414653
+#define VMUFAT_SUPER_MAGIC	0x55555555  /* opening bytes of root */
 
 
 #define REISERFS_SUPER_MAGIC	0x52654973	/* used by gcc */

From 0548b9f06328ad66c66effc5fa10d5de994e2f4a Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 4 Dec 2025 21:42:00 +0000
Subject: [PATCH 005/101] beware of null pointer dereference and match new API
 for status

---
 fs/vmufat/super.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 61a8e90b25c41e..f5663ba891b38a 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -93,15 +93,19 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 	long superblock_bno;
 	struct timespec64 current_time;
 
-	vmudetails = sb->s_fs_info;
 	inode = iget_locked(sb, ino);
-	if (!inode) {
+	if (!inode || !sb) {
+		error = -EIO;
+		goto reterror;
+	}
+	vmudetails = sb->s_fs_info;
+	if (!vmudetails) {
 		error = -EIO;
 		goto reterror;
 	}
 	superblock_bno = vmudetails->sb_bnum;
 
-	if (inode->i_state & I_NEW) {
+	if (inode_state_read_once(inode) & I_NEW) {
 		inode->i_uid = current_fsuid();
 		inode->i_gid = current_fsgid();
 		inode->i_mode &= ~S_IFMT;
@@ -337,10 +341,10 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 
 static int check_sb_format(struct buffer_head *bh)
 {
-	return (((u32 *) bh->b_data)[0] == VMUFAT_MAGIC &&
-		((u32 *) bh->b_data)[1] == VMUFAT_MAGIC &&
-		((u32 *) bh->b_data)[2] == VMUFAT_MAGIC &&
-		((u32 *) bh->b_data)[3] == VMUFAT_MAGIC);
+	return (((u32 *) bh->b_data)[0] == VMUFAT_SUPER_MAGIC &&
+		((u32 *) bh->b_data)[1] == VMUFAT_SUPER_MAGIC &&
+		((u32 *) bh->b_data)[2] == VMUFAT_SUPER_MAGIC &&
+		((u32 *) bh->b_data)[3] == VMUFAT_SUPER_MAGIC);
 }
 
 static void vmufat_populate_vmudata(struct memcard *vmudata,

From 8ba577e457d14d0f6b7615fe5d890bebfeff4cf3 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 24 Jan 2026 20:41:07 +0000
Subject: [PATCH 006/101] add comma, tidy

---
 fs/vmufat/super.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index f5663ba891b38a..a3a196dde26ae0 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -427,7 +427,6 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 
 	vmufat_populate_vmudata(vmudata, bh, test_sz);
 	mutex_init(&vmudata->mutex);
-	sb->s_fs_info = vmudata;
 
 	root_i = vmufat_get_inode(sb, vmudata->sb_bnum);
 	if (!root_i) {
@@ -472,7 +471,6 @@ static int init_inodecache(void)
 		sizeof(struct vmufat_inode), 0,
 			SLAB_RECLAIM_ACCOUNT, init_once);
 	return vmufat_inode_cachep ? 0 : -ENOMEM;
-
 }
 
 static void destroy_inodecache(void)
@@ -514,15 +512,12 @@ static int vmufat_init_fs_context(struct fs_context *fc)
 	return err;
 }
 
-
-
 static struct file_system_type vmufat_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "vmufat",
 	.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
-	.init_fs_context = vmufat_init_fs_context
-
+	.init_fs_context = vmufat_init_fs_context,
 };
 
 static int __init init_vmufat_fs(void)

From 904c8dc218650823e79f6c18ae119ef5b170e2ae Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 1 Feb 2026 19:28:14 +0000
Subject: [PATCH 007/101] create the vmudata structure in sb code

---
 fs/vmufat/super.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index a3a196dde26ae0..da52e34d2e0eea 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -390,24 +390,23 @@ static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 static int vmufat_set_fs_private(struct fs_context *fc)
 {
 	int err = 0;
-	struct memcard *vmudata;
-
-	vmudata = kmalloc(sizeof(struct memcard), GFP_KERNEL);
-	if (!vmudata) {
-		err = -ENOMEM;
-	}
-	fc->s_fs_info = vmudata;
 	return err;
 }
 
 static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 {
 	struct buffer_head *bh = NULL;
-	struct memcard *vmudata = fc->s_fs_info;
+	struct memcard *vmudata;
 	int test_sz;
 	struct inode *root_i;
 	int ret = 0;
 
+	vmudata = kmalloc(sizeof(struct memcard), GFP_KERNEL);
+	if (!vmudata) {
+		ret = -ENOMEM;
+		goto freevmudata_out;
+	}
+	sb->s_fs_info = vmudata;
 	sb_set_blocksize(sb, VMU_BLK_SZ);
 	sb->s_blocksize_bits = ilog2(VMU_BLK_SZ);
 	sb->s_magic = VMUFAT_SUPER_MAGIC;
@@ -432,27 +431,29 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 	if (!root_i) {
 		printk(KERN_ERR "VMUFAT: get root inode failed\n");
 		ret = -ENOMEM;
-		goto freevmudata_out;
+		goto freebh_out;
 	}
 	if (IS_ERR(root_i)) {
 		printk(KERN_ERR "VMUFAT: get root"
 			" inode failed - error 0x%lX\n",
 			PTR_ERR(root_i));
 		ret = PTR_ERR(root_i);
-		goto freevmudata_out;
+		goto freebh_out;
 	}
 
 	sb->s_root = d_make_root(root_i);
 	if (!sb->s_root) {
 		ret = -EIO;
-		goto freevmudata_out;
+		goto freebh_out;
 	}
 	else 
 		goto out;
 
+freebh_out:
+	brelse(bh);
 freevmudata_out:
 	kfree(vmudata);
-	brelse(bh);
+
 out:
 	return ret;
 }
@@ -495,8 +496,7 @@ static int vmufat_get_tree(struct fs_context *fc)
 
 static void vmufat_free_fc(struct fs_context *fc)
 {
-	struct memcard *vmudata = fc->s_fs_info;
-	kfree(vmudata);
+
 }
 
 static const struct fs_context_operations vmufat_fs_context_ops = {

From 01c281681271afacca88eed9251a35d6d4cd6f03 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 13 Feb 2026 19:10:28 +0000
Subject: [PATCH 008/101] use ctx

---
 fs/vmufat/inode.c | 25 ++++++++++++++-----------
 fs/vmufat/super.c |  2 +-
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 88903c1678a740..b77615f29c7cf6 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -276,14 +276,16 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 
 	if (rtc_read_time(rtc, &now) < 0)
 		vmufat_save_bcd_nortc(in, bh, index_to_dir);
-	bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)(now.tm_year/100));
-	bh[index_to_dir + VMUFAT_DIR_YEAR] = bin2bcd((char)(now.tm_year % 100));
-	bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd((char)(now.tm_mon));
-	bh[index_to_dir + VMUFAT_DIR_DAY] = bin2bcd((char)(now.tm_mday));
-	bh[index_to_dir + VMUFAT_DIR_HOUR] = bin2bcd((char)(now.tm_hour));
-	bh[index_to_dir + VMUFAT_DIR_MIN] = bin2bcd((char)(now.tm_min));
-	bh[index_to_dir + VMUFAT_DIR_SEC] = bin2bcd((char)(now.tm_sec));
-	bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)(now.tm_wday));
+	else {
+		bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)(now.tm_year/100));
+		bh[index_to_dir + VMUFAT_DIR_YEAR] = bin2bcd((char)(now.tm_year % 100));
+		bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd((char)(now.tm_mon));
+		bh[index_to_dir + VMUFAT_DIR_DAY] = bin2bcd((char)(now.tm_mday));
+		bh[index_to_dir + VMUFAT_DIR_HOUR] = bin2bcd((char)(now.tm_hour));
+		bh[index_to_dir + VMUFAT_DIR_MIN] = bin2bcd((char)(now.tm_min));
+		bh[index_to_dir + VMUFAT_DIR_SEC] = bin2bcd((char)(now.tm_sec));
+		bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)(now.tm_wday));
+	}
 }
 
 /*
@@ -474,9 +476,10 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 	dentry = filp->f_path.dentry;
 	sb = inode->i_sb;
 	vmudetails = sb->s_fs_info;
-	index = filp->f_pos;
+	index = ctx->pos;
+	//index = filp->f_pos; //change to ctx->pos
 	/* handle . for this directory and .. for parent */
-	switch ((unsigned int) filp->f_pos) {
+	switch ((unsigned int) ctx->pos) {
 	case 0:
 		error = ctx->actor(ctx, ".", 1, index++, inode->i_ino, DT_DIR);
 		if (error < 0)
@@ -532,7 +535,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 	}
 
 finish:
-	filp->f_pos = index;
+	ctx->pos = index;
 	kfree(saved_file);
 	brelse(bh);
 out:
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index da52e34d2e0eea..52d0e26316b2e0 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -362,7 +362,7 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 	/* return the true number of user available blocks - physical VMUs
  	 * return a neat 200 and ignore 40 blocks of usable space -
  	 * we get round that in a hardware neutral way */
-	vmudata->numblocks = vmudata->dir_bnum - vmudata->dir_len + 1;
+	vmudata->numblocks = vmudata->sb_bnum + 1;
 }
 
 static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)

From 4914df2218a5b8db951cf247b6926b2b39e7abdc Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Feb 2026 12:50:06 +0000
Subject: [PATCH 009/101] attempy to fix slab and leap year issues

---
 fs/vmufat/inode.c  | 42 ++++++++++++++++++++++--------------------
 fs/vmufat/super.c  | 20 ++++++++++++++++++--
 fs/vmufat/vmufat.h |  6 +++++-
 3 files changed, 45 insertions(+), 23 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index b77615f29c7cf6..2ccebe1cf2e698 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -37,7 +37,7 @@ const struct inode_operations vmufat_inode_operations;
 const struct file_operations vmufat_file_operations;
 const struct address_space_operations vmufat_address_space_operations;
 const struct file_operations vmufat_file_dir_operations;
-struct kmem_cache *vmufat_blist_cachep;
+extern struct kmem_cache *vmufat_blist_cachep;
 /* Linear day numbers of the respective 1sts in non-leap years. */
 int day_n[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
@@ -223,6 +223,7 @@ static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 	long years, days;
 	unsigned char bcd_century, nl_day, bcd_month;
 	unsigned char u8year;
+	bool century22 = FALSE;
 	time64_t unix_date;
 
 	unix_date = in->i_mtime_sec;
@@ -233,9 +234,13 @@ static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 		years--;
 	/* rebase days to account for leap years */
 	days -= (years + 3) / 4 + DAYS_PER_YEAR * years;
+	// 2100 is not a leap year
+	if (years >= CENTURY22 + 1) {
+		days--;
+	}
 	/* 1 Jan is Day 1 */
 	days++;
-	if (days == (FEB28 + 1) && !(years % 4)) {
+	if (days == (FEB28 + 1) && !(years % 4) && (years != CENTURY22)) {
 		nl_day = days;
 		bcd_month = 2;
 	} else {
@@ -246,13 +251,11 @@ static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 	}
 
 	bcd_century = 19;
-	/* TODO:accounts for 21st century but will fail in 2100
-		because of leap days */
 	if (years > 29)
-		bcd_century += 1 + (years - 30)/100;
+		bcd_century += 1 + (years - CENTURY21)/100;
 
 	bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd(bcd_century);
-	u8year = years + 70; /* account for epoch */
+	u8year = years + START_OF_EPOCH; /* account for epoch */
 	if (u8year > 99)
 		u8year = u8year - 100;
 
@@ -274,7 +277,7 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 {
 	struct rtc_time now;
 
-	if (rtc_read_time(rtc, &now) < 0)
+	if (rtc_read_time(rtc, &now))
 		vmufat_save_bcd_nortc(in, bh, index_to_dir);
 	else {
 		bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)(now.tm_year/100));
@@ -284,7 +287,8 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 		bh[index_to_dir + VMUFAT_DIR_HOUR] = bin2bcd((char)(now.tm_hour));
 		bh[index_to_dir + VMUFAT_DIR_MIN] = bin2bcd((char)(now.tm_min));
 		bh[index_to_dir + VMUFAT_DIR_SEC] = bin2bcd((char)(now.tm_sec));
-		bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)(now.tm_wday));
+		bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)((now.tm_wday + 1))
+			% DAYS_PER_WEEK);
 	}
 }
 
@@ -309,21 +313,20 @@ static int vmufat_allocate_inode(umode_t imode,
 		struct super_block *sb, struct inode *in)
 {
 	int error = 0;
-	/* Executable files must be at the start of the volume */
+	/* Executable files should be at the start of the volume */
 	if (imode & EXEC) {
-		in->i_ino = VMUFAT_ZEROBLOCK;
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
-			printk(KERN_INFO "VMUFAT: cannot write excutable "
-				"file. Volume block 0 already allocated.\n");
-			error = -ENOSPC;
-			goto out;
+			printk(KERN_WARN "VMUFAT: Warning cannot write excutable "
+				"file to block 0. Volume block 0 already allocated.\n");
+		}
+		else {
+			in->i_ino = VMUFAT_ZEROBLOCK;
+			return error;
 		}
-	} else {
-		error = vmufat_find_free(sb);
-		if (error >= 0)
-			in->i_ino = error;
 	}
-out:
+	error = vmufat_find_free(sb);
+	if (error >= 0)
+		in->i_ino = error;
 	return error;
 }
 
@@ -477,7 +480,6 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 	sb = inode->i_sb;
 	vmudetails = sb->s_fs_info;
 	index = ctx->pos;
-	//index = filp->f_pos; //change to ctx->pos
 	/* handle . for this directory and .. for parent */
 	switch ((unsigned int) ctx->pos) {
 	case 0:
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 52d0e26316b2e0..e7161dbd78953a 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -34,6 +34,7 @@
 #include "vmufat.h"
 
 static struct kmem_cache *vmufat_inode_cachep;
+struct kmem_cache *vmufat_blist_cachep;
 static const struct super_operations vmufat_super_operations;
 extern int *day_n;
 extern const struct inode_operations vmufat_inode_operations;
@@ -470,14 +471,29 @@ static int init_inodecache(void)
 {
 	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
 		sizeof(struct vmufat_inode), 0,
-			SLAB_RECLAIM_ACCOUNT, init_once);
-	return vmufat_inode_cachep ? 0 : -ENOMEM;
+		SLAB_RECLAIM_ACCOUNT, init_once);
+	if (!vmufat_inode_cachep) {
+		return -ENOMEM;
+	}
+	rcu_barrier();
+	vmufat_blist_cachep = kmem_cache_create("vmufat_blist_cache",
+		sizeof(struct vmufat_block_list), 0,
+		SLAB_RECLAIM_ACCOUNT, init_once);
+	if (!vmufat_blist_cachep) {
+		rcu_barrier();
+		kmem_cache_destroy(vmufat_inode_cachep);
+		return -ENOMEM;
+	}
+	rcu_barrier();
+	return 0;
 }
 
 static void destroy_inodecache(void)
 {
 	rcu_barrier();
 	kmem_cache_destroy(vmufat_inode_cachep);
+	rcu_barrier();
+	kmem_cache_destroy(vmufat_blist_cachep);
 }
 
 static const struct super_operations vmufat_super_operations = {
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 1d116525646e13..9204dc6ed938e0 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -72,7 +72,11 @@ enum vmufat_date {
 #define SECONDS_PER_HOUR		3600
 #define HOURS_PER_DAY			24
 #define SIXTY_MINS_OR_SECS		60
-#define FEB28				59
+#define FEB28					59
+#define DAYS_PER_WEEK			7
+#define START_OF_EPOCH			70
+#define CENTURY21				30
+#define CENTURY22				130
 
 struct memcard {
 	unsigned int sb_bnum;

From 1ab356b812472413ee0fe88112573be1c03dbb92 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Feb 2026 12:56:20 +0000
Subject: [PATCH 010/101] correct logging constant

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 2ccebe1cf2e698..2a21df564e51e5 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -316,7 +316,7 @@ static int vmufat_allocate_inode(umode_t imode,
 	/* Executable files should be at the start of the volume */
 	if (imode & EXEC) {
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
-			printk(KERN_WARN "VMUFAT: Warning cannot write excutable "
+			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
 				"file to block 0. Volume block 0 already allocated.\n");
 		}
 		else {

From 8cdb259104d306c723fff6421edc859106c71468 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Feb 2026 12:58:02 +0000
Subject: [PATCH 011/101] Remove bad bool

---
 fs/vmufat/inode.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 2a21df564e51e5..ed0346ba77dc11 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -223,7 +223,6 @@ static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 	long years, days;
 	unsigned char bcd_century, nl_day, bcd_month;
 	unsigned char u8year;
-	bool century22 = FALSE;
 	time64_t unix_date;
 
 	unix_date = in->i_mtime_sec;

From 2a7e1856c50fadfded4618995cdf14481ad6813e Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Feb 2026 19:06:50 +0000
Subject: [PATCH 012/101] fixing BCD date

---
 fs/vmufat/inode.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index ed0346ba77dc11..c19eaf15d7d474 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -279,14 +279,15 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 	if (rtc_read_time(rtc, &now))
 		vmufat_save_bcd_nortc(in, bh, index_to_dir);
 	else {
-		bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)(now.tm_year/100));
-		bh[index_to_dir + VMUFAT_DIR_YEAR] = bin2bcd((char)(now.tm_year % 100));
-		bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd((char)(now.tm_mon));
+		bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)((now.tm_year + 1900)/100));
+		bh[index_to_dir + VMUFAT_DIR_YEAR] =
+			bin2bcd((char)(now.tm_year % 100));
+		bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd((char)(now.tm_mon + 1));
 		bh[index_to_dir + VMUFAT_DIR_DAY] = bin2bcd((char)(now.tm_mday));
 		bh[index_to_dir + VMUFAT_DIR_HOUR] = bin2bcd((char)(now.tm_hour));
 		bh[index_to_dir + VMUFAT_DIR_MIN] = bin2bcd((char)(now.tm_min));
 		bh[index_to_dir + VMUFAT_DIR_SEC] = bin2bcd((char)(now.tm_sec));
-		bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)((now.tm_wday + 1))
+		bh[index_to_dir + VMUFAT_DIR_DOW] = bin2bcd((char)((now.tm_wday + 6))
 			% DAYS_PER_WEEK);
 	}
 }

From 1db7eac8492d53121f59c32629edb7178da558e2 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Feb 2026 19:48:44 +0000
Subject: [PATCH 013/101] better file name length handling

---
 fs/vmufat/inode.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index c19eaf15d7d474..ab6e821dcb8ac1 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -526,9 +526,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 			memcpy(saved_file->fname,
 				bh->b_data + pos + VMUFAT_NAME_OFFSET,
 				VMUFAT_NAMELEN);
-			filenamelen = strlen(saved_file->fname);
-			if (filenamelen > VMUFAT_NAMELEN)
-				filenamelen = VMUFAT_NAMELEN;
+			filenamelen = strnlen(saved_file->fname, VMUFAT_NAMELEN);
 			error = ctx->actor(ctx, saved_file->fname, filenamelen,
 				index++, saved_file->fblk, DT_REG);
 			if (error < 0)

From 9e9d858b283324f6800c4977572a8bc0b2be7d7c Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 16 Feb 2026 15:44:50 +0000
Subject: [PATCH 014/101] simplify looking for blocks in inode block chain

---
 fs/vmufat/inode.c | 56 +++++++++++++++++++----------------------------
 1 file changed, 22 insertions(+), 34 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index ab6e821dcb8ac1..4b5b22b0796cd3 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -116,42 +116,23 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 static int vmufat_find_free(struct super_block *sb)
 {
 	struct memcard *vmudetails;
-	int testblk, fatblk, ret;
+	int testblk, fatblk, ret = -1;
 	struct buffer_head *bh_fat;
 
 	vmudetails = sb->s_fs_info;
 
-	for (fatblk = vmudetails->fat_bnum;
-		fatblk > vmudetails->fat_bnum - vmudetails->fat_len;
-		fatblk--) {
-		bh_fat = vmufat_sb_bread(sb, fatblk);
+	fatblk = vmudetails->fat_bnum;
+	for (int i = 0; i < vmudetails->fat_len; i++)
+	{
+		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {
 			ret = -EIO;
 			goto fail;
 		}
-
-		/* Handle 256 block VMUs like physical devices
-		 * and other VMUs more simply
-		 */
-		if (vmudetails->sb_bnum != VMU_BLK_SZ16) {
-			/* Cannot be physical VMU */
-			testblk = vmufat_get_freeblock(VMU_BLK_SZ16, 0, bh_fat);
-			put_bh(bh_fat);
-			if (testblk >= 0)
-				goto out_of_loop;
-		} else { /* Physical VMU or logical VMU with same size */
-			testblk = vmufat_get_freeblock(VMUFAT_START_ALLOC, 0,
-				bh_fat);
-			if (testblk >= 0) {
-				put_bh(bh_fat);
-				goto out_of_loop;
-			}
-			/* Only allocate to higher blocks if no space left */
-			testblk = vmufat_get_freeblock(VMU_BLK_SZ16,
-				VMUFAT_START_ALLOC + 1, bh_fat);
-			put_bh(bh_fat);
-			if (testblk > VMUFAT_START_ALLOC)
-				goto out_of_loop;
+		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ16, bh_fat);
+		put_bh(bh_fat);
+		if (testblk >= 0) {
+			goto out_of_loop;
 		}
 	}
 	printk(KERN_INFO "VMUFAT: volume is full\n");
@@ -159,8 +140,7 @@ static int vmufat_find_free(struct super_block *sb)
 	goto fail;
 
 out_of_loop:
-	ret = (fatblk - 1 - vmudetails->fat_bnum + vmudetails->fat_len)
-			* VMU_BLK_SZ16 + testblk;
+	ret = testblk;
 fail:
 	return ret;
 }
@@ -818,17 +798,25 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 	finblk = vblk->bno;
 
 	mutex_lock(&vmudetails->mutex);
-	/* Exec files have to be linear */
+	/* Exec files have to be linear on real VMUs */
+	/* But this is policy so we warn but don't fail */
 	if (inode->i_ino == 0) {
 		exeblk = vmufat_get_fat(sb, finblk + 1);
 		if (exeblk != VMUFAT_UNALLOCATED) {
 			mutex_unlock(&vmudetails->mutex);
 			printk(KERN_WARNING "VMUFAT: Cannot allocate linear "
 				"space needed for executible\n");
-			error = -ENOSPC;
-			goto out;
+			mutex_lock(&vmudetails->mutex);
+			nxtblk = vmufat_find_free(sb);
+			if (nxtblk < 0) {
+				mutex_unlock(&vmudetails->mutex);
+				error = nxtblk;
+				goto out;
+			}
+		}
+		else {
+			nxtblk = finblk + 1;
 		}
-		nxtblk = finblk + 1;
 	} else {
 		nxtblk = vmufat_find_free(sb);
 		if (nxtblk < 0) {

From b2355137beb19f4823eb0a1418e4763ab2df26b0 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 16 Feb 2026 18:18:40 +0000
Subject: [PATCH 015/101] further modification of cache code

---
 fs/vmufat/inode.c |  2 +-
 fs/vmufat/super.c | 17 ++++++-----------
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 4b5b22b0796cd3..718455ae1d1513 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -532,7 +532,7 @@ int vmufat_list_blocks(struct inode *in)
 	struct memcard *vmudetails;
 	int error = -EINVAL;
 	struct list_head *iter, *iter2;
-	struct vmufat_block_list *vbl, *nvbl;
+	struct vmufat_blo ck_list *vbl, *nvbl;
 	u16 fatdata;
 
 	vi = VMUFAT_I(in);
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index e7161dbd78953a..30edbb4362b777 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -469,22 +469,17 @@ static void init_once(void *foo)
 
 static int init_inodecache(void)
 {
-	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
-		sizeof(struct vmufat_inode), 0,
-		SLAB_RECLAIM_ACCOUNT, init_once);
-	if (!vmufat_inode_cachep) {
+	vmufat_blist_cachep = KMEM_CACHE(vmufat_block_list, 0);
+	if (!vmufat_blist_cachep) {
+		printk(KERN_EMERG "VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;
 	}
-	rcu_barrier();
-	vmufat_blist_cachep = kmem_cache_create("vmufat_blist_cache",
-		sizeof(struct vmufat_block_list), 0,
-		SLAB_RECLAIM_ACCOUNT, init_once);
-	if (!vmufat_blist_cachep) {
-		rcu_barrier();
+	vmufat_inode_cachep = KMEM_CACHE(vmufat_inode, 0);
+	if (!vmufat_inode_cachep) {
+		printk(KERN_EMERG "VMUFAT: Could not create inode cache.\n");
 		kmem_cache_destroy(vmufat_inode_cachep);
 		return -ENOMEM;
 	}
-	rcu_barrier();
 	return 0;
 }
 

From 51249fe630fa342b829cc49213f2e003ce77a068 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 17 Feb 2026 13:58:50 +0000
Subject: [PATCH 016/101] only iterate the list if it's not empty

---
 fs/vmufat/inode.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 718455ae1d1513..6d37633cef65b6 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -532,7 +532,7 @@ int vmufat_list_blocks(struct inode *in)
 	struct memcard *vmudetails;
 	int error = -EINVAL;
 	struct list_head *iter, *iter2;
-	struct vmufat_blo ck_list *vbl, *nvbl;
+	struct vmufat_block_list *vbl, *nvbl;
 	u16 fatdata;
 
 	vi = VMUFAT_I(in);
@@ -547,10 +547,12 @@ int vmufat_list_blocks(struct inode *in)
 		nextblock = 0;
 
 	/* Delete any previous list of blocks */
-	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
-		vbl = list_entry(iter, struct vmufat_block_list, b_list);
-		list_del(iter);
-		kmem_cache_free(vmufat_blist_cachep, vbl);
+	if (!list_empty(vi->blocks.b_list)) {
+		list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
+			vbl = list_entry(iter, struct vmufat_block_list, b_list);
+			list_del(iter);
+			kmem_cache_free(vmufat_blist_cachep, vbl);
+		}
 	}
 	vi->nblcks = 0;
 	do {

From fc2f0641210ce6d8bd726cda527a6aa40463023b Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 17 Feb 2026 17:03:45 +0000
Subject: [PATCH 017/101] revert unneeded change

---
 fs/vmufat/inode.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 6d37633cef65b6..4b5b22b0796cd3 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -547,12 +547,10 @@ int vmufat_list_blocks(struct inode *in)
 		nextblock = 0;
 
 	/* Delete any previous list of blocks */
-	if (!list_empty(vi->blocks.b_list)) {
-		list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
-			vbl = list_entry(iter, struct vmufat_block_list, b_list);
-			list_del(iter);
-			kmem_cache_free(vmufat_blist_cachep, vbl);
-		}
+	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
+		vbl = list_entry(iter, struct vmufat_block_list, b_list);
+		list_del(iter);
+		kmem_cache_free(vmufat_blist_cachep, vbl);
 	}
 	vi->nblcks = 0;
 	do {

From 212025636c7f9a0f337d8a8310025b5aff52e0d9 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 17 Feb 2026 22:34:12 +0000
Subject: [PATCH 018/101] skip over unfound entries, don't fail on them

---
 fs/vmufat/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 30edbb4362b777..cdc49e5cf42506 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -141,7 +141,7 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 				{
 					if (bh->b_data[j * VMU_DIR_RECORD_LEN]
 						== 0)
-						goto notfound;
+						continue;
 					if (le16_to_cpu(((u16 *) bh->b_data)
 					[j * VMU_DIR_RECORD_LEN16 +
 					VMUFAT_FIRSTBLOCK_OFFSET16]) == ino) {

From 2b676be3a7f233e72fc73a0ff9c34d8cdd12766c Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 11:57:31 +0000
Subject: [PATCH 019/101] simplifications

---
 fs/vmufat/super.c | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index cdc49e5cf42506..336290053c7985 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -128,25 +128,21 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 			inode->i_mode = S_IFREG | S_IRUGO | S_IWUSR;
 
 			/* Scan through the directory to find matching file */
-			for (i = vmudetails->dir_bnum;
-				i > vmudetails->dir_bnum - vmudetails->dir_len;
-				i--) {
+			for (i = 0; i < vmudetails->dir_len; i++) {
 				brelse(bh);
-				bh = vmufat_sb_bread(sb, i);
+				bh = vmufat_sb_bread(sb,
+					vmudetails->dir_bnum - i);
 				if (!bh) {
 					error = -EIO;
 					goto failed;
 				}
 				for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++)
 				{
-					if (bh->b_data[j * VMU_DIR_RECORD_LEN]
-						== 0)
-						continue;
-					if (le16_to_cpu(((u16 *) bh->b_data)
-					[j * VMU_DIR_RECORD_LEN16 +
-					VMUFAT_FIRSTBLOCK_OFFSET16]) == ino) {
-						found = 1;
-						goto found;
+					u16 ino_read = le16_to_cpu(((u16 *) bh->b_data)
+						[j * VMU_DIR_RECORD_LEN16 +
+						VMUFAT_FIRSTBLOCK_OFFSET16]);
+					if (ino_read == ino)
+							goto found;
 					}
 				}
 			}

From 64b469942e97ae637458bbea07b1058576e9e1a1 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 12:08:51 +0000
Subject: [PATCH 020/101] add missing bracket

---
 fs/vmufat/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 336290053c7985..7f107b53d027bf 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -141,7 +141,7 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 					u16 ino_read = le16_to_cpu(((u16 *) bh->b_data)
 						[j * VMU_DIR_RECORD_LEN16 +
 						VMUFAT_FIRSTBLOCK_OFFSET16]);
-					if (ino_read == ino)
+					if (ino_read == ino) {
 							goto found;
 					}
 				}

From 46ed72744e60c72d195c1dc70fc41e539be5a18b Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 12:57:26 +0000
Subject: [PATCH 021/101] properly walk the buffer head

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 4b5b22b0796cd3..82c6f667a68fff 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -74,7 +74,7 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 			dent->d_name.len) == 0) {
 				ino = vmufat_get_inode(sb,
 					le16_to_cpu(((u16 *) bh->b_data)
-					[record_offset
+					[(record_offset / 2)
 					+ VMUFAT_FIRSTBLOCK_OFFSET16]));
 				if (IS_ERR(ino)) {
 					error = PTR_ERR(ino);

From b8f3e1b26d527e9a77eebaa42e1e2082a7c24c50 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 17:42:18 +0000
Subject: [PATCH 022/101] use approved helpers etc

---
 fs/vmufat/inode.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 82c6f667a68fff..661aebfa2b3e89 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -313,18 +313,15 @@ static int vmufat_allocate_inode(umode_t imode,
 static void vmufat_setup_inode(struct inode *in, umode_t imode,
 		struct super_block *sb)
 {
-	struct timespec64 current_time;
-	in->i_uid = current_fsuid();
-	in->i_gid = current_fsgid();
-	ktime_get_coarse_real_ts64(&current_time);
-	in->i_mtime_sec = in->i_atime_sec = in->i_ctime_sec = current_time.tv_sec;
+	simple_inode_init_ts(in);
 	in->i_mode = imode;
 	in->i_blocks = 1;
 	in->i_sb = sb;
-	insert_inode_hash(in);
 	in->i_op = &vmufat_inode_operations;
 	in->i_fop = &vmufat_file_operations;
 	in->i_mapping->a_ops = &vmufat_address_space_operations;
+	insert_inode_hash(in);
+	mark_inode_dirty(in);
 }
 
 static void vmu_handle_zeroblock(int recno, struct buffer_head *bh, int ino)
@@ -379,7 +376,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	mutex_unlock(&vmudetails->mutex);
 	if (error)
 		goto clean_inode;
-
+	inode_init_owner(&nop_mnt_idmap, in, dir);
 	vmufat_setup_inode(inode, imode, sb);
 
 	/* Write to the directory

From 2a366542624e6ed91d1dd2a341c3890cf5b07d34 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 18:00:19 +0000
Subject: [PATCH 023/101] fix bad call

---
 fs/vmufat/inode.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 661aebfa2b3e89..6ba7ca0f233e4e 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -314,7 +314,6 @@ static void vmufat_setup_inode(struct inode *in, umode_t imode,
 		struct super_block *sb)
 {
 	simple_inode_init_ts(in);
-	in->i_mode = imode;
 	in->i_blocks = 1;
 	in->i_sb = sb;
 	in->i_op = &vmufat_inode_operations;
@@ -376,7 +375,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	mutex_unlock(&vmudetails->mutex);
 	if (error)
 		goto clean_inode;
-	inode_init_owner(&nop_mnt_idmap, in, dir);
+	inode_init_owner(&nop_mnt_idmap, in, dir, imode);
 	vmufat_setup_inode(inode, imode, sb);
 
 	/* Write to the directory

From 84f201106ac470f3d985d26fec2d933165f9c85d Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 18:03:14 +0000
Subject: [PATCH 024/101] further tidy

---
 fs/vmufat/inode.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 6ba7ca0f233e4e..f39e05bf598c62 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -310,8 +310,7 @@ static int vmufat_allocate_inode(umode_t imode,
 	return error;
 }
 
-static void vmufat_setup_inode(struct inode *in, umode_t imode,
-		struct super_block *sb)
+static void vmufat_setup_inode(struct inode *in, struct super_block *sb)
 {
 	simple_inode_init_ts(in);
 	in->i_blocks = 1;
@@ -375,8 +374,8 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	mutex_unlock(&vmudetails->mutex);
 	if (error)
 		goto clean_inode;
-	inode_init_owner(&nop_mnt_idmap, in, dir, imode);
-	vmufat_setup_inode(inode, imode, sb);
+	inode_init_owner(&nop_mnt_idmap, inode, dir, imode);
+	vmufat_setup_inode(inode, sb);
 
 	/* Write to the directory
 	 * Now search for space for the directory entry */

From 4d18d9083d413fd4caa83e6712d5f5d83e9e2b14 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 18:35:37 +0000
Subject: [PATCH 025/101] mark as dirty in a diffent place

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index f39e05bf598c62..5f698629bfa7aa 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -319,7 +319,6 @@ static void vmufat_setup_inode(struct inode *in, struct super_block *sb)
 	in->i_fop = &vmufat_file_operations;
 	in->i_mapping->a_ops = &vmufat_address_space_operations;
 	insert_inode_hash(in);
-	mark_inode_dirty(in);
 }
 
 static void vmu_handle_zeroblock(int recno, struct buffer_head *bh, int ino)
@@ -425,6 +424,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	if (error)
 		goto clean_fat;
 	mutex_unlock(&vmudetails->mutex);
+	mark_inode_dirty(in);
 	d_instantiate(de, inode);
 	return error;
 

From f4d28a7a4a076c5517fc2b7e065cbcd026852049 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Feb 2026 19:14:14 +0000
Subject: [PATCH 026/101] correct variable name

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 5f698629bfa7aa..87c2165180aa44 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -424,7 +424,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	if (error)
 		goto clean_fat;
 	mutex_unlock(&vmudetails->mutex);
-	mark_inode_dirty(in);
+	mark_inode_dirty(inode);
 	d_instantiate(de, inode);
 	return error;
 

From d16abf70811fc78329050834be968382f48bf820 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Feb 2026 13:18:15 +0000
Subject: [PATCH 027/101] simplify code

---
 fs/vmufat/inode.c |  6 ++----
 fs/vmufat/super.c | 13 -------------
 2 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 87c2165180aa44..e6111d75945b70 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -347,7 +347,7 @@ static void vmu_write_name(int recno, struct buffer_head *bh, char *name,
 static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	struct dentry *de, umode_t imode, bool excl)
 {
-	int i, j, entry, found = 0, error = 0, freeblock;
+	int i, j, entry, error = 0, freeblock;
 	struct inode *inode;
 	struct super_block *sb;
 	struct memcard *vmudetails;
@@ -391,13 +391,11 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			entry = j * VMU_DIR_RECORD_LEN;
 			if (((bh->b_data)[entry]) == 0) {
-				found = 1;
 				goto dir_space_found;
 			}
 		}
 	}
-	if (found == 0)
-		goto clean_fat;
+	goto clean_fat;
 dir_space_found:
 	/* Have the directory entry
 	 * so now update it */
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 7f107b53d027bf..9c8686f3a443de 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -384,12 +384,6 @@ static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 	return i;
 }
 
-static int vmufat_set_fs_private(struct fs_context *fc)
-{
-	int err = 0;
-	return err;
-}
-
 static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 {
 	struct buffer_head *bh = NULL;
@@ -501,20 +495,13 @@ static int vmufat_get_tree(struct fs_context *fc)
 	return get_tree_bdev(fc, vmufat_fill_super);
 }
 
-static void vmufat_free_fc(struct fs_context *fc)
-{
-
-}
-
 static const struct fs_context_operations vmufat_fs_context_ops = {
 	.get_tree	= vmufat_get_tree,
-	.free		= vmufat_free_fc,
 };
 
 static int vmufat_init_fs_context(struct fs_context *fc)
 {
 	int err = 0;
-	err = vmufat_set_fs_private(fc);
 	fc->ops = &vmufat_fs_context_ops;
 	return err;
 }

From 78fc557e6a3b8846e0695126f1a831167035709d Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 11:42:36 +0000
Subject: [PATCH 028/101] Better list management hopefully

---
 fs/vmufat/inode.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e6111d75945b70..45d42f4e5a47f5 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -540,10 +540,9 @@ int vmufat_list_blocks(struct inode *in)
 		nextblock = 0;
 
 	/* Delete any previous list of blocks */
-	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
-		vbl = list_entry(iter, struct vmufat_block_list, b_list);
-		list_del(iter);
-		kmem_cache_free(vmufat_blist_cachep, vbl);
+	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
+		list_del(iter->b_list);
+		kmem_cache_free(vmufat_blist_cachep, iter);
 	}
 	vi->nblcks = 0;
 	do {

From 0a9425cb4ed4082cd0a043ebca7d7332a05389e0 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 11:50:51 +0000
Subject: [PATCH 029/101] define objects properly for list traversal

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 45d42f4e5a47f5..d84ff605be1cc9 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -524,7 +524,7 @@ int vmufat_list_blocks(struct inode *in)
 	long ino;
 	struct memcard *vmudetails;
 	int error = -EINVAL;
-	struct list_head *iter, *iter2;
+	struct vmufat_block_list *iter, *iter2;
 	struct vmufat_block_list *vbl, *nvbl;
 	u16 fatdata;
 

From b45449e13870dc99e563e6c7a790a8779a0aef33 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 12:41:10 +0000
Subject: [PATCH 030/101] rework linked list code

---
 fs/vmufat/inode.c  | 11 +++++------
 fs/vmufat/super.c  |  9 +++++----
 fs/vmufat/vmufat.h |  4 ++--
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index d84ff605be1cc9..d7cd684c600c0d 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -524,7 +524,7 @@ int vmufat_list_blocks(struct inode *in)
 	long ino;
 	struct memcard *vmudetails;
 	int error = -EINVAL;
-	struct vmufat_block_list *iter, *iter2;
+	struct vmufat_block *iter, *iter2;
 	struct vmufat_block_list *vbl, *nvbl;
 	u16 fatdata;
 
@@ -554,7 +554,7 @@ int vmufat_list_blocks(struct inode *in)
 		}
 		INIT_LIST_HEAD(&vbl->b_list);
 		vbl->bno = nextblock;
-		list_add_tail(&vbl->b_list, &vi->blocks.b_list);
+		list_add_tail(&vbl->b_list, &vi->blocks);
 		vi->nblcks++;
 
 		/* Find next block in the FAT - if there is one */
@@ -573,10 +573,9 @@ int vmufat_list_blocks(struct inode *in)
 	return error;
 
 unwind_out:
-	list_for_each_entry_safe(vbl, nvbl, &vi->blocks.b_list, b_list) {
-		list_del_init(&vbl->b_list);
-		kmem_cache_free(vmufat_blist_cachep, vbl);
-	}
+	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
+		list_del(iter->b_list);
+		kmem_cache_free(vmufat_blist_cachep, iter);
 	return error;
 }
 
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 9c8686f3a443de..2d6f445b32037b 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -64,7 +64,7 @@ static struct inode *vmufat_alloc_inode(struct super_block *sb)
 	if (!vi)
 		return NULL;
 
-	INIT_LIST_HEAD(&vi->blocks.b_list);
+	INIT_LIST_HEAD(&vi->blocks);
 	return &vi->vfs_inode;
 }
 
@@ -72,14 +72,15 @@ static void vmufat_destroy_inode(struct inode *in)
 {
 	struct vmufat_inode *vi;
 	struct vmufat_block_list *vb;
-	struct list_head *iter, *iter2;
+	struct vmufat_block *iter, *iter2;
 	vi = VMUFAT_I(in);
 	if (!vi)
 		return;
 
-	list_for_each_safe(iter, iter2, &vi->blocks.b_list) {
+	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
 		vb = list_entry(iter, struct vmufat_block_list, b_list);
-		list_del(iter);
+		list_del(iter->b_list);
+		kmem_cache_free(vmufat_blist_cachep, iter)
 	}
 	kmem_cache_free(vmufat_inode_cachep, vi);
 }
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 9204dc6ed938e0..3dc4f16a4fb72c 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -88,13 +88,13 @@ struct memcard {
 	struct mutex mutex;
 };
 
-struct vmufat_block_list {
+struct vmufat_block {
 	struct list_head b_list;
 	int bno;
 };
 
 struct vmufat_inode {
-	struct vmufat_block_list blocks;
+	struct list_head blocks;
 	unsigned int nblcks;
 	struct inode vfs_inode;
 };

From ab67f570e042baaea8d776fc9e2c21a72271a11f Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 12:49:30 +0000
Subject: [PATCH 031/101] more linked list refactoring

---
 fs/vmufat/inode.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index d7cd684c600c0d..af0b62b1dd6d3a 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -760,11 +760,11 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	if (iblock < vin->nblcks) {
 		/* block is already here so read it into the buffer head */
-		list_for_each(iter, &vlist->b_list) {
+		list_for_each(iter, &vlist->blocks) {
 			if (cntdwn-- == 0)
 				break;
 		}
-		vblk = list_entry(iter, struct vmufat_block_list, b_list);
+		vblk = list_entry(iter, struct vmufat_block, b_list);
 		clear_buffer_new(bh_result);
 		error = 0;
 		phys = vblk->bno;
@@ -781,11 +781,11 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	/* if looking for a block that is not current - allocate it */
 	cural = vin->nblcks;
-	list_for_each(iter, &vlist->b_list) {
+	list_for_each(iter, &vlist->blocks) {
 		if (cural-- == 1)
 			break;
 	}
-	vblk = list_entry(iter, struct vmufat_block_list, b_list);
+	vblk = list_entry(iter, struct vmufat_block, b_list);
 	finblk = vblk->bno;
 
 	mutex_lock(&vmudetails->mutex);

From b14bd26884fc263f02e8e7c9a194bbbb8ddc449a Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 12:52:59 +0000
Subject: [PATCH 032/101] even more linked list refactoring

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index af0b62b1dd6d3a..4201556a051d9b 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -760,7 +760,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	if (iblock < vin->nblcks) {
 		/* block is already here so read it into the buffer head */
-		list_for_each(iter, &vlist->blocks) {
+		list_for_each(iter, &vin->blocks) {
 			if (cntdwn-- == 0)
 				break;
 		}
@@ -781,7 +781,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	/* if looking for a block that is not current - allocate it */
 	cural = vin->nblcks;
-	list_for_each(iter, &vlist->blocks) {
+	list_for_each(iter, &vin->blocks) {
 		if (cural-- == 1)
 			break;
 	}

From 7e48e50e4e4c3b183ce7bef767d9b78fd53284fd Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 12:55:09 +0000
Subject: [PATCH 033/101] still more linked list refactoring

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 4201556a051d9b..e228f9af8bf1c1 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -760,7 +760,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	if (iblock < vin->nblcks) {
 		/* block is already here so read it into the buffer head */
-		list_for_each(iter, &vin->blocks) {
+		list_for_each(iter, &vlist) {
 			if (cntdwn-- == 0)
 				break;
 		}
@@ -781,7 +781,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	/* if looking for a block that is not current - allocate it */
 	cural = vin->nblcks;
-	list_for_each(iter, &vin->blocks) {
+	list_for_each(iter, &vlist) {
 		if (cural-- == 1)
 			break;
 	}

From 6d821bd4a9a7b72ed6833cd6c323434335f1cfa5 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 12:58:07 +0000
Subject: [PATCH 034/101] still struggling with linked list code

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e228f9af8bf1c1..cadb50ff3179fb 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -760,7 +760,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	if (iblock < vin->nblcks) {
 		/* block is already here so read it into the buffer head */
-		list_for_each(iter, &vlist) {
+		list_for_each(iter, vlist) {
 			if (cntdwn-- == 0)
 				break;
 		}
@@ -781,7 +781,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	/* if looking for a block that is not current - allocate it */
 	cural = vin->nblcks;
-	list_for_each(iter, &vlist) {
+	list_for_each(iter, vlist) {
 		if (cural-- == 1)
 			break;
 	}

From 7b47f10cb59880f8549cbc2d404c382e39494e5b Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:00:31 +0000
Subject: [PATCH 035/101] more struggling with linked list code

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index cadb50ff3179fb..0df72fffe9ef0f 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -741,7 +741,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 	struct buffer_head *bh_result, int create)
 {
 	struct vmufat_inode *vin;
-	struct vmufat_block_list *vlist, *vblk;
+	struct vmufat_block *vlist, *vblk;
 	struct super_block *sb;
 	struct memcard *vmudetails;
 	int cural;

From b9b01878a2cfe84280843bead3cb039f742a148f Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:09:22 +0000
Subject: [PATCH 036/101] more and more linked list stuff

---
 fs/vmufat/inode.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 0df72fffe9ef0f..6089cd2060c2b8 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -525,7 +525,7 @@ int vmufat_list_blocks(struct inode *in)
 	struct memcard *vmudetails;
 	int error = -EINVAL;
 	struct vmufat_block *iter, *iter2;
-	struct vmufat_block_list *vbl, *nvbl;
+	struct vmufat_block *vbl, *nvbl;
 	u16 fatdata;
 
 	vi = VMUFAT_I(in);
@@ -541,7 +541,7 @@ int vmufat_list_blocks(struct inode *in)
 
 	/* Delete any previous list of blocks */
 	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
-		list_del(iter->b_list);
+		list_del(&iter->b_list);
 		kmem_cache_free(vmufat_blist_cachep, iter);
 	}
 	vi->nblcks = 0;
@@ -574,7 +574,7 @@ int vmufat_list_blocks(struct inode *in)
 
 unwind_out:
 	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
-		list_del(iter->b_list);
+		list_del(&iter->b_list);
 		kmem_cache_free(vmufat_blist_cachep, iter);
 	return error;
 }

From 65873d030ea0306524dce7b050d8b9786c165383 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:15:36 +0000
Subject: [PATCH 037/101] restore missing bracket

---
 fs/vmufat/inode.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 6089cd2060c2b8..94aeb80197ba39 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -576,6 +576,7 @@ int vmufat_list_blocks(struct inode *in)
 	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
 		list_del(&iter->b_list);
 		kmem_cache_free(vmufat_blist_cachep, iter);
+	}
 	return error;
 }
 

From 25d549ed8a3a5295d599921d513f63c7046dde54 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:21:23 +0000
Subject: [PATCH 038/101] use list_head

---
 fs/vmufat/inode.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 94aeb80197ba39..945ba9f4330931 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -742,7 +742,8 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 	struct buffer_head *bh_result, int create)
 {
 	struct vmufat_inode *vin;
-	struct vmufat_block *vlist, *vblk;
+	struct list_head *vlist;
+	struct vmufat_block *vblk;
 	struct super_block *sb;
 	struct memcard *vmudetails;
 	int cural;

From 5624fd5c034d30a20c090c6ca7667d2ecf59299b Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:25:06 +0000
Subject: [PATCH 039/101] fix issues in super.c

---
 fs/vmufat/super.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 2d6f445b32037b..40ca396a3ca8ab 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -80,7 +80,7 @@ static void vmufat_destroy_inode(struct inode *in)
 	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
 		vb = list_entry(iter, struct vmufat_block_list, b_list);
 		list_del(iter->b_list);
-		kmem_cache_free(vmufat_blist_cachep, iter)
+		kmem_cache_free(vmufat_blist_cachep, iter);
 	}
 	kmem_cache_free(vmufat_inode_cachep, vi);
 }
@@ -88,7 +88,7 @@ static void vmufat_destroy_inode(struct inode *in)
 struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 {
 	struct buffer_head *bh = NULL;
-	int error = 0, i, j, found = 0;
+	int error = 0, i, j;
 	int offsetindir;
 	struct inode *inode;
 	struct memcard *vmudetails;
@@ -460,7 +460,7 @@ static void init_once(void *foo)
 
 static int init_inodecache(void)
 {
-	vmufat_blist_cachep = KMEM_CACHE(vmufat_block_list, 0);
+	vmufat_blist_cachep = KMEM_CACHE(vmufat_block, 0);
 	if (!vmufat_blist_cachep) {
 		printk(KERN_EMERG "VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;

From fe22234a25bc687285104f164cfda267526442cd Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 13:30:34 +0000
Subject: [PATCH 040/101] fix another issue in super.c

---
 fs/vmufat/super.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 40ca396a3ca8ab..0b36fa370cab0e 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -71,15 +71,13 @@ static struct inode *vmufat_alloc_inode(struct super_block *sb)
 static void vmufat_destroy_inode(struct inode *in)
 {
 	struct vmufat_inode *vi;
-	struct vmufat_block_list *vb;
 	struct vmufat_block *iter, *iter2;
 	vi = VMUFAT_I(in);
 	if (!vi)
 		return;
 
 	list_for_each_entry_safe(iter, iter2, &vi->blocks, b_list) {
-		vb = list_entry(iter, struct vmufat_block_list, b_list);
-		list_del(iter->b_list);
+		list_del(&iter->b_list);
 		kmem_cache_free(vmufat_blist_cachep, iter);
 	}
 	kmem_cache_free(vmufat_inode_cachep, vi);

From 073ae17c3fca3714a945218d42a90c63ea7f504b Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Feb 2026 23:30:42 +0000
Subject: [PATCH 041/101] test change in attempt to track down bug

---
 fs/vmufat/inode.c | 14 +++++++-------
 fs/vmufat/super.c |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 945ba9f4330931..f9631f223e02b2 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -862,7 +862,7 @@ const struct address_space_operations
 	.read_folio =	vmufat_read_folio,
 	.writepages =	vmufat_writepages,
 	.write_begin =	vmufat_write_begin,
-	.write_end =	generic_write_end,
+//	.write_end =	generic_write_end,
 };
 
 const struct inode_operations vmufat_inode_operations = {
@@ -873,14 +873,14 @@ const struct inode_operations vmufat_inode_operations = {
 
 const struct file_operations vmufat_file_dir_operations = {
 	.owner =	THIS_MODULE,
-	.read =		generic_read_dir,
+//	.read =		generic_read_dir,
 	.iterate_shared =	vmufat_readdir,
-	.fsync =	generic_file_fsync,
+//	.fsync =	generic_file_fsync,
 };
 
 const struct file_operations vmufat_file_operations = {
-	.llseek =	generic_file_llseek,
-	.read_iter =	generic_file_read_iter,
-	.write_iter =	generic_file_write_iter,
-	.fsync =	generic_file_fsync,
+//	.llseek =	generic_file_llseek,
+//	.read_iter =	generic_file_read_iter,
+//	.write_iter =	generic_file_write_iter,
+//	.fsync =	generic_file_fsync,
 };
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 0b36fa370cab0e..93cc18a2a8ba44 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -508,7 +508,7 @@ static int vmufat_init_fs_context(struct fs_context *fc)
 static struct file_system_type vmufat_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "vmufat",
-	.kill_sb	= kill_block_super,
+	//.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
 	.init_fs_context = vmufat_init_fs_context,
 };

From f0dae2b317942d7d6611d1ceaf36dea30eb72785 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Feb 2026 18:04:10 +0000
Subject: [PATCH 042/101] revert last changes, change cache creation code
 instead

---
 fs/vmufat/inode.c | 12 ++++++------
 fs/vmufat/super.c |  8 +++++---
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index f9631f223e02b2..eb3c8458aba9a0 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -873,14 +873,14 @@ const struct inode_operations vmufat_inode_operations = {
 
 const struct file_operations vmufat_file_dir_operations = {
 	.owner =	THIS_MODULE,
-//	.read =		generic_read_dir,
+	.read =		generic_read_dir,
 	.iterate_shared =	vmufat_readdir,
-//	.fsync =	generic_file_fsync,
+	.fsync =	generic_file_fsync,
 };
 
 const struct file_operations vmufat_file_operations = {
-//	.llseek =	generic_file_llseek,
-//	.read_iter =	generic_file_read_iter,
-//	.write_iter =	generic_file_write_iter,
-//	.fsync =	generic_file_fsync,
+	.llseek =	generic_file_llseek,
+	.read_iter =	generic_file_read_iter,
+	.write_iter =	generic_file_write_iter,
+	.fsync =	generic_file_fsync,
 };
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 93cc18a2a8ba44..8438550eba44c9 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -458,12 +458,14 @@ static void init_once(void *foo)
 
 static int init_inodecache(void)
 {
-	vmufat_blist_cachep = KMEM_CACHE(vmufat_block, 0);
+	vmufat_blist_cachep = kmem_cache_create("vmufat_block_cache".
+		sizeof(struct vmufat_block), 0, SLAB_RECLAIM_ACCOUNT, 0);
 	if (!vmufat_blist_cachep) {
 		printk(KERN_EMERG "VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;
 	}
-	vmufat_inode_cachep = KMEM_CACHE(vmufat_inode, 0);
+	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
+		sizeof(vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT, init_once);
 	if (!vmufat_inode_cachep) {
 		printk(KERN_EMERG "VMUFAT: Could not create inode cache.\n");
 		kmem_cache_destroy(vmufat_inode_cachep);
@@ -508,7 +510,7 @@ static int vmufat_init_fs_context(struct fs_context *fc)
 static struct file_system_type vmufat_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "vmufat",
-	//.kill_sb	= kill_block_super,
+	.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
 	.init_fs_context = vmufat_init_fs_context,
 };

From 5d9bcdcdb726e3cd78562c9077676dd7c073c729 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Feb 2026 18:11:52 +0000
Subject: [PATCH 043/101] fix typos etc

---
 fs/vmufat/super.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 8438550eba44c9..d707adea594e68 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -458,14 +458,14 @@ static void init_once(void *foo)
 
 static int init_inodecache(void)
 {
-	vmufat_blist_cachep = kmem_cache_create("vmufat_block_cache".
+	vmufat_blist_cachep = kmem_cache_create("vmufat_block_cache",
 		sizeof(struct vmufat_block), 0, SLAB_RECLAIM_ACCOUNT, 0);
 	if (!vmufat_blist_cachep) {
 		printk(KERN_EMERG "VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;
 	}
 	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
-		sizeof(vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT, init_once);
+		sizeof(struct vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT, init_once);
 	if (!vmufat_inode_cachep) {
 		printk(KERN_EMERG "VMUFAT: Could not create inode cache.\n");
 		kmem_cache_destroy(vmufat_inode_cachep);

From 9510fbe84d7edffddccf0a9f4367c0d8e28ec085 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Feb 2026 18:52:35 +0000
Subject: [PATCH 044/101] comment generic code back in

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index eb3c8458aba9a0..945ba9f4330931 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -862,7 +862,7 @@ const struct address_space_operations
 	.read_folio =	vmufat_read_folio,
 	.writepages =	vmufat_writepages,
 	.write_begin =	vmufat_write_begin,
-//	.write_end =	generic_write_end,
+	.write_end =	generic_write_end,
 };
 
 const struct inode_operations vmufat_inode_operations = {

From 0d6a1a39da4fe9131b3237c6b7692c7f9e5e11b4 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Feb 2026 21:01:15 +0000
Subject: [PATCH 045/101] fix typo, search for free blocks properly

---
 fs/vmufat/inode.c | 2 +-
 fs/vmufat/super.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 945ba9f4330931..bb792f6389b28b 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -100,7 +100,7 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 	int i, ret = -1;
 	__le16 fatdata;
 
-	for (i = start; i >= end; i--) {
+	for (i = start; i < end; i++) {
 		fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
 		if (fatdata == VMUFAT_UNALLOCATED) {
 			ret = i;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index d707adea594e68..097d72f5b41684 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -409,7 +409,7 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 	test_sz = vmufat_get_size(sb, &bh);
 	if (test_sz < VMUFAT_MIN_BLK) {
 		printk(KERN_ERR "VMUFAT: attempted to mount corrupted vmufat "
-			"or non-vmufat violume as vmufat.\n");
+			"or non-vmufat volume as vmufat.\n");
 		ret = test_sz;
 		goto out;
 	}

From c21c4e0c5849b331f18c67597f411129f21a176e Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 24 Feb 2026 19:22:24 +0000
Subject: [PATCH 046/101] remove unused code etc

---
 fs/vmufat/inode.c | 3 +--
 fs/vmufat/super.c | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index bb792f6389b28b..7c4062c9daeb79 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -524,8 +524,7 @@ int vmufat_list_blocks(struct inode *in)
 	long ino;
 	struct memcard *vmudetails;
 	int error = -EINVAL;
-	struct vmufat_block *iter, *iter2;
-	struct vmufat_block *vbl, *nvbl;
+	struct vmufat_block *iter, *iter2, *vbl;
 	u16 fatdata;
 
 	vi = VMUFAT_I(in);
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 097d72f5b41684..d3347d5c66a814 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -145,7 +145,6 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 					}
 				}
 			}
-notfound:
 			error = -ENOENT;
 			goto failed;
 found:

From b3935d73fa8c8bb7bf8e28da517446ed050343af Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 28 Feb 2026 13:51:13 +0000
Subject: [PATCH 047/101] Further tidy plus avoid inode 0 issue

---
 fs/vmufat/inode.c |  5 ++++-
 fs/vmufat/super.c | 14 +++++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 7c4062c9daeb79..cb53f645a43871 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -305,8 +305,11 @@ static int vmufat_allocate_inode(umode_t imode,
 		}
 	}
 	error = vmufat_find_free(sb);
-	if (error >= 0)
+	if (error == 0) {
+		in->i_ino = VMUFAT_ZEROBLOCK;
+	} else if (error > 0) {
 		in->i_ino = error;
+	}
 	return error;
 }
 
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index d3347d5c66a814..74c0a65b480512 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -226,12 +226,12 @@ static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
 
 	sb = dentry->d_sb;
 	error = vmufat_count_freeblocks(sb, kstatbuf);
-	if (error)
-		goto out;
-	kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
-	kstatbuf->f_bsize = sb->s_blocksize;
-	kstatbuf->f_namelen = VMUFAT_NAMELEN;
-out:
+	if (!error)
+	{
+		kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
+		kstatbuf->f_bsize = sb->s_blocksize;
+		kstatbuf->f_namelen = VMUFAT_NAMELEN;
+	}
 	return error;
 }
 
@@ -390,7 +390,7 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 	struct inode *root_i;
 	int ret = 0;
 
-	vmudata = kmalloc(sizeof(struct memcard), GFP_KERNEL);
+	vmudata = kzalloc(sizeof(struct memcard), GFP_KERNEL);
 	if (!vmudata) {
 		ret = -ENOMEM;
 		goto freevmudata_out;

From b49ae137683e4515cb0fe429cd3fffc5824b78b5 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 8 Mar 2026 13:07:57 +0000
Subject: [PATCH 048/101] Collect more stats

---
 fs/vmufat/inode.c |  5 ++--
 fs/vmufat/super.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index cb53f645a43871..1bd4344f72f9fe 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -70,8 +70,8 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 			if (bh->b_data[record_offset] == 0)
 				goto insert_negative;
 			if (memcmp(dent->d_name.name,
-			bh->b_data + record_offset + VMUFAT_NAME_OFFSET,
-			dent->d_name.len) == 0) {
+				bh->b_data + record_offset + VMUFAT_NAME_OFFSET,
+				dent->d_name.len) == 0) {
 				ino = vmufat_get_inode(sb,
 					le16_to_cpu(((u16 *) bh->b_data)
 					[(record_offset / 2)
@@ -197,7 +197,6 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 	return error;
 }
 
-
 static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 {
 	long years, days;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 74c0a65b480512..91740b87390d48 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -219,6 +219,76 @@ static int vmufat_count_freeblocks(struct super_block *sb,
 	return error;
 }
 
+static int vmufat_count_files(struct super_block *sb)
+{
+	int error = -1;
+	int files_found = 0;
+	struct buffer_head *bh = NULL;
+	struct memcard *vmudetails;
+	// get directory
+	if (!sb) {
+		return error;
+	}
+	vmudetails = sb->s_fs_info;
+	if (!vmudetails) {
+		return error;
+	}
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			error = -EIO;
+			return error;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			int record_offset = j * VMU_DIR_RECORD_LEN;
+			if (bh->b_data[record_offset] != 0) {
+				files_found++;
+			}
+		}
+	}
+	return files_found;
+}
+
+
+static int vmufat_count_file_space(struct super_block *sb)
+{
+	int error = -1;
+	int files_available = 0;
+	int free_blocks;
+	struct buffer_head *bh = NULL;
+	struct memcard *vmudetails;
+	// get directory
+	if (!sb) {
+		return error;
+	}
+	vmudetails = sb->s_fs_info;
+	if (!vmudetails) {
+		return error;
+	}
+	free_blocks = vmufat_count_freeblocks();
+	if (free_blocks <= 0) {
+		return free_blocks;
+	}
+	for (i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			error = -EIO;
+			return error;
+		}
+		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+			int record_offset = j * VMU_DIR_RECORD_LEN;
+			if (bh->b_data[record_offset] == 0) {
+				files_available++;
+			}
+		}
+	}
+	return files_available;
+}
+
 static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
 {
 	int error;
@@ -231,6 +301,11 @@ static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
 		kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
 		kstatbuf->f_bsize = sb->s_blocksize;
 		kstatbuf->f_namelen = VMUFAT_NAMELEN;
+		kstatbuf->f_files = vmufat_count_files(sb);
+		kstatbuf->f_ffree = vmufat_count_file_space(sb);
+		if (kstatbuf->f_ffree > kstatbuf->f_bfree) {
+			kstatbuf->f_ffree = kstatbuf->f_bfree;
+		}
 	}
 	return error;
 }

From f4ab7ba5993e794d20e726d78ac0948fbd425fef Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 8 Mar 2026 19:46:49 +0000
Subject: [PATCH 049/101] fix loops etc

---
 fs/vmufat/super.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 91740b87390d48..87260ffcab8752 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -233,7 +233,7 @@ static int vmufat_count_files(struct super_block *sb)
 	if (!vmudetails) {
 		return error;
 	}
-	for (i = vmudetails->dir_bnum;
+	for (int i = vmudetails->dir_bnum;
 		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
@@ -241,7 +241,7 @@ static int vmufat_count_files(struct super_block *sb)
 			error = -EIO;
 			return error;
 		}
-		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+		for (int j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			int record_offset = j * VMU_DIR_RECORD_LEN;
 			if (bh->b_data[record_offset] != 0) {
 				files_found++;
@@ -267,11 +267,7 @@ static int vmufat_count_file_space(struct super_block *sb)
 	if (!vmudetails) {
 		return error;
 	}
-	free_blocks = vmufat_count_freeblocks();
-	if (free_blocks <= 0) {
-		return free_blocks;
-	}
-	for (i = vmudetails->dir_bnum;
+	for (int i = vmudetails->dir_bnum;
 		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
@@ -279,7 +275,7 @@ static int vmufat_count_file_space(struct super_block *sb)
 			error = -EIO;
 			return error;
 		}
-		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
+		for (int j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			int record_offset = j * VMU_DIR_RECORD_LEN;
 			if (bh->b_data[record_offset] == 0) {
 				files_available++;

From bc0e47310e30793ba18ee916e7faef5067c9ef12 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 9 Mar 2026 11:47:50 +0000
Subject: [PATCH 050/101] remove unneeded variable

---
 fs/vmufat/super.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 87260ffcab8752..5055beeeb6807d 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -256,7 +256,6 @@ static int vmufat_count_file_space(struct super_block *sb)
 {
 	int error = -1;
 	int files_available = 0;
-	int free_blocks;
 	struct buffer_head *bh = NULL;
 	struct memcard *vmudetails;
 	// get directory

From a7ad63a91abd78808f1481e6e7bfd4e2aa28b099 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 10 Mar 2026 18:45:08 +0000
Subject: [PATCH 051/101] add a getattr function

---
 fs/vmufat/inode.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 1bd4344f72f9fe..8a8f8efc6765f5 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -858,6 +858,15 @@ static int vmufat_read_folio(struct file *file, struct folio *folio)
 	return block_read_full_folio(folio, vmufat_get_block);
 }
 
+static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
+	struct kstat *stat, u32 request_mask, unsigned int query_flags)
+{
+	struct inode *inode = d_inode(path->dentry);
+	struct vmufat_inode = VMUFAT_I(inode);
+	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
+	return 0;
+}
+
 const struct address_space_operations
 		vmufat_address_space_operations = {
 	.read_folio =	vmufat_read_folio,
@@ -870,6 +879,7 @@ const struct inode_operations vmufat_inode_operations = {
 	.lookup =	vmufat_inode_lookup,
 	.create =	vmufat_inode_create,
 	.unlink =	vmufat_unlink,
+	.getattr =	vmufat_getattr,
 };
 
 const struct file_operations vmufat_file_dir_operations = {

From ae8111de0e1e98b9e3c8efa22f4cc773ddef7576 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 10 Mar 2026 18:56:58 +0000
Subject: [PATCH 052/101] add missing variable name

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 8a8f8efc6765f5..5b02d483df0e1e 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -862,7 +862,7 @@ static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
 	struct kstat *stat, u32 request_mask, unsigned int query_flags)
 {
 	struct inode *inode = d_inode(path->dentry);
-	struct vmufat_inode = VMUFAT_I(inode);
+	struct vmufat_inode *vnode = VMUFAT_I(inode);
 	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
 	return 0;
 }

From d8a7563c75503dc4956f958e4bd20b3e84f0102f Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 11 Mar 2026 15:37:16 +0000
Subject: [PATCH 053/101] is incrementing pos the answer?

---
 fs/vmufat/inode.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 5b02d483df0e1e..b17effce5793c5 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -459,11 +459,13 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 	switch ((unsigned int) ctx->pos) {
 	case 0:
 		error = ctx->actor(ctx, ".", 1, index++, inode->i_ino, DT_DIR);
+		ctx->pos++;
 		if (error < 0)
 			goto out;
 	case 1:
 		error = ctx->actor(ctx, "..", 2, index++,
 			    dentry->d_parent->d_inode->i_ino, DT_DIR);
+		ctx->pos++;
 		if (error < 0)
 			goto out;
 	default:
@@ -504,6 +506,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 			filenamelen = strnlen(saved_file->fname, VMUFAT_NAMELEN);
 			error = ctx->actor(ctx, saved_file->fname, filenamelen,
 				index++, saved_file->fblk, DT_REG);
+			ctx->pos++;
 			if (error < 0)
 				goto finish;
 		}

From a3c7c44298d9a013bdc3b174012d9bb9fae0543e Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 11 Mar 2026 22:39:33 +0000
Subject: [PATCH 054/101] Try generic seek for directory file ops

---
 fs/vmufat/inode.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index b17effce5793c5..5a732e3c6c7eea 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -890,6 +890,7 @@ const struct file_operations vmufat_file_dir_operations = {
 	.read =		generic_read_dir,
 	.iterate_shared =	vmufat_readdir,
 	.fsync =	generic_file_fsync,
+	.llseek =	generic_file_llseek,
 };
 
 const struct file_operations vmufat_file_operations = {

From fd4e4bbf25130e6a21d64c7029e2e60236ada378 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 12 Mar 2026 14:19:02 +0000
Subject: [PATCH 055/101] trying to fix directory size issue

---
 fs/vmufat/inode.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 5a732e3c6c7eea..708cb90cea6596 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -864,9 +864,19 @@ static int vmufat_read_folio(struct file *file, struct folio *folio)
 static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
 	struct kstat *stat, u32 request_mask, unsigned int query_flags)
 {
+	struct super_block *sb;
+	struct memcard vmudetails;
 	struct inode *inode = d_inode(path->dentry);
-	struct vmufat_inode *vnode = VMUFAT_I(inode);
 	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
+	/* correct for superblock to give directory size as one */
+	sb = inode->i_sb;
+	if (sb) {
+		vmudetails = sb->s_fs_info;
+		if (vmudetails && vmudetails->sb_bnum == inode->i_ino) {
+			stat->size = (vmudetails->fat_len + vmudetails->dir_len + 1) * 
+				VMU_BLK_SZ;
+		}
+	}
 	return 0;
 }
 

From a158724fc5c602dd831b7fc3bb9fd9eb94cb4a70 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 12 Mar 2026 14:35:49 +0000
Subject: [PATCH 056/101] use pointer type

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 708cb90cea6596..13334aebe72801 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -865,10 +865,10 @@ static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
 	struct kstat *stat, u32 request_mask, unsigned int query_flags)
 {
 	struct super_block *sb;
-	struct memcard vmudetails;
+	struct memcard *vmudetails;
 	struct inode *inode = d_inode(path->dentry);
 	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
-	/* correct for superblock to give directory size as one */
+	/* correct for superblock to give directory size as all metadata combined */
 	sb = inode->i_sb;
 	if (sb) {
 		vmudetails = sb->s_fs_info;

From 72631b0ffe1033c5db414b2db33b280d72dd8e9c Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Thu, 12 Mar 2026 20:44:18 +0000
Subject: [PATCH 057/101] fix link count for directory?

---
 fs/vmufat/inode.c | 2 ++
 fs/vmufat/super.c | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 13334aebe72801..87feaf55716bae 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -38,6 +38,7 @@ const struct file_operations vmufat_file_operations;
 const struct address_space_operations vmufat_address_space_operations;
 const struct file_operations vmufat_file_dir_operations;
 extern struct kmem_cache *vmufat_blist_cachep;
+extern int vmufat_count_files(struct super_block *sb);
 /* Linear day numbers of the respective 1sts in non-leap years. */
 int day_n[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
@@ -875,6 +876,7 @@ static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
 		if (vmudetails && vmudetails->sb_bnum == inode->i_ino) {
 			stat->size = (vmudetails->fat_len + vmudetails->dir_len + 1) * 
 				VMU_BLK_SZ;
+			stat->nlink = vmufat_count_files(sb) + 2;
 		}
 	}
 	return 0;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 5055beeeb6807d..09c700a2e51a69 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -219,7 +219,7 @@ static int vmufat_count_freeblocks(struct super_block *sb,
 	return error;
 }
 
-static int vmufat_count_files(struct super_block *sb)
+int vmufat_count_files(struct super_block *sb)
 {
 	int error = -1;
 	int files_found = 0;

From fc491fa1867ae1deb305390c835801f9f9b37eae Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 13 Mar 2026 11:20:49 +0000
Subject: [PATCH 058/101] general code tidy

---
 fs/vmufat/super.c | 50 +++++++++++++++++++++--------------------------
 1 file changed, 22 insertions(+), 28 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 09c700a2e51a69..4092f69cd67010 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -202,10 +202,10 @@ static void vmufat_put_super(struct super_block *sb)
 	kfree(sb->s_fs_info);
 }
 
-static int vmufat_count_freeblocks(struct super_block *sb,
+static void vmufat_count_freeblocks(struct super_block *sb,
 					struct kstatfs *kstatbuf)
 {
-	int i, free = 0, error = 0;
+	int i, free = 0;
 	struct memcard *vmudetails = sb->s_fs_info;
 
 	/* Look through the FAT */
@@ -216,7 +216,6 @@ static int vmufat_count_freeblocks(struct super_block *sb,
 	kstatbuf->f_bfree = free;
 	kstatbuf->f_bavail = free;
 	kstatbuf->f_blocks = vmudetails->numblocks;
-	return error;
 }
 
 int vmufat_count_files(struct super_block *sb)
@@ -286,23 +285,18 @@ static int vmufat_count_file_space(struct super_block *sb)
 
 static int vmufat_statfs(struct dentry *dentry, struct kstatfs *kstatbuf)
 {
-	int error;
 	struct super_block *sb;
-
 	sb = dentry->d_sb;
-	error = vmufat_count_freeblocks(sb, kstatbuf);
-	if (!error)
-	{
-		kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
-		kstatbuf->f_bsize = sb->s_blocksize;
-		kstatbuf->f_namelen = VMUFAT_NAMELEN;
-		kstatbuf->f_files = vmufat_count_files(sb);
-		kstatbuf->f_ffree = vmufat_count_file_space(sb);
-		if (kstatbuf->f_ffree > kstatbuf->f_bfree) {
-			kstatbuf->f_ffree = kstatbuf->f_bfree;
-		}
+	vmufat_count_freeblocks(sb, kstatbuf);
+	kstatbuf->f_type = VMUFAT_SUPER_MAGIC;
+	kstatbuf->f_bsize = sb->s_blocksize;
+	kstatbuf->f_namelen = VMUFAT_NAMELEN;
+	kstatbuf->f_files = vmufat_count_files(sb);
+	kstatbuf->f_ffree = vmufat_count_file_space(sb);
+	if (kstatbuf->f_ffree > kstatbuf->f_bfree) {
+		kstatbuf->f_ffree = kstatbuf->f_bfree;
 	}
-	return error;
+	return 0;
 }
 
 /* Remove inode from memory */
@@ -530,13 +524,13 @@ static int init_inodecache(void)
 	vmufat_blist_cachep = kmem_cache_create("vmufat_block_cache",
 		sizeof(struct vmufat_block), 0, SLAB_RECLAIM_ACCOUNT, 0);
 	if (!vmufat_blist_cachep) {
-		printk(KERN_EMERG "VMUFAT: Could not create block list cache.\n");
+		printk(KERN_CRIT "VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;
 	}
 	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
 		sizeof(struct vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT, init_once);
 	if (!vmufat_inode_cachep) {
-		printk(KERN_EMERG "VMUFAT: Could not create inode cache.\n");
+		printk(KERN_CRIT "VMUFAT: Could not create inode cache.\n");
 		kmem_cache_destroy(vmufat_inode_cachep);
 		return -ENOMEM;
 	}
@@ -557,7 +551,7 @@ static const struct super_operations vmufat_super_operations = {
 	.write_inode =		vmufat_write_inode,
 	.evict_inode =		vmufat_evict_inode,
 	.put_super =		vmufat_put_super,
-	.statfs =		vmufat_statfs,
+	.statfs =			vmufat_statfs,
 };
 
 static int vmufat_get_tree(struct fs_context *fc)
@@ -571,17 +565,16 @@ static const struct fs_context_operations vmufat_fs_context_ops = {
 
 static int vmufat_init_fs_context(struct fs_context *fc)
 {
-	int err = 0;
 	fc->ops = &vmufat_fs_context_ops;
-	return err;
+	return 0;
 }
 
 static struct file_system_type vmufat_fs_type = {
-	.owner		= THIS_MODULE,
-	.name		= "vmufat",
-	.kill_sb	= kill_block_super,
-	.fs_flags	= FS_REQUIRES_DEV,
-	.init_fs_context = vmufat_init_fs_context,
+	.owner =			THIS_MODULE,
+	.name = 			"vmufat",
+	.kill_sb = 			kill_block_super,
+	.fs_flags = 		FS_REQUIRES_DEV,
+	.init_fs_context =	vmufat_init_fs_context,
 };
 
 static int __init init_vmufat_fs(void)
@@ -590,7 +583,8 @@ static int __init init_vmufat_fs(void)
 	err = init_inodecache();
 	if (err)
 		return err;
-	return register_filesystem(&vmufat_fs_type);
+	else
+		register_filesystem(&vmufat_fs_type);
 }
 
 static void __exit exit_vmufat_fs(void)

From 03f53df7c8f16fda5aad4b10fb83cfddba212fb4 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 13 Mar 2026 11:41:41 +0000
Subject: [PATCH 059/101] further code tidying

---
 fs/vmufat/inode.c  |  4 ++--
 fs/vmufat/super.c  | 24 ++++++------------------
 fs/vmufat/vmufat.h |  2 ++
 3 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 87feaf55716bae..843925dea19077 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -38,7 +38,6 @@ const struct file_operations vmufat_file_operations;
 const struct address_space_operations vmufat_address_space_operations;
 const struct file_operations vmufat_file_dir_operations;
 extern struct kmem_cache *vmufat_blist_cachep;
-extern int vmufat_count_files(struct super_block *sb);
 /* Linear day numbers of the respective 1sts in non-leap years. */
 int day_n[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
@@ -296,6 +295,7 @@ static int vmufat_allocate_inode(umode_t imode,
 	/* Executable files should be at the start of the volume */
 	if (imode & EXEC) {
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
+			/* Warning for anyone concerned about playable games */
 			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
 				"file to block 0. Volume block 0 already allocated.\n");
 		}
@@ -436,7 +436,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	iput(inode);
 out:
 	if (error < 0)
-		printk(KERN_INFO "VMUFAT: inode creation fails with error"
+		printk(KERN_ERR "VMUFAT: inode creation fails with error"
 			" %i\n", error);
 	return error;
 }
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 4092f69cd67010..d2fadd4dacb9ff 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -94,7 +94,7 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 	struct timespec64 current_time;
 
 	inode = iget_locked(sb, ino);
-	if (!inode || !sb) {
+	if (!inode) {
 		error = -EIO;
 		goto reterror;
 	}
@@ -153,27 +153,23 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 			inode->i_ctime_sec = inode->i_mtime_sec =
 				vmufat_get_date(bh,
 					offsetindir + VMUFAT_FILE_DATEOFFSET);
-
 			/* Execute if a game, write if not copy protected */
 			inode->i_mode &= ~(S_IWUGO | S_IXUGO);
 			inode->i_mode |= S_IRUGO;
-
 			/* Mode - is it write protected? */
 			if ((((u8 *) bh->b_data)[0x01 + offsetindir] ==
-			     0x00) & ~(sb->s_flags & SB_RDONLY))
+			     0x00) & ~(sb->s_flags & SB_RDONLY)) {
 				inode->i_mode |= S_IWUSR;
+			}
 			/* Is file executible - ie a game */
 			if ((((u8 *) bh->b_data)[offsetindir] ==
-			     0xcc) & ~(sb->s_flags & SB_NOEXEC))
+			     0xcc) & ~(sb->s_flags & SB_NOEXEC)) {
 				inode->i_mode |= S_IXUSR;
-
-			inode->i_fop = &vmufat_file_operations;
-
+			}
 			inode->i_blocks =
 			    le16_to_cpu(((u16 *) bh->b_data)
 				[offsetindir / 2 + 0x0C]);
 			inode->i_size = inode->i_blocks * sb->s_blocksize;
-
 			inode->i_mapping->a_ops =
 				&vmufat_address_space_operations;
 			inode->i_op = &vmufat_inode_operations;
@@ -225,9 +221,6 @@ int vmufat_count_files(struct super_block *sb)
 	struct buffer_head *bh = NULL;
 	struct memcard *vmudetails;
 	// get directory
-	if (!sb) {
-		return error;
-	}
 	vmudetails = sb->s_fs_info;
 	if (!vmudetails) {
 		return error;
@@ -250,7 +243,6 @@ int vmufat_count_files(struct super_block *sb)
 	return files_found;
 }
 
-
 static int vmufat_count_file_space(struct super_block *sb)
 {
 	int error = -1;
@@ -368,7 +360,6 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 		error = -EIO;
 		goto out;
 	}
-
 	/* Have the directory entry
 	 * so now update it */
 	if (inode_num != 0)
@@ -378,12 +369,10 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 	if (bh->b_data[pos + 1] !=  0 && bh->b_data[pos + 1] != (char) 0xff)
 		bh->b_data[pos + 1] = 0;
 	((u16 *) bh->b_data)[pos16 + 1] = cpu_to_le16(inode_num);
-
 	/* BCD timestamp it */
 	ktime_get_coarse_real_ts64(&current_time);
 	in->i_mtime_sec = current_time.tv_sec;
 	vmufat_save_bcd(in, bh->b_data, pos);
-
 	((u16 *) bh->b_data)[pos16 + VMUFAT_SIZE_OFFSET16] =
 		cpu_to_le16(in->i_blocks);
 	if (inode_num != 0)
@@ -427,7 +416,6 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 {
 	int i;
-
 	for (i = VMUFAT_MIN_BLK; i <= VMUFAT_MAX_BLK; i = i * 2) {
 		brelse(*bh);
 		*bh = vmufat_sb_bread(sb, i - 1);
@@ -584,7 +572,7 @@ static int __init init_vmufat_fs(void)
 	if (err)
 		return err;
 	else
-		register_filesystem(&vmufat_fs_type);
+		return register_filesystem(&vmufat_fs_type);
 }
 
 static void __exit exit_vmufat_fs(void)
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 3dc4f16a4fb72c..553ed59dc61d49 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -117,4 +117,6 @@ static struct buffer_head *vmufat_sb_bread(struct super_block *sb,
 		return NULL;
 	return sb_bread(sb, block);
 }
+
+int vmufat_count_files(struct super_block *sb);
 #endif

From d17e7175b858fb927541817b00e24e9d1572df25 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Mar 2026 20:41:55 +0000
Subject: [PATCH 060/101] grow files in directory as well as FAT

---
 fs/vmufat/inode.c | 55 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 52 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 843925dea19077..2c1782fb4558ed 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -184,8 +184,8 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 		error = -EINVAL;
 		goto out;
 	}
-	bh = vmufat_sb_bread(sb, offset + 1 +
-		vmudetails->fat_bnum - vmudetails->fat_len);
+	bh = vmufat_sb_bread(sb, offset + (1 +
+		vmudetails->fat_bnum - vmudetails->fat_len));
 	if (!bh) {
 		error = -EIO;
 		goto out;
@@ -292,7 +292,7 @@ static int vmufat_allocate_inode(umode_t imode,
 		struct super_block *sb, struct inode *in)
 {
 	int error = 0;
-	/* Executable files should be at the start of the volume */
+	/* Executable files should be at the start of the volume if possible */
 	if (imode & EXEC) {
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
 			/* Warning for anyone concerned about playable games */
@@ -595,6 +595,7 @@ static int vmufat_clean_fat(struct super_block *sb, int inum)
 		fatword = vmufat_get_fat(sb, nextword);
 		if (fatword == VMUFAT_ERROR) {
 			error = -EIO;
+			printk(KERN_ERR "VMUFAT: Failure while cleaning FAT.\n");
 			break;
 		}
 		error = vmufat_set_fat(sb, nextword, VMUFAT_UNALLOCATED);
@@ -743,6 +744,51 @@ static int vmufat_unlink(struct inode *dir, struct dentry *dentry)
 	return 0;
 }
 
+/* Update the directory record */
+static int vmufat_increment_filesize(struct *inode)
+{
+	struct superblock *sb = inode->i_sb;
+	struct buffer_head *bh = NULL;
+	struct memcard vmudetails = sb->s_fs_info;
+	unsigned long ino_num = inode->i_ino;
+	int error = 0;
+
+	if (ino_num = VMUZEROBLOCK) {
+		ino_num = 0;
+	}
+
+	for (int i = vmudetails->dir_bnum; i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		brelse(bh);
+		bh = vmufat_sb_bread(sb, i);
+		if (!bh) {
+			error = -EIO;
+			return error;
+		}
+		for (int j = 0; j < VMU_ENTRIES_PER_BLOCK; j++) {
+			int record_offset = j * VMU_DIR_RECORD_LEN;
+			if (bh->b_data[record_offset] == 0) {
+				continue;
+			}
+			if (le16_to_cpu(((u16 *) bh->b_data)
+				[j * VMU_DIR_RECORD_LEN16 +
+				VMUFAT_FIRSTBLOCK_OFFSET16]) != ino_num) {
+					continue;
+			}
+			int current_count = le16_to_cpu(((u16 *) bh_>b_data)
+				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16]);
+			current_count++;
+			((u16 *) bh_>b_data)
+				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16] =
+				cpu_to_le16(current_count);
+			mark_buffer_dirty(bh);
+			goto done;
+		}
+	}
+done:
+	brelse(bh);
+	return error;
+}
+
 static int vmufat_get_block(struct inode *inode, sector_t iblock,
 	struct buffer_head *bh_result, int create)
 {
@@ -824,6 +870,9 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 		}
 	}
 	error = vmufat_set_fat(sb, finblk, nxtblk);
+	if (!error) {
+		error = vmufat_increment_filesize(inode);
+	}
 	if (error) {
 		mutex_unlock(&vmudetails->mutex);
 		goto out;

From d123f2c51b61c6d6309e37369cc576e24aa9d693 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Mar 2026 20:47:04 +0000
Subject: [PATCH 061/101] fix typo

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 2c1782fb4558ed..7c42e15c811e8b 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -774,7 +774,7 @@ static int vmufat_increment_filesize(struct *inode)
 				VMUFAT_FIRSTBLOCK_OFFSET16]) != ino_num) {
 					continue;
 			}
-			int current_count = le16_to_cpu(((u16 *) bh_>b_data)
+			int current_count = le16_to_cpu(((u16 *) bh->b_data)
 				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16]);
 			current_count++;
 			((u16 *) bh_>b_data)

From 3dcb514d5fd73908fa85d14d4faa782f9ac64410 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Mar 2026 20:50:16 +0000
Subject: [PATCH 062/101] further typographical errors etc

---
 fs/vmufat/inode.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 7c42e15c811e8b..f50ed3b3368be6 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -745,15 +745,15 @@ static int vmufat_unlink(struct inode *dir, struct dentry *dentry)
 }
 
 /* Update the directory record */
-static int vmufat_increment_filesize(struct *inode)
+static int vmufat_increment_filesize(struct inode *inode)
 {
 	struct superblock *sb = inode->i_sb;
 	struct buffer_head *bh = NULL;
-	struct memcard vmudetails = sb->s_fs_info;
+	struct memcard *vmudetails = sb->s_fs_info;
 	unsigned long ino_num = inode->i_ino;
 	int error = 0;
 
-	if (ino_num = VMUZEROBLOCK) {
+	if (ino_num = VMUFAT_ZEROBLOCK) {
 		ino_num = 0;
 	}
 
@@ -764,7 +764,7 @@ static int vmufat_increment_filesize(struct *inode)
 			error = -EIO;
 			return error;
 		}
-		for (int j = 0; j < VMU_ENTRIES_PER_BLOCK; j++) {
+		for (int j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			int record_offset = j * VMU_DIR_RECORD_LEN;
 			if (bh->b_data[record_offset] == 0) {
 				continue;
@@ -777,7 +777,7 @@ static int vmufat_increment_filesize(struct *inode)
 			int current_count = le16_to_cpu(((u16 *) bh->b_data)
 				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16]);
 			current_count++;
-			((u16 *) bh_>b_data)
+			((u16 *) bh->b_data)
 				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16] =
 				cpu_to_le16(current_count);
 			mark_buffer_dirty(bh);

From e56cbd8f70098fdc8230a374886a063d3c9d53e2 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Mar 2026 20:51:56 +0000
Subject: [PATCH 063/101] even more typographical errors etc

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index f50ed3b3368be6..06096b77934b1b 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -747,13 +747,13 @@ static int vmufat_unlink(struct inode *dir, struct dentry *dentry)
 /* Update the directory record */
 static int vmufat_increment_filesize(struct inode *inode)
 {
-	struct superblock *sb = inode->i_sb;
+	struct super_block *sb = inode->i_sb;
 	struct buffer_head *bh = NULL;
 	struct memcard *vmudetails = sb->s_fs_info;
 	unsigned long ino_num = inode->i_ino;
 	int error = 0;
 
-	if (ino_num = VMUFAT_ZEROBLOCK) {
+	if (ino_num == VMUFAT_ZEROBLOCK) {
 		ino_num = 0;
 	}
 

From 8fde16898c66766c5ad771c51571974570ecbaaf Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 15 Mar 2026 21:55:11 +0000
Subject: [PATCH 064/101] trying to fix non-sync issue

---
 fs/vmufat/super.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index d2fadd4dacb9ff..471c0b8da3edfc 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -578,6 +578,7 @@ static int __init init_vmufat_fs(void)
 static void __exit exit_vmufat_fs(void)
 {
 	destroy_inodecache();
+	rcu_barrier();
 	unregister_filesystem(&vmufat_fs_type);
 }
 

From 24b97e1e9dc9e3d1e57ff6a4a5401fbb9d14c834 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 16 Mar 2026 16:20:18 +0000
Subject: [PATCH 065/101] don't write bad data out

---
 fs/vmufat/inode.c | 10 +++++-----
 fs/vmufat/super.c | 16 ----------------
 2 files changed, 5 insertions(+), 21 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 06096b77934b1b..4a7895ecd1f2b7 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -498,7 +498,8 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 			if (saved_file->ftype == 0)
 				goto finish;
 			saved_file->fblk =
-				le16_to_cpu(((u16 *) bh->b_data)[pos16 + 1]);
+				le16_to_cpu(((u16 *) bh->b_data)
+					[pos16 + VMUFAT_START_OFFSET16]);
 			if (saved_file->fblk == 0)
 				saved_file->fblk = VMUFAT_ZEROBLOCK;
 			memcpy(saved_file->fname,
@@ -770,15 +771,15 @@ static int vmufat_increment_filesize(struct inode *inode)
 				continue;
 			}
 			if (le16_to_cpu(((u16 *) bh->b_data)
-				[j * VMU_DIR_RECORD_LEN16 +
+				[(j * VMU_DIR_RECORD_LEN16) +
 				VMUFAT_FIRSTBLOCK_OFFSET16]) != ino_num) {
 					continue;
 			}
 			int current_count = le16_to_cpu(((u16 *) bh->b_data)
-				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16]);
+				[(j * VMU_DIR_RECORD_LEN16) + VMUFAT_SIZE_OFFSET16]);
 			current_count++;
 			((u16 *) bh->b_data)
-				[j * VMU_DIR_RECORD_LEN16 + VMUFAT_SIZE_OFFSET16] =
+				[(j * VMU_DIR_RECORD_LEN16) + VMUFAT_SIZE_OFFSET16] =
 				cpu_to_le16(current_count);
 			mark_buffer_dirty(bh);
 			goto done;
@@ -947,7 +948,6 @@ const struct inode_operations vmufat_inode_operations = {
 };
 
 const struct file_operations vmufat_file_dir_operations = {
-	.owner =	THIS_MODULE,
 	.read =		generic_read_dir,
 	.iterate_shared =	vmufat_readdir,
 	.fsync =	generic_file_fsync,
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 471c0b8da3edfc..21b21c56380264 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -360,26 +360,10 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 		error = -EIO;
 		goto out;
 	}
-	/* Have the directory entry
-	 * so now update it */
-	if (inode_num != 0)
-		bh->b_data[pos] = VMU_DATA;
-	else
-		bh->b_data[pos] = VMU_GAME;
-	if (bh->b_data[pos + 1] !=  0 && bh->b_data[pos + 1] != (char) 0xff)
-		bh->b_data[pos + 1] = 0;
-	((u16 *) bh->b_data)[pos16 + 1] = cpu_to_le16(inode_num);
 	/* BCD timestamp it */
 	ktime_get_coarse_real_ts64(&current_time);
 	in->i_mtime_sec = current_time.tv_sec;
 	vmufat_save_bcd(in, bh->b_data, pos);
-	((u16 *) bh->b_data)[pos16 + VMUFAT_SIZE_OFFSET16] =
-		cpu_to_le16(in->i_blocks);
-	if (inode_num != 0)
-		((u16 *) bh->b_data)[pos16 + VMUFAT_HEADER_OFFSET16] = 0;
-	else /* game */
-		((u16 *) bh->b_data)[pos16 + VMUFAT_HEADER_OFFSET16]
-			= cpu_to_le16(1);
 	mutex_unlock(&vmudetails->mutex);
 	mark_buffer_dirty(bh);
 	brelse(bh);

From d30315ed04ad2b249fc66feeeb58ca60b9659c45 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 17 Mar 2026 14:31:05 +0000
Subject: [PATCH 066/101] working with exec and data files

---
 fs/vmufat/inode.c  | 70 ++++++++++++++++++++++++++++++++++++++++------
 fs/vmufat/super.c  | 10 +++++--
 fs/vmufat/vmufat.h |  5 ++--
 3 files changed, 73 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 4a7895ecd1f2b7..7141b57cf79148 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -100,20 +100,32 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 	int i, ret = -1;
 	__le16 fatdata;
 
-	for (i = start; i < end; i++) {
-		fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
-		if (fatdata == VMUFAT_UNALLOCATED) {
-			ret = i;
-			break;
+	if (start < end) {
+		for (i = start; i < end; i++) {
+			fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
+			if (fatdata == VMUFAT_UNALLOCATED) {
+				ret = i;
+				break;
+			}
+		}
+	} else {
+		for (i = start; i > end; i--) {
+			fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
+			if (fatdata == VMUFAT_UNALLOCATED) {
+				ret = i;
+				break;
+			}
 		}
 	}
 	return ret;
 }
 
 /*
- * Find a block marked free in the FAT
+ * Find a block marked free in the FAT - for exec files
+ * Dreamcasts expect data and exec files to be stored differently
+ * - we attempt to replicate that
  */
-static int vmufat_find_free(struct super_block *sb)
+static int vmufat_find_free_forward(struct super_block *sb)
 {
 	struct memcard *vmudetails;
 	int testblk, fatblk, ret = -1;
@@ -124,6 +136,10 @@ static int vmufat_find_free(struct super_block *sb)
 	fatblk = vmudetails->fat_bnum;
 	for (int i = 0; i < vmudetails->fat_len; i++)
 	{
+		if ((i * VMU_BLK_SZ16) > (vmudetails->dir_bnum - vmudetails->dir_len))
+		{
+			goto full;
+		}
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {
 			ret = -EIO;
@@ -135,6 +151,7 @@ static int vmufat_find_free(struct super_block *sb)
 			goto out_of_loop;
 		}
 	}
+full:
 	printk(KERN_INFO "VMUFAT: volume is full\n");
 	ret = -ENOSPC;
 	goto fail;
@@ -145,6 +162,41 @@ static int vmufat_find_free(struct super_block *sb)
 	return ret;
 }
 
+/* And for data files*/
+static int vmu_find_free_backward(struct super_block *sb)
+{
+		struct memcard *vmudetails;
+	int testblk, fatblk, ret = -1;
+	struct buffer_head *bh_fat;
+
+	vmudetails = sb->s_fs_info;
+
+	fatblk = vmudetails->fat_bnum;
+	for (int i = (vmudetails->dir_bnum - vmudetails->dir_len) / VMU_BLK_SZ16;
+		i <= 0 ; i--)
+	{
+		bh_fat = vmufat_sb_bread(sb, fatblk + i);
+		if (!bh_fat) {
+			ret = -EIO;
+			goto fail;
+		}
+		testblk = vmufat_get_freeblock(VMU_BLK_SZ16 , 0, bh_fat);
+		put_bh(bh_fat);
+		if (testblk >= 0) {
+			goto out_of_loop;
+		}
+	}
+	printk(KERN_INFO "VMUFAT: volume is full\n");
+	ret = -ENOSPC;
+	goto fail;
+
+out_of_loop:
+	ret = testblk;
+fail:
+	return ret;
+
+}
+
 /* read the FAT for a given block */
 u16 vmufat_get_fat(struct super_block *sb, long block)
 {
@@ -303,8 +355,10 @@ static int vmufat_allocate_inode(umode_t imode,
 			in->i_ino = VMUFAT_ZEROBLOCK;
 			return error;
 		}
+		error = vmu_find_free_forward(sb)
+	} else {
+		error = vmufat_find_free_backward(sb);
 	}
-	error = vmufat_find_free(sb);
 	if (error == 0) {
 		in->i_ino = VMUFAT_ZEROBLOCK;
 	} else if (error > 0) {
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 21b21c56380264..ef42cc936f9861 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -211,7 +211,7 @@ static void vmufat_count_freeblocks(struct super_block *sb,
 	}
 	kstatbuf->f_bfree = free;
 	kstatbuf->f_bavail = free;
-	kstatbuf->f_blocks = vmudetails->numblocks;
+	kstatbuf->f_blocks = vmudetails->sb_num + 1;
 }
 
 int vmufat_count_files(struct super_block *sb)
@@ -391,10 +391,16 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_DIR]);
 	vmudata->dir_len =
 		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_DIRLEN]);
+	if (test_sz == VMU_PHYS_SZ) {
+		vmudata->numblocks =
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_USRLEN])
+	} else {
 	/* return the true number of user available blocks - physical VMUs
  	 * return a neat 200 and ignore 40 blocks of usable space -
  	 * we get round that in a hardware neutral way */
-	vmudata->numblocks = vmudata->sb_bnum + 1;
+		vmudata->numblocks =
+			(vmudata->dir_bnum - vmudata->vmudata->dir_len) + 1;
+	}
 }
 
 static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 553ed59dc61d49..60bc77a5924be2 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -8,8 +8,9 @@
 
 /* GNU utils won't list files with inode num 0 */
 #define VMUFAT_ZEROBLOCK		0x10000
-#define VMU_BLK_SZ			512
-#define	VMU_BLK_SZ16			256
+#define VMU_BLK_SZ				0x200
+#define	VMU_BLK_SZ16			0x100
+#define VMU_PHYS_SZ				0x100
 
 /* file allocation table markers */
 #define VMUFAT_FILE_END			0xFFFA

From a4d399fac43e1d16c4ee155b0c32cb9d3e616926 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 13:38:15 +0000
Subject: [PATCH 067/101] fix typos etc

---
 fs/vmufat/inode.c  | 15 +++++++++++----
 fs/vmufat/super.c  |  6 +++---
 fs/vmufat/vmufat.h |  4 ++++
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 7141b57cf79148..5f96f8941eb8e9 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -163,7 +163,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 }
 
 /* And for data files*/
-static int vmu_find_free_backward(struct super_block *sb)
+static int vmufat_find_free_backward(struct super_block *sb)
 {
 		struct memcard *vmudetails;
 	int testblk, fatblk, ret = -1;
@@ -343,9 +343,11 @@ void vmufat_save_bcd(struct inode *in, char *bh, int index_to_dir)
 static int vmufat_allocate_inode(umode_t imode,
 		struct super_block *sb, struct inode *in)
 {
+	struct vmufat_inode *vin = VMUFAT_I(in);
 	int error = 0;
 	/* Executable files should be at the start of the volume if possible */
 	if (imode & EXEC) {
+		vin->file_type = EXEC;
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
 			/* Warning for anyone concerned about playable games */
 			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
@@ -355,8 +357,9 @@ static int vmufat_allocate_inode(umode_t imode,
 			in->i_ino = VMUFAT_ZEROBLOCK;
 			return error;
 		}
-		error = vmu_find_free_forward(sb)
+		error = vmufat_find_free_forward(sb);
 	} else {
+		vin->file_type = DATA;
 		error = vmufat_find_free_backward(sb);
 	}
 	if (error == 0) {
@@ -906,7 +909,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 			printk(KERN_WARNING "VMUFAT: Cannot allocate linear "
 				"space needed for executible\n");
 			mutex_lock(&vmudetails->mutex);
-			nxtblk = vmufat_find_free(sb);
+			nxtblk = vmufat_find_free_forward(sb);
 			if (nxtblk < 0) {
 				mutex_unlock(&vmudetails->mutex);
 				error = nxtblk;
@@ -917,7 +920,11 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 			nxtblk = finblk + 1;
 		}
 	} else {
-		nxtblk = vmufat_find_free(sb);
+		if (vin->file_type == EXEC) {
+			nxtblk = vmufat_find_free_forward(sb);
+		} else {
+			nxtblk = vmufat_find_free_backward(sb);
+		}
 		if (nxtblk < 0) {
 			mutex_unlock(&vmudetails->mutex);
 			error = nxtblk;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index ef42cc936f9861..8ee502e012570c 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -211,7 +211,7 @@ static void vmufat_count_freeblocks(struct super_block *sb,
 	}
 	kstatbuf->f_bfree = free;
 	kstatbuf->f_bavail = free;
-	kstatbuf->f_blocks = vmudetails->sb_num + 1;
+	kstatbuf->f_blocks = vmudetails->sb_bnum + 1;
 }
 
 int vmufat_count_files(struct super_block *sb)
@@ -393,13 +393,13 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_DIRLEN]);
 	if (test_sz == VMU_PHYS_SZ) {
 		vmudata->numblocks =
-		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_USRLEN])
+		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_USRLEN]);
 	} else {
 	/* return the true number of user available blocks - physical VMUs
  	 * return a neat 200 and ignore 40 blocks of usable space -
  	 * we get round that in a hardware neutral way */
 		vmudata->numblocks =
-			(vmudata->dir_bnum - vmudata->vmudata->dir_len) + 1;
+			(vmudata->dir_bnum - vmudata->dir_len) + 1;
 	}
 }
 
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 60bc77a5924be2..7daa6a20137e44 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -97,6 +97,10 @@ struct vmufat_block {
 struct vmufat_inode {
 	struct list_head blocks;
 	unsigned int nblcks;
+	enum file_type {
+		EXEC,
+		DATA
+	};
 	struct inode vfs_inode;
 };
 

From edfa5b171e0a9d5ee64541b6edcd98d9684608e1 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 13:44:16 +0000
Subject: [PATCH 068/101] avoid clashing definitions of EXEC

---
 fs/vmufat/inode.c  | 6 +++---
 fs/vmufat/vmufat.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 5f96f8941eb8e9..1646b3ad8b8812 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -347,7 +347,7 @@ static int vmufat_allocate_inode(umode_t imode,
 	int error = 0;
 	/* Executable files should be at the start of the volume if possible */
 	if (imode & EXEC) {
-		vin->file_type = EXEC;
+		vin->vmufat_file_type = GAME;
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
 			/* Warning for anyone concerned about playable games */
 			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
@@ -359,7 +359,7 @@ static int vmufat_allocate_inode(umode_t imode,
 		}
 		error = vmufat_find_free_forward(sb);
 	} else {
-		vin->file_type = DATA;
+		vin->vmufat_file_type = DATA;
 		error = vmufat_find_free_backward(sb);
 	}
 	if (error == 0) {
@@ -920,7 +920,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 			nxtblk = finblk + 1;
 		}
 	} else {
-		if (vin->file_type == EXEC) {
+		if (vin->vmufat_file_type == GAME) {
 			nxtblk = vmufat_find_free_forward(sb);
 		} else {
 			nxtblk = vmufat_find_free_backward(sb);
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 7daa6a20137e44..1b4358324c3e9b 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -97,9 +97,9 @@ struct vmufat_block {
 struct vmufat_inode {
 	struct list_head blocks;
 	unsigned int nblcks;
-	enum file_type {
-		EXEC,
-		DATA
+	enum vmufat_file_type {
+		GAME = 1,
+		DATA = 2
 	};
 	struct inode vfs_inode;
 };

From 74ce2526174212789821699c105d056ba173d269 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 13:47:48 +0000
Subject: [PATCH 069/101] get enum declaration right

---
 fs/vmufat/inode.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 1646b3ad8b8812..fa80930b032df6 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -347,7 +347,7 @@ static int vmufat_allocate_inode(umode_t imode,
 	int error = 0;
 	/* Executable files should be at the start of the volume if possible */
 	if (imode & EXEC) {
-		vin->vmufat_file_type = GAME;
+		vin->ft = GAME;
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
 			/* Warning for anyone concerned about playable games */
 			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
@@ -359,7 +359,7 @@ static int vmufat_allocate_inode(umode_t imode,
 		}
 		error = vmufat_find_free_forward(sb);
 	} else {
-		vin->vmufat_file_type = DATA;
+		vin->ft = DATA;
 		error = vmufat_find_free_backward(sb);
 	}
 	if (error == 0) {
@@ -920,7 +920,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 			nxtblk = finblk + 1;
 		}
 	} else {
-		if (vin->vmufat_file_type == GAME) {
+		if (vin->ft == GAME) {
 			nxtblk = vmufat_find_free_forward(sb);
 		} else {
 			nxtblk = vmufat_find_free_backward(sb);

From 6b707466d450f0287e4291f5ca590928b17d27eb Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 13:48:54 +0000
Subject: [PATCH 070/101] include chages in header file

---
 fs/vmufat/vmufat.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 1b4358324c3e9b..8772395bb73497 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -100,7 +100,7 @@ struct vmufat_inode {
 	enum vmufat_file_type {
 		GAME = 1,
 		DATA = 2
-	};
+	} ft;
 	struct inode vfs_inode;
 };
 

From 038a3ecd2bb197082803edd6c17e9c15adf9fddd Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 14:31:28 +0000
Subject: [PATCH 071/101] adjust free block counts

---
 fs/vmufat/inode.c | 6 +++---
 fs/vmufat/super.c | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index fa80930b032df6..eeebefe3453471 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -136,7 +136,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 	fatblk = vmudetails->fat_bnum;
 	for (int i = 0; i < vmudetails->fat_len; i++)
 	{
-		if ((i * VMU_BLK_SZ16) > (vmudetails->dir_bnum - vmudetails->dir_len))
+		if ((i * VMU_BLK_SZ16) > (vmudetails->numblocks))
 		{
 			goto full;
 		}
@@ -165,14 +165,14 @@ static int vmufat_find_free_forward(struct super_block *sb)
 /* And for data files*/
 static int vmufat_find_free_backward(struct super_block *sb)
 {
-		struct memcard *vmudetails;
+	struct memcard *vmudetails;
 	int testblk, fatblk, ret = -1;
 	struct buffer_head *bh_fat;
 
 	vmudetails = sb->s_fs_info;
 
 	fatblk = vmudetails->fat_bnum;
-	for (int i = (vmudetails->dir_bnum - vmudetails->dir_len) / VMU_BLK_SZ16;
+	for (int i = (vmudetails->numblocks) / VMU_BLK_SZ16;
 		i <= 0 ; i--)
 	{
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 8ee502e012570c..11e41d7c5cd6b2 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -258,7 +258,7 @@ static int vmufat_count_file_space(struct super_block *sb)
 		return error;
 	}
 	for (int i = vmudetails->dir_bnum;
-		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+		i > vmudetails->numblocks; i--) {
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {

From cf834f5b1c9013f8592194368125658cfd453252 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 16:37:00 +0000
Subject: [PATCH 072/101] get the search for a free block correct

---
 fs/vmufat/inode.c  | 10 ++++++----
 fs/vmufat/super.c  |  5 +++++
 fs/vmufat/vmufat.h | 10 +++++-----
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index eeebefe3453471..d944f3707cbc03 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -95,13 +95,15 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 	return ERR_PTR(error);
 }
 
+
+/* Search for free block in inclusive range */
 static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 {
 	int i, ret = -1;
 	__le16 fatdata;
 
 	if (start < end) {
-		for (i = start; i < end; i++) {
+		for (i = start; i <= end; i++) {
 			fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
 			if (fatdata == VMUFAT_UNALLOCATED) {
 				ret = i;
@@ -109,7 +111,7 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 			}
 		}
 	} else {
-		for (i = start; i > end; i--) {
+		for (i = start; i >= end; i--) {
 			fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
 			if (fatdata == VMUFAT_UNALLOCATED) {
 				ret = i;
@@ -145,7 +147,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 			ret = -EIO;
 			goto fail;
 		}
-		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ16, bh_fat);
+		testblk = vmufat_get_freeblock(0, vmudetails->numblocks - 1, bh_fat);
 		put_bh(bh_fat);
 		if (testblk >= 0) {
 			goto out_of_loop;
@@ -180,7 +182,7 @@ static int vmufat_find_free_backward(struct super_block *sb)
 			ret = -EIO;
 			goto fail;
 		}
-		testblk = vmufat_get_freeblock(VMU_BLK_SZ16 , 0, bh_fat);
+		testblk = vmufat_get_freeblock(vmudetails->numblocks - 1, 0, bh_fat);
 		put_bh(bh_fat);
 		if (testblk >= 0) {
 			goto out_of_loop;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 11e41d7c5cd6b2..9cd6a2bd01b086 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -394,6 +394,11 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 	if (test_sz == VMU_PHYS_SZ) {
 		vmudata->numblocks =
 		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_USRLEN]);
+		if (vmudata->numblocks == 0)
+		{
+			vmudata->numblocks =
+				(vmudata->dir_bnum - vmudata->dir_len) + 1;			
+		}
 	} else {
 	/* return the true number of user available blocks - physical VMUs
  	 * return a neat 200 and ignore 40 blocks of usable space -
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 8772395bb73497..93f3a73b38126f 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -23,10 +23,10 @@
 #define VMUFAT_START_ALLOC		199
 
 /* specifcations for directory entries */
-#define VMU_DIR_RECORD_LEN		0x20
+#define VMU_DIR_RECORD_LEN			0x20
 #define VMU_DIR_RECORD_LEN16		0x10
 #define VMU_DIR_ENTRIES_PER_BLOCK	0x10
-#define VMUFAT_NAME_OFFSET		0x04
+#define VMUFAT_NAME_OFFSET			0x04
 #define VMUFAT_FIRSTBLOCK_OFFSET16	0x01
 #define VMUFAT_START_OFFSET16		0x01
 #define VMUFAT_SIZE_OFFSET16		0x0C
@@ -41,11 +41,11 @@
 #define VMU_LOCATION_FATLEN		0x24
 #define VMU_LOCATION_DIR		0x25
 #define VMU_LOCATION_DIRLEN		0x26
-#define VMU_LOCATION_USRLEN		0x28 /* reports false figure */
+#define VMU_LOCATION_USRLEN		0x28 /* set to 200 by real hardware */
 
 /* date offsets */
-#define VMUFAT_SB_DATEOFFSET		0x30
-#define VMUFAT_FILE_DATEOFFSET		0x10
+#define VMUFAT_SB_DATEOFFSET	0x30
+#define VMUFAT_FILE_DATEOFFSET	0x10
 
 #define EXEC				0111
 #define NOCOPY				0xFF

From b72abfaa621e5e2bad924f612f3d7d69b1b14cce Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 21:41:02 +0000
Subject: [PATCH 073/101] working on fixing fat for directory

---
 fs/vmufat/inode.c | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index d944f3707cbc03..e06af0d2d8730c 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -400,10 +400,13 @@ static void vmu_handle_zeroblock(int recno, struct buffer_head *bh, int ino)
 static void vmu_write_name(int recno, struct buffer_head *bh, char *name,
 	int len)
 {
-	memset((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET), '\0',
-		VMUFAT_NAMELEN);
-	memcpy((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET),
-		name, len);
+	if ((bh->b_size - recno - VMUFAT_NAME_OFFSET) >= 
+		VMUFAT_NAMELEN && (bh->b_size - recno - VMUFAT_NAME_OFFSET) >= len) {
+		memset((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET), '\0',
+			VMUFAT_NAMELEN);
+		memcpy((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET),
+			name, len);
+	}
 }
 
 static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
@@ -561,9 +564,11 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 					[pos16 + VMUFAT_START_OFFSET16]);
 			if (saved_file->fblk == 0)
 				saved_file->fblk = VMUFAT_ZEROBLOCK;
-			memcpy(saved_file->fname,
-				bh->b_data + pos + VMUFAT_NAME_OFFSET,
-				VMUFAT_NAMELEN);
+			if ((bh->b_size - pos - VMUFAT_NAME_OFFSET) >= VMUFAT_NAMELEN) {
+				memcpy(saved_file->fname,
+					bh->b_data + pos + VMUFAT_NAME_OFFSET,
+					VMUFAT_NAMELEN);
+			}
 			filenamelen = strnlen(saved_file->fname, VMUFAT_NAMELEN);
 			error = ctx->actor(ctx, saved_file->fname, filenamelen,
 				index++, saved_file->fblk, DT_REG);
@@ -669,6 +674,12 @@ static int vmufat_clean_fat(struct super_block *sb, int inum)
 	return error;
 }
 
+static void vmufat_shorten_dirfat(struct super_block *sb, const int block_leaving)
+{
+	vmufat_set_fat(sb, block_leaving, VMUFAT_UNALLOCATED);
+
+}
+
 /*
  * Delete inode by marking space as free in FAT
  * no need to waste time and effort by actually
@@ -679,7 +690,7 @@ static void vmufat_remove_inode(struct inode *in)
 	struct buffer_head *bh = NULL, *bh_old = NULL;
 	struct super_block *sb;
 	struct memcard *vmudetails;
-	int i, j, k, l, startpt, found = 0;
+	int i, j, k, l, x, startpt, found = 0;
 
 	if (in->i_ino == VMUFAT_ZEROBLOCK)
 		in->i_ino = 0;
@@ -700,10 +711,10 @@ static void vmufat_remove_inode(struct inode *in)
 	/* Now clean the directory entry
 	 * Have to wander through this
 	 * to find the appropriate entry */
-	for (i = vmudetails->dir_bnum;
-		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+	for (x = vmudetails->dir_bnum;
+		x > vmudetails->dir_bnum - vmudetails->dir_len; x--) {
 		brelse(bh);
-		bh = vmufat_sb_bread(sb, i);
+		bh = vmufat_sb_bread(sb, x);
 		if (!bh) {
 			mutex_unlock(&vmudetails->mutex);
 			goto failure;
@@ -774,10 +785,14 @@ static void vmufat_remove_inode(struct inode *in)
 			bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i];
 		bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i] = 0;
 	}
+	if (bh_old != bh) {
+		if ((k - 1) == 0) {
+			vmufat_shorten_dirfat(sb, l);
+		}
+	}
 	mark_buffer_dirty(bh_old);
 	mark_buffer_dirty(bh);
 	brelse(bh_old);
-
 finish:
 	mutex_unlock(&vmudetails->mutex);
 	brelse(bh);

From 78d4724563fd3aeededf14d68670cea67002c43c Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 21:55:38 +0000
Subject: [PATCH 074/101] more dir fat code

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e06af0d2d8730c..6709c71722c22c 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -677,7 +677,7 @@ static int vmufat_clean_fat(struct super_block *sb, int inum)
 static void vmufat_shorten_dirfat(struct super_block *sb, const int block_leaving)
 {
 	vmufat_set_fat(sb, block_leaving, VMUFAT_UNALLOCATED);
-
+	vmufat_set_fat(sb, block_leaving + 1, VMUFAT_FILE_END);
 }
 
 /*

From 3ac8fb7d4253d5a88b24dd04d9f8e224aa210594 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 18 Mar 2026 22:47:22 +0000
Subject: [PATCH 075/101] turns out none of that needed for properly formatted
 device

---
 fs/vmufat/inode.c | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 6709c71722c22c..4e6295f8753b53 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -674,12 +674,6 @@ static int vmufat_clean_fat(struct super_block *sb, int inum)
 	return error;
 }
 
-static void vmufat_shorten_dirfat(struct super_block *sb, const int block_leaving)
-{
-	vmufat_set_fat(sb, block_leaving, VMUFAT_UNALLOCATED);
-	vmufat_set_fat(sb, block_leaving + 1, VMUFAT_FILE_END);
-}
-
 /*
  * Delete inode by marking space as free in FAT
  * no need to waste time and effort by actually
@@ -785,11 +779,6 @@ static void vmufat_remove_inode(struct inode *in)
 			bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i];
 		bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i] = 0;
 	}
-	if (bh_old != bh) {
-		if ((k - 1) == 0) {
-			vmufat_shorten_dirfat(sb, l);
-		}
-	}
 	mark_buffer_dirty(bh_old);
 	mark_buffer_dirty(bh);
 	brelse(bh_old);

From aff0746d3322354d1a4ae39de24b67f56b0a1bdb Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 15:30:33 +0000
Subject: [PATCH 076/101] still not handling non-standard sizes properly - fix?

---
 fs/vmufat/super.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 9cd6a2bd01b086..670e3d98e2e091 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -397,14 +397,14 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 		if (vmudata->numblocks == 0)
 		{
 			vmudata->numblocks =
-				(vmudata->dir_bnum - vmudata->dir_len) + 1;			
+				vmudata->dir_bnum;
 		}
 	} else {
 	/* return the true number of user available blocks - physical VMUs
  	 * return a neat 200 and ignore 40 blocks of usable space -
  	 * we get round that in a hardware neutral way */
 		vmudata->numblocks =
-			(vmudata->dir_bnum - vmudata->dir_len) + 1;
+			vmudata->dir_bnum;
 	}
 }
 

From baeb3046facd2dbf910cd4275969f10741504070 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 15:47:26 +0000
Subject: [PATCH 077/101] fixing backward search

---
 fs/vmufat/inode.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 4e6295f8753b53..746765c5d8148b 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -174,8 +174,7 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	vmudetails = sb->s_fs_info;
 
 	fatblk = vmudetails->fat_bnum;
-	for (int i = (vmudetails->numblocks) / VMU_BLK_SZ16;
-		i <= 0 ; i--)
+	for (int i = vmudetails->numblocks; i <= 0 ; i--)
 	{
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {

From f4ca89a3b9a73ce10ce32c3ffd795dc55880e85d Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 17:14:25 +0000
Subject: [PATCH 078/101] search code all messed up - test new backward search

---
 fs/vmufat/inode.c | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 746765c5d8148b..ed9df1d9a4f3c0 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -168,31 +168,35 @@ static int vmufat_find_free_forward(struct super_block *sb)
 static int vmufat_find_free_backward(struct super_block *sb)
 {
 	struct memcard *vmudetails;
-	int testblk, fatblk, ret = -1;
+	int testblk, ret = -1;
+	int i, readblk;
 	struct buffer_head *bh_fat;
 
 	vmudetails = sb->s_fs_info;
+	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ;
 
-	fatblk = vmudetails->fat_bnum;
-	for (int i = vmudetails->numblocks; i <= 0 ; i--)
+	for (i = vmudetails->fat_bnum;
+		i >  vmudetails->fat_bnum - vmudetails->fat_len; i--)
 	{
-		bh_fat = vmufat_sb_bread(sb, fatblk + i);
+		bh_fat = vmufat_sb_bread(sb, i);
 		if (!bh_fat) {
 			ret = -EIO;
 			goto fail;
 		}
-		testblk = vmufat_get_freeblock(vmudetails->numblocks - 1, 0, bh_fat);
+		testblk = vmufat_get_freeblock(readblk, 0, bh_fat);
 		put_bh(bh_fat);
 		if (testblk >= 0) {
 			goto out_of_loop;
 		}
+		readblk = VMU_BLK_SZ - 1;
 	}
 	printk(KERN_INFO "VMUFAT: volume is full\n");
 	ret = -ENOSPC;
 	goto fail;
 
 out_of_loop:
-	ret = testblk;
+	ret = testblk + (i - (vmudetails->fat_bnum - vmudetails->fat_len))
+		* VMU_BLK_SZ;
 fail:
 	return ret;
 

From 180d317f145f6ab05e5486a9b528d32062e72436 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 17:47:06 +0000
Subject: [PATCH 079/101] more work on multiblock FATs

---
 fs/vmufat/inode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index ed9df1d9a4f3c0..f52420ffdde096 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -236,7 +236,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 	int offset, error = 0;
 	struct memcard *vmudetails = sb->s_fs_info;
 
-	offset = block / VMU_BLK_SZ16;
+	offset = block / VMU_BLK_SZ;
 	if (offset >= vmudetails->fat_len) {
 		error = -EINVAL;
 		goto out;
@@ -247,7 +247,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 		error = -EIO;
 		goto out;
 	}
-	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data_to_set);
+	((u16 *) bh->b_data)[block % VMU_BLK_SZ] = cpu_to_le16(data_to_set);
 	mark_buffer_dirty(bh);
 	put_bh(bh);
 out:

From 2ac554906bd394eb5753c5e29023490d05e4fe3d Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 18:20:39 +0000
Subject: [PATCH 080/101] still working on multiblock VMUs

---
 fs/vmufat/inode.c  | 4 ++--
 fs/vmufat/vmufat.h | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index f52420ffdde096..f45375e2d9305d 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -175,8 +175,8 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	vmudetails = sb->s_fs_info;
 	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ;
 
-	for (i = vmudetails->fat_bnum;
-		i >  vmudetails->fat_bnum - vmudetails->fat_len; i--)
+	for (i = (vmudetails->fat_bnum - vmudetails->fat_len) + 1;
+		i >=  vmudetails->fat_bnum; i--)
 	{
 		bh_fat = vmufat_sb_bread(sb, i);
 		if (!bh_fat) {
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index 93f3a73b38126f..a42c437097d00b 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -6,7 +6,7 @@
 /* maximum length of file name */
 #define VMUFAT_NAMELEN			12
 
-/* GNU utils won't list files with inode num 0 */
+/* Some GNU utils might not list files with inode num 0 */
 #define VMUFAT_ZEROBLOCK		0x10000
 #define VMU_BLK_SZ				0x200
 #define	VMU_BLK_SZ16			0x100

From da3f0c9b7d9827ddf9f91096797d01a24941e555 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 19:04:29 +0000
Subject: [PATCH 081/101] fixing search forward

---
 fs/vmufat/inode.c | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index f45375e2d9305d..81a8bc9475592c 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -134,22 +134,17 @@ static int vmufat_find_free_forward(struct super_block *sb)
 	struct buffer_head *bh_fat;
 
 	vmudetails = sb->s_fs_info;
-
 	fatblk = vmudetails->fat_bnum;
 	for (int i = 0; i < vmudetails->fat_len; i++)
 	{
-		if ((i * VMU_BLK_SZ16) > (vmudetails->numblocks))
-		{
-			goto full;
-		}
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {
 			ret = -EIO;
 			goto fail;
 		}
-		testblk = vmufat_get_freeblock(0, vmudetails->numblocks - 1, bh_fat);
+		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ, bh_fat);
 		put_bh(bh_fat);
-		if (testblk >= 0) {
+		if (testblk > 0 && testblk + i * VMU_BLK_SZ < vmudetails->numblocks) {
 			goto out_of_loop;
 		}
 	}
@@ -195,7 +190,7 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	goto fail;
 
 out_of_loop:
-	ret = testblk + (i - (vmudetails->fat_bnum - vmudetails->fat_len))
+	ret = testblk + ((i - 1) - (vmudetails->fat_bnum - vmudetails->fat_len))
 		* VMU_BLK_SZ;
 fail:
 	return ret;

From 239af98b48c46e24fdd90f6c2bab5a20b69853c6 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 20 Mar 2026 21:13:27 +0000
Subject: [PATCH 082/101] trying to identify error

---
 fs/vmufat/super.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 670e3d98e2e091..3f19f27ec9e437 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -95,12 +95,12 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 
 	inode = iget_locked(sb, ino);
 	if (!inode) {
-		error = -EIO;
+		error = -ENOENT;
 		goto reterror;
 	}
 	vmudetails = sb->s_fs_info;
 	if (!vmudetails) {
-		error = -EIO;
+		error = -ENOMEM;
 		goto reterror;
 	}
 	superblock_bno = vmudetails->sb_bnum;
@@ -112,7 +112,7 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 		if (inode->i_ino == superblock_bno) {
 			bh = vmufat_sb_bread(sb, inode->i_ino);
 			if (!bh) {
-				error = -EIO;
+				error = -ENOENT;
 				goto failed;
 			}
 			inode->i_ctime_sec = inode->i_mtime_sec =
@@ -132,7 +132,7 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 				bh = vmufat_sb_bread(sb,
 					vmudetails->dir_bnum - i);
 				if (!bh) {
-					error = -EIO;
+					error = -ENOMEM;
 					goto failed;
 				}
 				for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++)
@@ -333,7 +333,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {
 			mutex_unlock(&vmudetails->mutex);
-			error = -EIO;
+			error = -ENXIO;
 			goto out;
 		}
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
@@ -357,7 +357,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 found:
 	if (found == 0) {
 		mutex_unlock(&vmudetails->mutex);
-		error = -EIO;
+		error = -ENXIO;
 		goto out;
 	}
 	/* BCD timestamp it */

From c8f5ca9cc1a2fd67a91ddce1d0d13a6d52bde111 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Mar 2026 18:41:14 +0000
Subject: [PATCH 083/101] still working on multiblock issue

---
 fs/vmufat/inode.c  | 18 +++++++++---------
 fs/vmufat/vmufat.h |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 81a8bc9475592c..e1a9cca138a302 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -132,10 +132,11 @@ static int vmufat_find_free_forward(struct super_block *sb)
 	struct memcard *vmudetails;
 	int testblk, fatblk, ret = -1;
 	struct buffer_head *bh_fat;
+	int i;
 
 	vmudetails = sb->s_fs_info;
 	fatblk = vmudetails->fat_bnum;
-	for (int i = 0; i < vmudetails->fat_len; i++)
+	for (i = 0; i < vmudetails->fat_len; i++)
 	{
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {
@@ -144,17 +145,16 @@ static int vmufat_find_free_forward(struct super_block *sb)
 		}
 		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ, bh_fat);
 		put_bh(bh_fat);
-		if (testblk > 0 && testblk + i * VMU_BLK_SZ < vmudetails->numblocks) {
+		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ) < vmudetails->numblocks) {
 			goto out_of_loop;
 		}
 	}
-full:
 	printk(KERN_INFO "VMUFAT: volume is full\n");
 	ret = -ENOSPC;
 	goto fail;
 
 out_of_loop:
-	ret = testblk;
+	ret = testblk + (i * VMU_BLK_SZ);
 fail:
 	return ret;
 }
@@ -206,18 +206,18 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 	struct memcard *vmudetails = sb->s_fs_info;
 
 	/* which block in the FAT */
-	offset = block / VMU_BLK_SZ16;
+	offset = block / VMU_BLK_SZ;
 	if (offset >= vmudetails->fat_len)
 		goto out;
 
-	/* fat_bnum points to highest block in FAT */
-	bufhead = vmufat_sb_bread(sb, offset + 1 +
-		vmudetails->fat_bnum - vmudetails->fat_len);
+	/* fat_bnum points to lowest block in FAT */
+	bufhead = vmufat_sb_bread(sb, offset +
+		vmudetails->fat_bnum);
 	if (!bufhead)
 		goto out;
 	/* look inside the block */
 	block_content = le16_to_cpu(((u16 *)bufhead->b_data)
-		[block % VMU_BLK_SZ16]);
+		[block % VMU_BLK_SZ]);
 	put_bh(bufhead);
 out:
 	return block_content;
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index a42c437097d00b..e541b9515b7506 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -20,7 +20,7 @@
 /* parameters for possible VMU volume sizes */
 #define VMUFAT_MIN_BLK			0x04
 #define VMUFAT_MAX_BLK			0x10000
-#define VMUFAT_START_ALLOC		199
+//#define VMUFAT_START_ALLOC		199
 
 /* specifcations for directory entries */
 #define VMU_DIR_RECORD_LEN			0x20

From 3cf41a38e980144c8d188c7f731ca15f6401690c Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Mar 2026 18:59:34 +0000
Subject: [PATCH 084/101] simplify search code

---
 fs/vmufat/inode.c  | 12 +++++-------
 fs/vmufat/vmufat.h |  1 -
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e1a9cca138a302..51f0bb42457818 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -149,7 +149,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 			goto out_of_loop;
 		}
 	}
-	printk(KERN_INFO "VMUFAT: volume is full\n");
+	printk(KERN_INFO "VMUFAT: volume is full, cannot save game file\n");
 	ret = -ENOSPC;
 	goto fail;
 
@@ -170,10 +170,9 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	vmudetails = sb->s_fs_info;
 	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ;
 
-	for (i = (vmudetails->fat_bnum - vmudetails->fat_len) + 1;
-		i >=  vmudetails->fat_bnum; i--)
+	for (i = vmudetails->fat_len - 1; i >= 0; i--)
 	{
-		bh_fat = vmufat_sb_bread(sb, i);
+		bh_fat = vmufat_sb_bread(sb, i + vmudetails->fat_bnum);
 		if (!bh_fat) {
 			ret = -EIO;
 			goto fail;
@@ -185,13 +184,12 @@ static int vmufat_find_free_backward(struct super_block *sb)
 		}
 		readblk = VMU_BLK_SZ - 1;
 	}
-	printk(KERN_INFO "VMUFAT: volume is full\n");
+	printk(KERN_INFO "VMUFAT: volume is full, cannot save data file\n");
 	ret = -ENOSPC;
 	goto fail;
 
 out_of_loop:
-	ret = testblk + ((i - 1) - (vmudetails->fat_bnum - vmudetails->fat_len))
-		* VMU_BLK_SZ;
+	ret = testblk + i * VMU_BLK_SZ;
 fail:
 	return ret;
 
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index e541b9515b7506..b716777d6aa963 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -20,7 +20,6 @@
 /* parameters for possible VMU volume sizes */
 #define VMUFAT_MIN_BLK			0x04
 #define VMUFAT_MAX_BLK			0x10000
-//#define VMUFAT_START_ALLOC		199
 
 /* specifcations for directory entries */
 #define VMU_DIR_RECORD_LEN			0x20

From b8739bd103398cd29790f3f10164c22198dcf1dd Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sat, 21 Mar 2026 19:35:59 +0000
Subject: [PATCH 085/101] use correct offset to read FAT in many block FATs

---
 fs/vmufat/inode.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 51f0bb42457818..e536cd8ef7cb15 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -234,8 +234,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 		error = -EINVAL;
 		goto out;
 	}
-	bh = vmufat_sb_bread(sb, offset + (1 +
-		vmudetails->fat_bnum - vmudetails->fat_len));
+	bh = vmufat_sb_bread(sb, offset + vmudetails->fat_bnum);
 	if (!bh) {
 		error = -EIO;
 		goto out;

From 131fc2c9d326c0ed9913f498779cbf376daf1115 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 12:10:49 +0000
Subject: [PATCH 086/101] use correct multiples for multiblock search

---
 fs/vmufat/inode.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e536cd8ef7cb15..31ffbe739ae0d1 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -143,9 +143,9 @@ static int vmufat_find_free_forward(struct super_block *sb)
 			ret = -EIO;
 			goto fail;
 		}
-		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ, bh_fat);
+		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ16 - 1, bh_fat);
 		put_bh(bh_fat);
-		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ) < vmudetails->numblocks) {
+		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ16) < vmudetails->numblocks) {
 			goto out_of_loop;
 		}
 	}
@@ -154,7 +154,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 	goto fail;
 
 out_of_loop:
-	ret = testblk + (i * VMU_BLK_SZ);
+	ret = testblk + (i * VMU_BLK_SZ16);
 fail:
 	return ret;
 }
@@ -168,7 +168,7 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	struct buffer_head *bh_fat;
 
 	vmudetails = sb->s_fs_info;
-	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ;
+	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ16;
 
 	for (i = vmudetails->fat_len - 1; i >= 0; i--)
 	{
@@ -182,14 +182,14 @@ static int vmufat_find_free_backward(struct super_block *sb)
 		if (testblk >= 0) {
 			goto out_of_loop;
 		}
-		readblk = VMU_BLK_SZ - 1;
+		readblk = VMU_BLK_SZ16 - 1;
 	}
 	printk(KERN_INFO "VMUFAT: volume is full, cannot save data file\n");
 	ret = -ENOSPC;
 	goto fail;
 
 out_of_loop:
-	ret = testblk + i * VMU_BLK_SZ;
+	ret = testblk + (i * VMU_BLK_SZ16);
 fail:
 	return ret;
 

From 42dc03526145be32df364405e195edae97089f71 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 12:15:07 +0000
Subject: [PATCH 087/101] more use of correct multiples for multiblock search

---
 fs/vmufat/inode.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 31ffbe739ae0d1..e6bb520115a064 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -204,7 +204,7 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 	struct memcard *vmudetails = sb->s_fs_info;
 
 	/* which block in the FAT */
-	offset = block / VMU_BLK_SZ;
+	offset = block / VMU_BLK_SZ16;
 	if (offset >= vmudetails->fat_len)
 		goto out;
 
@@ -215,7 +215,7 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 		goto out;
 	/* look inside the block */
 	block_content = le16_to_cpu(((u16 *)bufhead->b_data)
-		[block % VMU_BLK_SZ]);
+		[block % VMU_BLK_SZ16]);
 	put_bh(bufhead);
 out:
 	return block_content;
@@ -229,7 +229,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 	int offset, error = 0;
 	struct memcard *vmudetails = sb->s_fs_info;
 
-	offset = block / VMU_BLK_SZ;
+	offset = block / VMU_BLK_SZ16;
 	if (offset >= vmudetails->fat_len) {
 		error = -EINVAL;
 		goto out;
@@ -239,7 +239,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 		error = -EIO;
 		goto out;
 	}
-	((u16 *) bh->b_data)[block % VMU_BLK_SZ] = cpu_to_le16(data_to_set);
+	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data_to_set);
 	mark_buffer_dirty(bh);
 	put_bh(bh);
 out:

From f934c9e82c3bf64775d00af74c0df947a219befd Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 17:35:25 +0000
Subject: [PATCH 088/101] working on directory cleaning

---
 fs/vmufat/inode.c | 110 +++++++++++++++++++++++-----------------------
 1 file changed, 56 insertions(+), 54 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index e6bb520115a064..6e59c73da11dfa 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -679,14 +679,15 @@ static void vmufat_remove_inode(struct inode *in)
 	struct buffer_head *bh = NULL, *bh_old = NULL;
 	struct super_block *sb;
 	struct memcard *vmudetails;
-	int i, j, k, l, x, startpt, found = 0;
+	int i, j, k, l, x, start_point;
+	bool found, first = true;
 
 	if (in->i_ino == VMUFAT_ZEROBLOCK)
 		in->i_ino = 0;
 	sb = in->i_sb;
 	vmudetails = sb->s_fs_info;
 	if (in->i_ino > vmudetails->fat_len * sb->s_blocksize / 2) {
-		printk(KERN_WARNING "VMUFAT: attempting to delete"
+		printk(KERN_ERR "VMUFAT: attempting to delete"
 			"inode beyond device size");
 		goto ret;
 	}
@@ -698,7 +699,7 @@ static void vmufat_remove_inode(struct inode *in)
 	}
 
 	/* Now clean the directory entry
-	 * Have to wander through this
+	 * Have to walk through entries
 	 * to find the appropriate entry */
 	for (x = vmudetails->dir_bnum;
 		x > vmudetails->dir_bnum - vmudetails->dir_len; x--) {
@@ -711,76 +712,77 @@ static void vmufat_remove_inode(struct inode *in)
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			if (bh->b_data[j * VMU_DIR_RECORD_LEN] == 0) {
 				mutex_unlock(&vmudetails->mutex);
+				brelse(bh);
 				goto failure;
 			}
 			if (le16_to_cpu(((u16 *) bh->b_data)
 				[j * VMU_DIR_RECORD_LEN16 +
 				VMUFAT_FIRSTBLOCK_OFFSET16]) == in->i_ino) {
-				found = 1;
-				goto found;
+				found = true;
+				goto found_bk;
 			}
 		}
 	}
-found:
-	if (found == 0) {
-		mutex_unlock(&vmudetails->mutex);
+found_bk:
+	// actually found nothing - an error or failure of some sort
+	if (!found) {
+		brelse(bh);
 		goto failure;
 	}
-
-	/* Found directory entry - so NULL it now */
-	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
-		bh->b_data[j * VMU_DIR_RECORD_LEN + k] = 0;
-	mark_buffer_dirty(bh);
-	/* Patch up directory, by moving up last file */
-	found = 0;
-	startpt = j + 1;
-	for (l = i; l > vmudetails->dir_bnum - vmudetails->dir_len; l--) {
-		bh_old = vmufat_sb_bread(sb, l);
-		if (!bh_old) {
-			mutex_unlock(&vmudetails->mutex);
-			goto failure;
-		}
-		for (k = startpt; k < VMU_DIR_ENTRIES_PER_BLOCK; k++) {
-			if (bh_old->b_data[k * VMU_DIR_RECORD_LEN] == 0) {
-				found = 1;
-				brelse(bh_old);
-				goto lastdirfound;
+	// have found the directory entry, so first we clean it out
+	for (i = 0; i < DIR_RECORD_LEN; i++)
+	{
+		bh->b_data[i + (j * VMU_DIR_RECORD_LEN)] = 0;
+	}
+	mark_bh_dirty(bh);
+	// now test if there are further records
+	found = false;
+	for (i = x; i < vmudetails->dir_bnum - vmudetails_>dir_len; i++)
+	{
+		brelse(bh_old);
+		bh_old = vmufat_sb_read(sb, i);
+		if (first) {
+			for (l = j; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
+			{
+				if (first) {
+					first = false;
+					continue;
+				}
+				if (bh_old->data[l * VMU_DIR_RECORD_LEN] == 0) {
+					found = true;
+					goto found_final;
+				}
+			}
+		} else {
+			for (l = 0; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
+			{
+				if (bh_old->data[l * VMU_DIR_RECORD_LEN] == 0) {
+					found = true;
+					goto found_final;
+				}
 			}
 		}
-		startpt = 0;
-		brelse(bh_old);
-	}
-lastdirfound:
-	if (found == 0) {	/* full directory */
-		l = vmudetails->dir_bnum - vmudetails->dir_len + 1;
-		k = VMU_DIR_ENTRIES_PER_BLOCK;
-	} else if (l == i && k == j + 1) /* deleted entry was last in dir */
-		goto finish;
-	else if (k == 0) {
-		l = l + 1;
-		k = VMU_DIR_ENTRIES_PER_BLOCK;
-		if (l == i && k == j + 1)
-			goto finish;
 	}
-	/* fill gap first then wipe out old entry */
-	bh_old = vmufat_sb_bread(sb, l);
-	if (!bh_old) {
+found_final:
+	if (!found) // cleaned entry was the final entry
+	{
 		mutex_unlock(&vmudetails->mutex);
+		brelse(bh_old);
 		brelse(bh);
-		goto failure;
+		goto ret;
 	}
-	for (i = 0; i < VMU_DIR_RECORD_LEN; i++) {
-		bh->b_data[j * VMU_DIR_RECORD_LEN + i] =
-			bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i];
-		bh_old->b_data[(k - 1) * VMU_DIR_RECORD_LEN + i] = 0;
+	// copy the final entry into the empty slot and zero the final entry
+	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
+	{
+		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] = bh_old[k + (l * VMU_DIR_RECORD_LEN)];
+		bh_old[k + (l * VMU_DIR_RECORD_LEN)] = 0;
 	}
-	mark_buffer_dirty(bh_old);
-	mark_buffer_dirty(bh);
-	brelse(bh_old);
-finish:
+	mark_bh_dirty(bh);
+	mark_bh_dirty(bh_old);
 	mutex_unlock(&vmudetails->mutex);
 	brelse(bh);
-	return;
+	brelse(bh_old);
+	goto ret;
 
 failure:
 	printk(KERN_WARNING "VMUFAT: Failure to read volume,"

From 13daff14e7189ad6ed439a3f5fb0b1eb3f92d889 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 18:06:45 +0000
Subject: [PATCH 089/101] fix typos etc

---
 fs/vmufat/inode.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 6e59c73da11dfa..7547581a4df8f8 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -241,7 +241,7 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 	}
 	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data_to_set);
 	mark_buffer_dirty(bh);
-	put_bh(bh);
+	brelse(bh);
 out:
 	return error;
 }
@@ -679,7 +679,7 @@ static void vmufat_remove_inode(struct inode *in)
 	struct buffer_head *bh = NULL, *bh_old = NULL;
 	struct super_block *sb;
 	struct memcard *vmudetails;
-	int i, j, k, l, x, start_point;
+	int i, j, k, l, x;
 	bool found, first = true;
 
 	if (in->i_ino == VMUFAT_ZEROBLOCK)
@@ -730,17 +730,17 @@ static void vmufat_remove_inode(struct inode *in)
 		goto failure;
 	}
 	// have found the directory entry, so first we clean it out
-	for (i = 0; i < DIR_RECORD_LEN; i++)
+	for (i = 0; i < VMU_DIR_RECORD_LEN; i++)
 	{
 		bh->b_data[i + (j * VMU_DIR_RECORD_LEN)] = 0;
 	}
-	mark_bh_dirty(bh);
+	mark_buffer_dirty(bh);
 	// now test if there are further records
 	found = false;
-	for (i = x; i < vmudetails->dir_bnum - vmudetails_>dir_len; i++)
+	for (i = x; i < vmudetails->dir_bnum - vmudetails->dir_len; i++)
 	{
 		brelse(bh_old);
-		bh_old = vmufat_sb_read(sb, i);
+		bh_old = vmufat_sb_bread(sb, i);
 		if (first) {
 			for (l = j; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
 			{
@@ -748,7 +748,7 @@ static void vmufat_remove_inode(struct inode *in)
 					first = false;
 					continue;
 				}
-				if (bh_old->data[l * VMU_DIR_RECORD_LEN] == 0) {
+				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN] == 0) {
 					found = true;
 					goto found_final;
 				}
@@ -756,7 +756,7 @@ static void vmufat_remove_inode(struct inode *in)
 		} else {
 			for (l = 0; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
 			{
-				if (bh_old->data[l * VMU_DIR_RECORD_LEN] == 0) {
+				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN] == 0) {
 					found = true;
 					goto found_final;
 				}
@@ -774,11 +774,11 @@ static void vmufat_remove_inode(struct inode *in)
 	// copy the final entry into the empty slot and zero the final entry
 	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
 	{
-		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] = bh_old[k + (l * VMU_DIR_RECORD_LEN)];
-		bh_old[k + (l * VMU_DIR_RECORD_LEN)] = 0;
+		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] = bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)];
+		bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)] = 0;
 	}
-	mark_bh_dirty(bh);
-	mark_bh_dirty(bh_old);
+	mark_buffer_dirty(bh);
+	mark_buffer_dirty(bh_old);
 	mutex_unlock(&vmudetails->mutex);
 	brelse(bh);
 	brelse(bh_old);

From 81eb21dd010644ac133945c0bf7ffd61060c0bf7 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 18:50:26 +0000
Subject: [PATCH 090/101] search in the correct direction

---
 fs/vmufat/inode.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 7547581a4df8f8..bcb76c7dfa77b0 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -144,7 +144,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 			goto fail;
 		}
 		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ16 - 1, bh_fat);
-		put_bh(bh_fat);
+		brelse(bh_fat);
 		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ16) < vmudetails->numblocks) {
 			goto out_of_loop;
 		}
@@ -178,7 +178,7 @@ static int vmufat_find_free_backward(struct super_block *sb)
 			goto fail;
 		}
 		testblk = vmufat_get_freeblock(readblk, 0, bh_fat);
-		put_bh(bh_fat);
+		brelse(bh_fat);
 		if (testblk >= 0) {
 			goto out_of_loop;
 		}
@@ -216,7 +216,7 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 	/* look inside the block */
 	block_content = le16_to_cpu(((u16 *)bufhead->b_data)
 		[block % VMU_BLK_SZ16]);
-	put_bh(bufhead);
+	brelse(bufhead);
 out:
 	return block_content;
 }
@@ -737,7 +737,7 @@ static void vmufat_remove_inode(struct inode *in)
 	mark_buffer_dirty(bh);
 	// now test if there are further records
 	found = false;
-	for (i = x; i < vmudetails->dir_bnum - vmudetails->dir_len; i++)
+	for (i = x; i > vmudetails->dir_bnum - vmudetails->dir_len; i--)
 	{
 		brelse(bh_old);
 		bh_old = vmufat_sb_bread(sb, i);

From 43d538fdc7826ecc4b89da5db184237760f4435f Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 19:06:59 +0000
Subject: [PATCH 091/101] replace with the correct record

---
 fs/vmufat/inode.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index bcb76c7dfa77b0..25a4743afd337e 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -772,6 +772,13 @@ static void vmufat_remove_inode(struct inode *in)
 		goto ret;
 	}
 	// copy the final entry into the empty slot and zero the final entry
+	if (l = VMU_DIR_ENTRIES_PER_BLOCK) {
+		l = 0;
+		brelse(bh_old);
+		bh_old = vmufat_sb_bread(sb, i - 1);
+	} else {
+		l--;
+	}
 	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
 	{
 		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] = bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)];

From 59ab7f95c17dd5ce69269485da0ffcf2b69d496f Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Sun, 22 Mar 2026 19:21:49 +0000
Subject: [PATCH 092/101] fix = for == typo

---
 fs/vmufat/inode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 25a4743afd337e..8113e4fef37d12 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -772,7 +772,7 @@ static void vmufat_remove_inode(struct inode *in)
 		goto ret;
 	}
 	// copy the final entry into the empty slot and zero the final entry
-	if (l = VMU_DIR_ENTRIES_PER_BLOCK) {
+	if (l == VMU_DIR_ENTRIES_PER_BLOCK) {
 		l = 0;
 		brelse(bh_old);
 		bh_old = vmufat_sb_bread(sb, i - 1);

From f134ebda77105254b786d9e785c7e752d5f14000 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 23 Mar 2026 13:59:35 +0000
Subject: [PATCH 093/101] update documentation

---
 Documentation/filesystems/vmufat.rst | 38 ++++++++++++++++++----------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/Documentation/filesystems/vmufat.rst b/Documentation/filesystems/vmufat.rst
index cde87531e9f607..b6ec6271027267 100644
--- a/Documentation/filesystems/vmufat.rst
+++ b/Documentation/filesystems/vmufat.rst
@@ -8,31 +8,33 @@ Android apps etc.
 
 It is not recommended for general use, but does not require a Dreamcast.
 
-All the physical VMU devices that were made were of the same size 256 blocks
-of 512 octets - 128KB in total. But the specification supports a wider range
-of sizes and the filesystem in the Linux kernel is capable of handling volumes
-of a size between 4 blocks and 65536 blocks.
+All the physical VMU devices that were made were of the same size - 256 blocks
+of 512 octets (8 bit bytes) - 128KB in total. But the specification supports a 
+wider range of sizes and the filesystem in the Linux kernel is capable of
+handling volumes of a size between 256 blocks and 65536 blocks.
 
 The standard 256 block VMU is described below:
 
 ========    =======
-BLOCK NO	CONTENT
+BLOCK NO    CONTENT
 ========    =======
-0 - 199     Space used by Dreamcast to save files      
-200 - 240   Space which can be used but which the Dreamcast ignores
+  0 - 199   Space used by Dreamcast to save files      
+200 - 240   Space used by the Dreamcast system
 241 - 253   Directory (can hold 208 file records)
 254         File Allocation Table (FAT)
 255         Root Block
 ========    =======
 
 The standard VMU filesystem has 241 blocks which can be used for file storage
-but a Dreamcast will only use 200 of these. The Linux kernel driver prefers to
-use blocks 0 - 199 when allocating blocks to files, but will use blocks 200 -
-240 if lower numbered blocks are not available.
+but a Dreamcast will only use 200 of these. The other 41 are for Dreamcast system
+use, though the filesystem can access them if set up as a general file store.
+If a device is formatted as strictly compatible with the Dreamcast those blocks
+will not be accessible. Most use cases will want that strict comaptibility.
 
 An executible file (generally a game written in the native machine code of
 the VMU's microcontroller) must begin at block 0 and be stored linearly in
-the volume.
+the volume. The filesystem driver seeks to match that policy but it is not
+absolutely constrained by it.
 
 =========
 DIRECTORY
@@ -100,6 +102,14 @@ Octets 0x4C - 0x4D contain the size (little endian) of the Directory
 Octets 0x4E - 0x4F is Dreamcast specific (icon shape)
 
 Octets 0x50 - 0x51 contain the number (little endian) of user blocks - NB this
-is marked as 200 in a physical VMU although there are in fact 241 usable
-blocks - the reason appears to be that the Directory is not big enough to
-support 1 block files in all user blocks.
\ No newline at end of file
+is marked as 200 in a physical VMU. A filesystem formatted for strict
+compatibility will respect this boundary, one formatted as a general
+file store will not and will instead seek to use all writeable blocks.
+
+====================
+Formatting tool
+====================
+
+A formatting tool is available at https://github.com/mcmenaminadrian/mkfs.vmufat
+
+A phsyicali, factory-set, VMU is unlikely to require reformatting, of course.

From e6782a3146e396a4294b5e8769159cee6c732746 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 23 Mar 2026 22:46:02 +0000
Subject: [PATCH 094/101] formatting fixes

---
 fs/vmufat/inode.c | 193 ++++++++++++++++++++--------------------------
 fs/vmufat/super.c |  85 ++++++++++----------
 2 files changed, 125 insertions(+), 153 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 8113e4fef37d12..bd9f436833fbbd 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -2,8 +2,8 @@
 /*
  * VMUFAT file system
  *
- * Copyright (C) 2002 - 2012, 2025	Adrian McMenamin
- * Copyright (C) 2002		        Paul Mundt
+ * Copyright (C) 2002-2012, 2025, 2026	Adrian McMenamin
+ * Copyright (C) 2002			Paul Mundt
  *
  * 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
@@ -48,11 +48,11 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 	struct memcard *vmudetails;
 	struct buffer_head *bh = NULL;
 	struct inode *ino;
-	int i, j, error = 0;
+	int i, j;
+	int error = 0;
 
 	if (dent->d_name.len > VMUFAT_NAMELEN) {
-		error = -ENAMETOOLONG;
-		goto out;
+		return -ENAMETOOLONG;
 	}
 	sb = in->i_sb;
 	vmudetails = sb->s_fs_info;
@@ -62,16 +62,15 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {
-			error = -EIO;
-			goto out;
+			return -EIO;
 		}
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			int record_offset = j * VMU_DIR_RECORD_LEN;
 			if (bh->b_data[record_offset] == 0)
 				goto insert_negative;
 			if (memcmp(dent->d_name.name,
-				bh->b_data + record_offset + VMUFAT_NAME_OFFSET,
-				dent->d_name.len) == 0) {
+				bh->b_data + record_offset +
+				VMUFAT_NAME_OFFSET, dent->d_name.len) == 0) {
 				ino = vmufat_get_inode(sb,
 					le16_to_cpu(((u16 *) bh->b_data)
 					[(record_offset / 2)
@@ -101,7 +100,6 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 {
 	int i, ret = -1;
 	__le16 fatdata;
-
 	if (start < end) {
 		for (i = start; i <= end; i++) {
 			fatdata = le16_to_cpu(((u16 *)bh->b_data)[i]);
@@ -125,38 +123,30 @@ static int vmufat_get_freeblock(int start, int end, struct buffer_head *bh)
 /*
  * Find a block marked free in the FAT - for exec files
  * Dreamcasts expect data and exec files to be stored differently
- * - we attempt to replicate that
+ * - we attempt to replicate that with *enforcing* a policy
  */
 static int vmufat_find_free_forward(struct super_block *sb)
 {
 	struct memcard *vmudetails;
-	int testblk, fatblk, ret = -1;
+	int testblk, fatblk, i;
+	int ret = -1;
 	struct buffer_head *bh_fat;
-	int i;
-
 	vmudetails = sb->s_fs_info;
 	fatblk = vmudetails->fat_bnum;
-	for (i = 0; i < vmudetails->fat_len; i++)
-	{
+	for (i = 0; i < vmudetails->fat_len; i++) {
 		bh_fat = vmufat_sb_bread(sb, fatblk + i);
 		if (!bh_fat) {
-			ret = -EIO;
-			goto fail;
+			return -EIO;
 		}
 		testblk = vmufat_get_freeblock(0, VMU_BLK_SZ16 - 1, bh_fat);
 		brelse(bh_fat);
-		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ16) < vmudetails->numblocks) {
-			goto out_of_loop;
+		if (testblk >= 0 && testblk + (i * VMU_BLK_SZ16) < 
+			vmudetails->numblocks) {
+			return testblk + (i * VMU_BLK_SZ16);
 		}
 	}
 	printk(KERN_INFO "VMUFAT: volume is full, cannot save game file\n");
-	ret = -ENOSPC;
-	goto fail;
-
-out_of_loop:
-	ret = testblk + (i * VMU_BLK_SZ16);
-fail:
-	return ret;
+	return -ENOSPC;
 }
 
 /* And for data files*/
@@ -170,29 +160,20 @@ static int vmufat_find_free_backward(struct super_block *sb)
 	vmudetails = sb->s_fs_info;
 	readblk = (vmudetails->numblocks - 1) % VMU_BLK_SZ16;
 
-	for (i = vmudetails->fat_len - 1; i >= 0; i--)
-	{
+	for (i = vmudetails->fat_len - 1; i >= 0; i--) {
 		bh_fat = vmufat_sb_bread(sb, i + vmudetails->fat_bnum);
 		if (!bh_fat) {
-			ret = -EIO;
-			goto fail;
+			return -EIO;
 		}
 		testblk = vmufat_get_freeblock(readblk, 0, bh_fat);
 		brelse(bh_fat);
 		if (testblk >= 0) {
-			goto out_of_loop;
+			return testblk + (i * VMU_BLK_SZ16);
 		}
 		readblk = VMU_BLK_SZ16 - 1;
 	}
 	printk(KERN_INFO "VMUFAT: volume is full, cannot save data file\n");
-	ret = -ENOSPC;
-	goto fail;
-
-out_of_loop:
-	ret = testblk + (i * VMU_BLK_SZ16);
-fail:
-	return ret;
-
+	return -ENOSPC;
 }
 
 /* read the FAT for a given block */
@@ -207,10 +188,8 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 	offset = block / VMU_BLK_SZ16;
 	if (offset >= vmudetails->fat_len)
 		goto out;
-
 	/* fat_bnum points to lowest block in FAT */
-	bufhead = vmufat_sb_bread(sb, offset +
-		vmudetails->fat_bnum);
+	bufhead = vmufat_sb_bread(sb, offset + vmudetails->fat_bnum);
 	if (!bufhead)
 		goto out;
 	/* look inside the block */
@@ -222,8 +201,7 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 }
 
 /* set the FAT for a given block */
-static int vmufat_set_fat(struct super_block *sb, long block,
-		u16 data_to_set)
+static int vmufat_set_fat(struct super_block *sb, long block, u16 data)
 {
 	struct buffer_head *bh;
 	int offset, error = 0;
@@ -231,28 +209,25 @@ static int vmufat_set_fat(struct super_block *sb, long block,
 
 	offset = block / VMU_BLK_SZ16;
 	if (offset >= vmudetails->fat_len) {
-		error = -EINVAL;
-		goto out;
+		return -EINVAL;
 	}
 	bh = vmufat_sb_bread(sb, offset + vmudetails->fat_bnum);
 	if (!bh) {
-		error = -EIO;
-		goto out;
+		return -EIO;
 	}
-	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data_to_set);
+	((u16 *) bh->b_data)[block % VMU_BLK_SZ16] = cpu_to_le16(data);
 	mark_buffer_dirty(bh);
 	brelse(bh);
-out:
-	return error;
+	return 0;
 }
 
-static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
+/* No real time clock or real time clock read fails */
+static void vmufat_save_bcd_no_rtc(struct inode *in, char *bh, int index_to_dir)
 {
 	long years, days;
 	unsigned char bcd_century, nl_day, bcd_month;
 	unsigned char u8year;
 	time64_t unix_date;
-
 	unix_date = in->i_mtime_sec;
 	days = unix_date / SECONDS_PER_DAY;
 	years = days / DAYS_PER_YEAR;
@@ -272,9 +247,10 @@ static void vmufat_save_bcd_nortc(struct inode *in, char *bh, int index_to_dir)
 		bcd_month = 2;
 	} else {
 		nl_day = (years % 4) || days <= FEB28 ? days : days - 1;
-		for (bcd_month = 0; bcd_month < 12; bcd_month++)
+		for (bcd_month = 0; bcd_month < 12; bcd_month++) {
 			if (day_n[bcd_month] > nl_day)
 				break;
+		}
 	}
 
 	bcd_century = 19;
@@ -305,7 +281,7 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 	struct rtc_time now;
 
 	if (rtc_read_time(rtc, &now))
-		vmufat_save_bcd_nortc(in, bh, index_to_dir);
+		vmufat_save_bcd_no_rtc(in, bh, index_to_dir);
 	else {
 		bh[index_to_dir + VMUFAT_DIR_CENT] = bin2bcd((char)((now.tm_year + 1900)/100));
 		bh[index_to_dir + VMUFAT_DIR_YEAR] =
@@ -330,7 +306,7 @@ void vmufat_save_bcd(struct inode *in, char *bh, int index_to_dir)
 	struct rtc_device *rtc;
 	rtc = rtc_class_open("rtc0");
 	if (!rtc)
-		vmufat_save_bcd_nortc(in, bh, index_to_dir);
+		vmufat_save_bcd_no_rtc(in, bh, index_to_dir);
 	else {
 		vmufat_save_bcd_rtc(rtc, in, bh, index_to_dir);
 		rtc_class_close(rtc);
@@ -347,8 +323,9 @@ static int vmufat_allocate_inode(umode_t imode,
 		vin->ft = GAME;
 		if (vmufat_get_fat(sb, 0) != VMUFAT_UNALLOCATED) {
 			/* Warning for anyone concerned about playable games */
-			printk(KERN_WARNING "VMUFAT: Warning cannot write excutable "
-				"file to block 0. Volume block 0 already allocated.\n");
+			printk(KERN_WARNING 
+				"VMUFAT: Warning cannot write excutable "
+				"file to block 0: already allocated.\n");
 		}
 		else {
 			in->i_ino = VMUFAT_ZEROBLOCK;
@@ -395,11 +372,11 @@ static void vmu_handle_zeroblock(int recno, struct buffer_head *bh, int ino)
 static void vmu_write_name(int recno, struct buffer_head *bh, char *name,
 	int len)
 {
-	if ((bh->b_size - recno - VMUFAT_NAME_OFFSET) >= 
-		VMUFAT_NAMELEN && (bh->b_size - recno - VMUFAT_NAME_OFFSET) >= len) {
-		memset((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET), '\0',
-			VMUFAT_NAMELEN);
-		memcpy((char *) (bh->b_data + recno + VMUFAT_NAME_OFFSET),
+	if ((bh->b_size - recno - VMUFAT_NAME_OFFSET) >= VMUFAT_NAMELEN &&
+		(bh->b_size - recno - VMUFAT_NAME_OFFSET) >= len) {
+		memset((char *)(bh->b_data + recno + VMUFAT_NAME_OFFSET),
+			'\0', VMUFAT_NAMELEN);
+		memcpy((char *)(bh->b_data + recno + VMUFAT_NAME_OFFSET),
 			name, len);
 	}
 }
@@ -478,6 +455,7 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 	    cpu_to_le16(inode->i_blocks);
 	mark_buffer_dirty(bh);
 	brelse(bh);
+
 	error = vmufat_list_blocks(inode);
 	if (error)
 		goto clean_fat;
@@ -500,7 +478,8 @@ static int vmufat_inode_create(struct mnt_idmap *idmap, struct inode *dir,
 
 static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 {
-	int filenamelen, index, j, k, error = 0;
+	int filenamelen, index, j, k;
+	int error = 0;
 	struct vmufat_file_info *saved_file = NULL;
 	struct dentry *dentry;
 	struct inode *inode;
@@ -519,13 +498,13 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 		error = ctx->actor(ctx, ".", 1, index++, inode->i_ino, DT_DIR);
 		ctx->pos++;
 		if (error < 0)
-			goto out;
+			return error;
 	case 1:
 		error = ctx->actor(ctx, "..", 2, index++,
 			    dentry->d_parent->d_inode->i_ino, DT_DIR);
 		ctx->pos++;
 		if (error < 0)
-			goto out;
+			return error;
 	default:
 		break;
 	}
@@ -533,8 +512,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 	saved_file =
 	    kmalloc(sizeof(struct vmufat_file_info), GFP_KERNEL);
 	if (!saved_file) {
-		error = -ENOMEM;
-		goto out;
+		return -ENOMEM;
 	}
 
 	for (j = vmudetails->dir_bnum -
@@ -543,8 +521,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, j);
 		if (!bh) {
-			error = -EIO;
-			goto finish;
+			return -EIO;
 		}
 		for (k = (index - 2) % VMU_DIR_ENTRIES_PER_BLOCK;
 			k < VMU_DIR_ENTRIES_PER_BLOCK; k++) {
@@ -556,15 +533,17 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 				goto finish;
 			saved_file->fblk =
 				le16_to_cpu(((u16 *) bh->b_data)
-					[pos16 + VMUFAT_START_OFFSET16]);
+				[pos16 + VMUFAT_START_OFFSET16]);
 			if (saved_file->fblk == 0)
 				saved_file->fblk = VMUFAT_ZEROBLOCK;
-			if ((bh->b_size - pos - VMUFAT_NAME_OFFSET) >= VMUFAT_NAMELEN) {
+			if ((bh->b_size - pos - VMUFAT_NAME_OFFSET) >=
+				VMUFAT_NAMELEN) {
 				memcpy(saved_file->fname,
-					bh->b_data + pos + VMUFAT_NAME_OFFSET,
-					VMUFAT_NAMELEN);
+				bh->b_data + pos + VMUFAT_NAME_OFFSET,
+				VMUFAT_NAMELEN);
 			}
-			filenamelen = strnlen(saved_file->fname, VMUFAT_NAMELEN);
+			filenamelen = strnlen(saved_file->fname,
+						VMUFAT_NAMELEN);
 			error = ctx->actor(ctx, saved_file->fname, filenamelen,
 				index++, saved_file->fblk, DT_REG);
 			ctx->pos++;
@@ -572,12 +551,10 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 				goto finish;
 		}
 	}
-
 finish:
 	ctx->pos = index;
 	kfree(saved_file);
 	brelse(bh);
-out:
 	return error;
 }
 
@@ -595,7 +572,7 @@ int vmufat_list_blocks(struct inode *in)
 
 	vi = VMUFAT_I(in);
 	if (!vi)
-		goto out;
+		return error;
 	sb = in->i_sb;
 	ino = in->i_ino;
 	vmudetails = sb->s_fs_info;
@@ -655,7 +632,8 @@ static int vmufat_clean_fat(struct super_block *sb, int inum)
 		fatword = vmufat_get_fat(sb, nextword);
 		if (fatword == VMUFAT_ERROR) {
 			error = -EIO;
-			printk(KERN_ERR "VMUFAT: Failure while cleaning FAT.\n");
+			printk(KERN_ERR
+				"VMUFAT: Failure while cleaning FAT.\n");
 			break;
 		}
 		error = vmufat_set_fat(sb, nextword, VMUFAT_UNALLOCATED);
@@ -689,7 +667,7 @@ static void vmufat_remove_inode(struct inode *in)
 	if (in->i_ino > vmudetails->fat_len * sb->s_blocksize / 2) {
 		printk(KERN_ERR "VMUFAT: attempting to delete"
 			"inode beyond device size");
-		goto ret;
+		return;
 	}
 
 	mutex_lock(&vmudetails->mutex);
@@ -730,33 +708,31 @@ static void vmufat_remove_inode(struct inode *in)
 		goto failure;
 	}
 	// have found the directory entry, so first we clean it out
-	for (i = 0; i < VMU_DIR_RECORD_LEN; i++)
-	{
+	for (i = 0; i < VMU_DIR_RECORD_LEN; i++) {
 		bh->b_data[i + (j * VMU_DIR_RECORD_LEN)] = 0;
 	}
 	mark_buffer_dirty(bh);
 	// now test if there are further records
 	found = false;
-	for (i = x; i > vmudetails->dir_bnum - vmudetails->dir_len; i--)
-	{
+	for (i = x; i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
 		brelse(bh_old);
 		bh_old = vmufat_sb_bread(sb, i);
 		if (first) {
-			for (l = j; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
-			{
+			for (l = j; l < VMU_DIR_ENTRIES_PER_BLOCK; l++) {
 				if (first) {
 					first = false;
 					continue;
 				}
-				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN] == 0) {
+				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN]
+					== 0) {
 					found = true;
 					goto found_final;
 				}
 			}
 		} else {
-			for (l = 0; l < VMU_DIR_ENTRIES_PER_BLOCK; l++)
-			{
-				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN] == 0) {
+			for (l = 0; l < VMU_DIR_ENTRIES_PER_BLOCK; l++) {
+				if (bh_old->b_data[l * VMU_DIR_RECORD_LEN]
+					== 0) {
 					found = true;
 					goto found_final;
 				}
@@ -764,12 +740,12 @@ static void vmufat_remove_inode(struct inode *in)
 		}
 	}
 found_final:
-	if (!found) // cleaned entry was the final entry
-	{
+	if (!found) {
+		// cleaned entry was final entry
 		mutex_unlock(&vmudetails->mutex);
 		brelse(bh_old);
 		brelse(bh);
-		goto ret;
+		return;
 	}
 	// copy the final entry into the empty slot and zero the final entry
 	if (l == VMU_DIR_ENTRIES_PER_BLOCK) {
@@ -779,9 +755,9 @@ static void vmufat_remove_inode(struct inode *in)
 	} else {
 		l--;
 	}
-	for (k = 0; k < VMU_DIR_RECORD_LEN; k++)
-	{
-		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] = bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)];
+	for (k = 0; k < VMU_DIR_RECORD_LEN; k++) {
+		bh->b_data[k + (j * VMU_DIR_RECORD_LEN)] =
+			bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)];
 		bh_old->b_data[k + (l * VMU_DIR_RECORD_LEN)] = 0;
 	}
 	mark_buffer_dirty(bh);
@@ -789,12 +765,11 @@ static void vmufat_remove_inode(struct inode *in)
 	mutex_unlock(&vmudetails->mutex);
 	brelse(bh);
 	brelse(bh_old);
-	goto ret;
+	return;
 
 failure:
 	printk(KERN_WARNING "VMUFAT: Failure to read volume,"
 		" could not delete inode - filesystem may be damaged\n");
-ret:
 	return;
 }
 
@@ -825,7 +800,8 @@ static int vmufat_increment_filesize(struct inode *inode)
 		ino_num = 0;
 	}
 
-	for (int i = vmudetails->dir_bnum; i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
+	for (int i = vmudetails->dir_bnum;
+		i > vmudetails->dir_bnum - vmudetails->dir_len; i--) {
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {
@@ -874,7 +850,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 
 	vin = VMUFAT_I(inode);
 	if (!vin || vin->nblcks <= 0)
-		goto out;
+		return -EINVAL;
 	vlist = &vin->blocks;
 	sb = inode->i_sb;
 	vmudetails = sb->s_fs_info;
@@ -922,8 +898,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 			nxtblk = vmufat_find_free_forward(sb);
 			if (nxtblk < 0) {
 				mutex_unlock(&vmudetails->mutex);
-				error = nxtblk;
-				goto out;
+				return nxtblk;
 			}
 		}
 		else {
@@ -937,8 +912,7 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 		}
 		if (nxtblk < 0) {
 			mutex_unlock(&vmudetails->mutex);
-			error = nxtblk;
-			goto out;
+			return nxtblk;
 		}
 	}
 	error = vmufat_set_fat(sb, finblk, nxtblk);
@@ -947,16 +921,16 @@ static int vmufat_get_block(struct inode *inode, sector_t iblock,
 	}
 	if (error) {
 		mutex_unlock(&vmudetails->mutex);
-		goto out;
+		return error;
 	}
 	error = vmufat_set_fat(sb, nxtblk, VMUFAT_FILE_END);
 	mutex_unlock(&vmudetails->mutex);
 	if (error)
-		goto out;
+		return error;
 	error = vmufat_list_blocks(inode);
 	mark_inode_dirty(inode);
 	if (error)
-		goto out;
+		return error;
 	set_buffer_new(bh_result);
 	phys = nxtblk;
 	error = 0;
@@ -990,7 +964,8 @@ static int vmufat_getattr(struct mnt_idmap *idmap, const struct path *path,
 	struct memcard *vmudetails;
 	struct inode *inode = d_inode(path->dentry);
 	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
-	/* correct for superblock to give directory size as all metadata combined */
+	/* correct for superblock to give directory size */
+	/* as all metadata combined */
 	sb = inode->i_sb;
 	if (sb) {
 		vmudetails = sb->s_fs_info;
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 3f19f27ec9e437..907839654416dd 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -2,8 +2,8 @@
 /*
  * VMUFAT file system
  *
- * Copyright (C) 2002 - 2012, 2025	Adrian McMenamin
- * Copyright (C) 2002		        Paul Mundt
+ * Copyright (C) 2002-2012, 2025, 2026	Adrian McMenamin
+ * Copyright (C) 2002			Paul Mundt
  *
  * 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
@@ -36,11 +36,11 @@
 static struct kmem_cache *vmufat_inode_cachep;
 struct kmem_cache *vmufat_blist_cachep;
 static const struct super_operations vmufat_super_operations;
-extern int *day_n;
-extern const struct inode_operations vmufat_inode_operations;
-extern const struct file_operations vmufat_file_operations;
-extern const struct address_space_operations vmufat_address_space_operations;
-extern const struct file_operations vmufat_file_dir_operations;
+int *day_n;
+const struct inode_operations vmufat_inode_operations;
+const struct file_operations vmufat_file_operations;
+const struct address_space_operations vmufat_address_space_operations;
+const struct file_operations vmufat_file_dir_operations;
 
 static time64_t vmufat_get_date(struct buffer_head *bh, int offset)
 {
@@ -137,8 +137,9 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 				}
 				for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++)
 				{
-					u16 ino_read = le16_to_cpu(((u16 *) bh->b_data)
-						[j * VMU_DIR_RECORD_LEN16 +
+					u16 ino_read = le16_to_cpu(((u16 *)
+						bh->b_data)[j * 
+						VMU_DIR_RECORD_LEN16 + 
 						VMUFAT_FIRSTBLOCK_OFFSET16]);
 					if (ino_read == ino) {
 							goto found;
@@ -157,17 +158,17 @@ struct inode *vmufat_get_inode(struct super_block *sb, long ino)
 			inode->i_mode &= ~(S_IWUGO | S_IXUGO);
 			inode->i_mode |= S_IRUGO;
 			/* Mode - is it write protected? */
-			if ((((u8 *) bh->b_data)[0x01 + offsetindir] ==
-			     0x00) & ~(sb->s_flags & SB_RDONLY)) {
+			if ((((u8 *) bh->b_data)[0x01 + offsetindir] == 0x00) &
+				~(sb->s_flags & SB_RDONLY)) {
 				inode->i_mode |= S_IWUSR;
 			}
 			/* Is file executible - ie a game */
-			if ((((u8 *) bh->b_data)[offsetindir] ==
-			     0xcc) & ~(sb->s_flags & SB_NOEXEC)) {
+			if ((((u8 *) bh->b_data)[offsetindir] == 0xcc) &
+				~(sb->s_flags & SB_NOEXEC)) {
 				inode->i_mode |= S_IXUSR;
 			}
 			inode->i_blocks =
-			    le16_to_cpu(((u16 *) bh->b_data)
+				le16_to_cpu(((u16 *) bh->b_data)
 				[offsetindir / 2 + 0x0C]);
 			inode->i_size = inode->i_blocks * sb->s_blocksize;
 			inode->i_mapping->a_ops =
@@ -206,8 +207,9 @@ static void vmufat_count_freeblocks(struct super_block *sb,
 
 	/* Look through the FAT */
 	for (i = 0; i < vmudetails->numblocks; i++) {
-		if (vmufat_get_fat(sb, i) == VMUFAT_UNALLOCATED)
+		if (vmufat_get_fat(sb, i) == VMUFAT_UNALLOCATED) {
 			free++;
+		}
 	}
 	kstatbuf->f_bfree = free;
 	kstatbuf->f_bavail = free;
@@ -308,7 +310,8 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 {
 	struct buffer_head *bh = NULL;
 	unsigned long inode_num;
-	int i, j, found = 0, error = 0;
+	int i, j; 
+	int found = 0;
 	int pos, pos16;
 	struct super_block *sb;
 	struct memcard *vmudetails;
@@ -319,7 +322,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 	/* As most real world devices are flash we
 	 * won't update the superblock every time */
 	if (in->i_ino == vmudetails->sb_bnum)
-		goto out;
+		return 0;
 	if (in->i_ino == VMUFAT_ZEROBLOCK)
 		inode_num = 0;
 	else
@@ -333,8 +336,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {
 			mutex_unlock(&vmudetails->mutex);
-			error = -ENXIO;
-			goto out;
+			return -ENXIO;
 		}
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			pos = j * VMU_DIR_RECORD_LEN;
@@ -342,8 +344,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 			if (bh->b_data[pos] == 0) {
 				mutex_unlock(&vmudetails->mutex);
 				brelse(bh);
-				error = -ENOENT;
-				goto out;
+				return -ENOENT;
 			}
 			if (le16_to_cpu(((u16 *)bh->b_data)
 				[pos16 + VMUFAT_FIRSTBLOCK_OFFSET16])
@@ -357,8 +358,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 found:
 	if (found == 0) {
 		mutex_unlock(&vmudetails->mutex);
-		error = -ENXIO;
-		goto out;
+		return -ENXIO;
 	}
 	/* BCD timestamp it */
 	ktime_get_coarse_real_ts64(&current_time);
@@ -367,8 +367,7 @@ static int vmufat_write_inode(struct inode *in, struct writeback_control *wbc)
 	mutex_unlock(&vmudetails->mutex);
 	mark_buffer_dirty(bh);
 	brelse(bh);
-out:
-	return error;
+	return 0;
 }
 
 static int check_sb_format(struct buffer_head *bh)
@@ -394,8 +393,7 @@ static void vmufat_populate_vmudata(struct memcard *vmudata,
 	if (test_sz == VMU_PHYS_SZ) {
 		vmudata->numblocks =
 		le16_to_cpu(((u16 *) bh->b_data)[VMU_LOCATION_USRLEN]);
-		if (vmudata->numblocks == 0)
-		{
+		if (vmudata->numblocks == 0) {
 			vmudata->numblocks =
 				vmudata->dir_bnum;
 		}
@@ -415,15 +413,13 @@ static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 		brelse(*bh);
 		*bh = vmufat_sb_bread(sb, i - 1);
 		if (*bh == NULL) {
-			i = -EIO;
-			goto out;
+			return -EIO;
 		}
 		if (check_sb_format(*bh))
 			break;
 	}
 	if (i > VMUFAT_MAX_BLK) {
-		brelse(*bh);
-		i = -ENOENT;
+		return -ENOENT;
 	}
 out:
 	return i;
@@ -432,15 +428,14 @@ static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 {
 	struct buffer_head *bh = NULL;
-	struct memcard *vmudata;
+	struct memcard *vmudata = NULL;
 	int test_sz;
 	struct inode *root_i;
 	int ret = 0;
 
 	vmudata = kzalloc(sizeof(struct memcard), GFP_KERNEL);
 	if (!vmudata) {
-		ret = -ENOMEM;
-		goto freevmudata_out;
+		return -ENOMEM;
 	}
 	sb->s_fs_info = vmudata;
 	sb_set_blocksize(sb, VMU_BLK_SZ);
@@ -457,7 +452,7 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 		printk(KERN_ERR "VMUFAT: attempted to mount corrupted vmufat "
 			"or non-vmufat volume as vmufat.\n");
 		ret = test_sz;
-		goto out;
+		goto freebh_out;
 	}
 
 	vmufat_populate_vmudata(vmudata, bh, test_sz);
@@ -487,9 +482,7 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 
 freebh_out:
 	brelse(bh);
-freevmudata_out:
 	kfree(vmudata);
-
 out:
 	return ret;
 }
@@ -497,7 +490,6 @@ static int vmufat_fill_super(struct super_block *sb, struct fs_context *fc)
 static void init_once(void *foo)
 {
 	struct vmufat_inode *vi = foo;
-
 	vi->nblcks = 0;
 	inode_init_once(&vi->vfs_inode);
 }
@@ -507,13 +499,16 @@ static int init_inodecache(void)
 	vmufat_blist_cachep = kmem_cache_create("vmufat_block_cache",
 		sizeof(struct vmufat_block), 0, SLAB_RECLAIM_ACCOUNT, 0);
 	if (!vmufat_blist_cachep) {
-		printk(KERN_CRIT "VMUFAT: Could not create block list cache.\n");
+		printk(KERN_CRIT
+			"VMUFAT: Could not create block list cache.\n");
 		return -ENOMEM;
 	}
 	vmufat_inode_cachep = kmem_cache_create("vmufat_inode_cache",
-		sizeof(struct vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT, init_once);
+		sizeof(struct vmufat_inode), 0, SLAB_RECLAIM_ACCOUNT,
+		init_once);
 	if (!vmufat_inode_cachep) {
-		printk(KERN_CRIT "VMUFAT: Could not create inode cache.\n");
+		printk(KERN_CRIT
+			"VMUFAT: Could not create inode cache.\n");
 		kmem_cache_destroy(vmufat_inode_cachep);
 		return -ENOMEM;
 	}
@@ -522,6 +517,7 @@ static int init_inodecache(void)
 
 static void destroy_inodecache(void)
 {
+	// ensure the caches are up to date before we try to destroy them
 	rcu_barrier();
 	kmem_cache_destroy(vmufat_inode_cachep);
 	rcu_barrier();
@@ -534,7 +530,7 @@ static const struct super_operations vmufat_super_operations = {
 	.write_inode =		vmufat_write_inode,
 	.evict_inode =		vmufat_evict_inode,
 	.put_super =		vmufat_put_super,
-	.statfs =			vmufat_statfs,
+	.statfs =		vmufat_statfs,
 };
 
 static int vmufat_get_tree(struct fs_context *fc)
@@ -556,8 +552,8 @@ static struct file_system_type vmufat_fs_type = {
 	.owner =			THIS_MODULE,
 	.name = 			"vmufat",
 	.kill_sb = 			kill_block_super,
-	.fs_flags = 		FS_REQUIRES_DEV,
-	.init_fs_context =	vmufat_init_fs_context,
+	.fs_flags =			FS_REQUIRES_DEV,
+	.init_fs_context =		vmufat_init_fs_context,
 };
 
 static int __init init_vmufat_fs(void)
@@ -573,6 +569,7 @@ static int __init init_vmufat_fs(void)
 static void __exit exit_vmufat_fs(void)
 {
 	destroy_inodecache();
+	// ensure all caches removed before we disappear
 	rcu_barrier();
 	unregister_filesystem(&vmufat_fs_type);
 }

From dd939cd34260721490e0cd3d0c5a945bbb0b3cf4 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Mon, 23 Mar 2026 22:51:30 +0000
Subject: [PATCH 095/101] further small formatting changes

---
 fs/vmufat/inode.c  |  6 +++---
 fs/vmufat/vmufat.h | 14 +++++++-------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index bd9f436833fbbd..828543d75e8915 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -994,10 +994,10 @@ const struct inode_operations vmufat_inode_operations = {
 };
 
 const struct file_operations vmufat_file_dir_operations = {
-	.read =		generic_read_dir,
+	.read =			generic_read_dir,
 	.iterate_shared =	vmufat_readdir,
-	.fsync =	generic_file_fsync,
-	.llseek =	generic_file_llseek,
+	.fsync =		generic_file_fsync,
+	.llseek =		generic_file_llseek,
 };
 
 const struct file_operations vmufat_file_operations = {
diff --git a/fs/vmufat/vmufat.h b/fs/vmufat/vmufat.h
index b716777d6aa963..369ee59738eeab 100644
--- a/fs/vmufat/vmufat.h
+++ b/fs/vmufat/vmufat.h
@@ -8,9 +8,9 @@
 
 /* Some GNU utils might not list files with inode num 0 */
 #define VMUFAT_ZEROBLOCK		0x10000
-#define VMU_BLK_SZ				0x200
+#define VMU_BLK_SZ			0x200
 #define	VMU_BLK_SZ16			0x100
-#define VMU_PHYS_SZ				0x100
+#define VMU_PHYS_SZ			0x100
 
 /* file allocation table markers */
 #define VMUFAT_FILE_END			0xFFFA
@@ -22,10 +22,10 @@
 #define VMUFAT_MAX_BLK			0x10000
 
 /* specifcations for directory entries */
-#define VMU_DIR_RECORD_LEN			0x20
+#define VMU_DIR_RECORD_LEN		0x20
 #define VMU_DIR_RECORD_LEN16		0x10
 #define VMU_DIR_ENTRIES_PER_BLOCK	0x10
-#define VMUFAT_NAME_OFFSET			0x04
+#define VMUFAT_NAME_OFFSET		0x04
 #define VMUFAT_FIRSTBLOCK_OFFSET16	0x01
 #define VMUFAT_START_OFFSET16		0x01
 #define VMUFAT_SIZE_OFFSET16		0x0C
@@ -72,11 +72,11 @@ enum vmufat_date {
 #define SECONDS_PER_HOUR		3600
 #define HOURS_PER_DAY			24
 #define SIXTY_MINS_OR_SECS		60
-#define FEB28					59
+#define FEB28				59
 #define DAYS_PER_WEEK			7
 #define START_OF_EPOCH			70
-#define CENTURY21				30
-#define CENTURY22				130
+#define CENTURY21			30
+#define CENTURY22			130
 
 struct memcard {
 	unsigned int sb_bnum;

From 26e5d14cb747fff2fe00fa14a5a85d6ad67f3ea5 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 24 Mar 2026 17:36:06 +0000
Subject: [PATCH 096/101] further tidy

---
 fs/vmufat/inode.c | 10 ++++------
 fs/vmufat/super.c |  1 -
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 828543d75e8915..9c2ae8279b4f77 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -52,7 +52,7 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 	int error = 0;
 
 	if (dent->d_name.len > VMUFAT_NAMELEN) {
-		return -ENAMETOOLONG;
+		return ERR_PTR(-ENAMETOOLONG);
 	}
 	sb = in->i_sb;
 	vmudetails = sb->s_fs_info;
@@ -62,7 +62,7 @@ static struct dentry *vmufat_inode_lookup(struct inode *in, struct dentry *dent,
 		brelse(bh);
 		bh = vmufat_sb_bread(sb, i);
 		if (!bh) {
-			return -EIO;
+			return ERR_PTR(-EIO);
 		}
 		for (j = 0; j < VMU_DIR_ENTRIES_PER_BLOCK; j++) {
 			int record_offset = j * VMU_DIR_RECORD_LEN;
@@ -129,7 +129,6 @@ static int vmufat_find_free_forward(struct super_block *sb)
 {
 	struct memcard *vmudetails;
 	int testblk, fatblk, i;
-	int ret = -1;
 	struct buffer_head *bh_fat;
 	vmudetails = sb->s_fs_info;
 	fatblk = vmudetails->fat_bnum;
@@ -153,7 +152,7 @@ static int vmufat_find_free_forward(struct super_block *sb)
 static int vmufat_find_free_backward(struct super_block *sb)
 {
 	struct memcard *vmudetails;
-	int testblk, ret = -1;
+	int testblk;
 	int i, readblk;
 	struct buffer_head *bh_fat;
 
@@ -204,7 +203,7 @@ u16 vmufat_get_fat(struct super_block *sb, long block)
 static int vmufat_set_fat(struct super_block *sb, long block, u16 data)
 {
 	struct buffer_head *bh;
-	int offset, error = 0;
+	int offset;
 	struct memcard *vmudetails = sb->s_fs_info;
 
 	offset = block / VMU_BLK_SZ16;
@@ -611,7 +610,6 @@ int vmufat_list_blocks(struct inode *in)
 			break;
 		nextblock = fatdata;
 	} while (1);
-out:
 	return error;
 
 unwind_out:
diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index 907839654416dd..fa8f01be65b09a 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -421,7 +421,6 @@ static int vmufat_get_size(struct super_block *sb, struct buffer_head **bh)
 	if (i > VMUFAT_MAX_BLK) {
 		return -ENOENT;
 	}
-out:
 	return i;
 }
 

From c68901f720939ce4712bde6fb1fdf2e0d3d6f318 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Tue, 24 Mar 2026 17:42:35 +0000
Subject: [PATCH 097/101] add extern keyword back

---
 fs/vmufat/super.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/vmufat/super.c b/fs/vmufat/super.c
index fa8f01be65b09a..69f4852f3d030c 100644
--- a/fs/vmufat/super.c
+++ b/fs/vmufat/super.c
@@ -36,11 +36,11 @@
 static struct kmem_cache *vmufat_inode_cachep;
 struct kmem_cache *vmufat_blist_cachep;
 static const struct super_operations vmufat_super_operations;
-int *day_n;
-const struct inode_operations vmufat_inode_operations;
-const struct file_operations vmufat_file_operations;
-const struct address_space_operations vmufat_address_space_operations;
-const struct file_operations vmufat_file_dir_operations;
+extern int *day_n;
+extern const struct inode_operations vmufat_inode_operations;
+extern const struct file_operations vmufat_file_operations;
+extern const struct address_space_operations vmufat_address_space_operations;
+extern const struct file_operations vmufat_file_dir_operations;
 
 static time64_t vmufat_get_date(struct buffer_head *bh, int offset)
 {

From a59cfeb109755fe16cc6e6d5b38d0640b36fa8eb Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 25 Mar 2026 14:09:08 +0000
Subject: [PATCH 098/101] fix documentation typo

---
 Documentation/filesystems/vmufat.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Documentation/filesystems/vmufat.rst b/Documentation/filesystems/vmufat.rst
index b6ec6271027267..e342d9c81e642f 100644
--- a/Documentation/filesystems/vmufat.rst
+++ b/Documentation/filesystems/vmufat.rst
@@ -112,4 +112,4 @@ Formatting tool
 
 A formatting tool is available at https://github.com/mcmenaminadrian/mkfs.vmufat
 
-A phsyicali, factory-set, VMU is unlikely to require reformatting, of course.
+A physical, factory-set, VMU is unlikely to require reformatting, of course.

From 5d5e6a8b5ae2a4105218117f4183c1df7f9dec16 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 25 Mar 2026 16:13:58 +0000
Subject: [PATCH 099/101] fix up documentation

---
 Documentation/filesystems/index.rst  |  1 +
 Documentation/filesystems/vmufat.rst | 40 ++++++++++++++++++----------
 fs/vmufat/Kconfig                    |  2 +-
 3 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/Documentation/filesystems/index.rst b/Documentation/filesystems/index.rst
index f4873197587df7..893b585d17a9cf 100644
--- a/Documentation/filesystems/index.rst
+++ b/Documentation/filesystems/index.rst
@@ -120,5 +120,6 @@ Documentation for filesystem implementations.
    udf
    virtiofs
    vfat
+   vmufat
    xfs/index
    zonefs
diff --git a/Documentation/filesystems/vmufat.rst b/Documentation/filesystems/vmufat.rst
index e342d9c81e642f..2f7230e8e39030 100644
--- a/Documentation/filesystems/vmufat.rst
+++ b/Documentation/filesystems/vmufat.rst
@@ -15,21 +15,25 @@ handling volumes of a size between 256 blocks and 65536 blocks.
 
 The standard 256 block VMU is described below:
 
-========    =======
-BLOCK NO    CONTENT
-========    =======
-  0 - 199   Space used by Dreamcast to save files      
-200 - 240   Space used by the Dreamcast system
-241 - 253   Directory (can hold 208 file records)
-254         File Allocation Table (FAT)
-255         Root Block
-========    =======
++----------+---------------------------------------------+
+| BLOCK NO |   CONTENT                                   |
++==========+=============================================+
+| 0-199    |   Space used by Dreamcast to save files     |
++----------+---------------------------------------------+
+| 200-240  |   Space used by the Dreamcast system        |
++----------+---------------------------------------------+
+| 241-253  |   Directory (can hold 208 file records)     |
++----------+---------------------------------------------+
+| 254      |   File Allocation Table (FAT)               |
++----------+---------------------------------------------+
+| 255      |   Root Block                                |
++----------+---------------------------------------------+
 
 The standard VMU filesystem has 241 blocks which can be used for file storage
 but a Dreamcast will only use 200 of these. The other 41 are for Dreamcast system
 use, though the filesystem can access them if set up as a general file store.
 If a device is formatted as strictly compatible with the Dreamcast those blocks
-will not be accessible. Most use cases will want that strict comaptibility.
+will not be accessible. Most use cases will want that strict compatibility.
 
 An executible file (generally a game written in the native machine code of
 the VMU's microcontroller) must begin at block 0 and be stored linearly in
@@ -37,20 +41,26 @@ the volume. The filesystem driver seeks to match that policy but it is not
 absolutely constrained by it.
 
 =========
-DIRECTORY
+Directory
 =========
 
 The directory contains records 32 octets long (format detail below from Marcus
 Comstedt's website - http://mc.pp.se/dc/vms/flashmem.html)
 
 0x00      : file type (0x00 = no file, 0x33 = data, 0xcc = game)
+
 0x01      : copy protect (0x00 = copy ok, 0xff = copy protected)
+
 0x02-0x03 : 16 bits (little endian) : location of first block
+
 0x04-0x0f : ASCII string : filename (12 characters)
+
 0x10-0x17 : Binary Coded Decimal timestamp: file creation time
+
 0x18-0x19 : 16 bits (little endian) : file size (in blocks)
+
 0x1a-0x1b : 16 bits (little endian) : offset of header (in blocks)
-            from file start
+
 
 Header positioning is a matter for executible files written in native
 code for a physical VMU (an 8 bit Sanyo microcontroller).
@@ -74,7 +84,7 @@ Second (eg., 22)
 Day of week (Monday is 00, Sunday is 06)
 
 =====================
-FILE ALLOCATION TABLE
+File allocation table
 =====================
 
 Every block in the volume is mapped to the FAT eg., block 0 of the VMU maps to
@@ -82,7 +92,9 @@ the first 16 bits of the FAT and so on. Blocks marked 0xFFFC are empty, blocks
 allocated to a file are either numbered with with next block or, if the final
 block are marked 0xFFFA.
 
-**ROOT BLOCK**
+==========
+Root block
+==========
 
 The first 16 octets are marked as 0x55 - we use this to provide the *magic
 number* for this filesystem. The octets at 0x10 - 0x14 are used to determine
diff --git a/fs/vmufat/Kconfig b/fs/vmufat/Kconfig
index cdc7282924b362..92553a24691144 100644
--- a/fs/vmufat/Kconfig
+++ b/fs/vmufat/Kconfig
@@ -11,4 +11,4 @@ config VMUFAT_FS
 	  everyone else should say 'N'.
 
 	  To compile this as a module say 'M' here. The module will be called
-	  vmufat
\ No newline at end of file
+	  vmufat.

From a0c2bd23393242e9ed174513bc9bf0b6afd88906 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Wed, 25 Mar 2026 20:36:37 +0000
Subject: [PATCH 100/101] testing 32 bits with no RTC

---
 fs/vmufat/inode.c | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index 9c2ae8279b4f77..bc328483476759 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -223,12 +223,14 @@ static int vmufat_set_fat(struct super_block *sb, long block, u16 data)
 /* No real time clock or real time clock read fails */
 static void vmufat_save_bcd_no_rtc(struct inode *in, char *bh, int index_to_dir)
 {
-	long years, days;
+	u32 years, days;
 	unsigned char bcd_century, nl_day, bcd_month;
 	unsigned char u8year;
 	time64_t unix_date;
 	unix_date = in->i_mtime_sec;
-	days = unix_date / SECONDS_PER_DAY;
+	time64_t substitute_date = unix_date;
+	do_div(substitute_date, SECONDS_PER_DAY);
+	days = (u32)substitute_date;
 	years = days / DAYS_PER_YEAR;
 	/* 1 Jan gets 1 day later after every leap year */
 	if ((years + 3) / 4 + DAYS_PER_YEAR * years >= days)
@@ -265,15 +267,19 @@ static void vmufat_save_bcd_no_rtc(struct inode *in, char *bh, int index_to_dir)
 	bh[index_to_dir + VMUFAT_DIR_MONTH] = bin2bcd(bcd_month);
 	bh[index_to_dir + VMUFAT_DIR_DAY] =
 	    bin2bcd(days - day_n[bcd_month - 1]);
+	substitute_date = unix_date;
+	do_div(substitute_date, SECONDS_PER_HOUR);
 	bh[index_to_dir + VMUFAT_DIR_HOUR] =
-	    bin2bcd((unix_date / SECONDS_PER_HOUR) % HOURS_PER_DAY);
+	    bin2bcd(substitute_date % HOURS_PER_DAY);
+	substitute_date = unix_date;
+	do_div(substitute_date, SIXTY_MINS_OR_SECS);
 	bh[index_to_dir + VMUFAT_DIR_MIN] =
-		bin2bcd((unix_date / SIXTY_MINS_OR_SECS)
-		 % SIXTY_MINS_OR_SECS);
+		bin2bcd(substitute_date % SIXTY_MINS_OR_SECS);
 	bh[index_to_dir + VMUFAT_DIR_SEC] =
-		bin2bcd(unix_date % SIXTY_MINS_OR_SECS);
+		bin2bcd(do_div(unix_date, SIXTY_MINS_OR_SECS));
 }
 
+#ifdef CONFIG_RTC_CLASS
 static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 	char *bh, int index_to_dir)
 {
@@ -294,6 +300,7 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
 			% DAYS_PER_WEEK);
 	}
 }
+#endif
 
 /*
  * write out the date in bcd format
@@ -302,14 +309,18 @@ static void vmufat_save_bcd_rtc(struct rtc_device *rtc, struct inode *in,
  */
 void vmufat_save_bcd(struct inode *in, char *bh, int index_to_dir)
 {
+#ifdef CONFIG_RTC_CLASS
 	struct rtc_device *rtc;
 	rtc = rtc_class_open("rtc0");
 	if (!rtc)
+#endif
 		vmufat_save_bcd_no_rtc(in, bh, index_to_dir);
+#ifdef CONFIG_RTC_CLASS
 	else {
 		vmufat_save_bcd_rtc(rtc, in, bh, index_to_dir);
 		rtc_class_close(rtc);
 	}
+#endif
 }
 
 static int vmufat_allocate_inode(umode_t imode,
@@ -498,6 +509,7 @@ static int vmufat_readdir(struct file *filp, struct dir_context *ctx)
 		ctx->pos++;
 		if (error < 0)
 			return error;
+		fallthrough;
 	case 1:
 		error = ctx->actor(ctx, "..", 2, index++,
 			    dentry->d_parent->d_inode->i_ino, DT_DIR);

From 8e45e357d960faf446a081c8c41b883fde79e742 Mon Sep 17 00:00:00 2001
From: Adrian McMenamin <adrianmcmenamin@gmail.com>
Date: Fri, 27 Mar 2026 14:39:27 +0000
Subject: [PATCH 101/101] further work to make code portable across 32 and 64
 bit kernels

---
 fs/vmufat/inode.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/fs/vmufat/inode.c b/fs/vmufat/inode.c
index bc328483476759..62f3e371393ef9 100644
--- a/fs/vmufat/inode.c
+++ b/fs/vmufat/inode.c
@@ -223,14 +223,14 @@ static int vmufat_set_fat(struct super_block *sb, long block, u16 data)
 /* No real time clock or real time clock read fails */
 static void vmufat_save_bcd_no_rtc(struct inode *in, char *bh, int index_to_dir)
 {
-	u32 years, days;
+	u32 years, days, seconds;
 	unsigned char bcd_century, nl_day, bcd_month;
 	unsigned char u8year;
-	time64_t unix_date;
+	time64_t unix_date, substitute_date;
 	unix_date = in->i_mtime_sec;
-	time64_t substitute_date = unix_date;
+	substitute_date = unix_date;
 	do_div(substitute_date, SECONDS_PER_DAY);
-	days = (u32)substitute_date;
+	days = (u32)substitute_date; /* cast not an issue for next 5 million years+ */
 	years = days / DAYS_PER_YEAR;
 	/* 1 Jan gets 1 day later after every leap year */
 	if ((years + 3) / 4 + DAYS_PER_YEAR * years >= days)
@@ -270,13 +270,12 @@ static void vmufat_save_bcd_no_rtc(struct inode *in, char *bh, int index_to_dir)
 	substitute_date = unix_date;
 	do_div(substitute_date, SECONDS_PER_HOUR);
 	bh[index_to_dir + VMUFAT_DIR_HOUR] =
-	    bin2bcd(substitute_date % HOURS_PER_DAY);
-	substitute_date = unix_date;
-	do_div(substitute_date, SIXTY_MINS_OR_SECS);
+	    bin2bcd(do_div(substitute_date, HOURS_PER_DAY));
+	seconds = do_div(unix_date, SIXTY_MINS_OR_SECS);
 	bh[index_to_dir + VMUFAT_DIR_MIN] =
-		bin2bcd(substitute_date % SIXTY_MINS_OR_SECS);
+		bin2bcd(unix_date);
 	bh[index_to_dir + VMUFAT_DIR_SEC] =
-		bin2bcd(do_div(unix_date, SIXTY_MINS_OR_SECS));
+		bin2bcd(seconds);
 }
 
 #ifdef CONFIG_RTC_CLASS