src/filelock.c

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