[PATCH 0/8] u-boot: fs: add generic unaligned read handling
[BACKGROUND] Unlike FUSE/Kernel which always pass aligned read range, U-boot fs code just pass the request range to underlying fses. Under most case, this works fine, as U-boot only really needs to read the whole file (aka, 0 for both offset and len, len will be later determined using file size). But if some advanced user/script wants to extract kernel/initramfs from combined image, we may need to do unaligned read in that case. [ADVANTAGE] This patchset will handle unaligned read range in _fs_read(): - Get blocksize of the underlying fs - Read the leading block contianing the unaligned range The full block will be stored in a local buffer, then only copy the bytes in the unaligned range into the destination buffer. If the first block covers the whole range, we just call it aday. - Read the aligned range if there is any - Read the tailing block containing the unaligned range And copy the covered range into the destination. [DISADVANTAGE] There are mainly two problems: - Extra memory allocation for every _fs_read() call For the leading and tailing block. - Extra path resolving All those supported fs will have to do extra path resolving up to 2 times (one for the leading block, one for the tailing block). This may slow down the read. [SUPPORTED FSES] - Btrfs (manually tested*) - Ext4 (manually tested) - FAT (manually tested) - Erofs - sandboxfs - ubifs *: Failed to get the test cases run, thus have to go sandbox mode, and attach an image with target fs, load the target file (with unaligned range) and compare the result using md5sum. For EXT4/FAT, they may need extra cleanup, as their existing unaligned range handling is no longer needed anymore, cleaning them up should free more code lines than the added one. Just not confident enough to modify them all by myself. [UNSUPPORTED FSES] - Squashfs They don't support non-zero offset, thus it can not handle the tailing block reading. Need extra help to add block aligned offset support. - Semihostfs It's using hardcoded trap to do system calls, not sure how it would work for stat() call. Extra testing/feedback is always appreciated. Qu Wenruo (8): fs: fat: unexport file_fat_read_at() fs: always get the file size in _fs_read() fs: btrfs: move the unaligned read code to _fs_read() for btrfs fs: ext4: rely on _fs_read() to pass block aligned range into ext4fs_read_file() fs: fat: rely on higher layer to get block aligned read range fs: sandboxfs: add sandbox_fs_get_blocksize() fs: ubifs: rely on higher layer to do unaligned read fs: erofs: add unaligned read range handling arch/sandbox/cpu/os.c | 11 +++ fs/btrfs/btrfs.c | 24 +++--- fs/btrfs/inode.c | 84 ++-- fs/erofs/internal.h| 1 + fs/erofs/super.c | 6 ++ fs/ext4/ext4fs.c | 11 +++ fs/fat/fat.c | 17 - fs/fs.c| 169 +++-- fs/sandbox/sandboxfs.c | 14 fs/ubifs/ubifs.c | 13 ++-- include/btrfs.h| 1 + include/erofs.h| 1 + include/ext4fs.h | 1 + include/fat.h | 3 +- include/os.h | 8 ++ include/sandboxfs.h| 1 + include/ubifs_uboot.h | 1 + 17 files changed, 258 insertions(+), 108 deletions(-) -- 2.36.1
Re: [PATCH 0/8] u-boot: fs: add generic unaligned read handling
On 6/28/22 3:28 AM, Qu Wenruo wrote: [BACKGROUND] Unlike FUSE/Kernel which always pass aligned read range, U-boot fs code just pass the request range to underlying fses. Under most case, this works fine, as U-boot only really needs to read the whole file (aka, 0 for both offset and len, len will be later determined using file size). But if some advanced user/script wants to extract kernel/initramfs from combined image, we may need to do unaligned read in that case. [ADVANTAGE] This patchset will handle unaligned read range in _fs_read(): - Get blocksize of the underlying fs - Read the leading block contianing the unaligned range The full block will be stored in a local buffer, then only copy the bytes in the unaligned range into the destination buffer. If the first block covers the whole range, we just call it aday. - Read the aligned range if there is any - Read the tailing block containing the unaligned range And copy the covered range into the destination. [DISADVANTAGE] There are mainly two problems: - Extra memory allocation for every _fs_read() call For the leading and tailing block. - Extra path resolving All those supported fs will have to do extra path resolving up to 2 times (one for the leading block, one for the tailing block). This may slow down the read. [SUPPORTED FSES] - Btrfs (manually tested*) - Ext4 (manually tested) - FAT (manually tested) - Erofs - sandboxfs - ubifs *: Failed to get the test cases run, thus have to go sandbox mode, and attach an image with target fs, load the target file (with unaligned range) and compare the result using md5sum. For EXT4/FAT, they may need extra cleanup, as their existing unaligned range handling is no longer needed anymore, cleaning them up should free more code lines than the added one. Just not confident enough to modify them all by myself. [UNSUPPORTED FSES] - Squashfs They don't support non-zero offset, thus it can not handle the tailing block reading. Need extra help to add block aligned offset support. - Semihostfs It's using hardcoded trap to do system calls, not sure how it would work for stat() call. There are no alignment requirements for semihosted FSs. So you can pass in an unaligned offset and it will work fine. This is because typically the host will call read() and the host OS will do the aligning. --Sean
Re: [PATCH 0/8] u-boot: fs: add generic unaligned read handling
On Tue, Jun 28, 2022 at 03:28:00PM +0800, Qu Wenruo wrote: > [BACKGROUND] > Unlike FUSE/Kernel which always pass aligned read range, U-boot fs code > just pass the request range to underlying fses. > > Under most case, this works fine, as U-boot only really needs to read > the whole file (aka, 0 for both offset and len, len will be later > determined using file size). > > But if some advanced user/script wants to extract kernel/initramfs from > combined image, we may need to do unaligned read in that case. > > [ADVANTAGE] > This patchset will handle unaligned read range in _fs_read(): > > - Get blocksize of the underlying fs > > - Read the leading block contianing the unaligned range > The full block will be stored in a local buffer, then only copy > the bytes in the unaligned range into the destination buffer. > > If the first block covers the whole range, we just call it aday. > > - Read the aligned range if there is any > > - Read the tailing block containing the unaligned range > And copy the covered range into the destination. > > [DISADVANTAGE] > There are mainly two problems: > > - Extra memory allocation for every _fs_read() call > For the leading and tailing block. > > - Extra path resolving > All those supported fs will have to do extra path resolving up to 2 > times (one for the leading block, one for the tailing block). > This may slow down the read. This conceptually seems like a good thing. Can you please post some before/after times of reading large images from the supported filesystems? -- Tom signature.asc Description: PGP signature
Re: [PATCH 0/8] u-boot: fs: add generic unaligned read handling
On 2022/6/28 22:17, Tom Rini wrote: On Tue, Jun 28, 2022 at 03:28:00PM +0800, Qu Wenruo wrote: [BACKGROUND] Unlike FUSE/Kernel which always pass aligned read range, U-boot fs code just pass the request range to underlying fses. Under most case, this works fine, as U-boot only really needs to read the whole file (aka, 0 for both offset and len, len will be later determined using file size). But if some advanced user/script wants to extract kernel/initramfs from combined image, we may need to do unaligned read in that case. [ADVANTAGE] This patchset will handle unaligned read range in _fs_read(): - Get blocksize of the underlying fs - Read the leading block contianing the unaligned range The full block will be stored in a local buffer, then only copy the bytes in the unaligned range into the destination buffer. If the first block covers the whole range, we just call it aday. - Read the aligned range if there is any - Read the tailing block containing the unaligned range And copy the covered range into the destination. [DISADVANTAGE] There are mainly two problems: - Extra memory allocation for every _fs_read() call For the leading and tailing block. - Extra path resolving All those supported fs will have to do extra path resolving up to 2 times (one for the leading block, one for the tailing block). This may slow down the read. This conceptually seems like a good thing. Can you please post some before/after times of reading large images from the supported filesystems? One thing to mention is, this change doesn't really bother large file read. As the patchset is splitting a large read into 3 parts: 1) Leading block 2) Aligned blocks, aka the main part of a large file 3) Tailing block Most time should still be spent on part 2), not much different than the old code. Part 1) and Part 3) are at most 2 blocks (aka, 2 * 4KiB for most modern large enough fses). So I doubt it would make any difference for large file read. Furthermore, as pointed out by Huang Jianan, currently the patchset can not handle read on soft link correctly, thus I'd update the series to do the split into even less parts: 1) Leading block For the unaligned initial block 2) Aligned blocks until the end The tailing block should still starts at a block aligned position, thus most filesystems is already handling them correctly. (Just a min(end, blockend) is enough for most cases already). Anyway, I'll try to craft some benchmarking for file reads using sandbox. But please don't expect much (or any) difference in that case. Thanks, Qu
Re: [PATCH 0/8] u-boot: fs: add generic unaligned read handling
On Wed, Jun 29, 2022 at 09:40:58AM +0800, Qu Wenruo wrote: > > > On 2022/6/28 22:17, Tom Rini wrote: > > On Tue, Jun 28, 2022 at 03:28:00PM +0800, Qu Wenruo wrote: > > > [BACKGROUND] > > > Unlike FUSE/Kernel which always pass aligned read range, U-boot fs code > > > just pass the request range to underlying fses. > > > > > > Under most case, this works fine, as U-boot only really needs to read > > > the whole file (aka, 0 for both offset and len, len will be later > > > determined using file size). > > > > > > But if some advanced user/script wants to extract kernel/initramfs from > > > combined image, we may need to do unaligned read in that case. > > > > > > [ADVANTAGE] > > > This patchset will handle unaligned read range in _fs_read(): > > > > > > - Get blocksize of the underlying fs > > > > > > - Read the leading block contianing the unaligned range > > >The full block will be stored in a local buffer, then only copy > > >the bytes in the unaligned range into the destination buffer. > > > > > >If the first block covers the whole range, we just call it aday. > > > > > > - Read the aligned range if there is any > > > > > > - Read the tailing block containing the unaligned range > > >And copy the covered range into the destination. > > > > > > [DISADVANTAGE] > > > There are mainly two problems: > > > > > > - Extra memory allocation for every _fs_read() call > > >For the leading and tailing block. > > > > > > - Extra path resolving > > >All those supported fs will have to do extra path resolving up to 2 > > >times (one for the leading block, one for the tailing block). > > >This may slow down the read. > > > > This conceptually seems like a good thing. Can you please post some > > before/after times of reading large images from the supported > > filesystems? > > > > One thing to mention is, this change doesn't really bother large file read. > > As the patchset is splitting a large read into 3 parts: > > 1) Leading block > 2) Aligned blocks, aka the main part of a large file > 3) Tailing block > > Most time should still be spent on part 2), not much different than the > old code. Part 1) and Part 3) are at most 2 blocks (aka, 2 * 4KiB for > most modern large enough fses). > > So I doubt it would make any difference for large file read. > > > Furthermore, as pointed out by Huang Jianan, currently the patchset can > not handle read on soft link correctly, thus I'd update the series to do > the split into even less parts: > > 1) Leading block >For the unaligned initial block > > 2) Aligned blocks until the end >The tailing block should still starts at a block aligned position, >thus most filesystems is already handling them correctly. >(Just a min(end, blockend) is enough for most cases already). > > Anyway, I'll try to craft some benchmarking for file reads using sandbox. > But please don't expect much (or any) difference in that case. The rework sounds good. And doing it without any real impact to performance either way is good. -- Tom signature.asc Description: PGP signature
