[PATCH] Add new tests for fopen
DJ Delorie
dj@redhat.com
Wed Jan 22 23:19:05 GMT 2025
Copyright years need updating throughout...
Missing xpthread_barrier_init() in threaded test 2
Martin Coufal <mcoufal@redhat.com> writes:
> Adding some basic tests for fopen, testing different modes, stream
> positioning and concurrent read/write operation on files.
> diff --git a/stdio-common/Makefile b/stdio-common/Makefile
> tst-fmemopen2 \
> tst-fmemopen3 \
> tst-fmemopen4 \
> + tst-fopen \
> tst-fphex \
Ok.
> diff --git a/stdio-common/tst-fopen.c b/stdio-common/tst-fopen.c
> +/* Basic test for fopen.
> + Copyright (C) 2024 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>
> +#include <stdio.h>
> +#include <string.h>
> +#include <unistd.h>
> +
> +#include <support/check.h>
> +#include <support/temp_file.h>
> +#include <support/xstdio.h>
Ok.
> +#define APPENDED_TEXT "This is appended text. "
> +#define DEFAULT_TEXT "Lorem ipsum dolor sit amet, consectetur " \
> + "adipiscing elit, sed do eiusmod tempor incididunt ut labore et " \
> + "dolore magna aliqua."
> +#define MAX_BUFFER_SIZE 300
Ok.
> +
> +static int
> +do_test (void)
> +{
> + char *temp_file;
> + FILE *fd_file = NULL;
> + char read_buffer[MAX_BUFFER_SIZE] = "";
> + size_t ret;
Ok.
> + /* Prepare files. */
> + int fd = create_temp_file ("tst-fopen.", &temp_file);
> + TEST_VERIFY_EXIT (fd != -1);
> + fd_file = fdopen (fd, "w");
> + ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> + xfclose (fd_file);
Ok. File has "DEFAULT_TEXT"
> + /* Test 1: This checks for fopen with mode "r". Open text file for
> + reading. The stream is positioned at the beginning of the file. */
> + printf ("Test 1: This checks for fopen with mode \"r\".\n");
> + fd_file = fopen (temp_file, "r");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + /* Read should succeed. */
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> + TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT) == 0);
Ok.
> + /* Write should fail. */
> + errno = 0;
> + ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> + TEST_VERIFY (ferror (fd_file) != 0);
> + TEST_COMPARE (errno, EBADF);
> + TEST_COMPARE (ret, 0);
> + clearerr (fd_file);
Ok.
> + /* Opening non-existent file should fail. */
> + xfclose (fd_file);
> + errno = 0;
> + fd_file = fopen ("file-that-does-not-exist", "r");
> + TEST_VERIFY (fd_file == NULL);
> + TEST_COMPARE (errno, ENOENT);
> + TEST_VERIFY (fd_file == NULL);
Ok.
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
Ok.
> + /* Test 2: This checks for fopen with mode "r+". Open for reading and
> + writing. The stream is positioned at the beginning of the file. */
> + printf ("Test 2: This checks for fopen with mode \"r+\".\n");
> + fd_file = fopen (temp_file, "r+");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + /* Read should succeed. */
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> + TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT) == 0);
Ok.
> + fflush (fd_file);
> + /* File position indicator expected at 0 + read bytes. */
> + TEST_COMPARE (ftell (fd_file), ret);
Ok.
> + /* Write should succeed. */
> + ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
Ok.
> + /* Opening non-existent file should fail. */
> + xfclose (fd_file);
> + errno = 0;
> + fd_file = fopen ("file-that-does-not-exist", "r+");
> + TEST_VERIFY (fd_file == NULL);
> + TEST_COMPARE (errno, ENOENT);
> + TEST_VERIFY (fd_file == NULL);
Ok.
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
> +
> + /* Test 3: This checks for fopen with mode "w". Truncate file to zero
> + length or create text file for writing. The stream is positioned
> + at the beginning of the file. */
> + printf ("Test 3: This checks for fopen with mode \"w\".\n");
> + fd_file = fopen (temp_file, "w");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + /* Read should fail. */
> + errno = 0;
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_VERIFY (ferror (fd_file) != 0);
> + TEST_COMPARE (errno, EBADF);
> + TEST_COMPARE (ret, 0);
Ok.
> + clearerr (fd_file);
> + /* Write should succeed. */
> + ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
Ok.
> + /* Opening non-existent file should succeed. */
> + xfclose (fd_file);
> + fd_file = fopen ("/tmp/file-that-does-not-exist", "w");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + xfclose (fd_file);
> + remove ("/tmp/file-that-does-not-exist");
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
Ok.
> + /* Test 4: This checks for fopen with mode "w+". Open for reading and
> + writing. The file is created if it does not exist, otherwise it is
> + truncated. The stream is positioned at the beginning of the file.
> + */
> + printf ("Test 4: This checks for fopen with mode \"w+\".\n");
> + fd_file = fopen (temp_file, "w+");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + /* Read should succeed. */
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, 0);
> + TEST_VERIFY (read_buffer[0] == '\0');
Ok.
> + /* Write should succeed. */
> + ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
Ok.
> + /* Opening non-existent file should succeed. */
> + xfclose (fd_file);
> + fd_file = fopen ("/tmp/file-that-does-not-exist", "w+");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + xfclose (fd_file);
> + remove ("/tmp/file-that-does-not-exist");
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
Ok.
> + /* Test 5: This checks for fopen with mode "a". Open for appending
> + (writing at end of file). The file is created if it does not
> + exist. The stream is positioned at the end of the file. */
> + printf ("Test 5: This checks for fopen with mode \"a\".\n");
> + fd_file = fopen (temp_file, "a");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), strlen (DEFAULT_TEXT));
Ok.
> + /* Read should fail. */
> + errno = 0;
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_VERIFY (ferror (fd_file) != 0);
> + TEST_COMPARE (errno, EBADF);
> + TEST_COMPARE (ret, 0);
Ok.
> + clearerr (fd_file);
> + /* Write should succeed. */
> + ret = fwrite (APPENDED_TEXT, sizeof (char), strlen (APPENDED_TEXT), fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (APPENDED_TEXT));
Ok.
> + /* The file position indicator for the stream is advanced by the
> + * number of bytes successfully read or written. */
> + TEST_COMPARE (ftell (fd_file), strlen (DEFAULT_TEXT) + ret);
Ok.
> + /* Opening non-existent file should succeed. */
> + xfclose (fd_file);
> + fd_file = fopen ("/tmp/file-that-does-not-exist", "a");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + xfclose (fd_file);
> + remove ("/tmp/file-that-does-not-exist");
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
Ok.
> + /* Test 6: This checks for fopen with mode "a+". Open for reading and
> + appending (writing at end of file). The file is created if it does
> + not exist. Output is always appended to the end of the file. The
> + initial file position for reading is at the beginning of the file,
> + but it is advanced to the end prior to each write. */
> + printf ("Test 6: This checks for fopen with mode \"a+\".\n");
> + errno = 0;
> + fd_file = fopen (temp_file, "a+");
> + TEST_COMPARE (errno, 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + /* Read should succeed. */
> + ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (DEFAULT_TEXT) + strlen (APPENDED_TEXT));
> + TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT APPENDED_TEXT) == 0);
Ok.
> + /* Write should succeed. */
> + const char* SECOND_APPEND = "This is second append.";
> + ret = fwrite (SECOND_APPEND, sizeof (char), strlen (SECOND_APPEND), fd_file);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_COMPARE (ret, strlen (SECOND_APPEND));
Ok.
> + /* The file position indicator for the stream is advanced by the
> + number of bytes successfully read or written. */
> + TEST_COMPARE (ftell (fd_file),
> + strlen (DEFAULT_TEXT) + strlen (APPENDED_TEXT) + ret);
Ok.
> + /* Opening non-existent file should succeed. */
> + xfclose (fd_file);
> + fd_file = fopen ("/tmp/file-that-does-not-exist", "a+");
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + TEST_COMPARE (ftell (fd_file), 0);
Ok.
> + xfclose (fd_file);
> + remove ("/tmp/file-that-does-not-exist");
> + memset (read_buffer, 0, MAX_BUFFER_SIZE);
Ok.
> + /* Test 7: This checks for fopen with other valid modes set, such as
> + "rc", "we" or "am". The test calls fopen with these modes and
> + checks that no errors appear. */
> + printf ("Test 7: This checks for fopen with other valid modes set, "
> + "such as \"rc\", \"we\" or \"am\".\n");
> + /* These modes all operate correctly with the file already present. */
> + static const char *valid_modes[] =
> + { "rc", "we", "am", "r+x", "wb+", "ab", 0 };
> + const char **p = valid_modes;
> + while (*p != 0)
> + {
> + fd_file = fopen (temp_file, *p);
> + TEST_COMPARE (ferror (fd_file), 0);
> + TEST_VERIFY (fd_file != NULL);
> + xfclose (fd_file);
> + ++p;
> + }
Ok.
> + /* Test 8: This checks for fopen with invalid modes. The test calls
> + fopen with these modes and checks that opening existing files with
> + invalid mode fails and that opening non-existing files with invalid
> + mode doesn't create a new file. */
> + printf ("Test 8: This checks for fopen with invalid modes.\n");
> + static const char *invalid_modes[] = { "0", "tr", "z", "x", " ", 0 };
> + p = invalid_modes;
> + while (*p != 0)
> + {
> + errno = 0;
> + fd_file = fopen (temp_file, *p);
> + TEST_VERIFY (fd_file == NULL);
> + TEST_COMPARE (errno, EINVAL);
> + errno = 0;
> + fd_file = fopen ("/tmp/file-that-does-not-exist", *p);
> + TEST_VERIFY (fd_file == NULL);
> + TEST_COMPARE (errno, EINVAL);
> + ++p;
> + TEST_VERIFY (access ("/tmp/file-that-does-not-exist", F_OK) == -1);
> + }
Ok.
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
Ok.
> diff --git a/sysdeps/pthread/Makefile b/sysdeps/pthread/Makefile
> index a123e28a57..5947db43f3 100644
> --- a/sysdeps/pthread/Makefile
> +++ b/sysdeps/pthread/Makefile
> @@ -154,6 +154,7 @@ tests += \
> tst-exit3 \
> tst-flock1 \
> tst-flock2 \
> + tst-fopen-threaded \
> tst-fork1 \
> tst-fork2 \
> tst-fork3 \
Ok.
> diff --git a/sysdeps/pthread/tst-fopen-threaded.c b/sysdeps/pthread/tst-fopen-threaded.c
> new file mode 100644
> index 0000000000..07bcea16db
> --- /dev/null
> +++ b/sysdeps/pthread/tst-fopen-threaded.c
> @@ -0,0 +1,249 @@
> +/* Test for fread and fwrite with multiple threads.
> + Copyright (C) 2024 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/>. */
> +
> +/* Description of test intent.
> + The test creates NUM_THREADS threads for reading and writing to the
> + prepared file. The prepared file contains 'NUM_THREADS - 1' bytes
> + where each byte is unique number from 0 to 'NUM_THREADS - 2'. If all
> + operations are correctly multi-threaded safe then all concurent read
> + operations should succeed and read a unique 1 byte value. The last
> + thread to read should get an EOF. In concurrent write, all write
> + operations should succeed and the file should contain all unique 1
> + byte values from 0 to 'NUM_THREADS - 1'. Both concurrent read and
> + concurrent write tests are repeated ITERS times to increase
> + the probability of detecting concurrency issues. */
> +
> +#include <errno.h>
> +#include <pthread.h>
> +#include <stdbool.h>
> +#include <stdio.h>
> +#include <string.h>
> +#include <unistd.h>
> +
> +#include <support/check.h>
> +#include <support/temp_file.h>
> +#include <support/xstdio.h>
> +#include <support/xthread.h>
> +
> +#define NUM_THREADS 100
> +#define ITERS 10
Ok.
> +char *temp_file;
> +pthread_barrier_t barrier;
> +
> +struct thread_data
> +{
> + FILE *fd;
> + /* Read value or value to be written. */
> + unsigned char value;
> + bool eof;
> +};
Ok.
> +static void *
> +threadReadRoutine (void *argv)
> +{
> + struct thread_data *my_data;
> + unsigned char read_buffer;
> + int ret = 0;
> + my_data = (struct thread_data *) argv;
> + /* Wait for all threads to be ready to read. */
> + xpthread_barrier_wait (&barrier);
Ok.
> + ret =
> + fread (&read_buffer, sizeof (char), sizeof (read_buffer), my_data->fd);
> + if (feof (my_data->fd) != 0)
> + {
> + clearerr (my_data->fd);
> + my_data->eof = true;
> + }
> + else
> + {
> + TEST_COMPARE (ret, 1);
> + /* Save the read value. */
> + my_data->value = read_buffer;
> + }
> + TEST_COMPARE (ferror (my_data->fd), 0);
> + return NULL;
> +}
Ok.
> +void *
> +threadWriteRoutine (void *argv)
> +{
> + struct thread_data *my_data;
> + int ret = 0;
> + my_data = (struct thread_data *) argv;
> + /* Wait for all threads to be ready to write. */
> + xpthread_barrier_wait (&barrier);
Ok.
> + ret = fwrite (&my_data->value, sizeof (unsigned char), 1, my_data->fd);
> + TEST_COMPARE (ferror (my_data->fd), 0);
> + TEST_COMPARE (feof (my_data->fd), 0);
> + TEST_COMPARE (ret, 1);
> + return NULL;
> +}
Ok.
> +void *
> +threadOpenCloseRoutine (void *argv)
> +{
> + /* Wait for all threads to be ready to call fopen and fclose. */
> + xpthread_barrier_wait (&barrier);
> +
> + FILE *fd = xfopen ("/tmp/openclosetest", "w+");
> + xfclose (fd);
> + return NULL;
> +}
Ok.
> +static int
> +do_test (void)
> +{
> + FILE *fd_file = NULL;
> + unsigned char buffer[NUM_THREADS] = "0";
> + size_t ret = 0;
> + pthread_t threads[NUM_THREADS];
> + struct thread_data thread_data_array[NUM_THREADS];
> + bool present_values[NUM_THREADS] = { false };
Ok.
> + /* Prepare files. */
> + for (int i = 0; i < NUM_THREADS; i++)
> + buffer[i] = i;
Ok.
> + int fd = create_temp_file ("tst-fopen.", &temp_file);
> + TEST_VERIFY_EXIT (fd != -1);
> + fd_file = fdopen (fd, "w");
Ok.
> + /* NUM_THREADS - 1: last thread will read EOF */
> + ret = fwrite (buffer, sizeof (unsigned char), NUM_THREADS - 1, fd_file);
> + TEST_COMPARE (ret, NUM_THREADS - 1);
> + xfclose (fd_file);
Ok.
> + /* Test 1: Concurrent read. */
> + for (int reps = 1; reps <= ITERS; reps++)
> + {
> + fd_file = xfopen (temp_file, "r");
> + xpthread_barrier_init (&barrier, NULL, NUM_THREADS);
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + thread_data_array[i].fd = fd_file;
> + /* Initialize with highest possible value so it's easier to debug if
> + anything goes wrong. */
> + thread_data_array[i].value = 255;
> + thread_data_array[i].eof = false;
> +
> + threads[i] =
> + xpthread_create (support_small_stack_thread_attribute (),
> + threadReadRoutine,
> + (void *) &thread_data_array[i]);
> + }
> +
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + xpthread_join (threads[i]);
> + }
> + xpthread_barrier_destroy (&barrier);
> + xfclose (fd_file);
Ok.
> + /* Verify read values. */
> + int eof_cnt = 0;
> + for (int i = 0; i < NUM_THREADS; i++)
> + present_values[i] = false;
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + if (thread_data_array[i].eof)
> + {
> + /* EOF was read. */
> + present_values[NUM_THREADS - 1] = true;
> + eof_cnt++;
> + }
> + else
> + {
> + /* The same value shouldn't be read twice. */
> + TEST_VERIFY (!present_values[thread_data_array[i].value]);
> + present_values[thread_data_array[i].value] = true;
> + }
> + }
> + /* EOF is read exactly once. */
> + TEST_COMPARE (eof_cnt, 1);
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + /* All values should be read. */
> + TEST_VERIFY (present_values[i]);
> + }
> + }
Ok.
> + /* Test 2: Concurrent write. */
> + for (int reps = 1; reps <= ITERS; reps++)
> + {
> + fd_file = xfopen (temp_file, "w");
You need a xpthread_barrier_init() here.
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + thread_data_array[i].fd = fd_file;
> + thread_data_array[i].value = i;
> +
> + threads[i] =
> + xpthread_create (support_small_stack_thread_attribute (),
> + threadWriteRoutine,
> + (void *) &thread_data_array[i]);
> + }
> +
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + xpthread_join (threads[i]);
> + }
> + xpthread_barrier_destroy (&barrier);
> + xfclose (fd_file);
Ok.
> + /* Verify written values. */
> + for (int i = 0; i < NUM_THREADS; i++)
> + present_values[i] = false;
> + memset (buffer, 0, NUM_THREADS);
> + fd_file = xfopen (temp_file, "r");
> + ret = fread (buffer, sizeof (unsigned char), NUM_THREADS, fd_file);
> + TEST_COMPARE (ret, NUM_THREADS);
Ok.
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + /* The same value shouldn't be written twice. */
> + TEST_VERIFY (!present_values[buffer[i]]);
> + present_values[buffer[i]] = true;
> + }
Ok.
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + /* All values should be written. */
> + TEST_VERIFY (present_values[i]);
> + }
> + xfclose (fd_file);
> + }
Ok.
> + /* Test 3: Concurrent open/close. */
> + for (int reps = 1; reps <= ITERS; reps++)
> + {
> + xpthread_barrier_init (&barrier, NULL, NUM_THREADS);
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + threads[i] =
> + xpthread_create (support_small_stack_thread_attribute (),
> + threadOpenCloseRoutine, NULL);
> + }
> + for (int i = 0; i < NUM_THREADS; i++)
> + {
> + xpthread_join (threads[i]);
> + }
> + xpthread_barrier_destroy (&barrier);
> + }
> +
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
Ok.
More information about the Libc-alpha
mailing list