| Current File : //sbin/rpcctl |
#!/usr/libexec/platform-python
import argparse
import collections
import errno
import os
import pathlib
import socket
import sys
with open("/proc/mounts", 'r') as f:
mount = [ line.split()[1] for line in f if "sysfs" in line ]
if len(mount) == 0:
print("ERROR: sysfs is not mounted")
sys.exit(1)
sunrpc = pathlib.Path(mount[0]) / "kernel" / "sunrpc"
if not sunrpc.is_dir():
print("ERROR: sysfs does not have sunrpc directory")
sys.exit(1)
def read_addr_file(path):
try:
with open(path, 'r') as f:
return f.readline().strip()
except:
return "(enoent)"
def write_addr_file(path, newaddr):
with open(path, 'w') as f:
f.write(newaddr)
return read_addr_file(path)
def read_info_file(path):
res = collections.defaultdict(int)
try:
with open(path) as info:
lines = [ l.split("=", 1) for l in info if "=" in l ]
res.update({ key:int(val.strip()) for (key, val) in lines })
finally:
return res
class Xprt:
def __init__(self, path):
self.path = path
self.name = path.stem.rsplit("-", 1)[0]
self.type = path.stem.split("-")[2]
self.info = read_info_file(path / "xprt_info")
self.dstaddr = read_addr_file(path / "dstaddr")
self.srcaddr = read_addr_file(path / "srcaddr")
self.read_state()
def __lt__(self, rhs):
return self.name < rhs.name
def _xprt(self):
main = ", main" if self.info.get("main_xprt") else ""
return f"{self.name}: {self.type}, {self.dstaddr}, " \
f"port {self.info['dst_port']}, state <{self.state}>{main}"
def _src_reqs(self):
return f" Source: {self.srcaddr}, port {self.info['src_port']}, " \
f"Requests: {self.info['num_reqs']}"
def _cong_slots(self):
return f" Congestion: cur {self.info['cur_cong']}, win {self.info['cong_win']}, " \
f"Slots: min {self.info['min_num_slots']}, max {self.info['max_num_slots']}"
def _queues(self):
return f" Queues: binding {self.info['binding_q_len']}, " \
f"sending {self.info['sending_q_len']}, pending {self.info['pending_q_len']}, " \
f"backlog {self.info['backlog_q_len']}, tasks {self.info['tasks_queuelen']}"
def __str__(self):
if not self.path.exists():
return f"{self.name}: has been removed"
return "\n".join([self._xprt(), self._src_reqs(),
self._cong_slots(), self._queues() ])
def read_state(self):
if self.path.exists():
with open(self.path / "xprt_state") as f:
self.state = ','.join(f.readline().split()[1:])
def small_str(self):
main = " [main]" if self.info.get("main_xprt") else ""
return f"{self.name}: {self.type}, {self.dstaddr}{main}"
def set_dstaddr(self, newaddr):
self.dstaddr = write_addr_file(self.path / "dstaddr", newaddr)
def set_state(self, state):
if self.info.get("main_xprt"):
raise Exception(f"Main xprts cannot be set {state}")
with open(self.path / "xprt_state", 'w') as f:
f.write(state)
self.read_state()
def remove(self):
if self.info.get("main_xprt"):
raise Exception("Main xprts cannot be removed")
self.set_state("offline")
self.set_state("remove")
def add_command(subparser):
parser = subparser.add_parser("xprt", help="Commands for individual xprts")
parser.set_defaults(func=Xprt.show, xprt=None)
subparser = parser.add_subparsers()
remove = subparser.add_parser("remove", help="Remove an xprt")
remove.add_argument("xprt", metavar="XPRT", nargs=1,
help="Name of the xprt to remove")
remove.set_defaults(func=Xprt.set_property, property="remove")
show = subparser.add_parser("show", help="Show xprts")
show.add_argument("xprt", metavar="XPRT", nargs='?',
help="Name of a specific xprt to show")
show.set_defaults(func=Xprt.show)
set = subparser.add_parser("set", help="Change an xprt property")
set.add_argument("xprt", metavar="XPRT", nargs=1,
help="Name of a specific xprt to modify")
subparser = set.add_subparsers()
online = subparser.add_parser("online", help="Set an xprt online")
online.set_defaults(func=Xprt.set_property, property="online")
offline = subparser.add_parser("offline", help="Set an xprt offline")
offline.set_defaults(func=Xprt.set_property, property="offline")
dstaddr = subparser.add_parser("dstaddr", help="Change an xprt's dstaddr")
dstaddr.add_argument("newaddr", metavar="NEWADDR", nargs=1,
help="The new address for the xprt")
dstaddr.set_defaults(func=Xprt.set_property, property="dstaddr")
def get_by_name(name):
glob = f"**/{name}-*" if name else "**/xprt-*"
res = [ Xprt(x) for x in (sunrpc / "xprt-switches").glob(glob) ]
if name and len(res) == 0:
raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
f"{sunrpc / 'xprt-switches' / glob}")
return sorted(res)
def show(args):
for xprt in Xprt.get_by_name(args.xprt):
print(xprt)
def set_property(args):
for xprt in Xprt.get_by_name(args.xprt[0]):
if args.property == "dstaddr":
xprt.set_dstaddr(socket.gethostbyname(args.newaddr[0]))
elif args.property == "remove":
xprt.remove()
else:
xprt.set_state(args.property)
print(xprt)
class XprtSwitch:
def __init__(self, path, sep=":"):
self.path = path
self.name = path.stem
self.info = read_info_file(path / "xprt_switch_info")
self.xprts = sorted([ Xprt(p) for p in self.path.iterdir() if p.is_dir() ])
self.sep = sep
def __lt__(self, rhs):
return self.name < rhs.name
def __str__(self):
switch = f"{self.name}{self.sep} " \
f"xprts {self.info['num_xprts']}, " \
f"active {self.info['num_active']}, " \
f"queue {self.info['queue_len']}"
xprts = [ f" {x.small_str()}" for x in self.xprts ]
return "\n".join([ switch ] + xprts)
def add_command(subparser):
parser = subparser.add_parser("switch", help="Commands for xprt switches")
parser.set_defaults(func=XprtSwitch.show, switch=None)
subparser = parser.add_subparsers()
show = subparser.add_parser("show", help="Show xprt switches")
show.add_argument("switch", metavar="SWITCH", nargs='?',
help="Name of a specific switch to show")
show.set_defaults(func=XprtSwitch.show)
set = subparser.add_parser("set", help="Change an xprt switch property")
set.add_argument("switch", metavar="SWITCH", nargs=1,
help="Name of a specific xprt switch to modify")
subparser = set.add_subparsers()
dstaddr = subparser.add_parser("dstaddr", help="Change an xprt switch's dstaddr")
dstaddr.add_argument("newaddr", metavar="NEWADDR", nargs=1,
help="The new address for the xprt switch")
dstaddr.set_defaults(func=XprtSwitch.set_property, property="dstaddr")
def get_by_name(name):
xprt_switches = sunrpc / "xprt-switches"
if name:
return [ XprtSwitch(xprt_switches / name) ]
return [ XprtSwitch(f) for f in sorted(xprt_switches.iterdir()) ]
def show(args):
for switch in XprtSwitch.get_by_name(args.switch):
print(switch)
def set_property(args):
for switch in XprtSwitch.get_by_name(args.switch[0]):
resolved = socket.gethostbyname(args.newaddr[0])
for xprt in switch.xprts:
xprt.set_dstaddr(resolved)
print(switch)
class RpcClient:
def __init__(self, path):
self.path = path
self.name = path.stem
self.switch = XprtSwitch(path / os.readlink(path / "switch"), sep=",")
def __lt__(self, rhs):
return self.name < rhs.name
def __str__(self):
return f"{self.name}: {self.switch}"
def add_command(subparser):
parser = subparser.add_parser("client", help="Commands for rpc clients")
parser.set_defaults(func=RpcClient.show, client=None)
subparser = parser.add_subparsers()
show = subparser.add_parser("show", help="Show rpc clients")
show.add_argument("client", metavar="CLIENT", nargs='?',
help="Name of a specific rpc client to show")
parser.set_defaults(func=RpcClient.show)
def get_by_name(name):
rpc_clients = sunrpc / "rpc-clients"
if name:
return [ RpcClient(rpc_clients / name) ]
return [ RpcClient(f) for f in sorted(rpc_clients.iterdir()) ]
def show(args):
for client in RpcClient.get_by_name(args.client):
print(client)
parser = argparse.ArgumentParser()
def show_small_help(args):
parser.print_usage()
print("sunrpc dir:", sunrpc)
parser.set_defaults(func=show_small_help)
subparser = parser.add_subparsers(title="commands")
RpcClient.add_command(subparser)
XprtSwitch.add_command(subparser)
Xprt.add_command(subparser)
args = parser.parse_args()
try:
args.func(args)
except Exception as e:
print(str(e))
sys.exit(1)