Hello community,
here is the log from the commit of package stress-ng for openSUSE:Factory
checked in at 2017-08-10 14:06:19
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/stress-ng (Old)
and /work/SRC/openSUSE:Factory/.stress-ng.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "stress-ng"
Thu Aug 10 14:06:19 2017 rev:17 rq:515419 version:0.08.10
Changes:
--------
--- /work/SRC/openSUSE:Factory/stress-ng/stress-ng.changes 2017-07-19
12:22:17.481502410 +0200
+++ /work/SRC/openSUSE:Factory/.stress-ng.new/stress-ng.changes 2017-08-10
14:13:37.591584069 +0200
@@ -1,0 +2,20 @@
+Tue Aug 8 06:28:58 UTC 2017 - mar...@gmx.de
+
+- Update to version 0.08.10:
+ * Makefile: bump version
+ * stress-dirdeep: fix warning on unused variable ret on BSD systems
+ * Update manual description for the --all option
+ * job: allow classes to be run as jobs (LP: #1706970)
+ * stress-dirdeep: don't remove directories in main exercise function
+ * return EXIT_SUCCESS for class cpu? class command
+ * stress-dirdeep: exercise files rather than create/delete
+ * manual: fix wording in memthrash table
+ * stress-dirdeep: Fix inode accounting, add more -v information feedback
+ * Add --dirdeep-inodes option to limit of inodes being consumed:
+ * parse-opts: don't allow negative percentages
+ * Add stress_get_filesystem_available_inodes to get inode number
+ * Add generialized percentage opt parser get_uint64_percent
+ * helper: remove debug message from stress_get_filesystem_size
+ * stress-ng: ensure --version option terminates immediately
+
+-------------------------------------------------------------------
Old:
----
stress-ng-0.08.09.tar.gz
New:
----
stress-ng-0.08.10.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ stress-ng.spec ++++++
--- /var/tmp/diff_new_pack.LHTcfz/_old 2017-08-10 14:13:38.291485521 +0200
+++ /var/tmp/diff_new_pack.LHTcfz/_new 2017-08-10 14:13:38.303483832 +0200
@@ -18,7 +18,7 @@
Name: stress-ng
-Version: 0.08.09
+Version: 0.08.10
Release: 0
Summary: Tool to load and stress a computer
License: GPL-2.0
++++++ stress-ng-0.08.09.tar.gz -> stress-ng-0.08.10.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/Makefile
new/stress-ng-0.08.10/Makefile
--- old/stress-ng-0.08.09/Makefile 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/Makefile 2017-08-07 22:34:14.000000000 +0200
@@ -16,7 +16,7 @@
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
USA.
#
-VERSION=0.08.09
+VERSION=0.08.10
#
# Codename "harmful hardware harasser"
#
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/helper.c
new/stress-ng-0.08.10/helper.c
--- old/stress-ng-0.08.09/helper.c 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/helper.c 2017-08-07 22:34:14.000000000 +0200
@@ -222,14 +222,30 @@
if (blocks > max_blocks)
blocks = max_blocks;
- (void)printf("stress_get_filesystem_size: %" PRIu64 " %" PRIu64 " %"
PRIu64 "\n",
- (uint64_t)buf.f_bsize, (uint64_t)blocks,
- (uint64_t)buf.f_bsize * blocks);
-
return (uint64_t)buf.f_bsize * blocks;
}
/*
+ * stress_get_filesystem_available_inodes()
+ * get number of free inodes on the current stress
+ * temporary path, return 0 if failed
+ */
+uint64_t stress_get_filesystem_available_inodes(void)
+{
+ int rc;
+ struct statvfs buf;
+
+ if (!stress_temp_path)
+ return 0;
+
+ rc = statvfs(stress_temp_path, &buf);
+ if (rc < 0)
+ return 0;
+
+ return (uint64_t)buf.f_favail;
+}
+
+/*
* stress_set_nonblock()
* try to make fd non-blocking
*/
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/job.c new/stress-ng-0.08.10/job.c
--- old/stress-ng-0.08.09/job.c 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/job.c 2017-08-07 22:34:14.000000000 +0200
@@ -64,7 +64,7 @@
!strcmp(argv[2], "seq")) {
if (*flag & RUN_PARALLEL)
goto err;
- *flag |= RUN_PARALLEL;
+ *flag |= RUN_SEQUENTIAL;
g_opt_flags |= OPT_FLAGS_SEQUENTIAL;
return 1;
}
@@ -73,8 +73,9 @@
!strcmp(argv[2], "together")) {
if (*flag & RUN_SEQUENTIAL)
goto err;
- *flag |= RUN_SEQUENTIAL;
+ *flag |= RUN_PARALLEL;
g_opt_flags &= ~OPT_FLAGS_SEQUENTIAL;
+ g_opt_flags |= OPT_FLAGS_ALL;
return 1;
}
err:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/parse-opts.c
new/stress-ng-0.08.10/parse-opts.c
--- old/stress-ng-0.08.09/parse-opts.c 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/parse-opts.c 2017-08-07 22:34:14.000000000 +0200
@@ -210,23 +210,27 @@
}
/*
- * get_uint64_byte_memory()
- * get memory size from string. If it contains %
- * at the end, then covert it into the available
- * physical memory scaled by that percentage divided
- * by the number of stressor instances
+ * get_uint64_percent()
+ * get a value by whole number or by percentage
*/
-uint64_t get_uint64_byte_memory(
+uint64_t get_uint64_percent(
const char *const str,
- const uint32_t instances)
+ const uint32_t instances,
+ const uint64_t max,
+ const char *const errmsg)
{
size_t len = strlen(str);
- /* Convert to % of memory over N instances */
+ /* Convert to % over N instances */
if ((len > 1) && (str[len - 1] == '%')) {
- uint64_t phys_mem = stress_get_phys_mem_size();
double val;
+ /* Avoid division by zero */
+ if (max == 0) {
+ (void)fprintf(stderr, "%s\n", errmsg);
+ longjmp(g_error_env, 1);
+ }
+
/* Should NEVER happen */
if (instances < 1) {
(void)fprintf(stderr, "Invalid number of instances\n");
@@ -236,16 +240,33 @@
(void)fprintf(stderr, "Invalid percentage %s\n", str);
longjmp(g_error_env, 1);
}
- if (phys_mem == 0) {
- (void)fprintf(stderr, "Cannot determine physical memory
size\n");
+ if (val < 0.0) {
+ (void)fprintf(stderr, "Invalid percentage %s\n", str);
longjmp(g_error_env, 1);
}
- return (uint64_t)((double)(phys_mem * val) / (100.0 *
instances));
+ return (uint64_t)((double)(max * val) / (100.0 * instances));
}
return get_uint64_byte(str);
}
/*
+ * get_uint64_byte_memory()
+ * get memory size from string. If it contains %
+ * at the end, then covert it into the available
+ * physical memory scaled by that percentage divided
+ * by the number of stressor instances
+ */
+uint64_t get_uint64_byte_memory(
+ const char *const str,
+ const uint32_t instances)
+{
+ uint64_t phys_mem = stress_get_phys_mem_size();
+
+ return get_uint64_percent(str, instances, phys_mem,
+ "Cannot determine physical memory size");
+}
+
+/*
* get_uint64_byte_filesystem()
* get file size from string. If it contains %
* at the end, then covert it into the available
@@ -256,29 +277,10 @@
const char *const str,
const uint32_t instances)
{
- size_t len = strlen(str);
+ uint64_t bytes = stress_get_filesystem_size();
- /* Convert to % of available filesystem space over N instances */
- if ((len > 1) && (str[len - 1] == '%')) {
- uint64_t bytes = stress_get_filesystem_size();
- double val;
-
- /* Should NEVER happen */
- if (instances < 1) {
- (void)fprintf(stderr, "Invalid number of instances\n");
- longjmp(g_error_env, 1);
- }
- if (sscanf(str, "%lf", &val) != 1) {
- (void)fprintf(stderr, "Invalid percentage %s\n", str);
- longjmp(g_error_env, 1);
- }
- if (bytes == 0) {
- (void)fprintf(stderr, "Cannot determine available space
on file system\n");
- longjmp(g_error_env, 1);
- }
- return (uint64_t)((double)(bytes * val) / (100.0 * instances));
- }
- return get_uint64_byte(str);
+ return get_uint64_percent(str, instances, bytes,
+ "Cannot determine available space on file system");
}
/*
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/stress-dirdeep.c
new/stress-ng-0.08.10/stress-dirdeep.c
--- old/stress-ng-0.08.09/stress-dirdeep.c 2017-07-18 11:53:20.000000000
+0200
+++ new/stress-ng-0.08.10/stress-dirdeep.c 2017-08-07 22:34:14.000000000
+0200
@@ -35,12 +35,27 @@
uint32_t dirdeep_dirs;
dirdeep_dirs = get_uint32(opt);
- check_range("dirdeep-dirs", dirdeep_dirs,
- 1, 10);
+
+ check_range("dirdeep-dirs", dirdeep_dirs, 1, 10);
set_setting("dirdeep-dirs", TYPE_ID_UINT32, &dirdeep_dirs);
}
/*
+ * stress_set_dirdeep_inodes()
+ * set max number of inodes to consume
+ */
+void stress_set_dirdeep_inodes(const char *opt)
+{
+ uint64_t inodes = stress_get_filesystem_available_inodes();
+ uint64_t dirdeep_inodes;
+
+ dirdeep_inodes = get_uint64_percent(opt, 1, inodes,
+ "Cannot determine number of available free inodes");
+ set_setting("dirdeep-inodes", TYPE_ID_UINT64, &dirdeep_inodes);
+}
+
+
+/*
* stress_dir_make()
* depth-first tree creation, create lots of sub-trees with
* dirdeep_dir number of subtress per level.
@@ -52,11 +67,20 @@
const size_t len,
const size_t path_len,
const uint32_t dirdeep_dirs,
- uint32_t *depth)
+ const uint64_t dirdeep_inodes,
+ const uint64_t inodes_target_free,
+ uint64_t *min_inodes_free,
+ uint32_t depth)
{
uint32_t i;
int ret;
+ uint64_t inodes_avail = stress_get_filesystem_available_inodes();
+
+ if (*min_inodes_free > inodes_avail)
+ *min_inodes_free = inodes_avail;
+ if (inodes_avail <= inodes_target_free)
+ return;
if (len + 2 >= path_len)
return;
if (!keep_stressing())
@@ -77,7 +101,7 @@
/*
* Top level, create file to symlink and link to
*/
- if (!(*depth)) {
+ if (!depth) {
int fd;
fd = creat(linkpath, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
@@ -88,24 +112,96 @@
(void)close(fd);
}
- (*depth)++;
-
path[len] = '/';
path[len + 1] = 's'; /* symlink */
path[len + 2] = '\0';
ret = symlink(linkpath, path);
(void)ret;
+
path[len + 1] = 'h'; /* hardlink */
ret = link(linkpath, path);
(void)ret;
for (i = 0; i < dirdeep_dirs; i++) {
path[len + 1] = '0' + i;
- stress_dir_make(args, linkpath, path, len + 2, path_len,
dirdeep_dirs, depth);
+ stress_dir_make(args, linkpath, path, len + 2, path_len,
+ dirdeep_dirs, dirdeep_inodes,
inodes_target_free,
+ min_inodes_free, depth + 1);
+ }
+ path[len] = '\0';
+}
+
+/*
+ * stress_dir_exercise()
+ * exercise files and directories in the tree
+ */
+static void stress_dir_exercise(
+ const args_t *args,
+ char *const path,
+ const size_t len,
+ const size_t path_len)
+{
+ struct dirent **namelist;
+ int n;
+#if _POSIX_C_SOURCE >= 200809L
+ const double now = time_now();
+ const time_t sec = (time_t)now;
+ const long nsec = (long)((now - (double)sec) * 1000000000.0);
+ struct timespec times[2] = {
+ { sec, nsec },
+ { sec, nsec }
+ };
+#endif
+
+ if (len + 2 >= path_len)
+ return;
+
+ n = scandir(path, &namelist, NULL, alphasort);
+ if (n < 0)
+ return;
+
+ while (n--) {
+ if (namelist[n]->d_name[0] == '.')
+ continue;
+
+ path[len] = '/';
+ path[len + 1] = namelist[n]->d_name[0];
+ path[len + 2] = '\0';
+
+ if (isdigit((int)namelist[n]->d_name[0])) {
+ stress_dir_exercise(args, path, len + 2, path_len);
+ } else {
+ int fd;
+
+ /* This will update atime only */
+ fd = open(path, O_RDONLY);
+ if (fd >= 0) {
+ const uint16_t rnd = mwc16();
+#if _POSIX_C_SOURCE >= 200809L
+ int ret = futimens(fd, times);
+ (void)ret;
+#endif
+ /* Occasional flushing */
+ if (rnd >= 0xfff0) {
+#if defined(__linux__) && NEED_GLIBC(2,14,0)
+ (void)syncfs(fd);
+#else
+ (void)sync();
+#endif
+ } else if (rnd > 0xff40) {
+ (void)fsync(fd);
+ }
+ (void)close(fd);
+ }
+ inc_counter(args);
+ }
+ free(namelist[n]);
}
path[len] = '\0';
+ free(namelist);
}
+
/*
* stress_dir_tidy()
* clean up all files and directories in the tree
@@ -160,8 +256,16 @@
char rootpath[PATH_MAX];
size_t path_len;
uint32_t dirdeep_dirs = 1;
+ uint64_t dirdeep_inodes = ~0ULL;
+ const uint64_t inodes_avail = stress_get_filesystem_available_inodes();
+ uint64_t inodes_target_free;
+ uint64_t min_inodes_free = ~0ULL;
(void)get_setting("dirdeep-dirs", &dirdeep_dirs);
+ (void)get_setting("dirdeep-inodes", &dirdeep_inodes);
+
+ inodes_target_free = (inodes_avail > dirdeep_inodes) ?
+ inodes_avail - dirdeep_inodes : 0;
(void)stress_temp_dir_args(args, rootpath, sizeof(rootpath));
path_len = strlen(rootpath);
@@ -169,17 +273,26 @@
strncpy(linkpath, rootpath, sizeof(linkpath));
strncat(linkpath, "/f", sizeof(linkpath) - 3);
- do {
- uint32_t depth = 0;
+ pr_inf("%s: %" PRIu64 " inodes available, exercising up to %" PRIu64 "
inodes\n",
+ args->name, inodes_avail, inodes_avail - inodes_target_free);
+ strncpy(path, rootpath, sizeof(path));
+ stress_dir_make(args, linkpath, path, path_len, sizeof(path),
+ dirdeep_dirs, dirdeep_inodes, inodes_target_free,
&min_inodes_free, 0);
+ do {
strncpy(path, rootpath, sizeof(path));
- stress_dir_make(args, linkpath, path, path_len, sizeof(path),
dirdeep_dirs, &depth);
- strncpy(path, rootpath, sizeof(path));
- if (!keep_stressing())
- pr_tidy("%s: removing directories\n", args->name);
- stress_dir_tidy(args, path, path_len, sizeof(path));
- sync();
+ stress_dir_exercise(args, path, path_len, sizeof(path));
} while (keep_stressing());
+ strncpy(path, rootpath, sizeof(path));
+ pr_tidy("%s: removing directories\n", args->name);
+ stress_dir_tidy(args, path, path_len, sizeof(path));
+
+ pr_inf("%s: %" PRIu64 " inodes exercised\n", args->name, inodes_avail -
min_inodes_free);
+ if (inodes_target_free < min_inodes_free)
+ pr_inf("%s: note: specifying a larger --dirdeep setting or "
+ "running the stressor for longer will use more "
+ "inodes\n", args->name);
+
return ret;
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/stress-ng.1
new/stress-ng-0.08.10/stress-ng.1
--- old/stress-ng-0.08.09/stress-ng.1 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/stress-ng.1 2017-08-07 22:34:14.000000000 +0200
@@ -2,7 +2,7 @@
.\" First parameter, NAME, should be all caps
.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
.\" other parameters are allowed: see man(7), man(1)
-.TH STRESS-NG 1 "July 18, 2017"
+.TH STRESS-NG 1 "August 7, 2017"
.\" Please adjust this date whenever revising the manpage.
.\"
.\" Some roff macros, for reference:
@@ -71,10 +71,10 @@
the balance of user time vs system time used depending on the type of stressor
being used.
.TP
-.B \-a N, \-\-all N
-start N instances of each stressor. If N is less than zero, then the number
-of CPUs online is used for the number of instances. If N is zero, then the
-number of CPUs in the system is used.
+.B \-a N, \-\-all N, \-\-parallel N
+start N instances of all stressors in parallel. If N is less than zero, then
+the number of CPUs online is used for the number of instances. If N is zero,
+then the number of CPUs in the system is used.
.TP
.B \-b N, \-\-backoff N
wait N microseconds between the start of each stress worker process. This
@@ -1081,10 +1081,16 @@
.TP
.B \-\-dirdeep\-ops N
stop directory depth workers after N bogo directory operations.
+.TP
.B \-\-dirdeep\-dirs N
create N directories at each tree level. The default is just 1 but can be
increased to a maximum of 10 per level.
.TP
+.B \-\-dirdeep\-inodes N
+consume upto N inodes per dirdeep stressor while creating directories and
+links. The value N can be the number of inodes or a percentage of the total
+available free inodes on the filesystem being used.
+.TP
.B \-\-dnotify N
start N workers performing file system activities such as making/deleting
files/directories, renaming files, etc. to stress exercise the various dnotify
@@ -1818,7 +1824,7 @@
l l.
Method Description
all T{
-iterate over all the below matrix stress methods
+iterate over all the below memthrash methods
T}
chunk1 T{
memset 1 byte chunks of random data into random locations
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/stress-ng.c
new/stress-ng-0.08.10/stress-ng.c
--- old/stress-ng-0.08.09/stress-ng.c 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/stress-ng.c 2017-08-07 22:34:14.000000000 +0200
@@ -496,6 +496,7 @@
{ "dirdeep", 1, 0, OPT_DIRDEEP },
{ "dirdeep-ops",1, 0, OPT_DIRDEEP_OPS },
{ "dirdeep-dirs",1, 0, OPT_DIRDEEP_DIRS },
+ { "dirdeep-inodes",1, 0, OPT_DIRDEEP_INODES },
{ "dry-run", 0, 0, OPT_DRY_RUN },
{ "dnotify", 1, 0, OPT_DNOTIFY },
{ "dnotify-ops",1, 0, OPT_DNOTIFY_OPS },
@@ -698,6 +699,7 @@
{ "open", 1, 0, OPT_OPEN },
{ "open-ops", 1, 0, OPT_OPEN_OPS },
{ "page-in", 0, 0, OPT_PAGE_IN },
+ { "parallel", 1, 0, OPT_ALL },
{ "pathological",0, 0, OPT_PATHOLOGICAL },
{ "perf", 0, 0, OPT_PERF_STATS },
{ "personality",1, 0, OPT_PERSONALITY },
@@ -959,6 +961,7 @@
{ NULL, "no-madvise", "don't use random madvise
options for each mmap" },
{ NULL, "no-rand-seed", "seed random numbers with the
same constant" },
{ NULL, "page-in", "touch allocated pages that are
not in core" },
+ { NULL, "parallel N", "synonym for 'all N'" },
{ NULL, "pathological", "enable stressors that are
known to hang a machine" },
#if defined(STRESS_PERF_STATS)
{ NULL, "perf", "display perf statistics" },
@@ -1080,6 +1083,7 @@
{ NULL, "dirdeep N", "start N directory depth
stressors" },
{ NULL, "dirdeep-ops N", "stop after N directory depth
bogo operations" },
{ NULL, "dirdeep-dirs N", "create N directories per
level" },
+ { NULL, "dirdeep-inodes N", "create a maximum N inodes (N
can also be %)" },
{ NULL, "dnotify N", "start N workers exercising
dnotify events" },
{ NULL, "dnotify-ops N", "stop dnotify workers after N
bogo operations" },
{ NULL, "dup N", "start N workers exercising
dup/close" },
@@ -2895,9 +2899,11 @@
if (ret < 0)
return EXIT_FAILURE;
else if (ret > 0)
- return EXIT_SUCCESS;
- else
+ exit(EXIT_SUCCESS);
+ else {
set_setting("class", TYPE_ID_UINT32, &u32);
+ enable_classes(u32);
+ }
break;
case OPT_CLONE_MAX:
stress_set_clone_max(optarg);
@@ -2959,6 +2965,9 @@
case OPT_DIRDEEP_DIRS:
stress_set_dirdeep_dirs(optarg);
break;
+ case OPT_DIRDEEP_INODES:
+ stress_set_dirdeep_inodes(optarg);
+ break;
case OPT_EPOLL_DOMAIN:
if (stress_set_epoll_domain(optarg) < 0)
return EXIT_FAILURE;
@@ -3354,7 +3363,7 @@
break;
case OPT_VERSION:
version();
- return EXIT_SUCCESS;
+ exit(EXIT_SUCCESS);
case OPT_VM_BYTES:
stress_set_vm_bytes(optarg);
break;
@@ -3585,9 +3594,6 @@
if (ret != EXIT_SUCCESS)
exit(ret);
- (void)get_setting("class", &class);
- enable_classes(class);
-
/*
* Throw away excluded stressors
*/
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/stress-ng-0.08.09/stress-ng.h
new/stress-ng-0.08.10/stress-ng.h
--- old/stress-ng-0.08.09/stress-ng.h 2017-07-18 11:53:20.000000000 +0200
+++ new/stress-ng-0.08.10/stress-ng.h 2017-08-07 22:34:14.000000000 +0200
@@ -1510,6 +1510,7 @@
OPT_DIRDEEP,
OPT_DIRDEEP_OPS,
OPT_DIRDEEP_DIRS,
+ OPT_DIRDEEP_INODES,
OPT_DNOTIFY,
OPT_DNOTIFY_OPS,
@@ -2291,13 +2292,11 @@
extern int stress_mlock_region(const void *addr_start, const void *addr_end);
/* Argument parsing and range checking */
-extern WARN_UNUSED int32_t get_opt_sched(const char *const str);
-extern WARN_UNUSED int32_t get_opt_ionice_class(const char *const str);
-extern WARN_UNUSED uint32_t get_uint32(const char *const str);
-extern WARN_UNUSED int32_t get_int32(const char *const str);
extern WARN_UNUSED uint64_t get_uint64(const char *const str);
extern WARN_UNUSED uint64_t get_uint64_scale(const char *const str,
const scale_t scales[], const char *const msg);
+extern WARN_UNUSED uint64_t get_uint64_percent(const char *const str,
+ const uint32_t instances, const uint64_t max, const char *const errmsg);
extern WARN_UNUSED uint64_t get_uint64_byte(const char *const str);
extern WARN_UNUSED uint64_t get_uint64_byte_memory(const char *const str,
const uint32_t instances);
@@ -2310,6 +2309,10 @@
extern void check_range_bytes(const char *const opt, const uint64_t val,
const uint64_t lo, const uint64_t hi);
extern WARN_UNUSED int set_cpu_affinity(char *const arg);
+extern WARN_UNUSED uint32_t get_uint32(const char *const str);
+extern WARN_UNUSED int32_t get_int32(const char *const str);
+extern WARN_UNUSED int32_t get_opt_sched(const char *const str);
+extern WARN_UNUSED int32_t get_opt_ionice_class(const char *const str);
/* Misc helper funcs */
extern void stress_unmap_shared(void);
@@ -2352,6 +2355,7 @@
extern WARN_UNUSED int mmap_check(uint8_t *buf, const size_t sz, const size_t
page_size);
extern WARN_UNUSED uint64_t stress_get_phys_mem_size(void);
extern WARN_UNUSED uint64_t stress_get_filesystem_size(void);
+extern WARN_UNUSED uint64_t stress_get_filesystem_available_inodes(void);
extern char *stress_uint64_to_str(char *str, size_t len, const uint64_t val);
/*
@@ -2480,6 +2484,7 @@
extern int stress_set_dentry_order(const char *opt);
extern void stress_set_dir_dirs(const char *opt);
extern void stress_set_dirdeep_dirs(const char *opt);
+extern void stress_set_dirdeep_inodes(const char *opt);
extern void stress_set_epoll_port(const char *opt);
extern int stress_set_epoll_domain(const char *opt);
extern void stress_set_exec_max(const char *opt);
