| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
|
|
* Makefile.am (nsmux_LDADD): Link against libpthread instead of
libthreads.
* nsmux.h: Include <pthread.h> instead of <cthreads.h>
* lnode.h: Use pthread type instead of cthreads structure.
* node.h: Likewise.
* ncache.h: Likewise.
* lnode.c: Use pthread functions instead of cthreads functions.
* node.c: Likewise.
* ncache.c: Likewise.
* nsmux.c: Likewise.
|
|
* configure.ac: New file.
* package.m4: Likewise.
* Makefile.am: Likewise.
* build: Remove file.
* nsmux.c (netfs_server_name, netfs_server_version): Set from the Autoconf
variables.
* options.c (argp_program_version): Likewise.
(argp_program_bug_address): New.
|
|
Previously, a settrans -gR on a node on which nsmux resides
would only kill the dynamic translators, without shutting
down nsmux, because it didn't wait for the children to close
their ports, which made a check in netfs_shutdown fail. Now
nsmux waits for the dynamic translator to finish, so
settrans -gR does its job as expected: shuts down everything.
|
|
Now nsmux can shutdown all of its dynamic translators on exit, thus
doing sufficient cleanup. One can tell nsmux to shutdown dynamic
translators using the ``--recursive'' option to settrans. Note that
because fsys_goaway returns immediately as the RPC is processed, while
the receiver may still remain in memory, doing something like
settrans -g --recursive foo
where nsmux is sitting on foo will almost always result in a ``Server
busy'' error message. The reason is that libnetfs counts how many open
ports to its nodes there are at shutdown and in most cases it does the
check *before* the dynamic translators manage to drop their
references. Therefore, the aforementioned command gracefully kills all
dynamic translators. Invoked the second time, this command will
shutdown nsmux, too. Immediate shutdown with killing dynamic
translators can be achieved via
settrans -gf --recursive foo
|
|
nsmux cannot presently shut down gracefully (without the -f option)
after having done a magic lookup, because the dynamic translators it
starts hold ports (references) to its nodes and make the standard
fsys_goaway handler return with EBUSY. To solve the problem, nsmux
will need to keep track of dynamic translators and shut them down
explicitly, not relying on standard mechanisms, which don't know that
the translators might be stacked and might try stopping a translator
in the middle of the dynamic stack, which will certainly result in
EBUSY.
(Note that this commit comes on top of an erroneous one and is meant
to fix it. I could not revert the previous commit because of ``bad
index'', so I hope this commit will solve the problem...)
|
|
This reverts commit 0ec50f8fb5ec477523571a9612cfb9f23a10de12.
|
|
nsmux cannot presently shut down gracefully (without the -f option)
after having done a magic lookup, because the dynamic translators it
starts hold ports (references) to its nodes and make the standard
fsys_goaway handler return with EBUSY. To solve the problem, nsmux
will need to keep track of dynamic translators and shut them down
explicitly, not relying on standard mechanisms, which don't know that
the translators might be stacked and might try stopping a translator
in the middle of the dynamic stack, which will certainly result in
EBUSY.
# Please enter the commit message for your changes.
# (Comment lines starting with '#' will not be included)
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# modified: debug.h
# modified: lib.c
# modified: lib.h
# modified: lnode.c
# modified: lnode.h
# modified: magic.c
# modified: magic.h
# modified: ncache.c
# modified: ncache.h
# modified: node.c
# modified: node.h
# modified: nsmux.c
# modified: nsmux.h
# modified: options.c
# modified: options.h
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# my_S_dir_lookup.c
# sav/
# update
|
|
The copyright years were listed only up to 2008, so I added
2009. Also, some of the files I created from scratch used to
list copyright years starting with 2001, which was wrong.
This has also been corrected.
|
|
nsmux will eventually need to be able to traverse dynamic
translator stacks, so it will have to know which node lies under
a certain node (shadow or proxy). To be able to do this, nsmux
now maintains the service nodes in a dynamic translator stack
in a one-directional linked list.
|
|
Now inside each netnode (and, hence, inside each node) there is
a field showing the type of the node. This is required because,
at least in response to requests by the filter, proxy nodes and
shadow nodes will have different jobs to do and the server-side
implementation of filesystem RPCs in nsmux would need to know
what actions they are expected to carry out.
|
|
When setting dynamic translators, nsmux used to offer the client
a port to the dynamic translator directly. Now it gives off a
proxy node, which contains a port to the translator. Also, proxy
nodes are now included in dynamic translator stacks. Dynamic
translator stacks now consist of the following interconnected
conceptual blocks:
-- shadow node -- translator -- proxy node --
|
|
When a client wants nsmux to set several translators on a node
using a syntax like ``file,,x,,y'', nsmux sets the first
translator on a shadow node mirroring ``file'' and punts a
retry to the client. The client (commonly) does the retry and
thus control comes back to nsmux, which creates another shadow
node and sets the second translator on this node.
At the moment translator stacks do not include proxy nodes, i.e.
the structure of a dynamic translator stack is:
...---dynamic translator -- shadow node -- dynamic translator ---...
|
|
Usually the file of which the supplied node is a mirror is
looked up by node_set_translator, so that it can open using
the flag combination required by the translator being started.
However, when dealing with a dynamic translator being set upon
another dynamic translator, node_set_translator must not do any
lookups, because a valid port is already stored in the supplied
node.
|
|
Now, when nsmux sets another dynamic translator, it sends a
retry to the client, so that it could set the (possible) next
dynamic translator in the next execution of netfs_S_dir_lookup,
which will occur due to the retry. However, nsmux cannot handle
the retry properly yet.
The reason for splitting the functionality of *only* passing the
retry to client in a separate commit is that it required some
tricky code manipulation and hence I feel that keeping it
in a separate commit is quite reasonable.
|
|
Since we want netfs_S_dir_lookup to ask the client to do a
retry when it sets a new dynamic translator, nsmux has to give
the client a *proxy* of the port to the root of the current
dynamic translator, so that the retry gets back in nsmux. For
this we need to create proxy nodes for ports, which is precisely
what node_create_from_port does.
|
|
nsmux can now handle the syntax ``file,,x'' correctly again.
Translator *stacks* cannot be created yet.
|
|
Now this function is called node_set_translator and sets only
one translator on the supplied (shadow) node. This function has
not yet been debugged.
|
|
Due to the transition to a different way of building translator
stacks netfs_S_dir_lookup has been broken and nsmux could not
respond normally to any lookup requests. Now netfs_S_dir_lookup
is again capable of doing normal lookups. At the moment nsmux
is doing nothing but mirror the real filesystem.
|
|
Now nsmux has two special routines for parsing the special
``,,'' syntax: magic_find_sep and magic_unescape. The reason
for their separate existence is that the magic ``,,'' is
allowed to be escaped in the following way ``,,,'' and nsmux
must be able to react correspondingly to such syntax.
|
|
Up to now it was netfs_attempt_lookup_improved who handled the
magic syntax for ``,,''. Now the idea is to handle this syntax
via retries and netfs_attempt_lookup_improved is in no position
to manage this. In further commits the magic syntax will be
handled by netfs_S_dir_lookup. Note nsmux does not actually
work at the moment.
|
|
So far dynamic translator stacks were created in the following
fashion: nsmux created a shadow node on which the whole
dynamic translator stack was built. This commit starts the
transition to a different strategy: the new approach consists
in setting *each* dynamic translator on its personal shadow
node. To achieve such functionality the set of fiels of struct
node was modified and the bits of code that manipulated these
fields were stripped out. The code is not functional now. The
coming commits will bring it back to life.
|
|
Before, netfs_S_dir_lookup used to open the ports in shadow,
nodes. This could cause conflicts with the flags required by
the translator starting up on the node. Now the port is opened
only based on the flags requested by the translator being
launched.
|
|
Now the code is (hopefully) compliant with GNU Coding Standards.
|
|
node_set_translators used to count the translators in the list
and set the first one so many times as there were translators.
This bug is killed now.
|
|
real node
Now netfs_S_file_get_translator_cntl calls the
file_get_translator_cntl routine on the untranslated version of
the real node, which makes it possible for the filter to trace
the real translator stack.
|
|
netfs_attempt_lookup_improved will now lookup the requested file
both with the requested flags and in an untranslated fashion.
This will allow netfs_S_file_get_translator_cntl to correctly
redirect requests to the real filesystem node.
|
|
When 'file,,x' is requested, nsmux cannot tell whether 'x'
is a filter or not and whether it will require the untranslated
version of the file or not. However, when
netfs_S_file_get_translator_cntl would like to show the
translator stack on the *real* node, it will need the
untranslated version of the node, which must be available by
that time. The new field in netnode solves this issue.
|
|
Earlier the README said that nsmux will propagate translators
into a directory if it will be set on a directory. However,
this functionality will be later implemented as a separate
translator, therefore nsmux shall not care for this task in
the future.
|
|
netfs_S_file_get_translator_cntl
Now netfs_file_get_translator_cntl will recognize whether it
is called for the root node or not. In case the node it is
called on is not the root, it will call file_get_translator_cntl
on the real node, so that filters could trace translator stacks
on real nodes.
|
|
By default, libnetfs does not implement this callback, which,
BTW, makes impossible to trace the translator stack consisting
of libnetfs translators. nsmux not only needs an implementation
of this routine, but also requires customizations in order for
filters to trace translator stacks on real nodes.
|
|
This reverts commit 7200dac108c4a8981b7f7f5f90757409c3e6d5bf.
|
|
libdiskfs."
This reverts commit e7b2aaa4548c0fa5fb5d6c8586fee63748d16dab.
|
|
By default, libnetfs does not implement this callback, which,
BTW, makes impossible to trace the translator stack consisting
of libnetfs translators. nsmux not only needs an implementation
of this routine, but also requires customizations in order for
filters to trace translator stacks on real nodes.
|
|
I cloned the native implementation of netfs_S_fsys_getroot,
since we filter translators run on nsmux nodes to see the
translator stacks of the real filesystem nodes.
|
|
I refactored the node cache in such a way that it now only
maintains references to nodes (the reason is that only
directory nodes and shadow nodes are created, therefore the
existing node cache is very well suited for this purpose).
It must be remarked that the node cache, borrowed from
unionfs, has never actually been a *cache*, therefore this
small change does not alter things badly.
I also removed the command line option --ncache-size.
|
|
Now nsmux will handle properly the requests to write into
proxy nodes, instead of simply returning 0.
|
|
Now, when 'file,,x' is requested, nsmux will create a proxy
node and will set the translator 'x' on this node, not on
the real filesystem node. Also, nsmux will not create nodes
for simple file looks, instead it will simply return the
port to the required file, thus avoiding the necessity
to handle IO operations inside itself.
|
|
Now the user can enter directories using the following command:
cd dir,,x
All files in this directory will then be implicitly translated
by translator 'x'; in other words, if there is a file 'file' in
directory 'dir', after executing the command mentioned above,
and after running
cat file
the user will obtain the content of 'file' translated by 'x'.
Also fixed several rather serious bugs in lookup of file names
of the type 'file,,x'.
|
|
The user can now request files with special names like 'file,,x'
and the proxy will start the translator 'x' on file 'file' and
return the port to the user. If 'x' is not an absolute path,
the default prefix '/hurd/' is added to it.
|
|
At the moment nsmux is only capable of creating a read-only
mirror of the given directory.
|
