Fix OpenEnv sessions and scoped runtime cleanup (part 2)

components/tmax/runtime/native_shell/backend.py

@@ -17,7 +17,7 @@ import time
 from uuid import uuid4
 
 from common.contracts import ACTION_SCHEMA, observation_payload
-from .guard import Guard, GuardError, Policy, ordinary
+from .guard import Guard, GuardError, InvalidOutput, Policy, ordinary
 
 _lease = Lock()
 
@@ -142,8 +142,6 @@ class ShellBackend:
                     shutil.copyfile(pristine,target)
                 clear_contents('/logs/verifier')
                 clear_contents(self._private_root()/'episode')
-                clear_contents('/tmp')
-                os.chown('/tmp',0,0);os.chmod('/tmp',0o1777)
                 os.chown(self.config_path.parent,0,0);os.chmod(self.config_path.parent,0o700)
                 policy=Policy(workspace=work,
                     inputs=tuple(Path(p) for p in task['inputs']),
@@ -210,7 +208,7 @@ class ShellBackend:
     def _finish_impl(self):
         try:
             self.guard.freeze()
-        except GuardError:
+        except InvalidOutput:
             self.guard.stop_actor()
             self.final=observation_payload(self.task['id'],'Output violates the published regular-file boundary.',
                                            {'status':'invalid_output'},reward=0.0,done=True)
@@ -218,7 +216,6 @@ class ShellBackend:
 
 
 
-        clear_contents('/tmp');os.chown('/tmp',0,0);os.chmod('/tmp',0o700)
         grader=self.task['grader']
         python=self.task['python']
         private=self._private_root()/'episode'

components/tmax/runtime/native_shell/guard.py

@@ -16,10 +16,20 @@ import sys
 import time
 
 
+try:
+    from .process_scope import current_scope
+except ImportError:
+    from process_scope import current_scope
+
+
 class GuardError(RuntimeError):
     pass
 
 
+class InvalidOutput(GuardError):
+    pass
+
+
 def ordinary(path):
     path = Path(path)
     for current in [path, *path.parents]:
@@ -84,6 +94,7 @@ class Guard:
         if sys.platform != "linux" or os.geteuid() != 0:
             raise GuardError("Guard requires a dedicated Linux root supervisor")
         self.policy = policy
+        self.scope = current_scope()
         self.records = {}
         self.closed_trees = {}
         self.phase = "new"
@@ -104,7 +115,8 @@ class Guard:
 
         for parent in [Path(path).parent, *Path(path).parent.parents]:
             st = ordinary(parent)
-            os.chown(parent, 0, 0)
+            if st.st_uid != 0 or st.st_gid != 0:
+                os.chown(parent, 0, 0)
             mode = stat.S_IMODE(st.st_mode)
             if mode & 0o022:
                 os.chmod(parent, mode | stat.S_ISVTX)
@@ -181,29 +193,7 @@ class Guard:
                 raise GuardError(f"Protected directory membership changed: {root}")
 
     def stop_actor(self):
-
-        deadline = time.monotonic() + 3
-        while True:
-            live = []
-            for entry in Path("/proc").iterdir():
-                if not entry.name.isdigit():
-                    continue
-                try:
-                    fields = dict(line.split(":", 1) for line in (entry / "status").read_text().splitlines() if ":" in line)
-                    if self.policy.uid in map(int, fields["Uid"].split()) and not fields["State"].strip().startswith("Z"):
-                        live.append(int(entry.name))
-                except (FileNotFoundError, ProcessLookupError, PermissionError):
-                    continue
-            if not live:
-                return
-            for pid in live:
-                try:
-                    os.kill(pid, signal.SIGKILL)
-                except ProcessLookupError:
-                    pass
-            if time.monotonic() > deadline:
-                raise GuardError("Could not stop all actor processes")
-            time.sleep(0.02)
+        return self.scope.stop_uid(self.policy.uid)
 
     def run_actor(self, command, timeout=10, output_limit=65536):
         if self.phase != "actor":
@@ -219,6 +209,7 @@ class Guard:
         process = subprocess.Popen(argv, env={"PATH": "/usr/local/bin:/usr/bin:/bin"},
             stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             pass_fds=(write_fd,), start_new_session=True)
+        identity = self.scope.track_child(process.pid)
         os.close(write_fd)
         selector = selectors.DefaultSelector()
         for stream in [process.stdout, process.stderr]:
@@ -229,16 +220,7 @@ class Guard:
         deadline = time.monotonic() + timeout
         try:
             while selector.get_map():
-                rss_kib = 0
-                for entry in Path('/proc').iterdir():
-                    if not entry.name.isdigit():
-                        continue
-                    try:
-                        fields = dict(line.split(':',1) for line in (entry/'status').read_text().splitlines() if ':' in line)
-                        if self.policy.uid in map(int,fields['Uid'].split()):
-                            rss_kib += int(fields.get('VmRSS','0').split()[0])
-                    except (FileNotFoundError,ProcessLookupError,PermissionError):
-                        continue
+                rss_kib = self.scope.rss_kib(self.policy.uid)
                 if rss_kib > self.policy.memory_mb * 1024:
                     reason = 'aggregate_rss_limit'
                     self.stop_actor()
@@ -276,6 +258,8 @@ class Guard:
                 self.stop_actor()
                 process.kill()
                 process.wait()
+            self.scope.untrack_child(identity)
+            self.scope.reap_uid(self.policy.uid)
         self.check_integrity()
         return {"return_code": process.returncode, "reason": reason,
                 "stdout": output[process.stdout].decode(errors="replace"),
@@ -286,20 +270,23 @@ class Guard:
             raise GuardError("Can only freeze an active actor phase")
         self.stop_actor()
         self.check_integrity()
-        total = 0
-        for path in self.policy.output_paths:
-            if not path.is_relative_to(self.policy.workspace):
-                raise GuardError("Output path is outside workspace")
-            if not os.path.lexists(path):
-                continue
-            for item in descendants(path):
-                st = ordinary(item)
-                if stat.S_ISREG(st.st_mode):
-                    total += st.st_size
-                    if st.st_size > 16 * 1024 * 1024 or total > 64 * 1024 * 1024:
-                        raise GuardError("Output artifact exceeds prototype limits")
-                os.chown(item, 0, 0)
-                os.chmod(item, 0o555 if stat.S_ISDIR(st.st_mode) else 0o444)
+        try:
+            total = 0
+            for path in self.policy.output_paths:
+                if not path.is_relative_to(self.policy.workspace):
+                    raise GuardError("Output path is outside workspace")
+                if not os.path.lexists(path):
+                    continue
+                for item in descendants(path):
+                    st = ordinary(item)
+                    if stat.S_ISREG(st.st_mode):
+                        total += st.st_size
+                        if st.st_size > 16 * 1024 * 1024 or total > 64 * 1024 * 1024:
+                            raise GuardError("Output artifact exceeds prototype limits")
+                    os.chown(item, 0, 0)
+                    os.chmod(item, 0o555 if stat.S_ISDIR(st.st_mode) else 0o444)
+        except GuardError as exc:
+            raise InvalidOutput(str(exc)) from exc
         self.phase = "frozen"
 
     def run_verifier(self, script, timeout=30):

components/tmax/runtime/native_shell/process_scope.py

@@ -0,0 +1,235 @@
+import ctypes
+from dataclasses import dataclass
+import errno
+import os
+from pathlib import Path
+import signal
+import sys
+import threading
+import time
+
+
+class ProcessScopeError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class ProcessIdentity:
+    pid: int
+    start_ticks: int
+
+
+@dataclass(frozen=True)
+class ProcessRecord:
+    identity: ProcessIdentity
+    ppid: int
+    state: str
+    uids: tuple[int, ...]
+    rss_kib: int
+
+
+def _read_record(pid):
+    path = Path('/proc') / str(pid)
+    raw = (path / 'stat').read_text()
+    fields = raw[raw.rfind(')') + 2:].split()
+    if len(fields) < 22:
+        raise ProcessScopeError('Incomplete process stat')
+    status = {}
+    for line in (path / 'status').read_text().splitlines():
+        if ':' in line:
+            key, value = line.split(':', 1)
+            status[key] = value
+    uids = tuple(map(int, status['Uid'].split()))
+    if len(uids) != 4:
+        raise ProcessScopeError('Incomplete process identity')
+    record = ProcessRecord(
+        ProcessIdentity(pid, int(fields[19])), int(fields[1]), fields[0],
+        uids, int(status.get('VmRSS', '0 kB').split()[0]),
+    )
+    raw_after = (path / 'stat').read_text()
+    fields_after = raw_after[raw_after.rfind(')') + 2:].split()
+    if int(fields_after[19]) != record.identity.start_ticks:
+        raise ProcessLookupError(pid)
+    return record
+
+
+def _read_if_present(pid):
+    try:
+        return _read_record(pid)
+    except (FileNotFoundError, ProcessLookupError):
+        return None
+
+
+def _enable_subreaper():
+    if sys.platform != 'linux':
+        raise ProcessScopeError('Process scoping requires Linux')
+    if not hasattr(os, 'pidfd_open') or not hasattr(signal, 'pidfd_send_signal'):
+        raise ProcessScopeError('Process scoping requires pidfd signal support')
+    if not hasattr(os, 'P_PIDFD'):
+        raise ProcessScopeError('Process scoping requires pidfd wait support')
+    libc = ctypes.CDLL(None, use_errno=True)
+    if libc.prctl(36, 1, 0, 0, 0):
+        raise ProcessScopeError('Could not enable child subreaper: ' + str(ctypes.get_errno()))
+    value = ctypes.c_int()
+    if libc.prctl(37, ctypes.byref(value), 0, 0, 0) or value.value != 1:
+        raise ProcessScopeError('Child subreaper verification failed')
+
+
+class ProcessScope:
+    def __init__(self):
+        _enable_subreaper()
+        self.owner = _read_record(os.getpid()).identity
+        self._tracked = set()
+        self._lock = threading.RLock()
+
+    def _check_owner(self):
+        if os.getpid() != self.owner.pid or _read_record(os.getpid()).identity != self.owner:
+            raise ProcessScopeError('Process scope used by a different supervisor')
+
+    def track_child(self, pid):
+        self._check_owner()
+        record = _read_if_present(pid)
+        if record is None or not self._is_descendant(record):
+            raise ProcessScopeError('Cannot track a process outside this supervisor')
+        with self._lock:
+            self._tracked.add(record.identity)
+        return record.identity
+
+    def untrack_child(self, identity):
+        self._check_owner()
+        with self._lock:
+            self._tracked.discard(identity)
+
+    def _is_descendant(self, candidate):
+        if candidate.identity == self.owner:
+            return False
+        visited = set()
+        current = candidate
+        while current.ppid != self.owner.pid:
+            if current.ppid <= 1 or current.ppid in visited:
+                return False
+            visited.add(current.ppid)
+            parent = _read_if_present(current.ppid)
+            if parent is None:
+                return False
+            after = _read_if_present(current.identity.pid)
+            if after is None or after.identity != current.identity or after.ppid != parent.identity.pid:
+                return False
+            current = parent
+        owner = _read_if_present(self.owner.pid)
+        if owner is None or owner.identity != self.owner:
+            raise ProcessScopeError('Supervisor identity changed')
+        after = _read_if_present(current.identity.pid)
+        return after is not None and after.identity == current.identity and after.ppid == self.owner.pid
+
+    def records(self, uid, include_zombies=False):
+        self._check_owner()
+        if not isinstance(uid, int) or uid <= 0:
+            raise ProcessScopeError('Only non-root learner UIDs can be targeted')
+        records = []
+        for entry in Path('/proc').iterdir():
+            if not entry.name.isdigit():
+                continue
+            record = _read_if_present(int(entry.name))
+            if record is None or uid not in record.uids:
+                continue
+            if not include_zombies and record.state == 'Z':
+                continue
+            if self._is_descendant(record):
+                records.append(record)
+        return records
+
+    def rss_kib(self, uid):
+        return sum(record.rss_kib for record in self.records(uid))
+
+    def _open_checked_pidfd(self, record, uid):
+        current = _read_if_present(record.identity.pid)
+        if current is None or current.identity != record.identity or uid not in current.uids:
+            return None
+        if not self._is_descendant(current):
+            return None
+        try:
+            fd = os.pidfd_open(record.identity.pid, 0)
+        except ProcessLookupError:
+            return None
+        except OSError as error:
+            raise ProcessScopeError('Could not open a safe process handle') from error
+        try:
+            after = _read_if_present(record.identity.pid)
+            if after is None or after.identity != record.identity or uid not in after.uids:
+                os.close(fd)
+                return None
+            if not self._is_descendant(after):
+                os.close(fd)
+                return None
+        except BaseException:
+            os.close(fd)
+            raise
+        return fd
+
+    def reap_uid(self, uid):
+        reaped = 0
+        for record in self.records(uid, include_zombies=True):
+            with self._lock:
+                tracked = record.identity in self._tracked
+            if record.state != 'Z' or record.ppid != self.owner.pid or tracked:
+                continue
+            fd = self._open_checked_pidfd(record, uid)
+            if fd is None:
+                continue
+            try:
+                try:
+                    result = os.waitid(os.P_PIDFD, fd, os.WEXITED | os.WNOHANG)
+                    reaped += int(result is not None)
+                except ChildProcessError:
+                    pass
+            finally:
+                os.close(fd)
+        return reaped
+
+    def stop_uid(self, uid, timeout=3.0):
+        if timeout <= 0:
+            raise ValueError('A positive cleanup timeout is required')
+        deadline = time.monotonic() + timeout
+        quiet = 0
+        signaled = set()
+        reaped = 0
+        while True:
+            live = self.records(uid)
+            if not live:
+                reaped += self.reap_uid(uid)
+                quiet += 1
+                if quiet >= 2:
+                    return {'signaled': len(signaled), 'reaped': reaped}
+            else:
+                quiet = 0
+                for record in live:
+                    fd = self._open_checked_pidfd(record, uid)
+                    if fd is None:
+                        continue
+                    try:
+                        try:
+                            signal.pidfd_send_signal(fd, signal.SIGKILL, None, 0)
+                            signaled.add(record.identity)
+                        except ProcessLookupError:
+                            pass
+                        except OSError as error:
+                            raise ProcessScopeError('Could not stop a learner process') from error
+                    finally:
+                        os.close(fd)
+                reaped += self.reap_uid(uid)
+            if time.monotonic() >= deadline:
+                raise ProcessScopeError('Could not stop all scoped learner processes')
+            time.sleep(0.02)
+
+
+_current_scope = None
+_current_lock = threading.Lock()
+
+
+def current_scope():
+    global _current_scope
+    with _current_lock:
+        if _current_scope is None or _current_scope.owner.pid != os.getpid():
+            _current_scope = ProcessScope()
+        return _current_scope

components/tmax/runtime/native_shell/server.py

@@ -1,13 +1,9 @@
 
 from openenv.core.env_server.http_server import create_app
 from common.models import ArenaAction, ArenaObservation
-from common.http_routes import install_persistent_http_routes
 from .environment import NativeHarborEnvironment
-from .backend import RuntimeUnavailable
 
 app=create_app(NativeHarborEnvironment,ArenaAction,ArenaObservation,env_name='native_harbor',max_concurrent_envs=1)
-http_env=NativeHarborEnvironment()
-http_lock=install_persistent_http_routes(app,http_env,conflict_error=RuntimeUnavailable)
 
 
 def main():

components/tmax/runtime/native_shell/wire_client.py

@@ -71,48 +71,75 @@ class WireClient:
             raise PermissionError('Wire client is reserved for the trusted supervisor')
         url=urllib.parse.urlsplit(base_url)
         if url.scheme!='http' or url.hostname not in ('127.0.0.1','localhost','::1') or url.username or url.password or url.query or url.fragment or url.path not in ('','/'):
-            raise ValueError('Only an unauthenticated local HTTP server is allowed')
-        self.base_url=base_url.rstrip('/')
+            raise ValueError('Only an unauthenticated local server is allowed')
+        self.ws_url='ws://'+url.netloc+'/ws'
         self.timeout=timeout
-        self.opener=urllib.request.build_opener(urllib.request.ProxyHandler({}),RejectRedirects())
-
-    def _post(self,path,payload):
-        body=json.dumps(payload,ensure_ascii=False,allow_nan=False,separators=(',',':')).encode()
-        request=urllib.request.Request(self.base_url+path,data=body,headers={'Content-Type':'application/json'})
+        self.connection=None
+
+    def close(self):
+        if self.connection is not None:
+            from websockets.exceptions import ConnectionClosedOK
+            connection,self.connection=self.connection,None
+            try:
+                connection.send('{"type":"close"}')
+                connection.recv(timeout=min(self.timeout,10))
+                raise WireProtocolError('OpenEnv session did not close')
+            except ConnectionClosedOK:
+                pass
+            finally:
+                connection.close()
+
+    def _request(self,kind,payload):
+        from websockets.sync.client import connect
+        if self.connection is None:
+            if kind!='reset':raise WireProtocolError('Reset before stepping')
+            self.connection=connect(self.ws_url,proxy=None,open_timeout=min(self.timeout,30),max_size=2*1024*1024)
+        body=json.dumps({'type':kind,'data':payload},ensure_ascii=False,allow_nan=False,separators=(',',':'))
         try:
-            with self.opener.open(request,timeout=self.timeout) as response:
-                if response.status!=200:raise WireProtocolError('Unexpected HTTP status')
-                raw=response.read(2*1024*1024+1)
-        except urllib.error.HTTPError as exc:
-            raise WireProtocolError(f'OpenEnv HTTP {exc.code}: '+exc.read(2048).decode(errors='replace')) from exc
-        if len(raw)>2*1024*1024:raise WireProtocolError('SDK response exceeds the transport limit')
-        return validate_envelope(loads(raw))
+            self.connection.send(body)
+            response=loads(self.connection.recv(timeout=self.timeout))
+            if response.get('type')!='observation':
+                raise WireProtocolError('OpenEnv error: '+json.dumps(response.get('data',{}),ensure_ascii=False))
+            result=validate_envelope(response['data'])
+            return result
+        except BaseException:
+            self.close()
+            raise
 
     def reset(self,**kwargs):
-        return self._post('/reset',kwargs)
+        return self._request('reset',kwargs)
 
     def step(self,action):
-        return self._post('/step',{'action':action})
+        return self._request('step',action)
 
     def finish(self):
         return validate_envelope(self.step({'op':'finish'}),require_done=True)
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self,*args):
+        self.close()
+
 
 def main():
     parser=argparse.ArgumentParser()
-    parser.add_argument('operation',choices=['reset','step','finish'])
-    parser.add_argument('--payload-base64')
+    parser.add_argument('operation',choices=['episode'])
+    parser.add_argument('--payload-base64',required=True)
     parser.add_argument('--url',default='http://127.0.0.1:8000')
     parser.add_argument('--timeout',type=float,default=330)
     args=parser.parse_args()
-    payload={} if args.payload_base64 is None else loads(base64.b64decode(args.payload_base64,validate=True))
-    if not isinstance(payload,dict):raise WireProtocolError('Payload must be a JSON object')
-    client=WireClient(args.url,args.timeout)
-    if args.operation=='reset':result=client.reset(**payload)
-    elif args.operation=='step':result=client.step(payload)
-    else:
-        if payload:raise WireProtocolError('Finish has no payload')
-        result=client.finish()
+    payload=loads(base64.b64decode(args.payload_base64,validate=True))
+    if not isinstance(payload,dict) or set(payload)-{'reset','actions'}:
+        raise WireProtocolError('Expected reset and actions')
+    actions=payload.get('actions',[])
+    if not isinstance(actions,list):raise WireProtocolError('Actions must be a list')
+    with WireClient(args.url,args.timeout) as client:
+        result=client.reset(**payload.get('reset',{}))
+        for action in actions:
+            if result['done']:break
+            result=client.step(action)
+        if not result['done']:result=client.finish()
     print(json.dumps(result,ensure_ascii=False,allow_nan=False,separators=(',',':')))