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 /* The directory for writing temporary files. */
51 Lisp_Object Vtemporary_file_directory
;
53 #ifdef CLASH_DETECTION
59 #if !defined (S_ISLNK) && defined (S_IFLNK)
60 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
63 /* A file whose last-modified time is just after the most recent boot.
64 Define this to be NULL to disable checking for this file. */
65 #ifndef BOOT_TIME_FILE
66 #define BOOT_TIME_FILE "/var/run/random-seed"
70 #define WTMP_FILE "/var/log/wtmp"
73 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
74 directory, with link data `user@host.pid'. This avoids a single
75 mount (== failure) point for lock files.
77 When the host in the lock data is the current host, we can check if
78 the pid is valid with kill.
80 Otherwise, we could look at a separate file that maps hostnames to
81 reboot times to see if the remote pid can possibly be valid, since we
82 don't want Emacs to have to communicate via pipes or sockets or
83 whatever to other processes, either locally or remotely; rms says
84 that's too unreliable. Hence the separate file, which could
85 theoretically be updated by daemons running separately -- but this
86 whole idea is unimplemented; in practice, at least in our
87 environment, it seems such stale locks arise fairly infrequently, and
88 Emacs' standard methods of dealing with clashes suffice.
90 We use symlinks instead of normal files because (1) they can be
91 stored more efficiently on the filesystem, since the kernel knows
92 they will be small, and (2) all the info about the lock can be read
93 in a single system call (readlink). Although we could use regular
94 files to be useful on old systems lacking symlinks, nowadays
95 virtually all such systems are probably single-user anyway, so it
96 didn't seem worth the complication.
98 Similarly, we don't worry about a possible 14-character limit on
99 file names, because those are all the same systems that don't have
102 This is compatible with the locking scheme used by Interleaf (which
103 has contributed this implementation for Emacs), and was designed by
104 Ethan Jacobson, Kimbo Mundy, and others.
106 --karl@cs.umb.edu/karl@hq.ileaf.com. */
109 /* Return the time of the last system boot. */
111 static time_t boot_time
;
112 static int boot_time_initialized
;
115 static void get_boot_time_1 (const char *, int);
121 #if defined (BOOT_TIME)
125 if (boot_time_initialized
)
127 boot_time_initialized
= 1;
129 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
133 struct timeval boottime_val
;
136 mib
[1] = KERN_BOOTTIME
;
137 size
= sizeof (boottime_val
);
139 if (sysctl (mib
, 2, &boottime_val
, &size
, NULL
, 0) >= 0)
141 boot_time
= boottime_val
.tv_sec
;
145 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
150 if (stat (BOOT_TIME_FILE
, &st
) == 0)
152 boot_time
= st
.st_mtime
;
157 #if defined (BOOT_TIME)
159 /* The utmp routines maintain static state.
160 Don't touch that state unless we are initialized,
161 since it might not survive dumping. */
164 #endif /* not CANNOT_DUMP */
166 /* Try to get boot time from utmp before wtmp,
167 since utmp is typically much smaller than wtmp.
168 Passing a null pointer causes get_boot_time_1
169 to inspect the default file, namely utmp. */
170 get_boot_time_1 ((char *) 0, 0);
174 /* Try to get boot time from the current wtmp file. */
175 get_boot_time_1 (WTMP_FILE
, 1);
177 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
178 for (counter
= 0; counter
< 20 && ! boot_time
; counter
++)
180 char cmd_string
[100];
181 Lisp_Object tempname
, filename
;
186 sprintf (cmd_string
, "%s.%d", WTMP_FILE
, counter
);
187 tempname
= build_string (cmd_string
);
188 if (! NILP (Ffile_exists_p (tempname
)))
192 sprintf (cmd_string
, "%s.%d.gz", WTMP_FILE
, counter
);
193 tempname
= build_string (cmd_string
);
194 if (! NILP (Ffile_exists_p (tempname
)))
198 /* The utmp functions on mescaline.gnu.org accept only
199 file names up to 8 characters long. Choose a 2
200 character long prefix, and call make_temp_file with
201 second arg non-zero, so that it will add not more
202 than 6 characters to the prefix. */
203 tempname
= Fexpand_file_name (build_string ("wt"),
204 Vtemporary_file_directory
);
205 tempname
= make_temp_name (tempname
, 1);
206 args
[0] = Vshell_file_name
;
210 args
[4] = build_string ("-c");
211 sprintf (cmd_string
, "gunzip < %s.%d.gz > %s",
212 WTMP_FILE
, counter
, SDATA (tempname
));
213 args
[5] = build_string (cmd_string
);
214 Fcall_process (6, args
);
220 if (! NILP (filename
))
222 get_boot_time_1 (SDATA (filename
), 1);
224 unlink (SDATA (filename
));
235 /* Try to get the boot time from wtmp file FILENAME.
236 This succeeds if that file contains a reboot record.
238 If FILENAME is zero, use the same file as before;
239 if no FILENAME has ever been specified, this is the utmp file.
240 Use the newest reboot record if NEWEST is nonzero,
241 the first reboot record otherwise.
242 Ignore all reboot records on or before BOOT_TIME.
243 Success is indicated by setting BOOT_TIME to a larger value. */
246 get_boot_time_1 (const char *filename
, int 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 1 for the
310 trailing period plus one for the digit after it plus one for the
312 #define MAKE_LOCK_NAME(lock, file) \
313 (lock = (char *) alloca (SBYTES (file) + 2 + 1 + 1 + 1), \
314 fill_in_lock_file_name (lock, (file)))
317 fill_in_lock_file_name (register char *lockfile
, register Lisp_Object fn
)
323 strcpy (lockfile
, SDATA (fn
));
325 /* Shift the nondirectory part of the file name (including the null)
326 right two characters. Here is one of the places where we'd have to
327 do something to support 14-character-max file names. */
328 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
331 /* Insert the `.#'. */
337 while (lstat (lockfile
, &st
) == 0 && !S_ISLNK (st
.st_mode
))
344 sprintf (p
, ".%d", count
++);
348 /* Lock the lock file named LFNAME.
349 If FORCE is nonzero, we do so even if it is already locked.
350 Return 1 if successful, 0 if not. */
353 lock_file_1 (char *lfname
, int force
)
357 const char *user_name
;
358 const char *host_name
;
361 /* Call this first because it can GC. */
362 boot_time
= get_boot_time ();
364 if (STRINGP (Fuser_login_name (Qnil
)))
365 user_name
= (char *)SDATA (Fuser_login_name (Qnil
));
368 if (STRINGP (Fsystem_name ()))
369 host_name
= (char *)SDATA (Fsystem_name ());
372 lock_info_str
= (char *)alloca (strlen (user_name
) + strlen (host_name
)
373 + LOCK_PID_MAX
+ 30);
376 sprintf (lock_info_str
, "%s@%s.%lu:%lu", user_name
, host_name
,
377 (unsigned long) getpid (), (unsigned long) boot_time
);
379 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
380 (unsigned long) getpid ());
382 err
= symlink (lock_info_str
, lfname
);
383 if (errno
== EEXIST
&& force
)
386 err
= symlink (lock_info_str
, lfname
);
392 /* Return 1 if times A and B are no more than one second apart. */
395 within_one_second (time_t a
, time_t b
)
397 return (a
- b
>= -1 && a
- b
<= 1);
400 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
401 1 if another process owns it (and set OWNER (if non-null) to info),
402 2 if the current process owns it,
403 or -1 if something is wrong with the locking mechanism. */
406 current_lock_owner (lock_info_type
*owner
, char *lfname
)
410 char *at
, *dot
, *colon
;
413 /* Read arbitrarily-long contents of symlink. Similar code in
414 file-symlink-p in fileio.c. */
418 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
420 len
= readlink (lfname
, lfinfo
, bufsize
);
422 /* HP-UX reports ERANGE if the buffer is too small. */
423 if (len
== -1 && errno
== ERANGE
)
427 while (len
>= bufsize
);
429 /* If nonexistent lock file, all is well; otherwise, got strange error. */
433 return errno
== ENOENT
? 0 : -1;
436 /* Link info exists, so `len' is its length. Null terminate. */
439 /* Even if the caller doesn't want the owner info, we still have to
440 read it to determine return value, so allocate it. */
443 owner
= (lock_info_type
*) alloca (sizeof (lock_info_type
));
447 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
448 /* The USER is everything before the last @. */
449 at
= strrchr (lfinfo
, '@');
450 dot
= strrchr (lfinfo
, '.');
457 owner
->user
= (char *) xmalloc (len
+ 1);
458 strncpy (owner
->user
, lfinfo
, len
);
459 owner
->user
[len
] = 0;
461 /* The PID is everything from the last `.' to the `:'. */
462 owner
->pid
= atoi (dot
+ 1);
464 while (*colon
&& *colon
!= ':')
466 /* After the `:', if there is one, comes the boot time. */
468 owner
->boot_time
= atoi (colon
+ 1);
470 owner
->boot_time
= 0;
472 /* The host is everything in between. */
474 owner
->host
= (char *) xmalloc (len
+ 1);
475 strncpy (owner
->host
, at
+ 1, len
);
476 owner
->host
[len
] = 0;
478 /* We're done looking at the link info. */
481 /* On current host? */
482 if (STRINGP (Fsystem_name ())
483 && strcmp (owner
->host
, SDATA (Fsystem_name ())) == 0)
485 if (owner
->pid
== getpid ())
486 ret
= 2; /* We own it. */
487 else if (owner
->pid
> 0
488 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
)
489 && (owner
->boot_time
== 0
490 || within_one_second (owner
->boot_time
, get_boot_time ())))
491 ret
= 1; /* An existing process on this machine owns it. */
492 /* The owner process is dead or has a strange pid (<=0), so try to
494 else if (unlink (lfname
) < 0)
500 { /* If we wanted to support the check for stale locks on remote machines,
501 here's where we'd do it. */
506 if (local_owner
|| ret
<= 0)
508 FREE_LOCK_INFO (*owner
);
514 /* Lock the lock named LFNAME if possible.
515 Return 0 in that case.
516 Return positive if some other process owns the lock, and info about
517 that process in CLASHER.
518 Return -1 if cannot lock for any other reason. */
521 lock_if_free (lock_info_type
*clasher
, register char *lfname
)
523 while (lock_file_1 (lfname
, 0) == 0)
530 locker
= current_lock_owner (clasher
, lfname
);
533 FREE_LOCK_INFO (*clasher
);
534 return 0; /* We ourselves locked it. */
536 else if (locker
== 1)
537 return 1; /* Someone else has it. */
538 else if (locker
== -1)
539 return -1; /* current_lock_owner returned strange error. */
541 /* We deleted a stale lock; try again to lock the file. */
546 /* lock_file locks file FN,
547 meaning it serves notice on the world that you intend to edit that file.
548 This should be done only when about to modify a file-visiting
549 buffer previously unmodified.
550 Do not (normally) call this for a buffer already modified,
551 as either the file is already locked, or the user has already
552 decided to go ahead without locking.
554 When this returns, either the lock is locked for us,
555 or the user has said to go ahead without locking.
557 If the file is locked by someone else, this calls
558 ask-user-about-lock (a Lisp function) with two arguments,
559 the file name and info about the user who did the locking.
560 This function can signal an error, or return t meaning
561 take away the lock, or return nil meaning ignore the lock. */
564 lock_file (Lisp_Object fn
)
566 register Lisp_Object attack
, orig_fn
, encoded_fn
;
567 register char *lfname
, *locker
;
568 lock_info_type lock_info
;
571 /* Don't do locking while dumping Emacs.
572 Uncompressing wtmp files uses call-process, which does not work
573 in an uninitialized Emacs. */
574 if (! NILP (Vpurify_flag
))
579 fn
= Fexpand_file_name (fn
, Qnil
);
580 encoded_fn
= ENCODE_FILE (fn
);
582 /* Create the name of the lock-file for file fn */
583 MAKE_LOCK_NAME (lfname
, encoded_fn
);
585 /* See if this file is visited and has changed on disk since it was
588 register Lisp_Object subject_buf
;
590 subject_buf
= get_truename_buffer (orig_fn
);
592 if (!NILP (subject_buf
)
593 && NILP (Fverify_visited_file_modtime (subject_buf
))
594 && !NILP (Ffile_exists_p (fn
)))
595 call1 (intern ("ask-user-about-supersession-threat"), fn
);
600 /* Try to lock the lock. */
601 if (lock_if_free (&lock_info
, lfname
) <= 0)
602 /* Return now if we have locked it, or if lock creation failed */
605 /* Else consider breaking the lock */
606 locker
= (char *) alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
608 sprintf (locker
, "%s@%s (pid %lu)", lock_info
.user
, lock_info
.host
,
610 FREE_LOCK_INFO (lock_info
);
612 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
614 /* User says take the lock */
616 lock_file_1 (lfname
, 1);
619 /* User says ignore the lock */
623 unlock_file (register Lisp_Object fn
)
625 register char *lfname
;
627 fn
= Fexpand_file_name (fn
, Qnil
);
628 fn
= ENCODE_FILE (fn
);
630 MAKE_LOCK_NAME (lfname
, fn
);
632 if (current_lock_owner (0, lfname
) == 2)
637 unlock_all_files (void)
639 register Lisp_Object tail
;
640 register struct buffer
*b
;
642 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
644 b
= XBUFFER (XCDR (XCAR (tail
)));
645 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
647 unlock_file(b
->file_truename
);
652 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
654 doc
: /* Lock FILE, if current buffer is modified.
655 FILE defaults to current buffer's visited file,
656 or else nothing is done if current buffer isn't visiting a file. */)
660 file
= current_buffer
->file_truename
;
663 if (SAVE_MODIFF
< MODIFF
669 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
671 doc
: /* Unlock the file visited in the current buffer.
672 If the buffer is not modified, this does nothing because the file
673 should not be locked in that case. */)
676 if (SAVE_MODIFF
< MODIFF
677 && STRINGP (current_buffer
->file_truename
))
678 unlock_file (current_buffer
->file_truename
);
682 /* Unlock the file visited in buffer BUFFER. */
685 unlock_buffer (struct buffer
*buffer
)
687 if (BUF_SAVE_MODIFF (buffer
) < BUF_MODIFF (buffer
)
688 && STRINGP (buffer
->file_truename
))
689 unlock_file (buffer
->file_truename
);
692 DEFUN ("file-locked-p", Ffile_locked_p
, Sfile_locked_p
, 1, 1, 0,
693 doc
: /* Return a value indicating whether FILENAME is locked.
694 The value is nil if the FILENAME is not locked,
695 t if it is locked by you, else a string saying which user has locked it. */)
696 (Lisp_Object filename
)
699 register char *lfname
;
701 lock_info_type locker
;
703 filename
= Fexpand_file_name (filename
, Qnil
);
705 MAKE_LOCK_NAME (lfname
, filename
);
707 owner
= current_lock_owner (&locker
, lfname
);
713 ret
= build_string (locker
.user
);
716 FREE_LOCK_INFO (locker
);
721 /* Initialization functions. */
727 boot_time_initialized
= 0;
730 #endif /* CLASH_DETECTION */
733 syms_of_filelock (void)
735 DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory
,
736 doc
: /* The directory for writing temporary files. */);
737 Vtemporary_file_directory
= Qnil
;
739 #ifdef CLASH_DETECTION
740 defsubr (&Sunlock_buffer
);
741 defsubr (&Slock_buffer
);
742 defsubr (&Sfile_locked_p
);