c124ab264b
loop.py is a simple wrapper around the kernel loop API. remoteloop.py uses this to create a server/clinet pair that communicates over an AF_UNIX/SOCK_DGRAM socket to allow the server to create loop devices for the client. The client passes a fd that should be bound to the resulting loop device, and a dir-fd where the loop device node should be created. The server returns the name of the device node to the client. The idea is that the client is run from whithin a container without access to devtmpfs (and hence /dev/loop-control), and the server runs on the host. The client would typically pass its (fake) /dev as the output directory. For the client this will be similar to `losetup -f foo.img --show`. [@larskarlitski: pylint: ignore the new LoopInfo class, because it only has dynamic attributes. Also disable attribute-defined-outside-init, which (among other problems) is not ignored for that class.] Signed-off-by: Tom Gundersen <teg@jklm.no>
138 lines
4.2 KiB
Python
138 lines
4.2 KiB
Python
import array
|
|
import asyncio
|
|
import errno
|
|
import json
|
|
import os
|
|
import socket
|
|
import threading
|
|
import osbuild.loop as loop
|
|
|
|
|
|
__all__ = [
|
|
"LoopClient",
|
|
"LoopServer"
|
|
]
|
|
|
|
|
|
def load_fds(sock, msglen):
|
|
fds = array.array("i") # Array of ints
|
|
msg, ancdata, _, addr = sock.recvmsg(msglen, socket.CMSG_LEN(253 * fds.itemsize))
|
|
for cmsg_level, cmsg_type, cmsg_data in ancdata:
|
|
if (cmsg_level == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS):
|
|
# Append data, ignoring any truncated integers at the end.
|
|
fds.fromstring(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
|
|
return json.loads(msg), list(fds), addr
|
|
|
|
|
|
def dump_fds(sock, obj, fds):
|
|
sock.sendmsg([json.dumps(obj).encode('utf-8')], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array("i", fds))])
|
|
|
|
|
|
class LoopServer:
|
|
"""Server for creating loopback devices
|
|
|
|
The server listens for requests on a AF_UNIX/SOCK_DRGAM sockets.
|
|
|
|
A request should contain SCM_RIGHTS of two filedescriptors, one
|
|
that sholud be the backing file for the new loopdevice, and a
|
|
second that should be a directory file descriptor where the new
|
|
device node will be created.
|
|
|
|
The payload should be a JSON object with the mandatory arguments
|
|
@fd which is the offset in the SCM_RIGHTS array for the backing
|
|
file descriptor and @dir_fd which is the offset for the output
|
|
directory. Optionally, @offset and @sizelimit in bytes may also
|
|
be specified.
|
|
|
|
The server respods with a JSON object containing the device name
|
|
of the new device node created in the output directory.
|
|
|
|
The created loopback device is guaranteed to be bound to the
|
|
given backing file descriptor for the lifetime of the LoopServer
|
|
object.
|
|
"""
|
|
|
|
def __init__(self, sock):
|
|
self.devs = []
|
|
self.sock = sock
|
|
self.ctl = loop.LoopControl()
|
|
self.event_loop = asyncio.new_event_loop()
|
|
self.event_loop.add_reader(self.sock, self._dispatch)
|
|
self.thread = threading.Thread(target=self._run_event_loop)
|
|
|
|
def __del__(self):
|
|
self.sock.close()
|
|
|
|
def _create_device(self, fd, dir_fd, offset=None, sizelimit=None):
|
|
while True:
|
|
# Getting an unbound loopback device and attaching a backing
|
|
# file descriptor to it is racy, so we must use a retry loop
|
|
lo = loop.Loop(self.ctl.get_unbound())
|
|
try:
|
|
lo.set_fd(fd)
|
|
except OSError as e:
|
|
if e.errno == errno.EBUSY:
|
|
continue
|
|
raise e
|
|
break
|
|
lo.set_status(offset=offset, sizelimit=sizelimit, autoclear=True)
|
|
lo.mknod(dir_fd)
|
|
# Pin the Loop objects so they are only released when the LoopServer
|
|
# is destroyed.
|
|
self.devs.append(lo)
|
|
return lo.devname
|
|
|
|
def _dispatch(self):
|
|
args, fds, addr = load_fds(self.sock, 1024)
|
|
|
|
fd = fds[args["fd"]]
|
|
dir_fd = fds[args["dir_fd"]]
|
|
offset = args.get("offset")
|
|
sizelimit = args.get("sizelimit")
|
|
|
|
devname = self._create_device(fd, dir_fd, offset, sizelimit)
|
|
ret = json.dumps({"devname": devname})
|
|
self.sock.sendto(ret.encode('utf-8'), addr)
|
|
|
|
def _run_event_loop(self):
|
|
# Set the thread-local event loop
|
|
asyncio.set_event_loop(self.event_loop)
|
|
# Run event loop until stopped
|
|
self.event_loop.run_forever()
|
|
|
|
def __enter__(self):
|
|
self.thread.start()
|
|
|
|
def __exit__(self, *args):
|
|
self.event_loop.call_soon_threadsafe(self.event_loop.stop)
|
|
self.thread.join()
|
|
|
|
|
|
class LoopClient:
|
|
def __init__(self, sock):
|
|
self.sock = sock
|
|
|
|
def __del__(self):
|
|
self.sock.close()
|
|
|
|
def create_device(self, fd, dir_fd=None, offset=None, sizelimit=None):
|
|
req = {}
|
|
fds = array.array("i")
|
|
|
|
if not dir_fd:
|
|
dir_fd = os.open("/dev", os.O_DIRECTORY)
|
|
|
|
fds.append(fd)
|
|
req["fd"] = 0
|
|
fds.append(dir_fd)
|
|
req["dir_fd"] = 1
|
|
|
|
if offset:
|
|
req["offset"] = offset
|
|
if sizelimit:
|
|
req["sizelimit"] = sizelimit
|
|
|
|
dump_fds(self.sock, req, fds)
|
|
ret = json.loads(self.sock.recv(1024))
|
|
|
|
return ret["devname"]
|