src/filelock.c

   1 /* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc.
   2
   3 This file is part of GNU Emacs.
   4
   5 GNU Emacs is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Emacs is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Emacs; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <signal.h>
  24 #include <config.h>
  25
  26 #ifdef VMS
  27 #include "vms-pwd.h"
  28 #else
  29 #include <pwd.h>
  30 #endif /* not VMS */
  31
  32 #include <sys/file.h>
  33 #ifdef USG
  34 #include <fcntl.h>
  35 #include <string.h>
  36 #endif /* USG */
  37
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41
  42 #include "lisp.h"
  43 #include "buffer.h"
  44
  45 #include <time.h>
  46 #include <errno.h>
  47 #ifndef errno
  48 extern int errno;
  49 #endif
  50
  51 #ifdef CLASH_DETECTION
  52
  53 #include <utmp.h>
  54
  55 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
  56    directory, with link data `user@host.pid'.  This avoids a single
  57    mount (== failure) point for lock files.
  58
  59    When the host in the lock data is the current host, we can check if
  60    the pid is valid with kill.
  61
  62    Otherwise, we could look at a separate file that maps hostnames to
  63    reboot times to see if the remote pid can possibly be valid, since we
  64    don't want Emacs to have to communicate via pipes or sockets or
  65    whatever to other processes, either locally or remotely; rms says
  66    that's too unreliable.  Hence the separate file, which could
  67    theoretically be updated by daemons running separately -- but this
  68    whole idea is unimplemented; in practice, at least in our
  69    environment, it seems such stale locks arise fairly infrequently, and
  70    Emacs' standard methods of dealing with clashes suffice.
  71
  72    We use symlinks instead of normal files because (1) they can be
  73    stored more efficiently on the filesystem, since the kernel knows
  74    they will be small, and (2) all the info about the lock can be read
  75    in a single system call (readlink).  Although we could use regular
  76    files to be useful on old systems lacking symlinks, nowadays
  77    virtually all such systems are probably single-user anyway, so it
  78    didn't seem worth the complication.
  79
  80    Similarly, we don't worry about a possible 14-character limit on
  81    file names, because those are all the same systems that don't have
  82    symlinks.
  83
  84    This is compatible with the locking scheme used by Interleaf (which
  85    has contributed this implementation for Emacs), and was designed by
  86    Ethan Jacobson, Kimbo Mundy, and others.
  87
  88    --karl@cs.umb.edu/karl@hq.ileaf.com.  */
  89
  90 \f
  91 /* Return the time of the last system boot.  */
  92
  93 static time_t boot_time;
  94
  95 static time_t
  96 get_boot_time ()
  97 {
  98 #ifdef BOOT_TIME
  99   struct utmp ut, *utp;
 100
 101   if (boot_time)
 102     return boot_time;
 103
 104   utmpname ("/var/log/wtmp");
 105   ut.ut_type = BOOT_TIME;
 106   utp = getutid (&ut);
 107   endutent ();
 108
 109   if (!utp)
 110     return boot_time = 1;
 111   return boot_time = utp->ut_time;
 112 #else
 113   return 0;
 114 #endif;
 115 }
 116 \f
 117 /* Here is the structure that stores information about a lock.  */
 118
 119 typedef struct
 120 {
 121   char *user;
 122   char *host;
 123   unsigned long pid;
 124   time_t boot_time;
 125 } lock_info_type;
 126
 127 /* When we read the info back, we might need this much more,
 128    enough for decimal representation plus null.  */
 129 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
 130
 131 /* Free the two dynamically-allocated pieces in PTR.  */
 132 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
 133
 134
 135 /* Write the name of the lock file for FN into LFNAME.  Length will be
 136    that of FN plus two more for the leading `.#' plus one for the null.  */
 137 #define MAKE_LOCK_NAME(lock, file) \
 138   (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
 139    fill_in_lock_file_name (lock, (file)))
 140
 141 static void
 142 fill_in_lock_file_name (lockfile, fn)
 143      register char *lockfile;
 144      register Lisp_Object fn;
 145 {
 146   register char *p;
 147
 148   strcpy (lockfile, XSTRING (fn)->data);
 149
 150   /* Shift the nondirectory part of the file name (including the null)
 151      right two characters.  Here is one of the places where we'd have to
 152      do something to support 14-character-max file names.  */
 153   for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
 154     p[2] = *p;
 155
 156   /* Insert the `.#'.  */
 157   p[1] = '.';
 158   p[2] = '#';
 159 }
 160
 161 /* Lock the lock file named LFNAME.
 162    If FORCE is nonzero, we do so even if it is already locked.
 163    Return 1 if successful, 0 if not.  */
 164
 165 static int
 166 lock_file_1 (lfname, force)
 167      char *lfname;
 168      int force;
 169 {
 170   register int err;
 171   time_t boot_time;
 172   char *user_name;
 173   char *host_name;
 174   char *lock_info_str;
 175
 176   if (STRINGP (Fuser_login_name (Qnil)))
 177     user_name = (char *)XSTRING (Fuser_login_name (Qnil))->data;
 178   else
 179     user_name = "";
 180   if (STRINGP (Fsystem_name ()))
 181     host_name = (char *)XSTRING (Fsystem_name ())->data;
 182   else
 183     host_name = "";
 184   lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
 185                                   + LOCK_PID_MAX + 5);
 186
 187   boot_time = get_boot_time ();
 188   if (boot_time)
 189     sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
 190              (unsigned long) getpid (), (unsigned long) boot_time);
 191   else
 192     sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
 193              (unsigned long) getpid ());
 194
 195   err = symlink (lock_info_str, lfname);
 196   if (errno == EEXIST && force)
 197     {
 198       unlink (lfname);
 199       err = symlink (lock_info_str, lfname);
 200     }
 201
 202   return err == 0;
 203 }
 204
 205
 206 \f
 207 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
 208    1 if another process owns it (and set OWNER (if non-null) to info),
 209    2 if the current process owns it,
 210    or -1 if something is wrong with the locking mechanism.  */
 211
 212 static int
 213 current_lock_owner (owner, lfname)
 214      lock_info_type *owner;
 215      char *lfname;
 216 {
 217 #ifndef index
 218   extern char *rindex (), *index ();
 219 #endif
 220   int o, p, len, ret;
 221   int local_owner = 0;
 222   char *at, *dot, *colon;
 223   char *lfinfo = 0;
 224   int bufsize = 50;
 225   /* Read arbitrarily-long contents of symlink.  Similar code in
 226      file-symlink-p in fileio.c.  */
 227   do
 228     {
 229       bufsize *= 2;
 230       lfinfo = (char *) xrealloc (lfinfo, bufsize);
 231       len = readlink (lfname, lfinfo, bufsize);
 232     }
 233   while (len >= bufsize);
 234
 235   /* If nonexistent lock file, all is well; otherwise, got strange error. */
 236   if (len == -1)
 237     {
 238       xfree (lfinfo);
 239       return errno == ENOENT ? 0 : -1;
 240     }
 241
 242   /* Link info exists, so `len' is its length.  Null terminate.  */
 243   lfinfo[len] = 0;
 244
 245   /* Even if the caller doesn't want the owner info, we still have to
 246      read it to determine return value, so allocate it.  */
 247   if (!owner)
 248     {
 249       owner = (lock_info_type *) alloca (sizeof (lock_info_type));
 250       local_owner = 1;
 251     }
 252
 253   /* Parse USER@HOST.PID:BOOT_TIME.  If can't parse, return -1.  */
 254   /* The USER is everything before the first @.  */
 255   at = index (lfinfo, '@');
 256   dot = rindex (lfinfo, '.');
 257   if (!at || !dot)
 258     {
 259       xfree (lfinfo);
 260       return -1;
 261     }
 262   len = at - lfinfo;
 263   owner->user = (char *) xmalloc (len + 1);
 264   strncpy (owner->user, lfinfo, len);
 265   owner->user[len] = 0;
 266
 267   /* The PID is everything from the last `.' to the `:'.  */
 268   owner->pid = atoi (dot + 1);
 269   colon = dot;
 270   while (*colon && *colon != ':')
 271     colon++;
 272   /* After the `:', if there is one, comes the boot time.  */
 273   if (*colon == ':')
 274     owner->boot_time = atoi (colon + 1);
 275   else
 276     owner->boot_time = 0;
 277
 278   /* The host is everything in between.  */
 279   len = dot - at - 1;
 280   owner->host = (char *) xmalloc (len + 1);
 281   strncpy (owner->host, at + 1, len);
 282   owner->host[len] = 0;
 283
 284   /* We're done looking at the link info.  */
 285   xfree (lfinfo);
 286
 287   /* On current host?  */
 288   if (STRINGP (Fsystem_name ())
 289       && strcmp (owner->host, XSTRING (Fsystem_name ())->data) == 0)
 290     {
 291       if (owner->pid == getpid ())
 292         ret = 2; /* We own it.  */
 293       else if (owner->pid > 0
 294                && (kill (owner->pid, 0) >= 0 || errno == EPERM)
 295                && (owner->boot_time == 0
 296                    || owner->boot_time == get_boot_time ()))
 297         ret = 1; /* An existing process on this machine owns it.  */
 298       /* The owner process is dead or has a strange pid (<=0), so try to
 299          zap the lockfile.  */
 300       else if (unlink (lfname) < 0)
 301         ret = -1;
 302       else
 303         ret = 0;
 304     }
 305   else
 306     { /* If we wanted to support the check for stale locks on remote machines,
 307          here's where we'd do it.  */
 308       ret = 1;
 309     }
 310
 311   /* Avoid garbage.  */
 312   if (local_owner || ret <= 0)
 313     {
 314       FREE_LOCK_INFO (*owner);
 315     }
 316   return ret;
 317 }
 318
 319 \f
 320 /* Lock the lock named LFNAME if possible.
 321    Return 0 in that case.
 322    Return positive if some other process owns the lock, and info about
 323      that process in CLASHER.
 324    Return -1 if cannot lock for any other reason.  */
 325
 326 static int
 327 lock_if_free (clasher, lfname)
 328      lock_info_type *clasher;
 329      register char *lfname;
 330 {
 331   if (lock_file_1 (lfname, 0) == 0)
 332     {
 333       int locker;
 334
 335       if (errno != EEXIST)
 336         return -1;
 337
 338       locker = current_lock_owner (clasher, lfname);
 339       if (locker == 2)
 340         {
 341           FREE_LOCK_INFO (*clasher);
 342           return 0;   /* We ourselves locked it.  */
 343         }
 344       else if (locker == 1)
 345         return 1;  /* Someone else has it.  */
 346
 347       return -1; /* Something's wrong.  */
 348     }
 349   return 0;
 350 }
 351
 352 /* lock_file locks file FN,
 353    meaning it serves notice on the world that you intend to edit that file.
 354    This should be done only when about to modify a file-visiting
 355    buffer previously unmodified.
 356    Do not (normally) call this for a buffer already modified,
 357    as either the file is already locked, or the user has already
 358    decided to go ahead without locking.
 359
 360    When this returns, either the lock is locked for us,
 361    or the user has said to go ahead without locking.
 362
 363    If the file is locked by someone else, this calls
 364    ask-user-about-lock (a Lisp function) with two arguments,
 365    the file name and info about the user who did the locking.
 366    This function can signal an error, or return t meaning
 367    take away the lock, or return nil meaning ignore the lock.  */
 368
 369 void
 370 lock_file (fn)
 371     register Lisp_Object fn;
 372 {
 373   register Lisp_Object attack, orig_fn;
 374   register char *lfname, *locker;
 375   lock_info_type lock_info;
 376
 377   orig_fn = fn;
 378   fn = Fexpand_file_name (fn, Qnil);
 379
 380   /* Create the name of the lock-file for file fn */
 381   MAKE_LOCK_NAME (lfname, fn);
 382
 383   /* See if this file is visited and has changed on disk since it was
 384      visited.  */
 385   {
 386     register Lisp_Object subject_buf;
 387     subject_buf = get_truename_buffer (orig_fn);
 388     if (!NILP (subject_buf)
 389         && NILP (Fverify_visited_file_modtime (subject_buf))
 390         && !NILP (Ffile_exists_p (fn)))
 391       call1 (intern ("ask-user-about-supersession-threat"), fn);
 392   }
 393
 394   /* Try to lock the lock. */
 395   if (lock_if_free (&lock_info, lfname) <= 0)
 396     /* Return now if we have locked it, or if lock creation failed */
 397     return;
 398
 399   /* Else consider breaking the lock */
 400   locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
 401                             + LOCK_PID_MAX + 9);
 402   sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
 403            lock_info.pid);
 404   FREE_LOCK_INFO (lock_info);
 405
 406   attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
 407   if (!NILP (attack))
 408     /* User says take the lock */
 409     {
 410       lock_file_1 (lfname, 1);
 411       return;
 412     }
 413   /* User says ignore the lock */
 414 }
 415
 416 void
 417 unlock_file (fn)
 418      register Lisp_Object fn;
 419 {
 420   register char *lfname;
 421
 422   fn = Fexpand_file_name (fn, Qnil);
 423
 424   MAKE_LOCK_NAME (lfname, fn);
 425
 426   if (current_lock_owner (0, lfname) == 2)
 427     unlink (lfname);
 428 }
 429
 430 void
 431 unlock_all_files ()
 432 {
 433   register Lisp_Object tail;
 434   register struct buffer *b;
 435
 436   for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
 437     {
 438       b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
 439       if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 440         {
 441           register char *lfname;
 442
 443           MAKE_LOCK_NAME (lfname, b->file_truename);
 444
 445           if (current_lock_owner (0, lfname) == 2)
 446             unlink (lfname);
 447         }
 448     }
 449 }
 450 \f
 451 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
 452   0, 1, 0,
 453   "Lock FILE, if current buffer is modified.\n\
 454 FILE defaults to current buffer's visited file,\n\
 455 or else nothing is done if current buffer isn't visiting a file.")
 456   (file)
 457      Lisp_Object file;
 458 {
 459   if (NILP (file))
 460     file = current_buffer->file_truename;
 461   else
 462     CHECK_STRING (file, 0);
 463   if (SAVE_MODIFF < MODIFF
 464       && !NILP (file))
 465     lock_file (file);
 466   return Qnil;
 467 }
 468
 469 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
 470   0, 0, 0,
 471  "Unlock the file visited in the current buffer,\n\
 472 if it should normally be locked.")
 473   ()
 474 {
 475   if (SAVE_MODIFF < MODIFF
 476       && STRINGP (current_buffer->file_truename))
 477     unlock_file (current_buffer->file_truename);
 478   return Qnil;
 479 }
 480
 481 /* Unlock the file visited in buffer BUFFER.  */
 482
 483 void
 484 unlock_buffer (buffer)
 485      struct buffer *buffer;
 486 {
 487   if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
 488       && STRINGP (buffer->file_truename))
 489     unlock_file (buffer->file_truename);
 490 }
 491
 492 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
 493   "Return nil if the FILENAME is not locked,\n\
 494 t if it is locked by you, else a string of the name of the locker.")
 495   (filename)
 496   Lisp_Object filename;
 497 {
 498   Lisp_Object ret;
 499   register char *lfname;
 500   int owner;
 501   lock_info_type locker;
 502
 503   filename = Fexpand_file_name (filename, Qnil);
 504
 505   MAKE_LOCK_NAME (lfname, filename);
 506
 507   owner = current_lock_owner (&locker, lfname);
 508   if (owner <= 0)
 509     ret = Qnil;
 510   else if (owner == 2)
 511     ret = Qt;
 512   else
 513     ret = build_string (locker.user);
 514
 515   if (owner > 0)
 516     FREE_LOCK_INFO (locker);
 517
 518   return ret;
 519 }
 520 \f
 521 /* Initialization functions.  */
 522
 523 void
 524 syms_of_filelock ()
 525 {
 526   defsubr (&Sunlock_buffer);
 527   defsubr (&Slock_buffer);
 528   defsubr (&Sfile_locked_p);
 529 }
 530
 531 #endif /* CLASH_DETECTION */