One Filesystem or Several for Informix Dbspaces
The short answer
Two questions tend to get run together when people plan Informix® storage, and only one of them has been settled.
| Question | Status |
|---|---|
| Raw devices or cooked files | Settled. DIRECT_IO closes most of the gap, and the old answer that raw is faster is closer to wrong. |
| One filesystem or several | A different question, and the answer to the first does not settle it. |
For performance alone, a single filesystem is very nearly as good as several.
The reasons people remember for splitting were the filesystem buffer cache,
metadata overhead and allocation contention, and most of those were answered
by DIRECT_IO and by preallocating chunks.
The reasons that survive are operational, and they are not trivial. Most of them are really arguments for separate block devices rather than separate filesystems. Two filesystems carved out of one logical volume share a request queue, so splitting them delivers almost nothing.
The decision axis
Separate the block devices where the I/O patterns genuinely differ, and let the filesystems follow. Deciding the filesystem count first is answering the wrong question.
That axis holds whether the engine runs on bare metal, in a virtual machine or in a container. What changes in a container is that separating a block device becomes trivial while choosing a filesystem becomes someone else’s decision, which reorders the practical advice considerably. See the section on containers, Kubernetes and OpenShift.
Why the performance argument has mostly gone away
DIRECT_IO removed the buffering problem
Without DIRECT_IO, chunk I/O passes through the filesystem page
cache as well as the Informix bufferpool. The same page is cached twice, with a
copy between the two, and that was the strongest technical argument for raw
devices.
DIRECT_IO bypasses filesystem buffering for chunk I/O. It also
enables KAIO on cooked chunks, a benefit that used to belong to raw devices
alone and is often forgotten.
Vendor documentation still hedges. It says to use raw devices whenever performance is important, yet the same pages state that cooked chunks with direct I/O can approach raw device performance and that the two are equally reliable. A frequently quoted figure from the Informix community puts the residual gap at roughly 5%. That is one practitioner’s field estimate, not a vendor measurement and not a benchmark, and it is repeated here only because it is the number people will have heard. Do not size a decision on it. If the difference matters at your volumes, measure it on your own hardware.
Preallocated chunks reduce the metadata work
A chunk file is normally created once at its full size and does not grow. Preallocation does not eliminate filesystem metadata work, but it moves almost all of it to creation time, so steady-state writes into an existing chunk perform no extent allocation and update no inode state. On a metadata-journalling filesystem the journal is therefore close to idle for chunk I/O.
The exception is a chunk that has been marked as extendable, which the server can grow when a space fills. Each extension is also preallocated in one step, at the time of the extension, rather than file space being allocated as individual writes arrive. The metadata cost is therefore paid once per extension and not on every I/O, so there is still no metadata or journal activity from one I/O to the next. The point of the argument holds for extendable chunks as well, with the added note that the filesystem will see an occasional burst of allocation whenever an extension happens.
Extendable chunks do carry one assumption that is worth making explicit, because it stops being true on a fixed-size volume: that somebody can enlarge the volume underneath when it runs out. On a host with LVM that is a short change at any time, provided the volume group has free space. On a fixed claim it is not, and the consequences are covered in the container section.
On a metadata-journalling filesystem such as XFS, JFS2, or ext4 in
data=writeback or ordered mode, the filesystem is
reduced largely to an address translation layer. This is the core of the
argument that splitting is unnecessary, and it is correct: two chunks in one
filesystem contend for almost nothing that two chunks in two filesystems would
not.
What is left
Going through the usual reasons for splitting in turn, very little remains.
| Concern | Still real? |
|---|---|
| Double buffering | No, because of DIRECT_IO. |
| Journal contention from chunk I/O | No, because chunks are preallocated. |
| Free-space fragmentation | No, for the same reason. |
| Filesystem allocation locks | Largely no, since almost nothing is allocated after creation. |
fsync scope | Marginal, but not because direct I/O makes writes durable, which it does not. O_DIRECT bypasses the page cache and says nothing about a volatile write cache on the device, so durability still depends on the engine’s flush behaviour and on the storage honouring cache-flush or FUA requests. File-level sync and device-level cache flushing are different things: fsync() targets one file and its metadata, while a cache flush can still reach a device that two filesystems share, so separate filesystems on one device do not isolate flushes. |
| Per-inode locking | Situational. |
The case for a single filesystem
The main argument is simplicity, and it should not be dismissed. Every
additional filesystem is a mount unit, an entry in /etc/fstab, a
capacity to monitor and a thing that can fail to mount at boot. It is also
something that someone has to remember when storage is being extended at 2am.
| Argument | Weight |
|---|---|
| One pool and no stranded space. Free space is fungible, so five filesystems at 80% full have five separate cliffs where one at 80% has one. | Strong |
| Fewer moving parts at boot and during maintenance. A missing mount means a down instance. | Strong |
| Easier growth, with one filesystem to extend and one logical volume to grow. | Moderate |
| No need to predict the split in advance. Getting the data, log and temp ratio wrong means a migration, while one pool makes it a non-event. | Moderate |
| Performance is close enough, as described above. | Moderate |
Stranded space is the one that bites most often in practice. It is the mirror image of the strongest argument against a single filesystem, covered next. Which of the two matters more depends on whether a site is more afraid of running out of space or of one component consuming another’s.
Note that most of the weight in this table is provisioning effort and operational risk rather than anything technical. That matters, because a container platform removes a great deal of both, which is why the balance shifts in the container section.
The case against a single filesystem
| Argument | Weight |
|---|---|
Hard space ceilings. A runaway temp dbspace, an unbacked-up logical log or a careless onspaces cannot consume what another purpose depends on. | Strong |
| Per-mount observability, where the storage stack exports distinct metrics per mount or device. Separate mounts then let data, log and temp traffic be attributed without guessing. | Moderate to strong |
| Blast radius. A filesystem that needs repair takes down everything on it. | Moderate |
Mount options per purpose, such as noatime, allocation group count, discard and barrier behaviour. | Moderate |
| Snapshot and backup granularity. | Moderate |
| Different page sizes may need different block sizes, as described below. | Situational, but a hard constraint when it applies |
The observability argument is easy to overstate. Informix already reports I/O
per chunk and per file through onstat -D and
onstat -g iof, so attribution between data, log and temp does not
require separate mounts, because the engine can answer it. What separate mounts
add is the host’s view: queue depth, service time and merge behaviour per
device, which the engine does not see and which is exactly where the queueing
problems live. The argument is therefore real but narrower than saying you
cannot attribute I/O otherwise.
What actually differs between dbspace types
Separation only earns its keep where the I/O patterns genuinely differ, and for Informix they do.
| Space | Pattern | Latency-critical? |
|---|---|---|
| Logical logs | Small sequential writes | On the commit path for unbuffered logging. With buffered logging a commit can complete before the flush. |
| Physical log | Sequential writes, bursty at checkpoint, and also flushed when its buffer fills or a before-image must reach disk before a dirty page is written | Partly |
| Data chunks | Large random reads, with bulk writes at checkpoint | Throughput-bound |
| Temp dbspaces | Bursty and throwaway | No |
| Log backups | Large sequential writes | No |
The one combination with a real mechanism behind it is logical logs sharing a device with data chunks. With unbuffered logging, a log flush is on the commit path, so a flush that is queued behind a bulk random read inherits that read’s latency and every committing transaction waits with it. With buffered logging a commit can complete before the flush, so the effect is smaller. Because this is a device-queue effect, it is not fixed by putting the two in separate filesystems on the same volume. Only separating the volumes helps, and it is worth doing when measured commit latency and storage contention justify it.
Temp dbspaces are the best candidate for isolation on different grounds. They are the only space whose loss costs nothing, so on their own volume they can use different durability settings, can be rebuilt freely, and cannot consume space that the database needs to stay up.
The page size and block size constraint
Direct I/O requires the engine’s I/O to satisfy the alignment rules of the filesystem and the underlying device. Where it does not, the chunk falls back to buffered I/O rather than failing, and the double buffering described earlier returns for that chunk alone.
Treat the specifics as release-dependent and check your own version’s
documentation. The rule has historically been stated as the chunk page size
needing to be an even multiple of the filesystem block size, and HCL has changed
what is supported with respect to device block sizes across releases. There is
no single rule that holds across all versions, so the DIRECT_IO
reference page for the exact server release is the authority, not a general
statement.
Two further points decide the outcome in practice.
- Linux alignment is enforced against the device, not only the filesystem. The
open(2)manual page is explicit thatO_DIRECTalignment restrictions can vary by filesystem, by kernel version and even by file, and that no portable guarantee exists. A page size smaller than the filesystem block size may still work on a device with 512-byte logical sectors and fail on a 4Kn device. - The engine reports the outcome per chunk. This is the part most often missed, and it makes the whole question far easier to settle than it looks. See the next section.
An instance running mixed page sizes on a single filesystem of one block size is the case to check explicitly. In a container the constraint is harder to satisfy and easier to avoid altogether, because the filesystem is created by the storage driver. See the container section.
How to check that DIRECT_IO is working
Start with the engine, because it already knows. A widely repeated belief is
that nothing reports whether direct I/O is actually in force for a given chunk,
and that only behavioural testing can establish it. That is wrong:
onstat -d carries the answer in the chunk flags. The other checks
below exist to investigate why when the answer is not what you expected, not to
establish the answer itself.
Check 1: ask the engine
onstat -d
In the chunk flags, the sixth position carries D when direct I/O is
in use for that cooked-file chunk. A chunk reading PO-B-D has it,
and the same chunk reading PO-B-- does not. Consult the
onstat -d documentation for your release for the full flag legend,
since positions and letters have varied.
The flag only applies to cooked-file chunks, so check every cooked chunk that
you expect to use direct I/O, including chunks that use the default page size.
Raw chunks never carry D, and a raw chunk without it is not a
finding. On AIX, a C in the same position means concurrent I/O is
enabled, so account for it where concurrent I/O is configured.
| Result | Meaning |
|---|---|
D present on the chunk | Direct I/O is in force for that chunk. Nothing further to establish. |
D absent, and the dbspace is temporary | Expected unless the temp-dbspace bit of DIRECT_IO is set. Compare against the configured value. |
D absent on a non-temporary cooked-file chunk that should use direct I/O | A real finding. Proceed to the remaining checks to find out why. |
D absent on a raw chunk | Expected. The flag does not apply to raw chunks. |
The flag reports the mode that Informix enabled for that chunk, so it is the
authority on what the engine is doing. It is also worth comparing it with your
configured DIRECT_IO value. An instance configured to exclude
temporary dbspaces should normally show the flag on its non-temporary cooked
chunks and not on its temporary ones, although eligibility can vary from chunk
to chunk. If the flags and the configuration disagree, trust the flags and find
out why, because that disagreement is itself the finding.
This check costs one command, needs no scratch file and no privileges beyond
running onstat. Everything below is diagnosis, not detection.
Check 2: what the engine was asked to do
onstat -c | grep -i direct_io onstat -m | grep -i direct # recent messages from the running instance onstat -c | grep -i msgpath # where the message log for this instance lives
onstat -c reports the configured value, which is the intent. Check
1 reports the outcome. Use onstat -m for recent messages. For older
entries, such as those written at startup, read the file named by
MSGPATH rather than assuming
$INFORMIXDIR/tmp/online.log, because a host with a custom
MSGPATH or several instances can have a different or stale file at
the default location. The value is a bitmask whose accepted values have changed
between releases, so read the reference page for your version rather than
assuming.
Check 3: does O_DIRECT work at that page size on this filesystem?
This is only needed when check 1 showed a missing D on a
non-temporary cooked-file chunk. It tests the filesystem and device, not the
engine, and it is an alignment probe rather than a verdict.
(
dir=/path/to/chunk/filesystem
cd "$dir" || { echo "cannot reach $dir"; exit 1; }
tmp=$(mktemp "$dir/diotest.XXXXXX") || exit 1
trap 'rm -f "$tmp"' EXIT
dd if=/dev/zero of="$tmp" bs=2048 count=10 oflag=direct # the page size under test
dd if=/dev/zero of="$tmp" bs=4096 count=10 oflag=direct # control
)
Note the || on the cd and the mktemp. A
fixed filename such as ./diotest will silently overwrite and then
delete an existing file of that name, and a failed cd sends the
whole test to the wrong filesystem and reports a result for somewhere else. Both
are easy to do and neither announces itself. The whole test runs in a subshell
so that the exit calls and the cleanup trap do not affect your
terminal session.
Pick the control size to match a page size the instance actually uses. An instance with no 4 KB dbspaces is better controlled against 16 KB, because a control at a page size you do not run tells you nothing.
| Result | Meaning |
|---|---|
| Both succeed | The write completed at both sizes. That is weak evidence on its own, because Linux can fall back to buffered I/O for some misaligned requests, so success does not rule out alignment as the cause of a missing D. The D flag reports the mode Informix enabled for the chunk, while filesystem behaviour can still vary for individual operations. |
| The small size fails with “Invalid argument” and the control succeeds | Alignment is rejected at that size here, which is consistent with a fallback and a stronger result than the case above. |
| Both fail | Something else is wrong, such as the wrong filesystem, permissions, or no O_DIRECT support. Investigate before concluding anything. |
Check 4: the parameters that explain it
xfs_info /path/to/chunk/filesystem | head -3 blockdev --getss /dev/mapper/your_device # logical sector size blockdev --getpbsz /dev/mapper/your_device # physical sector size lsblk -o NAME,LOG-SEC,PHY-SEC,MOUNTPOINT
A logical sector size of 512 commonly permits a 2 KB direct write that a 4Kn device would reject.
On kernels and filesystems that support it, statx() with
STATX_DIOALIGN reports the direct I/O memory and offset alignment
for the actual chunk file, which is more direct than inferring it from sector
sizes. Support depends on the kernel version and the filesystem, so check the
statx(2) manual page for your system. Treat all of these as
evidence about alignment. Where they disagree with one another, or with the
D flag from check 1, the flag still tells you what Informix
enabled, and the disagreement is a reason to investigate rather than to pick
the number you prefer.
This is the check that degrades in a container. With a filesystem-mode volume
the pod usually cannot see the underlying device, so blockdev and
lsblk need node access, such as a privileged debug pod, or
oc debug node/… on OpenShift.
Check 5: page-cache residency, as supporting evidence only
If direct I/O is in force, a chunk file should hold little in the page cache.
This is corroboration, not proof, and it is weak in both directions. A chunk
that has not been read recently shows low residency whether or not direct I/O is
working, and a backup, a cp, or any other buffered reader will
populate the cache for a chunk that the engine opens with O_DIRECT.
Interpret it only alongside check 1.
vmtouch -v reports residency directly, and fincore
does the same where util-linux is recent enough. Where neither is
available, this script reads the residency with mincore:
python3 - /path/to/chunk1 /path/to/chunk2 <<'PY'
import ctypes, os, sys
if len(sys.argv) < 2:
sys.exit("usage: python3 - /path/to/chunk [/path/to/chunk ...]")
PROT_READ, MAP_SHARED = 0x1, 0x01
libc = ctypes.CDLL("libc.so.6", use_errno=True)
libc.mmap.restype = ctypes.c_void_p
libc.mmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_int,
ctypes.c_int, ctypes.c_int, ctypes.c_long]
libc.munmap.argtypes = [ctypes.c_void_p, ctypes.c_size_t]
libc.mincore.argtypes = [ctypes.c_void_p, ctypes.c_size_t,
ctypes.POINTER(ctypes.c_ubyte)]
PAGE = os.sysconf("SC_PAGE_SIZE")
for path in sys.argv[1:]:
try:
fd = os.open(path, os.O_RDONLY)
except OSError as e:
print("%-44s ERROR: %s" % (path, e)); continue
try:
sz = os.fstat(fd).st_size
if sz == 0:
print("%-44s empty" % path); continue
addr = libc.mmap(None, sz, PROT_READ, MAP_SHARED, fd, 0)
if not addr or addr == ctypes.c_void_p(-1).value:
print("%-44s ERROR: mmap errno %d" % (path, ctypes.get_errno())); continue
try:
n = (sz + PAGE - 1) // PAGE
vec = (ctypes.c_ubyte * n)()
if libc.mincore(ctypes.c_void_p(addr), sz, vec) != 0:
print("%-44s ERROR: mincore errno %d" % (path, ctypes.get_errno())); continue
res = sum(b & 1 for b in vec)
print("%-44s %8d/%-8d pages %6.2f%%" % (path, res, n, 100.0*res/n))
finally:
libc.munmap(ctypes.c_void_p(addr), sz)
finally:
os.close(fd)
PY
Run it with explicit chunk paths, as shown. Without any it has nothing to
examine and exits with a usage message. Run it as the user that owns the
chunks, normally informix. Linux restricts what
mincore() reports for files that the caller neither owns nor can
write, and in that case it can report every page as resident, which would make
the result meaningless.
Two details matter in this script. The address must come from
libc.mmap rather than from a Python mmap object,
because ctypes.c_char.from_buffer() requires a writable buffer and
raises TypeError: underlying buffer is not writable on a read-only
mapping. And the page size must come from sysconf, not a
hard-coded 4096. The mincore() call returns -1 on error, which must
be checked rather than producing a plausible-looking zero.
Reading the results together
Check 1 is the answer, and checks 2 to 5 explain it. If the D flag
is present on the cooked-file chunks you care about, direct I/O is working and
nothing else needs doing. On AIX, a C in the same position means
concurrent I/O is enabled and counts the same way. If it is absent on a non-temporary cooked-file chunk,
the remaining checks tell
you whether the cause is the configuration, the filesystem, the device, or
something else. The remedies are to move those dbspaces to a filesystem whose
alignment they satisfy, rebuild them at a page size that does, accept buffered
I/O where the space is small and well cached, or use raw devices for the
latency-critical log spaces. Those do not cost the same, and one of them is a
rebuild.
Containers, Kubernetes and OpenShift
Everything above holds when the engine runs in a container. What changes is the cost of the actions it recommends, and in two places that is enough to change the recommendation itself.
Why the economics change
On a traditional host, a separate volume means LVM, and the work is in the
provisioning: a volume group, a logical volume, a filesystem, an
/etc/fstab entry, and a mount that has to survive a reboot. That
cost is why single-filesystem layouts are so common. It is not that anyone
decided separation was wrong. It was work, and the performance case for doing it
was weak.
In Kubernetes that cost is close to zero, since a second PersistentVolumeClaim is a few lines of YAML. But a claim is a request for storage, not a guarantee of an isolated device, and that distinction matters more than it first appears.
- On a block-backed CSI driver, a claim typically does present as its own device in the guest, with its own request queue. That is the case the rest of this section assumes.
- On a shared-filesystem backend such as NFS, it does not. Several claims can be directories on one export, sharing a single mount, a single client connection and a single server-side queue. The layout looks separated and behaves as one device.
- Even with block volumes, claims from the same storage class commonly land on the same backing pool or datastore, so the array-side queue is shared even where the guest-side queue is not.
So the first container question is not how many claims to create but what each claim is actually backed by. Guest-side separation and backend separation are different properties, and only the first comes automatically.
The other side of the trade is that you lose direct control of the filesystem. You asked for storage and a filesystem type, and the driver created the filesystem with its own defaults.
The decision rule, restated
| Rule | In a container |
|---|---|
| Logical logs on their own volume | Easier, subject to the backing check above. |
| Temp dbspaces on their own volume | Much easier, and the natural case for a dedicated ephemeral volume. |
| Log backups and archive separated | Unchanged. Use another claim, or object storage. |
| Do not split data chunks for performance | Unchanged, and more true, since claims carry real management cost. |
| One filesystem per volume | Automatic. A filesystem-mode claim is exactly this, and cannot be subdivided. |
| Verify page size against block size | Use check 1 as before. The remedies differ, as described below. |
Temp dbspaces have one container-specific wrinkle. A RAM-backed ephemeral volume
is attractive for a space whose loss costs nothing, but tmpfs has historically
not supported O_DIRECT, and support depends on the kernel version,
so test it on your own nodes rather than assuming. Where it is not supported,
temp chunks placed there run buffered. That is harmless, since the data is
already in memory, but it means the temp-dbspace bit of DIRECT_IO
will show no D on those chunks, which is expected and not a defect.
A RAM-backed temp space also counts against the pod’s memory limit, so it
competes with the bufferpool rather than supplementing it.
The page-size constraint, and block mode
A storage class typically exposes the filesystem type and little else, and many
drivers provide no mkfs block-size parameter. So the cheapest
remedy, moving the affected dbspaces to a filesystem whose block size suits the
page size, may not be expressible. Check the specific driver rather than
assuming either way.
A block-mode volume gives the pod a raw device and no filesystem, which removes filesystem alignment from the question entirely. It does not remove device alignment, and it does not remove the release-specific support considerations in the constraint section, so it is a narrower fix than it first appears.
Verify before committing to it:
- that the CSI driver supports
volumeMode: Blockfor the storage class in question - that the device is accessible to the UID the container actually runs as.
fsGroupdoes not give a portable guarantee for raw block devices, because device permission handling differs by driver and by Kubernetes version, and needs testing rather than assuming - that expansion behaves as expected for block volumes on that driver, which is not always the same as for filesystem volumes
- that your Informix release supports the configuration you are moving to
Raw devices reconsidered
The usual objections to raw devices are the loss of online resize, the loss of ordinary filesystem tooling, and the fragility of device naming and permissions. Those are judgements about operational cost, not about throughput. A container platform pays some of that cost for you, though less of it than the YAML suggests.
| Objection to raw devices | On a traditional host | With a block-mode volume |
|---|---|---|
| Device naming across reboots | Real, needing udev rules or /dev/mapper discipline | Handled: the device appears at the path in the pod specification |
| Permissions | Real | Driver-dependent, so verify and do not assume |
| Resize | Awkward | A claim edit, where the driver supports it for block mode |
| Provisioning effort | Significant | Comparable to a filesystem volume |
| Ordinary filesystem tooling for backup and inspection | Lost | Still lost |
This does not make raw devices the default. The performance case remains a field estimate of around 5%, which is not a reason to change a working cooked layout. What changes is that raw becomes a reasonable answer to a specific problem, which is alignment that the available filesystems cannot satisfy, where on a traditional host it would have been an overreaction.
Advice of the form “do not convert to raw devices”, written for a traditional or virtualised estate, should be read as scoped to that estate.
Extendable chunks meet a volume that does not grow itself
Extendable chunks are good practice, and their metadata cost is paid per extension rather than per I/O. They do assume that somebody can enlarge the volume underneath when it fills.
In a container the engine can grow the chunk and the volume cannot grow itself. A claim has a fixed size until somebody changes it, so an extendable chunk can attempt to grow, find the filesystem full, and fail the extension, leaving the dbspace out of space even though the chunk configuration was correct.
Enabling allowVolumeExpansion on the storage class lets an eligible
claim request expansion, subject to driver and backend support. A larger claim
provides capacity underneath Informix. A separate Informix operation, or
automatic storage management, is what makes that capacity available to a
dbspace.
This is checkable and recoverable rather than a trap.
- Volume expansion must be enabled on the storage class. It can be added to an existing class by editing or patching it, and claims already provisioned from that class can then be expanded, so getting it wrong initially is not permanent.
- Expansion is per claim, by raising the requested storage. Volume claim templates in a StatefulSet cannot be edited in place, so each claim has to be expanded individually.
- Most drivers support expanding a mounted volume online, and some still require the pod to restart. This is driver-specific.
Three pieces of practical guidance follow.
- Verify that expansion is enabled before provisioning, not during an incident.
- Work to a defined sizing budget that covers existing allocations, planned growth and filesystem headroom, so the engine cannot outrun the volume.
- Alert on filesystem utilisation, not only on dbspace utilisation. On a traditional host the two tend to track each other because the volume is sized generously. With a fixed claim they can diverge, and the dbspace will report space that it cannot actually obtain.
It is also worth asking whether extendable chunks remain the right choice when the volume beneath them is fixed. A fixed claim with fixed chunks is less convenient and more predictable.
Confirm where the chunks actually landed
Container storage introduces one failure that has no equivalent on a traditional host: chunks on the container’s writable layer. That layer does not survive a restart, and it is a poor home for direct I/O, so this is a data-loss failure and a performance failure together.
onstat -d # the configured chunk paths findmnt -T /path/to/chunk # what that path is actually on
It matters what this establishes and what it does not. findmnt
returning something other than overlay does not prove the storage
is persistent, because an emptyDir is a real mount and is not
overlay, and it is still gone when the pod is replaced. The check is therefore
to resolve every chunk path from onstat -d and confirm that each
one is on the volume you intended for it.
- Persistent cooked chunks should resolve to their intended persistent volume mount.
- Raw chunks should resolve to their configured device path.
findmntdoes not apply to them at all, and the check is that the device is present and is the one you meant. - Temporary dbspaces on a dedicated ephemeral volume are correct, not a violation. They are the one case where non-persistent backing is the intended design, as described for temp dbspaces earlier, and flagging them as an error would be wrong.
The thing to catch is a chunk that was meant to be on a persistent volume and
silently landed somewhere else, which is usually the writable layer and
occasionally a forgotten emptyDir.
OpenShift: the security context
On OpenShift the default restricted-v2 security context constraint
blocks several things a database pod may need: running as a fixed UID,
IPC_LOCK for locking shared memory, hostPath volumes,
and unsafe sysctls.
Do not ask for a blanket exception. Each of those is a separate permission, and an SCC exception should be justified against a specific, demonstrated workload requirement rather than granted wholesale because a database is involved. Establish which of them your configuration actually needs, since many deployments need none, and request only those. It is a security conversation with the platform team, and a narrowly scoped request is far more likely to succeed than a broad one.
Filesystem choice, briefly
XFS is the mainstream choice on Linux and suits this workload well, with metadata-only journalling, good large-file and direct-I/O behaviour and online growth. ext4 is serviceable: it can be grown online, but it cannot be shrunk online.
Older Informix guidance recommends non-journalling filesystems such as ext2, on the reasoning that the journal is pure overhead for preallocated chunks. That advice is dated. The journal is near-idle anyway, and the recovery time after an unclean shutdown is a poor trade for what is saved.
Copy-on-write filesystems, such as btrfs or ZFS without careful tuning, are best avoided for chunks unless their behaviour is well understood. Copy-on-write turns in-place database writes into allocations, which reintroduces exactly the fragmentation and metadata traffic that preallocation removes.
Overlayfs is not a candidate for chunks at all, because its writable layer does not persist, for the reasons given in the section on where chunks actually landed.
Disabling the ext4 journal on Red Hat: a field report
The dated advice above is sometimes applied by taking a modern filesystem and turning its journal off, for example with
tune2fs -O ^has_journalon ext4. Do not do this on RHEL.Red Hat has a documented incident record for a kernel panic with a journal-less ext4 on specific RHEL 6 kernels, so the failure mode is not hypothetical. Separately, a case reported to Oninit in November 2026 found a current RHEL release locking up in the same configuration, with Red Hat acknowledging the behaviour but declining to treat it as a bug because running ext4 without a journal falls outside their supported configuration. That second account is a single field report rather than a published support statement, and anyone relying on it should confirm the current policy for their own release and subscription.
The direction of the advice does not depend on which account you weight. The theoretical gain from removing a journal that is already near-idle for preallocated chunks is close to nothing, and the downside is an unsupported configuration. If the journal genuinely has to go, that is an argument for XFS or for raw devices, not for crippling ext4.
A decision rule
Start from the block devices rather than the filesystems, and work through the following in order.
- Evaluate putting the logical logs on their own volume first, when unbuffered commit latency is the bottleneck and measured storage contention justifies it. This is the split with the clearest mechanism behind it, and it protects the commit path.
- Put temp dbspaces on their own volume, because losing them costs nothing and containing them costs nothing.
- Separate the log backups and archive destinations. Throughput-bound bulk writes have no business sharing a queue with database I/O.
- Do not split data chunks across many filesystems for performance. If the array benefits, spread them across devices instead, since the filesystem count is irrelevant.
- Give each volume one filesystem. Several filesystems on one volume gets you the space ceilings and the metrics but none of the queue separation, which is fine if that is what you wanted, provided you are clear it is what you are buying.
- Check
onstat -dfor theDflag on every cooked-file chunk where direct I/O is expected, or forCon AIX where concurrent I/O is expected. Include default-page-size chunks, and investigate any non-temporary one missing the flag, using the checks above. Raw chunks do not carry the flag.
In a container, add three steps and reorder nothing.
- Confirm every chunk resolves to the volume you intended for it, as described above: persistent volumes for persistent spaces, a dedicated ephemeral volume for temp if that is the design, and never the writable layer by accident.
- Establish what each claim is actually backed by before assuming it isolates anything, and where alignment cannot be satisfied by any available filesystem, evaluate a block-mode volume for the affected spaces against the verification list above.
- Verify that volume expansion is enabled and size for growth, because the engine extends itself and the volume does not.
If a split is made, use it. A separate volume with nothing on it is the worst outcome: it carries the operational cost of an extra filesystem, gives none of the benefit, and invites the assumption that a separation exists when it does not. In a container this applies with more force, not less, because a declared claim with nothing on it consumes quota, appears in every inventory, and invites exactly the same wrong assumption.
Sources
- onstat -d command: Print chunk information — IBM Informix 14.10
- Improving the performance of cooked-file dbspaces by using direct I/O — HCL Informix 14.10
- Direct I/O (UNIX) — IBM Informix 14.10
- Direct I/O behaviour — HCL Informix 14.10 Performance Guide
- DIRECT_IO configuration parameter (UNIX) — HCL Informix 14.10
- DIRECT_IO configuration parameter (UNIX) — HCL Informix 15.0
- I/O-related onstat commands — HCL Informix 14.10
- Unbuffered or buffered disk access on UNIX — HCL Informix 14.10
- Dbspace and chunk guidelines — HCL Informix 14.10
- open(2) — Linux manual page,
O_DIRECTalignment - mincore(2) — Linux manual page
- Kubernetes — persistent volumes
- Kubernetes — volumes and their lifetimes
- Kubernetes — non-root containers and devices
- Red Hat — kernel panic in ext4 running without a filesystem journal on RHEL 6
- Informix on RHEL on VMware: cooked vs raw devices recommendation (IBM Community), source of the 5% field estimate
- Undocumented feature: direct I/O enabled for temp dbspaces (IBM Community)
- Expand volumes — NetApp Trident