Tue Jul 4 15:06:28 2023 UTC ()

jemalloc: Enforce alignment-must-divide-size rule of aligned_alloc.

C11, Sec. 7.22.3.1 The aligned_alloc function, paragraph 2, p. 348:

   The value of alignment shall be a valid alignment supported by the
   implementation and the value of size shall be an integral multiple
   of alignment.

posix_memalign does not appear to have any corresponding constraint.

XXX pullup-10


(riastradh)

diff -r1.10 -r1.11 src/external/bsd/jemalloc/dist/src/jemalloc.c

--- src/external/bsd/jemalloc/dist/src/jemalloc.c 2023/07/01 06:29:14	1.10
+++ src/external/bsd/jemalloc/dist/src/jemalloc.c 2023/07/04 15:06:28	1.11

 @@ -1625,26 +1625,29 @@ struct static_opts_s {
 	 * Whether to assert that allocations are not of size 0 (after any
 	 * bumping).
 	 */
 	bool assert_nonempty_alloc;
 	/*
 	 * Whether or not to modify the 'result' argument to malloc in case of
 	 * error.
 	 */
 	bool null_out_result_on_error;
 	/* Whether to set errno when we encounter an error condition. */
 	bool set_errno_on_error;
 	/* Whether the alignment must divide the size. */
 	bool alignment_must_divide_size;
 	/*
 	 * The minimum valid alignment for functions requesting aligned storage.
 	 */
 	size_t min_alignment;
 	/* The error string to use if we oom. */
 	const char *oom_string;
 	/* The error string to use if the passed-in alignment is invalid. */
 	const char *invalid_alignment_string;
 	/*
 	 * False if we're configured to skip some time-consuming operations.
+	 *
 @@ -1652,26 +1655,27 @@ struct static_opts_s {
 	 * summary of several other static (or at least, static after program
 	 * initialization) options.
 	 */
 	bool slow;
 };
 JEMALLOC_ALWAYS_INLINE void
 static_opts_init(static_opts_t *static_opts) {
 	static_opts->may_overflow = false;
 	static_opts->bump_empty_alloc = false;
 	static_opts->assert_nonempty_alloc = false;
 	static_opts->null_out_result_on_error = false;
 	static_opts->set_errno_on_error = false;
 	static_opts->alignment_must_divide_size = false;
 	static_opts->min_alignment = 0;
 	static_opts->oom_string = "";
 	static_opts->invalid_alignment_string = "";
 	static_opts->slow = false;
+}
 /*
  * These correspond to the macros in jemalloc/jemalloc_macros.h.  Broadly, we
  * should have one constant here per magic value there.  Note however that the
  * representations need not be related.
  */
 #define TCACHE_IND_NONE ((unsigned)-1)
 #define TCACHE_IND_AUTOMATIC ((unsigned)-2)
 @@ -1847,26 +1851,31 @@ imalloc_body(static_opts_t *sopts, dynam
 		if (unlikely(size == 0)) {
 			size = 1;
+		}
+	}
 	if (sopts->assert_nonempty_alloc) {
 		assert (size != 0);
+	}
 	if (unlikely(dopts->alignment < sopts->min_alignment
 	    || (dopts->alignment & (dopts->alignment - 1)) != 0)) {
 		goto label_invalid_alignment;
+	}
 	if (sopts->alignment_must_divide_size) {
 		if (unlikely(dopts->item_size % dopts->alignment)) {
 			goto label_invalid_alignment;
+		}
+	}
 	/* This is the beginning of the "core" algorithm. */
 	if (dopts->alignment == 0) {
 		ind = sz_size2index(size);
 		if (unlikely(ind >= NSIZES)) {
 			goto label_oom;
+		}
 		if (config_stats || (config_prof && opt_prof)) {
 			usize = sz_index2size(ind);
 			assert(usize > 0 && usize <= LARGE_MAXCLASS);
+		}
 	} else {
 @@ -2115,26 +2124,27 @@ je_aligned_alloc(size_t alignment, size_
 	static_opts_t sopts;
 	dynamic_opts_t dopts;
 	LOG("core.aligned_alloc.entry", "alignment: %zu, size: %zu\n",
 	    alignment, size);
 	static_opts_init(&sopts);
 	dynamic_opts_init(&dopts);
 	sopts.bump_empty_alloc = true;
 	sopts.null_out_result_on_error = true;
 	sopts.set_errno_on_error = true;
 	sopts.alignment_must_divide_size = true;
 	sopts.min_alignment = 1;
 	sopts.oom_string =
 	    "<jemalloc>: Error allocating aligned memory: out of memory\n";
 	sopts.invalid_alignment_string =
 	    "<jemalloc>: Error allocating aligned memory: invalid alignment\n";
 	dopts.result = &ret;
 	dopts.num_items = 1;
 	dopts.item_size = size;
 	dopts.alignment = alignment;
 	imalloc(&sopts, &dopts);