From: Simon Glass <simon.glass@canonical.com> The ext4l filesystem uses several ktime functions which are currently defined inline in ext4_uboot.h. Create a new linux/ktime.h header file with these stub implementations to better match the Linux kernel structure. This reduces duplication and makes ext4_uboot.h smaller. Functions moved: - ktime_get() - ktime_to_ns() - ktime_sub() - ktime_add_ns() - ktime_get_ns() Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 25 ++-------------- include/linux/ktime.h | 70 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+), 22 deletions(-) create mode 100644 include/linux/ktime.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 91e0ce95467..04872c0a34e 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -1032,26 +1032,8 @@ static inline void shrinker_free(struct shrinker *s) { } -/* ktime functions */ -static inline ktime_t ktime_get(void) -{ - return 0; -} - -static inline s64 ktime_to_ns(ktime_t kt) -{ - return kt; -} - -static inline ktime_t ktime_sub(ktime_t a, ktime_t b) -{ - return a - b; -} - -static inline ktime_t ktime_add_ns(ktime_t kt, s64 ns) -{ - return kt + ns; -} +/* ktime functions - use linux/ktime.h */ +#include <linux/ktime.h> /* hrtimer stubs */ #define HRTIMER_MODE_ABS 0 @@ -1983,8 +1965,7 @@ int IOPRIO_PRIO_VALUE(int class, int data); void *kvzalloc(size_t size, gfp_t flags); #define kvmalloc(size, flags) kvzalloc(size, flags) -/* Time operations */ -#define ktime_get_ns() (0ULL) +/* Time operations - ktime_get_ns is in linux/ktime.h */ /* nsecs_to_jiffies is in linux/jiffies.h */ /* Superblock write operations */ diff --git a/include/linux/ktime.h b/include/linux/ktime.h new file mode 100644 index 00000000000..c853e694823 --- /dev/null +++ b/include/linux/ktime.h @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * ktime_t - nanosecond-resolution time format. + * + * Stub implementation for U-Boot. + */ +#ifndef _LINUX_KTIME_H +#define _LINUX_KTIME_H + +#include <linux/types.h> + +/* ktime_t is defined in linux/types.h */ + +/** + * ktime_get() - get current time + * + * U-Boot stub - returns 0 as we don't track real time during operations. + * + * Return: current time as ktime_t (always 0) + */ +static inline ktime_t ktime_get(void) +{ + return 0; +} + +/** + * ktime_to_ns() - convert ktime_t to nanoseconds + * @kt: the ktime_t value to convert + * + * Return: the nanosecond value + */ +static inline s64 ktime_to_ns(ktime_t kt) +{ + return kt; +} + +/** + * ktime_sub() - subtract two ktime_t values + * @a: first ktime_t value + * @b: second ktime_t value + * + * Return: a - b + */ +static inline ktime_t ktime_sub(ktime_t a, ktime_t b) +{ + return a - b; +} + +/** + * ktime_add_ns() - add nanoseconds to a ktime_t value + * @kt: base ktime_t value + * @ns: nanoseconds to add + * + * Return: kt + ns + */ +static inline ktime_t ktime_add_ns(ktime_t kt, s64 ns) +{ + return kt + ns; +} + +/** + * ktime_get_ns() - get current time in nanoseconds + * + * U-Boot stub - returns 0. + * + * Return: current time in nanoseconds (always 0) + */ +#define ktime_get_ns() (0ULL) + +#endif /* _LINUX_KTIME_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> U-Boot does not have memory pressure or reclaim infrastructure. The ext4l filesystem uses shrinker structures which are currently defined in ext4_uboot.h. Create a new linux/shrinker.h header file with stub implementations to better match the Linux kernel structure. Types and functions moved: - struct shrink_control - struct shrinker - shrinker_alloc() - shrinker_register() - shrinker_free() Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 32 +--------------- include/linux/shrinker.h | 83 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 30 deletions(-) create mode 100644 include/linux/shrinker.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 47236e63911..d04a843175b 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -992,36 +992,8 @@ static inline int in_range(unsigned long val, unsigned long start, /* extents_status.c stubs */ -/* shrinker - memory reclaim infrastructure (stub for U-Boot) */ -struct shrink_control { - gfp_t gfp_mask; - int nid; - unsigned long nr_to_scan; - unsigned long nr_scanned; -}; - -struct shrinker { - unsigned long (*count_objects)(struct shrinker *, struct shrink_control *); - unsigned long (*scan_objects)(struct shrinker *, struct shrink_control *); - void *private_data; -}; - -static inline struct shrinker *shrinker_alloc(unsigned int flags, - const char *fmt, ...) -{ - /* Return static dummy - U-Boot doesn't need memory reclamation */ - static struct shrinker dummy_shrinker; - - return &dummy_shrinker; -} - -static inline void shrinker_register(struct shrinker *s) -{ -} - -static inline void shrinker_free(struct shrinker *s) -{ -} +/* shrinker - use linux/shrinker.h */ +#include <linux/shrinker.h> /* ktime functions - use linux/ktime.h */ #include <linux/ktime.h> diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h new file mode 100644 index 00000000000..b95df9d6dc9 --- /dev/null +++ b/include/linux/shrinker.h @@ -0,0 +1,83 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Shrinker interface stub for U-Boot + * + * U-Boot doesn't have memory pressure or reclaim, so these are stubs. + */ +#ifndef _LINUX_SHRINKER_H +#define _LINUX_SHRINKER_H + +#include <linux/types.h> + +/** + * struct shrink_control - control structure for shrinker callbacks + * @gfp_mask: allocation flags + * @nid: NUMA node being shrunk + * @nr_to_scan: number of objects to scan + * @nr_scanned: number of objects scanned + * + * Stub for U-Boot - memory reclaim is not needed. + */ +struct shrink_control { + gfp_t gfp_mask; + int nid; + unsigned long nr_to_scan; + unsigned long nr_scanned; +}; + +struct shrinker; + +/** + * struct shrinker - memory reclaim callback structure + * @count_objects: callback to count freeable objects + * @scan_objects: callback to scan and free objects + * @private_data: private data for the shrinker + * + * Stub for U-Boot - memory reclaim is not needed. + */ +struct shrinker { + unsigned long (*count_objects)(struct shrinker *, + struct shrink_control *); + unsigned long (*scan_objects)(struct shrinker *, + struct shrink_control *); + void *private_data; +}; + +/** + * shrinker_alloc() - allocate a shrinker structure + * @flags: shrinker flags + * @fmt: format string for name (unused) + * + * U-Boot stub - returns a static dummy shrinker. + * + * Return: pointer to dummy shrinker + */ +static inline struct shrinker *shrinker_alloc(unsigned int flags, + const char *fmt, ...) +{ + static struct shrinker dummy_shrinker; + + return &dummy_shrinker; +} + +/** + * shrinker_register() - register a shrinker + * @s: shrinker to register + * + * U-Boot stub - no-op. + */ +static inline void shrinker_register(struct shrinker *s) +{ +} + +/** + * shrinker_free() - free a shrinker + * @s: shrinker to free + * + * U-Boot stub - no-op. + */ +static inline void shrinker_free(struct shrinker *s) +{ +} + +#endif /* _LINUX_SHRINKER_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> U-Boot does not have a real page cache or VM system. The ext4l filesystem uses many folio and filemap operations which are currently defined inline in ext4_uboot.h. Create a new linux/pagemap.h header file with stub implementations to better match the Linux kernel structure. This significantly reduces duplication and makes ext4_uboot.h smaller. Types and operations moved: - struct folio - FGP_* flags for __filemap_get_folio() - PAGECACHE_TAG_* constants - folio operation stubs (folio_mark_dirty, folio_test_*, etc.) - filemap operation stubs (filemap_invalidate_*, filemap_write_*, etc.) - truncate stubs (truncate_pagecache, truncate_inode_pages, etc.) - readahead stubs (readahead_pos, readahead_length, etc.) - kmap/kunmap stubs - struct readahead_control Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 192 +++----------------------------------- include/linux/pagemap.h | 201 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 216 insertions(+), 177 deletions(-) create mode 100644 include/linux/pagemap.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 6a06805329f..40c68085c7a 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -394,8 +394,7 @@ struct sb_writers { int frozen; }; -/* mapping_large_folio_support stub */ -#define mapping_large_folio_support(m) (0) +/* mapping_large_folio_support is in linux/pagemap.h */ /* sector_t is now in linux/types.h */ @@ -870,28 +869,7 @@ static inline unsigned long memweight(const void *ptr, size_t bytes) /* Security checks - no security in U-Boot */ #define IS_NOSEC(inode) (1) -/* Filemap operations */ -#define filemap_invalidate_lock(m) do { } while (0) -#define filemap_invalidate_unlock(m) do { } while (0) -#define filemap_invalidate_lock_shared(m) do { } while (0) -#define filemap_invalidate_unlock_shared(m) do { } while (0) -#define filemap_write_and_wait_range(m, s, e) ({ (void)(m); (void)(s); (void)(e); 0; }) -#define filemap_fdatawrite_range(m, s, e) ({ (void)(m); (void)(s); (void)(e); 0; }) -#define truncate_pagecache(i, s) do { } while (0) -#define pagecache_isize_extended(i, f, t) do { } while (0) -#define invalidate_mapping_pages(m, s, e) do { (void)(m); (void)(s); (void)(e); } while (0) - -/* Filemap fault handlers - stubs */ -static inline vm_fault_t filemap_fault(struct vm_fault *vmf) -{ - return 0; -} - -static inline vm_fault_t filemap_map_pages(struct vm_fault *vmf, - pgoff_t start, pgoff_t end) -{ - return 0; -} +/* Filemap operations and fault handlers are in linux/pagemap.h */ /* DAX device mapping check - always false in U-Boot */ #define daxdev_mapping_supported(f, i, d) ({ (void)(f); (void)(i); (void)(d); 1; }) @@ -935,8 +913,7 @@ static inline int in_range(unsigned long val, unsigned long start, /* umin - unsigned min (Linux 6.x) */ #define umin(x, y) ((x) < (y) ? (x) : (y)) -/* truncate_inode_pages - stub */ -#define truncate_inode_pages(m, s) do { } while (0) +/* truncate_inode_pages is in linux/pagemap.h */ /* ext4_sb_bread_nofail is stubbed in interface.c */ @@ -966,48 +943,12 @@ static inline int in_range(unsigned long val, unsigned long start, /* SEQ_START_TOKEN is in linux/seq_file.h */ -/* folio - memory page container stub */ -struct folio { - struct page *page; - unsigned long index; - struct address_space *mapping; - unsigned long flags; - void *data; - struct buffer_head *private; - int _refcount; -}; - -/* struct folio_batch is in linux/pagevec.h */ - -/* folio operations - stubs */ -#define folio_mark_dirty(f) do { (void)(f); } while (0) -/* - * offset_in_folio - calculate offset of pointer within folio's data - * In Linux this uses page alignment, but in U-Boot we use the folio's - * actual data pointer since our buffers are malloc'd. - */ -#define offset_in_folio(f, p) ((f) ? (unsigned int)((uintptr_t)(p) - (uintptr_t)(f)->data) : 0U) -#define folio_buffers(f) ({ (void)(f); (struct buffer_head *)NULL; }) -#define virt_to_folio(p) ({ (void)(p); (struct folio *)NULL; }) -#define folio_set_bh(bh, f, off) do { if ((bh) && (f)) { (bh)->b_folio = (f); (bh)->b_data = (char *)(f)->data + (off); } } while (0) -#define memcpy_from_folio(dst, f, off, len) do { (void)(dst); (void)(f); (void)(off); (void)(len); } while (0) -#define folio_test_uptodate(f) ({ (void)(f); 1; }) -#define folio_pos(f) ({ (void)(f); 0LL; }) -#define folio_size(f) ({ (void)(f); PAGE_SIZE; }) -#define folio_unlock(f) do { (void)(f); } while (0) -/* folio_put and folio_get are implemented in support.c */ -#define folio_lock(f) do { (void)(f); } while (0) -/* folio_batch_init is in linux/pagevec.h */ -#define filemap_get_folios(m, i, e, fb) ({ (void)(m); (void)(i); (void)(e); (void)(fb); 0U; }) +/* folio and pagemap - use linux/pagemap.h */ +#include <linux/pagemap.h> /* xa_mark_t - xarray mark type */ typedef unsigned int xa_mark_t; -/* Page cache tags */ -#define PAGECACHE_TAG_DIRTY 0 -#define PAGECACHE_TAG_TOWRITE 1 -#define PAGECACHE_TAG_WRITEBACK 2 - static inline xa_mark_t wbc_to_tag(struct writeback_control *wbc) { if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) @@ -1025,54 +966,9 @@ struct blk_plug { /* Writeback reasons */ #define WB_REASON_FS_FREE_SPACE 0 -/* readahead_control stub */ -struct readahead_control { - struct address_space *mapping; - struct file *file; - unsigned long _index; - unsigned int _batch_count; -}; - -#define readahead_pos(rac) ({ (void)(rac); 0LL; }) -#define readahead_length(rac) ({ (void)(rac); 0UL; }) - /* address_space_operations is in linux/fs.h */ /* buffer_migrate_folio, buffer_migrate_folio_norefs, noop_dirty_folio are in linux/buffer_head.h */ - -/* Stub implementations for address_space_operations callbacks */ -static inline bool block_is_partially_uptodate(struct folio *folio, - size_t from, size_t count) -{ - return false; -} - -static inline int generic_error_remove_folio(struct address_space *mapping, - struct folio *folio) -{ - return 0; -} - -/* FGP flags for folio_grab_cache */ -#define FGP_ACCESSED 0x00000001 -#define FGP_LOCK 0x00000002 -#define FGP_CREAT 0x00000004 -#define FGP_WRITE 0x00000008 -#define FGP_NOFS 0x00000010 -#define FGP_NOWAIT 0x00000020 -#define FGP_FOR_MMAP 0x00000040 -#define FGP_STABLE 0x00000080 -#define FGP_WRITEBEGIN (FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE) - -/* kmap/kunmap stubs for inline.c */ -#define kmap_local_folio(folio, off) ((folio) ? (char *)(folio)->data + (off) : NULL) -#define kunmap_local(addr) do { (void)(addr); } while (0) - -/* Folio zeroing stubs for inline.c */ -#define folio_zero_tail(f, off, kaddr) ({ (void)(f); (void)(off); (void)(kaddr); (void *)NULL; }) -#define folio_zero_segment(f, s, e) do { (void)(f); (void)(s); (void)(e); } while (0) - -/* mapping_gfp_mask stub */ -#define mapping_gfp_mask(m) ({ (void)(m); GFP_KERNEL; }) +/* readahead_control, FGP_*, kmap/kunmap, folio stubs are in linux/pagemap.h */ /* Folio operations - implemented in support.c */ struct folio *__filemap_get_folio(struct address_space *mapping, @@ -1154,43 +1050,8 @@ static inline char *d_path(const struct path *path, char *buf, int buflen) #define inode_is_open_for_write(i) (0) #define inode_is_dirtytime_only(i) (0) -/* Writeback stubs for super.c */ -#define writeback_iter(mapping, wbc, folio, error) \ - ({ (void)(mapping); (void)(wbc); (void)(error); (struct folio *)NULL; }) -#define folio_redirty_for_writepage(wbc, folio) \ - ({ (void)(wbc); (void)(folio); false; }) - -/* Folio operations - additional stubs */ -#define folio_zero_segments(f, s1, e1, s2, e2) do { } while (0) -#define folio_zero_new_buffers(f, f2, t) do { } while (0) -#define folio_wait_stable(f) do { } while (0) -#define folio_zero_range(f, s, l) do { } while (0) -#define folio_mark_uptodate(f) do { } while (0) -#define folio_next_index(f) ((f)->index + 1) -#define folio_next_pos(f) ((loff_t)folio_next_index(f) << PAGE_SHIFT) -#define folio_mapped(f) (0) - -/* - * fgf_set_order - Set the order (size) for folio allocation - * U-Boot doesn't support large folios, so this is a no-op stub. - */ -#define fgf_set_order(size) (0) -#define folio_clear_dirty_for_io(f) ({ (void)(f); 1; }) -#define folio_clear_uptodate(f) do { } while (0) +/* Folio operations and writeback stubs are in linux/pagemap.h */ #define folio_batch_release(fb) do { } while (0) -#define folio_nr_pages(f) (1UL) -#define folio_contains(f, idx) ({ (void)(f); (void)(idx); 1; }) -#define folio_clear_checked(f) do { } while (0) -#define folio_test_dirty(f) (0) -#define folio_test_writeback(f) (0) -#define folio_wait_writeback(f) do { } while (0) -#define folio_clear_dirty(f) do { } while (0) -#define folio_test_checked(f) (0) -#define folio_maybe_dma_pinned(f) (0) -#define folio_set_checked(f) do { } while (0) -#define folio_test_locked(f) (0) -#define folio_mkclean(f) (0) -#define page_folio(page) ((struct folio *)(page)) /* Quota stubs - additional */ #define dquot_claim_block(i, n) ({ (void)(i); (void)(n); 0; }) @@ -1202,20 +1063,8 @@ static inline char *d_path(const struct path *path, char *buf, int buflen) /* percpu_counter_sub is in linux/percpu_counter.h */ -/* Filemap operations - additional */ -#define filemap_get_folio(m, i) ((struct folio *)NULL) -#define filemap_get_folios_tag(m, s, e, t, fb) ({ (void)(m); (void)(s); (void)(e); (void)(t); (void)(fb); 0U; }) -#define filemap_flush(m) ({ (void)(m); 0; }) -#define filemap_write_and_wait(m) ({ (void)(m); 0; }) -#define filemap_dirty_folio(m, f) ({ (void)(m); (void)(f); false; }) -#define filemap_lock_folio(m, i) ((struct folio *)NULL) -/* filemap_invalidate_lock_shared defined earlier */ -#define mapping_tagged(m, t) (0) -#define tag_pages_for_writeback(m, s, e) do { } while (0) +/* Filemap operations are in linux/pagemap.h */ #define try_to_writeback_inodes_sb(sb, r) do { } while (0) -#define mapping_gfp_constraint(m, g) (g) -#define mapping_set_folio_order_range(m, l, h) do { } while (0) -#define filemap_splice_read(i, p, pi, l, f) ({ (void)(i); (void)(p); (void)(pi); (void)(l); (void)(f); 0L; }) /* Buffer operations - additional */ #define getblk_unmovable(bdev, block, size) sb_getblk(bdev->bd_super, block) @@ -1340,9 +1189,7 @@ extern struct inode *iget_locked(struct super_block *sb, unsigned long ino); /* Block device alignment */ #define bdev_dma_alignment(bd) (0) -/* Truncation */ -#define truncate_inode_pages_final(m) do { } while (0) -#define truncate_pagecache_range(i, s, e) do { } while (0) +/* Truncation stubs are in linux/pagemap.h */ /* * Additional stubs for dir.c @@ -1353,9 +1200,7 @@ extern struct inode *iget_locked(struct super_block *sb, unsigned long ino); /* fscrypt directory operations are in ext4_fscrypt.h */ -/* Readahead operations */ -#define ra_has_index(ra, idx) ({ (void)(ra); (void)(idx); 0; }) -#define page_cache_sync_readahead(m, ra, f, i, n) do { } while (0) +/* Readahead operations are in linux/pagemap.h */ /* Inode version operations */ #define inode_eq_iversion(i, v) ({ (void)(i); (void)(v); 1; }) @@ -2072,9 +1917,7 @@ static inline unsigned long ext4_find_next_bit_le(const void *addr, /* CPU cycle counter stub */ #define get_cycles() (0ULL) -/* folio_address - get virtual address of folio data */ -#undef folio_address -#define folio_address(folio) ((folio)->data) +/* folio_address is in linux/pagemap.h */ /* sb_end_intwrite defined earlier */ @@ -2243,9 +2086,7 @@ typedef void *mempool_t; #define fsverity_verify_folio(f) ({ (void)(f); 1; }) #define IS_VERITY(inode) (0) -/* readahead operations */ -#define readahead_count(rac) ({ (void)(rac); 0UL; }) -#define readahead_folio(rac) ({ (void)(rac); (struct folio *)NULL; }) +/* readahead operations are in linux/pagemap.h */ /* prefetch operations */ #define prefetchw(addr) do { (void)(addr); } while (0) @@ -2300,10 +2141,9 @@ struct wait_bit_entry { #define write_dirty_buffer(bh, flags) sync_dirty_buffer(bh) #define spin_needbreak(l) ({ (void)(l); 0; }) -/* JBD2 commit.c stubs */ +/* JBD2 commit.c stubs (folio_trylock is in linux/pagemap.h) */ #define clear_bit_unlock(nr, addr) clear_bit(nr, addr) #define smp_mb__after_atomic() do { } while (0) -#define folio_trylock(f) ({ (void)(f); 1; }) #define ktime_get_coarse_real_ts64(ts) do { (ts)->tv_sec = 0; (ts)->tv_nsec = 0; } while (0) #define filemap_fdatawait_range_keep_errors(m, s, e) \ ({ (void)(m); (void)(s); (void)(e); 0; }) @@ -2379,7 +2219,7 @@ int bh_read(struct buffer_head *bh, int flags); #ifndef SECTOR_SHIFT #define SECTOR_SHIFT 9 #endif -#define mapping_max_folio_order(m) ({ (void)(m); 0; }) +/* mapping_max_folio_order is in linux/pagemap.h */ /* Memory allocation for journal.c */ #define __get_free_pages(gfp, order) ((unsigned long)memalign(PAGE_SIZE, PAGE_SIZE << (order))) @@ -2410,9 +2250,7 @@ static inline struct new_utsname *init_utsname(void) #define down_write_nested(sem, subclass) \ do { (void)(sem); (void)(subclass); } while (0) -/* filemap_release_folio - try to release a folio */ -#define filemap_release_folio(folio, gfp) \ - ({ (void)(folio); (void)(gfp); 1; }) +/* filemap_release_folio is in linux/pagemap.h */ /* IS_SWAPFILE - check if inode is a swap file */ #define IS_SWAPFILE(inode) ({ (void)(inode); 0; }) diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h new file mode 100644 index 00000000000..19a64993955 --- /dev/null +++ b/include/linux/pagemap.h @@ -0,0 +1,201 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Page cache and folio management stubs for U-Boot + * + * U-Boot doesn't have a real page cache, so these are stubs. + */ +#ifndef _LINUX_PAGEMAP_H +#define _LINUX_PAGEMAP_H + +#include <linux/types.h> +#include <linux/mm_types.h> + +/* Forward declarations */ +struct address_space; +struct buffer_head; + +/** + * struct folio - memory page container stub + * @page: associated page + * @index: page index in the mapping + * @mapping: address space this folio belongs to + * @flags: folio flags + * @data: pointer to the actual data + * @private: private data for filesystem + * @_refcount: reference count + * + * U-Boot stub - simplified folio structure. + */ +struct folio { + struct page *page; + unsigned long index; + struct address_space *mapping; + unsigned long flags; + void *data; + struct buffer_head *private; + int _refcount; +}; + +/* FGP flags for __filemap_get_folio() */ +#define FGP_ACCESSED 0x00000001 +#define FGP_LOCK 0x00000002 +#define FGP_CREAT 0x00000004 +#define FGP_WRITE 0x00000008 +#define FGP_NOFS 0x00000010 +#define FGP_NOWAIT 0x00000020 +#define FGP_FOR_MMAP 0x00000040 +#define FGP_STABLE 0x00000080 +#define FGP_WRITEBEGIN (FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE) + +/* Page cache tags */ +#define PAGECACHE_TAG_DIRTY 0 +#define PAGECACHE_TAG_TOWRITE 1 +#define PAGECACHE_TAG_WRITEBACK 2 + +/* Folio operations - stubs */ +#define folio_mark_dirty(f) do { (void)(f); } while (0) +#define folio_test_uptodate(f) ({ (void)(f); 1; }) +#define folio_pos(f) ({ (void)(f); 0LL; }) +#define folio_size(f) ({ (void)(f); PAGE_SIZE; }) +#define folio_unlock(f) do { (void)(f); } while (0) +#define folio_lock(f) do { (void)(f); } while (0) +#define folio_buffers(f) ({ (void)(f); (struct buffer_head *)NULL; }) +#define virt_to_folio(p) ({ (void)(p); (struct folio *)NULL; }) +#define folio_zero_tail(f, off, kaddr) ({ (void)(f); (void)(off); (void)(kaddr); (void *)NULL; }) +#define folio_zero_segment(f, s, e) do { (void)(f); (void)(s); (void)(e); } while (0) +#define folio_zero_segments(f, s1, e1, s2, e2) do { } while (0) +#define folio_zero_new_buffers(f, f2, t) do { } while (0) +#define folio_wait_stable(f) do { } while (0) +#define folio_zero_range(f, s, l) do { } while (0) +#define folio_mark_uptodate(f) do { } while (0) +#define folio_next_index(f) ((f)->index + 1) +#define folio_next_pos(f) ((loff_t)folio_next_index(f) << PAGE_SHIFT) +#define folio_mapped(f) (0) +#define fgf_set_order(size) (0) +#define folio_clear_dirty_for_io(f) ({ (void)(f); 1; }) +#define folio_clear_uptodate(f) do { } while (0) +#define folio_nr_pages(f) (1UL) +#define folio_contains(f, idx) ({ (void)(f); (void)(idx); 1; }) +#define folio_clear_checked(f) do { } while (0) +#define folio_test_dirty(f) (0) +#define folio_test_writeback(f) (0) +#define folio_wait_writeback(f) do { } while (0) +#define folio_clear_dirty(f) do { } while (0) +#define folio_test_checked(f) (0) +#define folio_maybe_dma_pinned(f) (0) +#define folio_set_checked(f) do { } while (0) +#define folio_test_locked(f) (0) +#define folio_mkclean(f) (0) +#define page_folio(page) ((struct folio *)(page)) +#define folio_address(folio) ((folio)->data) +#define folio_trylock(f) ({ (void)(f); 1; }) + +/* Folio writeback operations */ +#define folio_end_writeback(f) do { (void)(f); } while (0) +#define folio_start_writeback(f) do { (void)(f); } while (0) +#define folio_start_writeback_keepwrite(f) do { (void)(f); } while (0) +#define folio_end_read(f, success) do { (void)(f); (void)(success); } while (0) +#define folio_set_mappedtodisk(f) do { (void)(f); } while (0) +#define folio_redirty_for_writepage(wbc, folio) \ + ({ (void)(wbc); (void)(folio); false; }) + +/* + * offset_in_folio - calculate offset of pointer within folio's data + * + * In Linux this uses page alignment, but in U-Boot we use the folio's + * actual data pointer since our buffers are malloc'd. + */ +#define offset_in_folio(f, p) ((f) ? (unsigned int)((uintptr_t)(p) - (uintptr_t)(f)->data) : 0U) + +/* folio_set_bh - associate buffer_head with folio */ +#define folio_set_bh(bh, f, off) do { if ((bh) && (f)) { (bh)->b_folio = (f); (bh)->b_data = (char *)(f)->data + (off); } } while (0) + +#define memcpy_from_folio(dst, f, off, len) do { (void)(dst); (void)(f); (void)(off); (void)(len); } while (0) + +/* kmap/kunmap for folio access */ +#define kmap_local_folio(folio, off) ((folio) ? (char *)(folio)->data + (off) : NULL) +#define kunmap_local(addr) do { (void)(addr); } while (0) + +/* mapping_gfp_mask - get GFP mask for address_space */ +#define mapping_gfp_mask(m) ({ (void)(m); GFP_KERNEL; }) + +/* mapping_large_folio_support stub */ +#define mapping_large_folio_support(m) (0) + +/* Filemap operations - stubs */ +#define filemap_get_folios(m, i, e, fb) ({ (void)(m); (void)(i); (void)(e); (void)(fb); 0U; }) +#define filemap_get_folio(m, i) ((struct folio *)NULL) +#define filemap_get_folios_tag(m, s, e, t, fb) \ + ({ (void)(m); (void)(s); (void)(e); (void)(t); (void)(fb); 0U; }) +#define filemap_lock_folio(m, i) ((struct folio *)NULL) +#define filemap_dirty_folio(m, f) ({ (void)(m); (void)(f); false; }) +#define filemap_invalidate_lock(m) do { } while (0) +#define filemap_invalidate_unlock(m) do { } while (0) +#define filemap_invalidate_lock_shared(m) do { } while (0) +#define filemap_invalidate_unlock_shared(m) do { } while (0) +#define filemap_write_and_wait_range(m, s, e) ({ (void)(m); (void)(s); (void)(e); 0; }) +#define filemap_fdatawrite_range(m, s, e) ({ (void)(m); (void)(s); (void)(e); 0; }) +#define filemap_flush(m) ({ (void)(m); 0; }) +#define filemap_write_and_wait(m) ({ (void)(m); 0; }) +#define filemap_release_folio(folio, gfp) ({ (void)(folio); (void)(gfp); 1; }) +#define mapping_tagged(m, t) (0) +#define tag_pages_for_writeback(m, s, e) do { } while (0) +#define mapping_gfp_constraint(m, g) (g) +#define mapping_set_folio_order_range(m, l, h) do { } while (0) +#define filemap_splice_read(i, p, pi, l, f) ({ (void)(i); (void)(p); (void)(pi); (void)(l); (void)(f); 0L; }) +#define mapping_max_folio_order(m) ({ (void)(m); 0; }) + +/* Truncation stubs */ +#define truncate_pagecache(i, s) do { } while (0) +#define truncate_inode_pages(m, s) do { } while (0) +#define truncate_inode_pages_final(m) do { } while (0) +#define truncate_pagecache_range(i, s, e) do { } while (0) +#define truncate_inode_pages_range(m, s, e) do { (void)(m); (void)(s); (void)(e); } while (0) +#define pagecache_isize_extended(i, f, t) do { } while (0) +#define invalidate_mapping_pages(m, s, e) do { (void)(m); (void)(s); (void)(e); } while (0) + +/* Filemap fault handlers */ +static inline vm_fault_t filemap_fault(struct vm_fault *vmf) +{ + return 0; +} + +static inline vm_fault_t filemap_map_pages(struct vm_fault *vmf, + pgoff_t start, pgoff_t end) +{ + return 0; +} + +/* readahead_control stub */ +struct readahead_control { + struct address_space *mapping; + struct file *file; + unsigned long _index; + unsigned int _batch_count; +}; + +#define readahead_pos(rac) ({ (void)(rac); 0LL; }) +#define readahead_length(rac) ({ (void)(rac); 0UL; }) +#define readahead_count(rac) ({ (void)(rac); 0UL; }) +#define readahead_folio(rac) ({ (void)(rac); (struct folio *)NULL; }) +#define page_cache_sync_readahead(m, ra, f, i, n) do { } while (0) +#define ra_has_index(ra, idx) ({ (void)(ra); (void)(idx); 0; }) + +/* Stub implementations for address_space_operations callbacks */ +static inline bool block_is_partially_uptodate(struct folio *folio, + size_t from, size_t count) +{ + return false; +} + +static inline int generic_error_remove_folio(struct address_space *mapping, + struct folio *folio) +{ + return 0; +} + +/* writeback_iter stub */ +#define writeback_iter(mapping, wbc, folio, error) \ + ({ (void)(mapping); (void)(wbc); (void)(error); (struct folio *)NULL; }) + +#endif /* _LINUX_PAGEMAP_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move filesystem context and parameter parsing stubs to dedicated header files that mirror the Linux kernel organisation. fs_context.h provides: - enum fs_context_purpose - struct fs_context_operations - struct file_system_type with FS_* flags - struct fs_context - struct fs_parameter - get_tree_bdev(), get_tree_nodev(), kill_block_super() stubs fs_parser.h provides: - struct constant_table - struct fs_parameter_spec with fs_param_is_* constants - struct fs_parse_result - fsparam_*() macros for mount option specification - fs_parse() and fs_lookup_param() stubs These are stubs for U-Boot since filesystem mounting is simpler than in the Linux kernel, but they allow ext4l code to compile. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 150 +----------------------------------- include/linux/fs_context.h | 154 +++++++++++++++++++++++++++++++++++++ include/linux/fs_parser.h | 110 ++++++++++++++++++++++++++ 3 files changed, 266 insertions(+), 148 deletions(-) create mode 100644 include/linux/fs_context.h create mode 100644 include/linux/fs_parser.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index b49e6604589..a1047607e79 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -84,6 +84,8 @@ #include <linux/jiffies.h> #include <linux/blkdev.h> #include <linux/blk_types.h> +#include <linux/fs_context.h> +#include <linux/fs_parser.h> /* atomic_dec_if_positive, atomic_add_unless, etc. are now in asm-generic/atomic.h */ @@ -1302,88 +1304,11 @@ static inline const char *simple_get_link(struct dentry *dentry, * Additional stubs for super.c */ -/* fs_context and fs_parser stubs */ -struct constant_table { - const char *name; - int value; -}; - -struct fs_parameter_spec { - const char *name; - int opt; - unsigned short type; - const struct constant_table *data; -}; - -/* fs_parameter spec types */ -#define fs_param_is_flag 0 -#define fs_param_is_u32 1 -#define fs_param_is_s32 2 -#define fs_param_is_u64 3 -#define fs_param_is_enum 4 -#define fs_param_is_string 5 -#define fs_param_is_blob 6 -#define fs_param_is_fd 7 -#define fs_param_is_uid 8 -#define fs_param_is_gid 9 -#define fs_param_is_blockdev 10 - -/* fsparam_* macros for mount option parsing - use literal values */ -#define fsparam_flag(name, opt) \ - {(name), (opt), 0, NULL} -#define fsparam_u32(name, opt) \ - {(name), (opt), 1, NULL} -#define fsparam_s32(name, opt) \ - {(name), (opt), 2, NULL} -#define fsparam_u64(name, opt) \ - {(name), (opt), 3, NULL} -#define fsparam_string(name, opt) \ - {(name), (opt), 5, NULL} -#define fsparam_string_empty(name, opt) \ - {(name), (opt), 5, NULL} -#define fsparam_enum(name, opt, array) \ - {(name), (opt), 4, (array)} -#define fsparam_bdev(name, opt) \ - {(name), (opt), 10, NULL} -#define fsparam_uid(name, opt) \ - {(name), (opt), 8, NULL} -#define fsparam_gid(name, opt) \ - {(name), (opt), 9, NULL} -#define __fsparam(type, name, opt, flags, data) \ - {(name), (opt), (type), (data)} - /* Quota format constants */ #define QFMT_VFS_OLD 1 #define QFMT_VFS_V0 2 #define QFMT_VFS_V1 4 -struct fs_context; -struct fs_parameter; - -struct fs_context_operations { - int (*parse_param)(struct fs_context *, struct fs_parameter *); - int (*get_tree)(struct fs_context *); - int (*reconfigure)(struct fs_context *); - void (*free)(struct fs_context *); -}; - -struct file_system_type { - struct module *owner; - const char *name; - int (*init_fs_context)(struct fs_context *); - const struct fs_parameter_spec *parameters; - void (*kill_sb)(struct super_block *); - int fs_flags; - struct list_head fs_supers; -}; - -#define FS_REQUIRES_DEV 1 -#define FS_BINARY_MOUNTDATA 2 -#define FS_HAS_SUBTYPE 4 -#define FS_USERNS_MOUNT 8 -#define FS_DISALLOW_NOTIFY_PERM 16 -#define FS_ALLOW_IDMAP 32 - /* Buffer read sync */ static inline void end_buffer_read_sync(struct buffer_head *bh, int uptodate) { @@ -1510,82 +1435,11 @@ struct kstatfs { #define EXT4_GOING_FLAGS_LOGFLUSH 1 #define EXT4_GOING_FLAGS_NOLOGFLUSH 2 -/* fs_context stubs */ -/* fs_context_purpose - what the context is for */ -enum fs_context_purpose { - FS_CONTEXT_FOR_MOUNT, - FS_CONTEXT_FOR_SUBMOUNT, - FS_CONTEXT_FOR_RECONFIGURE, -}; - -struct fs_context { - const struct fs_context_operations *ops; - struct file_system_type *fs_type; - void *fs_private; - struct dentry *root; - struct user_namespace *user_ns; - void *s_fs_info; /* Filesystem specific info */ - unsigned int sb_flags; - unsigned int sb_flags_mask; - unsigned int lsm_flags; - enum fs_context_purpose purpose; - bool sloppy; - bool silent; -}; - /* ext4 superblock initialisation and commit */ int ext4_fill_super(struct super_block *sb, struct fs_context *fc); int ext4_commit_super(struct super_block *sb); void ext4_unregister_li_request(struct super_block *sb); -/* fs_parameter stubs */ -struct fs_parameter { - const char *key; - int type; - size_t size; - int dirfd; - union { - char *string; - int boolean; - int integer; - }; -}; - -/* fs_value types - result type from parsing */ -enum fs_value_type { - fs_value_is_undefined, - fs_value_is_flag, - fs_value_is_string, - fs_value_is_blob, - fs_value_is_filename, - fs_value_is_file, -}; - -/* fs_parse_result - result of parsing a parameter */ -struct fs_parse_result { - bool negated; - union { - bool boolean; - int int_32; - unsigned int uint_32; - u64 uint_64; - kuid_t uid; - kgid_t gid; - }; -}; - -/* fs_parse stubs */ -#define fs_parse(fc, desc, param, result) ({ (void)(fc); (void)(desc); (void)(param); (void)(result); -ENOPARAM; }) -#define ENOPARAM 519 -#define fs_lookup_param(fc, p, bdev, fl, path) ({ (void)(fc); (void)(p); (void)(bdev); (void)(fl); (void)(path); -EINVAL; }) - -/* get_tree helpers */ -#define get_tree_bdev(fc, fill_super) ({ (void)(fc); (void)(fill_super); -ENODEV; }) -#define get_tree_nodev(fc, fill_super) ({ (void)(fc); (void)(fill_super); -ENODEV; }) - -/* kill_sb helpers */ -#define kill_block_super(sb) do { } while (0) - /* prandom */ #define get_random_u32() 0 #define prandom_u32_max(max) 0 diff --git a/include/linux/fs_context.h b/include/linux/fs_context.h new file mode 100644 index 00000000000..66cb462c656 --- /dev/null +++ b/include/linux/fs_context.h @@ -0,0 +1,154 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Filesystem context stubs for U-Boot + * + * Based on Linux fs_context.h - U-Boot doesn't have real mount contexts, + * so these are stubs for compilation. + */ +#ifndef _LINUX_FS_CONTEXT_H +#define _LINUX_FS_CONTEXT_H + +#include <linux/types.h> +#include <linux/list.h> + +/* Forward declarations */ +struct dentry; +struct fs_parameter; +struct module; +struct super_block; +struct user_namespace; + +/** + * enum fs_context_purpose - what the context is for + * @FS_CONTEXT_FOR_MOUNT: New superblock for explicit mount + * @FS_CONTEXT_FOR_SUBMOUNT: New superblock for automatic submount + * @FS_CONTEXT_FOR_RECONFIGURE: Superblock reconfiguration (remount) + */ +enum fs_context_purpose { + FS_CONTEXT_FOR_MOUNT, + FS_CONTEXT_FOR_SUBMOUNT, + FS_CONTEXT_FOR_RECONFIGURE, +}; + +/** + * enum fs_value_type - type of parameter value + * @fs_value_is_undefined: Value not specified + * @fs_value_is_flag: Value not given a value + * @fs_value_is_string: Value is a string + * @fs_value_is_blob: Value is a binary blob + * @fs_value_is_filename: Value is a filename + dirfd + * @fs_value_is_file: Value is a file pointer + */ +enum fs_value_type { + fs_value_is_undefined, + fs_value_is_flag, + fs_value_is_string, + fs_value_is_blob, + fs_value_is_filename, + fs_value_is_file, +}; + +struct fs_context; + +/** + * struct fs_context_operations - filesystem context operations + * @parse_param: parse a single parameter + * @get_tree: get the superblock + * @reconfigure: reconfigure the superblock + * @free: free the context + */ +struct fs_context_operations { + int (*parse_param)(struct fs_context *, struct fs_parameter *); + int (*get_tree)(struct fs_context *); + int (*reconfigure)(struct fs_context *); + void (*free)(struct fs_context *); +}; + +/** + * struct file_system_type - filesystem type descriptor + * @owner: module owner + * @name: filesystem name + * @init_fs_context: initialise a filesystem context + * @parameters: mount parameter specification + * @kill_sb: destroy a superblock + * @fs_flags: filesystem flags + * @fs_supers: list of superblocks of this type + */ +struct file_system_type { + struct module *owner; + const char *name; + int (*init_fs_context)(struct fs_context *); + const struct fs_parameter_spec *parameters; + void (*kill_sb)(struct super_block *); + int fs_flags; + struct list_head fs_supers; +}; + +/* Filesystem type flags */ +#define FS_REQUIRES_DEV 1 +#define FS_BINARY_MOUNTDATA 2 +#define FS_HAS_SUBTYPE 4 +#define FS_USERNS_MOUNT 8 +#define FS_DISALLOW_NOTIFY_PERM 16 +#define FS_ALLOW_IDMAP 32 + +/** + * struct fs_context - filesystem context for mount/reconfigure + * @ops: operations for this context + * @fs_type: filesystem type + * @fs_private: filesystem private data + * @root: root dentry (for reconfigure) + * @user_ns: user namespace for this mount + * @s_fs_info: proposed s_fs_info + * @sb_flags: proposed superblock flags + * @sb_flags_mask: superblock flags that changed + * @lsm_flags: LSM flags + * @purpose: what this context is for + * @sloppy: permit unrecognised options + * @silent: suppress mount errors + */ +struct fs_context { + const struct fs_context_operations *ops; + struct file_system_type *fs_type; + void *fs_private; + struct dentry *root; + struct user_namespace *user_ns; + void *s_fs_info; + unsigned int sb_flags; + unsigned int sb_flags_mask; + unsigned int lsm_flags; + enum fs_context_purpose purpose; + bool sloppy; + bool silent; +}; + +/** + * struct fs_parameter - filesystem mount parameter + * @key: parameter name + * @type: value type + * @size: size of value + * @dirfd: directory fd for filename values + * @string: string value + * @boolean: boolean value + * @integer: integer value + */ +struct fs_parameter { + const char *key; + int type; + size_t size; + int dirfd; + union { + char *string; + int boolean; + int integer; + }; +}; + +/* get_tree helpers - stubs */ +#define get_tree_bdev(fc, fill_super) ({ (void)(fc); (void)(fill_super); -ENODEV; }) +#define get_tree_nodev(fc, fill_super) ({ (void)(fc); (void)(fill_super); -ENODEV; }) + +/* kill_sb helpers - stubs */ +#define kill_block_super(sb) do { } while (0) + +#endif /* _LINUX_FS_CONTEXT_H */ diff --git a/include/linux/fs_parser.h b/include/linux/fs_parser.h new file mode 100644 index 00000000000..b3f1014fb98 --- /dev/null +++ b/include/linux/fs_parser.h @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Filesystem parameter parser stubs for U-Boot + * + * Based on Linux fs_parser.h - U-Boot doesn't have real mount option + * parsing, so these are stubs for compilation. + */ +#ifndef _LINUX_FS_PARSER_H +#define _LINUX_FS_PARSER_H + +#include <linux/fs_context.h> + +/** + * struct constant_table - table of named constants + * @name: constant name + * @value: constant value + */ +struct constant_table { + const char *name; + int value; +}; + +/** + * struct fs_parameter_spec - mount parameter specification + * @name: parameter name + * @opt: option number returned by fs_parse() + * @type: parameter type (fs_param_is_* constants) + * @data: type-specific data (e.g., enum table) + */ +struct fs_parameter_spec { + const char *name; + int opt; + unsigned short type; + const struct constant_table *data; +}; + +/* fs_parameter spec types - simplified numeric types for U-Boot */ +#define fs_param_is_flag 0 +#define fs_param_is_u32 1 +#define fs_param_is_s32 2 +#define fs_param_is_u64 3 +#define fs_param_is_enum 4 +#define fs_param_is_string 5 +#define fs_param_is_blob 6 +#define fs_param_is_fd 7 +#define fs_param_is_uid 8 +#define fs_param_is_gid 9 +#define fs_param_is_blockdev 10 + +/** + * struct fs_parse_result - result of parsing a parameter + * @negated: true if param was "noxxx" + * @boolean: boolean result + * @int_32: 32-bit signed integer result + * @uint_32: 32-bit unsigned integer result + * @uint_64: 64-bit unsigned integer result + * @uid: UID result + * @gid: GID result + */ +struct fs_parse_result { + bool negated; + union { + bool boolean; + int int_32; + unsigned int uint_32; + u64 uint_64; + kuid_t uid; + kgid_t gid; + }; +}; + +/* + * fsparam_* macros for mount option parsing - use literal type values + * These macros build fs_parameter_spec entries. + */ +#define fsparam_flag(name, opt) \ + {(name), (opt), 0, NULL} +#define fsparam_u32(name, opt) \ + {(name), (opt), 1, NULL} +#define fsparam_s32(name, opt) \ + {(name), (opt), 2, NULL} +#define fsparam_u64(name, opt) \ + {(name), (opt), 3, NULL} +#define fsparam_string(name, opt) \ + {(name), (opt), 5, NULL} +#define fsparam_string_empty(name, opt) \ + {(name), (opt), 5, NULL} +#define fsparam_enum(name, opt, array) \ + {(name), (opt), 4, (array)} +#define fsparam_bdev(name, opt) \ + {(name), (opt), 10, NULL} +#define fsparam_uid(name, opt) \ + {(name), (opt), 8, NULL} +#define fsparam_gid(name, opt) \ + {(name), (opt), 9, NULL} +#define __fsparam(type, name, opt, flags, data) \ + {(name), (opt), (type), (data)} + +/* ENOPARAM - parameter not found */ +#define ENOPARAM 519 + +/* fs_parse - parse a mount option - stub */ +#define fs_parse(fc, desc, param, result) \ + ({ (void)(fc); (void)(desc); (void)(param); (void)(result); -ENOPARAM; }) + +/* fs_lookup_param - lookup parameter path - stub */ +#define fs_lookup_param(fc, p, bdev, fl, path) \ + ({ (void)(fc); (void)(p); (void)(bdev); (void)(fl); (void)(path); -EINVAL; }) + +#endif /* _LINUX_FS_PARSER_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move UUID and GUID type definitions to a dedicated header file that mirrors the Linux kernel organisation. uuid.h provides: - uuid_t type for big-endian UUIDs - guid_t type for little-endian GUIDs - UUID_SIZE and UUID_STRING_LEN constants - GUID_INIT() and UUID_INIT() macros - Comparison functions: guid_equal(), uuid_equal() - Copy functions: guid_copy(), uuid_copy() - Import/export: import_uuid(), export_uuid() These types are used by ext4l for filesystem UUID handling. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 6 +-- include/linux/uuid.h | 120 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 122 insertions(+), 4 deletions(-) create mode 100644 include/linux/uuid.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 9423c92169e..3ce94750fcf 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -87,6 +87,7 @@ #include <linux/fs_context.h> #include <linux/fs_parser.h> #include <linux/dcache.h> +#include <linux/uuid.h> /* atomic_dec_if_positive, atomic_add_unless, etc. are now in asm-generic/atomic.h */ @@ -490,10 +491,7 @@ struct fstrim_range { /* SB_RDONLY, SB_I_VERSION, etc. superblock flags are in linux/fs.h */ -/* UUID type */ -typedef struct { - __u8 b[16]; -} uuid_t; +/* uuid_t is now in linux/uuid.h */ /* Forward declarations for super_block */ struct super_operations; diff --git a/include/linux/uuid.h b/include/linux/uuid.h new file mode 100644 index 00000000000..810cf1d735d --- /dev/null +++ b/include/linux/uuid.h @@ -0,0 +1,120 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * UUID/GUID definitions for U-Boot + * + * Based on Linux uuid.h + */ +#ifndef _LINUX_UUID_H_ +#define _LINUX_UUID_H_ + +#include <linux/types.h> +#include <linux/string.h> + +#define UUID_SIZE 16 + +/** + * typedef guid_t - GUID type (little-endian) + * + * GUIDs are stored in little-endian byte order. + */ +typedef struct { + __u8 b[UUID_SIZE]; +} guid_t; + +/** + * typedef uuid_t - UUID type (big-endian / network order) + * + * UUIDs are stored in big-endian byte order. + */ +typedef struct { + __u8 b[UUID_SIZE]; +} uuid_t; + +/** + * GUID_INIT - initialise a GUID (little-endian) + */ +#define GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ +((guid_t) \ +{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \ + (b) & 0xff, ((b) >> 8) & 0xff, \ + (c) & 0xff, ((c) >> 8) & 0xff, \ + (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}) + +/** + * UUID_INIT - initialise a UUID (big-endian) + */ +#define UUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ +((uuid_t) \ +{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff, ((a) >> 8) & 0xff, (a) & 0xff, \ + ((b) >> 8) & 0xff, (b) & 0xff, \ + ((c) >> 8) & 0xff, (c) & 0xff, \ + (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}) + +/* Length of UUID string without NUL */ +#define UUID_STRING_LEN 36 + +/** + * guid_equal - compare two GUIDs + * @u1: first GUID + * @u2: second GUID + * + * Return: true if equal, false otherwise + */ +static inline bool guid_equal(const guid_t *u1, const guid_t *u2) +{ + return memcmp(u1, u2, sizeof(guid_t)) == 0; +} + +/** + * guid_copy - copy a GUID + * @dst: destination + * @src: source + */ +static inline void guid_copy(guid_t *dst, const guid_t *src) +{ + memcpy(dst, src, sizeof(guid_t)); +} + +/** + * uuid_equal - compare two UUIDs + * @u1: first UUID + * @u2: second UUID + * + * Return: true if equal, false otherwise + */ +static inline bool uuid_equal(const uuid_t *u1, const uuid_t *u2) +{ + return memcmp(u1, u2, sizeof(uuid_t)) == 0; +} + +/** + * uuid_copy - copy a UUID + * @dst: destination + * @src: source + */ +static inline void uuid_copy(uuid_t *dst, const uuid_t *src) +{ + memcpy(dst, src, sizeof(uuid_t)); +} + +/** + * import_uuid - import a UUID from raw bytes + * @dst: destination UUID + * @src: source bytes + */ +static inline void import_uuid(uuid_t *dst, const __u8 *src) +{ + memcpy(dst, src, sizeof(uuid_t)); +} + +/** + * export_uuid - export a UUID to raw bytes + * @dst: destination bytes + * @src: source UUID + */ +static inline void export_uuid(__u8 *dst, const uuid_t *src) +{ + memcpy(dst, src, sizeof(uuid_t)); +} + +#endif /* _LINUX_UUID_H_ */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move SMP-related stubs to a dedicated header file that mirrors the Linux kernel organisation. smp.h provides: - raw_smp_processor_id() and smp_processor_id() - always return 0 - smp_rmb(), smp_wmb(), smp_mb() - memory barriers (no-ops) - smp_mb__after_atomic() - post-atomic memory barrier (no-op) These are all stubs since U-Boot is single-threaded. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 13 +++------- include/linux/smp.h | 60 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 9 deletions(-) create mode 100644 include/linux/smp.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index f26006f9291..57d967965da 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -88,13 +88,11 @@ #include <linux/fs_parser.h> #include <linux/dcache.h> #include <linux/uuid.h> +#include <linux/smp.h> /* atomic_dec_if_positive, atomic_add_unless, etc. are now in asm-generic/atomic.h */ - -/* SMP stubs - U-Boot is single-threaded */ -#define raw_smp_processor_id() 0 - /* cmpxchg is now in asm-generic/atomic.h */ +/* SMP stubs (raw_smp_processor_id, smp_*mb) are now in linux/smp.h */ /* Reference count type */ typedef struct { atomic_t refs; } refcount_t; @@ -255,10 +253,7 @@ struct buffer_head *sb_getblk(struct super_block *sb, sector_t block); /* inode_needs_sync - stub */ #define inode_needs_sync(inode) (0) -/* Memory barriers - stubs for single-threaded */ -#define smp_rmb() do { } while (0) -#define smp_wmb() do { } while (0) -#define smp_mb() do { } while (0) +/* Memory barriers are now in linux/smp.h */ /* * set_bit/clear_bit are declared extern in asm/bitops.h but not implemented. @@ -1897,7 +1892,7 @@ struct wait_bit_entry { /* JBD2 commit.c stubs (folio_trylock is in linux/pagemap.h) */ #define clear_bit_unlock(nr, addr) clear_bit(nr, addr) -#define smp_mb__after_atomic() do { } while (0) +/* smp_mb__after_atomic is now in linux/smp.h */ #define ktime_get_coarse_real_ts64(ts) do { (ts)->tv_sec = 0; (ts)->tv_nsec = 0; } while (0) #define filemap_fdatawait_range_keep_errors(m, s, e) \ ({ (void)(m); (void)(s); (void)(e); 0; }) diff --git a/include/linux/smp.h b/include/linux/smp.h new file mode 100644 index 00000000000..15fb7fa656f --- /dev/null +++ b/include/linux/smp.h @@ -0,0 +1,60 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * SMP stubs for U-Boot + * + * U-Boot is single-threaded, so all SMP operations are stubs. + */ +#ifndef _LINUX_SMP_H +#define _LINUX_SMP_H + +#include <linux/types.h> + +/** + * raw_smp_processor_id() - get current processor ID + * + * U-Boot stub - always returns 0 (single CPU). + */ +#define raw_smp_processor_id() 0 + +/** + * smp_processor_id() - get current processor ID + * + * U-Boot stub - always returns 0 (single CPU). + */ +#define smp_processor_id() 0 + +/* Memory barriers - stubs for single-threaded U-Boot */ + +/** + * smp_rmb() - read memory barrier + * + * Ensures that all reads before this point are completed before + * any reads after this point. No-op in single-threaded U-Boot. + */ +#define smp_rmb() do { } while (0) + +/** + * smp_wmb() - write memory barrier + * + * Ensures that all writes before this point are completed before + * any writes after this point. No-op in single-threaded U-Boot. + */ +#define smp_wmb() do { } while (0) + +/** + * smp_mb() - full memory barrier + * + * Ensures that all memory operations before this point are completed + * before any memory operations after this point. No-op in single-threaded + * U-Boot. + */ +#define smp_mb() do { } while (0) + +/** + * smp_mb__after_atomic() - memory barrier after atomic operation + * + * No-op in single-threaded U-Boot. + */ +#define smp_mb__after_atomic() do { } while (0) + +#endif /* _LINUX_SMP_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move kobject type and related stubs to a dedicated header file that mirrors the Linux kernel organisation. kobject.h provides: - struct kobject with minimal fields (just name) - kobject_put() declaration - super_set_sysfs_name_bdev() stub macro These are minimal stubs since U-Boot doesn't have sysfs or the full kobject infrastructure. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 11 ++++------- include/linux/kobject.h | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 7 deletions(-) create mode 100644 include/linux/kobject.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 4fe7d40c37f..655d64398d5 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -112,10 +112,8 @@ typedef struct { unsigned int val; } kprojid_t; #define from_kprojid(ns, kprojid) ((kprojid).val) #define projid_eq(a, b) ((a).val == (b).val) -/* kobject - stub */ -struct kobject { - const char *name; -}; +/* kobject is now in linux/kobject.h */ +#include <linux/kobject.h> /* lockdep stubs - needed before jbd2.h is included */ #include <linux/lockdep.h> @@ -1489,8 +1487,7 @@ struct block_device *file_bdev(struct file *file); int sync_blockdev(struct block_device *bdev); void invalidate_bdev(struct block_device *bdev); -/* Kobject - declarations for stub.c */ -void kobject_put(struct kobject *kobj); +/* kobject_put is now in linux/kobject.h */ /* wait_for_completion is now a macro in linux/completion.h */ /* DAX - declaration for stub.c */ @@ -1591,7 +1588,7 @@ static inline void super_set_uuid(struct super_block *sb, const u8 *uuid, memcpy(sb->s_uuid.b, uuid, len); } -#define super_set_sysfs_name_bdev(sb) do { } while (0) +/* super_set_sysfs_name_bdev is now in linux/kobject.h */ /* * mb_cache - metadata block cache stubs for xattr.c diff --git a/include/linux/kobject.h b/include/linux/kobject.h new file mode 100644 index 00000000000..f6427724d00 --- /dev/null +++ b/include/linux/kobject.h @@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Kobject stubs for U-Boot + * + * U-Boot doesn't have sysfs or the full kobject infrastructure, + * so these are minimal stubs. + */ +#ifndef _LINUX_KOBJECT_H +#define _LINUX_KOBJECT_H + +#include <linux/types.h> + +/** + * struct kobject - kernel object + * @name: name of the object + * + * U-Boot stub - minimal structure for filesystem code. + */ +struct kobject { + const char *name; +}; + +/** + * kobject_put() - decrement refcount on kobject + * @kobj: object to release + * + * U-Boot stub - declared here, implemented in stub.c. + */ +void kobject_put(struct kobject *kobj); + +/* sysfs stubs */ +#define super_set_sysfs_name_bdev(sb) do { } while (0) + +#endif /* _LINUX_KOBJECT_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move memory pool type and operation stubs to a dedicated header file that mirrors the Linux kernel organisation. mempool.h provides: - mempool_t type - mempool_alloc() - allocate from pool (stub returns NULL) - mempool_free() - free to pool (stub no-op) - mempool_create_slab_pool() - create pool (stub returns NULL) - mempool_destroy() - destroy pool (stub no-op) These are stubs since U-Boot doesn't use memory pools. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 8 ++---- include/linux/mempool.h | 57 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+), 6 deletions(-) create mode 100644 include/linux/mempool.h diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index 97bcc48d922..f77891835cb 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -1795,12 +1795,8 @@ bool __folio_start_writeback(struct folio *folio, bool keep_write); * Stubs for readpage.c */ -/* mempool - memory pool stubs */ -typedef void *mempool_t; -#define mempool_alloc(pool, gfp) ({ (void)(pool); (void)(gfp); (void *)NULL; }) -#define mempool_free(elem, pool) do { (void)(elem); (void)(pool); } while (0) -#define mempool_create_slab_pool(n, c) ({ (void)(n); (void)(c); (mempool_t *)NULL; }) -#define mempool_destroy(pool) do { (void)(pool); } while (0) +/* mempool is now in linux/mempool.h */ +#include <linux/mempool.h> /* folio read operations */ #define folio_end_read(f, success) do { (void)(f); (void)(success); } while (0) diff --git a/include/linux/mempool.h b/include/linux/mempool.h new file mode 100644 index 00000000000..feb99a1455c --- /dev/null +++ b/include/linux/mempool.h @@ -0,0 +1,57 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Memory pool stubs for U-Boot + * + * U-Boot doesn't have memory pools, so these are stubs. + */ +#ifndef _LINUX_MEMPOOL_H +#define _LINUX_MEMPOOL_H + +#include <linux/types.h> + +/** + * typedef mempool_t - memory pool handle + * + * U-Boot stub - memory pools are not used. + */ +typedef void *mempool_t; + +/** + * mempool_alloc() - allocate element from pool + * @pool: memory pool + * @gfp: allocation flags + * + * U-Boot stub - always returns NULL. + */ +#define mempool_alloc(pool, gfp) \ + ({ (void)(pool); (void)(gfp); (void *)NULL; }) + +/** + * mempool_free() - free element back to pool + * @elem: element to free + * @pool: memory pool + * + * U-Boot stub - no-op. + */ +#define mempool_free(elem, pool) \ + do { (void)(elem); (void)(pool); } while (0) + +/** + * mempool_create_slab_pool() - create a memory pool backed by a slab cache + * @min_nr: minimum number of elements + * @cache: slab cache + * + * U-Boot stub - always returns NULL. + */ +#define mempool_create_slab_pool(min_nr, cache) \ + ({ (void)(min_nr); (void)(cache); (mempool_t *)NULL; }) + +/** + * mempool_destroy() - destroy a memory pool + * @pool: memory pool to destroy + * + * U-Boot stub - no-op. + */ +#define mempool_destroy(pool) do { (void)(pool); } while (0) + +#endif /* _LINUX_MEMPOOL_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move block I/O plugging stubs to linux/blkdev.h where they belong in the Linux kernel organisation. Add to blkdev.h: - struct blk_plug - block I/O plug structure - blk_start_plug() - start plugging (stub no-op) - blk_finish_plug() - finish plugging (stub no-op) These are stubs since U-Boot doesn't use block I/O plugging. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- fs/ext4l/ext4_uboot.h | 7 +------ include/linux/blkdev.h | 25 +++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 6 deletions(-) diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index aa357599449..979af9ed22a 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -925,12 +925,7 @@ static inline xa_mark_t wbc_to_tag(struct writeback_control *wbc) return PAGECACHE_TAG_DIRTY; } -/* blk_plug - block I/O plugging stub */ -struct blk_plug { - int dummy; -}; -#define blk_start_plug(p) do { (void)(p); } while (0) -#define blk_finish_plug(p) do { (void)(p); } while (0) +/* blk_plug is now in linux/blkdev.h */ /* Writeback reasons */ #define WB_REASON_FS_FREE_SPACE 0 diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index 92878b01c3e..8c848139a7e 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -18,4 +18,29 @@ struct gendisk; /* Block size helpers */ #define bdev_logical_block_size(bdev) 512 +/** + * struct blk_plug - block I/O plug + * + * U-Boot stub - block I/O plugging is not used. + */ +struct blk_plug { + int dummy; +}; + +/** + * blk_start_plug() - start plugging block I/O + * @plug: plug structure + * + * U-Boot stub - no-op. + */ +#define blk_start_plug(plug) do { (void)(plug); } while (0) + +/** + * blk_finish_plug() - finish plugging and submit I/O + * @plug: plug structure + * + * U-Boot stub - no-op. + */ +#define blk_finish_plug(plug) do { (void)(plug); } while (0) + #endif /* _LINUX_BLKDEV_H */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move xchg and try_cmpxchg macros to asm-generic/atomic.h alongside cmpxchg, as they are all atomic exchange operations. Add: - try_cmpxchg() - compare and exchange with boolean return and old value update on failure - xchg() - atomic exchange, stores new value and returns old These are single-threaded implementations for U-Boot. Add #ifndef guards to all three macros (cmpxchg, try_cmpxchg, xchg) to avoid redefinition warnings on architectures like MIPS that provide their own implementations. Signed-off-by: Simon Glass <simon.glass@canonical.com> Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> --- fs/ext4l/ext4_uboot.h | 12 ++---------- include/asm-generic/atomic.h | 37 ++++++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 10 deletions(-) diff --git a/fs/ext4l/ext4_uboot.h b/fs/ext4l/ext4_uboot.h index a4d863b86e1..a4baac6fc86 100644 --- a/fs/ext4l/ext4_uboot.h +++ b/fs/ext4l/ext4_uboot.h @@ -949,14 +949,7 @@ typedef unsigned int projid_t; * Additional stubs for inode.c */ -/* try_cmpxchg - compare and exchange with return value */ -#define try_cmpxchg(ptr, old, new) ({ \ - typeof(*(old)) __old = *(old); \ - typeof(*(ptr)) __ret = cmpxchg(ptr, __old, (new)); \ - if (__ret != __old) \ - *(old) = __ret; \ - __ret == __old; \ -}) +/* try_cmpxchg is now in asm-generic/atomic.h */ /* hash_64 - simple 64-bit hash */ #define hash_64(val, bits) ((unsigned long)((val) >> (64 - (bits)))) @@ -1743,8 +1736,7 @@ static inline unsigned long ext4_find_next_bit_le(const void *addr, /* refcount operations are now in linux/refcount.h */ -/* xchg - exchange value atomically */ -#define xchg(ptr, new) ({ typeof(*(ptr)) __old = *(ptr); *(ptr) = (new); __old; }) +/* xchg is now in asm-generic/atomic.h */ /* printk_ratelimited is in linux/printk.h */ diff --git a/include/asm-generic/atomic.h b/include/asm-generic/atomic.h index 3fa749bf012..3f72ae39ee1 100644 --- a/include/asm-generic/atomic.h +++ b/include/asm-generic/atomic.h @@ -209,6 +209,7 @@ static inline void atomic64_dec(volatile atomic64_t *v) * Single-threaded version for U-Boot. Atomically compares *ptr with old * and if equal, stores new. Returns the original value of *ptr. */ +#ifndef cmpxchg #define cmpxchg(ptr, old, new) ({ \ typeof(*(ptr)) __cmpxchg_old = (old); \ typeof(*(ptr)) __cmpxchg_new = (new); \ @@ -217,5 +218,41 @@ static inline void atomic64_dec(volatile atomic64_t *v) *(ptr) = __cmpxchg_new; \ __cmpxchg_ret; \ }) +#endif + +/** + * try_cmpxchg - compare and exchange with boolean return + * @ptr: pointer to the value + * @oldp: pointer to expected old value (updated on failure) + * @new: new value to store if current equals old + * + * Returns true if exchange succeeded, false otherwise. + * On failure, *oldp is updated with the current value. + */ +#ifndef try_cmpxchg +#define try_cmpxchg(ptr, oldp, new) ({ \ + typeof(*(oldp)) __old = *(oldp); \ + typeof(*(ptr)) __ret = cmpxchg(ptr, __old, (new)); \ + if (__ret != __old) \ + *(oldp) = __ret; \ + __ret == __old; \ +}) +#endif + +/** + * xchg - exchange value atomically + * @ptr: pointer to the value + * @new: new value to store + * + * Atomically stores new value and returns the old value. + * Single-threaded version for U-Boot. + */ +#ifndef xchg +#define xchg(ptr, new) ({ \ + typeof(*(ptr)) __xchg_old = *(ptr); \ + *(ptr) = (new); \ + __xchg_old; \ +}) +#endif #endif -- 2.43.0