AIX Version 4.3 Differences Guide

address and marks the process as a 32-bit executable. The segstate structure is
handled later by shm_asinit(), and the 64-bit u-block extension is freed in the
subsequent call to vm_cleardata(). The vm_cleardata() call also initializes the
sbreak value for the private segment and adjusts the storage protect key
accordingly in the external page tables covering the user region. There is no
service to re-initialize a 64-bit adspace to a newly-created 64-bit adspace, so it is
necessary to call vm_makeme32, followed by vm_cleardata() and
vm_makeme64(), when a 64-bit program exec()’s another 64-bit program.
3.2.6.2 Address Space Management
The address space management code is significantly impacted for 64-bits. The
code was updated to understand segment numbers, or effective segment IDs,
above the first sixteen IDs.
32-Bit Address Space Programming Interfaces
The following 32-bit services that operate on the process address space are
exported to kernel extensions, so the AIX 4.3 versions of these services are
binary-compatible with prior versions. For internal base kernel use, these address
space services are extended to handle 64-bit address spaces but only by code
that has been modified to be 64-bit aware. This means only by code that knows
how to compute an appropriate adspace_t for a 64-bit address space:
caddr_t as_att(adspace_t * adsp, vmhandle_t srval, caddr_t addr)
int as_det(adspace_t * adsp, caddr_t addr)
vmhandle_t as_geth(adspace_t * adsp, caddr_t addr)
vmhandle_t as_getsrval(adspace_t * adsp, caddr_t addr)
void as_puth(adspace_t *adsp, vmhandle_t srval)
void as_seth(adspace_t * adsp, vmhandle_t srval, caddr_t addr)
adspace_t *getadsp()
To provide compatibility for 32-bit kernel extensions, the 32-bit getadsp() kernel
service is modified to determine if it is running under a 64-bit user address space,
and if so, it will return the first adspace_t. This represents ESIDS 0-15. This could
enable some extensions to run under the 4 GB boundary for 64-bit.
All of the 32-bit services listed may be used by a kernel extension or device
driver, but they will only operate on addresses below 4 GB, even when under a
64-bit process. The service to compute an adspace_t for 64-bit, getadsp64(), is
not exported from the kernel. Thus, these routines are not enabled outside the
kernel to operate above the 4 GB line.
Kernel services and drivers should use the new 64-bit address space services
described in the following.
For 64-bit address spaces (internal to the kernel, where there is getadsp64()), the
address arguments specified preceding as caddr_ts are actually 32-bit quantities
that are treated as offsets into the appropriate adspace_t. The only reason for
keeping enablement of these services for 64-bit inside the kernel is that, on some
system calls, there should be some performance improvement by only computing
an adspace_t once.
64-Bit Address Space Programming Interfaces
The following additional address space services are provided for use by the
64-bit kernel extension and by other base kernel code that has been modified to
be 64-bit aware.
64-Bit Enablement 53