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, 2011
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
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.
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.
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/>. */
23 #include <sys/types.h>
38 #include <sys/sysctl.h>
39 #endif /* __FreeBSD__ */
45 #include "character.h"
49 #ifdef CLASH_DETECTION
55 #if !defined (S_ISLNK) && defined (S_IFLNK)
56 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
59 /* A file whose last-modified time is just after the most recent boot.
60 Define this to be NULL to disable checking for this file. */
61 #ifndef BOOT_TIME_FILE
62 #define BOOT_TIME_FILE "/var/run/random-seed"
66 #define WTMP_FILE "/var/log/wtmp"
69 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
70 directory, with link data `user@host.pid'. This avoids a single
71 mount (== failure) point for lock files.
73 When the host in the lock data is the current host, we can check if
74 the pid is valid with kill.
76 Otherwise, we could look at a separate file that maps hostnames to
77 reboot times to see if the remote pid can possibly be valid, since we
78 don't want Emacs to have to communicate via pipes or sockets or
79 whatever to other processes, either locally or remotely; rms says
80 that's too unreliable. Hence the separate file, which could
81 theoretically be updated by daemons running separately -- but this
82 whole idea is unimplemented; in practice, at least in our
83 environment, it seems such stale locks arise fairly infrequently, and
84 Emacs' standard methods of dealing with clashes suffice.
86 We use symlinks instead of normal files because (1) they can be
87 stored more efficiently on the filesystem, since the kernel knows
88 they will be small, and (2) all the info about the lock can be read
89 in a single system call (readlink). Although we could use regular
90 files to be useful on old systems lacking symlinks, nowadays
91 virtually all such systems are probably single-user anyway, so it
92 didn't seem worth the complication.
94 Similarly, we don't worry about a possible 14-character limit on
95 file names, because those are all the same systems that don't have
98 This is compatible with the locking scheme used by Interleaf (which
99 has contributed this implementation for Emacs), and was designed by
100 Ethan Jacobson, Kimbo Mundy, and others.
102 --karl@cs.umb.edu/karl@hq.ileaf.com. */
105 /* Return the time of the last system boot. */
107 static time_t boot_time
;
108 static int boot_time_initialized
;
111 static void get_boot_time_1 (const char *, int);
117 #if defined (BOOT_TIME)
121 if (boot_time_initialized
)
123 boot_time_initialized
= 1;
125 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
129 struct timeval boottime_val
;
132 mib
[1] = KERN_BOOTTIME
;
133 size
= sizeof (boottime_val
);
135 if (sysctl (mib
, 2, &boottime_val
, &size
, NULL
, 0) >= 0)
137 boot_time
= boottime_val
.tv_sec
;
141 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
146 if (stat (BOOT_TIME_FILE
, &st
) == 0)
148 boot_time
= st
.st_mtime
;
153 #if defined (BOOT_TIME)
155 /* The utmp routines maintain static state.
156 Don't touch that state unless we are initialized,
157 since it might not survive dumping. */
160 #endif /* not CANNOT_DUMP */
162 /* Try to get boot time from utmp before wtmp,
163 since utmp is typically much smaller than wtmp.
164 Passing a null pointer causes get_boot_time_1
165 to inspect the default file, namely utmp. */
166 get_boot_time_1 ((char *) 0, 0);
170 /* Try to get boot time from the current wtmp file. */
171 get_boot_time_1 (WTMP_FILE
, 1);
173 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
174 for (counter
= 0; counter
< 20 && ! boot_time
; counter
++)
176 char cmd_string
[100];
177 Lisp_Object tempname
, filename
;
182 sprintf (cmd_string
, "%s.%d", WTMP_FILE
, counter
);
183 tempname
= build_string (cmd_string
);
184 if (! NILP (Ffile_exists_p (tempname
)))
188 sprintf (cmd_string
, "%s.%d.gz", WTMP_FILE
, counter
);
189 tempname
= build_string (cmd_string
);
190 if (! NILP (Ffile_exists_p (tempname
)))
194 /* The utmp functions on mescaline.gnu.org accept only
195 file names up to 8 characters long. Choose a 2
196 character long prefix, and call make_temp_file with
197 second arg non-zero, so that it will add not more
198 than 6 characters to the prefix. */
199 tempname
= Fexpand_file_name (build_string ("wt"),
200 Vtemporary_file_directory
);
201 tempname
= make_temp_name (tempname
, 1);
202 args
[0] = Vshell_file_name
;
206 args
[4] = build_string ("-c");
207 sprintf (cmd_string
, "gunzip < %s.%d.gz > %s",
208 WTMP_FILE
, counter
, SDATA (tempname
));
209 args
[5] = build_string (cmd_string
);
210 Fcall_process (6, args
);
216 if (! NILP (filename
))
218 get_boot_time_1 (SDATA (filename
), 1);
220 unlink (SDATA (filename
));
231 /* Try to get the boot time from wtmp file FILENAME.
232 This succeeds if that file contains a reboot record.
234 If FILENAME is zero, use the same file as before;
235 if no FILENAME has ever been specified, this is the utmp file.
236 Use the newest reboot record if NEWEST is nonzero,
237 the first reboot record otherwise.
238 Ignore all reboot records on or before BOOT_TIME.
239 Success is indicated by setting BOOT_TIME to a larger value. */
242 get_boot_time_1 (const char *filename
, int newest
)
244 struct utmp ut
, *utp
;
249 /* On some versions of IRIX, opening a nonexistent file name
250 is likely to crash in the utmp routines. */
251 desc
= emacs_open (filename
, O_RDONLY
, 0);
264 /* Find the next reboot record. */
265 ut
.ut_type
= BOOT_TIME
;
269 /* Compare reboot times and use the newest one. */
270 if (utp
->ut_time
> boot_time
)
272 boot_time
= utp
->ut_time
;
276 /* Advance on element in the file
277 so that getutid won't repeat the same one. */
284 #endif /* BOOT_TIME */
286 /* Here is the structure that stores information about a lock. */
296 /* When we read the info back, we might need this much more,
297 enough for decimal representation plus null. */
298 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
300 /* Free the two dynamically-allocated pieces in PTR. */
301 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
304 /* Write the name of the lock file for FN into LFNAME. Length will be
305 that of FN plus two more for the leading `.#' plus 1 for the
306 trailing period plus one for the digit after it plus one for the
308 #define MAKE_LOCK_NAME(lock, file) \
309 (lock = (char *) alloca (SBYTES (file) + 2 + 1 + 1 + 1), \
310 fill_in_lock_file_name (lock, (file)))
313 fill_in_lock_file_name (register char *lockfile
, register Lisp_Object fn
)
319 strcpy (lockfile
, SDATA (fn
));
321 /* Shift the nondirectory part of the file name (including the null)
322 right two characters. Here is one of the places where we'd have to
323 do something to support 14-character-max file names. */
324 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
327 /* Insert the `.#'. */
333 while (lstat (lockfile
, &st
) == 0 && !S_ISLNK (st
.st_mode
))
340 sprintf (p
, ".%d", count
++);
344 /* Lock the lock file named LFNAME.
345 If FORCE is nonzero, we do so even if it is already locked.
346 Return 1 if successful, 0 if not. */
349 lock_file_1 (char *lfname
, int force
)
353 const char *user_name
;
354 const char *host_name
;
357 /* Call this first because it can GC. */
358 boot_time
= get_boot_time ();
360 if (STRINGP (Fuser_login_name (Qnil
)))
361 user_name
= SSDATA (Fuser_login_name (Qnil
));
364 if (STRINGP (Fsystem_name ()))
365 host_name
= SSDATA (Fsystem_name ());
368 lock_info_str
= (char *)alloca (strlen (user_name
) + strlen (host_name
)
369 + LOCK_PID_MAX
+ 30);
372 sprintf (lock_info_str
, "%s@%s.%lu:%lu", user_name
, host_name
,
373 (unsigned long) getpid (), (unsigned long) boot_time
);
375 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
376 (unsigned long) getpid ());
378 err
= symlink (lock_info_str
, lfname
);
379 if (errno
== EEXIST
&& force
)
382 err
= symlink (lock_info_str
, lfname
);
388 /* Return 1 if times A and B are no more than one second apart. */
391 within_one_second (time_t a
, time_t b
)
393 return (a
- b
>= -1 && a
- b
<= 1);
396 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
397 1 if another process owns it (and set OWNER (if non-null) to info),
398 2 if the current process owns it,
399 or -1 if something is wrong with the locking mechanism. */
402 current_lock_owner (lock_info_type
*owner
, char *lfname
)
406 char *at
, *dot
, *colon
;
409 /* Read arbitrarily-long contents of symlink. Similar code in
410 file-symlink-p in fileio.c. */
414 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
416 len
= readlink (lfname
, lfinfo
, bufsize
);
418 /* HP-UX reports ERANGE if the buffer is too small. */
419 if (len
== -1 && errno
== ERANGE
)
423 while (len
>= bufsize
);
425 /* If nonexistent lock file, all is well; otherwise, got strange error. */
429 return errno
== ENOENT
? 0 : -1;
432 /* Link info exists, so `len' is its length. Null terminate. */
435 /* Even if the caller doesn't want the owner info, we still have to
436 read it to determine return value, so allocate it. */
439 owner
= (lock_info_type
*) alloca (sizeof (lock_info_type
));
443 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
444 /* The USER is everything before the last @. */
445 at
= strrchr (lfinfo
, '@');
446 dot
= strrchr (lfinfo
, '.');
453 owner
->user
= (char *) xmalloc (len
+ 1);
454 strncpy (owner
->user
, lfinfo
, len
);
455 owner
->user
[len
] = 0;
457 /* The PID is everything from the last `.' to the `:'. */
458 owner
->pid
= atoi (dot
+ 1);
460 while (*colon
&& *colon
!= ':')
462 /* After the `:', if there is one, comes the boot time. */
464 owner
->boot_time
= atoi (colon
+ 1);
466 owner
->boot_time
= 0;
468 /* The host is everything in between. */
470 owner
->host
= (char *) xmalloc (len
+ 1);
471 strncpy (owner
->host
, at
+ 1, len
);
472 owner
->host
[len
] = 0;
474 /* We're done looking at the link info. */
477 /* On current host? */
478 if (STRINGP (Fsystem_name ())
479 && strcmp (owner
->host
, SDATA (Fsystem_name ())) == 0)
481 if (owner
->pid
== getpid ())
482 ret
= 2; /* We own it. */
483 else if (owner
->pid
> 0
484 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
)
485 && (owner
->boot_time
== 0
486 || within_one_second (owner
->boot_time
, get_boot_time ())))
487 ret
= 1; /* An existing process on this machine owns it. */
488 /* The owner process is dead or has a strange pid (<=0), so try to
490 else if (unlink (lfname
) < 0)
496 { /* If we wanted to support the check for stale locks on remote machines,
497 here's where we'd do it. */
502 if (local_owner
|| ret
<= 0)
504 FREE_LOCK_INFO (*owner
);
510 /* Lock the lock named LFNAME if possible.
511 Return 0 in that case.
512 Return positive if some other process owns the lock, and info about
513 that process in CLASHER.
514 Return -1 if cannot lock for any other reason. */
517 lock_if_free (lock_info_type
*clasher
, register char *lfname
)
519 while (lock_file_1 (lfname
, 0) == 0)
526 locker
= current_lock_owner (clasher
, lfname
);
529 FREE_LOCK_INFO (*clasher
);
530 return 0; /* We ourselves locked it. */
532 else if (locker
== 1)
533 return 1; /* Someone else has it. */
534 else if (locker
== -1)
535 return -1; /* current_lock_owner returned strange error. */
537 /* We deleted a stale lock; try again to lock the file. */
542 /* lock_file locks file FN,
543 meaning it serves notice on the world that you intend to edit that file.
544 This should be done only when about to modify a file-visiting
545 buffer previously unmodified.
546 Do not (normally) call this for a buffer already modified,
547 as either the file is already locked, or the user has already
548 decided to go ahead without locking.
550 When this returns, either the lock is locked for us,
551 or the user has said to go ahead without locking.
553 If the file is locked by someone else, this calls
554 ask-user-about-lock (a Lisp function) with two arguments,
555 the file name and info about the user who did the locking.
556 This function can signal an error, or return t meaning
557 take away the lock, or return nil meaning ignore the lock. */
560 lock_file (Lisp_Object fn
)
562 register Lisp_Object attack
, orig_fn
, encoded_fn
;
563 register char *lfname
, *locker
;
564 lock_info_type lock_info
;
567 /* Don't do locking while dumping Emacs.
568 Uncompressing wtmp files uses call-process, which does not work
569 in an uninitialized Emacs. */
570 if (! NILP (Vpurify_flag
))
575 fn
= Fexpand_file_name (fn
, Qnil
);
576 encoded_fn
= ENCODE_FILE (fn
);
578 /* Create the name of the lock-file for file fn */
579 MAKE_LOCK_NAME (lfname
, encoded_fn
);
581 /* See if this file is visited and has changed on disk since it was
584 register Lisp_Object subject_buf
;
586 subject_buf
= get_truename_buffer (orig_fn
);
588 if (!NILP (subject_buf
)
589 && NILP (Fverify_visited_file_modtime (subject_buf
))
590 && !NILP (Ffile_exists_p (fn
)))
591 call1 (intern ("ask-user-about-supersession-threat"), fn
);
596 /* Try to lock the lock. */
597 if (lock_if_free (&lock_info
, lfname
) <= 0)
598 /* Return now if we have locked it, or if lock creation failed */
601 /* Else consider breaking the lock */
602 locker
= (char *) alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
604 sprintf (locker
, "%s@%s (pid %lu)", lock_info
.user
, lock_info
.host
,
606 FREE_LOCK_INFO (lock_info
);
608 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
610 /* User says take the lock */
612 lock_file_1 (lfname
, 1);
615 /* User says ignore the lock */
619 unlock_file (register Lisp_Object fn
)
621 register char *lfname
;
623 fn
= Fexpand_file_name (fn
, Qnil
);
624 fn
= ENCODE_FILE (fn
);
626 MAKE_LOCK_NAME (lfname
, fn
);
628 if (current_lock_owner (0, lfname
) == 2)
633 unlock_all_files (void)
635 register Lisp_Object tail
;
636 register struct buffer
*b
;
638 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
640 b
= XBUFFER (XCDR (XCAR (tail
)));
641 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
643 unlock_file(b
->file_truename
);
648 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
650 doc
: /* Lock FILE, if current buffer is modified.
651 FILE defaults to current buffer's visited file,
652 or else nothing is done if current buffer isn't visiting a file. */)
656 file
= current_buffer
->file_truename
;
659 if (SAVE_MODIFF
< MODIFF
665 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
667 doc
: /* Unlock the file visited in the current buffer.
668 If the buffer is not modified, this does nothing because the file
669 should not be locked in that case. */)
672 if (SAVE_MODIFF
< MODIFF
673 && STRINGP (current_buffer
->file_truename
))
674 unlock_file (current_buffer
->file_truename
);
678 /* Unlock the file visited in buffer BUFFER. */
681 unlock_buffer (struct buffer
*buffer
)
683 if (BUF_SAVE_MODIFF (buffer
) < BUF_MODIFF (buffer
)
684 && STRINGP (buffer
->file_truename
))
685 unlock_file (buffer
->file_truename
);
688 DEFUN ("file-locked-p", Ffile_locked_p
, Sfile_locked_p
, 1, 1, 0,
689 doc
: /* Return a value indicating whether FILENAME is locked.
690 The value is nil if the FILENAME is not locked,
691 t if it is locked by you, else a string saying which user has locked it. */)
692 (Lisp_Object filename
)
695 register char *lfname
;
697 lock_info_type locker
;
699 filename
= Fexpand_file_name (filename
, Qnil
);
701 MAKE_LOCK_NAME (lfname
, filename
);
703 owner
= current_lock_owner (&locker
, lfname
);
709 ret
= build_string (locker
.user
);
712 FREE_LOCK_INFO (locker
);
717 /* Initialization functions. */
723 boot_time_initialized
= 0;
726 #endif /* CLASH_DETECTION */
729 syms_of_filelock (void)
731 DEFVAR_LISP ("temporary-file-directory", Vtemporary_file_directory
,
732 doc
: /* The directory for writing temporary files. */);
733 Vtemporary_file_directory
= Qnil
;
735 #ifdef CLASH_DETECTION
736 defsubr (&Sunlock_buffer
);
737 defsubr (&Slock_buffer
);
738 defsubr (&Sfile_locked_p
);