1 /* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc.
3 This file is part of SXEmacs
5 SXEmacs 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 3 of the License, or
8 (at your option) any later version.
10 SXEmacs 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 this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* Synced with FSF 20.2 */
25 #include <sxe-paths.h>
30 #include "syssignal.h" /* for kill */
32 Lisp_Object Qask_user_about_supersession_threat;
33 Lisp_Object Qask_user_about_lock;
34 int inhibit_clash_detection;
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... */
76 /* Here is the structure that stores information about a lock. */
84 /* When we read the info back, we might need this much more,
85 enough for decimal representation plus null. */
86 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
88 /* Free the two dynamically-allocated pieces in PTR. */
89 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
91 /* Write the name of the lock file for FN into LFNAME. Length will be
92 that of FN plus two more for the leading `.#' plus one for the null. */
93 #define MAKE_LOCK_NAME(lock, file) \
94 (lock = (char *) alloca (XSTRING_LENGTH (file) + 2 + 1), \
95 fill_in_lock_file_name ((Bufbyte *) (lock), (file)))
97 static void fill_in_lock_file_name(Bufbyte * lockfile, Lisp_Object fn)
99 Bufbyte *file_name = XSTRING_DATA(fn);
103 for (p = file_name + XSTRING_LENGTH(fn) - 1;
104 p > file_name && !IS_ANY_SEP(p[-1]); p--) ;
105 dirlen = p - file_name;
107 memcpy(lockfile, file_name, dirlen);
108 p = lockfile + dirlen;
111 memcpy(p, file_name + dirlen, XSTRING_LENGTH(fn) - dirlen + 1);
114 /* Lock the lock file named LFNAME.
115 If FORCE is nonzero, we do so even if it is already locked.
116 Return 1 if successful, 0 if not. */
118 static int lock_file_1(char *lfname, int force)
124 char *user_name = user_login_name(NULL);
127 if (user_name == NULL)
130 if (STRINGP(Vsystem_name))
131 host_name = (char *)XSTRING_DATA(Vsystem_name);
135 maxlen = strlen(user_name) + strlen(host_name)
137 lock_info_str = (char *)alloca(maxlen);
139 sz = snprintf(lock_info_str, maxlen, "%s@%s.%lu", user_name, host_name,
140 (unsigned long)getpid());
141 assert(sz>=0 && sz < maxlen);
143 err = symlink(lock_info_str, lfname);
144 if (err != 0 && errno == EEXIST && force) {
146 err = symlink(lock_info_str, lfname);
152 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
153 1 if another process owns it (and set OWNER (if non-null) to info),
154 2 if the current process owns it,
155 or -1 if something is wrong with the locking mechanism. */
157 static int current_lock_owner(lock_info_type * owner, char *lfname)
165 /* Read arbitrarily-long contents of symlink. Similar code in
166 file-symlink-p in fileio.c. */
169 lfinfo = (char *)xrealloc(lfinfo, bufsize);
170 len = readlink(lfname, lfinfo, bufsize);
172 while (len >= bufsize);
174 /* If nonexistent lock file, all is well; otherwise, got strange error. */
177 return errno == ENOENT ? 0 : -1;
180 /* Link info exists, so `len' is its length. Null terminate. */
183 /* Even if the caller doesn't want the owner info, we still have to
184 read it to determine return value, so allocate it. */
186 owner = (lock_info_type *) alloca(sizeof(lock_info_type));
190 /* Parse USER@HOST.PID. If can't parse, return -1. */
191 /* The USER is everything before the first @. */
192 at = strchr(lfinfo, '@');
193 dot = strrchr(lfinfo, '.');
199 owner->user = (char *)xmalloc_atomic(len + 1);
200 strncpy(owner->user, lfinfo, len);
201 owner->user[len] = 0;
203 /* The PID is everything after the last `.'. */
204 owner->pid = atoi(dot + 1);
206 /* The host is everything in between. */
208 owner->host = (char *)xmalloc_atomic(len + 1);
209 strncpy(owner->host, at + 1, len);
210 owner->host[len] = 0;
212 /* We're done looking at the link info. */
215 /* On current host? */
216 if (STRINGP(Fsystem_name())
217 && strcmp(owner->host, (char *)XSTRING_DATA(Fsystem_name())) == 0) {
218 if (owner->pid == (unsigned long)getpid())
219 ret = 2; /* We own it. */
220 else if (owner->pid > 0
221 && (kill(owner->pid, 0) >= 0 || errno == EPERM))
222 ret = 1; /* An existing process on this machine owns it. */
223 /* The owner process is dead or has a strange pid (<=0), so try to
225 else if (unlink(lfname) < 0)
229 } else { /* If we wanted to support the check for stale locks on remote machines,
230 here's where we'd do it. */
235 if (local_owner || ret <= 0) {
236 FREE_LOCK_INFO(*owner);
241 /* Lock the lock named LFNAME if possible.
242 Return 0 in that case.
243 Return positive if some other process owns the lock, and info about
244 that process in CLASHER.
245 Return -1 if cannot lock for any other reason. */
247 static int lock_if_free(lock_info_type * clasher, char *lfname)
250 if (lock_file_1(lfname, 0) == 0) {
256 locker = current_lock_owner(clasher, lfname);
258 FREE_LOCK_INFO(*clasher);
259 return 0; /* We ourselves locked it. */
260 } else if (locker == 1)
261 return 1; /* Someone else has it. */
263 return -1; /* Something's wrong. */
268 /* lock_file locks file FN,
269 meaning it serves notice on the world that you intend to edit that file.
270 This should be done only when about to modify a file-visiting
271 buffer previously unmodified.
272 Do not (normally) call this for a buffer already modified,
273 as either the file is already locked, or the user has already
274 decided to go ahead without locking.
276 When this returns, either the lock is locked for us,
277 or the user has said to go ahead without locking.
279 If the file is locked by someone else, this calls
280 ask-user-about-lock (a Lisp function) with two arguments,
281 the file name and info about the user who did the locking.
282 This function can signal an error, or return t meaning
283 take away the lock, or return nil meaning ignore the lock. */
285 void lock_file(Lisp_Object fn)
287 /* This function can GC. GC checked 7-11-00 ben */
288 /* dmoore - and can destroy current_buffer and all sorts of other
289 mean nasty things with pointy teeth. If you call this make sure
290 you protect things right. */
291 /* Somebody updated the code in this function and removed the previous
294 register Lisp_Object attack, orig_fn;
295 register char *lfname, *locker;
296 lock_info_type lock_info;
297 struct gcpro gcpro1, gcpro2, gcpro3;
298 Lisp_Object old_current_buffer;
299 Lisp_Object subject_buf;
302 if (inhibit_clash_detection)
305 XSETBUFFER(old_current_buffer, current_buffer);
307 GCPRO3(fn, subject_buf, old_current_buffer);
309 fn = Fexpand_file_name(fn, Qnil);
311 /* Create the name of the lock-file for file fn */
312 MAKE_LOCK_NAME(lfname, fn);
314 /* See if this file is visited and has changed on disk since it was
317 subject_buf = get_truename_buffer(orig_fn);
318 if (!NILP(subject_buf)
319 && NILP(Fverify_visited_file_modtime(subject_buf))
320 && !NILP(Ffile_exists_p(fn)))
321 call1_in_buffer(XBUFFER(subject_buf),
322 Qask_user_about_supersession_threat,
326 /* Try to lock the lock. */
327 if (current_buffer != XBUFFER(old_current_buffer)
328 || lock_if_free(&lock_info, lfname) <= 0)
329 /* Return now if we have locked it, or if lock creation failed
330 or current buffer is killed. */
333 /* Else consider breaking the lock */
334 max_sz = strlen(lock_info.user) + strlen(lock_info.host)
336 locker = (char *)alloca(max_sz);
337 sz = snprintf(locker, max_sz, "%s@%s (pid %lu)",
338 lock_info.user, lock_info.host,
340 assert(sz>=0 && sz < max_sz);
341 FREE_LOCK_INFO(lock_info);
343 attack = call2_in_buffer(BUFFERP(subject_buf) ? XBUFFER(subject_buf) :
344 current_buffer, Qask_user_about_lock, fn,
345 build_string(locker));
346 if (!NILP(attack) && current_buffer == XBUFFER(old_current_buffer))
347 /* User says take the lock */
349 lock_file_1(lfname, 1);
352 /* User says ignore the lock */
357 void unlock_file(Lisp_Object fn)
360 register char *lfname;
365 fn = Fexpand_file_name(fn, Qnil);
367 MAKE_LOCK_NAME(lfname, fn);
369 if (current_lock_owner(0, lfname) == 2)
375 void unlock_all_files(void)
377 register Lisp_Object tail;
379 for (tail = Vbuffer_alist; CONSP(tail); tail = XCDR(tail)) {
380 struct buffer *b = XBUFFER(XCDR(XCAR(tail)));
381 if (STRINGP(b->file_truename)
382 && BUF_SAVE_MODIFF(b) < BUF_MODIFF(b))
383 unlock_file(b->file_truename);
387 DEFUN("lock-buffer", Flock_buffer, 0, 1, 0, /*
388 Lock FILE, if current buffer is modified.
389 FILE defaults to current buffer's visited file,
390 or else nothing is done if current buffer isn't visiting a file.
395 file = current_buffer->file_truename;
397 if (BUF_SAVE_MODIFF(current_buffer) < BUF_MODIFF(current_buffer)
403 DEFUN("unlock-buffer", Funlock_buffer, 0, 0, 0, /*
404 Unlock the file visited in the current buffer,
405 if it should normally be locked.
409 /* This function can GC */
410 /* dmoore - and can destroy current_buffer and all sorts of other
411 mean nasty things with pointy teeth. If you call this make sure
412 you protect things right. */
414 if (BUF_SAVE_MODIFF(current_buffer) < BUF_MODIFF(current_buffer)
415 && STRINGP(current_buffer->file_truename))
416 unlock_file(current_buffer->file_truename);
420 /* Unlock the file visited in buffer BUFFER. */
422 void unlock_buffer(struct buffer *buffer)
424 /* This function can GC */
425 /* dmoore - and can destroy current_buffer and all sorts of other
426 mean nasty things with pointy teeth. If you call this make sure
427 you protect things right. */
428 if (BUF_SAVE_MODIFF(buffer) < BUF_MODIFF(buffer)
429 && STRINGP(buffer->file_truename))
430 unlock_file(buffer->file_truename);
433 DEFUN("file-locked-p", Ffile_locked_p, 0, 1, 0, /*
434 Return nil if the FILENAME is not locked,
435 t if it is locked by you, else a string of the name of the locker.
440 register char *lfname;
442 lock_info_type locker;
447 filename = Fexpand_file_name(filename, Qnil);
449 MAKE_LOCK_NAME(lfname, filename);
451 owner = current_lock_owner(&locker, lfname);
457 ret = build_string(locker.user);
460 FREE_LOCK_INFO(locker);
467 /* Initialization functions. */
469 void syms_of_filelock(void)
471 /* This function can GC */
472 DEFSUBR(Funlock_buffer);
473 DEFSUBR(Flock_buffer);
474 DEFSUBR(Ffile_locked_p);
476 defsymbol(&Qask_user_about_supersession_threat,
477 "ask-user-about-supersession-threat");
478 defsymbol(&Qask_user_about_lock, "ask-user-about-lock");
481 void vars_of_filelock(void)
483 DEFVAR_BOOL("inhibit-clash-detection", &inhibit_clash_detection /*
484 Non-nil inhibits creation of lock file to detect clash.
486 inhibit_clash_detection = 0;
489 #endif /* CLASH_DETECTION */