]>
code.delx.au - gnu-emacs/blob - src/filelock.c
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. */
21 #include <sys/types.h>
45 #ifdef CLASH_DETECTION
47 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
48 directory, with link data `user@host.pid'. This avoids a single
49 mount (== failure) point for lock files.
51 When the host in the lock data is the current host, we can check if
52 the pid is valid with kill.
54 Otherwise, we could look at a separate file that maps hostnames to
55 reboot times to see if the remote pid can possibly be valid, since we
56 don't want Emacs to have to communicate via pipes or sockets or
57 whatever to other processes, either locally or remotely; rms says
58 that's too unreliable. Hence the separate file, which could
59 theoretically be updated by daemons running separately -- but this
60 whole idea is unimplemented; in practice, at least in our
61 environment, it seems such stale locks arise fiarly infrequently, and
62 Emacs' standard methods of dealing with clashes suffice.
64 We use symlinks instead of normal files because (1) they can be
65 stored more efficiently on the filesystem, since the kernel knows
66 they will be small, and (2) all the info about the lock can be read
67 in a single system call (readlink). Although we could use regular
68 files to be useful on old systems lacking symlinks, noawdays
69 virtually all such systems are probably single-user anyway, so it
70 didn't seem worth the complication.
72 Similarly, we don't worry about a possible 14-character limit on
73 file names, because those are all the same systems that don't have
76 This is compatible with the locking scheme used by Interleaf (which
77 has contributed this implementation for Emacs), and was designed by
78 Ethan Jacobson, Kimbo Mundy, and others.
80 --karl@cs.umb.edu/karl@hq.ileaf.com. */
83 /* Here is the structure that stores information about a lock. */
92 /* When we read the info back, we might need this much more. */
93 #define LOCK_PID_MAX 21 /* enough for signed 64 bits plus null */
95 /* Free the two dynamically-allocated pieces in PTR. */
96 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
99 /* Write the name of the lock file for FN into LFNAME. Length will be
100 that of FN plus two more for the leading `.#' plus one for the null. */
101 #define MAKE_LOCK_NAME(lock, file) \
102 (lock = (char *) alloca (XSTRING (file)->size + 2 + 1), \
103 fill_in_lock_file_name (lock, (file)))
106 fill_in_lock_file_name (lockfile
, fn
)
107 register char *lockfile
;
108 register Lisp_Object fn
;
112 strcpy (lockfile
, XSTRING (fn
)->data
);
114 /* Shift the nondirectory part of the file name (including the null)
115 right two characters. Here is one of the places where we'd have to
116 do something to support 14-character-max file names. */
117 for (p
= lockfile
+ strlen (lockfile
); p
!= lockfile
&& *p
!= '/'; p
--)
120 /* Insert the `.#'. */
125 /* Lock the lock file named LFNAME.
126 If FORCE is nonzero, we do so even if it is already locked.
127 Return 1 if successful, 0 if not. */
130 lock_file_1 (lfname
, force
)
135 char *user_name
= XSTRING (Fuser_login_name (Qnil
))->data
;
136 char *host_name
= XSTRING (Fsystem_name ())->data
;
137 char *lock_info_str
= alloca (strlen (user_name
) + strlen (host_name
) + 21);
139 sprintf (lock_info_str
, "%s@%s.%lu", user_name
, host_name
,
140 (unsigned long) getpid ());
142 err
= symlink (lock_info_str
, lfname
);
143 if (errno
== EEXIST
&& force
)
146 err
= symlink (lock_info_str
, lfname
);
154 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
155 1 if another process owns it (and set OWNER (if non-null) to info),
156 2 if the current process owns it,
157 or -1 if something is wrong with the locking mechanism. */
160 current_lock_owner (owner
, lfname
)
161 lock_info_type
*owner
;
165 extern char *rindex (), *index ();
172 /* Read arbitrarily-long contents of symlink. Similar code in
173 file-symlink-p in fileio.c. */
177 lfinfo
= (char *) xrealloc (lfinfo
, bufsize
);
178 len
= readlink (lfname
, lfinfo
, bufsize
);
180 while (len
>= bufsize
);
182 /* If nonexistent lock file, all is well; otherwise, got strange error. */
186 return errno
== ENOENT
? 0 : -1;
189 /* Link info exists, so `len' is its length. Null terminate. */
192 /* Even if the caller doesn't want the owner info, we still have to
193 read it to determine return value, so allocate it. */
196 owner
= alloca (sizeof (lock_info_type
));
200 /* Parse USER@HOST.PID. If can't parse, return -1. */
201 /* The USER is everything before the first @. */
202 at
= index (lfinfo
, '@');
203 dot
= rindex (lfinfo
, '.');
209 owner
->user
= (char *) xmalloc (len
+ 1);
210 strncpy (owner
->user
, lfinfo
, len
);
211 owner
->user
[len
] = 0;
213 /* The PID is everything after the last `.'. */
214 owner
->pid
= atoi (dot
+ 1);
216 /* The host is everything in between. */
218 owner
->host
= (char *) xmalloc (len
+ 1);
219 strncpy (owner
->host
, at
+ 1, len
);
220 owner
->host
[len
] = 0;
222 /* We're done looking at the link info. */
225 /* On current host? */
226 if (strcmp (owner
->host
, XSTRING (Fsystem_name ())->data
) == 0)
228 if (owner
->pid
== getpid ())
229 ret
= 2; /* We own it. */
232 && (kill (owner
->pid
, 0) >= 0 || errno
== EPERM
))
233 ret
= 1; /* An existing process on this machine owns it. */
235 /* The owner process is dead or has a strange pid (<=0), so try to
237 if (unlink (lfname
) < 0)
243 { /* If we wanted to support the check for stale locks on remote machines,
244 here's where we'd do it. */
249 if (local_owner
|| ret
<= 0)
251 FREE_LOCK_INFO (*owner
);
257 /* Lock the lock named LFNAME if possible.
258 Return 0 in that case.
259 Return positive if some other process owns the lock, and info about
260 that process in CLASHER.
261 Return -1 if cannot lock for any other reason. */
264 lock_if_free (clasher
, lfname
)
265 lock_info_type
*clasher
;
266 register char *lfname
;
268 while (lock_file_1 (lfname
, 0) == 0)
275 locker
= current_lock_owner (clasher
, lfname
);
278 FREE_LOCK_INFO (*clasher
);
279 return 0; /* We ourselves locked it. */
281 else if (locker
== 1)
282 return 1; /* Someone else has it. */
283 else if (locker
== -1)
284 return -1; /* Something's wrong. */
286 /* If some other error, or no such lock, try to lock again. */
287 /* Is there a case where we loop forever? */
292 /* lock_file locks file FN,
293 meaning it serves notice on the world that you intend to edit that file.
294 This should be done only when about to modify a file-visiting
295 buffer previously unmodified.
296 Do not (normally) call this for a buffer already modified,
297 as either the file is already locked, or the user has already
298 decided to go ahead without locking.
300 When this returns, either the lock is locked for us,
301 or the user has said to go ahead without locking.
303 If the file is locked by someone else, this calls
304 ask-user-about-lock (a Lisp function) with two arguments,
305 the file name and info about the user who did the locking.
306 This function can signal an error, or return t meaning
307 take away the lock, or return nil meaning ignore the lock. */
311 register Lisp_Object fn
;
313 register Lisp_Object attack
, orig_fn
;
314 register char *lfname
, *locker
;
315 lock_info_type lock_info
;
318 fn
= Fexpand_file_name (fn
, Qnil
);
320 /* Create the name of the lock-file for file fn */
321 MAKE_LOCK_NAME (lfname
, fn
);
323 /* See if this file is visited and has changed on disk since it was
326 register Lisp_Object subject_buf
;
327 subject_buf
= get_truename_buffer (orig_fn
);
328 if (!NILP (subject_buf
)
329 && NILP (Fverify_visited_file_modtime (subject_buf
))
330 && !NILP (Ffile_exists_p (fn
)))
331 call1 (intern ("ask-user-about-supersession-threat"), fn
);
334 /* Try to lock the lock. */
335 if (lock_if_free (&lock_info
, lfname
) <= 0)
336 /* Return now if we have locked it, or if lock creation failed */
339 /* Else consider breaking the lock */
340 locker
= alloca (strlen (lock_info
.user
) + strlen (lock_info
.host
)
342 sprintf (locker
, "%s@%s (pid %d)", lock_info
.user
, lock_info
.host
,
344 FREE_LOCK_INFO (lock_info
);
346 attack
= call2 (intern ("ask-user-about-lock"), fn
, build_string (locker
));
348 /* User says take the lock */
350 lock_file_1 (lfname
, 1);
353 /* User says ignore the lock */
358 register Lisp_Object fn
;
360 register char *lfname
;
362 fn
= Fexpand_file_name (fn
, Qnil
);
364 MAKE_LOCK_NAME (lfname
, fn
);
366 if (current_lock_owner (0, lfname
) == 2)
373 register Lisp_Object tail
;
374 register struct buffer
*b
;
376 for (tail
= Vbuffer_alist
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
378 b
= XBUFFER (XCONS (XCONS (tail
)->car
)->cdr
);
379 if (STRINGP (b
->file_truename
) && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
380 unlock_file (b
->file_truename
);
384 DEFUN ("lock-buffer", Flock_buffer
, Slock_buffer
,
386 "Lock FILE, if current buffer is modified.\n\
387 FILE defaults to current buffer's visited file,\n\
388 or else nothing is done if current buffer isn't visiting a file.")
393 file
= current_buffer
->file_truename
;
395 CHECK_STRING (file
, 0);
396 if (SAVE_MODIFF
< MODIFF
402 DEFUN ("unlock-buffer", Funlock_buffer
, Sunlock_buffer
,
404 "Unlock the file visited in the current buffer,\n\
405 if it should normally be locked.")
408 if (SAVE_MODIFF
< MODIFF
409 && STRINGP (current_buffer
->file_truename
))
410 unlock_file (current_buffer
->file_truename
);
414 /* Unlock the file visited in buffer BUFFER. */
416 unlock_buffer (buffer
)
417 struct buffer
*buffer
;
419 if (BUF_SAVE_MODIFF (buffer
) < BUF_MODIFF (buffer
)
420 && STRINGP (buffer
->file_truename
))
421 unlock_file (buffer
->file_truename
);
424 DEFUN ("file-locked-p", Ffile_locked_p
, Sfile_locked_p
, 0, 1, 0,
425 "Return nil if the FILENAME is not locked,\n\
426 t if it is locked by you, else a string of the name of the locker.")
428 Lisp_Object filename
;
431 register char *lfname
;
433 lock_info_type locker
;
435 filename
= Fexpand_file_name (filename
, Qnil
);
437 MAKE_LOCK_NAME (lfname
, filename
);
439 owner
= current_lock_owner (&locker
, lfname
);
445 ret
= build_string (locker
.user
);
448 FREE_LOCK_INFO (locker
);
454 /* Initialization functions. */
461 lock_dir
= egetenv ("EMACSLOCKDIR");
463 lock_dir
= PATH_LOCK
;
465 /* Copy the name in case egetenv got it from a Lisp string. */
466 new_name
= (char *) xmalloc (strlen (lock_dir
) + 2);
467 strcpy (new_name
, lock_dir
);
470 /* Make sure it ends with a slash. */
471 if (lock_dir
[strlen (lock_dir
) - 1] != '/')
472 strcat (lock_dir
, "/");
474 superlock_file
= (char *) xmalloc ((strlen (lock_dir
)
475 + sizeof (SUPERLOCK_NAME
)));
476 strcpy (superlock_file
, lock_dir
);
477 strcat (superlock_file
, SUPERLOCK_NAME
);
483 defsubr (&Sunlock_buffer
);
484 defsubr (&Slock_buffer
);
485 defsubr (&Sfile_locked_p
);
488 #endif /* CLASH_DETECTION */