minix/servers/vfs/lock.c

   1 /* This file handles advisory file locking as required by POSIX.
   2  *
   3  * The entry points into this file are
   4  *   lock_op:   perform locking operations for FCNTL system call
   5  *   lock_revive: revive processes when a lock is released
   6  */
   7
   8 #include "fs.h"
   9 #include <minix/com.h>
  10 #include <minix/u64.h>
  11 #include <fcntl.h>
  12 #include <unistd.h>
  13 #include <assert.h>
  14 #include "file.h"
  15 #include "lock.h"
  16 #include "vnode.h"
  17
  18 /*===========================================================================*
  19  *                              lock_op                                      *
  20  *===========================================================================*/
  21 int lock_op(int fd, int req, vir_bytes arg)
  22 {
  23 /* Perform the advisory locking required by POSIX. */
  24   int r, ltype, i, conflict = 0, unlocking = 0;
  25   mode_t mo;
  26   off_t first, last;
  27   struct filp *f;
  28   struct flock flock;
  29   struct file_lock *flp, *flp2, *empty;
  30
  31   assert(req == F_GETLK || req == F_SETLK || req == F_SETLKW);
  32
  33   f = fp->fp_filp[fd];
  34   assert(f != NULL);
  35
  36   /* Fetch the flock structure from user space. */
  37   r = sys_datacopy_wrapper(who_e, arg, VFS_PROC_NR, (vir_bytes)&flock,
  38       sizeof(flock));
  39   if (r != OK) return(EINVAL);
  40
  41   /* Make some error checks. */
  42   ltype = flock.l_type;
  43   mo = f->filp_mode;
  44   if (ltype != F_UNLCK && ltype != F_RDLCK && ltype != F_WRLCK) return(EINVAL);
  45   if (req == F_GETLK && ltype == F_UNLCK) return(EINVAL);
  46   if (!S_ISREG(f->filp_vno->v_mode) && !S_ISBLK(f->filp_vno->v_mode))
  47         return(EINVAL);
  48   if (req != F_GETLK && ltype == F_RDLCK && (mo & R_BIT) == 0) return(EBADF);
  49   if (req != F_GETLK && ltype == F_WRLCK && (mo & W_BIT) == 0) return(EBADF);
  50
  51   /* Compute the first and last bytes in the lock region. */
  52   switch (flock.l_whence) {
  53     case SEEK_SET:      first = 0; break;
  54     case SEEK_CUR:      first = f->filp_pos; break;
  55     case SEEK_END:      first = f->filp_vno->v_size; break;
  56     default:    return(EINVAL);
  57   }
  58
  59   /* Check for overflow. */
  60   if (((long) flock.l_start > 0) && ((first + flock.l_start) < first))
  61         return(EINVAL);
  62   if (((long) flock.l_start < 0) && ((first + flock.l_start) > first))
  63         return(EINVAL);
  64   first = first + flock.l_start;
  65   last = first + flock.l_len - 1;
  66   if (flock.l_len == 0) last = MAX_FILE_POS;
  67   if (last < first) return(EINVAL);
  68
  69   /* Check if this region conflicts with any existing lock. */
  70   empty = NULL;
  71   for (flp = &file_lock[0]; flp < &file_lock[NR_LOCKS]; flp++) {
  72         if (flp->lock_type == 0) {
  73                 if (empty == NULL) empty = flp;
  74                 continue;       /* 0 means unused slot */
  75         }
  76         if (flp->lock_vnode != f->filp_vno) continue;   /* different file */
  77         if (last < flp->lock_first) continue;   /* new one is in front */
  78         if (first > flp->lock_last) continue;   /* new one is afterwards */
  79         if (ltype == F_RDLCK && flp->lock_type == F_RDLCK) continue;
  80         if (ltype != F_UNLCK && flp->lock_pid == fp->fp_pid) continue;
  81
  82         /* There might be a conflict.  Process it. */
  83         conflict = 1;
  84         if (req == F_GETLK) break;
  85
  86         /* If we are trying to set a lock, it just failed. */
  87         if (ltype == F_RDLCK || ltype == F_WRLCK) {
  88                 if (req == F_SETLK) {
  89                         /* For F_SETLK, just report back failure. */
  90                         return(EAGAIN);
  91                 } else {
  92                         /* For F_SETLKW, suspend the process. */
  93                         fp->fp_flock.fd = fd;
  94                         fp->fp_flock.cmd = req;
  95                         fp->fp_flock.arg = arg;
  96                         suspend(FP_BLOCKED_ON_FLOCK);
  97                         return(SUSPEND);
  98                 }
  99         }
 100
 101         /* We are clearing a lock and we found something that overlaps. */
 102         unlocking = 1;
 103         if (first <= flp->lock_first && last >= flp->lock_last) {
 104                 flp->lock_type = 0;     /* mark slot as unused */
 105                 nr_locks--;             /* number of locks is now 1 less */
 106                 continue;
 107         }
 108
 109         /* Part of a locked region has been unlocked. */
 110         if (first <= flp->lock_first) {
 111                 flp->lock_first = last + 1;
 112                 continue;
 113         }
 114
 115         if (last >= flp->lock_last) {
 116                 flp->lock_last = first - 1;
 117                 continue;
 118         }
 119
 120         /* Bad luck. A lock has been split in two by unlocking the middle. */
 121         if (nr_locks == NR_LOCKS) return(ENOLCK);
 122         for (i = 0; i < NR_LOCKS; i++)
 123                 if (file_lock[i].lock_type == 0) break;
 124         flp2 = &file_lock[i];
 125         flp2->lock_type = flp->lock_type;
 126         flp2->lock_pid = flp->lock_pid;
 127         flp2->lock_vnode = flp->lock_vnode;
 128         flp2->lock_first = last + 1;
 129         flp2->lock_last = flp->lock_last;
 130         flp->lock_last = first - 1;
 131         nr_locks++;
 132   }
 133   if (unlocking) lock_revive();
 134
 135   if (req == F_GETLK) {
 136         if (conflict) {
 137                 /* GETLK and conflict. Report on the conflicting lock. */
 138                 flock.l_type = flp->lock_type;
 139                 flock.l_whence = SEEK_SET;
 140                 flock.l_start = flp->lock_first;
 141                 flock.l_len = flp->lock_last - flp->lock_first + 1;
 142                 flock.l_pid = flp->lock_pid;
 143
 144         } else {
 145                 /* It is GETLK and there is no conflict. */
 146                 flock.l_type = F_UNLCK;
 147         }
 148
 149         /* Copy the flock structure back to the caller. */
 150         r = sys_datacopy_wrapper(VFS_PROC_NR, (vir_bytes)&flock, who_e, arg,
 151             sizeof(flock));
 152         return(r);
 153   }
 154
 155   if (ltype == F_UNLCK) return(OK);     /* unlocked a region with no locks */
 156
 157   /* There is no conflict.  If space exists, store new lock in the table. */
 158   if (empty == NULL) return(ENOLCK);    /* table full */
 159   empty->lock_type = ltype;
 160   empty->lock_pid = fp->fp_pid;
 161   empty->lock_vnode = f->filp_vno;
 162   empty->lock_first = first;
 163   empty->lock_last = last;
 164   nr_locks++;
 165   return(OK);
 166 }
 167
 168
 169 /*===========================================================================*
 170  *                              lock_revive                                  *
 171  *===========================================================================*/
 172 void
 173 lock_revive(void)
 174 {
 175 /* Go find all the processes that are waiting for any kind of lock and
 176  * revive them all.  The ones that are still blocked will block again when
 177  * they run.  The others will complete.  This strategy is a space-time
 178  * tradeoff.  Figuring out exactly which ones to unblock now would take
 179  * extra code, and the only thing it would win would be some performance in
 180  * extremely rare circumstances (namely, that somebody actually used
 181  * locking).
 182  */
 183
 184   struct fproc *fptr;
 185
 186   for (fptr = &fproc[0]; fptr < &fproc[NR_PROCS]; fptr++){
 187         if (fptr->fp_pid == PID_FREE) continue;
 188         if (fptr->fp_blocked_on == FP_BLOCKED_ON_FLOCK) {
 189                 revive(fptr->fp_endpoint, 0);
 190         }
 191   }
 192 }