AIX Version 4.3 Differences Guide

name of the 32-bit system call. If a particular 32-bit system call is named bletch(),
then:
• The name of the C language routine in libc64.a that intercepts 64-bit calls to
bletch() is precisely that: bletch. Note that the kernel does not export a symbol
named bletch to 64-bit-mode processes, so all 64-bit calls to that label reach
the library routine.
• The C language routine library, at the point where it needs to invoke the kernel
extension routine for this system call, calls __bletch() (two leading
underscores). This is an assembly-language glue routine reached through the
branch-and-link instruction. The name of its actual entry point will be .__bletch
(leading period).
• The glue routine, still in the 64-bit library, loads an entry from the TOC and
issues a system call instruction. The TOC entry is assembled as a pointer to
bletch64 (no prefix, suffix 64).
• The kernel extension routine is named bletch64(), and this is the name that
the kernel extension exports as a syscall. The kernel extension routine will
itself call bletch() the existing 32-bit kernel service.
The reason for the two underscores is for conformance with ANSI C, which
reserves names not starting with two underscores (or one underscore and a
capital letter) for the user, except for existing non-conforming UNIX names that
are grandfathered. All external symbols in libc64.a must begin with two
underscores.
3.2.2.1 64-Bit to 32-Bit Data Reformatting
The goal of the 64-bit interface is to make it appear to the kernel that the system
service request came from a 32-bit program. To this end, the width of any data
passed across the interface in either direction must be adjusted to match the
expected size.
Data reformatting is done by the 64-bit library routine that is the call target of
64-bit system calls. It receives 64-bit data from the caller, does any necessary
reformatting to 32-bit data, and calls its corresponding kernel extension routine
that passes the (now 32-bit) data on to the kernel's system call service routine.
On completion of the system call, a return code is (generally) passed back. In
addition, the kernel may have passed data back in user space. When the library
routine regains control, it expands the return code from 32 bits to 64 and expands
any returned data in user space.
For scalar parameters, the library does the following before calling the kernel
extension routine:
• char, unsigned char - Passed without change.
• short, unsigned short - Passed without change.
• int, unsigned int, long, unsigned long - Tested to make sure that the value
being passed will fit in the 32-bit version of int or unsigned int. A value that is
too large generally results in setting errno to EINVAL and returning a return
code of -1. Values that are not too large are passed as 32-bit integers.
Note: Integers that are larger than 2 32 are valid in some cases. For example,
the lseek() routine takes an off_t (that is a long) as the seek position, a value
64-Bit Enablement 39