1 /* Lock files for editing.
2 Copyright (C) 1985, 86, 87, 93, 94, 96, 98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include <sys/types.h>
46 #include <sys/types.h>
47 #include <sys/sysctl.h>
48 #endif /* __FreeBSD__ */
62 /* The directory for writing temporary files. */
64 Lisp_Object Vtemporary_file_directory
;
66 #ifdef CLASH_DETECTION
70 /* A file whose last-modified time is just after the most recent boot.
71 Define this to be NULL to disable checking for this file. */
72 #ifndef BOOT_TIME_FILE
73 #define BOOT_TIME_FILE "/var/run/random-seed"
77 #define WTMP_FILE "/var/log/wtmp"
80 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
81 directory, with link data `user@host.pid'. This avoids a single
82 mount (== failure) point for lock files.
84 When the host in the lock data is the current host, we can check if
85 the pid is valid with kill.
87 Otherwise, we could look at a separate file that maps hostnames to
88 reboot times to see if the remote pid can possibly be valid, since we
89 don't want Emacs to have to communicate via pipes or sockets or
90 whatever to other processes, either locally or remotely; rms says
91 that's too unreliable. Hence the separate file, which could
92 theoretically be updated by daemons running separately -- but this
93 whole idea is unimplemented; in practice, at least in our
94 environment, it seems such stale locks arise fairly infrequently, and
95 Emacs' standard methods of dealing with clashes suffice.
97 We use symlinks instead of normal files because (1) they can be
98 stored more efficiently on the filesystem, since the kernel knows
99 they will be small, and (2) all the info about the lock can be read
100 in a single system call (readlink). Although we could use regular
101 files to be useful on old systems lacking symlinks, nowadays
102 virtually all such systems are probably single-user anyway, so it
103 didn't seem worth the complication.
105 Similarly, we don't worry about a possible 14-character limit on
106 file names, because those are all the same systems that don't have
109 This is compatible with the locking scheme used by Interleaf (which
110 has contributed this implementation for Emacs), and was designed by
111 Ethan Jacobson, Kimbo Mundy, and others.
113 --karl@cs.umb.edu/karl@hq.ileaf.com. */
116 /* Return the time of the last system boot. */
118 static time_t boot_time
;
119 static int boot_time_initialized
;
121 extern Lisp_Object Vshell_file_name
;
126 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
130 if (boot_time_initialized
)
132 boot_time_initialized
= 1;
134 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
138 struct timeval boottime_val
;
141 mib
[1] = KERN_BOOTTIME
;
142 size
= sizeof (boottime_val
);
144 if (sysctl (mib
, 2, &boottime_val
, &size
, NULL
, 0) >= 0)
146 boot_time
= boottime_val
.tv_sec
;
150 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
155 if (stat (BOOT_TIME_FILE
, &st
) == 0)
157 boot_time
= st
.st_mtime
;
162 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
164 /* The utmp routines maintain static state.
165 Don't touch that state unless we are initialized,
166 since it might not survive dumping. */
169 #endif /* not CANNOT_DUMP */
171 /* Try to get boot time from utmp before wtmp,
172 since utmp is typically much smaller than wtmp.
173 Passing a null pointer causes get_boot_time_1
174 to inspect the default file, namely utmp. */
175 get_boot_time_1 ((char *) 0, 0);
179 /* Try to get boot time from the current wtmp file. */
180 get_boot_time_1 (WTMP_FILE
, 1);
182 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
183 for (counter
= 0; counter
< 20 && ! boot_time
; counter
++)
185 char cmd_string
[100];
186 Lisp_Object tempname
, filename
;
191 sprintf (cmd_string
, "%s.%d", WTMP_FILE
, counter
);
192 tempname
= build_string (cmd_string
);
193 if (! NILP (Ffile_exists_p (tempname
)))
197 sprintf (cmd_string
, "%s.%d.gz", WTMP_FILE
, counter
);
198 tempname
= build_string (cmd_string
);
199 if (! NILP (Ffile_exists_p (tempname
)))
202 tempname
= Fexpand_file_name (build_string ("wtmp"),
203 Vtemporary_file_directory
);
204 tempname
= Fmake_temp_name (tempname
);
205 args
[0] = Vshell_file_name
;
209 args
[4] = build_string ("-c");
210 sprintf (cmd_string
, "gunzip < %s.%d.gz > %s",
211 WTMP_FILE
, counter
, XSTRING (tempname
)->data
);
212 args
[5] = build_string (cmd_string
);
213 Fcall_process (6, args
);
219 if (! NILP (filename
))
221 get_boot_time_1 (XSTRING (filename
)->data
, 1);
223 unlink (XSTRING (filename
)->data
);
234 /* Try to get the boot time from wtmp file FILENAME.
235 This succeeds if that file contains a reboot record.
237 If FILENAME is zero, use the same file as before;
238 if no FILENAME has ever been specified, this is the utmp file.
239 Use the newest reboot record if NEWEST is nonzero,
240 the first reboot record otherwise.
241 Ignore all reboot records on or before BOOT_TIME.
242 Success is indicated by setting BOOT_TIME to a larger value. */
244 get_boot_time_1 (filename
, newest
)
248 struct utmp ut
, *utp
;
253 /* On some versions of IRIX, opening a nonexistent file name
254 is likely to crash in the utmp routines. */
255 desc
= emacs_open (filename
, O_RDONLY
, 0);
268 /* Find the next reboot record. */
269 ut
.ut_type
= BOOT_TIME
;
273 /* Compare reboot times and use the newest one. */
274 if (utp
->ut_time
> boot_time
)
276 boot_time
= utp
->ut_time
;
280 /* Advance on element in the file
281 so that getutid won't repeat the same one. */
288 #endif /* BOOT_TIME */
290 /* Here is the structure that stores information about a lock. */
300 /* When we read the info back, we might need this much more,
301 enough for decimal representation plus null. */
302 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
304 /* Free the two dynamically-allocated pieces in PTR. */
305 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
308 /* Write the name of the lock file for FN into LFNAME. Length will be
309 that of FN plus two more for the leading `.#' plus one for the null. */
310 #define MAKE_LOCK_NAME(lock, file) \
311 (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
312 fill_in_lock_file_name (lock, (file)))
315 fill_in_lock_file_name (lockfile
, fn
)
316 register char *lockfile
;
317 register Lisp_Object fn
;
321 strcpy (lockfile
, XSTRING (fn
)->data
);
323 /* Shift the nondirectory part of the file name (including the null)
324 right two characters. Here is one of the places where we'd have to
325 do something to support 14-character-max file names. */
326 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
329 /* Insert the `.#'. */
334 /* Lock the lock file named LFNAME.
335 If FORCE is nonzero, we do so even if it is already locked.
336 Return 1 if successful, 0 if not. */
339 lock_file_1 (lfname
, force
)
349 if (STRINGP (Fuser_login_name (Qnil
)))
350 user_name
= (char *)XSTRING (Fuser_login_name (Qnil
))->data
;
353 if (STRINGP (Fsystem_name ()))
354 host_name
= (char *)XSTRING (Fsystem_name ())->data
;
357 lock_info_str
= (char *)alloca (strlen (user_name
) + strlen (host_name
)
360 boot_time
= get_boot_time ();
362 sprintf (lock_info_str
, "%s@%s.%lu:%lu", user_name
, host_name
,
363 (unsigned long) getpid (), (unsigned long) boot_time
);
365 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
366 (unsigned long) getpid ());
368 err
= symlink (lock_info_str
, lfname
);
369 if (errno
== EEXIST
&& force
)
372 err
= symlink (lock_info_str
, lfname
);
378 /* Return 1 if times A and B are no more than one second apart. */
381 within_one_second (a
, b
)
384 return (a
- b
>= -1 && a
- b
<= 1);
387 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
388 1 if another process owns it (and set OWNER (if non-null) to info),
389 2 if the current process owns it,
390 or -1 if something is wrong with the locking mechanism. */
393 current_lock_owner (owner
, lfname
)
394 lock_info_type
*owner
;
398 extern char *rindex (), *index ();
402 char *at
, *dot
, *colon
;
405 /* Read arbitrarily-long contents of symlink. Similar code in
406 file-symlink-p in fileio.c. */
410 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
411 len
= readlink (lfname
, lfinfo
, bufsize
);
413 while (len
>= bufsize
);
415 /* If nonexistent lock file, all is well; otherwise, got strange error. */
419 return errno
== ENOENT
? 0 : -1;
422 /* Link info exists, so `len' is its length. Null terminate. */
425 /* Even if the caller doesn't want the owner info, we still have to
426 read it to determine return value, so allocate it. */
429 owner
= (lock_info_type
*) alloca (sizeof (lock_info_type
));
433 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
434 /* The USER is everything before the first @. */
435 at
= index (lfinfo
, '@');
436 dot
= rindex (lfinfo
, '.');
443 owner
->user
= (char *) xmalloc (len
+ 1);
444 strncpy (owner
->user
, lfinfo
, len
);
445 owner
->user
[len
] = 0;
447 /* The PID is everything from the last `.' to the `:'. */
448 owner
->pid
= atoi (dot
+ 1);
450 while (*colon
&& *colon
!= ':')
452 /* After the `:', if there is one, comes the boot time. */
454 owner
->boot_time
= atoi (colon
+ 1);
456 owner
->boot_time
= 0;
458 /* The host is everything in between. */
460 owner
->host
= (char *) xmalloc (len
+ 1);
461 strncpy (owner
->host
, at
+ 1, len
);
462 owner
->host
[len
] = 0;
464 /* We're done looking at the link info. */
467 /* On current host? */
468 if (STRINGP (Fsystem_name ())
469 && strcmp (owner
->host
, XSTRING (Fsystem_name ())->data
) == 0)
471 if (owner
->pid
== getpid ())
472 ret
= 2; /* We own it. */
473 else if (owner
->pid
> 0
474 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
)
475 && (owner
->boot_time
== 0
476 || within_one_second (owner
->boot_time
, get_boot_time ())))
477 ret
= 1; /* An existing process on this machine owns it. */
478 /* The owner process is dead or has a strange pid (<=0), so try to
480 else if (unlink (lfname
) < 0)
486 { /* If we wanted to support the check for stale locks on remote machines,
487 here's where we'd do it. */
492 if (local_owner
|| ret
<= 0)
494 FREE_LOCK_INFO (*owner
);
500 /* Lock the lock named LFNAME if possible.
501 Return 0 in that case.
502 Return positive if some other process owns the lock, and info about
503 that process in CLASHER.
504 Return -1 if cannot lock for any other reason. */
507 lock_if_free (clasher
, lfname
)
508 lock_info_type
*clasher
;
509 register char *lfname
;
511 while (lock_file_1 (lfname
, 0) == 0)
518 locker
= current_lock_owner (clasher
, lfname
);
521 FREE_LOCK_INFO (*clasher
);
522 return 0; /* We ourselves locked it. */
524 else if (locker
== 1)
525 return 1; /* Someone else has it. */
526 else if (locker
== -1)
527 return -1; /* current_lock_owner returned strange error. */
529 /* We deleted a stale lock; try again to lock the file. */
534 /* lock_file locks file FN,
535 meaning it serves notice on the world that you intend to edit that file.
536 This should be done only when about to modify a file-visiting
537 buffer previously unmodified.
538 Do not (normally) call this for a buffer already modified,
539 as either the file is already locked, or the user has already
540 decided to go ahead without locking.
542 When this returns, either the lock is locked for us,
543 or the user has said to go ahead without locking.
545 If the file is locked by someone else, this calls
546 ask-user-about-lock (a Lisp function) with two arguments,
547 the file name and info about the user who did the locking.
548 This function can signal an error, or return t meaning
549 take away the lock, or return nil meaning ignore the lock. */
555 register Lisp_Object attack
, orig_fn
, encoded_fn
;
556 register char *lfname
, *locker
;
557 lock_info_type lock_info
;
560 /* Don't do locking while dumping Emacs.
561 Uncompressing wtmp files uses call-process, which does not work
562 in an uninitialized Emacs. */
563 if (! NILP (Vpurify_flag
))
568 fn
= Fexpand_file_name (fn
, Qnil
);
569 encoded_fn
= ENCODE_FILE (fn
);
571 /* Create the name of the lock-file for file fn */
572 MAKE_LOCK_NAME (lfname
, encoded_fn
);
574 /* See if this file is visited and has changed on disk since it was
577 register Lisp_Object subject_buf
;
579 subject_buf
= get_truename_buffer (orig_fn
);
581 if (!NILP (subject_buf
)
582 && NILP (Fverify_visited_file_modtime (subject_buf
))
583 && !NILP (Ffile_exists_p (fn
)))
584 call1 (intern ("ask-user-about-supersession-threat"), fn
);
589 /* Try to lock the lock. */
590 if (lock_if_free (&lock_info
, lfname
) <= 0)
591 /* Return now if we have locked it, or if lock creation failed */
594 /* Else consider breaking the lock */
595 locker
= (char *) alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
597 sprintf (locker
, "%s@%s (pid %lu)", lock_info
.user
, lock_info
.host
,
599 FREE_LOCK_INFO (lock_info
);
601 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
603 /* User says take the lock */
605 lock_file_1 (lfname
, 1);
608 /* User says ignore the lock */
613 register Lisp_Object fn
;
615 register char *lfname
;
617 fn
= Fexpand_file_name (fn
, Qnil
);
618 fn
= ENCODE_FILE (fn
);
620 MAKE_LOCK_NAME (lfname
, fn
);
622 if (current_lock_owner (0, lfname
) == 2)
629 register Lisp_Object tail
;
630 register struct buffer
*b
;
632 for (tail
= Vbuffer_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
634 b
= XBUFFER (XCDR (XCAR (tail
)));
635 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
637 register char *lfname
;
639 MAKE_LOCK_NAME (lfname
, b
->file_truename
);
641 if (current_lock_owner (0, lfname
) == 2)
647 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
649 "Lock FILE, if current buffer is modified.\n\
650 FILE defaults to current buffer's visited file,\n\
651 or else nothing is done if current buffer isn't visiting a file.")
656 file
= current_buffer
->file_truename
;
658 CHECK_STRING (file
, 0);
659 if (SAVE_MODIFF
< MODIFF
665 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
667 "Unlock the file visited in the current buffer,\n\
668 if it should normally be locked.")
671 if (SAVE_MODIFF
< MODIFF
672 && STRINGP (current_buffer
->file_truename
))
673 unlock_file (current_buffer
->file_truename
);
677 /* Unlock the file visited in buffer BUFFER. */
680 unlock_buffer (buffer
)
681 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 "Return nil if the FILENAME is not locked,\n\
690 t if it is locked by you, else a string of the name of the locker.")
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;
729 DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory
,
730 "The directory for writing temporary files.");
731 Vtemporary_file_directory
= Qnil
;
733 defsubr (&Sunlock_buffer
);
734 defsubr (&Slock_buffer
);
735 defsubr (&Sfile_locked_p
);
738 #endif /* CLASH_DETECTION */