glibc/stdio-common/tst-fwrite-pos.c

/* Test if fwrite returns consistent values on partial writes.
   Copyright (C) 2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#include <errno.h>
/* stdio.h provides BUFSIZ, which is the size of fwrite's internal buffer.  */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/fuse.h>
#include <support/support.h>
#include <support/xstdio.h>
#include <support/temp_file.h>

/* Length of the buffer in bytes.  */
#define INBUF_SIZE (BUFSIZ)

/* Amount of bytes written to fwrite's internal cache that trigger a
   flush.  */
#define CACHE_THRESHOLD (BUFSIZ / 2)

#define ITERATIONS 1000

/* Maximum number of bytes written during a partial write.  */
#define PARTIAL_BYTES 4

#define EXPECT_EVENT(opcode, state, expected_state)             \
  {                                                             \
    if (state != expected_state)                                \
      {                                                         \
	char *s = support_fuse_opcode (opcode);                 \
	FAIL ("unexpected event %s at state %d", s, state);     \
	free (s);                                               \
      }                                                         \
  }

/* The goal of this test is to check that file position of a file stream is
   correctly updated when write () returns a partial write.
   The file system simulates pseudorandom partial writes while the test is
   running.
   Meanwhile the main thread calls fwrite () with a large object first and
   small objects later.  The usage of a large enough object ensures that
   fwrite's internal cache is full enough, without triggering a write to file.
   Subsequent calls to fwrite are guaranteed to trigger a write to file.  */

static void
fuse_thread (struct support_fuse *f, void *closure)
{
  struct fuse_in_header *inh;
  int state = 0;
  while ((inh = support_fuse_next (f)) != NULL)
    {
      {
	char *opcode = support_fuse_opcode (inh->opcode);
	printf ("info: (T) event %s(%llu) len=%u nodeid=%llu\n",
		opcode, (unsigned long long int) inh->unique, inh->len,
		(unsigned long long int) inh->nodeid);
	free (opcode);
      }

      /* Handle mountpoint and basic directory operation for the root (1).  */
      if (support_fuse_handle_mountpoint (f)
	  || (inh->nodeid == 1 && support_fuse_handle_directory (f)))
	continue;

      switch (inh->opcode)
	{
	case FUSE_LOOKUP:
	  EXPECT_EVENT (inh->nodeid, state, 0);
	  state++;
	  support_fuse_reply_error (f, ENOENT);
	  break;
	case FUSE_CREATE:
	  EXPECT_EVENT (inh->nodeid, state, 1);
	  state++;
	  struct fuse_entry_out *entry;
	  struct fuse_open_out *open;
	  support_fuse_prepare_create (f, 2, &entry, &open);
	  entry->attr.mode = S_IFREG | 0600;
	  support_fuse_reply_prepared (f);
	  break;
	case FUSE_GETXATTR:
	  /* We don't need to support extended attributes in this test.  */
	  support_fuse_reply_error (f, ENOSYS);
	  break;
	case FUSE_GETATTR:
	  /* Happens after open.  */
	  if (inh->nodeid == 2)
	    {
	      struct fuse_attr_out *out = support_fuse_prepare_attr (f);
	      out->attr.mode = S_IFREG | 0600;
	      out->attr.size = 0;
	      support_fuse_reply_prepared (f);
	    }
	  else
	    support_fuse_reply_error (f, ENOENT);
	  break;
	case FUSE_WRITE:
	  if (inh->nodeid == 2)
	    {
	      struct fuse_write_out out;
	      if (state > 1 && state < ITERATIONS + 2)
		{
		  /* The 2nd and subsequent calls to fwrite () trigger a
		     flush of fwrite's internal cache.  Simulate a partial
		     write of up to PARTIAL_BYTES bytes.  */
		  out.padding = 0;
		  out.size = 1 + rand () % PARTIAL_BYTES,
		  state++;
		  support_fuse_reply (f, &out, sizeof (out));
		}
	      else if (state >= ITERATIONS + 2)
		{
		  /* This request is expected to come from fflush ().  Copy
		     all the data successfully.  This may be executed more
		     than once.  */
		  struct fuse_write_in *p = support_fuse_cast (WRITE, inh);
		  out.padding = 0;
		  out.size = p->size,
		  state++;
		  support_fuse_reply (f, &out, sizeof (out));
		}
	      else
		support_fuse_reply_error (f, EIO);
	    }
	  else
	    support_fuse_reply_error (f, EIO);
	  break;
	case FUSE_FLUSH:
	case FUSE_RELEASE:
	  TEST_COMPARE (inh->nodeid, 2);
	  support_fuse_reply_empty (f);
	  break;
	default:
	  FAIL ("unexpected event %s", support_fuse_opcode (inh->opcode));
	  support_fuse_reply_error (f, EIO);
	}
    }
}

static int
do_test (void)
{
  char *in;
  int i;
  size_t written;

  _Static_assert (CACHE_THRESHOLD <= INBUF_SIZE,
		  "the input buffer must be larger than the cache threshold");
  /* Avoid filling up fwrite's cache.  */
  _Static_assert (CACHE_THRESHOLD - 1 + PARTIAL_BYTES * ITERATIONS <= BUFSIZ,
		  "fwrite's cache must fit all data written");

  support_fuse_init ();
  struct support_fuse *fs = support_fuse_mount (fuse_thread, NULL);

  /* Create and open a temporary file in the fuse mount point.  */
  char *fname = xasprintf ("%s/%sXXXXXX", support_fuse_mountpoint (fs),
                           "tst-fwrite-fuse");
  int fd = mkstemp (fname);
  TEST_VERIFY_EXIT (fd != -1);
  FILE *f = fdopen (fd, "w");
  TEST_VERIFY_EXIT (f != NULL);

  /* Allocate an input array that will be written to the temporary file.  */
  in = xmalloc (INBUF_SIZE);
  for (i = 0; i < INBUF_SIZE; i++)
    in[i] = i % 0xff;

  /* Ensure the file position indicator is at the beginning of the stream.  */
  TEST_COMPARE (ftell (f), 0);

  /* Try to fill as most data to the cache of the file stream as possible
     with a single large object.
     All data is expected to be written to the cache.
     No errors are expected from this.  */
  TEST_COMPARE (fwrite (in, CACHE_THRESHOLD - 1, 1, f), 1);
  TEST_COMPARE (ferror (f), 0);
  written = CACHE_THRESHOLD - 1;

  /* Ensure the file position indicator advanced correctly.  */
  TEST_COMPARE (ftell (f), written);

  for (i = 0; i < ITERATIONS; i++)
    {
      /* Write an extra object of size PARTIAL_BYTES that triggers a write to
	 disk.  Our FS will write at most PARTIAL_BYTES bytes to the file
	 instead of all the data.  By writting PARTIAL_BYTES, we guarantee
	 the amount of data in the cache will never decrease below
	 CACHE_THRESHOLD.
	 No errors are expected.  */
      TEST_COMPARE (fwrite (in, PARTIAL_BYTES, 1, f), 1);
      TEST_COMPARE (ferror (f), 0);
      written += PARTIAL_BYTES;

      /* Ensure the file position indicator advanced correctly.  */
      TEST_COMPARE (ftell (f), written);
    }

  /* Flush the rest of the data.  */
  TEST_COMPARE (fflush (f), 0);
  TEST_COMPARE (ferror (f), 0);

  /* Ensure the file position indicator was not modified.  */
  TEST_COMPARE (ftell (f), written);

  /* In case an unexpected error happened, clear it before exiting.  */
  if (ferror (f))
    clearerr (f);

  xfclose (f);
  free (fname);
  free (in);
  support_fuse_unmount (fs);
  return 0;
}

#include <support/test-driver.c>