src/filelock.c

   1 /* Lock files for editing.
   2    Copyright (C) 1985-1987, 1993-1994, 1996, 1998-2012
   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 "character.h"
  44 #include "buffer.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       tempname = make_formatted_string
 178         (cmd_string, "%s.%d", WTMP_FILE, counter);
 179       if (! NILP (Ffile_exists_p (tempname)))
 180         filename = tempname;
 181       else
 182         {
 183           tempname = make_formatted_string (cmd_string, "%s.%d.gz",
 184                                             WTMP_FILE, counter);
 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 = 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   ptrdiff_t length = SBYTES (fn);
 304   register char *p;
 305   struct stat st;
 306   int count = 0;
 307
 308   strcpy (lockfile, SSDATA (fn));
 309
 310   /* Shift the nondirectory part of the file name (including the null)
 311      right two characters.  Here is one of the places where we'd have to
 312      do something to support 14-character-max file names.  */
 313   for (p = lockfile + length; p != lockfile && *p != '/'; p--)
 314     p[2] = *p;
 315
 316   /* Insert the `.#'.  */
 317   p[1] = '.';
 318   p[2] = '#';
 319
 320   p = p + length + 2;
 321
 322   while (lstat (lockfile, &st) == 0 && !S_ISLNK (st.st_mode))
 323     {
 324       if (count > 9)
 325         {
 326           *p = '\0';
 327           return;
 328         }
 329       sprintf (p, ".%d", count++);
 330     }
 331 }
 332
 333 /* Lock the lock file named LFNAME.
 334    If FORCE is nonzero, we do so even if it is already locked.
 335    Return 1 if successful, 0 if not.  */
 336
 337 static int
 338 lock_file_1 (char *lfname, int force)
 339 {
 340   int err;
 341   int symlink_errno;
 342   USE_SAFE_ALLOCA;
 343
 344   /* Call this first because it can GC.  */
 345   printmax_t boot = get_boot_time ();
 346
 347   Lisp_Object luser_name = Fuser_login_name (Qnil);
 348   char const *user_name = STRINGP (luser_name) ? SSDATA (luser_name) : "";
 349   Lisp_Object lhost_name = Fsystem_name ();
 350   char const *host_name = STRINGP (lhost_name) ? SSDATA (lhost_name) : "";
 351   ptrdiff_t lock_info_size = (strlen (user_name) + strlen (host_name)
 352                               + 2 * INT_STRLEN_BOUND (printmax_t)
 353                               + sizeof "@.:");
 354   char *lock_info_str = SAFE_ALLOCA (lock_info_size);
 355   printmax_t pid = getpid ();
 356
 357   esprintf (lock_info_str, boot ? "%s@%s.%"pMd":%"pMd : "%s@%s.%"pMd,
 358             user_name, host_name, pid, boot);
 359
 360   err = symlink (lock_info_str, lfname);
 361   if (errno == EEXIST && force)
 362     {
 363       unlink (lfname);
 364       err = symlink (lock_info_str, lfname);
 365     }
 366
 367   symlink_errno = errno;
 368   SAFE_FREE ();
 369   errno = symlink_errno;
 370   return err == 0;
 371 }
 372
 373 /* Return 1 if times A and B are no more than one second apart.  */
 374
 375 static int
 376 within_one_second (time_t a, time_t 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 (lock_info_type *owner, char *lfname)
 388 {
 389   int ret;
 390   ptrdiff_t len;
 391   lock_info_type local_owner;
 392   intmax_t n;
 393   char *at, *dot, *colon;
 394   char readlink_buf[READLINK_BUFSIZE];
 395   char *lfinfo = emacs_readlink (lfname, readlink_buf);
 396
 397   /* If nonexistent lock file, all is well; otherwise, got strange error. */
 398   if (!lfinfo)
 399     return errno == ENOENT ? 0 : -1;
 400
 401   /* Even if the caller doesn't want the owner info, we still have to
 402      read it to determine return value.  */
 403   if (!owner)
 404     owner = &local_owner;
 405
 406   /* Parse USER@HOST.PID:BOOT_TIME.  If can't parse, return -1.  */
 407   /* The USER is everything before the last @.  */
 408   at = strrchr (lfinfo, '@');
 409   dot = strrchr (lfinfo, '.');
 410   if (!at || !dot)
 411     {
 412       if (lfinfo != readlink_buf)
 413         xfree (lfinfo);
 414       return -1;
 415     }
 416   len = at - lfinfo;
 417   owner->user = xmalloc (len + 1);
 418   memcpy (owner->user, lfinfo, len);
 419   owner->user[len] = 0;
 420
 421   /* The PID is everything from the last `.' to the `:'.  */
 422   errno = 0;
 423   n = strtoimax (dot + 1, NULL, 10);
 424   owner->pid =
 425     ((0 <= n && n <= TYPE_MAXIMUM (pid_t)
 426       && (TYPE_MAXIMUM (pid_t) < INTMAX_MAX || errno != ERANGE))
 427      ? n : 0);
 428
 429   colon = strchr (dot + 1, ':');
 430   /* After the `:', if there is one, comes the boot time.  */
 431   n = 0;
 432   if (colon)
 433     {
 434       errno = 0;
 435       n = strtoimax (colon + 1, NULL, 10);
 436     }
 437   owner->boot_time =
 438     ((0 <= n && n <= TYPE_MAXIMUM (time_t)
 439       && (TYPE_MAXIMUM (time_t) < INTMAX_MAX || errno != ERANGE))
 440      ? n : 0);
 441
 442   /* The host is everything in between.  */
 443   len = dot - at - 1;
 444   owner->host = xmalloc (len + 1);
 445   memcpy (owner->host, at + 1, len);
 446   owner->host[len] = 0;
 447
 448   /* We're done looking at the link info.  */
 449   if (lfinfo != readlink_buf)
 450     xfree (lfinfo);
 451
 452   /* On current host?  */
 453   if (STRINGP (Fsystem_name ())
 454       && strcmp (owner->host, SSDATA (Fsystem_name ())) == 0)
 455     {
 456       if (owner->pid == getpid ())
 457         ret = 2; /* We own it.  */
 458       else if (owner->pid > 0
 459                && (kill (owner->pid, 0) >= 0 || errno == EPERM)
 460                && (owner->boot_time == 0
 461                    || within_one_second (owner->boot_time, get_boot_time ())))
 462         ret = 1; /* An existing process on this machine owns it.  */
 463       /* The owner process is dead or has a strange pid (<=0), so try to
 464          zap the lockfile.  */
 465       else if (unlink (lfname) < 0)
 466         ret = -1;
 467       else
 468         ret = 0;
 469     }
 470   else
 471     { /* If we wanted to support the check for stale locks on remote machines,
 472          here's where we'd do it.  */
 473       ret = 1;
 474     }
 475
 476   /* Avoid garbage.  */
 477   if (owner == &local_owner || ret <= 0)
 478     {
 479       FREE_LOCK_INFO (*owner);
 480     }
 481   return ret;
 482 }
 483
 484 \f
 485 /* Lock the lock named LFNAME if possible.
 486    Return 0 in that case.
 487    Return positive if some other process owns the lock, and info about
 488      that process in CLASHER.
 489    Return -1 if cannot lock for any other reason.  */
 490
 491 static int
 492 lock_if_free (lock_info_type *clasher, register char *lfname)
 493 {
 494   while (lock_file_1 (lfname, 0) == 0)
 495     {
 496       int locker;
 497
 498       if (errno != EEXIST)
 499         return -1;
 500
 501       locker = current_lock_owner (clasher, lfname);
 502       if (locker == 2)
 503         {
 504           FREE_LOCK_INFO (*clasher);
 505           return 0;   /* We ourselves locked it.  */
 506         }
 507       else if (locker == 1)
 508         return 1;  /* Someone else has it.  */
 509       else if (locker == -1)
 510         return -1;   /* current_lock_owner returned strange error.  */
 511
 512       /* We deleted a stale lock; try again to lock the file.  */
 513     }
 514   return 0;
 515 }
 516
 517 /* lock_file locks file FN,
 518    meaning it serves notice on the world that you intend to edit that file.
 519    This should be done only when about to modify a file-visiting
 520    buffer previously unmodified.
 521    Do not (normally) call this for a buffer already modified,
 522    as either the file is already locked, or the user has already
 523    decided to go ahead without locking.
 524
 525    When this returns, either the lock is locked for us,
 526    or the user has said to go ahead without locking.
 527
 528    If the file is locked by someone else, this calls
 529    ask-user-about-lock (a Lisp function) with two arguments,
 530    the file name and info about the user who did the locking.
 531    This function can signal an error, or return t meaning
 532    take away the lock, or return nil meaning ignore the lock.  */
 533
 534 void
 535 lock_file (Lisp_Object fn)
 536 {
 537   register Lisp_Object attack, orig_fn, encoded_fn;
 538   register char *lfname, *locker;
 539   ptrdiff_t locker_size;
 540   lock_info_type lock_info;
 541   printmax_t pid;
 542   struct gcpro gcpro1;
 543   USE_SAFE_ALLOCA;
 544
 545   /* Don't do locking if the user has opted out.  */
 546   if (! create_lockfiles)
 547     return;
 548
 549   /* Don't do locking while dumping Emacs.
 550      Uncompressing wtmp files uses call-process, which does not work
 551      in an uninitialized Emacs.  */
 552   if (! NILP (Vpurify_flag))
 553     return;
 554
 555   orig_fn = fn;
 556   GCPRO1 (fn);
 557   fn = Fexpand_file_name (fn, Qnil);
 558   encoded_fn = ENCODE_FILE (fn);
 559
 560   /* Create the name of the lock-file for file fn */
 561   MAKE_LOCK_NAME (lfname, encoded_fn);
 562
 563   /* See if this file is visited and has changed on disk since it was
 564      visited.  */
 565   {
 566     register Lisp_Object subject_buf;
 567
 568     subject_buf = get_truename_buffer (orig_fn);
 569
 570     if (!NILP (subject_buf)
 571         && NILP (Fverify_visited_file_modtime (subject_buf))
 572         && !NILP (Ffile_exists_p (fn)))
 573       call1 (intern ("ask-user-about-supersession-threat"), fn);
 574
 575   }
 576   UNGCPRO;
 577
 578   /* Try to lock the lock. */
 579   if (lock_if_free (&lock_info, lfname) <= 0)
 580     /* Return now if we have locked it, or if lock creation failed */
 581     return;
 582
 583   /* Else consider breaking the lock */
 584   locker_size = (strlen (lock_info.user) + strlen (lock_info.host)
 585                  + INT_STRLEN_BOUND (printmax_t)
 586                  + sizeof "@ (pid )");
 587   locker = SAFE_ALLOCA (locker_size);
 588   pid = lock_info.pid;
 589   esprintf (locker, "%s@%s (pid %"pMd")",
 590             lock_info.user, lock_info.host, pid);
 591   FREE_LOCK_INFO (lock_info);
 592
 593   attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
 594   SAFE_FREE ();
 595   if (!NILP (attack))
 596     /* User says take the lock */
 597     {
 598       lock_file_1 (lfname, 1);
 599       return;
 600     }
 601   /* User says ignore the lock */
 602 }
 603
 604 void
 605 unlock_file (register Lisp_Object fn)
 606 {
 607   register char *lfname;
 608
 609   fn = Fexpand_file_name (fn, Qnil);
 610   fn = ENCODE_FILE (fn);
 611
 612   MAKE_LOCK_NAME (lfname, fn);
 613
 614   if (current_lock_owner (0, lfname) == 2)
 615     unlink (lfname);
 616 }
 617
 618 void
 619 unlock_all_files (void)
 620 {
 621   register Lisp_Object tail;
 622   register struct buffer *b;
 623
 624   for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
 625     {
 626       b = XBUFFER (XCDR (XCAR (tail)));
 627       if (STRINGP (BVAR (b, file_truename)) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 628         {
 629           unlock_file (BVAR (b, file_truename));
 630         }
 631     }
 632 }
 633 \f
 634 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
 635        0, 1, 0,
 636        doc: /* Lock FILE, if current buffer is modified.
 637 FILE defaults to current buffer's visited file,
 638 or else nothing is done if current buffer isn't visiting a file.  */)
 639   (Lisp_Object file)
 640 {
 641   if (NILP (file))
 642     file = BVAR (current_buffer, file_truename);
 643   else
 644     CHECK_STRING (file);
 645   if (SAVE_MODIFF < MODIFF
 646       && !NILP (file))
 647     lock_file (file);
 648   return Qnil;
 649 }
 650
 651 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
 652        0, 0, 0,
 653        doc: /* Unlock the file visited in the current buffer.
 654 If the buffer is not modified, this does nothing because the file
 655 should not be locked in that case.  */)
 656   (void)
 657 {
 658   if (SAVE_MODIFF < MODIFF
 659       && STRINGP (BVAR (current_buffer, file_truename)))
 660     unlock_file (BVAR (current_buffer, file_truename));
 661   return Qnil;
 662 }
 663
 664 /* Unlock the file visited in buffer BUFFER.  */
 665
 666 void
 667 unlock_buffer (struct buffer *buffer)
 668 {
 669   if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
 670       && STRINGP (BVAR (buffer, file_truename)))
 671     unlock_file (BVAR (buffer, file_truename));
 672 }
 673
 674 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 1, 1, 0,
 675        doc: /* Return a value indicating whether FILENAME is locked.
 676 The value is nil if the FILENAME is not locked,
 677 t if it is locked by you, else a string saying which user has locked it.  */)
 678   (Lisp_Object filename)
 679 {
 680   Lisp_Object ret;
 681   register char *lfname;
 682   int owner;
 683   lock_info_type locker;
 684
 685   filename = Fexpand_file_name (filename, Qnil);
 686
 687   MAKE_LOCK_NAME (lfname, filename);
 688
 689   owner = current_lock_owner (&locker, lfname);
 690   if (owner <= 0)
 691     ret = Qnil;
 692   else if (owner == 2)
 693     ret = Qt;
 694   else
 695     ret = build_string (locker.user);
 696
 697   if (owner > 0)
 698     FREE_LOCK_INFO (locker);
 699
 700   return ret;
 701 }
 702
 703 #endif /* CLASH_DETECTION */
 704
 705 void
 706 syms_of_filelock (void)
 707 {
 708   DEFVAR_LISP ("temporary-file-directory", Vtemporary_file_directory,
 709                doc: /* The directory for writing temporary files.  */);
 710   Vtemporary_file_directory = Qnil;
 711
 712   DEFVAR_BOOL ("create-lockfiles", create_lockfiles,
 713                doc: /* Non-nil means use lockfiles to avoid editing collisions.  */);
 714   create_lockfiles = 1;
 715
 716 #ifdef CLASH_DETECTION
 717   defsubr (&Sunlock_buffer);
 718   defsubr (&Slock_buffer);
 719   defsubr (&Sfile_locked_p);
 720 #endif
 721 }