SEGATTACH(2) SEGATTACH(2)
NAME
segattach, segdetach, segfree - map/unmap a segment in
virtual memory
SYNOPSIS
int segattach(int attr, char *class, void *va, ulong len)
int segdetach(void *addr)
int segfree(void *va, ulong len)
DESCRIPTION
Segattach creates a new memory segment and adds it to the
calling process's address space. Segments are identified by
system-dependent classes. Segment classes memory (plain
memory) and shared (shared memory) should be available on
all systems.
Shared segments are inherited by the children of the attach-
ing process and remain untouched across a fork(2). An
exec(2) will release a shared segment if it overlaps the
segments in the file being exec'ed; otherwise the segment
will be inherited.
Some machines provide a segment class lock. Lock segments
allow access to special lock hardware provided by some mul-
tiprocessors, in particular the SGI Power Series machines.
Systems may also provide interfaces to special hardware
devices like frame buffers through the segattach interface.
Device memory mapped by this method is typically uncached by
default.
If the specified class is unknown, segattach draws an error.
Attr specifies the new segment's attributes. The only
attribute implemented on all classes of segment is SG_RONLY,
which allows only read access on the segment. Specific
devices may implement attributes to control caching and
allocation, but these will vary between devices.
Va and len specify the position of the segment in the
process's address space. Va is rounded down to the nearest
page boundary and va+len is rounded up. The system does not
permit segments to overlap.
Segdetach removes a segment from a process's address space.
Memory used by the segment is freed. Addr may be any
address within the bounds of the segment.
Page 1 Plan 9 (printed 12/21/24)
SEGATTACH(2) SEGATTACH(2)
The system will not permit the text and stack segments to be
detached from the address space.
Segfree allows specific areas of a segment's memory to be
freed. Va and len are interpreted as in segattach but need
not refer to the entire segment.
To select a virtual address to which a segment can be
attached, the following algorithm is reliable. Read the
segment file of the current process (see proc(3)) to find
the base of the stack segment. Subtract the size of the new
segment and use that address.
The MIPS R2000 and R3000 have no hardware instructions to
implement locks. The following method can be used to build
them from software. First, try to segattach a segment of
class lock. If this succeeds, the machine is an SGI Power
Series and the memory contains hardware locks. Each 4096-
byte page has 64 long words at its beginning; each word
implements a test-and-set semaphore when read; the low bit
of the word is zero on success, one on failure. If the
segattach fails, there is no hardware support but the oper-
ating system helps: Any COP3 instruction will be trapped by
the kernel and interpreted as a test-and-set. In the trap,
R1 points to a long; on return, R1 is greater or equal zero
on success, negative on failure. The following assembly
language implements such a test-and-set.
/*
* MIPS test and set
*/
TEXT tas(SB), $0
btas:
MOVW sema+0(FP), R1
MOVB R0, 1(R1)
NOR R0, R0, R0 /* NOP */
WORD $(023<<26) /* MFC3 R0, R0 */
BLTZ R1, btas
RET
SEE ALSO
segbrk(2), segflush(2)
/proc/*/segment
DIAGNOSTICS
These functions set errstr.
Page 2 Plan 9 (printed 12/21/24)