/*      $NetBSD: t_fcntl.c,v 1.6 2025/12/10 03:08:52 perseant Exp $     */

#include <sys/types.h>
#include <sys/mount.h>
#include <sys/wait.h>

#include <atf-c.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <string.h>

#include <rump/rump.h>
#include <rump/rump_syscalls.h>

#include <ufs/ufs/ufsmount.h>
#include <ufs/lfs/lfs.h>
#include <ufs/lfs/lfs_extern.h>

#include "h_macros.h"
#include "util.h"

/* Debugging conditions */
/* #define FORCE_SUCCESS */ /* Don't actually revert, everything worked */
/* #define USE_DUMPLFS */ /* Dump the filesystem at certain steps */

#define UNCHANGED_CONTROL MP "/3-a-random-file"
#define FSSIZE 10000     /* In sectors */
#define A_FEW_BLOCKS 6500  /* In bytes; a few blocks worth */
#define MORE_THAN_A_SEGMENT (4 * SEGSIZE) /* In bytes; > SEGSIZE */

/* Set up filesystem with a file in it */
int setup(int, struct ufs_args *, off_t);

/* Actually run the test */
void coalesce(int);
void cleanseg(int);
void autoclean(int);

/* Unmount and check fsck */
void teardown(int, struct ufs_args *, off_t);

ATF_TC(coalesce32);
ATF_TC_HEAD(coalesce32, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS32 LFCNSCRAMBLE/LFCNREWRITEFILE");
        /* atf_tc_set_md_var(tc, "timeout", "20"); */
}

ATF_TC(coalesce64);
ATF_TC_HEAD(coalesce64, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS64 LFCNSCRAMBLE/LFCNREWRITEFILE");
        /* atf_tc_set_md_var(tc, "timeout", "20"); */
}

ATF_TC(cleanseg32);
ATF_TC_HEAD(cleanseg32, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS32 LFCNREWRITESEG");
        atf_tc_set_md_var(tc, "timeout", "20");
}

ATF_TC(cleanseg64);
ATF_TC_HEAD(cleanseg64, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS64 LFCNREWRITESEG");
        atf_tc_set_md_var(tc, "timeout", "20");
}

ATF_TC(autoclean32);
ATF_TC_HEAD(autoclean32, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS32 LFCNAUTOCLEAN");
        /* atf_tc_set_md_var(tc, "timeout", "20"); */
}

ATF_TC(autoclean64);
ATF_TC_HEAD(autoclean64, tc)
{
        atf_tc_set_md_var(tc, "descr",
                "LFS64 LFCNAUTOCLEAN");
        /* atf_tc_set_md_var(tc, "timeout", "20"); */
}

ATF_TC_BODY(coalesce32, tc)
{
        coalesce(32);
}

ATF_TC_BODY(coalesce64, tc)
{
        coalesce(64);
}

ATF_TC_BODY(cleanseg32, tc)
{
        cleanseg(32);
}

ATF_TC_BODY(cleanseg64, tc)
{
        cleanseg(64);
}

ATF_TC_BODY(autoclean32, tc)
{
        autoclean(32);
}

ATF_TC_BODY(autoclean64, tc)
{
        autoclean(64);
}

int setup(int width, struct ufs_args *argsp, off_t filesize)
{
        int fd;

        setvbuf(stdout, NULL, _IONBF, 0);

        /*
         * Initialize.
         */

        /* Create image file */
        create_lfs(FSSIZE, FSSIZE, width, 1);

        /* Mount filesystem */
        fprintf(stderr, "* Mount fs [1]\n");
        memset(argsp, 0, sizeof *argsp);
        argsp->fspec = __UNCONST(FAKEBLK);
        if (rump_sys_mount(MOUNT_LFS, MP, 0, argsp, sizeof *argsp) == -1)
                atf_tc_fail_errno("rump_sys_mount failed");

        /* Payload */
        fprintf(stderr, "* Initial payload\n");
        write_file(UNCHANGED_CONTROL, filesize, 1, 3);

        /* Make the data go to disk */
        fprintf(stderr, "* Double sync\n");
        rump_sys_sync();
        rump_sys_sync();

        /* Get a handle to the root of the file system */
        fd = rump_sys_open(MP, O_RDONLY);
        if (fd < 0)
                atf_tc_fail_errno("rump_sys_open mount point root failed");

        return fd;
}

void teardown(int fd, struct ufs_args *argsp, off_t filesize)
{
        /* Close descriptor */
        rump_sys_close(fd);

        /* Unmount */
        if (rump_sys_unmount(MP, 0) < 0)
                atf_tc_fail_errno("rump_sys_unmount failed[1]");

        /* Fsck */
        fprintf(stderr, "* Fsck after final unmount\n");
        if (fsck())
                atf_tc_fail("fsck found errors after final unmount");

        /*
         * Check file system contents
         */

        /* Mount filesystem one last time */
        fprintf(stderr, "* Mount fs again to check contents\n");
        if (rump_sys_mount(MOUNT_LFS, MP, 0, argsp, sizeof *argsp) == -1)
                atf_tc_fail_errno("rump_sys_mount failed [4]");

        if (check_file(UNCHANGED_CONTROL, filesize, 3) != 0)
                atf_tc_fail("Unchanged control file differs(!)");

        /* Umount filesystem */
        if (rump_sys_unmount(MP, 0) < 0)
                atf_tc_fail_errno("rump_sys_unmount failed[2]");

        /* Final fsck to double check */
        fprintf(stderr, "* Fsck after final unmount\n");
        if (fsck())
                atf_tc_fail("fsck found errors after final unmount");
}

void coalesce(int width)
{
        struct ufs_args args;
        struct stat statbuf;
        struct lfs_filestat_req fsr;
        struct lfs_filestats fss_before, fss_scrambled, fss_after;
        struct lfs_inode_array inotbl;
        int fd;
        ino_t ino;
                
        fd = setup(width, &args, A_FEW_BLOCKS);
        
        /* Get our file's inode number */
        if (rump_sys_stat(UNCHANGED_CONTROL, &statbuf) != 0)
                atf_tc_fail_errno("rump_sys_stat failed");
        ino = statbuf.st_ino;

        fprintf(stderr, "Treating inode %d\n", (int)ino);

        /* Retrieve fragmentation statistics */
        memset(&fss_before, 0, sizeof fss_before);
        memset(&fss_scrambled, 0, sizeof fss_scrambled);
        memset(&fss_after, 0, sizeof fss_after);
        
        fsr.ino = ino;
        fsr.len = 1;
        fsr.fss = &fss_before;
        if (rump_sys_fcntl(fd, LFCNFILESTATS, &fsr) < 0)
                atf_tc_fail_errno("LFCNFILESTATS[1] failed");

        inotbl.len = 1;
        inotbl.inodes = &ino;
        
        fprintf(stderr, "Start ino %d nblk %d count %d total %d\n",
                (int)ino, (int)fss_before.nblk, (int)fss_before.dc_count,
                (int)fss_before.dc_sum);

        /* Scramble */
        if (rump_sys_fcntl(fd, LFCNSCRAMBLE, &inotbl) < 0)
                atf_tc_fail_errno("LFCNSCRAMBLE failed");
        fsr.fss = &fss_scrambled;
        if (rump_sys_fcntl(fd, LFCNFILESTATS, &fsr) < 0)
                atf_tc_fail_errno("LFCNFILESTATS[2] failed");
        if (fss_scrambled.dc_count <= fss_before.dc_count)
                atf_tc_fail("Scramble did not worsen gap count");
        if (fss_scrambled.dc_sum <= fss_before.dc_sum)
                atf_tc_fail("Scramble did not worsen total gap length");
        
        fprintf(stderr, "Scrambled ino %d nblk %d count %d total %d\n",
                (int)ino, (int)fss_scrambled.nblk, (int)fss_scrambled.dc_count,
                (int)fss_scrambled.dc_sum);

        /* Coalesce */
        if (rump_sys_fcntl(fd, LFCNREWRITEFILE, &inotbl) < 0)
                atf_tc_fail_errno("LFCNREWRITEFILE failed");
        fsr.fss = &fss_after;
        if (rump_sys_fcntl(fd, LFCNFILESTATS, &fsr) < 0)
                atf_tc_fail_errno("LFCNFILESTATS[3] failed");
        if (fss_scrambled.dc_count <= fss_after.dc_count)
                atf_tc_fail("Rewrite did not improve gap count");
        if (fss_scrambled.dc_sum <= fss_after.dc_sum)
                atf_tc_fail("Rewrite did not improve total gap length");

        fprintf(stderr, "Coalesced ino %d nblk %d count %d total %d\n",
                (int)ino, (int)fss_after.nblk, (int)fss_after.dc_count,
                (int)fss_after.dc_sum);

        teardown(fd, &args, A_FEW_BLOCKS);
}

void cleanseg(int width)
{
        struct ufs_args args;
        struct lfs_segnum_array sna;
        struct lfs_seguse_array sua;
        int fd, sn;
                
        fd = setup(width, &args, MORE_THAN_A_SEGMENT);

        fprintf(stderr, "* Get seguse\n");
        sua.len = LFS_SEGUSE_MAXCNT;
        sua.start = 0;
        sua.seguse = malloc(LFS_SEGUSE_MAXCNT * sizeof(*sua.seguse));
        if (rump_sys_fcntl(fd, LFCNSEGUSE, &sua) < 0)
                atf_tc_fail_errno("LFCNSEGUSE[1] failed");

        for (sn = 0; sn < (int)sua.len; ++sn) {
                if (sua.seguse[sn].su_nbytes == 0)
                        continue;
                if ((sua.seguse[sn].su_flags & (SEGUSE_DIRTY | SEGUSE_ACTIVE))
                    != SEGUSE_DIRTY)
                        continue;
                break;
        }
        if (sn == (int)sua.len)
                atf_tc_fail("No segments found to clean");
        
        fprintf(stderr, "* Cleaning segment #%d\n", sn);

        memset(&sna, 0, sizeof sna);
        sna.len = 1;
        sna.segments = &sn;
        if (rump_sys_fcntl(fd, LFCNREWRITESEGS, &sna) < 0)
                atf_tc_fail_errno("LFCNREWRITESEGS failed");

        fprintf(stderr, "* Double sync\n");
        rump_sys_sync();
        rump_sys_sync();

        fprintf(stderr, "* Get seguse again\n");
        sua.len = 1;
        sua.start = sn;
        if (rump_sys_fcntl(fd, LFCNSEGUSE, &sua) < 0)
                atf_tc_fail_errno("LFCNSEGUSE[2] failed");

        if (sua.seguse[0].su_nbytes > 0)
                atf_tc_fail("Empty bytes after clean");

        fprintf(stderr, "* Teardown\n");
        teardown(fd, &args, MORE_THAN_A_SEGMENT);
}

void autoclean(int width)
{
        struct ufs_args args;
        struct lfs_autoclean_params autoclean;
        int i, fd;
        char filename[1024];
        struct statvfs statbuf;
        CLEANERINFO64 ci_before, ci_after;
        unsigned long target;
                
        fd = setup(width, &args, CHUNKSIZE);

        rump_sys_fstatvfs1(fd, &statbuf, ST_WAIT);
        target = 7 * statbuf.f_blocks / 8;

        /* Write a number of files, deleting every other one. */
        fprintf(stderr, "* Write numbered files\n");
        for (i = 4; ; i++) {
                fprintf(stderr, "* create %d\n", i);
                sprintf(filename, "%s/%d", MP, i);
                write_file(filename, SEGSIZE / 3, 1, 0);
                rump_sys_fstatvfs1(fd, &statbuf, ST_WAIT);
                if (statbuf.f_bfree < target)
                        break;
                fprintf(stderr, "  %ld blocks vs target %ld\n",
                        (long)statbuf.f_bfree, (long)target);
        }
        rump_sys_sync();
        rump_sys_sync();

        /* Record cleanerinfo */
        fprintf(stderr, "* Get cleanerinfo\n");
        if (rump_sys_fcntl(fd, LFCNCLEANERINFO, &ci_before) < 0)
                atf_tc_fail_errno("LFCNCLEANERINFO[1] failed");

        /* Start autocleaner */
        autoclean.size = sizeof(autoclean);
        autoclean.mode = LFS_CLEANMODE_GREEDY;
        autoclean.thresh = -1;
        autoclean.target = -1;
        if (rump_sys_fcntl(fd, LFCNAUTOCLEAN, &autoclean) < 0)
                atf_tc_fail_errno("LFCNAUTOCLEAN[1] failed");

        /* Make many segments almost empty */
        fprintf(stderr, "* Delete most files\n");
        for (; i > 0; i--) {
                if (i % 3 == 0)
                        continue;
                fprintf(stderr, "* delete %d\n", i);
                sprintf(filename, "%s/%d", MP, i);
                rump_sys_unlink(filename);
        }
        rump_sys_sync();
        rump_sys_sync();

        /* Give the cleaner a chance to run */
        fprintf(stderr, "* Sleep\n");
        sleep(5);

        /* Auto reclaim freed segments */
        fprintf(stderr, "* Sync\n");
        rump_sys_sync();
        rump_sys_sync();
        
        /* Record cleanerinfo again */
        fprintf(stderr, "* Get cleanerinfo again\n");
        if (rump_sys_fcntl(fd, LFCNCLEANERINFO, &ci_after) < 0)
                atf_tc_fail_errno("LFCNCLEANERINFO[2] failed");

        /* Compare */
        if (ci_before.avail >= ci_after.avail)
                atf_tc_fail("No improvement");
        
        teardown(fd, &args, CHUNKSIZE);
}

ATF_TP_ADD_TCS(tp)
{

        ATF_TP_ADD_TC(tp, coalesce32);
        ATF_TP_ADD_TC(tp, coalesce64);
        ATF_TP_ADD_TC(tp, cleanseg32);
        ATF_TP_ADD_TC(tp, cleanseg64);
        ATF_TP_ADD_TC(tp, autoclean32);
        ATF_TP_ADD_TC(tp, autoclean64);
        return atf_no_error();
}