1 /* Lock files for editing.
2 Copyright (C) 1985, 86, 87, 93, 94, 96, 98, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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 2, or (at your option)
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.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include <sys/types.h>
48 #include <sys/sysctl.h>
49 #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
;
124 static void get_boot_time_1
P_ ((char *, int));
130 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
134 if (boot_time_initialized
)
136 boot_time_initialized
= 1;
138 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
142 struct timeval boottime_val
;
145 mib
[1] = KERN_BOOTTIME
;
146 size
= sizeof (boottime_val
);
148 if (sysctl (mib
, 2, &boottime_val
, &size
, NULL
, 0) >= 0)
150 boot_time
= boottime_val
.tv_sec
;
154 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
159 if (stat (BOOT_TIME_FILE
, &st
) == 0)
161 boot_time
= st
.st_mtime
;
166 #if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
168 /* The utmp routines maintain static state.
169 Don't touch that state unless we are initialized,
170 since it might not survive dumping. */
173 #endif /* not CANNOT_DUMP */
175 /* Try to get boot time from utmp before wtmp,
176 since utmp is typically much smaller than wtmp.
177 Passing a null pointer causes get_boot_time_1
178 to inspect the default file, namely utmp. */
179 get_boot_time_1 ((char *) 0, 0);
183 /* Try to get boot time from the current wtmp file. */
184 get_boot_time_1 (WTMP_FILE
, 1);
186 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
187 for (counter
= 0; counter
< 20 && ! boot_time
; counter
++)
189 char cmd_string
[100];
190 Lisp_Object tempname
, filename
;
195 sprintf (cmd_string
, "%s.%d", WTMP_FILE
, counter
);
196 tempname
= build_string (cmd_string
);
197 if (! NILP (Ffile_exists_p (tempname
)))
201 sprintf (cmd_string
, "%s.%d.gz", WTMP_FILE
, counter
);
202 tempname
= build_string (cmd_string
);
203 if (! NILP (Ffile_exists_p (tempname
)))
207 /* The utmp functions on mescaline.gnu.org accept only
208 file names up to 8 characters long. Choose a 2
209 character long prefix, and call make_temp_file with
210 second arg non-zero, so that it will add not more
211 than 6 characters to the prefix. */
212 tempname
= Fexpand_file_name (build_string ("wt"),
213 Vtemporary_file_directory
);
214 tempname
= make_temp_name (tempname
, 1);
215 args
[0] = Vshell_file_name
;
219 args
[4] = build_string ("-c");
220 sprintf (cmd_string
, "gunzip < %s.%d.gz > %s",
221 WTMP_FILE
, counter
, XSTRING (tempname
)->data
);
222 args
[5] = build_string (cmd_string
);
223 Fcall_process (6, args
);
229 if (! NILP (filename
))
231 get_boot_time_1 (XSTRING (filename
)->data
, 1);
233 unlink (XSTRING (filename
)->data
);
244 /* Try to get the boot time from wtmp file FILENAME.
245 This succeeds if that file contains a reboot record.
247 If FILENAME is zero, use the same file as before;
248 if no FILENAME has ever been specified, this is the utmp file.
249 Use the newest reboot record if NEWEST is nonzero,
250 the first reboot record otherwise.
251 Ignore all reboot records on or before BOOT_TIME.
252 Success is indicated by setting BOOT_TIME to a larger value. */
255 get_boot_time_1 (filename
, newest
)
259 struct utmp ut
, *utp
;
264 /* On some versions of IRIX, opening a nonexistent file name
265 is likely to crash in the utmp routines. */
266 desc
= emacs_open (filename
, O_RDONLY
, 0);
279 /* Find the next reboot record. */
280 ut
.ut_type
= BOOT_TIME
;
284 /* Compare reboot times and use the newest one. */
285 if (utp
->ut_time
> boot_time
)
287 boot_time
= utp
->ut_time
;
291 /* Advance on element in the file
292 so that getutid won't repeat the same one. */
299 #endif /* BOOT_TIME */
301 /* Here is the structure that stores information about a lock. */
311 /* When we read the info back, we might need this much more,
312 enough for decimal representation plus null. */
313 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
315 /* Free the two dynamically-allocated pieces in PTR. */
316 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
319 /* Write the name of the lock file for FN into LFNAME. Length will be
320 that of FN plus two more for the leading `.#' plus 1 for the
321 trailing period plus one for the digit after it plus one for the
323 #define MAKE_LOCK_NAME(lock, file) \
324 (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1 + 1 + 1), \
325 fill_in_lock_file_name (lock, (file)))
328 fill_in_lock_file_name (lockfile
, fn
)
329 register char *lockfile
;
330 register Lisp_Object fn
;
336 strcpy (lockfile
, XSTRING (fn
)->data
);
338 /* Shift the nondirectory part of the file name (including the null)
339 right two characters. Here is one of the places where we'd have to
340 do something to support 14-character-max file names. */
341 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
344 /* Insert the `.#'. */
350 while (lstat (lockfile
, &st
) == 0 && !S_ISLNK (st
.st_mode
))
357 sprintf (p
, ".%d", count
++);
361 /* Lock the lock file named LFNAME.
362 If FORCE is nonzero, we do so even if it is already locked.
363 Return 1 if successful, 0 if not. */
366 lock_file_1 (lfname
, force
)
376 if (STRINGP (Fuser_login_name (Qnil
)))
377 user_name
= (char *)XSTRING (Fuser_login_name (Qnil
))->data
;
380 if (STRINGP (Fsystem_name ()))
381 host_name
= (char *)XSTRING (Fsystem_name ())->data
;
384 lock_info_str
= (char *)alloca (strlen (user_name
) + strlen (host_name
)
387 boot_time
= get_boot_time ();
389 sprintf (lock_info_str
, "%s@%s.%lu:%lu", user_name
, host_name
,
390 (unsigned long) getpid (), (unsigned long) boot_time
);
392 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
393 (unsigned long) getpid ());
395 err
= symlink (lock_info_str
, lfname
);
396 if (errno
== EEXIST
&& force
)
399 err
= symlink (lock_info_str
, lfname
);
405 /* Return 1 if times A and B are no more than one second apart. */
408 within_one_second (a
, b
)
411 return (a
- b
>= -1 && a
- b
<= 1);
414 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
415 1 if another process owns it (and set OWNER (if non-null) to info),
416 2 if the current process owns it,
417 or -1 if something is wrong with the locking mechanism. */
420 current_lock_owner (owner
, lfname
)
421 lock_info_type
*owner
;
425 extern char *rindex (), *index ();
429 char *at
, *dot
, *colon
;
432 /* Read arbitrarily-long contents of symlink. Similar code in
433 file-symlink-p in fileio.c. */
437 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
439 len
= readlink (lfname
, lfinfo
, bufsize
);
441 /* HP-UX reports ERANGE if the buffer is too small. */
442 if (len
== -1 && errno
== ERANGE
)
446 while (len
>= bufsize
);
448 /* If nonexistent lock file, all is well; otherwise, got strange error. */
452 return errno
== ENOENT
? 0 : -1;
455 /* Link info exists, so `len' is its length. Null terminate. */
458 /* Even if the caller doesn't want the owner info, we still have to
459 read it to determine return value, so allocate it. */
462 owner
= (lock_info_type
*) alloca (sizeof (lock_info_type
));
466 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
467 /* The USER is everything before the first @. */
468 at
= index (lfinfo
, '@');
469 dot
= rindex (lfinfo
, '.');
476 owner
->user
= (char *) xmalloc (len
+ 1);
477 strncpy (owner
->user
, lfinfo
, len
);
478 owner
->user
[len
] = 0;
480 /* The PID is everything from the last `.' to the `:'. */
481 owner
->pid
= atoi (dot
+ 1);
483 while (*colon
&& *colon
!= ':')
485 /* After the `:', if there is one, comes the boot time. */
487 owner
->boot_time
= atoi (colon
+ 1);
489 owner
->boot_time
= 0;
491 /* The host is everything in between. */
493 owner
->host
= (char *) xmalloc (len
+ 1);
494 strncpy (owner
->host
, at
+ 1, len
);
495 owner
->host
[len
] = 0;
497 /* We're done looking at the link info. */
500 /* On current host? */
501 if (STRINGP (Fsystem_name ())
502 && strcmp (owner
->host
, XSTRING (Fsystem_name ())->data
) == 0)
504 if (owner
->pid
== getpid ())
505 ret
= 2; /* We own it. */
506 else if (owner
->pid
> 0
507 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
)
508 && (owner
->boot_time
== 0
509 || within_one_second (owner
->boot_time
, get_boot_time ())))
510 ret
= 1; /* An existing process on this machine owns it. */
511 /* The owner process is dead or has a strange pid (<=0), so try to
513 else if (unlink (lfname
) < 0)
519 { /* If we wanted to support the check for stale locks on remote machines,
520 here's where we'd do it. */
525 if (local_owner
|| ret
<= 0)
527 FREE_LOCK_INFO (*owner
);
533 /* Lock the lock named LFNAME if possible.
534 Return 0 in that case.
535 Return positive if some other process owns the lock, and info about
536 that process in CLASHER.
537 Return -1 if cannot lock for any other reason. */
540 lock_if_free (clasher
, lfname
)
541 lock_info_type
*clasher
;
542 register char *lfname
;
544 while (lock_file_1 (lfname
, 0) == 0)
551 locker
= current_lock_owner (clasher
, lfname
);
554 FREE_LOCK_INFO (*clasher
);
555 return 0; /* We ourselves locked it. */
557 else if (locker
== 1)
558 return 1; /* Someone else has it. */
559 else if (locker
== -1)
560 return -1; /* current_lock_owner returned strange error. */
562 /* We deleted a stale lock; try again to lock the file. */
567 /* lock_file locks file FN,
568 meaning it serves notice on the world that you intend to edit that file.
569 This should be done only when about to modify a file-visiting
570 buffer previously unmodified.
571 Do not (normally) call this for a buffer already modified,
572 as either the file is already locked, or the user has already
573 decided to go ahead without locking.
575 When this returns, either the lock is locked for us,
576 or the user has said to go ahead without locking.
578 If the file is locked by someone else, this calls
579 ask-user-about-lock (a Lisp function) with two arguments,
580 the file name and info about the user who did the locking.
581 This function can signal an error, or return t meaning
582 take away the lock, or return nil meaning ignore the lock. */
588 register Lisp_Object attack
, orig_fn
, encoded_fn
;
589 register char *lfname
, *locker
;
590 lock_info_type lock_info
;
593 /* Don't do locking while dumping Emacs.
594 Uncompressing wtmp files uses call-process, which does not work
595 in an uninitialized Emacs. */
596 if (! NILP (Vpurify_flag
))
601 fn
= Fexpand_file_name (fn
, Qnil
);
602 encoded_fn
= ENCODE_FILE (fn
);
604 /* Create the name of the lock-file for file fn */
605 MAKE_LOCK_NAME (lfname
, encoded_fn
);
607 /* See if this file is visited and has changed on disk since it was
610 register Lisp_Object subject_buf
;
612 subject_buf
= get_truename_buffer (orig_fn
);
614 if (!NILP (subject_buf
)
615 && NILP (Fverify_visited_file_modtime (subject_buf
))
616 && !NILP (Ffile_exists_p (fn
)))
617 call1 (intern ("ask-user-about-supersession-threat"), fn
);
622 /* Try to lock the lock. */
623 if (lock_if_free (&lock_info
, lfname
) <= 0)
624 /* Return now if we have locked it, or if lock creation failed */
627 /* Else consider breaking the lock */
628 locker
= (char *) alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
630 sprintf (locker
, "%s@%s (pid %lu)", lock_info
.user
, lock_info
.host
,
632 FREE_LOCK_INFO (lock_info
);
634 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
636 /* User says take the lock */
638 lock_file_1 (lfname
, 1);
641 /* User says ignore the lock */
646 register Lisp_Object fn
;
648 register char *lfname
;
650 fn
= Fexpand_file_name (fn
, Qnil
);
651 fn
= ENCODE_FILE (fn
);
653 MAKE_LOCK_NAME (lfname
, fn
);
655 if (current_lock_owner (0, lfname
) == 2)
662 register Lisp_Object tail
;
663 register struct buffer
*b
;
665 for (tail
= Vbuffer_alist
; GC_CONSP (tail
); tail
= XCDR (tail
))
667 b
= XBUFFER (XCDR (XCAR (tail
)));
668 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
670 unlock_file(b
->file_truename
);
675 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
677 "Lock FILE, if current buffer is modified.\n\
678 FILE defaults to current buffer's visited file,\n\
679 or else nothing is done if current buffer isn't visiting a file.")
684 file
= current_buffer
->file_truename
;
686 CHECK_STRING (file
, 0);
687 if (SAVE_MODIFF
< MODIFF
693 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
695 "Unlock the file visited in the current buffer,\n\
696 if it should normally be locked.")
699 if (SAVE_MODIFF
< MODIFF
700 && STRINGP (current_buffer
->file_truename
))
701 unlock_file (current_buffer
->file_truename
);
705 /* Unlock the file visited in buffer BUFFER. */
708 unlock_buffer (buffer
)
709 struct buffer
*buffer
;
711 if (BUF_SAVE_MODIFF (buffer
) < BUF_MODIFF (buffer
)
712 && STRINGP (buffer
->file_truename
))
713 unlock_file (buffer
->file_truename
);
716 DEFUN ("file-locked-p", Ffile_locked_p
, Sfile_locked_p
, 1, 1, 0,
717 "Return nil if the FILENAME is not locked,\n\
718 t if it is locked by you, else a string of the name of the locker.")
720 Lisp_Object filename
;
723 register char *lfname
;
725 lock_info_type locker
;
727 filename
= Fexpand_file_name (filename
, Qnil
);
729 MAKE_LOCK_NAME (lfname
, filename
);
731 owner
= current_lock_owner (&locker
, lfname
);
737 ret
= build_string (locker
.user
);
740 FREE_LOCK_INFO (locker
);
745 /* Initialization functions. */
751 boot_time_initialized
= 0;
757 DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory
,
758 "The directory for writing temporary files.");
759 Vtemporary_file_directory
= Qnil
;
761 defsubr (&Sunlock_buffer
);
762 defsubr (&Slock_buffer
);
763 defsubr (&Sfile_locked_p
);
766 #endif /* CLASH_DETECTION */