1 /* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc.
3 This file is part of GNU Emacs.
5 GNU Emacs is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Emacs is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Emacs; see the file COPYING. If not, write to
17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
20 /* Synced with FSF 20.2 */
31 #include "syssignal.h" /* for kill */
33 Lisp_Object Qask_user_about_supersession_threat;
34 Lisp_Object Qask_user_about_lock;
36 #ifdef CLASH_DETECTION
38 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
39 directory, with link data `user@host.pid'. This avoids a single
40 mount (== failure) point for lock files.
42 When the host in the lock data is the current host, we can check if
43 the pid is valid with kill.
45 Otherwise, we could look at a separate file that maps hostnames to
46 reboot times to see if the remote pid can possibly be valid, since we
47 don't want Emacs to have to communicate via pipes or sockets or
48 whatever to other processes, either locally or remotely; rms says
49 that's too unreliable. Hence the separate file, which could
50 theoretically be updated by daemons running separately -- but this
51 whole idea is unimplemented; in practice, at least in our
52 environment, it seems such stale locks arise fairly infrequently, and
53 Emacs' standard methods of dealing with clashes suffice.
55 We use symlinks instead of normal files because (1) they can be
56 stored more efficiently on the filesystem, since the kernel knows
57 they will be small, and (2) all the info about the lock can be read
58 in a single system call (readlink). Although we could use regular
59 files to be useful on old systems lacking symlinks, nowadays
60 virtually all such systems are probably single-user anyway, so it
61 didn't seem worth the complication.
63 Similarly, we don't worry about a possible 14-character limit on
64 file names, because those are all the same systems that don't have
67 This is compatible with the locking scheme used by Interleaf (which
68 has contributed this implementation for Emacs), and was designed by
69 Ethan Jacobson, Kimbo Mundy, and others.
71 --karl@cs.umb.edu/karl@hq.ileaf.com. */
73 /* Note that muleization is provided by using mule-encapsulated
74 versions of the system calls we use like symlink(), unlink(), etc... */
77 /* Here is the structure that stores information about a lock. */
86 /* When we read the info back, we might need this much more,
87 enough for decimal representation plus null. */
88 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
90 /* Free the two dynamically-allocated pieces in PTR. */
91 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
93 /* Write the name of the lock file for FN into LFNAME. Length will be
94 that of FN plus two more for the leading `.#' plus one for the null. */
95 #define MAKE_LOCK_NAME(lock, file) \
96 (lock = (char *) alloca (XSTRING_LENGTH (file) + 2 + 1), \
97 fill_in_lock_file_name ((Bufbyte *) (lock), (file)))
100 fill_in_lock_file_name (Bufbyte *lockfile, Lisp_Object fn)
102 Bufbyte *file_name = XSTRING_DATA (fn);
106 for (p = file_name + XSTRING_LENGTH (fn) - 1;
107 p > file_name && !IS_ANY_SEP (p[-1]);
110 dirlen = p - file_name;
112 memcpy (lockfile, file_name, dirlen);
113 p = lockfile + dirlen;
116 memcpy (p, file_name + dirlen, XSTRING_LENGTH (fn) - dirlen + 1);
119 /* Lock the lock file named LFNAME.
120 If FORCE is nonzero, we do so even if it is already locked.
121 Return 1 if successful, 0 if not. */
124 lock_file_1 (char *lfname, int force)
129 char *user_name = user_login_name (NULL);
131 if (user_name == NULL)
134 if (STRINGP (Vsystem_name))
135 host_name = (char *) XSTRING_DATA (Vsystem_name);
139 lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
142 sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
143 (unsigned long) getpid ());
145 err = symlink (lock_info_str, lfname);
146 if (err != 0 && errno == EEXIST && force)
149 err = symlink (lock_info_str, lfname);
155 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
156 1 if another process owns it (and set OWNER (if non-null) to info),
157 2 if the current process owns it,
158 or -1 if something is wrong with the locking mechanism. */
161 current_lock_owner (lock_info_type *owner, char *lfname)
168 /* Read arbitrarily-long contents of symlink. Similar code in
169 file-symlink-p in fileio.c. */
173 lfinfo = (char *) xrealloc (lfinfo, bufsize);
174 len = readlink (lfname, lfinfo, bufsize);
176 while (len >= bufsize);
178 /* If nonexistent lock file, all is well; otherwise, got strange error. */
182 return errno == ENOENT ? 0 : -1;
185 /* Link info exists, so `len' is its length. Null terminate. */
188 /* Even if the caller doesn't want the owner info, we still have to
189 read it to determine return value, so allocate it. */
192 owner = (lock_info_type *) alloca (sizeof (lock_info_type));
196 /* Parse USER@HOST.PID. If can't parse, return -1. */
197 /* The USER is everything before the first @. */
198 at = strchr (lfinfo, '@');
199 dot = strrchr (lfinfo, '.');
205 owner->user = (char *) xmalloc (len + 1);
206 strncpy (owner->user, lfinfo, len);
207 owner->user[len] = 0;
209 /* The PID is everything after the last `.'. */
210 owner->pid = atoi (dot + 1);
212 /* The host is everything in between. */
214 owner->host = (char *) xmalloc (len + 1);
215 strncpy (owner->host, at + 1, len);
216 owner->host[len] = 0;
218 /* We're done looking at the link info. */
221 /* On current host? */
222 if (STRINGP (Fsystem_name ())
223 && strcmp (owner->host, (char *) XSTRING_DATA (Fsystem_name ())) == 0)
225 if (owner->pid == getpid ())
226 ret = 2; /* We own it. */
227 else if (owner->pid > 0
228 && (kill (owner->pid, 0) >= 0 || errno == EPERM))
229 ret = 1; /* An existing process on this machine owns it. */
230 /* The owner process is dead or has a strange pid (<=0), so try to
232 else if (unlink (lfname) < 0)
238 { /* If we wanted to support the check for stale locks on remote machines,
239 here's where we'd do it. */
244 if (local_owner || ret <= 0)
246 FREE_LOCK_INFO (*owner);
251 /* Lock the lock named LFNAME if possible.
252 Return 0 in that case.
253 Return positive if some other process owns the lock, and info about
254 that process in CLASHER.
255 Return -1 if cannot lock for any other reason. */
258 lock_if_free (lock_info_type *clasher, char *lfname)
260 if (lock_file_1 (lfname, 0) == 0)
267 locker = current_lock_owner (clasher, lfname);
270 FREE_LOCK_INFO (*clasher);
271 return 0; /* We ourselves locked it. */
273 else if (locker == 1)
274 return 1; /* Someone else has it. */
276 return -1; /* Something's wrong. */
281 /* lock_file locks file FN,
282 meaning it serves notice on the world that you intend to edit that file.
283 This should be done only when about to modify a file-visiting
284 buffer previously unmodified.
285 Do not (normally) call this for a buffer already modified,
286 as either the file is already locked, or the user has already
287 decided to go ahead without locking.
289 When this returns, either the lock is locked for us,
290 or the user has said to go ahead without locking.
292 If the file is locked by someone else, this calls
293 ask-user-about-lock (a Lisp function) with two arguments,
294 the file name and info about the user who did the locking.
295 This function can signal an error, or return t meaning
296 take away the lock, or return nil meaning ignore the lock. */
299 lock_file (Lisp_Object fn)
301 /* This function can GC. */
302 /* dmoore - and can destroy current_buffer and all sorts of other
303 mean nasty things with pointy teeth. If you call this make sure
304 you protect things right. */
305 /* Somebody updated the code in this function and removed the previous
308 register Lisp_Object attack, orig_fn;
309 register char *lfname, *locker;
310 lock_info_type lock_info;
311 struct gcpro gcpro1,gcpro2;
312 Lisp_Object subject_buf;
314 GCPRO2 (fn, subject_buf);
316 fn = Fexpand_file_name (fn, Qnil);
318 /* Create the name of the lock-file for file fn */
319 MAKE_LOCK_NAME (lfname, fn);
321 /* See if this file is visited and has changed on disk since it was
324 subject_buf = get_truename_buffer (orig_fn);
325 if (!NILP (subject_buf)
326 && NILP (Fverify_visited_file_modtime (subject_buf))
327 && !NILP (Ffile_exists_p (fn)))
328 call1_in_buffer (XBUFFER(subject_buf),
329 Qask_user_about_supersession_threat, fn);
332 /* Try to lock the lock. */
333 if (lock_if_free (&lock_info, lfname) <= 0)
334 /* Return now if we have locked it, or if lock creation failed */
337 /* Else consider breaking the lock */
338 locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
340 sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
342 FREE_LOCK_INFO (lock_info);
344 attack = call2_in_buffer (BUFFERP (subject_buf) ? XBUFFER (subject_buf) :
345 current_buffer, Qask_user_about_lock , fn,
346 build_string (locker));
348 /* User says take the lock */
350 lock_file_1 (lfname, 1);
353 /* User says ignore the lock */
359 unlock_file (Lisp_Object fn)
361 register char *lfname;
366 fn = Fexpand_file_name (fn, Qnil);
368 MAKE_LOCK_NAME (lfname, fn);
370 if (current_lock_owner (0, lfname) == 2)
377 unlock_all_files (void)
379 register Lisp_Object tail;
381 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
383 struct buffer *b = XBUFFER (XCDR (XCAR (tail)));
384 if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
385 unlock_file (b->file_truename);
389 DEFUN ("lock-buffer", Flock_buffer, 0, 1, 0, /*
390 Lock FILE, if current buffer is modified.
391 FILE defaults to current buffer's visited file,
392 or else nothing is done if current buffer isn't visiting a file.
397 file = current_buffer->file_truename;
399 if (BUF_SAVE_MODIFF (current_buffer) < BUF_MODIFF (current_buffer)
405 DEFUN ("unlock-buffer", Funlock_buffer, 0, 0, 0, /*
406 Unlock the file visited in the current buffer,
407 if it should normally be locked.
411 /* This function can GC */
412 /* dmoore - and can destroy current_buffer and all sorts of other
413 mean nasty things with pointy teeth. If you call this make sure
414 you protect things right. */
416 if (BUF_SAVE_MODIFF (current_buffer) < BUF_MODIFF (current_buffer)
417 && STRINGP (current_buffer->file_truename))
418 unlock_file (current_buffer->file_truename);
422 /* Unlock the file visited in buffer BUFFER. */
426 unlock_buffer (struct buffer *buffer)
428 /* This function can GC */
429 /* dmoore - and can destroy current_buffer and all sorts of other
430 mean nasty things with pointy teeth. If you call this make sure
431 you protect things right. */
432 if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
433 && STRINGP (buffer->file_truename))
434 unlock_file (buffer->file_truename);
437 DEFUN ("file-locked-p", Ffile_locked_p, 0, 1, 0, /*
438 Return nil if the FILENAME is not locked,
439 t if it is locked by you, else a string of the name of the locker.
444 register char *lfname;
446 lock_info_type locker;
451 filename = Fexpand_file_name (filename, Qnil);
453 MAKE_LOCK_NAME (lfname, filename);
455 owner = current_lock_owner (&locker, lfname);
461 ret = build_string (locker.user);
464 FREE_LOCK_INFO (locker);
472 /* Initialization functions. */
475 syms_of_filelock (void)
477 /* This function can GC */
478 DEFSUBR (Funlock_buffer);
479 DEFSUBR (Flock_buffer);
480 DEFSUBR (Ffile_locked_p);
482 defsymbol (&Qask_user_about_supersession_threat,
483 "ask-user-about-supersession-threat");
484 defsymbol (&Qask_user_about_lock, "ask-user-about-lock");
488 #endif /* CLASH_DETECTION */