src/filelock.c

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