Add support for symlink creation in EXT4
Subsystems (2)
v5 cover Add support for symlink creation in EXT4
This series adds support for the creation of symbolic links on ext4 file-systems.
The motivation behind this work is to have the ability to "do" the job of update-alternatives in u-boot.
Firmware on TI's platform are usually managed with update-alternatives and are thus targeted by a symbolic link. In some situations we need the ability to select an alternate firmware before the linux kernel is started so that when a early driver needing the firmware comes up, it can be fed the firmware of our choice.
Tested on a am57xx_evm, using a EXT4 partition on external SDcard. The filesystem can be checked later with: fsck.ext4 -f <dev>
usage example:
=> ln mmc 0:2 zImage /boot/the_linux_kernel
Changes in v5:
- Added filesystem integrity checks
- Fix bug in ext4fs_delete_file(). The type must be read from the inode.
Changes in v4:
- replaced u64 and u32 with uint64_t and uint32_t
Changes in v3:
- reworded commit log
- removed FS integrity test (fsck) in python tests
Changes in v2:
- Prevent write access if metadata checksum is enabled
- Fix issue in ext4fs_delete_file() when target in not stored in an allocated block
- Added python tests for symlinks under sandbox
Jean-Jacques Hiblot (7):
fs: ext4: do not allow writes if metadata checksum is active
test: fs: disable the metadata checksums on ext4 filesystems
test: fs: Add filesystem integrity checks
fs: ext4: constify the buffer passed to write functions
fs: ext4: Add support for the creation of symbolic links
fs: Add a new command to create symbolic links
test: fs: Added tests for symlinks
cmd/fs.c | 14 +++ fs/ext4/ext4_common.c | 4 +- fs/ext4/ext4_common.h | 2 +- fs/ext4/ext4_write.c | 74 +++++++++++--- fs/fs.c | 44 ++++++++ include/ext4fs.h | 6 +- include/fs.h | 2 + test/py/tests/test_fs/conftest.py | 77 ++++++++++++++ test/py/tests/test_fs/fstest_defs.py | 3 + test/py/tests/test_fs/fstest_helpers.py | 15 +++ test/py/tests/test_fs/test_basic.py | 4 + test/py/tests/test_fs/test_ext.py | 10 ++ test/py/tests/test_fs/test_mkdir.py | 8 ++ test/py/tests/test_fs/test_symlink.py | 129 ++++++++++++++++++++++++ test/py/tests/test_fs/test_unlink.py | 14 ++- 15 files changed, 382 insertions(+), 24 deletions(-) create mode 100644 test/py/tests/test_fs/fstest_helpers.py create mode 100644 test/py/tests/test_fs/test_symlink.py
Signature · 1 line
2.17.1
PATCH v5 1/7 fs: ext4: do not allow writes if metadata checksum is active
u-boot does not supports updating the metadata chacksums
---
Changes in v5: None
Changes in v4: None
Changes in v3: None
Changes in v2:
- Prevent write access if metadata checksum is enabled
fs/ext4/ext4_write.c | 12 ++++++++++-- include/ext4fs.h | 1 + 2 files changed, 11 insertions(+), 2 deletions(-)
fs/ext4/ext4_write.c +10 -2
@@ -858,12 +858,19 @@ int ext4fs_write(const char *fname, unsigned char *buffer, g_parent_inode =zalloc (fs->inodesz);if (!g_parent_inode) - goto fail; + goto fail_ext4fs_init;if (ext4fs_init () !=0 ) {printf ("error in File System init\n" ); -return -1 ; + goto fail_ext4fs_init; + } + +if (le32_to_cpu (fs->sb->feature_ro_compat) & +EXT4_FEATURE_RO_COMPAT_METADATA_CSUM ) { +printf ("u-boot doesn't support updating the metadata checksums yet\n" ); + goto fail; } + inodes_per_block = fs->blksz / fs->inodesz; parent_inodeno =ext4fs_get_parent_inode_num (fname, filename,F_FILE );if (parent_inodeno ==-1 )
@@ -990,6 +997,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,return 0 ; fail:ext4fs_deinit (); +fail_ext4fs_init:free (inode_buffer);free (g_parent_inode);free (temp_ptr);
include/ext4fs.h +1 -0
@@ -32,6 +32,7 @@#define EXT4_EXTENTS_FL 0x00080000/* Inode uses extents */ #define EXT4_EXT_MAGIC 0xf30a#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 +#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080#define EXT4_INDIRECT_BLOCKS 12
Signature · 1 line
2.17.1
PATCH v5 2/7 test: fs: disable the metadata checksums on ext4 filesystems
In reply to Jean-Jacques HiblotIf the metadata checksums are enabled, all write operations will fail.
---
Changes in v5: None
Changes in v4: None
Changes in v3: None
Changes in v2: None
test/py/tests/test_fs/conftest.py | 2 ++ 1 file changed, 2 insertions(+)
test/py/tests/test_fs/conftest.py +2 -0
@@ -143,6 +143,8 @@ def mk_fs(config, fs_type, size, id): mkfs_opt = '-F 16' elif fs_type == 'fat32': mkfs_opt = '-F 32' + elif fs_type == 'ext4': + mkfs_opt = '-O ^metadata_csum' else: mkfs_opt = ''
Signature · 1 line
2.17.1
PATCH v5 3/7 test: fs: Add filesystem integrity checks
In reply to Jean-Jacques HiblotWe need to make sure that file writes,file creation, etc. are properly performed and do not corrupt the filesystem.
To help with this, introduce the assert_fs_integrity() function that executes the appropriate fsck tool. It should be called at the end of any test that modify the content/organization of the filesystem. Currently only supports FATs and EXT4.
---
Changes in v5:
- Added filesystem integrity checks
Changes in v4: None
Changes in v3: None
Changes in v2: None
test/py/tests/test_fs/fstest_helpers.py | 15 +++++++++++++++ test/py/tests/test_fs/test_basic.py | 4 ++++ test/py/tests/test_fs/test_ext.py | 10 ++++++++++ test/py/tests/test_fs/test_mkdir.py | 8 ++++++++ test/py/tests/test_fs/test_unlink.py | 14 +++++++++++--- 5 files changed, 48 insertions(+), 3 deletions(-) create mode 100644 test/py/tests/test_fs/fstest_helpers.py
test/py/tests/test_fs/fstest_helpers.py new file +15 -0
@@ -0,0 +1,15 @@ +# SPDX-License-Identifier: GPL-2.0+ +# Copyright (c) 2019, Texas Instrument +# Author: JJ Hiblot <[email protected]> +# + +from subprocess import check_call, CalledProcessError + +def assert_fs_integrity(fs_type, fs_img): + try: + if fs_type == 'ext4': + check_call('fsck.ext4 -n -f %s' % fs_img, shell=True) + if fs_type == 'fat': + check_call('fsck.fat -n %s' % fs_img, shell=True) + except CalledProcessError: + raise
test/py/tests/test_fs/test_basic.py +4 -0
@@ -11,6 +11,7 @@ This test verifies basic read/write operation on file system. import pytest import re from fstest_defs import * +from fstest_helpers import assert_fs_integrity @pytest.mark.boardspec('sandbox') @pytest.mark.slow
@@ -237,6 +238,7 @@ class TestFsBasic(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[0] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs12(self, u_boot_console, fs_obj_basic): """
@@ -252,6 +254,7 @@ class TestFsBasic(object): 'host bind 0 %s' % fs_img, '%swrite host 0:0 %x /. 0x10' % (fs_type, ADDR)]) assert('Unable to write' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs13(self, u_boot_console, fs_obj_basic): """
@@ -286,3 +289,4 @@ class TestFsBasic(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[0] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img)
test/py/tests/test_fs/test_ext.py +10 -0
@@ -11,6 +11,7 @@ This test verifies extended write operation on file system. import pytest import re from fstest_defs import * +from fstest_helpers import assert_fs_integrity @pytest.mark.boardspec('sandbox') @pytest.mark.slow
@@ -36,6 +37,7 @@ class TestFsExt(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[0] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext2(self, u_boot_console, fs_obj_ext): """
@@ -58,6 +60,7 @@ class TestFsExt(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[0] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext3(self, u_boot_console, fs_obj_ext): """
@@ -72,6 +75,7 @@ class TestFsExt(object): '%swrite host 0:0 %x /dir1/none/%s.w3 $filesize' % (fs_type, ADDR, MIN_FILE)]) assert('Unable to write "/dir1/none/' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext4(self, u_boot_console, fs_obj_ext): """
@@ -104,6 +108,7 @@ class TestFsExt(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[1] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext5(self, u_boot_console, fs_obj_ext): """
@@ -136,6 +141,7 @@ class TestFsExt(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[2] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext6(self, u_boot_console, fs_obj_ext): """
@@ -160,6 +166,7 @@ class TestFsExt(object): 'printenv filesize', 'setenv filesize']) assert('filesize=0' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext7(self, u_boot_console, fs_obj_ext): """
@@ -192,6 +199,7 @@ class TestFsExt(object): 'md5sum %x $filesize' % ADDR, 'setenv filesize']) assert(md5val[3] in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext8(self, u_boot_console, fs_obj_ext): """
@@ -209,6 +217,7 @@ class TestFsExt(object): '%swrite host 0:0 %x /dir1/%s.w8 0x1400 %x' % (fs_type, ADDR, MIN_FILE, 0x100000 + 0x1400)) assert('Unable to write "/dir1' in output) + assert_fs_integrity(fs_type, fs_img) def test_fs_ext9(self, u_boot_console, fs_obj_ext): """
@@ -223,3 +232,4 @@ class TestFsExt(object): '%swrite host 0:0 %x /dir1/%s.w9 0x1400 0x1400' % (fs_type, ADDR, MIN_FILE)]) assert('Unable to write "/dir1' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img)
test/py/tests/test_fs/test_mkdir.py +8 -0
@@ -9,6 +9,7 @@ This test verifies mkdir operation on file system. """ import pytest +from fstest_helpers import assert_fs_integrity @pytest.mark.boardspec('sandbox') @pytest.mark.slow
@@ -29,6 +30,8 @@ class TestMkdir(object): '%sls host 0:0 dir1' % fs_type) assert('./' in output) assert('../' in output) + assert_fs_integrity(fs_type, fs_img) + def test_mkdir2(self, u_boot_console, fs_obj_mkdir): """
@@ -46,6 +49,7 @@ class TestMkdir(object): '%sls host 0:0 dir1/dir2' % fs_type) assert('./' in output) assert('../' in output) + assert_fs_integrity(fs_type, fs_img) def test_mkdir3(self, u_boot_console, fs_obj_mkdir): """
@@ -58,6 +62,7 @@ class TestMkdir(object): 'host bind 0 %s' % fs_img, '%smkdir host 0:0 none/dir3' % fs_type]) assert('Unable to create a directory' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_mkdir4(self, u_boot_console, fs_obj_mkdir): """
@@ -69,6 +74,7 @@ class TestMkdir(object): 'host bind 0 %s' % fs_img, '%smkdir host 0:0 .' % fs_type]) assert('Unable to create a directory' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_mkdir5(self, u_boot_console, fs_obj_mkdir): """
@@ -80,6 +86,7 @@ class TestMkdir(object): 'host bind 0 %s' % fs_img, '%smkdir host 0:0 ..' % fs_type]) assert('Unable to create a directory' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_mkdir6(self, u_boot_console, fs_obj_mkdir): """
@@ -111,3 +118,4 @@ class TestMkdir(object): '%sls host 0:0 dir6/0123456789abcdef13/..' % fs_type) assert('0123456789abcdef00/' in output) assert('0123456789abcdef13/' in output) + assert_fs_integrity(fs_type, fs_img)
test/py/tests/test_fs/test_unlink.py +11 -3
@@ -10,6 +10,7 @@ on file system. """ import pytest +from fstest_helpers import assert_fs_integrity @pytest.mark.boardspec('sandbox') @pytest.mark.slow
@@ -30,6 +31,7 @@ class TestUnlink(object): '%sls host 0:0 dir1/' % fs_type) assert(not 'file1' in output) assert('file2' in output) + assert_fs_integrity(fs_type, fs_img) def test_unlink2(self, u_boot_console, fs_obj_unlink): """
@@ -48,6 +50,7 @@ class TestUnlink(object): output = u_boot_console.run_command( '%sls host 0:0 dir2' % fs_type) assert('0 file(s), 2 dir(s)' in output) + assert_fs_integrity(fs_type, fs_img) def test_unlink3(self, u_boot_console, fs_obj_unlink): """
@@ -59,6 +62,7 @@ class TestUnlink(object): 'host bind 0 %s' % fs_img, '%srm host 0:0 dir1/nofile' % fs_type]) assert('nofile: doesn\'t exist' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_unlink4(self, u_boot_console, fs_obj_unlink): """
@@ -71,9 +75,10 @@ class TestUnlink(object): '%srm host 0:0 dir4' % fs_type]) assert('' == ''.join(output)) - output = u_boot_console.run_command( - '%sls host 0:0 /' % fs_type) - assert(not 'dir4' in output) + output = u_boot_console.run_command( + '%sls host 0:0 /' % fs_type) + assert(not 'dir4' in output) + assert_fs_integrity(fs_type, fs_img) def test_unlink5(self, u_boot_console, fs_obj_unlink): """
@@ -86,6 +91,7 @@ class TestUnlink(object): 'host bind 0 %s' % fs_img, '%srm host 0:0 dir5' % fs_type]) assert('directory is not empty' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_unlink6(self, u_boot_console, fs_obj_unlink): """
@@ -97,6 +103,7 @@ class TestUnlink(object): 'host bind 0 %s' % fs_img, '%srm host 0:0 dir5/.' % fs_type]) assert('directory is not empty' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img) def test_unlink7(self, u_boot_console, fs_obj_unlink): """
@@ -108,3 +115,4 @@ class TestUnlink(object): 'host bind 0 %s' % fs_img, '%srm host 0:0 dir5/..' % fs_type]) assert('directory is not empty' in ''.join(output)) + assert_fs_integrity(fs_type, fs_img)
Signature · 1 line
2.17.1
PATCH v5 4/7 fs: ext4: constify the buffer passed to write functions
In reply to Jean-Jacques HiblotThere is no need to modify the buffer passed to ext4fs_write_file(). The memset() call is not required here and was likely copied from the equivalent part of the ext4fs_read_file() function where we do need it.
---
Changes in v5: None
Changes in v4:
- replaced u64 and u32 with uint64_t and uint32_t
Changes in v3:
- reworded commit log
Changes in v2: None
fs/ext4/ext4_common.c | 2 +- fs/ext4/ext4_common.h | 2 +- fs/ext4/ext4_write.c | 11 +++++------ include/ext4fs.h | 2 +- 4 files changed, 8 insertions(+), 9 deletions(-)
fs/ext4/ext4_common.c +1 -1
@@ -190,7 +190,7 @@ uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n)return res; } -void put_ext4 (uint64_t off,void *buf,uint32_t size) +void put_ext4 (uint64_t off,const void *buf,uint32_t size) {uint64_t startblock;uint64_t remainder;
fs/ext4/ext4_common.h +1 -1
@@ -72,7 +72,7 @@ int ext4fs_iget(int inode_no, struct ext2_inode *inode);void ext4fs_allocate_blocks (struct ext2_inode *file_inode,unsigned int total_remaining_blocks,unsigned int *total_no_of_block); -void put_ext4 (uint64_t off,void *buf,uint32_t size); +void put_ext4 (uint64_t off,const void *buf,uint32_t size);struct ext2_block_group *ext4fs_get_group_descriptor (const struct ext_filesystem *fs,uint32_t bg_idx); uint64_t ext4fs_bg_get_block_id(const struct ext2_block_group *bg,
fs/ext4/ext4_write.c +5 -6
@@ -752,7 +752,7 @@ void ext4fs_deinit(void)* contigous sectors as ext4fs_read_file */ static int ext4fs_write_file (struct ext2_inode *file_inode, -int pos,unsigned int len,char *buf) +int pos,unsigned int len,const char *buf) {int i;int blockcnt;
@@ -764,7 +764,7 @@ static int ext4fs_write_file(struct ext2_inode *file_inode,int delayed_start =0 ;int delayed_extent =0 ;int delayed_next =0 ; -char *delayed_buf =NULL ; +const char *delayed_buf =NULL ;/* Adjust len so it we can't read past the end of the file. */ if (len > filesize)
@@ -816,7 +816,6 @@ static int ext4fs_write_file(struct ext2_inode *file_inode, (uint32_t) delayed_extent); previous_block_number =-1 ; } -memset (buf,0 , fs->blksz - skipfirst); } buf += fs->blksz - skipfirst; }
@@ -830,8 +829,8 @@ static int ext4fs_write_file(struct ext2_inode *file_inode,return len; } -int ext4fs_write (const char *fname,unsigned char *buffer, -unsigned long sizebytes) +int ext4fs_write (const char *fname,const char *buffer, +unsigned long sizebytes) {int ret =0 ;struct ext2_inode *file_inode =NULL ;
@@ -950,7 +949,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,if (ext4fs_put_metadata (temp_ptr, itable_blkno)) goto fail;/* copy the file content into data blocks */ -if (ext4fs_write_file (file_inode,0 , sizebytes, (char *)buffer) ==-1 ) { +if (ext4fs_write_file (file_inode,0 , sizebytes, buffer) ==-1 ) {printf ("Error in copying content\n" );/* FIXME: Deallocate data blocks */ goto fail;
include/ext4fs.h +1 -1
@@ -128,7 +128,7 @@ extern int gindex;int ext4fs_init (void );void ext4fs_deinit (void );int ext4fs_filename_unlink (char *filename); -int ext4fs_write (const char *fname,unsigned char *buffer, +int ext4fs_write (const char *fname,const char *buffer,unsigned long sizebytes);int ext4_write_file (const char *filename,void *buf,loff_t offset,loff_t len,loff_t *actwrite);
Signature · 1 line
2.17.1
PATCH v5 5/7 fs: ext4: Add support for the creation of symbolic links
In reply to Jean-Jacques HiblotRe-use the functions used to write/create a file, to support creation of a symbolic link.
The difference with a regular file are small:
- The inode mode is flagged with S_IFLNK instead of S_IFREG
- The ext2_dirent's filetype is FILETYPE_SYMLINK instead of FILETYPE_REG
- Instead of storing the content of a file in allocated blocks, the path to the target is stored. And if the target's path is short enough, no block is allocated and the target's path is stored in ext2_inode.b.symlink
As with regulars files, if a file/symlink with the same name exits, it is unlinked first and then re-created.
---
Changes in v5:
- Fix bug in ext4fs_delete_file(). The type must be read from the inode.
Changes in v4: None
Changes in v3: None
Changes in v2:
- Fix issue in ext4fs_delete_file() when target in not stored in an allocated block
fs/ext4/ext4_common.c | 2 +- fs/ext4/ext4_write.c | 53 +++++++++++++++++++++++++++++++++++-------- include/ext4fs.h | 3 ++- 3 files changed, 47 insertions(+), 11 deletions(-)
fs/ext4/ext4_common.c +1 -1
@@ -607,7 +607,7 @@ restart_read: dir->direntlen =cpu_to_le16 (fs->blksz - totalbytes); dir->namelen =strlen (filename); - dir->filetype =FILETYPE_REG ;/* regular file */ + dir->filetype = file_type; temp_dir = (char *)dir; temp_dir = temp_dir +sizeof (struct ext2_dirent );memcpy (temp_dir, filename,strlen (filename));
fs/ext4/ext4_write.c +44 -9
111 lines not on this page · raw message
include/ext4fs.h +2 -1
@@ -129,9 +129,10 @@ int ext4fs_init(void);void ext4fs_deinit (void );int ext4fs_filename_unlink (char *filename);int ext4fs_write (const char *fname,const char *buffer, -unsigned long sizebytes); +unsigned long sizebytes,int type);int ext4_write_file (const char *filename,void *buf,loff_t offset,loff_t len,loff_t *actwrite); +int ext4fs_create_link (const char *target,const char *fname);#endif struct ext_filesystem *get_fs (void );
Signature · 1 line
2.17.1
PATCH v5 6/7 fs: Add a new command to create symbolic links
In reply to Jean-Jacques HiblotThe command line is:
ln <interface> <dev[:part]> target linkname
Currently symbolic links are supported only in ext4 and only if the option CMD_EXT4_WRITE is enabled.
---
Changes in v5: None
Changes in v4: None
Changes in v3: None
Changes in v2: None
cmd/fs.c | 14 ++++++++++++++ fs/fs.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ include/fs.h | 2 ++ 3 files changed, 60 insertions(+)
cmd/fs.c +14 -0
@@ -74,6 +74,20 @@ U_BOOT_CMD( " device type 'interface' instance 'dev'." ) +static int do_ln_wrapper (cmd_tbl_t *cmdtp,int flag,int argc, +char *const argv[]) +{ +return do_ln (cmdtp, flag, argc, argv,FS_TYPE_ANY ); +} + +U_BOOT_CMD ( + ln,5 ,1 , do_ln_wrapper, +"Create a symbolic link" , +"<interface> <dev[:part]> target linkname\n" +" - create a symbolic link to 'target' with the name 'linkname' on\n" +" device type 'interface' instance 'dev'." +) +static int do_fstype_wrapper (cmd_tbl_t *cmdtp,int flag,int argc,char *const argv[]) {
fs/fs.c +44 -0
103 lines not on this page · raw message
include/fs.h +2 -0
@@ -191,6 +191,8 @@ int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[], int fstype);int do_mkdir (cmd_tbl_t *cmdtp,int flag,int argc,char *const argv[],int fstype); +int do_ln (cmd_tbl_t *cmdtp,int flag,int argc,char *const argv[], +int fstype);/* * Determine the UUID of the specified filesystem and print it. Optionally it is
Signature · 1 line
2.17.1
PATCH v5 7/7 test: fs: Added tests for symlinks
In reply to Jean-Jacques HiblotTest cases are:
1) basic link creation, verify it can be followed
2) chained links, verify it can be followed
3) replace exiting file a with a link, and a link with a link. verify it can be followed
4) create a broken link, verify it can't be followed
---
Changes in v5:
- Added FS integrity test
Changes in v4: None
Changes in v3:
- removed FS integrity test (fsck) in python tests
Changes in v2:
- Added python tests for symlinks under sandbox
test/py/tests/test_fs/conftest.py | 75 +++++++++++++++ test/py/tests/test_fs/fstest_defs.py | 3 + test/py/tests/test_fs/test_symlink.py | 129 ++++++++++++++++++++++++++ 3 files changed, 207 insertions(+) create mode 100644 test/py/tests/test_fs/test_symlink.py
test/py/tests/test_fs/conftest.py +75 -0
@@ -13,6 +13,7 @@ supported_fs_basic = ['fat16', 'fat32', 'ext4'] supported_fs_ext = ['fat16', 'fat32'] supported_fs_mkdir = ['fat16', 'fat32'] supported_fs_unlink = ['fat16', 'fat32'] +supported_fs_symlink = ['ext4'] # # Filesystem test specific setup
@@ -48,6 +49,7 @@ def pytest_configure(config): global supported_fs_ext global supported_fs_mkdir global supported_fs_unlink + global supported_fs_symlink def intersect(listA, listB): return [x for x in listA if x in listB]
@@ -59,6 +61,7 @@ def pytest_configure(config): supported_fs_ext = intersect(supported_fs, supported_fs_ext) supported_fs_mkdir = intersect(supported_fs, supported_fs_mkdir) supported_fs_unlink = intersect(supported_fs, supported_fs_unlink) + supported_fs_symlink = intersect(supported_fs, supported_fs_symlink) def pytest_generate_tests(metafunc): """Parametrize fixtures, fs_obj_xxx
@@ -84,6 +87,9 @@ def pytest_generate_tests(metafunc): if 'fs_obj_unlink' in metafunc.fixturenames: metafunc.parametrize('fs_obj_unlink', supported_fs_unlink, indirect=True, scope='module') + if 'fs_obj_symlink' in metafunc.fixturenames: + metafunc.parametrize('fs_obj_symlink', supported_fs_symlink, + indirect=True, scope='module') # # Helper functions
@@ -525,3 +531,72 @@ def fs_obj_unlink(request, u_boot_config): call('rmdir %s' % mount_dir, shell=True) if fs_img: call('rm -f %s' % fs_img, shell=True) + +# +# Fixture for symlink fs test +# +# NOTE: yield_fixture was deprecated since pytest-3.0 + at pytest.yield_fixture() +def fs_obj_symlink(request, u_boot_config): + """Set up a file system to be used in symlink fs test. + + Args: + request: Pytest request object. + u_boot_config: U-boot configuration. + + Return: + A fixture for basic fs test, i.e. a triplet of file system type, + volume file name and a list of MD5 hashes. + """ + fs_type = request.param + fs_img = '' + + fs_ubtype = fstype_to_ubname(fs_type) + check_ubconfig(u_boot_config, fs_ubtype) + + mount_dir = u_boot_config.persistent_data_dir + '/mnt' + + small_file = mount_dir + '/' + SMALL_FILE + medium_file = mount_dir + '/' + MEDIUM_FILE + + try: + + # 3GiB volume + fs_img = mk_fs(u_boot_config, fs_type, 0x40000000, '1GB') + + # Mount the image so we can populate it. + check_call('mkdir -p %s' % mount_dir, shell=True) + mount_fs(fs_type, fs_img, mount_dir) + + # Create a subdirectory. + check_call('mkdir %s/SUBDIR' % mount_dir, shell=True) + + # Create a small file in this image. + check_call('dd if=/dev/urandom of=%s bs=1M count=1' + % small_file, shell=True) + + # Create a medium file in this image. + check_call('dd if=/dev/urandom of=%s bs=10M count=1' + % medium_file, shell=True) + + # Generate the md5sums of reads that we will test against small file + out = check_output( + 'dd if=%s bs=1M skip=0 count=1 2> /dev/null | md5sum' + % small_file, shell=True) + md5val = [out.split()[0]] + out = check_output( + 'dd if=%s bs=10M skip=0 count=1 2> /dev/null | md5sum' + % medium_file, shell=True) + md5val.extend([out.split()[0]]) + + umount_fs(mount_dir) + except CalledProcessError: + pytest.skip('Setup failed for filesystem: ' + fs_type) + return + else: + yield [fs_ubtype, fs_img, md5val] + finally: + umount_fs(mount_dir) + call('rmdir %s' % mount_dir, shell=True) + if fs_img: + call('rm -f %s' % fs_img, shell=True)
test/py/tests/test_fs/fstest_defs.py +3 -0
@@ -6,6 +6,9 @@ MIN_FILE='testfile' # $SMALL_FILE is the name of the 1MB file in the file system image SMALL_FILE='1MB.file' +# $MEDIUM_FILE is the name of the 10MB file in the file system image +MEDIUM_FILE='10MB.file' + # $BIG_FILE is the name of the 2.5GB file in the file system image BIG_FILE='2.5GB.file'
test/py/tests/test_fs/test_symlink.py new file +129 -0
129 lines not on this page · raw message
Signature · 1 line
2.17.1
v5 cover Add support for symlink creation in EXT4
In reply to Jean-Jacques HiblotPlease ignore. I didn't send the right branch.
Sorry for the noise
Quoted 62 lines · Jean-Jacques Hiblot
This series adds support for the creation of symbolic links on ext4 file-systems.
The motivation behind this work is to have the ability to "do" the job of update-alternatives in u-boot.
Firmware on TI's platform are usually managed with update-alternatives and are thus targeted by a symbolic link. In some situations we need the ability to select an alternate firmware before the linux kernel is started so that when a early driver needing the firmware comes up, it can be fed the firmware of our choice.Tested on a
am57xx_evm, using a EXT4 partition on external SDcard. The filesystem can be checked later with: fsck.ext4 -f <dev>usage example:
=> ln mmc 0:2 zImage/boot/the_linux_kernelChanges in v5:
- Added filesystem integrity checks
- Fix bug inext4fs_delete_file(). The type must be read from the inode.Changes in v4:
- replaced u64 and u32 withuint64_tanduint32_tChanges in v3:
- reworded commit log
- removed FS integrity test (fsck) in python testsChanges in v2:
- Prevent write access if metadata checksum is enabled
- Fix issue inext4fs_delete_file()when target in not stored in an allocated block
- Added python tests for symlinks under sandboxJean-Jacques Hiblot (7):
fs: ext4: do not allow writes if metadata checksum is active
test: fs: disable the metadata checksums on ext4 filesystems
test: fs: Add filesystem integrity checks
fs: ext4: constify the buffer passed to write functions
fs: ext4: Add support for the creation of symbolic links
fs: Add a new command to create symbolic links
test: fs: Added tests for symlinkscmd/fs.c | 14 +++ fs/ext4/ext4_common.c | 4 +- fs/ext4/ext4_common.h | 2 +- fs/ext4/ext4_write.c | 74 +++++++++++--- fs/fs.c | 44 ++++++++ include/ext4fs.h | 6 +- include/fs.h | 2 + test/py/tests/test_fs/conftest.py | 77 ++++++++++++++ test/py/tests/test_fs/fstest_defs.py | 3 + test/py/tests/test_fs/fstest_helpers.py | 15 +++ test/py/tests/test_fs/test_basic.py | 4 + test/py/tests/test_fs/test_ext.py | 10 ++ test/py/tests/test_fs/test_mkdir.py | 8 ++ test/py/tests/test_fs/test_symlink.py | 129 ++++++++++++++++++++++++ test/py/tests/test_fs/test_unlink.py | 14 ++- 15 files changed, 382 insertions(+), 24 deletions(-)create mode 100644
test/py/tests/test_fs/fstest_helpers.pycreate mode 100644test/py/tests/test_fs/test_symlink.py