src/filelock.c

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