src/filelock.c

   1 /* Lock files for editing.
   2    Copyright (C) 1985, 86, 87, 93, 94, 96, 98, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <signal.h>
  25 #include <config.h>
  26 #ifdef HAVE_STDLIB_H
  27 #include <stdlib.h>
  28 #endif
  29
  30 #ifdef VMS
  31 #include "vms-pwd.h"
  32 #else
  33 #include <pwd.h>
  34 #endif /* not VMS */
  35
  36 #include <sys/file.h>
  37 #ifdef USG
  38 #include <fcntl.h>
  39 #include <string.h>
  40 #endif /* USG */
  41
  42 #ifdef HAVE_UNISTD_H
  43 #include <unistd.h>
  44 #endif
  45
  46 #ifdef __FreeBSD__
  47 #include <sys/time.h>
  48 #include <sys/types.h>
  49 #include <sys/sysctl.h>
  50 #endif /* __FreeBSD__ */
  51
  52 #include "lisp.h"
  53 #include "buffer.h"
  54 #include "charset.h"
  55 #include "coding.h"
  56 #include "systime.h"
  57
  58 #include <time.h>
  59 #include <errno.h>
  60 #ifndef errno
  61 extern int errno;
  62 #endif
  63
  64 #ifdef CLASH_DETECTION
  65
  66 #include <utmp.h>
  67
  68 /* A file whose last-modified time is just after the most recent boot.
  69    Define this to be NULL to disable checking for this file.  */
  70 #ifndef BOOT_TIME_FILE
  71 #define BOOT_TIME_FILE "/var/run/random-seed"
  72 #endif
  73
  74 #ifndef WTMP_FILE
  75 #define WTMP_FILE "/var/log/wtmp"
  76 #endif
  77
  78 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
  79    directory, with link data `user@host.pid'.  This avoids a single
  80    mount (== failure) point for lock files.
  81
  82    When the host in the lock data is the current host, we can check if
  83    the pid is valid with kill.
  84
  85    Otherwise, we could look at a separate file that maps hostnames to
  86    reboot times to see if the remote pid can possibly be valid, since we
  87    don't want Emacs to have to communicate via pipes or sockets or
  88    whatever to other processes, either locally or remotely; rms says
  89    that's too unreliable.  Hence the separate file, which could
  90    theoretically be updated by daemons running separately -- but this
  91    whole idea is unimplemented; in practice, at least in our
  92    environment, it seems such stale locks arise fairly infrequently, and
  93    Emacs' standard methods of dealing with clashes suffice.
  94
  95    We use symlinks instead of normal files because (1) they can be
  96    stored more efficiently on the filesystem, since the kernel knows
  97    they will be small, and (2) all the info about the lock can be read
  98    in a single system call (readlink).  Although we could use regular
  99    files to be useful on old systems lacking symlinks, nowadays
 100    virtually all such systems are probably single-user anyway, so it
 101    didn't seem worth the complication.
 102
 103    Similarly, we don't worry about a possible 14-character limit on
 104    file names, because those are all the same systems that don't have
 105    symlinks.
 106
 107    This is compatible with the locking scheme used by Interleaf (which
 108    has contributed this implementation for Emacs), and was designed by
 109    Ethan Jacobson, Kimbo Mundy, and others.
 110
 111    --karl@cs.umb.edu/karl@hq.ileaf.com.  */
 112
 113 \f
 114 /* Return the time of the last system boot.  */
 115
 116 static time_t boot_time;
 117 static int boot_time_initialized;
 118
 119 extern Lisp_Object Vshell_file_name;
 120
 121 static time_t
 122 get_boot_time ()
 123 {
 124   int counter;
 125
 126   if (boot_time_initialized)
 127     return boot_time;
 128   boot_time_initialized = 1;
 129
 130 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
 131   {
 132     int mib[2];
 133     size_t size;
 134     struct timeval boottime_val;
 135
 136     mib[0] = CTL_KERN;
 137     mib[1] = KERN_BOOTTIME;
 138     size = sizeof (boottime_val);
 139
 140     if (sysctl (mib, 2, &boottime_val, &size, NULL, 0) >= 0)
 141       {
 142         boot_time = boottime_val.tv_sec;
 143         return boot_time;
 144       }
 145   }
 146 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
 147
 148   if (BOOT_TIME_FILE)
 149     {
 150       struct stat st;
 151       if (stat (BOOT_TIME_FILE, &st) == 0)
 152         {
 153           boot_time = st.st_mtime;
 154           return boot_time;
 155         }
 156     }
 157
 158 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
 159 #ifndef CANNOT_DUMP
 160   /* The utmp routines maintain static state.
 161      Don't touch that state unless we are initialized,
 162      since it might not survive dumping.  */
 163   if (! initialized)
 164     return boot_time;
 165 #endif /* not CANNOT_DUMP */
 166
 167   /* Try to get boot time from utmp before wtmp,
 168      since utmp is typically much smaller than wtmp.
 169      Passing a null pointer causes get_boot_time_1
 170      to inspect the default file, namely utmp.  */
 171   get_boot_time_1 ((char *) 0, 0);
 172   if (boot_time)
 173     return boot_time;
 174
 175   /* Try to get boot time from the current wtmp file.  */
 176   get_boot_time_1 (WTMP_FILE, 1);
 177
 178   /* If we did not find a boot time in wtmp, look at wtmp, and so on.  */
 179   for (counter = 0; counter < 20 && ! boot_time; counter++)
 180     {
 181       char cmd_string[100];
 182       Lisp_Object tempname, filename;
 183       int delete_flag = 0;
 184
 185       filename = Qnil;
 186
 187       sprintf (cmd_string, "%s.%d", WTMP_FILE, counter);
 188       tempname = build_string (cmd_string);
 189       if (! NILP (Ffile_exists_p (tempname)))
 190         filename = tempname;
 191       else
 192         {
 193           sprintf (cmd_string, "%s.%d.gz", WTMP_FILE, counter);
 194           tempname = build_string (cmd_string);
 195           if (! NILP (Ffile_exists_p (tempname)))
 196             {
 197               Lisp_Object args[6];
 198               tempname = Fmake_temp_name (build_string ("wtmp"));
 199               args[0] = Vshell_file_name;
 200               args[1] = Qnil;
 201               args[2] = Qnil;
 202               args[3] = Qnil;
 203               args[4] = build_string ("-c");
 204               sprintf (cmd_string, "gunzip < %s.%d.gz > %s",
 205                        WTMP_FILE, counter, XSTRING (tempname)->data);
 206               args[5] = build_string (cmd_string);
 207               Fcall_process (6, args);
 208               filename = tempname;
 209               delete_flag = 1;
 210             }
 211         }
 212
 213       if (! NILP (filename))
 214         {
 215           get_boot_time_1 (XSTRING (filename)->data, 1);
 216           if (delete_flag)
 217             unlink (XSTRING (filename)->data);
 218         }
 219     }
 220
 221   return boot_time;
 222 #else
 223   return 0;
 224 #endif
 225 }
 226
 227 #ifdef BOOT_TIME
 228 /* Try to get the boot time from wtmp file FILENAME.
 229    This succeeds if that file contains a reboot record.
 230
 231    If FILENAME is zero, use the same file as before;
 232    if no FILENAME has ever been specified, this is the utmp file.
 233    Use the newest reboot record if NEWEST is nonzero,
 234    the first reboot record otherwise.
 235    Ignore all reboot records on or before BOOT_TIME.
 236    Success is indicated by setting BOOT_TIME to a larger value.  */
 237
 238 get_boot_time_1 (filename, newest)
 239      char *filename;
 240      int newest;
 241 {
 242   struct utmp ut, *utp;
 243   int desc;
 244
 245   if (filename)
 246     {
 247       /* On some versions of IRIX, opening a nonexistent file name
 248          is likely to crash in the utmp routines.  */
 249       desc = open (filename, O_RDONLY);
 250       if (desc < 0)
 251         return;
 252
 253       close (desc);
 254
 255       utmpname (filename);
 256     }
 257
 258   setutent ();
 259
 260   while (1)
 261     {
 262       /* Find the next reboot record.  */
 263       ut.ut_type = BOOT_TIME;
 264       utp = getutid (&ut);
 265       if (! utp)
 266         break;
 267       /* Compare reboot times and use the newest one.  */
 268       if (utp->ut_time > boot_time)
 269         {
 270           boot_time = utp->ut_time;
 271           if (! newest)
 272             break;
 273         }
 274       /* Advance on element in the file
 275          so that getutid won't repeat the same one.  */
 276       utp = getutent ();
 277       if (! utp)
 278         break;
 279     }
 280   endutent ();
 281 }
 282 #endif /* BOOT_TIME */
 283 \f
 284 /* Here is the structure that stores information about a lock.  */
 285
 286 typedef struct
 287 {
 288   char *user;
 289   char *host;
 290   unsigned long pid;
 291   time_t boot_time;
 292 } lock_info_type;
 293
 294 /* When we read the info back, we might need this much more,
 295    enough for decimal representation plus null.  */
 296 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
 297
 298 /* Free the two dynamically-allocated pieces in PTR.  */
 299 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
 300
 301
 302 /* Write the name of the lock file for FN into LFNAME.  Length will be
 303    that of FN plus two more for the leading `.#' plus one for the null.  */
 304 #define MAKE_LOCK_NAME(lock, file) \
 305   (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
 306    fill_in_lock_file_name (lock, (file)))
 307
 308 static void
 309 fill_in_lock_file_name (lockfile, fn)
 310      register char *lockfile;
 311      register Lisp_Object fn;
 312 {
 313   register char *p;
 314
 315   strcpy (lockfile, XSTRING (fn)->data);
 316
 317   /* Shift the nondirectory part of the file name (including the null)
 318      right two characters.  Here is one of the places where we'd have to
 319      do something to support 14-character-max file names.  */
 320   for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
 321     p[2] = *p;
 322
 323   /* Insert the `.#'.  */
 324   p[1] = '.';
 325   p[2] = '#';
 326 }
 327
 328 /* Lock the lock file named LFNAME.
 329    If FORCE is nonzero, we do so even if it is already locked.
 330    Return 1 if successful, 0 if not.  */
 331
 332 static int
 333 lock_file_1 (lfname, force)
 334      char *lfname;
 335      int force;
 336 {
 337   register int err;
 338   time_t boot_time;
 339   char *user_name;
 340   char *host_name;
 341   char *lock_info_str;
 342
 343   if (STRINGP (Fuser_login_name (Qnil)))
 344     user_name = (char *)XSTRING (Fuser_login_name (Qnil))->data;
 345   else
 346     user_name = "";
 347   if (STRINGP (Fsystem_name ()))
 348     host_name = (char *)XSTRING (Fsystem_name ())->data;
 349   else
 350     host_name = "";
 351   lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
 352                                   + LOCK_PID_MAX + 5);
 353
 354   boot_time = get_boot_time ();
 355   if (boot_time)
 356     sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
 357              (unsigned long) getpid (), (unsigned long) boot_time);
 358   else
 359     sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
 360              (unsigned long) getpid ());
 361
 362   err = symlink (lock_info_str, lfname);
 363   if (errno == EEXIST && force)
 364     {
 365       unlink (lfname);
 366       err = symlink (lock_info_str, lfname);
 367     }
 368
 369   return err == 0;
 370 }
 371
 372 /* Return 1 if times A and B are no more than one second apart.  */
 373
 374 int
 375 within_one_second (a, b)
 376      time_t a, b;
 377 {
 378   return (a - b >= -1 && a - b <= 1);
 379 }
 380 \f
 381 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
 382    1 if another process owns it (and set OWNER (if non-null) to info),
 383    2 if the current process owns it,
 384    or -1 if something is wrong with the locking mechanism.  */
 385
 386 static int
 387 current_lock_owner (owner, lfname)
 388      lock_info_type *owner;
 389      char *lfname;
 390 {
 391 #ifndef index
 392   extern char *rindex (), *index ();
 393 #endif
 394   int o, p, len, ret;
 395   int local_owner = 0;
 396   char *at, *dot, *colon;
 397   char *lfinfo = 0;
 398   int bufsize = 50;
 399   /* Read arbitrarily-long contents of symlink.  Similar code in
 400      file-symlink-p in fileio.c.  */
 401   do
 402     {
 403       bufsize *= 2;
 404       lfinfo = (char *) xrealloc (lfinfo, bufsize);
 405       len = readlink (lfname, lfinfo, bufsize);
 406     }
 407   while (len >= bufsize);
 408
 409   /* If nonexistent lock file, all is well; otherwise, got strange error. */
 410   if (len == -1)
 411     {
 412       xfree (lfinfo);
 413       return errno == ENOENT ? 0 : -1;
 414     }
 415
 416   /* Link info exists, so `len' is its length.  Null terminate.  */
 417   lfinfo[len] = 0;
 418
 419   /* Even if the caller doesn't want the owner info, we still have to
 420      read it to determine return value, so allocate it.  */
 421   if (!owner)
 422     {
 423       owner = (lock_info_type *) alloca (sizeof (lock_info_type));
 424       local_owner = 1;
 425     }
 426
 427   /* Parse USER@HOST.PID:BOOT_TIME.  If can't parse, return -1.  */
 428   /* The USER is everything before the first @.  */
 429   at = index (lfinfo, '@');
 430   dot = rindex (lfinfo, '.');
 431   if (!at || !dot)
 432     {
 433       xfree (lfinfo);
 434       return -1;
 435     }
 436   len = at - lfinfo;
 437   owner->user = (char *) xmalloc (len + 1);
 438   strncpy (owner->user, lfinfo, len);
 439   owner->user[len] = 0;
 440
 441   /* The PID is everything from the last `.' to the `:'.  */
 442   owner->pid = atoi (dot + 1);
 443   colon = dot;
 444   while (*colon && *colon != ':')
 445     colon++;
 446   /* After the `:', if there is one, comes the boot time.  */
 447   if (*colon == ':')
 448     owner->boot_time = atoi (colon + 1);
 449   else
 450     owner->boot_time = 0;
 451
 452   /* The host is everything in between.  */
 453   len = dot - at - 1;
 454   owner->host = (char *) xmalloc (len + 1);
 455   strncpy (owner->host, at + 1, len);
 456   owner->host[len] = 0;
 457
 458   /* We're done looking at the link info.  */
 459   xfree (lfinfo);
 460
 461   /* On current host?  */
 462   if (STRINGP (Fsystem_name ())
 463       && strcmp (owner->host, XSTRING (Fsystem_name ())->data) == 0)
 464     {
 465       if (owner->pid == getpid ())
 466         ret = 2; /* We own it.  */
 467       else if (owner->pid > 0
 468                && (kill (owner->pid, 0) >= 0 || errno == EPERM)
 469                && (owner->boot_time == 0
 470                    || within_one_second (owner->boot_time, get_boot_time ())))
 471         ret = 1; /* An existing process on this machine owns it.  */
 472       /* The owner process is dead or has a strange pid (<=0), so try to
 473          zap the lockfile.  */
 474       else if (unlink (lfname) < 0)
 475         ret = -1;
 476       else
 477         ret = 0;
 478     }
 479   else
 480     { /* If we wanted to support the check for stale locks on remote machines,
 481          here's where we'd do it.  */
 482       ret = 1;
 483     }
 484
 485   /* Avoid garbage.  */
 486   if (local_owner || ret <= 0)
 487     {
 488       FREE_LOCK_INFO (*owner);
 489     }
 490   return ret;
 491 }
 492
 493 \f
 494 /* Lock the lock named LFNAME if possible.
 495    Return 0 in that case.
 496    Return positive if some other process owns the lock, and info about
 497      that process in CLASHER.
 498    Return -1 if cannot lock for any other reason.  */
 499
 500 static int
 501 lock_if_free (clasher, lfname)
 502      lock_info_type *clasher;
 503      register char *lfname;
 504 {
 505   while (lock_file_1 (lfname, 0) == 0)
 506     {
 507       int locker;
 508
 509       if (errno != EEXIST)
 510         return -1;
 511
 512       locker = current_lock_owner (clasher, lfname);
 513       if (locker == 2)
 514         {
 515           FREE_LOCK_INFO (*clasher);
 516           return 0;   /* We ourselves locked it.  */
 517         }
 518       else if (locker == 1)
 519         return 1;  /* Someone else has it.  */
 520       else if (locker == -1)
 521         return -1;   /* current_lock_owner returned strange error.  */
 522
 523       /* We deleted a stale lock; try again to lock the file.  */
 524     }
 525   return 0;
 526 }
 527
 528 /* lock_file locks file FN,
 529    meaning it serves notice on the world that you intend to edit that file.
 530    This should be done only when about to modify a file-visiting
 531    buffer previously unmodified.
 532    Do not (normally) call this for a buffer already modified,
 533    as either the file is already locked, or the user has already
 534    decided to go ahead without locking.
 535
 536    When this returns, either the lock is locked for us,
 537    or the user has said to go ahead without locking.
 538
 539    If the file is locked by someone else, this calls
 540    ask-user-about-lock (a Lisp function) with two arguments,
 541    the file name and info about the user who did the locking.
 542    This function can signal an error, or return t meaning
 543    take away the lock, or return nil meaning ignore the lock.  */
 544
 545 void
 546 lock_file (fn)
 547      Lisp_Object fn;
 548 {
 549   register Lisp_Object attack, orig_fn, encoded_fn;
 550   register char *lfname, *locker;
 551   lock_info_type lock_info;
 552
 553   /* Don't do locking while dumping Emacs.
 554      Uncompressing wtmp files uses call-process, which does not work
 555      in an uninitialized Emacs.  */
 556   if (! NILP (Vpurify_flag))
 557     return;
 558
 559   orig_fn = fn;
 560   fn = Fexpand_file_name (fn, Qnil);
 561   encoded_fn = ENCODE_FILE (fn);
 562
 563   /* Create the name of the lock-file for file fn */
 564   MAKE_LOCK_NAME (lfname, encoded_fn);
 565
 566   /* See if this file is visited and has changed on disk since it was
 567      visited.  */
 568   {
 569     register Lisp_Object subject_buf;
 570     struct gcpro gcpro1;
 571
 572     subject_buf = get_truename_buffer (orig_fn);
 573     GCPRO1 (fn);
 574
 575     if (!NILP (subject_buf)
 576         && NILP (Fverify_visited_file_modtime (subject_buf))
 577         && !NILP (Ffile_exists_p (fn)))
 578       call1 (intern ("ask-user-about-supersession-threat"), fn);
 579
 580     UNGCPRO;
 581   }
 582
 583   /* Try to lock the lock. */
 584   if (lock_if_free (&lock_info, lfname) <= 0)
 585     /* Return now if we have locked it, or if lock creation failed */
 586     return;
 587
 588   /* Else consider breaking the lock */
 589   locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
 590                             + LOCK_PID_MAX + 9);
 591   sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
 592            lock_info.pid);
 593   FREE_LOCK_INFO (lock_info);
 594
 595   attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
 596   if (!NILP (attack))
 597     /* User says take the lock */
 598     {
 599       lock_file_1 (lfname, 1);
 600       return;
 601     }
 602   /* User says ignore the lock */
 603 }
 604
 605 void
 606 unlock_file (fn)
 607      register Lisp_Object fn;
 608 {
 609   register char *lfname;
 610
 611   fn = Fexpand_file_name (fn, Qnil);
 612   fn = ENCODE_FILE (fn);
 613
 614   MAKE_LOCK_NAME (lfname, fn);
 615
 616   if (current_lock_owner (0, lfname) == 2)
 617     unlink (lfname);
 618 }
 619
 620 void
 621 unlock_all_files ()
 622 {
 623   register Lisp_Object tail;
 624   register struct buffer *b;
 625
 626   for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
 627     {
 628       b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
 629       if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 630         {
 631           register char *lfname;
 632
 633           MAKE_LOCK_NAME (lfname, b->file_truename);
 634
 635           if (current_lock_owner (0, lfname) == 2)
 636             unlink (lfname);
 637         }
 638     }
 639 }
 640 \f
 641 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
 642   0, 1, 0,
 643   "Lock FILE, if current buffer is modified.\n\
 644 FILE defaults to current buffer's visited file,\n\
 645 or else nothing is done if current buffer isn't visiting a file.")
 646   (file)
 647      Lisp_Object file;
 648 {
 649   if (NILP (file))
 650     file = current_buffer->file_truename;
 651   else
 652     CHECK_STRING (file, 0);
 653   if (SAVE_MODIFF < MODIFF
 654       && !NILP (file))
 655     lock_file (file);
 656   return Qnil;
 657 }
 658
 659 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
 660   0, 0, 0,
 661  "Unlock the file visited in the current buffer,\n\
 662 if it should normally be locked.")
 663   ()
 664 {
 665   if (SAVE_MODIFF < MODIFF
 666       && STRINGP (current_buffer->file_truename))
 667     unlock_file (current_buffer->file_truename);
 668   return Qnil;
 669 }
 670
 671 /* Unlock the file visited in buffer BUFFER.  */
 672
 673 void
 674 unlock_buffer (buffer)
 675      struct buffer *buffer;
 676 {
 677   if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
 678       && STRINGP (buffer->file_truename))
 679     unlock_file (buffer->file_truename);
 680 }
 681
 682 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
 683   "Return nil if the FILENAME is not locked,\n\
 684 t if it is locked by you, else a string of the name of the locker.")
 685   (filename)
 686   Lisp_Object filename;
 687 {
 688   Lisp_Object ret;
 689   register char *lfname;
 690   int owner;
 691   lock_info_type locker;
 692
 693   filename = Fexpand_file_name (filename, Qnil);
 694
 695   MAKE_LOCK_NAME (lfname, filename);
 696
 697   owner = current_lock_owner (&locker, lfname);
 698   if (owner <= 0)
 699     ret = Qnil;
 700   else if (owner == 2)
 701     ret = Qt;
 702   else
 703     ret = build_string (locker.user);
 704
 705   if (owner > 0)
 706     FREE_LOCK_INFO (locker);
 707
 708   return ret;
 709 }
 710 \f
 711 /* Initialization functions.  */
 712
 713 void
 714 init_filelock ()
 715 {
 716   boot_time = 0;
 717   boot_time_initialized = 0;
 718 }
 719
 720 void
 721 syms_of_filelock ()
 722 {
 723   defsubr (&Sunlock_buffer);
 724   defsubr (&Slock_buffer);
 725   defsubr (&Sfile_locked_p);
 726 }
 727
 728 #endif /* CLASH_DETECTION */