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. */
22 #include <sys/types.h>
48 #include <sys/types.h>
49 #include <sys/sysctl.h>
50 #endif /* __FreeBSD__ */
64 #ifdef CLASH_DETECTION
68 /* A file whose last-modified time is just after the most recent boot.
69 Define this to be NULL to disable checking for this file. */
70 #ifndef BOOT_TIME_FILE
71 #define BOOT_TIME_FILE "/var/run/random-seed"
75 #define WTMP_FILE "/var/log/wtmp"
78 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
79 directory, with link data `user@host.pid'. This avoids a single
80 mount (== failure) point for lock files.
82 When the host in the lock data is the current host, we can check if
83 the pid is valid with kill.
85 Otherwise, we could look at a separate file that maps hostnames to
86 reboot times to see if the remote pid can possibly be valid, since we
87 don't want Emacs to have to communicate via pipes or sockets or
88 whatever to other processes, either locally or remotely; rms says
89 that's too unreliable. Hence the separate file, which could
90 theoretically be updated by daemons running separately -- but this
91 whole idea is unimplemented; in practice, at least in our
92 environment, it seems such stale locks arise fairly infrequently, and
93 Emacs' standard methods of dealing with clashes suffice.
95 We use symlinks instead of normal files because (1) they can be
96 stored more efficiently on the filesystem, since the kernel knows
97 they will be small, and (2) all the info about the lock can be read
98 in a single system call (readlink). Although we could use regular
99 files to be useful on old systems lacking symlinks, nowadays
100 virtually all such systems are probably single-user anyway, so it
101 didn't seem worth the complication.
103 Similarly, we don't worry about a possible 14-character limit on
104 file names, because those are all the same systems that don't have
107 This is compatible with the locking scheme used by Interleaf (which
108 has contributed this implementation for Emacs), and was designed by
109 Ethan Jacobson, Kimbo Mundy, and others.
111 --karl@cs.umb.edu/karl@hq.ileaf.com. */
114 /* Return the time of the last system boot. */
116 static time_t boot_time
;
117 static int boot_time_initialized
;
119 extern Lisp_Object Vshell_file_name
;
126 if (boot_time_initialized
)
128 boot_time_initialized
= 1;
130 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
134 struct timeval boottime_val
;
137 mib
[1] = KERN_BOOTTIME
;
138 size
= sizeof (boottime_val
);
140 if (sysctl (mib
, 2, &boottime_val
, &size
, NULL
, 0) >= 0)
142 boot_time
= boottime_val
.tv_sec
;
146 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
151 if (stat (BOOT_TIME_FILE
, &st
) == 0)
153 boot_time
= st
.st_mtime
;
158 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
160 /* The utmp routines maintain static state.
161 Don't touch that state unless we are initialized,
162 since it might not survive dumping. */
165 #endif /* not CANNOT_DUMP */
167 /* Try to get boot time from utmp before wtmp,
168 since utmp is typically much smaller than wtmp.
169 Passing a null pointer causes get_boot_time_1
170 to inspect the default file, namely utmp. */
171 get_boot_time_1 ((char *) 0, 0);
175 /* Try to get boot time from the current wtmp file. */
176 get_boot_time_1 (WTMP_FILE
, 1);
178 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
179 for (counter
= 0; counter
< 20 && ! boot_time
; counter
++)
181 char cmd_string
[100];
182 Lisp_Object tempname
, filename
;
187 sprintf (cmd_string
, "%s.%d", WTMP_FILE
, counter
);
188 tempname
= build_string (cmd_string
);
189 if (! NILP (Ffile_exists_p (tempname
)))
193 sprintf (cmd_string
, "%s.%d.gz", WTMP_FILE
, counter
);
194 tempname
= build_string (cmd_string
);
195 if (! NILP (Ffile_exists_p (tempname
)))
198 tempname
= Fmake_temp_name (build_string ("wtmp"));
199 args
[0] = Vshell_file_name
;
203 args
[4] = build_string ("-c");
204 sprintf (cmd_string
, "gunzip < %s.%d.gz > %s",
205 WTMP_FILE
, counter
, XSTRING (tempname
)->data
);
206 args
[5] = build_string (cmd_string
);
207 Fcall_process (6, args
);
213 if (! NILP (filename
))
215 get_boot_time_1 (XSTRING (filename
)->data
, 1);
217 unlink (XSTRING (filename
)->data
);
228 /* Try to get the boot time from wtmp file FILENAME.
229 This succeeds if that file contains a reboot record.
231 If FILENAME is zero, use the same file as before;
232 if no FILENAME has ever been specified, this is the utmp file.
233 Use the newest reboot record if NEWEST is nonzero,
234 the first reboot record otherwise.
235 Ignore all reboot records on or before BOOT_TIME.
236 Success is indicated by setting BOOT_TIME to a larger value. */
238 get_boot_time_1 (filename
, newest
)
242 struct utmp ut
, *utp
;
247 /* On some versions of IRIX, opening a nonexistent file name
248 is likely to crash in the utmp routines. */
249 desc
= open (filename
, O_RDONLY
);
262 /* Find the next reboot record. */
263 ut
.ut_type
= BOOT_TIME
;
267 /* Compare reboot times and use the newest one. */
268 if (utp
->ut_time
> boot_time
)
270 boot_time
= utp
->ut_time
;
274 /* Advance on element in the file
275 so that getutid won't repeat the same one. */
282 #endif /* BOOT_TIME */
284 /* Here is the structure that stores information about a lock. */
294 /* When we read the info back, we might need this much more,
295 enough for decimal representation plus null. */
296 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
298 /* Free the two dynamically-allocated pieces in PTR. */
299 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
302 /* Write the name of the lock file for FN into LFNAME. Length will be
303 that of FN plus two more for the leading `.#' plus one for the null. */
304 #define MAKE_LOCK_NAME(lock, file) \
305 (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
306 fill_in_lock_file_name (lock, (file)))
309 fill_in_lock_file_name (lockfile
, fn
)
310 register char *lockfile
;
311 register Lisp_Object fn
;
315 strcpy (lockfile
, XSTRING (fn
)->data
);
317 /* Shift the nondirectory part of the file name (including the null)
318 right two characters. Here is one of the places where we'd have to
319 do something to support 14-character-max file names. */
320 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
323 /* Insert the `.#'. */
328 /* Lock the lock file named LFNAME.
329 If FORCE is nonzero, we do so even if it is already locked.
330 Return 1 if successful, 0 if not. */
333 lock_file_1 (lfname
, force
)
343 if (STRINGP (Fuser_login_name (Qnil
)))
344 user_name
= (char *)XSTRING (Fuser_login_name (Qnil
))->data
;
347 if (STRINGP (Fsystem_name ()))
348 host_name
= (char *)XSTRING (Fsystem_name ())->data
;
351 lock_info_str
= (char *)alloca (strlen (user_name
) + strlen (host_name
)
354 boot_time
= get_boot_time ();
356 sprintf (lock_info_str
, "%s@%s.%lu:%lu", user_name
, host_name
,
357 (unsigned long) getpid (), (unsigned long) boot_time
);
359 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
360 (unsigned long) getpid ());
362 err
= symlink (lock_info_str
, lfname
);
363 if (errno
== EEXIST
&& force
)
366 err
= symlink (lock_info_str
, lfname
);
372 /* Return 1 if times A and B are no more than one second apart. */
375 within_one_second (a
, b
)
378 return (a
- b
>= -1 && a
- b
<= 1);
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. */
387 current_lock_owner (owner
, lfname
)
388 lock_info_type
*owner
;
392 extern char *rindex (), *index ();
396 char *at
, *dot
, *colon
;
399 /* Read arbitrarily-long contents of symlink. Similar code in
400 file-symlink-p in fileio.c. */
404 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
405 len
= readlink (lfname
, lfinfo
, bufsize
);
407 while (len
>= bufsize
);
409 /* If nonexistent lock file, all is well; otherwise, got strange error. */
413 return errno
== ENOENT
? 0 : -1;
416 /* Link info exists, so `len' is its length. Null terminate. */
419 /* Even if the caller doesn't want the owner info, we still have to
420 read it to determine return value, so allocate it. */
423 owner
= (lock_info_type
*) alloca (sizeof (lock_info_type
));
427 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
428 /* The USER is everything before the first @. */
429 at
= index (lfinfo
, '@');
430 dot
= rindex (lfinfo
, '.');
437 owner
->user
= (char *) xmalloc (len
+ 1);
438 strncpy (owner
->user
, lfinfo
, len
);
439 owner
->user
[len
] = 0;
441 /* The PID is everything from the last `.' to the `:'. */
442 owner
->pid
= atoi (dot
+ 1);
444 while (*colon
&& *colon
!= ':')
446 /* After the `:', if there is one, comes the boot time. */
448 owner
->boot_time
= atoi (colon
+ 1);
450 owner
->boot_time
= 0;
452 /* The host is everything in between. */
454 owner
->host
= (char *) xmalloc (len
+ 1);
455 strncpy (owner
->host
, at
+ 1, len
);
456 owner
->host
[len
] = 0;
458 /* We're done looking at the link info. */
461 /* On current host? */
462 if (STRINGP (Fsystem_name ())
463 && strcmp (owner
->host
, XSTRING (Fsystem_name ())->data
) == 0)
465 if (owner
->pid
== getpid ())
466 ret
= 2; /* We own it. */
467 else if (owner
->pid
> 0
468 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
)
469 && (owner
->boot_time
== 0
470 || within_one_second (owner
->boot_time
, get_boot_time ())))
471 ret
= 1; /* An existing process on this machine owns it. */
472 /* The owner process is dead or has a strange pid (<=0), so try to
474 else if (unlink (lfname
) < 0)
480 { /* If we wanted to support the check for stale locks on remote machines,
481 here's where we'd do it. */
486 if (local_owner
|| ret
<= 0)
488 FREE_LOCK_INFO (*owner
);
494 /* Lock the lock named LFNAME if possible.
495 Return 0 in that case.
496 Return positive if some other process owns the lock, and info about
497 that process in CLASHER.
498 Return -1 if cannot lock for any other reason. */
501 lock_if_free (clasher
, lfname
)
502 lock_info_type
*clasher
;
503 register char *lfname
;
505 while (lock_file_1 (lfname
, 0) == 0)
512 locker
= current_lock_owner (clasher
, lfname
);
515 FREE_LOCK_INFO (*clasher
);
516 return 0; /* We ourselves locked it. */
518 else if (locker
== 1)
519 return 1; /* Someone else has it. */
520 else if (locker
== -1)
521 return -1; /* current_lock_owner returned strange error. */
523 /* We deleted a stale lock; try again to lock the file. */
528 /* lock_file locks file FN,
529 meaning it serves notice on the world that you intend to edit that file.
530 This should be done only when about to modify a file-visiting
531 buffer previously unmodified.
532 Do not (normally) call this for a buffer already modified,
533 as either the file is already locked, or the user has already
534 decided to go ahead without locking.
536 When this returns, either the lock is locked for us,
537 or the user has said to go ahead without locking.
539 If the file is locked by someone else, this calls
540 ask-user-about-lock (a Lisp function) with two arguments,
541 the file name and info about the user who did the locking.
542 This function can signal an error, or return t meaning
543 take away the lock, or return nil meaning ignore the lock. */
549 register Lisp_Object attack
, orig_fn
, encoded_fn
;
550 register char *lfname
, *locker
;
551 lock_info_type lock_info
;
553 /* Don't do locking while dumping Emacs.
554 Uncompressing wtmp files uses call-process, which does not work
555 in an uninitialized Emacs. */
556 if (! NILP (Vpurify_flag
))
560 fn
= Fexpand_file_name (fn
, Qnil
);
561 encoded_fn
= ENCODE_FILE (fn
);
563 /* Create the name of the lock-file for file fn */
564 MAKE_LOCK_NAME (lfname
, encoded_fn
);
566 /* See if this file is visited and has changed on disk since it was
569 register Lisp_Object subject_buf
;
572 subject_buf
= get_truename_buffer (orig_fn
);
575 if (!NILP (subject_buf
)
576 && NILP (Fverify_visited_file_modtime (subject_buf
))
577 && !NILP (Ffile_exists_p (fn
)))
578 call1 (intern ("ask-user-about-supersession-threat"), fn
);
583 /* Try to lock the lock. */
584 if (lock_if_free (&lock_info
, lfname
) <= 0)
585 /* Return now if we have locked it, or if lock creation failed */
588 /* Else consider breaking the lock */
589 locker
= (char *) alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
591 sprintf (locker
, "%s@%s (pid %lu)", lock_info
.user
, lock_info
.host
,
593 FREE_LOCK_INFO (lock_info
);
595 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
597 /* User says take the lock */
599 lock_file_1 (lfname
, 1);
602 /* User says ignore the lock */
607 register Lisp_Object fn
;
609 register char *lfname
;
611 fn
= Fexpand_file_name (fn
, Qnil
);
612 fn
= ENCODE_FILE (fn
);
614 MAKE_LOCK_NAME (lfname
, fn
);
616 if (current_lock_owner (0, lfname
) == 2)
623 register Lisp_Object tail
;
624 register struct buffer
*b
;
626 for (tail
= Vbuffer_alist
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
628 b
= XBUFFER (XCONS (XCONS (tail
)->car
)->cdr
);
629 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
631 register char *lfname
;
633 MAKE_LOCK_NAME (lfname
, b
->file_truename
);
635 if (current_lock_owner (0, lfname
) == 2)
641 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
643 "Lock FILE, if current buffer is modified.\n\
644 FILE defaults to current buffer's visited file,\n\
645 or else nothing is done if current buffer isn't visiting a file.")
650 file
= current_buffer
->file_truename
;
652 CHECK_STRING (file
, 0);
653 if (SAVE_MODIFF
< MODIFF
659 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
661 "Unlock the file visited in the current buffer,\n\
662 if it should normally be locked.")
665 if (SAVE_MODIFF
< MODIFF
666 && STRINGP (current_buffer
->file_truename
))
667 unlock_file (current_buffer
->file_truename
);
671 /* Unlock the file visited in buffer BUFFER. */
674 unlock_buffer (buffer
)
675 struct buffer
*buffer
;
677 if (BUF_SAVE_MODIFF (buffer
) < BUF_MODIFF (buffer
)
678 && STRINGP (buffer
->file_truename
))
679 unlock_file (buffer
->file_truename
);
682 DEFUN ("file-locked-p", Ffile_locked_p
, Sfile_locked_p
, 0, 1, 0,
683 "Return nil if the FILENAME is not locked,\n\
684 t if it is locked by you, else a string of the name of the locker.")
686 Lisp_Object filename
;
689 register char *lfname
;
691 lock_info_type locker
;
693 filename
= Fexpand_file_name (filename
, Qnil
);
695 MAKE_LOCK_NAME (lfname
, filename
);
697 owner
= current_lock_owner (&locker
, lfname
);
703 ret
= build_string (locker
.user
);
706 FREE_LOCK_INFO (locker
);
711 /* Initialization functions. */
717 boot_time_initialized
= 0;
723 defsubr (&Sunlock_buffer
);
724 defsubr (&Slock_buffer
);
725 defsubr (&Sfile_locked_p
);
728 #endif /* CLASH_DETECTION */