Module rsyscall.unistd.pipe

Classes

class Pipe (read: FileDescriptor, write: FileDescriptor)

A pair of file descriptors, as written by pipe.

Expand source code Browse git

@dataclass
class Pipe(FixedSize):
    "A pair of file descriptors, as written by pipe."
    read: FileDescriptor
    write: FileDescriptor

    def __getitem__(self, idx: int) -> FileDescriptor:
        if idx == 0:
            return self.read
        elif idx == 1:
            return self.write
        else:
            raise IndexError("only index 0 or 1 are valid for Pipe:", idx)

    def __iter__(self) -> t.Iterable[FileDescriptor]:
        return iter([self.read, self.write])

    @classmethod
    def sizeof(cls) -> int:
        return ffi.sizeof('struct fdpair')

    @classmethod
    def get_serializer(cls: t.Type[T_pipe], task: FileDescriptorTask[FileDescriptor]) -> Serializer[T_pipe]:
        return PipeSerializer(cls, task)

Ancestors

• FixedSize
• FixedSerializer
• HasSerializer

Class variables

var read : FileDescriptor

var write : FileDescriptor

Inherited members

• FixedSize:
  • get_self_serializer
  • get_serializer
  • sizeof

class PipeSerializer (cls: t.Type[T_pipe], task: FileDescriptorTask[FileDescriptor])

PipeSerializer(cls: 't.Type[T_pipe]', task: 'FileDescriptorTask[FileDescriptor]')

Expand source code Browse git

@dataclass
class PipeSerializer(Serializer[T_pipe]):
    cls: t.Type[T_pipe]
    task: FileDescriptorTask[FileDescriptor]

    def to_bytes(self, pair: T_pipe) -> bytes:
        struct = ffi.new('struct fdpair*', (pair.read, pair.write))
        return bytes(ffi.buffer(struct))

    def from_bytes(self, data: bytes) -> T_pipe:
        struct = ffi.cast('struct fdpair const*', ffi.from_buffer(data))
        def make(n: int) -> FileDescriptor:
            return self.task.make_fd_handle(near.FileDescriptor(int(n)))
        return self.cls(make(struct.first), make(struct.second))

Ancestors

• Serializer
• typing.Generic

Class variables

var cls : t.Type[T_pipe]

var task : FileDescriptorTask[FileDescriptor]

Inherited members

• Serializer:
  • from_bytes
  • to_bytes

class PipeTask (sysif: SyscallInterface, near_process: Process, fd_table: FDTable, address_space: AddressSpace, pidns: PidNamespace)

A wrapper around SyscallInterface which tracks the namespaces of the underlying process

Note that this is a base class for the more fully featured Task.

We store namespace objects to represent the namespaces that we believe that underlying processes is in. Since we have complete control over the process, we can make sure this belief is accurate, by updating our stored namespaces when the process changes namespace. That isn't done here; it's done in handle.Task.

Currently, we store only one PidNamespace. But each process actually has two pid namespaces:

• the process's own pid namespace, which determines the pids returned from getpid, clone, and other syscalls.
• the pid namespace that new children will be in.

The two pid namespaces only differ if we call unshare(CLONE.NEWPID). Currently we don't do that because unshare(CLONE.NEWPID) makes monitoring children more complex, since they can be deleted without leaving a zombie at any time if the pid namespace shuts down. But if we did call unshare(CLONE.NEWPID), we'd need to handle this right.

In the analogy to near and far pointers, this is like a segment register, if a segment register was write-only. Then we'd need to maintain the knowledge of what the segment register was set to, outside the segment register itself. That's what we do here.

There actually were systems where segment registers were, if not quite write-only, at least expensive to set and expensive to read. For example, x86_64 - the FS and GS segment registers can only be set via syscall. If you wanted to use segmentation on such systems, you'd probably have a structure much like this one.

Expand source code Browse git

class PipeTask(FileDescriptorTask):
    async def pipe(self, buf: Pointer[Pipe], flags: O=O.NONE) -> LinearPointer[Pipe]:
        """create pipe

        manpage: pipe2(2)
        """
        # TODO we should force the serializer for the pipe to be using this task...
        # otherwise it could get deserialized by a task with which we share memory,
        # but not share file descriptor tables.
        # Maybe we could create the Serializer right here, and discard
        # the passed-in one? That wouldn't allow a different task in
        # the same fd table to receive the handles though.
        with buf.borrow(self):
            await _pipe(self.sysif, buf.near, flags|O.CLOEXEC)
            return buf._linearize()

Ancestors

• FileDescriptorTask
• Task
• typing.Generic

Subclasses

• Task

Class variables

var sysif : SyscallInterface

var near_process : Process

var fd_table : FDTable

var address_space : AddressSpace

var pidns : PidNamespace

Methods

async def pipe(self, buf: Pointer[Pipe], flags: O = O.NONE) ‑> LinearPointer[Pipe]

create pipe

manpage: pipe2(2)

Expand source code Browse git

async def pipe(self, buf: Pointer[Pipe], flags: O=O.NONE) -> LinearPointer[Pipe]:
    """create pipe

    manpage: pipe2(2)
    """
    # TODO we should force the serializer for the pipe to be using this task...
    # otherwise it could get deserialized by a task with which we share memory,
    # but not share file descriptor tables.
    # Maybe we could create the Serializer right here, and discard
    # the passed-in one? That wouldn't allow a different task in
    # the same fd table to receive the handles though.
    with buf.borrow(self):
        await _pipe(self.sysif, buf.near, flags|O.CLOEXEC)
        return buf._linearize()

Inherited members

• FileDescriptorTask:
  • inherit_fd
  • make_fd_handle
  • unshare_files