[Concept,2/6] fat: Separate fat.c from fat_write.c

  From: Simon Glass <simon.glass@canonical.com>

Currently fat_write.c includes fat.c directly, which is unusual and
makes the code harder to maintain. Use the internal header file to hold
shared functions, to avoid this.

Co-developed-by: Claude <noreply@anthropic.com>
Signed-off-by: Simon Glass <simon.glass@canonical.com>
---

 fs/fat/Makefile       |  2 +-
 fs/fat/fat.c          | 91 ++++++-----------------------------------
 fs/fat/fat_internal.h | 95 +++++++++++++++++++++++++++++++++++++++++--
 fs/fat/fat_write.c    |  4 +-
 4 files changed, 107 insertions(+), 85 deletions(-)
  

On 11/13/25 03:56, Simon Glass wrote:
> From: Simon Glass <simon.glass@canonical.com>
> 
> Currently fat_write.c includes fat.c directly, which is unusual and
> makes the code harder to maintain. Use the internal header file to hold
> shared functions, to avoid this.
> 
> Co-developed-by: Claude <noreply@anthropic.com>
> Signed-off-by: Simon Glass <simon.glass@canonical.com>

When applying this patch to upstream I get:

../fs/fat/fat_write.c:1171:21: error: implicit declaration of function 
‘dm_rtc_get’ [-Wimplicit-function-declaration]
  1171 |                 if (dm_rtc_get(dev, &tm))

Best regards

Heinrich

> ---
> 
>   fs/fat/Makefile       |  2 +-
>   fs/fat/fat.c          | 91 ++++++-----------------------------------
>   fs/fat/fat_internal.h | 95 +++++++++++++++++++++++++++++++++++++++++--
>   fs/fat/fat_write.c    |  4 +-
>   4 files changed, 107 insertions(+), 85 deletions(-)
> 
> diff --git a/fs/fat/Makefile b/fs/fat/Makefile
> index 3e739044537..f3982fca4c6 100644
> --- a/fs/fat/Makefile
> +++ b/fs/fat/Makefile
> @@ -2,4 +2,4 @@
>   #
>   
>   obj-$(CONFIG_$(PHASE_)FS_FAT) = fat.o
> -obj-$(CONFIG_$(PHASE_)FAT_WRITE) = fat_write.o
> +obj-$(CONFIG_$(PHASE_)FAT_WRITE) += fat_write.o
> diff --git a/fs/fat/fat.c b/fs/fat/fat.c
> index b1a3d71e2fe..f62a9ceaa64 100644
> --- a/fs/fat/fat.c
> +++ b/fs/fat/fat.c
> @@ -32,7 +32,7 @@
>    * 'len' may be larger than the length of 'str' if 'str' is NULL
>    * terminated.
>    */
> -static void downcase(char *str, size_t len)
> +void downcase(char *str, size_t len)
>   {
>   	while (*str != '\0' && len--) {
>   		*str = tolower(*str);
> @@ -40,10 +40,10 @@ static void downcase(char *str, size_t len)
>   	}
>   }
>   
> -static struct blk_desc *cur_dev;
> -static struct disk_partition cur_part_info;
> +struct blk_desc *cur_dev;
> +struct disk_partition cur_part_info;
>   
> -static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
> +int disk_read(__u32 block, __u32 nr_blocks, void *buf)
>   {
>   	ulong ret;
>   
> @@ -144,8 +144,6 @@ static void get_name(dir_entry *dirent, char *s_name)
>   		*s_name = DELETED_FLAG;
>   }
>   
> -static int flush_dirty_fat_buffer(fsdata *mydata);
> -
>   #if !CONFIG_IS_ENABLED(FAT_WRITE)
>   /* Stub for read only operation */
>   int flush_dirty_fat_buffer(fsdata *mydata)
> @@ -159,7 +157,7 @@ int flush_dirty_fat_buffer(fsdata *mydata)
>    * Get the entry at index 'entry' in a FAT (12/16/32) table.
>    * On failure 0x00 is returned.
>    */
> -static __u32 get_fatent(fsdata *mydata, __u32 entry)
> +__u32 get_fatent(fsdata *mydata, __u32 entry)
>   {
>   	__u32 bufnum;
>   	__u32 offset, off8;
> @@ -468,7 +466,7 @@ static int slot2str(dir_slot *slotptr, char *l_name, int *idx)
>   }
>   
>   /* Calculate short name checksum */
> -static __u8 mkcksum(struct nameext *nameext)
> +__u8 mkcksum(struct nameext *nameext)
>   {
>   	int i;
>   	u8 *pos = (void *)nameext;
> @@ -698,17 +696,7 @@ static int get_fs_info(fsdata *mydata)
>   	return 0;
>   }
>   
> -static int fat_itr_isdir(fat_itr *itr);
> -
> -/**
> - * fat_itr_root() - initialize an iterator to start at the root
> - * directory
> - *
> - * @itr: iterator to initialize
> - * @fsdata: filesystem data for the partition
> - * Return: 0 on success, else -errno
> - */
> -static int fat_itr_root(fat_itr *itr, fsdata *fsdata)
> +int fat_itr_root(fat_itr *itr, fsdata *fsdata)
>   {
>   	if (get_fs_info(fsdata))
>   		return -ENXIO;
> @@ -725,24 +713,7 @@ static int fat_itr_root(fat_itr *itr, fsdata *fsdata)
>   	return 0;
>   }
>   
> -/**
> - * fat_itr_child() - initialize an iterator to descend into a sub-
> - * directory
> - *
> - * Initializes 'itr' to iterate the contents of the directory at
> - * the current cursor position of 'parent'.  It is an error to
> - * call this if the current cursor of 'parent' is pointing at a
> - * regular file.
> - *
> - * Note that 'itr' and 'parent' can be the same pointer if you do
> - * not need to preserve 'parent' after this call, which is useful
> - * for traversing directory structure to resolve a file/directory.
> - *
> - * @itr: iterator to initialize
> - * @parent: the iterator pointing at a directory entry in the
> - *    parent directory of the directory to iterate
> - */
> -static void fat_itr_child(fat_itr *itr, fat_itr *parent)
> +void fat_itr_child(fat_itr *itr, fat_itr *parent)
>   {
>   	fsdata *mydata = parent->fsdata;  /* for silly macros */
>   	unsigned clustnum = START(parent->dent);
> @@ -843,7 +814,7 @@ void *fat_next_cluster(fat_itr *itr, unsigned int *nbytes)
>   	return itr->block;
>   }
>   
> -static dir_entry *next_dent(fat_itr *itr)
> +dir_entry *next_dent(fat_itr *itr)
>   {
>   	if (itr->remaining == 0) {
>   		unsigned nbytes;
> @@ -919,16 +890,7 @@ static dir_entry *extract_vfat_name(fat_itr *itr)
>   	return dent;
>   }
>   
> -/**
> - * fat_itr_next() - step to the next entry in a directory
> - *
> - * Must be called once on a new iterator before the cursor is valid.
> - *
> - * @itr: the iterator to iterate
> - * Return: boolean, 1 if success or 0 if no more entries in the
> - *    current directory
> - */
> -static int fat_itr_next(fat_itr *itr)
> +int fat_itr_next(fat_itr *itr)
>   {
>   	dir_entry *dent;
>   
> @@ -991,41 +953,12 @@ static int fat_itr_next(fat_itr *itr)
>   	return 1;
>   }
>   
> -/**
> - * fat_itr_isdir() - is current cursor position pointing to a directory
> - *
> - * @itr: the iterator
> - * Return: true if cursor is at a directory
> - */
> -static int fat_itr_isdir(fat_itr *itr)
> +int fat_itr_isdir(fat_itr *itr)
>   {
>   	return !!(itr->dent->attr & ATTR_DIR);
>   }
>   
> -/*
> - * Helpers:
> - */
> -
> -#define TYPE_FILE 0x1
> -#define TYPE_DIR  0x2
> -#define TYPE_ANY  (TYPE_FILE | TYPE_DIR)
> -
> -/**
> - * fat_itr_resolve() - traverse directory structure to resolve the
> - * requested path.
> - *
> - * Traverse directory structure to the requested path.  If the specified
> - * path is to a directory, this will descend into the directory and
> - * leave it iterator at the start of the directory.  If the path is to a
> - * file, it will leave the iterator in the parent directory with current
> - * cursor at file's entry in the directory.
> - *
> - * @itr: iterator initialized to root
> - * @path: the requested path
> - * @type: bitmask of allowable file types
> - * Return: 0 on success or -errno
> - */
> -static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type)
> +int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type)
>   {
>   	const char *next;
>   
> diff --git a/fs/fat/fat_internal.h b/fs/fat/fat_internal.h
> index 0174cd611e7..10881a15569 100644
> --- a/fs/fat/fat_internal.h
> +++ b/fs/fat/fat_internal.h
> @@ -22,6 +22,14 @@ struct disk_partition;
>   #define DOS_FS_TYPE_OFFSET	0x36
>   #define DOS_FS32_TYPE_OFFSET	0x52
>   
> +#define TYPE_FILE 0x1
> +#define TYPE_DIR  0x2
> +#define TYPE_ANY  (TYPE_FILE | TYPE_DIR)
> +
> +/* Global variables shared between fat.c and fat_write.c */
> +extern struct blk_desc *cur_dev;
> +extern struct disk_partition cur_part_info;
> +
>   /**
>    * struct fat_itr - directory iterator, to simplify filesystem traversal
>    *
> @@ -105,8 +113,89 @@ struct fat_itr {
>   	u8 block[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
>   };
>   
> -#define TYPE_FILE 0x1
> -#define TYPE_DIR  0x2
> -#define TYPE_ANY  (TYPE_FILE | TYPE_DIR)
> +/**
> + * downcase() - convert a string to lowercase
> + * @str: string to convert
> + * @len: maximum number of characters to convert
> + */
> +void downcase(char *str, size_t len);
> +
> +/**
> + * next_dent() - get next directory entry
> + * @itr: directory iterator
> + * Return: pointer to next directory entry, or NULL if at end
> + */
> +dir_entry *next_dent(fat_itr *itr);
> +
> +/**
> + * disk_read() - read sectors from the current FAT device
> + * @block: logical block number
> + * @nr_blocks: number of blocks to read
> + * @buf: buffer to read data into
> + * Return: number of blocks read, -1 on error
> + */
> +int disk_read(__u32 block, __u32 nr_blocks, void *buf);
> +
> +/**
> + * flush_dirty_fat_buffer() - write fat buffer to disk if dirty
> + * @mydata: filesystem data
> + * Return: 0 on success, -1 on error
> + */
> +int flush_dirty_fat_buffer(fsdata *mydata);
> +
> +/* Internal function declarations */
> +
> +/**
> + * get_fatent() - get the entry at index 'entry' in a FAT (12/16/32) table
> + * @mydata: filesystem data
> + * @entry: FAT entry index
> + * Return: FAT entry value, 0x00 on failure
> + */
> +__u32 get_fatent(fsdata *mydata, __u32 entry);
> +
> +/**
> + * mkcksum() - calculate short name checksum
> + * @nameext: name and extension structure
> + * Return: checksum value
> + */
> +__u8 mkcksum(struct nameext *nameext);
> +
> +/**
> + * fat_itr_root() - initialize an iterator to start at the root directory
> + * @itr: iterator to initialize
> + * @fsdata: filesystem data for the partition
> + * Return: 0 on success, else -errno
> + */
> +int fat_itr_root(fat_itr *itr, fsdata *fsdata);
> +
> +/**
> + * fat_itr_child() - initialize an iterator to descend into a sub-directory
> + * @itr: iterator to initialize
> + * @parent: the iterator pointing at a directory entry in the parent directory
> + */
> +void fat_itr_child(fat_itr *itr, fat_itr *parent);
> +
> +/**
> + * fat_itr_next() - step to the next entry in a directory
> + * @itr: the iterator to iterate
> + * Return: 1 if success or 0 if no more entries in the current directory
> + */
> +int fat_itr_next(fat_itr *itr);
> +
> +/**
> + * fat_itr_isdir() - is current cursor position pointing to a directory
> + * @itr: the iterator
> + * Return: true if cursor is at a directory
> + */
> +int fat_itr_isdir(fat_itr *itr);
> +
> +/**
> + * fat_itr_resolve() - traverse directory structure to resolve the requested path
> + * @itr: iterator initialized to root
> + * @path: the requested path
> + * @type: bitmask of allowable file types
> + * Return: 0 on success or -errno
> + */
> +int fat_itr_resolve(fat_itr *itr, const char *path, uint type);
>   
>   #endif /* _FAT_INTERNAL_H_ */
> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> index 45a2eef712b..c202f013f43 100644
> --- a/fs/fat/fat_write.c
> +++ b/fs/fat/fat_write.c
> @@ -13,6 +13,7 @@
>   #include <fat.h>
>   #include <log.h>
>   #include <malloc.h>
> +#include <memalign.h>
>   #include <part.h>
>   #include <rand.h>
>   #include <asm/byteorder.h>
> @@ -21,7 +22,6 @@
>   #include <linux/ctype.h>
>   #include <linux/math64.h>
>   #include "fat_internal.h"
> -#include "fat.c"
>   
>   static dir_entry *find_directory_entry(fat_itr *itr, char *filename);
>   static int new_dir_table(fat_itr *itr);
> @@ -216,7 +216,7 @@ static int disk_write(__u32 block, __u32 nr_blocks, void *buf)
>   /*
>    * Write fat buffer into block device
>    */
> -static int flush_dirty_fat_buffer(fsdata *mydata)
> +int flush_dirty_fat_buffer(fsdata *mydata)
>   {
>   	int getsize = FATBUFBLOCKS;
>   	__u32 fatlength = mydata->fatlength;