[LTP] [PATCH 1/2] fallocate01: Convert to new API
Andrea Cervesato
andrea.cervesato@suse.de
Mon Jul 20 13:48:26 CEST 2026
From: Andrea Cervesato <andrea.cervesato@suse.com>
Convert the fallocate01 test case from the legacy LTP API (test.h) to the
new tst_test API using a table-driven struct tcase[] and TST_EXP_* macros.
Preserve both scenarios (DEFAULT mode and FALLOC_FL_KEEP_SIZE) and all
oracles: the fallocate return code, the per-mode st_size side effect that
distinguishes the two modes (13 vs 12 blocks), the relative-seek position
check, and the write into the freshly allocated region. Map EOPNOTSUPP and
ENOSYS to TCONF for filesystems that do not support fallocate.
Reset the backing file to its pristine 12-block state at the start of each
run so the per-mode size assertions stay correct under -i, fixing a latent
bug where the legacy test silently failed on iterations after the first.
Derive the block size from st_blksize and rely on framework .needs_tmpdir
instead of manual tmpdir handling.
Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>
---
testcases/kernel/syscalls/fallocate/fallocate01.c | 337 ++++++----------------
1 file changed, 96 insertions(+), 241 deletions(-)
diff --git a/testcases/kernel/syscalls/fallocate/fallocate01.c b/testcases/kernel/syscalls/fallocate/fallocate01.c
index d21936ebaa125fd1d842c5e606f6c9a22b6967da..d859a0b47dd48abdcb55530729f86e92cd71fcc6 100644
--- a/testcases/kernel/syscalls/fallocate/fallocate01.c
+++ b/testcases/kernel/syscalls/fallocate/fallocate01.c
@@ -1,274 +1,129 @@
-/******************************************************************************
- * fallocate01.c
- * Mon Dec 24 2007
- * Copyright (c) International Business Machines Corp., 2007
- * Emali : sharyathi@in.ibm.com
- ******************************************************************************/
-
-/***************************************************************************
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Library General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-***************************************************************************/
-
-/*****************************************************************************
- *
- * OS Test - International Business Machines Corp. 2007.
- *
- * TEST IDENTIFIER : fallocate01
- *
- * EXECUTED BY : anyone
- *
- * TEST TITLE : Basic test for fallocate()
- *
- * TEST CASE TOTAL : 2
- *
- * CPU ARCHITECTURES : PPC,X86, X86_64
- *
- * AUTHOR : Sharyathi Nagesh
- *
- * CO-PILOT :
- *
- * DATE STARTED : 24/12/2007
- *
- * TEST CASES
- * (Working of fallocate under 2 modes)
- * 1) DEFAULT 2)FALLOC_FL_KEEP_SIZE
- *
- * INPUT SPECIFICATIONS
- * No input needs to be specified
- * fallocate() in puts are generated randomly
- *
- * OUTPUT SPECIFICATIONS
- * Output describing whether test cases passed or failed.
- *
- * ENVIRONMENTAL NEEDS
- * Test Needs to be executed on file system supporting ext4
- * LTP {TMP} Needs to be set to such a folder
- *
- * SPECIAL PROCEDURAL REQUIREMENTS
- * None
- *
- * DETAILED DESCRIPTION
- * This is a test case for fallocate() system call.
- * This test suite tests basic working of fallocate under different modes
- * It trys to fallocate memory blocks and write into that block
- *
- * Total 2 Test Cases :-
- * (1) Test Case for DEFAULT MODE
- * (2) Test Case for FALLOC_FL_KEEP_SIZE
- *
- * Setup:
- * Setup file on which fallocate is to be called
- * Set up 2 files for each mode
- *
- * Test:
- * Loop if the proper options are given.
- * Execute system call
- * Check return code, if system call did fail
- * lseek to some random location with in allocate block
- * write data into the locattion Report if any error encountered
- * PASS the test otherwise
- *
- * Cleanup:
- * Cleanup the temporary folder
- *
-*************************************************************************/
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) International Business Machines Corp., 2007
+ * Author: Sharyathi Nagesh <sharyathi@in.ibm.com>
+ * Copyright (c) Linux Test Project, 2008-2024
+ */
+
+/*\
+ * Basic test for :manpage:`fallocate(2)` covering the two preallocation
+ * modes and their effect on the file size.
+ *
+ * A file is pre-populated to 12 blocks and a single extra block is
+ * preallocated past the end of the file. The test verifies that the
+ * resulting file size matches the mode semantics and that the newly
+ * allocated region is writable.
+ *
+ * [Algorithm]
+ *
+ * - Populate the working file with 12 blocks of block_size bytes.
+ * - Preallocate one block at the end of the file.
+ * - In DEFAULT_MODE the file grows to 13 blocks.
+ * - In FALLOC_FL_KEEP_SIZE mode the file size stays at 12 blocks.
+ * - Seek into the newly allocated region and write a byte to it.
+ */
#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <endian.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-#include <inttypes.h>
-#include <sys/utsname.h>
-
-#include "test.h"
-#include "tso_safe_macros.h"
+#include "tst_test.h"
#include "lapi/fallocate.h"
-#include "lapi/fcntl.h"
#define BLOCKS_WRITTEN 12
-void get_blocksize(int);
-void populate_files(int fd);
-void runtest(int, int, loff_t);
+static int fd = -1;
+static int block_size;
-char *TCID = "fallocate01";
-char fname_mode1[255], fname_mode2[255]; /* Files used for testing */
-int fd_mode1, fd_mode2;
-int TST_TOTAL = 2;
-loff_t block_size;
-int buf_size;
+static struct tcase {
+ int mode;
+ int expected_blocks;
+ const char *desc;
+} tcases[] = {
+ {0, BLOCKS_WRITTEN + 1, "DEFAULT_MODE"},
+ {FALLOC_FL_KEEP_SIZE, BLOCKS_WRITTEN, "FALLOC_FL_KEEP_SIZE"},
+};
-/******************************************************************************
- * Performs all one time clean up for this test on successful
- * completion, premature exit or failure. Closes all temporary
- * files, removes all temporary directories exits the test with
- * appropriate return code by calling tst_exit() function.
-******************************************************************************/
-void cleanup(void)
+static void populate_file(void)
{
+ char buf[block_size];
- if (close(fd_mode1) == -1)
- tst_resm(TWARN | TERRNO, "close(%s) failed", fname_mode1);
- if (close(fd_mode2) == -1)
- tst_resm(TWARN | TERRNO, "close(%s) failed", fname_mode2);
- tst_rmdir();
-}
-
-/*****************************************************************************
- * Performs all one time setup for this test. This function is
- * used to create temporary dirs and temporary files
- * that may be used in the course of this test
- ******************************************************************************/
-void setup(void)
-{
- /* Create temporary directories */
- TEST_PAUSE;
+ for (int blocks = 0; blocks < BLOCKS_WRITTEN; blocks++) {
+ for (int i = 0; i < block_size; i++)
+ buf[i] = 'A' + (i % 26);
- tst_tmpdir();
-
- sprintf(fname_mode1, "tfile_mode1_%d", getpid());
- fd_mode1 = SAFE_OPEN(cleanup, fname_mode1, O_RDWR | O_CREAT, 0700);
- get_blocksize(fd_mode1);
- populate_files(fd_mode1);
-
- sprintf(fname_mode2, "tfile_mode2_%d", getpid());
- fd_mode2 = SAFE_OPEN(cleanup, fname_mode2, O_RDWR | O_CREAT, 0700);
- populate_files(fd_mode2);
+ SAFE_WRITE(SAFE_WRITE_ALL, fd, buf, block_size);
+ }
}
-/*****************************************************************************
- * Gets the block size for the file system
- ******************************************************************************/
-void get_blocksize(int fd)
+static void setup(void)
{
+ char fname[NAME_MAX];
struct stat file_stat;
- if (fstat(fd, &file_stat) < 0)
- tst_resm(TFAIL | TERRNO,
- "fstat failed while getting block_size");
-
- block_size = file_stat.st_blksize;
- buf_size = block_size;
-}
-
-/*****************************************************************************
- * Writes data into the file
- ******************************************************************************/
-
-void populate_files(int fd)
-{
- char buf[buf_size + 1];
- int index;
- int blocks;
- int data;
+ snprintf(fname, sizeof(fname), "tfile_%d", getpid());
+ fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
- for (blocks = 0; blocks < BLOCKS_WRITTEN; blocks++) {
- for (index = 0; index < buf_size; index++)
- buf[index] = 'A' + (index % 26);
- buf[buf_size] = '\0';
- if ((data = write(fd, buf, buf_size)) == -1)
- tst_brkm(TBROK | TERRNO, cleanup, "write failed");
- }
+ SAFE_FSTAT(fd, &file_stat);
+ block_size = (int)file_stat.st_blksize;
}
-int main(int ac, char **av)
+static void run(unsigned int n)
{
- loff_t expected_size;
- int lc;
-
- tst_parse_opts(ac, av, NULL, NULL);
+ struct tcase *tc = &tcases[n];
+ struct stat file_stat;
+ loff_t offset, len, pos, write_offset, expected_size;
- setup();
+ /* Reset the backing file to a pristine 12-block state per run. */
+ SAFE_FTRUNCATE(fd, 0);
+ SAFE_LSEEK(fd, 0, SEEK_SET);
+ populate_file();
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- tst_count = 0;
+ offset = SAFE_LSEEK(fd, 0, SEEK_END);
+ len = block_size;
+ expected_size = (loff_t)tc->expected_blocks * block_size;
- expected_size = BLOCKS_WRITTEN * block_size + block_size;
- runtest(0, fd_mode1, expected_size);
+ TEST(fallocate(fd, tc->mode, offset, len));
+ if (TST_RET != 0) {
+ if (TST_ERR == EOPNOTSUPP || TST_ERR == ENOSYS)
+ tst_brk(TCONF, "fallocate() not supported");
- expected_size = BLOCKS_WRITTEN * block_size;
- runtest(FALLOC_FL_KEEP_SIZE, fd_mode2, expected_size);
+ tst_res(TFAIL | TTERRNO, "fallocate(%s, %lld, %lld) failed",
+ tc->desc, (long long)offset, (long long)len);
+ return;
}
+ tst_res(TPASS, "fallocate(%s, %lld, %lld) succeeded",
+ tc->desc, (long long)offset, (long long)len);
- cleanup();
- tst_exit();
-}
-
-/*****************************************************************************
- * Calls the system call, with appropriate parameters and writes data
- ******************************************************************************/
-void runtest(int mode, int fd, loff_t expected_size)
-{
- loff_t offset;
- loff_t len = block_size;
- loff_t write_offset, lseek_offset;
- offset = lseek(fd, 0, SEEK_END);
- struct stat file_stat;
- errno = 0;
-
- TEST(fallocate(fd, mode, offset, len));
- /* check return code */
- if (TEST_RETURN != 0) {
- if (TEST_ERRNO == EOPNOTSUPP || TEST_ERRNO == ENOSYS) {
- tst_brkm(TCONF, cleanup,
- "fallocate system call is not implemented");
- }
- tst_resm(TFAIL | TTERRNO,
- "fallocate(%d, %d, %" PRId64 ", %" PRId64 ") failed",
- fd, mode, offset, len);
- return;
+ SAFE_FSTAT(fd, &file_stat);
+ if (file_stat.st_size != expected_size) {
+ tst_res(TFAIL, "file size is %lld, expected %lld",
+ (long long)file_stat.st_size, (long long)expected_size);
} else {
- tst_resm(TPASS,
- "fallocate(%d, %d, %" PRId64 ", %" PRId64
- ") returned %ld", fd, mode, offset, len,
- TEST_RETURN);
+ tst_res(TPASS, "file size is %lld as expected",
+ (long long)expected_size);
}
- if (fstat(fd, &file_stat) < 0)
- tst_resm(TFAIL | TERRNO, "fstat failed after fallocate()");
-
- if (file_stat.st_size != expected_size)
- tst_resm(TFAIL | TERRNO,
- "fstat test fails on fallocate (%d, %d, %" PRId64 ", %"
- PRId64 ") Failed on mode", fd, mode, offset, len);
-
- write_offset = random() % len;
- lseek_offset = lseek(fd, write_offset, SEEK_CUR);
- if (lseek_offset != offset + write_offset) {
- tst_resm(TFAIL | TERRNO,
- "lseek fails in fallocate(%d, %d, %" PRId64 ", %"
- PRId64 ") failed on mode", fd, mode, offset, len);
+ write_offset = len / 2;
+ pos = SAFE_LSEEK(fd, write_offset, SEEK_CUR);
+ if (pos != offset + write_offset) {
+ tst_res(TFAIL, "lseek returned %lld, expected %lld",
+ (long long)pos, (long long)(offset + write_offset));
return;
}
- //Write a character to file at random location
- TEST(write(fd, "A", 1));
- /* check return code */
- if (TEST_RETURN == -1) {
- tst_resm(TFAIL | TTERRNO,
- "write fails in fallocate(%d, %d, %" PRId64 ", %"
- PRId64 ") failed", fd, mode, offset, len);
- } else {
- tst_resm(TPASS,
- "write operation on fallocated(%d, %d, %"
- PRId64 ", %" PRId64 ") returned %ld", fd, mode,
- offset, len, TEST_RETURN);
- }
+
+ TST_EXP_POSITIVE(write(fd, "A", 1),
+ "write into the newly allocated region");
+}
+
+static void cleanup(void)
+{
+ if (fd != -1)
+ SAFE_CLOSE(fd);
}
+
+static struct tst_test test = {
+ .setup = setup,
+ .cleanup = cleanup,
+ .test = run,
+ .tcnt = ARRAY_SIZE(tcases),
+ .needs_tmpdir = 1,
+};
--
2.51.0
More information about the ltp
mailing list