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 "fproc.h"
  10
  11 static int is_vmnt_locked(struct vmnt *vmp);
  12 static void clear_vmnt(struct vmnt *vmp);
  13
  14 /* Is vmp pointer reasonable? */
  15 #define SANEVMP(v) ((((v) >= &vmnt[0] && (v) < &vmnt[NR_MNTS])))
  16 #define BADVMP(v, f, l) printf("%s:%d: bad vmp %p\n", f, l, v)
  17 /* vp check that panics */
  18 #define ASSERTVMP(v) if(!SANEVMP(v)) { \
  19         BADVMP(v, __FILE__, __LINE__); panic("bad vmp"); }
  20
  21 #if LOCK_DEBUG
  22 /*===========================================================================*
  23  *                              check_vmnt_locks_by_me                       *
  24  *===========================================================================*/
  25 void check_vmnt_locks_by_me(struct fproc *rfp)
  26 {
  27 /* Check whether this thread still has locks held on vmnts */
  28   struct vmnt *vmp;
  29
  30   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
  31         if (tll_locked_by_me(&vmp->m_lock))
  32                 panic("Thread %d still holds vmnt lock on vmp %p call_nr=%d\n",
  33                       mthread_self(), vmp, job_call_nr);
  34   }
  35
  36   if (rfp->fp_vmnt_rdlocks != 0)
  37         panic("Thread %d still holds read locks on a vmnt (%d) call_nr=%d\n",
  38               mthread_self(), rfp->fp_vmnt_rdlocks, job_call_nr);
  39 }
  40 #endif
  41
  42 /*===========================================================================*
  43  *                              check_vmnt_locks                             *
  44  *===========================================================================*/
  45 void check_vmnt_locks()
  46 {
  47   struct vmnt *vmp;
  48   int count = 0;
  49
  50   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++)
  51         if (is_vmnt_locked(vmp)) {
  52                 count++;
  53                 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);
  54         }
  55
  56   if (count) panic("%d locked vmnts\n", count);
  57 #if 0
  58   printf("check_vmnt_locks OK\n");
  59 #endif
  60 }
  61
  62 /*===========================================================================*
  63  *                             mark_vmnt_free                                *
  64  *===========================================================================*/
  65 void mark_vmnt_free(struct vmnt *vmp)
  66 {
  67   ASSERTVMP(vmp);
  68
  69   vmp->m_fs_e = NONE;
  70   vmp->m_dev = NO_DEV;
  71 }
  72
  73 /*===========================================================================*
  74  *                             clear_vmnt                                    *
  75  *===========================================================================*/
  76 static void clear_vmnt(struct vmnt *vmp)
  77 {
  78 /* Reset vmp to initial parameters */
  79   ASSERTVMP(vmp);
  80
  81   vmp->m_fs_e = NONE;
  82   vmp->m_dev = NO_DEV;
  83   vmp->m_flags = 0;
  84   vmp->m_mounted_on = NULL;
  85   vmp->m_root_node = NULL;
  86   vmp->m_label[0] = '\0';
  87   vmp->m_comm.c_max_reqs = 1;
  88   vmp->m_comm.c_cur_reqs = 0;
  89   vmp->m_comm.c_req_queue = NULL;
  90 }
  91
  92 /*===========================================================================*
  93  *                             get_free_vmnt                                 *
  94  *===========================================================================*/
  95 struct vmnt *get_free_vmnt(void)
  96 {
  97   struct vmnt *vmp;
  98
  99   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; ++vmp) {
 100         if (vmp->m_dev == NO_DEV) {
 101                 clear_vmnt(vmp);
 102                 return(vmp);
 103         }
 104   }
 105
 106   return(NULL);
 107 }
 108
 109 /*===========================================================================*
 110  *                             find_vmnt                                     *
 111  *===========================================================================*/
 112 struct vmnt *find_vmnt(endpoint_t fs_e)
 113 {
 114 /* Find the vmnt belonging to an FS with endpoint 'fs_e' iff it's in use */
 115   struct vmnt *vp;
 116
 117   for (vp = &vmnt[0]; vp < &vmnt[NR_MNTS]; ++vp)
 118         if (vp->m_fs_e == fs_e && vp->m_dev != NO_DEV)
 119                 return(vp);
 120
 121   return(NULL);
 122 }
 123
 124 /*===========================================================================*
 125  *                             init_vmnts                                    *
 126  *===========================================================================*/
 127 void init_vmnts(void)
 128 {
 129 /* Initialize vmnt table */
 130   struct vmnt *vmp;
 131
 132   for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) {
 133         clear_vmnt(vmp);
 134         tll_init(&vmp->m_lock);
 135   }
 136 }
 137
 138 /*===========================================================================*
 139  *                             is_vmnt_locked                                *
 140  *===========================================================================*/
 141 static int is_vmnt_locked(struct vmnt *vmp)
 142 {
 143   ASSERTVMP(vmp);
 144   return(tll_islocked(&vmp->m_lock) || tll_haspendinglock(&vmp->m_lock));
 145 }
 146
 147 /*===========================================================================*
 148  *                             lock_vmnt                                     *
 149  *===========================================================================*/
 150 int lock_vmnt(struct vmnt *vmp, tll_access_t locktype)
 151 {
 152   int r;
 153   tll_access_t initial_locktype;
 154
 155   ASSERTVMP(vmp);
 156
 157   initial_locktype = (locktype == VMNT_EXCL) ? VMNT_WRITE : locktype;
 158
 159   if (vmp->m_fs_e == who_e) return(EDEADLK);
 160
 161   r = tll_lock(&vmp->m_lock, initial_locktype);
 162
 163   if (r == EBUSY) return(r);
 164
 165   if (initial_locktype != locktype) {
 166         tll_upgrade(&vmp->m_lock);
 167   }
 168
 169 #if LOCK_DEBUG
 170   if (locktype == VMNT_READ)
 171         fp->fp_vmnt_rdlocks++;
 172 #endif
 173
 174   return(OK);
 175 }
 176
 177 /*===========================================================================*
 178  *                             vmnt_unmap_by_endpoint                        *
 179  *===========================================================================*/
 180 void vmnt_unmap_by_endpt(endpoint_t proc_e)
 181 {
 182   struct vmnt *vmp;
 183
 184   if ((vmp = find_vmnt(proc_e)) != NULL) {
 185         mark_vmnt_free(vmp);
 186         fs_cancel(vmp);
 187         invalidate_filp_by_endpt(proc_e);
 188         if (vmp->m_mounted_on) {
 189                 /* Only put mount point when it was actually used as mount
 190                  * point. That is, the mount was succesful. */
 191                 put_vnode(vmp->m_mounted_on);
 192         }
 193   }
 194 }
 195
 196 /*===========================================================================*
 197  *                             unlock_vmnt                                   *
 198  *===========================================================================*/
 199 void unlock_vmnt(struct vmnt *vmp)
 200 {
 201   ASSERTVMP(vmp);
 202
 203 #if LOCK_DEBUG
 204   /* Decrease read-only lock counter when not locked as VMNT_WRITE or
 205    * VMNT_EXCL */
 206   if (!tll_locked_by_me(&vmp->m_lock))
 207         fp->fp_vmnt_rdlocks--;
 208 #endif
 209
 210   tll_unlock(&vmp->m_lock);
 211
 212 #if LOCK_DEBUG
 213   assert(!tll_locked_by_me(&vmp->m_lock));
 214 #endif
 215
 216 }