* [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits
@ 2025-10-15 10:15 Ben Copeland
2025-10-15 14:42 ` Petr Vorel
0 siblings, 1 reply; 5+ messages in thread
From: Ben Copeland @ 2025-10-15 10:15 UTC (permalink / raw)
To: ltp; +Cc: arnd, lkft-triage, dan.carpenter
The overcommit test uses sum_total, the sum (memory and swap) to test
the overcommit settings.
This fixes two problems on 32-bit systems. The first is seen with a
integer overflow can occur when calculating sum_total * 2, if the
sum_total is larger than 2GB. The second is limited virtual address
space (2-3GB) means the test can fail from address space exhaustion
before overcommit has been tested.
Now the test runs correctly on low-memory 32-bit systems while avoiding
both the overflow bug and virtual address space issues.
Signed-off-by: Ben Copeland <ben.copeland@linaro.org>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Reviewed-by: Petr Vorel <pvorel@suse.cz>
---
.../kernel/mem/tunable/overcommit_memory.c | 33 +++++++++++++++----
1 file changed, 27 insertions(+), 6 deletions(-)
diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
index 9b2cb479d..7ff5a98d0 100644
--- a/testcases/kernel/mem/tunable/overcommit_memory.c
+++ b/testcases/kernel/mem/tunable/overcommit_memory.c
@@ -131,24 +131,45 @@ static void overcommit_memory_test(void)
TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 2, 1);
update_mem_commit();
- alloc_and_check(commit_left * 2, EXPECT_FAIL);
- alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
+ /* Skip tests that would overflow or exceed 32-bit address space */
+ if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
+ alloc_and_check(commit_left * 2, EXPECT_FAIL);
+ alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
+ } else {
+ tst_res(TCONF, "Skipping large allocation tests due to address space limits");
+ }
update_mem_commit();
- alloc_and_check(commit_left / 2, EXPECT_PASS);
+ if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
+ alloc_and_check(commit_left / 2, EXPECT_PASS);
+ } else {
+ tst_res(TCONF, "Skipping commit_left/2 allocation test due to address space limits");
+ }
/* start to test overcommit_memory=0 */
TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 0, 1);
update_mem();
alloc_and_check(free_total / 2, EXPECT_PASS);
- alloc_and_check(sum_total * 2, EXPECT_FAIL);
+ /* Skip if sum_total * 2 would exceed address space.
+ * On 32-bit, skip when sum_total > ULONG_MAX/4 (~1GB).
+ * Most 32-bit systems with <=1GB RAM can map 2x that in 3GB vaddr space.
+ * Systems with 2GB+ RAM likely cannot fit allocations in vaddr space. */
+ if (tst_kernel_bits() == 64 || (unsigned long)sum_total <= TST_GB / TST_KB) {
+ alloc_and_check(sum_total * 2, EXPECT_FAIL);
+ } else {
+ tst_res(TCONF, "Skipping large allocation test due to address space limits");
+ }
/* start to test overcommit_memory=1 */
TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 1, 1);
alloc_and_check(sum_total / 2, EXPECT_PASS);
- alloc_and_check(sum_total, EXPECT_PASS);
- alloc_and_check(sum_total * 2, EXPECT_PASS);
+ if (tst_kernel_bits() == 64 || (unsigned long)sum_total <= TST_GB / TST_KB) {
+ alloc_and_check(sum_total, EXPECT_PASS);
+ alloc_and_check(sum_total * 2, EXPECT_PASS);
+ } else {
+ tst_res(TCONF, "Skipping large allocation tests due to address space limits");
+ }
}
--
2.51.0
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits
2025-10-15 10:15 [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits Ben Copeland
@ 2025-10-15 14:42 ` Petr Vorel
2025-10-15 15:00 ` Dan Carpenter
0 siblings, 1 reply; 5+ messages in thread
From: Petr Vorel @ 2025-10-15 14:42 UTC (permalink / raw)
To: Ben Copeland; +Cc: arnd, lkft-triage, ltp, dan.carpenter
> The overcommit test uses sum_total, the sum (memory and swap) to test
> the overcommit settings.
> This fixes two problems on 32-bit systems. The first is seen with a
> integer overflow can occur when calculating sum_total * 2, if the
> sum_total is larger than 2GB. The second is limited virtual address
You still mention GB ...
> space (2-3GB) means the test can fail from address space exhaustion
> before overcommit has been tested.
> Now the test runs correctly on low-memory 32-bit systems while avoiding
> both the overflow bug and virtual address space issues.
> Signed-off-by: Ben Copeland <ben.copeland@linaro.org>
> Acked-by: Arnd Bergmann <arnd@arndb.de>
> Reviewed-by: Petr Vorel <pvorel@suse.cz>
> ---
> .../kernel/mem/tunable/overcommit_memory.c | 33 +++++++++++++++----
> 1 file changed, 27 insertions(+), 6 deletions(-)
> diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
> index 9b2cb479d..7ff5a98d0 100644
> --- a/testcases/kernel/mem/tunable/overcommit_memory.c
> +++ b/testcases/kernel/mem/tunable/overcommit_memory.c
> @@ -131,24 +131,45 @@ static void overcommit_memory_test(void)
> TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 2, 1);
> update_mem_commit();
> - alloc_and_check(commit_left * 2, EXPECT_FAIL);
> - alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> + /* Skip tests that would overflow or exceed 32-bit address space */
> + if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
... but TST_GB / TST_KB is actually MB (you could use TST_MB).
Yes, this fixes the problem on i686 as the tests are skipped as sum_total is
smaller than 1MB.
Kind regards,
Petr
tst_kernel.c:90: TINFO: uname.machine=i686 kernel is 32bit
tst_test.c:2021: TINFO: LTP version: 20250930
tst_test.c:2024: TINFO: Tested kernel: 6.17.1-1-default #1 SMP PREEMPT_DYNAMIC Tue Oct 7 04:26:30 UTC 2025 (1bf5c2e) i686
tst_kconfig.c:88: TINFO: Parsing kernel config '/proc/config.gz'
tst_kconfig.c:676: TINFO: CONFIG_FAULT_INJECTION kernel option detected which might slow the execution
tst_test.c:1842: TINFO: Overall timeout per run is 0h 02m 00s
overcommit_memory.c:104: TINFO: MemTotal is 2050308 kB
overcommit_memory.c:106: TINFO: SwapTotal is 2098152 kB
overcommit_memory.c:110: TINFO: CommitLimit is 3121256 kB
overcommit_memory.c:123: TINFO: Setting /proc/sys/vm/overcommit_ratio to 30
overcommit_memory.c:126: TINFO: TotalBatchSize is 8008 kB
overcommit_memory.c:132: TINFO: Setting /proc/sys/vm/overcommit_memory to 2
overcommit_memory.c:140: TCONF: Skipping large allocation tests due to address space limits
overcommit_memory.c:146: TCONF: Skipping commit_left/2 allocation test due to address space limits
overcommit_memory.c:150: TINFO: Setting /proc/sys/vm/overcommit_memory to 0
overcommit_memory.c:152: TINFO: ONE_GB: 1073741824
overcommit_memory.c:153: TINFO: TST_GB: 1073741824
overcommit_memory.c:154: TINFO: TST_MB: 1048576
overcommit_memory.c:155: TINFO: TST_GB / TST_KB: 1048576
overcommit_memory.c:156: TINFO: TST_MB * 1024: 1073741824
overcommit_memory.c:157: TINFO: tst_kernel_bits(): 32
overcommit_memory.c:158: TINFO: (unsigned long)sum_total <= ONE_GB: 1
overcommit_memory.c:159: TINFO: (unsigned long)sum_total <= TST_GB: 1
overcommit_memory.c:160: TINFO: condition: 1
overcommit_memory.c:193: TINFO: malloc 1669706 kB successfully
overcommit_memory.c:212: TPASS: alloc passed as expected
overcommit_memory.c:171: TCONF: Skipping large allocation test due to address space limits
overcommit_memory.c:175: TINFO: Setting /proc/sys/vm/overcommit_memory to 1
overcommit_memory.c:193: TINFO: malloc 2074230 kB successfully
overcommit_memory.c:212: TPASS: alloc passed as expected
overcommit_memory.c:182: TCONF: Skipping large allocation tests due to address space limits
> + alloc_and_check(commit_left * 2, EXPECT_FAIL);
> + alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> + } else {
> + tst_res(TCONF, "Skipping large allocation tests due to address space limits");
> + }
> update_mem_commit();
> - alloc_and_check(commit_left / 2, EXPECT_PASS);
> + if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
> + alloc_and_check(commit_left / 2, EXPECT_PASS);
> + } else {
> + tst_res(TCONF, "Skipping commit_left/2 allocation test due to address space limits");
> + }
> /* start to test overcommit_memory=0 */
> TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 0, 1);
> update_mem();
> alloc_and_check(free_total / 2, EXPECT_PASS);
> - alloc_and_check(sum_total * 2, EXPECT_FAIL);
> + /* Skip if sum_total * 2 would exceed address space.
> + * On 32-bit, skip when sum_total > ULONG_MAX/4 (~1GB).
> + * Most 32-bit systems with <=1GB RAM can map 2x that in 3GB vaddr space.
> + * Systems with 2GB+ RAM likely cannot fit allocations in vaddr space. */
> + if (tst_kernel_bits() == 64 || (unsigned long)sum_total <= TST_GB / TST_KB) {
> + alloc_and_check(sum_total * 2, EXPECT_FAIL);
> + } else {
> + tst_res(TCONF, "Skipping large allocation test due to address space limits");
> + }
> /* start to test overcommit_memory=1 */
> TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 1, 1);
> alloc_and_check(sum_total / 2, EXPECT_PASS);
> - alloc_and_check(sum_total, EXPECT_PASS);
> - alloc_and_check(sum_total * 2, EXPECT_PASS);
> + if (tst_kernel_bits() == 64 || (unsigned long)sum_total <= TST_GB / TST_KB) {
> + alloc_and_check(sum_total, EXPECT_PASS);
> + alloc_and_check(sum_total * 2, EXPECT_PASS);
> + } else {
> + tst_res(TCONF, "Skipping large allocation tests due to address space limits");
> + }
> }
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits
2025-10-15 14:42 ` Petr Vorel
@ 2025-10-15 15:00 ` Dan Carpenter
2025-10-15 16:02 ` Petr Vorel
0 siblings, 1 reply; 5+ messages in thread
From: Dan Carpenter @ 2025-10-15 15:00 UTC (permalink / raw)
To: Petr Vorel; +Cc: arnd, lkft-triage, ltp
On Wed, Oct 15, 2025 at 04:42:47PM +0200, Petr Vorel wrote:
> > The overcommit test uses sum_total, the sum (memory and swap) to test
> > the overcommit settings.
>
> > This fixes two problems on 32-bit systems. The first is seen with a
> > integer overflow can occur when calculating sum_total * 2, if the
> > sum_total is larger than 2GB. The second is limited virtual address
>
> You still mention GB ...
>
Yep. It is GB.
> > space (2-3GB) means the test can fail from address space exhaustion
> > before overcommit has been tested.
>
> > Now the test runs correctly on low-memory 32-bit systems while avoiding
> > both the overflow bug and virtual address space issues.
>
> > Signed-off-by: Ben Copeland <ben.copeland@linaro.org>
> > Acked-by: Arnd Bergmann <arnd@arndb.de>
> > Reviewed-by: Petr Vorel <pvorel@suse.cz>
> > ---
> > .../kernel/mem/tunable/overcommit_memory.c | 33 +++++++++++++++----
> > 1 file changed, 27 insertions(+), 6 deletions(-)
>
> > diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
> > index 9b2cb479d..7ff5a98d0 100644
> > --- a/testcases/kernel/mem/tunable/overcommit_memory.c
> > +++ b/testcases/kernel/mem/tunable/overcommit_memory.c
> > @@ -131,24 +131,45 @@ static void overcommit_memory_test(void)
> > TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 2, 1);
>
> > update_mem_commit();
> > - alloc_and_check(commit_left * 2, EXPECT_FAIL);
> > - alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> > + /* Skip tests that would overflow or exceed 32-bit address space */
> > + if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
>
> ... but TST_GB / TST_KB is actually MB (you could use TST_MB).
>
The sizes in this test are measured in KB, so it's 1GB but measured in
terms of KB not bytes. Using TST_MB would work mathematically but it's
misleading.
regards,
dan carpenter
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits
2025-10-15 15:00 ` Dan Carpenter
@ 2025-10-15 16:02 ` Petr Vorel
2025-10-16 12:36 ` Ben Copeland
0 siblings, 1 reply; 5+ messages in thread
From: Petr Vorel @ 2025-10-15 16:02 UTC (permalink / raw)
To: Dan Carpenter; +Cc: arnd, lkft-triage, ltp
> On Wed, Oct 15, 2025 at 04:42:47PM +0200, Petr Vorel wrote:
> > > The overcommit test uses sum_total, the sum (memory and swap) to test
> > > the overcommit settings.
> > > This fixes two problems on 32-bit systems. The first is seen with a
> > > integer overflow can occur when calculating sum_total * 2, if the
> > > sum_total is larger than 2GB. The second is limited virtual address
> > You still mention GB ...
> Yep. It is GB.
> > > space (2-3GB) means the test can fail from address space exhaustion
> > > before overcommit has been tested.
> > > Now the test runs correctly on low-memory 32-bit systems while avoiding
> > > both the overflow bug and virtual address space issues.
> > > Signed-off-by: Ben Copeland <ben.copeland@linaro.org>
> > > Acked-by: Arnd Bergmann <arnd@arndb.de>
> > > Reviewed-by: Petr Vorel <pvorel@suse.cz>
> > > ---
> > > .../kernel/mem/tunable/overcommit_memory.c | 33 +++++++++++++++----
> > > 1 file changed, 27 insertions(+), 6 deletions(-)
> > > diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
> > > index 9b2cb479d..7ff5a98d0 100644
> > > --- a/testcases/kernel/mem/tunable/overcommit_memory.c
> > > +++ b/testcases/kernel/mem/tunable/overcommit_memory.c
> > > @@ -131,24 +131,45 @@ static void overcommit_memory_test(void)
> > > TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 2, 1);
> > > update_mem_commit();
> > > - alloc_and_check(commit_left * 2, EXPECT_FAIL);
> > > - alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> > > + /* Skip tests that would overflow or exceed 32-bit address space */
> > > + if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
> > ... but TST_GB / TST_KB is actually MB (you could use TST_MB).
> The sizes in this test are measured in KB, so it's 1GB but measured in
> terms of KB not bytes. Using TST_MB would work mathematically but it's
> misleading.
Ah, I'm sorry to overlook an obvious point.
Implementation details: thinking about the code twice, shouldn't be the check
for overflow in alloc_and_check() instead of outside (to keep the condition on
single place)?
Also, if kept outside the 1st and 2nd if could be joined:
/* Skip tests that would overflow or exceed 32-bit address space */
if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
alloc_and_check(commit_left * 2, EXPECT_FAIL);
alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
update_mem_commit();
alloc_and_check(commit_left / 2, EXPECT_PASS);
} else {
tst_res(TCONF, "Skipping large allocation tests due to address space limits");
}
instead of your proposal:
update_mem_commit();
/* Skip tests that would overflow or exceed 32-bit address space */
if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
alloc_and_check(commit_left * 2, EXPECT_FAIL);
alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
} else {
tst_res(TCONF, "Skipping large allocation tests due to address space limits");
}
update_mem_commit();
if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
alloc_and_check(commit_left / 2, EXPECT_PASS);
} else {
tst_res(TCONF, "Skipping commit_left/2 allocation test due to address space limits");
}
because update_mem_commit() IMHO just evaluates /proc/meminfo values, but
when alloc_and_check() is skipped nothing has changed.
Kind regards,
Petr
> regards,
> dan carpenter
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits
2025-10-15 16:02 ` Petr Vorel
@ 2025-10-16 12:36 ` Ben Copeland
0 siblings, 0 replies; 5+ messages in thread
From: Ben Copeland @ 2025-10-16 12:36 UTC (permalink / raw)
To: Petr Vorel; +Cc: arnd, lkft-triage, Dan Carpenter, ltp
Hello Petr,
On Wed, 15 Oct 2025 at 17:02, Petr Vorel <pvorel@suse.cz> wrote:
>
> > On Wed, Oct 15, 2025 at 04:42:47PM +0200, Petr Vorel wrote:
> > > > The overcommit test uses sum_total, the sum (memory and swap) to test
> > > > the overcommit settings.
>
> > > > This fixes two problems on 32-bit systems. The first is seen with a
> > > > integer overflow can occur when calculating sum_total * 2, if the
> > > > sum_total is larger than 2GB. The second is limited virtual address
>
> > > You still mention GB ...
>
>
> > Yep. It is GB.
>
> > > > space (2-3GB) means the test can fail from address space exhaustion
> > > > before overcommit has been tested.
>
> > > > Now the test runs correctly on low-memory 32-bit systems while avoiding
> > > > both the overflow bug and virtual address space issues.
>
> > > > Signed-off-by: Ben Copeland <ben.copeland@linaro.org>
> > > > Acked-by: Arnd Bergmann <arnd@arndb.de>
> > > > Reviewed-by: Petr Vorel <pvorel@suse.cz>
> > > > ---
> > > > .../kernel/mem/tunable/overcommit_memory.c | 33 +++++++++++++++----
> > > > 1 file changed, 27 insertions(+), 6 deletions(-)
>
> > > > diff --git a/testcases/kernel/mem/tunable/overcommit_memory.c b/testcases/kernel/mem/tunable/overcommit_memory.c
> > > > index 9b2cb479d..7ff5a98d0 100644
> > > > --- a/testcases/kernel/mem/tunable/overcommit_memory.c
> > > > +++ b/testcases/kernel/mem/tunable/overcommit_memory.c
> > > > @@ -131,24 +131,45 @@ static void overcommit_memory_test(void)
> > > > TST_SYS_CONF_LONG_SET(OVERCOMMIT_MEMORY, 2, 1);
>
> > > > update_mem_commit();
> > > > - alloc_and_check(commit_left * 2, EXPECT_FAIL);
> > > > - alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> > > > + /* Skip tests that would overflow or exceed 32-bit address space */
> > > > + if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
>
> > > ... but TST_GB / TST_KB is actually MB (you could use TST_MB).
>
>
> > The sizes in this test are measured in KB, so it's 1GB but measured in
> > terms of KB not bytes. Using TST_MB would work mathematically but it's
> > misleading.
>
> Ah, I'm sorry to overlook an obvious point.
>
> Implementation details: thinking about the code twice, shouldn't be the check
> for overflow in alloc_and_check() instead of outside (to keep the condition on
> single place)?
Excellent suggestion. It makes sense to simplify it like that. I will
spin up a v3 patch with those changes.
Ben
>
> Also, if kept outside the 1st and 2nd if could be joined:
>
> /* Skip tests that would overflow or exceed 32-bit address space */
> if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
> alloc_and_check(commit_left * 2, EXPECT_FAIL);
> alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> update_mem_commit();
> alloc_and_check(commit_left / 2, EXPECT_PASS);
> } else {
> tst_res(TCONF, "Skipping large allocation tests due to address space limits");
> }
>
> instead of your proposal:
>
> update_mem_commit();
> /* Skip tests that would overflow or exceed 32-bit address space */
> if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
> alloc_and_check(commit_left * 2, EXPECT_FAIL);
> alloc_and_check(commit_limit + total_batch_size, EXPECT_FAIL);
> } else {
> tst_res(TCONF, "Skipping large allocation tests due to address space limits");
> }
> update_mem_commit();
> if (tst_kernel_bits() == 64 || (unsigned long)commit_left <= TST_GB / TST_KB) {
> alloc_and_check(commit_left / 2, EXPECT_PASS);
> } else {
> tst_res(TCONF, "Skipping commit_left/2 allocation test due to address space limits");
> }
>
> because update_mem_commit() IMHO just evaluates /proc/meminfo values, but
> when alloc_and_check() is skipped nothing has changed.
>
> Kind regards,
> Petr
>
> > regards,
> > dan carpenter
>
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2025-10-16 12:37 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-10-15 10:15 [LTP] [PATCH v2] overcommit_memory: Fix integer overflow and 32-bit limits Ben Copeland
2025-10-15 14:42 ` Petr Vorel
2025-10-15 15:00 ` Dan Carpenter
2025-10-15 16:02 ` Petr Vorel
2025-10-16 12:36 ` Ben Copeland
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.