Differential D10335 Diff 66435 contrib/lib9p/pytest/p9conn.py

Changeset View

Standalone View

contrib/lib9p/pytest/p9conn.py

This file was added.

				#! /usr/bin/env python

				"""
				handle plan9 server <-> client connections

				(We can act as either server or client.)

				This code needs some doctests or other unit tests...
				"""

				import collections
				import errno
				import logging
				import math
				import os
				import socket
				import stat
				import struct
				import sys
				import threading
				import time

				import lerrno
				import numalloc
				import p9err
				import pfod
				import protocol

				# Timespec based timestamps, if present, have
				# both seconds and nanoseconds.
				Timespec = collections.namedtuple('Timespec', 'sec nsec')

				# File attributes from Tgetattr, or given to Tsetattr.
				# (move to protocol.py?) We use pfod here instead of
				# namedtuple so that we can create instances with all-None
				# fields easily.
				Fileattrs = pfod.pfod('Fileattrs',
				'ino mode uid gid nlink rdev size blksize blocks '
				'atime mtime ctime btime gen data_version')

				qt2n = protocol.qid_type2name

				STD_P9_PORT=564

				class P9Error(Exception):
				pass

				class RemoteError(P9Error):
				"""
				Used when the remote returns an error. We track the client
				(connection instance), the operation being attempted, the
				message, and an error number and type. The message may be
				from the Rerror reply, or from converting the errno in a dot-L
				or dot-u Rerror reply. The error number may be None if the
				type is 'Rerror' rather than 'Rlerror'. The message may be
				None or empty string if a non-None errno supplies the error
				instead.
				"""
				def __init__(self, client, op, msg, etype, errno):
				self.client = str(client)
				self.op = op
				self.msg = msg
				self.etype = etype # 'Rerror' or 'Rlerror'
				self.errno = errno # may be None
				self.message = self._get_message()
				super(RemoteError, self).__init__(self, self.message)

				def __repr__(self):
				return ('{0!r}({1}, {2}, {3}, {4}, '
				'{5})'.format(self.__class__.__name__, self.client, self.op,
				self.msg, self.errno, self.etype))
				def __str__(self):
				prefix = '{0}: {1}: '.format(self.client, self.op)
				if self.errno: # check for "is not None", or just non-false-y?
				name = {'Rerror': '.u', 'Rlerror': 'Linux'}[self.etype]
				middle = '[{0} error {1}] '.format(name, self.errno)
				else:
				middle = ''
				return '{0}{1}{2}'.format(prefix, middle, self.message)

				def is_ENOTSUP(self):
				if self.etype == 'Rlerror':
				return self.errno == lerrno.EOPNOTSUPP
				return self.errno == errno.EOPNOTSUPP

				def _get_message(self):
				"get message based on self.msg or self.errno"
				if self.errno is not None:
				return {
				'Rlerror': p9err.dotl_strerror,
				'Rerror' : p9err.dotu_strerror,
				}[self.etype](self.errno)
				return self.msg

				class LocalError(P9Error):
				pass

				class TEError(LocalError):
				pass

				class P9SockIO(object):
				"""
				Common base for server and client, handle send and
				receive to communications channel. Note that this
				need not set up the channel initially, only the logger.
				The channel is typically connected later. However, you
				can provide one initially.
				"""
				def __init__(self, logger, name=None, server=None, port=STD_P9_PORT):
				self.logger = logger
				self.channel = None
				self.name = name
				self.maxio = None
				self.size_coder = struct.Struct('<I')
				if server is not None:
				self.connect(server, port)
				self.max_payload = 2**32 - self.size_coder.size

				def __str__(self):
				if self.name:
				return self.name
				return repr(self)

				def get_recommended_maxio(self):
				"suggest a max I/O size, for when self.maxio is 0 / unset"
				return 16 * 4096

				def min_maxio(self):
				"return a minimum size below which we refuse to work"
				return self.size_coder.size + 100

				def connect(self, server, port=STD_P9_PORT):
				"""
				Connect to given server name / IP address.

				If self.name was none, sets self.name to ip:port on success.
				"""
				if self.is_connected():
				raise LocalError('already connected')
				sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
				sock.connect((server, port))
				if self.name is None:
				if port == STD_P9_PORT:
				name = server
				else:
				name = '{0}:{1}'.format(server, port)
				else:
				name = None
				self.declare_connected(sock, name, None)

				def is_connected(self):
				"predicate: are we connected?"
				return self.channel != None

				def declare_connected(self, chan, name, maxio):
				"""
				Now available for normal protocol (size-prefixed) I/O.

				Replaces chan and name and adjusts maxio, if those
				parameters are not None.
				"""
				if maxio:
				minio = self.min_maxio()
				if maxio < minio:
				raise LocalError('maxio={0} < minimum {1}'.format(maxio, minio))
				if chan is not None:
				self.channel = chan
				if name is not None:
				self.name = name
				if maxio is not None:
				self.maxio = maxio
				self.max_payload = maxio - self.size_coder.size

				def reduce_maxio(self, maxio):
				"Reduce maximum I/O size per other-side request"
				minio = self.min_maxio()
				if maxio < minio:
				raise LocalError('new maxio={0} < minimum {1}'.format(maxio, minio))
				if maxio > self.maxio:
				raise LocalError('new maxio={0} > current {1}'.format(maxio,
				self.maxio))
				self.maxio = maxio
				self.max_payload = maxio - self.size_coder.size

				def declare_disconnected(self):
				"Declare comm channel dead (note: leaves self.name set!)"
				self.channel = None
				self.maxio = None

				def shutwrite(self):
				"Do a SHUT_WR on the outbound channel - can't send more"
				chan = self.channel
				# we're racing other threads here
				try:
				chan.shutdown(socket.SHUT_WR)
				except (OSError, AttributeError):
				pass

				def shutdown(self):
				"Shut down comm channel"
				if self.channel:
				try:
				self.channel.shutdown(socket.SHUT_RDWR)
				except socket.error:
				pass
				self.channel.close()
				self.declare_disconnected()

				def read(self):
				"""
				Try to read a complete packet.

				Returns '' for EOF, as read() usually does.

				If we can't even get the size, this still returns ''.
				If we get a sensible size but are missing some data,
				we can return a short packet. Since we know if we did
				this, we also return a boolean: True means "really got a
				complete packet."

				Note that '' EOF always returns False: EOF is never a
				complete packet.
				"""
				if self.channel is None:
				return b'', False
				size_field = self.xread(self.size_coder.size)
				if len(size_field) < self.size_coder.size:
				if len(size_field) == 0:
				self.logger.log(logging.INFO, '%s: normal EOF', self)
				else:
				self.logger.log(logging.ERROR,
				'%s: EOF while reading size (got %d bytes)',
				self, len(size_field))
				# should we raise an error here?
				return b'', False

				size = self.size_coder.unpack(size_field)[0] - self.size_coder.size
				if size <= 0 or size > self.max_payload:
				self.logger.log(logging.ERROR,
				'%s: incoming size %d is insane '
				'(max payload is %d)',
				self, size, self.max_payload)
				# indicate EOF - should we raise an error instead, here?
				return b'', False
				data = self.xread(size)
				return data, len(data) == size

				def xread(self, nbytes):
				"""
				Read nbytes bytes, looping if necessary. Return '' for
				EOF; may return a short count if we get some data, then
				EOF.
				"""
				assert nbytes > 0
				# Try to get everything at once (should usually succeed).
				# Return immediately for EOF or got-all-data.
				data = self.channel.recv(nbytes)
				if data == b'' or len(data) == nbytes:
				return data

				# Gather data fragments into an array, then join it all at
				# the end.
				count = len(data)
				data = [data]
				while count < nbytes:
				more = self.channel.recv(nbytes - count)
				if more == b'':
				break
				count += len(more)
				data.append(more)
				return b''.join(data)

				def write(self, data):
				"""
				Write all the data, in the usual encoding. Note that
				the length of the data, including the length of the length
				itself, is already encoded in the first 4 bytes of the
				data.

				Raises IOError if we can't write everything.

				Raises LocalError if len(data) exceeds max_payload.
				"""
				size = len(data)
				assert size >= 4
				if size > self.max_payload:
				raise LocalError('data length {0} exceeds '
				'maximum {1}'.format(size, self.max_payload))
				self.channel.sendall(data)

				def _pathcat(prefix, suffix):
				"""
				Concatenate paths we are using on the server side. This is
				basically just prefix + / + suffix, with two complications:

				It's possible we don't have a prefix path, in which case
				we want the suffix without a leading slash.

				It's possible that the prefix is just b'/', in which case we
				want prefix + suffix.
				"""
				if prefix:
				if prefix == b'/': # or prefix.endswith(b'/')?
				return prefix + suffix
				return prefix + b'/' + suffix
				return suffix

				class P9Client(P9SockIO):
				"""
				Act as client.

				We need the a logger (see logging), a timeout, and a protocol
				version to request. By default, we will downgrade to a lower
				version if asked.

				If server and port are supplied, they are remembered and become
				the default for .connect() (which is still deferred).

				Note that we keep a table of fid-to-path in self.live_fids,
				but at any time (except while holding the lock) a fid can
				be deleted entirely, and the table entry may just be True
				if we have no path name. In general, we update the name
				when we can.
				"""
				def __init__(self, logger, timeout, version, may_downgrade=True,
				server=None, port=None):
				super(P9Client, self).__init__(logger)
				self.timeout = timeout
				self.iproto = protocol.p9_version(version)
				self.may_downgrade = may_downgrade
				self.tagalloc = numalloc.NumAlloc(0, 65534)
				self.tagstate = {}
				# The next bit is slighlty dirty: perhaps we should just
				# allocate NOFID out of the 2**32-1 range, so as to avoid
				# "knowing" that it's 2**32-1.
				self.fidalloc = numalloc.NumAlloc(0, protocol.td.NOFID - 1)
				self.live_fids = {}
				self.rootfid = None
				self.rootqid = None
				self.rthread = None
				self.lock = threading.Lock()
				self.new_replies = threading.Condition(self.lock)
				self._monkeywrench = {}
				self._server = server
				self._port = port
				self._unsup = {}

				def get_monkey(self, what):
				"check for a monkey-wrench"
				with self.lock:
				wrench = self._monkeywrench.get(what)
				if wrench is None:
				return None
				if isinstance(wrench, list):
				# repeats wrench[0] times, or forever if that's 0
				ret = wrench[1]
				if wrench[0] > 0:
				wrench[0] -= 1
				if wrench[0] == 0:
				del self._monkeywrench[what]
				else:
				ret = wrench
				del self._monkeywrench[what]
				return ret

				def set_monkey(self, what, how, repeat=None):
				"""
				Set a monkey-wrench. If repeat is not None it is the number of
				times the wrench is applied (0 means forever, or until you call
				set again with how=None). What is what to monkey-wrench, which
				depends on the op. How is generally a replacement value.
				"""
				if how is None:
				with self.lock:
				try:
				del self._monkeywrench[what]
				except KeyError:
				pass
				return
				if repeat is not None:
				how = [repeat, how]
				with self.lock:
				self._monkeywrench[what] = how

				def get_tag(self, for_Tversion=False):
				"get next available tag ID"
				with self.lock:
				if for_Tversion:
				tag = 65535
				else:
				tag = self.tagalloc.alloc()
				if tag is None:
				raise LocalError('all tags in use')
				self.tagstate[tag] = True # ie, in use, still waiting
				return tag

				def set_tag(self, tag, reply):
				"set the reply info for the given tag"
				assert tag >= 0 and tag < 65536
				with self.lock:
				# check whether we're still waiting for the tag
				state = self.tagstate.get(tag)
				if state is True:
				self.tagstate[tag] = reply # i.e., here's the answer
				self.new_replies.notify_all()
				return
				# state must be one of these...
				if state is False:
				# We gave up on this tag. Reply came anyway.
				self.logger.log(logging.INFO,
				'%s: got tag %d = %r after timing out on it',
				self, tag, reply)
				self.retire_tag_locked(tag)
				return
				if state is None:
				# We got a tag back from the server that was not
				# outstanding!
				self.logger.log(logging.WARNING,
				'%s: got tag %d = %r when tag %d not in use!',
				self, tag, reply, tag)
				return
				# We got a second reply before handling the first reply!
				self.logger.log(logging.WARNING,
				'%s: got tag %d = %r when tag %d = %r!',
				self, tag, reply, tag, state)
				return

				def retire_tag(self, tag):
				"retire the given tag - only used by the thread that handled the result"
				if tag == 65535:
				return
				assert tag >= 0 and tag < 65535
				with self.lock:
				self.retire_tag_locked(tag)

				def retire_tag_locked(self, tag):
				"retire the given tag while holding self.lock"
				# must check "in tagstate" because we can race
				# with retire_all_tags.
				if tag in self.tagstate:
				del self.tagstate[tag]
				self.tagalloc.free(tag)

				def retire_all_tags(self):
				"retire all tags, after connection drop"
				with self.lock:
				# release all tags in any state (waiting, answered, timedout)
				self.tagalloc.free_multi(self.tagstate.keys())
				self.tagstate = {}
				self.new_replies.notify_all()

				def alloc_fid(self):
				"allocate new fid"
				with self.lock:
				fid = self.fidalloc.alloc()
				self.live_fids[fid] = True
				return fid

				def getpath(self, fid):
				"get path from fid, or return None if no path known, or not valid"
				with self.lock:
				path = self.live_fids.get(fid)
				if path is True:
				path = None
				return path

				def getpathX(self, fid):
				"""
				Much like getpath, but return <fid N, unknown path> if necessary.
				If we do have a path, return its repr().
				"""
				path = self.getpath(fid)
				if path is None:
				return '<fid {0}, unknown path>'.format(fid)
				return repr(path)

				def setpath(self, fid, path):
				"associate fid with new path (possibly from another fid)"
				with self.lock:
				if isinstance(path, int):
				path = self.live_fids.get(path)
				# path might now be None (not a live fid after all), or
				# True (we have no path name), or potentially even the
				# empty string (invalid for our purposes). Treat all of
				# those as True, meaning "no known path".
				if not path:
				path = True
				if self.live_fids.get(fid):
				# Existing fid maps to either True or its old path.
				# Set the new path (which may be just a placeholder).
				self.live_fids[fid] = path

				def did_rename(self, fid, ncomp, newdir=None):
				"""
				Announce that we renamed using a fid - we'll try to update
				other fids based on this (we can't really do it perfectly).

				NOTE: caller must provide a final-component.
				The caller can supply the new path (and should
				do so if the rename is not based on the retained path
				for the supplied fid, i.e., for rename ops where fid
				can move across directories). The rules:

				- If newdir is None (default), we use stored path.
				- Otherwise, newdir provides the best approximation
				we have to the path that needs ncomp appended.

				(This is based on the fact that renames happen via Twstat
				or Trename, or Trenameat, which change just one tail component,
				but the path names vary.)
				"""
				if ncomp is None:
				return
				opath = self.getpath(fid)
				if newdir is None:
				if opath is None:
				return
				ocomps = opath.split(b'/')
				ncomps = ocomps[0:-1]
				else:
				ocomps = None # well, none yet anyway
				ncomps = newdir.split(b'/')
				ncomps.append(ncomp)
				if opath is None or opath[0] != '/':
				# We don't have enough information to fix anything else.
				# Just store the new path and return. We have at least
				# a partial path now, which is no worse than before.
				npath = b'/'.join(ncomps)
				with self.lock:
				if fid in self.live_fids:
				self.live_fids[fid] = npath
				return
				if ocomps is None:
				ocomps = opath.split(b'/')
				olen = len(ocomps)
				ofinal = ocomps[olen - 1]
				# Old paths is full path. Find any other fids that start
				# with some or all the components in ocomps. Note that if
				# we renamed /one/two/three to /four/five this winds up
				# renaming files /one/a to /four/a, /one/two/b to /four/five/b,
				# and so on.
				with self.lock:
				for fid2, path2 in self.live_fids.iteritems():
				# Skip fids without byte-string paths
				if not isinstance(path2, bytes):
				continue
				# Before splitting (which is a bit expensive), try
				# a straightforward prefix match. This might give
				# some false hits, e.g., prefix /one/two/threepenny
				# starts with /one/two/three, but it quickly eliminates
				# /raz/baz/mataz and the like.
				if not path2.startswith(opath):
				continue
				# Split up the path, and use that to make sure that
				# the final component is a full match.
				parts2 = path2.split(b'/')
				if parts2[olen - 1] != ofinal:
				continue
				# OK, path2 starts with the old (renamed) sequence.
				# Replace the old components with the new ones.
				# This updates the renamed fid when we come across
				# it! It also handles a change in the number of
				# components, thanks to Python's slice assignment.
				parts2[0:olen] = ncomps
				self.live_fids[fid2] = b'/'.join(parts2)

				def retire_fid(self, fid):
				"retire one fid"
				with self.lock:
				self.fidalloc.free(fid)
				del self.live_fids[fid]

				def retire_all_fids(self):
				"return live fids to pool"
				# this is useful for debugging fid leaks:
				#for fid in self.live_fids:
				# print 'retiring', fid, self.getpathX(fid)
				with self.lock:
				self.fidalloc.free_multi(self.live_fids.keys())
				self.live_fids = {}

				def read_responses(self):
				"Read responses. This gets spun off as a thread."
				while self.is_connected():
				pkt, is_full = super(P9Client, self).read()
				if pkt == b'':
				self.shutwrite()
				self.retire_all_tags()
				return
				if not is_full:
				self.logger.log(logging.WARNING, '%s: got short packet', self)
				try:
				# We have one special case: if we're not yet connected
				# with a version, we must unpack as if it's a plain
				# 9P2000 response.
				if self.have_version:
				resp = self.proto.unpack(pkt)
				else:
				resp = protocol.plain.unpack(pkt)
				except protocol.SequenceError as err:
				self.logger.log(logging.ERROR, '%s: bad response: %s',
				self, err)
				try:
				resp = self.proto.unpack(pkt, noerror=True)
				except protocol.SequenceError:
				header = self.proto.unpack_header(pkt, noerror=True)
				self.logger.log(logging.ERROR,
				'%s: (not even raw-decodable)', self)
				self.logger.log(logging.ERROR,
				'%s: header decode produced %r',
				self, header)
				else:
				self.logger.log(logging.ERROR,
				'%s: raw decode produced %r',
				self, resp)
				# after this kind of problem, probably need to
				# shut down, but let's leave that out for a bit
				else:
				# NB: all protocol responses have a "tag",
				# so resp['tag'] always exists.
				self.logger.log(logging.DEBUG, "read_resp: tag %d resp %r", resp.tag, resp)
				self.set_tag(resp.tag, resp)

				def wait_for(self, tag):
				"""
				Wait for a response to the given tag. Return the response,
				releasing the tag. If self.timeout is not None, wait at most
				that long (and release the tag even if there's no reply), else
				wait forever.

				If this returns None, either the tag was bad initially, or
				a timeout occurred, or the connection got shut down.
				"""
				self.logger.log(logging.DEBUG, "wait_for: tag %d", tag)
				if self.timeout is None:
				deadline = None
				else:
				deadline = time.time() + self.timeout
				with self.lock:
				while True:
				# tagstate is True (waiting) or False (timedout) or
				# a valid response, or None if we've reset the tag
				# states (retire_all_tags, after connection drop).
				resp = self.tagstate.get(tag, None)
				if resp is None:
				# out of sync, exit loop
				break
				if resp is True:
				# still waiting for a response - wait some more
				self.new_replies.wait(self.timeout)
				if deadline and time.time() > deadline:
				# Halt the waiting, but go around once more.
				# Note we may have killed the tag by now though.
				if tag in self.tagstate:
				self.tagstate[tag] = False
				continue
				# resp is either False (timeout) or a reply.
				# If resp is False, change it to None; the tag
				# is now dead until we get a reply (then we
				# just toss the reply).
				# Otherwise, we're done with the tag: free it.
				# In either case, stop now.
				if resp is False:
				resp = None
				else:
				self.tagalloc.free(tag)
				del self.tagstate[tag]
				break
				return resp

				def badresp(self, req, resp):
				"""
				Complain that a response was not something expected.
				"""
				if resp is None:
				self.shutdown()
				raise TEError('{0}: {1}: timeout or EOF'.format(self, req))
				if isinstance(resp, protocol.rrd.Rlerror):
				raise RemoteError(self, req, None, 'Rlerror', resp.ecode)
				if isinstance(resp, protocol.rrd.Rerror):
				if resp.errnum is None:
				raise RemoteError(self, req, resp.errstr, 'Rerror', None)
				raise RemoteError(self, req, None, 'Rerror', resp.errnum)
				raise LocalError('{0}: {1} got response {2!r}'.format(self, req, resp))

				def supports(self, req_code):
				"""
				Test self.proto.support(req_code) unless we've recorded that
				while the protocol supports it, the client does not.
				"""
				return req_code not in self._unsup and self.proto.supports(req_code)

				def supports_all(self, *req_codes):
				"basically just all(supports(...))"
				return all(self.supports(code) for code in req_codes)

				def unsupported(self, req_code):
				"""
				Record an ENOTSUP (RemoteError was ENOTSUP) for a request.
				Must be called from the op, this does not happen automatically.
				(It's just an optimization.)
				"""
				self._unsup[req_code] = True

				def connect(self, server=None, port=None):
				"""
				Connect to given server/port pair.

				The server and port are remembered. If given as None,
				the last remembered values are used. The initial
				remembered values are from the creation of this client
				instance.

				New values are only remembered here on a successful
				connect, however.
				"""
				if server is None:
				server = self._server
				if server is None:
				raise LocalError('connect: no server specified and no default')
				if port is None:
				port = self._port
				if port is None:
				port = STD_P9_PORT
				self.name = None # wipe out previous name, if any
				super(P9Client, self).connect(server, port)
				maxio = self.get_recommended_maxio()
				self.declare_connected(None, None, maxio)
				self.proto = self.iproto # revert to initial protocol
				self.have_version = False
				self.rthread = threading.Thread(target=self.read_responses)
				self.rthread.start()
				tag = self.get_tag(for_Tversion=True)
				req = protocol.rrd.Tversion(tag=tag, msize=maxio,
				version=self.get_monkey('version'))
				super(P9Client, self).write(self.proto.pack_from(req))
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rversion):
				self.shutdown()
				if isinstance(resp, protocol.rrd.Rerror):
				version = req.version or self.proto.get_version()
				# for python3, we need to convert version to string
				if not isinstance(version, str):
				version = version.decode('utf-8', 'surrogateescape')
				raise RemoteError(self, 'version ' + version,
				resp.errstr, 'Rerror', None)
				self.badresp('version', resp)
				their_maxio = resp.msize
				try:
				self.reduce_maxio(their_maxio)
				except LocalError as err:
				raise LocalError('{0}: sent maxio={1}, they tried {2}: '
				'{3}'.format(self, maxio, their_maxio,
				err.args[0]))
				if resp.version != self.proto.get_version():
				if not self.may_downgrade:
				self.shutdown()
				raise LocalError('{0}: they only support '
				'version {1!r}'.format(self, resp.version))
				# raises LocalError if the version is bad
				# (should we wrap it with a connect-to-{0} msg?)
				self.proto = self.proto.downgrade_to(resp.version)
				self._server = server
				self._port = port
				self.have_version = True

				def attach(self, afid, uname, aname, n_uname):
				"""
				Attach.

				Currently we don't know how to do authentication,
				but we'll pass any provided afid through.
				"""
				if afid is None:
				afid = protocol.td.NOFID
				if uname is None:
				uname = ''
				if aname is None:
				aname = ''
				if n_uname is None:
				n_uname = protocol.td.NONUNAME
				tag = self.get_tag()
				fid = self.alloc_fid()
				pkt = self.proto.Tattach(tag=tag, fid=fid, afid=afid,
				uname=uname, aname=aname,
				n_uname=n_uname)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rattach):
				self.retire_fid(fid)
				self.badresp('attach', resp)
				# probably should check resp.qid
				self.rootfid = fid
				self.rootqid = resp.qid
				self.setpath(fid, b'/')

				def shutdown(self):
				"disconnect from server"
				if self.rootfid is not None:
				self.clunk(self.rootfid, ignore_error=True)
				self.retire_all_tags()
				self.retire_all_fids()
				self.rootfid = None
				self.rootqid = None
				super(P9Client, self).shutdown()
				if self.rthread:
				self.rthread.join()
				self.rthread = None

				def dupfid(self, fid):
				"""
				Copy existing fid to a new fid.
				"""
				tag = self.get_tag()
				newfid = self.alloc_fid()
				pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid, nwname=0,
				wname=[])
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rwalk):
				self.retire_fid(newfid)
				self.badresp('walk {0}'.format(self.getpathX(fid)), resp)
				# Copy path too
				self.setpath(newfid, fid)
				return newfid

				def lookup(self, fid, components):
				"""
				Do Twalk. Caller must provide a starting fid, which should
				be rootfid to look up from '/' - we do not do / vs . here.
				Caller must also provide a component-ized path (on purpose,
				so that caller can provide invalid components like '' or '/').
				The components must be byte-strings as well, for the same
				reason.

				We do allocate the new fid ourselves here, though.

				There's no logic here to split up long walks (yet?).
				"""
				# these are too easy to screw up, so check
				if self.rootfid is None:
				raise LocalError('{0}: not attached'.format(self))
				if (isinstance(components, (str, bytes) or
				not all(isinstance(i, bytes) for i in components))):
				raise LocalError('{0}: lookup: invalid '
				'components {1!r}'.format(self, components))
				tag = self.get_tag()
				newfid = self.alloc_fid()
				startpath = self.getpath(fid)
				pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid,
				nwname=len(components), wname=components)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rwalk):
				self.retire_fid(newfid)
				self.badresp('walk {0} in '
				'{1}'.format(components, self.getpathX(fid)),
				resp)
				# Just because we got Rwalk does not mean we got ALL the
				# way down the path. Raise OSError(ENOENT) if we're short.
				if resp.nwqid > len(components):
				# ??? this should be impossible. Local error? Remote error?
				# OS Error?
				self.clunk(newfid, ignore_error=True)
				raise LocalError('{0}: walk {1} in {2} returned {3} '
				'items'.format(self, components,
				self.getpathX(fid), resp.nwqid))
				if resp.nwqid < len(components):
				self.clunk(newfid, ignore_error=True)
				# Looking up a/b/c and got just a/b, c is what's missing.
				# Looking up a/b/c and got just a, b is what's missing.
				missing = components[resp.nwqid]
				within = _pathcat(startpath, b'/'.join(components[:resp.nwqid]))
				raise OSError(errno.ENOENT,
				'{0}: {1} in {2}'.format(os.strerror(errno.ENOENT),
				missing, within))
				self.setpath(newfid, _pathcat(startpath, b'/'.join(components)))
				return newfid, resp.wqid

				def lookup_last(self, fid, components):
				"""
				Like lookup, but return only the last component's qid.
				As a special case, if components is an empty list, we
				handle that.
				"""
				rfid, wqid = self.lookup(fid, components)
				if len(wqid):
				return rfid, wqid[-1]
				if fid == self.rootfid: # usually true, if we get here at all
				return rfid, self.rootqid
				tag = self.get_tag()
				pkt = self.proto.Tstat(tag=tag, fid=rfid)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rstat):
				self.badresp('stat {0}'.format(self.getpathX(fid)), resp)
				statval = self.proto.unpack_wirestat(resp.data)
				return rfid, statval.qid

				def clunk(self, fid, ignore_error=False):
				"issue clunk(fid)"
				tag = self.get_tag()
				pkt = self.proto.Tclunk(tag=tag, fid=fid)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rclunk):
				if ignore_error:
				return
				self.badresp('clunk {0}'.format(self.getpathX(fid)), resp)
				self.retire_fid(fid)

				def remove(self, fid, ignore_error=False):
				"issue remove (old style), which also clunks fid"
				tag = self.get_tag()
				pkt = self.proto.Tremove(tag=tag, fid=fid)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rremove):
				if ignore_error:
				# remove failed: still need to clunk the fid
				self.clunk(fid, True)
				return
				self.badresp('remove {0}'.format(self.getpathX(fid)), resp)
				self.retire_fid(fid)

				def create(self, fid, name, perm, mode, filetype=None, extension=b''):
				"""
				Issue create op (note that this may be mkdir, symlink, etc).
				fid is the directory in which the create happens, and for
				regular files, it becomes, on success, a fid referring to
				the now-open file. perm is, e.g., 0644, 0755, etc.,
				optionally with additional high bits. mode is a mode
				byte (e.g., protocol.td.ORDWR, or OWRONLY\|OTRUNC, etc.).

				As a service to callers, we take two optional arguments
				specifying the file type ('dir', 'symlink', 'device',
				'fifo', or 'socket') and additional info if needed.
				The additional info for a symlink is the target of the
				link (a byte string), and the additional info for a device
				is a byte string with "b <major> <minor>" or "c <major> <minor>".

				Otherwise, callers can leave filetype=None and encode the bits
				into the mode (caller must still provide extension if needed).

				We do NOT check whether the extension matches extra DM bits,
				or that there's only one DM bit set, or whatever, since this
				is a testing setup.
				"""
				tag = self.get_tag()
				if filetype is not None:
				perm \|= {
				'dir': protocol.td.DMDIR,
				'symlink': protocol.td.DMSYMLINK,
				'device': protocol.td.DMDEVICE,
				'fifo': protocol.td.DMNAMEDPIPE,
				'socket': protocol.td.DMSOCKET,
				}[filetype]
				pkt = self.proto.Tcreate(tag=tag, fid=fid, name=name,
				perm=perm, mode=mode, extension=extension)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rcreate):
				self.badresp('create {0} in {1}'.format(name, self.getpathX(fid)),
				resp)
				if resp.qid.type == protocol.td.QTFILE:
				# Creating a regular file opens the file,
				# thus changing the fid's path.
				self.setpath(fid, _pathcat(self.getpath(fid), name))
				return resp.qid, resp.iounit

				def open(self, fid, mode):
				"use Topen to open file or directory fid (mode is 1 byte)"
				tag = self.get_tag()
				pkt = self.proto.Topen(tag=tag, fid=fid, mode=mode)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Ropen):
				self.badresp('open {0}'.format(self.getpathX(fid)), resp)
				return resp.qid, resp.iounit

				def lopen(self, fid, flags):
				"use Tlopen to open file or directory fid (flags from L_O_*)"
				tag = self.get_tag()
				pkt = self.proto.Tlopen(tag=tag, fid=fid, flags=flags)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rlopen):
				self.badresp('lopen {0}'.format(self.getpathX(fid)), resp)
				return resp.qid, resp.iounit

				def read(self, fid, offset, count):
				"read (up to) count bytes from offset, given open fid"
				tag = self.get_tag()
				pkt = self.proto.Tread(tag=tag, fid=fid, offset=offset, count=count)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rread):
				self.badresp('read {0} bytes at offset {1} in '
				'{2}'.format(count, offset, self.getpathX(fid)),
				resp)
				return resp.data

				def write(self, fid, offset, data):
				"write (up to) count bytes to offset, given open fid"
				tag = self.get_tag()
				pkt = self.proto.Twrite(tag=tag, fid=fid, offset=offset,
				count=len(data), data=data)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rwrite):
				self.badresp('write {0} bytes at offset {1} in '
				'{2}'.format(len(data), offset, self.getpathX(fid)),
				resp)
				return resp.count

				# Caller may
				# - pass an actual stat object, or
				# - pass in all the individual to-set items by keyword, or
				# - mix and match a bit: get an existing stat, then use
				# keywords to override fields.
				# We convert "None"s to the internal "do not change" values,
				# and for diagnostic purposes, can turn "do not change" back
				# to None at the end, too.
				def wstat(self, fid, statobj=None, **kwargs):
				if statobj is None:
				statobj = protocol.td.stat()
				else:
				statobj = statobj._copy()
				# Fields in stat that you can't send as a wstat: the
				# type and qid are informative. Similarly, the
				# 'extension' is an input when creating a file but
				# read-only when stat-ing.
				#
				# It's not clear what it means to set dev, but we'll leave
				# it in as an optional parameter here. fs/backend.c just
				# errors out on an attempt to change it.
				if self.proto == protocol.plain:
				forbid = ('type', 'qid', 'extension',
				'n_uid', 'n_gid', 'n_muid')
				else:
				forbid = ('type', 'qid', 'extension')
				nochange = {
				'type': 0,
				'qid': protocol.td.qid(0, 0, 0),
				'dev': 2**32 - 1,
				'mode': 2**32 - 1,
				'atime': 2**32 - 1,
				'mtime': 2**32 - 1,
				'length': 2**64 - 1,
				'name': b'',
				'uid': b'',
				'gid': b'',
				'muid': b'',
				'extension': b'',
				'n_uid': 2**32 - 1,
				'n_gid': 2**32 - 1,
				'n_muid': 2**32 - 1,
				}
				for field in statobj._fields:
				if field in kwargs:
				if field in forbid:
				raise ValueError('cannot wstat a stat.{0}'.format(field))
				statobj[field] = kwargs.pop(field)
				else:
				if field in forbid or statobj[field] is None:
				statobj[field] = nochange[field]
				if kwargs:
				raise TypeError('wstat() got an unexpected keyword argument '
				'{0!r}'.format(kwargs.popitem()))

				data = self.proto.pack_wirestat(statobj)
				tag = self.get_tag()
				pkt = self.proto.Twstat(tag=tag, fid=fid, data=data)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rwstat):
				# For error viewing, switch all the do-not-change
				# and can't-change fields to None.
				statobj.qid = None
				for field in statobj._fields:
				if field in forbid:
				statobj[field] = None
				elif field in nochange and statobj[field] == nochange[field]:
				statobj[field] = None
				self.badresp('wstat {0}={1}'.format(self.getpathX(fid), statobj),
				resp)
				# wstat worked - change path names if needed
				if statobj.name != b'':
				self.did_rename(fid, statobj.name)

				def readdir(self, fid, offset, count):
				"read (up to) count bytes of dir data from offset, given open fid"
				tag = self.get_tag()
				pkt = self.proto.Treaddir(tag=tag, fid=fid, offset=offset, count=count)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rreaddir):
				self.badresp('readdir {0} bytes at offset {1} in '
				'{2}'.format(count, offset, self.getpathX(fid)),
				resp)
				return resp.data

				def rename(self, fid, dfid, name):
				"invoke Trename: rename file <fid> to <dfid>/name"
				tag = self.get_tag()
				pkt = self.proto.Trename(tag=tag, fid=fid, dfid=dfid, name=name)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rrename):
				self.badresp('rename {0} to {2} in '
				'{1}'.format(self.getpathX(fid),
				self.getpathX(dfid), name),
				resp)
				self.did_rename(fid, name, self.getpath(dfid))

				def renameat(self, olddirfid, oldname, newdirfid, newname):
				"invoke Trenameat: rename <olddirfid>/oldname to <newdirfid>/newname"
				tag = self.get_tag()
				pkt = self.proto.Trenameat(tag=tag,
				olddirfid=olddirfid, oldname=oldname,
				newdirfid=newdirfid, newname=newname)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rrenameat):
				self.badresp('rename {1} in {0} to {3} in '
				'{2}'.format(oldname, self.getpathX(olddirfid),
				newname, self.getpathX(newdirdfid)),
				resp)
				# There's no renamed fid, just a renamed file! So no
				# call to self.did_rename().

				def unlinkat(self, dirfd, name, flags):
				"invoke Tunlinkat - flags should be 0 or protocol.td.AT_REMOVEDIR"
				tag = self.get_tag()
				pkt = self.proto.Tunlinkat(tag=tag, dirfd=dirfd,
				name=name, flags=flags)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Runlinkat):
				self.badresp('unlinkat {0} in '
				'{1}'.format(name, self.getpathX(dirfd)), resp)

				def decode_stat_objects(self, bstring, noerror=False):
				"""
				Read on a directory returns an array of stat objects.
				Note that for .u these encode extra data.

				It's possible for this to produce a SequenceError, if
				the data are incorrect, unless you pass noerror=True.
				"""
				objlist = []
				offset = 0
				while offset < len(bstring):
				obj, offset = self.proto.unpack_wirestat(bstring, offset, noerror)
				objlist.append(obj)
				return objlist

				def decode_readdir_dirents(self, bstring, noerror=False):
				"""
				Readdir on a directory returns an array of dirent objects.

				It's possible for this to produce a SequenceError, if
				the data are incorrect, unless you pass noerror=True.
				"""
				objlist = []
				offset = 0
				while offset < len(bstring):
				obj, offset = self.proto.unpack_dirent(bstring, offset, noerror)
				objlist.append(obj)
				return objlist

				def lcreate(self, fid, name, lflags, mode, gid):
				"issue lcreate (.L)"
				tag = self.get_tag()
				pkt = self.proto.Tlcreate(tag=tag, fid=fid, name=name,
				flags=lflags, mode=mode, gid=gid)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rlcreate):
				self.badresp('create {0} in '
				'{1}'.format(name, self.getpathX(fid)), resp)
				# Creating a file opens the file,
				# thus changing the fid's path.
				self.setpath(fid, _pathcat(self.getpath(fid), name))
				return resp.qid, resp.iounit

				def mkdir(self, dfid, name, mode, gid):
				"issue mkdir (.L)"
				tag = self.get_tag()
				pkt = self.proto.Tmkdir(tag=tag, dfid=dfid, name=name,
				mode=mode, gid=gid)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rmkdir):
				self.badresp('mkdir {0} in '
				'{1}'.format(name, self.getpathX(dfid)), resp)
				return resp.qid

				# We don't call this getattr(), for the obvious reason.
				def Tgetattr(self, fid, request_mask=protocol.td.GETATTR_ALL):
				"issue Tgetattr.L - get what you ask for, or everything by default"
				tag = self.get_tag()
				pkt = self.proto.Tgetattr(tag=tag, fid=fid, request_mask=request_mask)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rgetattr):
				self.badresp('Tgetattr {0} of '
				'{1}'.format(request_mask, self.getpathX(fid)), resp)
				attrs = Fileattrs()
				# Handle the simplest valid-bit tests:
				for name in ('mode', 'nlink', 'uid', 'gid', 'rdev',
				'size', 'blocks', 'gen', 'data_version'):
				bit = getattr(protocol.td, 'GETATTR_' + name.upper())
				if resp.valid & bit:
				attrs[name] = resp[name]
				# Handle the timestamps, which are timespec pairs
				for name in ('atime', 'mtime', 'ctime', 'btime'):
				bit = getattr(protocol.td, 'GETATTR_' + name.upper())
				if resp.valid & bit:
				attrs[name] = Timespec(sec=resp[name + '_sec'],
				nsec=resp[name + '_nsec'])
				# There is no control bit for blksize; qemu and Linux always
				# provide one.
				attrs.blksize = resp.blksize
				# Handle ino, which comes out of qid.path
				if resp.valid & protocol.td.GETATTR_INO:
				attrs.ino = resp.qid.path
				return attrs

				# We don't call this setattr(), for the obvious reason.
				# See wstat for usage. Note that time fields can be set
				# with either second or nanosecond resolutions, and some
				# can be set without supplying an actual timestamp, so
				# this is all pretty ad-hoc.
				#
				# There's also one keyword-only argument, ctime=<anything>,
				# which means "set SETATTR_CTIME". This has the same effect
				# as supplying valid=protocol.td.SETATTR_CTIME.
				def Tsetattr(self, fid, valid=0, attrs=None, **kwargs):
				if attrs is None:
				attrs = Fileattrs()
				else:
				attrs = attrs._copy()

				# Start with an empty (all-zero) Tsetattr instance. We
				# don't really need to zero out tag and fid, but it doesn't
				# hurt. Note that if caller says, e.g., valid=SETATTR_SIZE
				# but does not supply an incoming size (via "attrs" or a size=
				# argument), we'll ask to set that field to 0.
				attrobj = protocol.rrd.Tsetattr()
				for field in attrobj._fields:
				attrobj[field] = 0

				# In this case, forbid means "only as kwargs": these values
				# in an incoming attrs object are merely ignored.
				forbid = ('ino', 'nlink', 'rdev', 'blksize', 'blocks', 'btime',
				'gen', 'data_version')
				for field in attrs._fields:
				if field in kwargs:
				if field in forbid:
				raise ValueError('cannot Tsetattr {0}'.format(field))
				attrs[field] = kwargs.pop(field)
				elif attrs[field] is None:
				continue
				# OK, we're setting this attribute. Many are just
				# numeric - if that's the case, we're good, set the
				# field and the appropriate bit.
				bitname = 'SETATTR_' + field.upper()
				bit = getattr(protocol.td, bitname)
				if field in ('mode', 'uid', 'gid', 'size'):
				valid \|= bit
				attrobj[field] = attrs[field]
				continue
				# Timestamps are special: The value may be given as
				# an integer (seconds), or as a float (we convert to
				# (we convert to sec+nsec), or as a timespec (sec+nsec).
				# If specified as 0, we mean "we are not providing the
				# actual time, use the server's time."
				#
				# The ctime field's value, if any, is ignored.
				if field in ('atime', 'mtime'):
				value = attrs[field]
				if hasattr(value, '__len__'):
				if len(value) != 2:
				raise ValueError('invalid {0}={1!r}'.format(field,
				value))
				sec = value[0]
				nsec = value[1]
				else:
				sec = value
				if isinstance(sec, float):
				nsec, sec = math.modf(sec)
				nsec = int(round(nsec * 1000000000))
				else:
				nsec = 0
				valid \|= bit
				attrobj[field + '_sec'] = sec
				attrobj[field + '_nsec'] = nsec
				if sec != 0 or nsec != 0:
				# Add SETATTR_ATIME_SET or SETATTR_MTIME_SET
				# as appropriate, to tell the server to *this
				# specific* time, instead of just "server now".
				bit = getattr(protocol.td, bitname + '_SET')
				valid \|= bit
				if 'ctime' in kwargs:
				kwargs.pop('ctime')
				valid \|= protocol.td.SETATTR_CTIME
				if kwargs:
				raise TypeError('Tsetattr() got an unexpected keyword argument '
				'{0!r}'.format(kwargs.popitem()))

				tag = self.get_tag()
				attrobj.valid = valid
				attrobj.tag = tag
				attrobj.fid = fid
				pkt = self.proto.pack(attrobj)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rsetattr):
				self.badresp('Tsetattr {0} {1} of '
				'{2}'.format(valid, attrs, self.getpathX(fid)), resp)

				def xattrwalk(self, fid, name=None):
				"walk one name or all names: caller should read() the returned fid"
				tag = self.get_tag()
				newfid = self.alloc_fid()
				pkt = self.proto.Txattrwalk(tag=tag, fid=fid, newfid=newfid,
				name=name or '')
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rxattrwalk):
				self.retire_fid(newfid)
				self.badresp('Txattrwalk {0} of '
				'{1}'.format(name, self.getpathX(fid)), resp)
				if name:
				self.setpath(newfid, 'xattr:' + name)
				else:
				self.setpath(newfid, 'xattr')
				return newfid, resp.size

				def _pathsplit(self, path, startdir, allow_empty=False):
				"common code for uxlookup and uxopen"
				if self.rootfid is None:
				raise LocalError('{0}: not attached'.format(self))
				if path.startswith(b'/') or startdir is None:
				startdir = self.rootfid
				components = [i for i in path.split(b'/') if i != b'']
				if len(components) == 0 and not allow_empty:
				raise LocalError('{0}: {1!r}: empty path'.format(self, path))
				return components, startdir

				def uxlookup(self, path, startdir=None):
				"""
				Unix-style lookup. That is, lookup('/foo/bar') or
				lookup('foo/bar'). If startdir is not None and the
				path does not start with '/' we look up from there.
				"""
				components, startdir = self._pathsplit(path, startdir, allow_empty=True)
				return self.lookup_last(startdir, components)

				def uxopen(self, path, oflags=0, perm=None, gid=None,
				startdir=None, filetype=None):
				"""
				Unix-style open()-with-option-to-create, or mkdir().
				oflags is 0/1/2 with optional os.O_CREAT, perm defaults
				to 0o666 (files) or 0o777 (directories). If we use
				a Linux create or mkdir op, we will need a gid, but it's
				not required if you are opening an existing file.

				Adds a final boolean value for "did we actually create".
				Raises OSError if you ask for a directory but it's a file,
				or vice versa. (??? reconsider this later)

				Note that this does not handle other file types, only
				directories.
				"""
				needtype = {
				'dir': protocol.td.QTDIR,
				None: protocol.td.QTFILE,
				}[filetype]
				omode_byte = oflags & 3 # cheating
				# allow looking up /, but not creating /
				allow_empty = (oflags & os.O_CREAT) == 0
				components, startdir = self._pathsplit(path, startdir,
				allow_empty=allow_empty)
				if not (oflags & os.O_CREAT):
				# Not creating, i.e., just look up and open existing file/dir.
				fid, qid = self.lookup_last(startdir, components)
				# If we got this far, use Topen on the fid; we did not
				# create the file.
				return self._uxopen2(path, needtype, fid, qid, omode_byte, False)

				# Only used if using dot-L, but make sure it's always provided
				# since this is generic.
				if gid is None:
				raise ValueError('gid is required when creating file or dir')

				if len(components) > 1:
				# Look up all but last component; this part must succeed.
				fid, _ = self.lookup(startdir, components[:-1])

				# Now proceed with the final component, using fid
				# as the start dir. Remember to clunk it!
				startdir = fid
				clunk_startdir = True
				components = components[-1:]
				else:
				# Use startdir as the start dir, and get a new fid.
				# Do not clunk startdir!
				clunk_startdir = False
				fid = self.alloc_fid()

				# Now look up the (single) component. If this fails,
				# assume the file or directory needs to be created.
				tag = self.get_tag()
				pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
				nwname=1, wname=components)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if isinstance(resp, protocol.rrd.Rwalk):
				if clunk_startdir:
				self.clunk(startdir, ignore_error=True)
				# fid successfully walked to refer to final component.
				# Just need to actually open the file.
				self.setpath(fid, _pathcat(self.getpath(startdir), components[0]))
				qid = resp.wqid[0]
				return self._uxopen2(needtype, fid, qid, omode_byte, False)

				# Walk failed. If we allocated a fid, retire it. Then set
				# up a fid that points to the parent directory in which to
				# create the file or directory. Note that if we're creating
				# a file, this fid will get changed so that it points to the
				# file instead of the directory, but if we're creating a
				# directory, it will be unchanged.
				if fid != startdir:
				self.retire_fid(fid)
				fid = self.dupfid(startdir)

				try:
				qid, iounit = self._uxcreate(filetype, fid, components[0],
				oflags, omode_byte, perm, gid)

				# Success. If we created an ordinary file, we have everything
				# now as create alters the incoming (dir) fid to open the file.
				# Otherwise (mkdir), we need to open the file, as with
				# a successful lookup.
				#
				# Note that qid type should match "needtype".
				if filetype != 'dir':
				if qid.type == needtype:
				return fid, qid, iounit, True
				self.clunk(fid, ignore_error=True)
				raise OSError(_wrong_file_type(qid),
				'{0}: server told to create {1} but '
				'created {2} instead'.format(path,
				qt2n(needtype),
				qt2n(qid.type)))

				# Success: created dir; but now need to walk to and open it.
				fid = self.alloc_fid()
				tag = self.get_tag()
				pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
				nwname=1, wname=components)
				super(P9Client, self).write(pkt)
				resp = self.wait_for(tag)
				if not isinstance(resp, protocol.rrd.Rwalk):
				self.clunk(fid, ignore_error=True)
				raise OSError(errno.ENOENT,
				'{0}: server made dir but then failed to '
				'find it again'.format(path))
				self.setpath(fid, _pathcat(self.getpath(fid), components[0]))
				return self._uxopen2(needtype, fid, qid, omode_byte, True)
				finally:
				# Regardless of success/failure/exception, make sure
				# we clunk startdir if needed.
				if clunk_startdir:
				self.clunk(startdir, ignore_error=True)

				def _uxcreate(self, filetype, fid, name, oflags, omode_byte, perm, gid):
				"""
				Helper for creating dir-or-file. The fid argument is the
				parent directory on input, but will point to the file (if
				we're creating a file) on return. oflags only applies if
				we're creating a file (even then we use omode_byte if we
				are using the plan9 create op).
				"""
				# Try to create or mkdir as appropriate.
				if self.supports_all(protocol.td.Tlcreate, protocol.td.Tmkdir):
				# Use Linux style create / mkdir.
				if filetype == 'dir':
				if perm is None:
				perm = 0o777
				return self.mkdir(startdir, name, perm, gid), None
				if perm is None:
				perm = 0o666
				lflags = flags_to_linux_flags(oflags)
				return self.lcreate(fid, name, lflags, perm, gid)

				if filetype == 'dir':
				if perm is None:
				perm = protocol.td.DMDIR \| 0o777
				else:
				perm \|= protocol.td.DMDIR
				else:
				if perm is None:
				perm = 0o666
				return self.create(fid, name, perm, omode_byte)

				def _uxopen2(self, needtype, fid, qid, omode_byte, didcreate):
				"common code for finishing up uxopen"
				if qid.type != needtype:
				self.clunk(fid, ignore_error=True)
				raise OSError(_wrong_file_type(qid),
				'{0}: is {1}, expected '
				'{2}'.format(path, qt2n(qid.type), qt2n(needtype)))
				qid, iounit = self.open(fid, omode_byte)
				# ? should we re-check qid? it should not have changed
				return fid, qid, iounit, didcreate

				def uxmkdir(self, path, perm, gid, startdir=None):
				"""
				Unix-style mkdir.

				The gid is only applied if we are using .L style mkdir.
				"""
				components, startdir = self._pathsplit(path, startdir)
				clunkme = None
				if len(components) > 1:
				fid, _ = self.lookup(startdir, components[:-1])
				startdir = fid
				clunkme = fid
				components = components[-1:]
				try:
				if self.supports(protocol.td.Tmkdir):
				qid = self.mkdir(startdir, components[0], perm, gid)
				else:
				qid, _ = self.create(startdir, components[0],
				protocol.td.DMDIR \| perm,
				protocol.td.OREAD)
				# Should we chown/chgrp the dir?
				finally:
				if clunkme:
				self.clunk(clunkme, ignore_error=True)
				return qid

				def uxreaddir(self, path, startdir=None, no_dotl=False):
				"""
				Read a directory to get a list of names (which may or may not
				include '.' and '..').

				If no_dotl is True (or anything non-false-y), this uses the
				plain or .u readdir format, otherwise it uses dot-L readdir
				if possible.
				"""
				components, startdir = self._pathsplit(path, startdir, allow_empty=True)
				fid, qid = self.lookup_last(startdir, components)
				try:
				if qid.type != protocol.td.QTDIR:
				raise OSError(errno.ENOTDIR,
				'{0}: {1}'.format(self.getpathX(fid),
				os.strerror(errno.ENOTDIR)))
				# We need both Tlopen and Treaddir to use Treaddir.
				if not self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
				no_dotl = True
				if no_dotl:
				statvals = self.uxreaddir_stat_fid(fid)
				return [i.name for i in statvals]

				dirents = self.uxreaddir_dotl_fid(fid)
				return [dirent.name for dirent in dirents]
				finally:
				self.clunk(fid, ignore_error=True)

				def uxreaddir_stat(self, path, startdir=None):
				"""
				Use directory read to get plan9 style stat data (plain or .u readdir).

				Note that this gets a fid, then opens it, reads, then clunks
				the fid. If you already have a fid, you may want to use
				uxreaddir_stat_fid (but note that this opens, yet does not
				clunk, the fid).

				We return the qid plus the list of the contents. If the
				target is not a directory, the qid will not have type QTDIR
				and the contents list will be empty.

				Raises OSError if this is applied to a non-directory.
				"""
				components, startdir = self._pathsplit(path, startdir)
				fid, qid = self.lookup_last(startdir, components)
				try:
				if qid.type != protocol.td.QTDIR:
				raise OSError(errno.ENOTDIR,
				'{0}: {1}'.format(self.getpathX(fid),
				os.strerror(errno.ENOTDIR)))
				statvals = self.ux_readdir_stat_fid(fid)
				return qid, statvals
				finally:
				self.clunk(fid, ignore_error=True)

				def uxreaddir_stat_fid(self, fid):
				"""
				Implement readdir loop that extracts stat values.
				This opens, but does not clunk, the given fid.

				Unlike uxreaddir_stat(), if this is applied to a file,
				rather than a directory, it just returns no entries.
				"""
				statvals = []
				qid, iounit = self.open(fid, protocol.td.OREAD)
				# ?? is a zero iounit allowed? if so, what do we use here?
				if qid.type == protocol.td.QTDIR:
				if iounit <= 0:
				iounit = 512 # probably good enough
				offset = 0
				while True:
				bstring = self.read(fid, offset, iounit)
				if bstring == b'':
				break
				statvals.extend(self.decode_stat_objects(bstring))
				offset += len(bstring)
				return statvals

				def uxreaddir_dotl_fid(self, fid):
				"""
				Implement readdir loop that uses dot-L style dirents.
				This opens, but does not clunk, the given fid.

				If applied to a file, the lopen should fail, because of the
				L_O_DIRECTORY flag.
				"""
				dirents = []
				qid, iounit = self.lopen(fid, protocol.td.OREAD \|
				protocol.td.L_O_DIRECTORY)
				# ?? is a zero iounit allowed? if so, what do we use here?
				# but, we want a minimum of over 256 anyway, let's go for 512
				if iounit < 512:
				iounit = 512
				offset = 0
				while True:
				bstring = self.readdir(fid, offset, iounit)
				if bstring == b'':
				break
				ents = self.decode_readdir_dirents(bstring)
				if len(ents) == 0:
				break # ???
				dirents.extend(ents)
				offset = ents[-1].offset
				return dirents

				def uxremove(self, path, startdir=None, filetype=None,
				force=False, recurse=False):
				"""
				Implement rm / rmdir, with optional -rf.
				if filetype is None, remove dir or file. If 'dir' or 'file'
				remove only if it's one of those. If force is set, ignore
				failures to remove. If recurse is True, remove contents of
				directories (recursively).

				File type mismatches (when filetype!=None) raise OSError (?).
				"""
				components, startdir = self._pathsplit(path, startdir, allow_empty=True)
				# Look up all components. If
				# we get an error we'll just assume the file does not
				# exist (is this good?).
				try:
				fid, qid = self.lookup_last(startdir, components)
				except RemoteError:
				return
				if qid.type == protocol.td.QTDIR:
				# it's a directory, remove only if allowed.
				# Note that we must check for "rm -r /" (len(components)==0).
				if filetype == 'file':
				self.clunk(fid, ignore_error=True)
				raise OSError(_wrong_file_type(qid),
				'{0}: is dir, expected file'.format(path))
				isroot = len(components) == 0
				closer = self.clunk if isroot else self.remove
				if recurse:
				# NB: _rm_recursive does not clunk fid
				self._rm_recursive(fid, filetype, force)
				# This will fail if the directory is non-empty, unless of
				# course we tell it to ignore error.
				closer(fid, ignore_error=force)
				return
				# Not a directory, call it a file (even if socket or fifo etc).
				if filetype == 'dir':
				self.clunk(fid, ignore_error=True)
				raise OSError(_wrong_file_type(qid),
				'{0}: is file, expected dir'.format(path))
				self.remove(fid, ignore_error=force)

				def _rm_file_by_dfid(self, dfid, name, force=False):
				"""
				Remove a file whose name is <name> (no path, just a component
				name) whose parent directory is <dfid>. We may assume that the
				file really is a file (or a socket, or fifo, or some such, but
				definitely not a directory).

				If force is set, ignore failures.
				"""
				# If we have unlinkat, that's the fast way. But it may
				# return an ENOTSUP error. If it does we shouldn't bother
				# doing this again.
				if self.supports(protocol.td.Tunlinkat):
				try:
				self.unlinkat(dfid, name, 0)
				return
				except RemoteError as err:
				if not err.is_ENOTSUP():
				raise
				self.unsupported(protocol.td.Tunlinkat)
				# fall through to remove() op
				# Fall back to lookup + remove.
				try:
				fid, qid = self.lookup_last(dfid, [name])
				except RemoteError:
				# If this has an errno we could tell ENOENT from EPERM,
				# and actually raise an error for the latter. Should we?
				return
				self.remove(fid, ignore_error=force)

				def _rm_recursive(self, dfid, filetype, force):
				"""
				Recursively remove a directory. filetype is probably None,
				but if it's 'dir' we fail if the directory contains non-dir
				files.

				If force is set, ignore failures.

				Although we open dfid (via the readdir.*_fid calls) we
				do not clunk it here; that's the caller's job.
				"""
				# first, remove contents
				if self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
				for entry in self.uxreaddir_dotl_fid(dfid):
				if entry.name in (b'.', b'..'):
				continue
				fid, qid = self.lookup(dfid, [entry.name])
				try:
				attrs = self.Tgetattr(fid, protocol.td.GETATTR_MODE)
				if stat.S_ISDIR(attrs.mode):
				self.uxremove(entry.name, dfid, filetype, force, True)
				else:
				self.remove(fid)
				fid = None
				finally:
				if fid is not None:
				self.clunk(fid, ignore_error=True)
				else:
				for statobj in self.uxreaddir_stat_fid(dfid):
				# skip . and ..
				name = statobj.name
				if name in (b'.', b'..'):
				continue
				if statobj.qid.type == protocol.td.QTDIR:
				self.uxremove(name, dfid, filetype, force, True)
				else:
				self._rm_file_by_dfid(dfid, name, force)

				def _wrong_file_type(qid):
				"return EISDIR or ENOTDIR for passing to OSError"
				if qid.type == protocol.td.QTDIR:
				return errno.EISDIR
				return errno.ENOTDIR

				def flags_to_linux_flags(flags):
				"""
				Convert OS flags (O_CREAT etc) to Linux flags (protocol.td.L_O_CREAT etc).
				"""
				flagmap = {
				os.O_CREAT: protocol.td.L_O_CREAT,
				os.O_EXCL: protocol.td.L_O_EXCL,
				os.O_NOCTTY: protocol.td.L_O_NOCTTY,
				os.O_TRUNC: protocol.td.L_O_TRUNC,
				os.O_APPEND: protocol.td.L_O_APPEND,
				os.O_DIRECTORY: protocol.td.L_O_DIRECTORY,
				}

				result = flags & os.O_RDWR
				flags &= ~os.O_RDWR
				for key, value in flagmap.iteritems():
				if flags & key:
				result \|= value
				flags &= ~key
				if flags:
				raise ValueError('untranslated bits 0x{0:x} in os flags'.format(flags))
				return result