term% ls -F
term% cat index.txt
BIND(2)                       System Calls Manual                      BIND(2)

       bind, mount, unmount - change name space

       #include <u.h>
       #include <libc.h>

       int bind(char *name, char *old, int flag)

       int mount(int fd, char *old, int flag, char *aname)

       int unmount(char *name, char *old)

       Bind  and  mount  modify the file name space of the current process and
       other processes in its name space group (see fork(2)).  For both calls,
       old  is  the  name of an existing file or directory in the current name
       space where the modification is to be made.  The name old is  evaluated
       as  described in intro(2), except that no translation of the final path
       element is done.

       For bind, name is the name of another (or possibly the  same)  existing
       file  or  directory in the current name space.  After a successful bind
       call, the file name old is an alias for the object originally named  by
       name;  if  the modification doesn't hide it, name will also still refer
       to its original file.  The evaluation of new happens at the time of the
       bind, not when the binding is later used.

       The  fd  argument to mount is a file descriptor of an open network con‐
       nection or pipe to a file server.  The old file must  be  a  directory.
       After a successful mount the file tree served (see below) by fd will be
       visible with its root directory having name old.

       The flag controls details of the modification made to the  name  space.
       In the following, new refers to the file as defined by name or the root
       directory served by fd.  Either both old and new files must be directo‐
       ries, or both must not be directories.  Flag can be one of:

       MREPL  Replace  the old file by the new one.  Henceforth, an evaluation
              of old will be translated to the new file.  If they are directo‐
              ries  (for mount, this condition is true by definition), old be‐
              comes a union directory consisting of  one  directory  (the  new

              Both  the  old  and new files must be directories.  Add the con‐
              stituent files of the new directory to the  union  directory  at
              old so its contents appear first in the union.  After an MBEFORE
              bind or mount, the new directory will  be  searched  first  when
              evaluating file names in the union directory.

       MAFTER Like MBEFORE but the new directory goes at the end of the union.

       The  flags  are  defined in <libc.h>.  In addition, there is an MCREATE
       flag that can be OR'd with any of the above.  When a create system call
       (see  open(2))  attempts  to  create in a union directory, and the file
       does not exist, the elements of the union are searched in  order  until
       one  is found with MCREATE set.  The file is created in that directory;
       if that attempt fails, the create fails.

       With mount, the file descriptor fd must be open for reading and writing
       and  prepared  to  respond  to  9P messages (see Section 5).  After the
       mount, the file tree starting at old is served by a kernel  mnt(3)  de‐
       vice.   That  device  will turn operations in the tree into messages on
       fd.  Aname selects among different file trees on the server;  the  null
       string chooses the default tree.

       The  file  descriptor  fd is automatically closed by a successful mount

       The effects of bind and mount can be undone by  unmount.   If  name  is
       zero,  everything bound to or mounted upon old is unbound or unmounted.
       If name is not zero, it is evaluated as described above for  bind,  and
       the  effect of binding or mounting that particular result on old is un‐


       bind(1), intro(2), fcall(2), auth(2) (particularly  amount),  intro(5),
       mnt(3), srv(3)

       The  return  value is a positive integer (a unique sequence number) for
       success, -1 for failure.  These routines set errstr.

       Mount will not return until it has successfully attached  to  the  file
       server, so the process doing a mount cannot be the one serving.