servers/vfs/vmnt.c

   1 /* Virtual mount table related routines.
   2  *
   3  */
   4
   5 #include "fs.h"
   6 #include "threads.h"
   7 #include "vmnt.h"
   8 #include <assert.h>
   9 #include <string.h>
  10 #include "fproc.h"
  11
  12 static int is_vmnt_locked(struct vmnt *vmp);
  13 static void clear_vmnt(struct vmnt *vmp);
  14
  15 /* Is vmp pointer reasonable? */
  16 #define SANEVMP(v) ((((v) >= &vmnt[0] && (v) < &vmnt[NR_MNTS])))
  17 #define BADVMP(v, f, l) printf("%s:%d: bad vmp %p\n", f, l, v)
  18 /* vp check that panics */
  19 #define ASSERTVMP(v) if(!SANEVMP(v)) { \
  20         BADVMP(v, __FILE__, __LINE__); panic("bad vmp"); }
  21
  22 #if LOCK_DEBUG
  23 /*===========================================================================*
  24  *                              check_vmnt_locks_by_me                       *
  25  *===========================================================================*/
  26 void check_vmnt_locks_by_me(struct fproc *rfp)
  27 {
  28 /* Check whether this thread still has locks held on vmnts */
  29   struct vmnt *vmp;
  30
  31   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
  32         if (tll_locked_by_me(&vmp->m_lock))
  33                 panic("Thread %d still holds vmnt lock on vmp %p call_nr=%d\n",
  34                       mthread_self(), vmp, job_call_nr);
  35   }
  36
  37   if (rfp->fp_vmnt_rdlocks != 0)
  38         panic("Thread %d still holds read locks on a vmnt (%d) call_nr=%d\n",
  39               mthread_self(), rfp->fp_vmnt_rdlocks, job_call_nr);
  40 }
  41 #endif
  42
  43 /*===========================================================================*
  44  *                              check_vmnt_locks                             *
  45  *===========================================================================*/
  46 void check_vmnt_locks()
  47 {
  48   struct vmnt *vmp;
  49   int count = 0;
  50
  51   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++)
  52         if (is_vmnt_locked(vmp)) {
  53                 count++;
  54                 printf("vmnt %p is %s, fs_e=%d dev=%d\n", vmp, (tll_islocked(&vmp->m_lock) ? "locked":"pending locked"), vmp->m_fs_e, vmp->m_dev);
  55         }
  56
  57   if (count) panic("%d locked vmnts\n", count);
  58 #if 0
  59   printf("check_vmnt_locks OK\n");
  60 #endif
  61 }
  62
  63 /*===========================================================================*
  64  *                             mark_vmnt_free                                *
  65  *===========================================================================*/
  66 void mark_vmnt_free(struct vmnt *vmp)
  67 {
  68   ASSERTVMP(vmp);
  69
  70   vmp->m_fs_e = NONE;
  71   vmp->m_dev = NO_DEV;
  72 }
  73
  74 /*===========================================================================*
  75  *                             clear_vmnt                                    *
  76  *===========================================================================*/
  77 static void clear_vmnt(struct vmnt *vmp)
  78 {
  79 /* Reset vmp to initial parameters */
  80   ASSERTVMP(vmp);
  81
  82   vmp->m_fs_e = NONE;
  83   vmp->m_dev = NO_DEV;
  84   vmp->m_flags = 0;
  85   vmp->m_mounted_on = NULL;
  86   vmp->m_root_node = NULL;
  87   vmp->m_label[0] = '\0';
  88   vmp->m_comm.c_max_reqs = 1;
  89   vmp->m_comm.c_cur_reqs = 0;
  90   vmp->m_comm.c_req_queue = NULL;
  91 }
  92
  93 /*===========================================================================*
  94  *                             get_free_vmnt                                 *
  95  *===========================================================================*/
  96 struct vmnt *get_free_vmnt(void)
  97 {
  98   struct vmnt *vmp;
  99
 100   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; ++vmp) {
 101         if (vmp->m_dev == NO_DEV) {
 102                 clear_vmnt(vmp);
 103                 return(vmp);
 104         }
 105   }
 106
 107   return(NULL);
 108 }
 109
 110 /*===========================================================================*
 111  *                             find_vmnt                                     *
 112  *===========================================================================*/
 113 struct vmnt *find_vmnt(endpoint_t fs_e)
 114 {
 115 /* Find the vmnt belonging to an FS with endpoint 'fs_e' iff it's in use */
 116   struct vmnt *vp;
 117
 118   for (vp = &vmnt[0]; vp < &vmnt[NR_MNTS]; ++vp)
 119         if (vp->m_fs_e == fs_e && vp->m_dev != NO_DEV)
 120                 return(vp);
 121
 122   return(NULL);
 123 }
 124
 125 /*===========================================================================*
 126  *                             init_vmnts                                    *
 127  *===========================================================================*/
 128 void init_vmnts(void)
 129 {
 130 /* Initialize vmnt table */
 131   struct vmnt *vmp;
 132
 133   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
 134         clear_vmnt(vmp);
 135         tll_init(&vmp->m_lock);
 136   }
 137 }
 138
 139 /*===========================================================================*
 140  *                             is_vmnt_locked                                *
 141  *===========================================================================*/
 142 static int is_vmnt_locked(struct vmnt *vmp)
 143 {
 144   ASSERTVMP(vmp);
 145   return(tll_islocked(&vmp->m_lock) || tll_haspendinglock(&vmp->m_lock));
 146 }
 147
 148 /*===========================================================================*
 149  *                             lock_vmnt                                     *
 150  *===========================================================================*/
 151 int lock_vmnt(struct vmnt *vmp, tll_access_t locktype)
 152 {
 153   int r;
 154   tll_access_t initial_locktype;
 155
 156   ASSERTVMP(vmp);
 157
 158   initial_locktype = (locktype == VMNT_EXCL) ? VMNT_WRITE : locktype;
 159
 160   if (vmp->m_fs_e == who_e) return(EDEADLK);
 161
 162   r = tll_lock(&vmp->m_lock, initial_locktype);
 163
 164   if (r == EBUSY) return(r);
 165
 166   if (initial_locktype != locktype) {
 167         upgrade_vmnt_lock(vmp);
 168   }
 169
 170 #if LOCK_DEBUG
 171   if (locktype == VMNT_READ)
 172         fp->fp_vmnt_rdlocks++;
 173 #endif
 174
 175   return(OK);
 176 }
 177
 178 /*===========================================================================*
 179  *                             vmnt_unmap_by_endpoint                        *
 180  *===========================================================================*/
 181 void vmnt_unmap_by_endpt(endpoint_t proc_e)
 182 {
 183   struct vmnt *vmp;
 184
 185   if ((vmp = find_vmnt(proc_e)) != NULL) {
 186         mark_vmnt_free(vmp);
 187         fs_cancel(vmp);
 188         invalidate_filp_by_endpt(proc_e);
 189         if (vmp->m_mounted_on) {
 190                 /* Only put mount point when it was actually used as mount
 191                  * point. That is, the mount was succesful. */
 192                 put_vnode(vmp->m_mounted_on);
 193         }
 194   }
 195 }
 196
 197 /*===========================================================================*
 198  *                             unlock_vmnt                                   *
 199  *===========================================================================*/
 200 void unlock_vmnt(struct vmnt *vmp)
 201 {
 202   ASSERTVMP(vmp);
 203
 204 #if LOCK_DEBUG
 205   /* Decrease read-only lock counter when not locked as VMNT_WRITE or
 206    * VMNT_EXCL */
 207   if (!tll_locked_by_me(&vmp->m_lock))
 208         fp->fp_vmnt_rdlocks--;
 209 #endif
 210
 211   tll_unlock(&vmp->m_lock);
 212
 213 #if LOCK_DEBUG
 214   assert(!tll_locked_by_me(&vmp->m_lock));
 215 #endif
 216
 217 }
 218
 219 /*===========================================================================*
 220  *                             downgrade_vmnt_lock                           *
 221  *===========================================================================*/
 222 void downgrade_vmnt_lock(struct vmnt *vmp)
 223 {
 224   ASSERTVMP(vmp);
 225   tll_downgrade(&vmp->m_lock);
 226
 227 #if LOCK_DEBUG
 228   /* If we're no longer the owner of a lock, we downgraded to VMNT_READ */
 229   if (!tll_locked_by_me(&vmp->m_lock)) {
 230         fp->fp_vmnt_rdlocks++;
 231   }
 232 #endif
 233 }
 234
 235 /*===========================================================================*
 236  *                             upgrade_vmnt_lock                             *
 237  *===========================================================================*/
 238 void upgrade_vmnt_lock(struct vmnt *vmp)
 239 {
 240   ASSERTVMP(vmp);
 241   tll_upgrade(&vmp->m_lock);
 242 }
 243
 244 /*===========================================================================*
 245  *                             fetch_vmnt_paths                              *
 246  *===========================================================================*/
 247 void fetch_vmnt_paths(void)
 248 {
 249   struct vmnt *vmp;
 250   struct vnode *cur_wd;
 251   char orig_path[PATH_MAX];
 252
 253   cur_wd = fp->fp_wd;
 254
 255   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
 256         if (vmp->m_dev == NO_DEV)
 257                 continue;
 258         if (vmp->m_fs_e == PFS_PROC_NR)
 259                 continue;
 260
 261         strlcpy(orig_path, vmp->m_mount_path, PATH_MAX);
 262
 263         /* Find canonical path */
 264         if (canonical_path(vmp->m_mount_path, fp) != OK) {
 265                 /* We failed to find it (moved somewhere else?). Let's try
 266                  * again by starting at the node on which we are mounted:
 267                  * pretend that node is our working directory and look for the
 268                  * canonical path of the relative path to the mount point
 269                  * (which should be in our 'working directory').
 270                  */
 271                 char *mp;
 272                 int len;
 273
 274                 fp->fp_wd = vmp->m_mounted_on;  /* Change our working dir */
 275
 276                 /* Isolate the mount point name of the full path */
 277                 len = strlen(vmp->m_mount_path);
 278                 if (vmp->m_mount_path[len - 1] == '/') {
 279                         vmp->m_mount_path[len - 1] = '\0';
 280                 }
 281                 mp = strrchr(vmp->m_mount_path, '/');
 282                 strlcpy(vmp->m_mount_path, mp+1, NAME_MAX+1);
 283
 284                 if (canonical_path(vmp->m_mount_path, fp) != OK) {
 285                         /* Our second try failed too. Maybe an FS has crashed
 286                          * and we're missing part of the tree. Revert path.
 287                          */
 288                         strlcpy(vmp->m_mount_path, orig_path, PATH_MAX);
 289                 }
 290                 fp->fp_wd = cur_wd;             /* Revert working dir */
 291         }
 292   }
 293 }