Mercurial > hg > xemacs-beta
annotate src/filelock.c @ 2367:ecf1ebac70d8
[xemacs-hg @ 2004-11-04 23:05:23 by ben]
commit mega-patch
configure.in: Turn off -Winline and -Wchar-subscripts.
Use the right set of cflags when compiling modules.
Rewrite ldap configuration to separate the inclusion of lber
(needed in recent Cygwin) from the basic checks for the
needed libraries.
add a function for MAKE_JUNK_C; initially code was added to
generate xemacs.def using this, but it will need to be rewritten.
add an rm -f for junk.c to avoid weird Cygwin bug with cp -f onto
an existing file.
Sort list of auto-detected functions and eliminate unused checks for
stpcpy, setlocale and getwd.
Add autodetection of Cygwin scanf problems
BETA: Rewrite section on configure to indicate what flags are important
and what not.
digest-doc.c, make-dump-id.c, profile.c, sorted-doc.c: Add proper decls for main().
make-msgfile.c: Document that this is old junk.
Move proposal to text.c.
make-msgfile.lex: Move proposal to text.c.
make-mswin-unicode.pl: Convert error-generating code so that the entire message will
be seen as a single unrecognized token.
mule/mule-ccl.el: Update docs.
lispref/mule.texi: Update CCL docs.
ldap/eldap.c: Mule-ize.
Use EXTERNAL_LIST_LOOP_2 instead of deleted EXTERNAL_LIST_LOOP.
* XEmacs 21.5.18 "chestnut" is released.
---------------------------------------------------------------
MULE-RELATED WORK:
---------------------------------------------------------------
---------------------------
byte-char conversion
---------------------------
buffer.c, buffer.h, insdel.c, text.c: Port FSF algorithm for byte-char conversion, replacing broken
previous version. Track the char position of the gap. Add
functions to do char-byte conversion downwards as well as upwards.
Move comments about algorithm workings to internals manual.
---------------------------
work on types
---------------------------
alloc.c, console-x-impl.h, dump-data.c, dump-data.h, dumper.c, dialog-msw.c, dired-msw.c, doc.c, editfns.c, esd.c, event-gtk.h, event-msw.c, events.c, file-coding.c, file-coding.h, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-shared.c, glyphs-x.c, glyphs.c, glyphs.h, gui.c, hpplay.c, imgproc.c, intl-win32.c, lrecord.h, lstream.c, keymap.c, lisp.h, libsst.c, linuxplay.c, miscplay.c, miscplay.h, mule-coding.c, nas.c, nt.c, ntheap.c, ntplay.c, objects-msw.c, objects-tty.c, objects-x.c, print.c, process-nt.c, process.c, redisplay.h, select-common.h, select-gtk.c, select-x.c, sgiplay.c, sound.c, sound.h, sunplay.c, sysfile.h, sysdep.c, syswindows.h, text.c, unexnt.c, win32.c, xgccache.c: Further work on types. This creates a full set of types for all
the basic semantics of `char' that I have so far identified, so that
its semantics can always be identified for the purposes of proper
Mule-safe code, and the raw use of `char' always avoided.
(1) More type renaming, for consistency of naming.
Char_ASCII -> Ascbyte
UChar_ASCII -> UAscbyte
Char_Binary -> CBinbyte
UChar_Binary -> Binbyte
SChar_Binary -> SBinbyte
(2) Introduce Rawbyte, CRawbyte, Boolbyte, Chbyte, UChbyte, and
Bitbyte and use them.
(3) New types Itext, Wexttext and Textcount for separating out
the concepts of bytes and textual units (different under UTF-16
and UTF-32, which are potential internal encodings).
(4) qxestr*_c -> qxestr*_ascii.
lisp.h: New; goes with other qxe() functions. #### Maybe goes in a
different section.
lisp.h: Group generic int-type defs together with EMACS_INT defs.
lisp.h: * lisp.h (WEXTTEXT_IS_WIDE)
New defns.
lisp.h: New type to replace places where int occurs as a boolean.
It's signed because occasionally people may want to use -1 as
an error value, and because unsigned ints are viral -- see comments
in the internals manual against using them.
dynarr.c: int -> Bytecount.
---------------------------
Mule-izing
---------------------------
device-x.c: Partially Mule-ize.
dumper.c, dumper.h: Mule-ize. Use Rawbyte. Use stderr_out not printf. Use wext_*().
sysdep.c, syswindows.h, text.c: New Wexttext API for manipulation of external text that may be
Unicode (e.g. startup code under Windows).
emacs.c: Mule-ize. Properly deal with argv in external encoding.
Use wext_*() and Wexttext. Use Rawbyte.
#if 0 some old junk on SCO that is unlikely to be correct.
Rewrite allocation code in run-temacs.
emacs.c, symsinit.h, win32.c: Rename win32 init function and call it even earlier, to
initialize mswindows_9x_p even earlier, for use in startup code
(XEUNICODE_P).
process.c: Use _wenviron not environ under Windows, to get Unicode environment
variables.
event-Xt.c: Mule-ize drag-n-drop related stuff.
dragdrop.c, dragdrop.h, frame-x.c: Mule-ize.
text.h: Add some more stand-in defines for particular kinds of conversion;
use in Mule-ization work in frame-x.c etc.
---------------------------
Freshening
---------------------------
intl-auto-encap-win32.c, intl-auto-encap-win32.h: Regenerate.
---------------------------
Unicode-work
---------------------------
intl-win32.c, syswindows.h: Factor out common options to MultiByteToWideChar and
WideCharToMultiByte. Add convert_unicode_to_multibyte_malloc()
and convert_unicode_to_multibyte_dynarr() and use. Add stuff for
alloca() conversion of multibyte/unicode.
alloc.c: Use dfc_external_data_len() in case of unicode coding system.
alloc.c, mule-charset.c: Don't zero out and reinit charset Unicode tables. This fucks up
dump-time loading. Anyway, either we load them at dump time or
run time, never both.
unicode.c: Dump the blank tables as well.
---------------------------------------------------------------
DOCUMENTATION, MOSTLY MULE-RELATED:
---------------------------------------------------------------
EmacsFrame.c, emodules.c, event-Xt.c, fileio.c, input-method-xlib.c, mule-wnnfns.c, redisplay-gtk.c, redisplay-tty.c, redisplay-x.c, regex.c, sysdep.c: Add comment about Mule work needed.
text.h: Add more documentation describing why DFC routines were not written
to return their value. Add some other DFC documentation.
console-msw.c, console-msw.h: Add pointer to docs in win32.c.
emacs.c: Add comments on sources of doc info.
text.c, charset.h, unicode.c, intl-win32.c, intl-encap-win32.c, text.h, file-coding.c, mule-coding.c: Collect background comments and related to text matters and
internationalization, and proposals for work to be done, in text.c
or Internals manual, stuff related to specific textual API's in
text.h, and stuff related to internal implementation of Unicode
conversion in unicode.c. Put lots of pointers to the comments to
make them easier to find.
s/mingw32.h, s/win32-common.h, s/win32-native.h, s/windowsnt.h, win32.c: Add bunches of new documentation on the different kinds of
builds and environments under Windows and how they work.
Collect this info in win32.c. Add pointers to these docs in
the relevant s/* files.
emacs.c: Document places with long comments.
Remove comment about exiting, move to internals manual, put
in pointer.
event-stream.c: Move docs about event queues and focus to internals manual, put
in pointer.
events.h: Move docs about event stream callbacks to internals manual, put
in pointer.
profile.c, redisplay.c, signal.c: Move documentation to the Internals manual.
process-nt.c: Add pointer to comment in win32-native.el.
lisp.h: Add comments about some comment conventions.
lisp.h: Add comment about the second argument.
device-msw.c, redisplay-msw.c: @@#### comments are out-of-date.
---------------------------------------------------------------
PDUMP WORK (MOTIVATED BY UNICODE CHANGES)
---------------------------------------------------------------
alloc.c, buffer.c, bytecode.c, console-impl.h, console.c, device.c, dumper.c, lrecord.h, elhash.c, emodules.h, events.c, extents.c, frame.c, glyphs.c, glyphs.h, mule-charset.c, mule-coding.c, objects.c, profile.c, rangetab.c, redisplay.c, specifier.c, specifier.h, window.c, lstream.c, file-coding.h, file-coding.c: PDUMP:
Properly implement dump_add_root_block(), which never worked before,
and is necessary for dumping Unicode tables.
Pdump name changes for accuracy:
XD_STRUCT_PTR -> XD_BLOCK_PTR.
XD_STRUCT_ARRAY -> XD_BLOCK_ARRAY.
XD_C_STRING -> XD_ASCII_STRING.
*_structure_* -> *_block_*.
lrecord.h: some comments added about
dump_add_root_block() vs dump_add_root_block_ptr().
extents.c: remove incorrect comment about pdump problems with gap array.
---------------------------------------------------------------
ALLOCATION
---------------------------------------------------------------
abbrev.c, alloc.c, bytecode.c, casefiddle.c, device-msw.c, device-x.c, dired-msw.c, doc.c, doprnt.c, dragdrop.c, editfns.c, emodules.c, file-coding.c, fileio.c, filelock.c, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-x.c, gui-msw.c, gui-x.c, imgproc.c, intl-win32.c, lread.c, menubar-gtk.c, menubar.c, nt.c, objects-msw.c, objects-x.c, print.c, process-nt.c, process-unix.c, process.c, realpath.c, redisplay.c, search.c, select-common.c, symbols.c, sysdep.c, syswindows.h, text.c, text.h, ui-byhand.c: New macros {alloca,xnew}_{itext,{i,ext,raw,bin,asc}bytes} for
more convenient allocation of these commonly requested items.
Modify functions to use alloca_ibytes, alloca_array, alloca_extbytes,
xnew_ibytes, etc. also XREALLOC_ARRAY, xnew.
alloc.c: Rewrite the allocation functions to factor out repeated code.
Add assertions for freeing dumped data.
lisp.h: Moved down and consolidated with other allocation stuff.
lisp.h, dynarr.c: New functions for allocation that's very efficient when mostly in
LIFO order.
lisp.h, text.c, text.h: Factor out some stuff for general use by alloca()-conversion funs.
text.h, lisp.h: Fill out convenience routines for allocating various kinds of
bytes and put them in lisp.h. Use them in place of xmalloc(),
ALLOCA().
text.h: Fill out the convenience functions so the _MALLOC() kinds match
the alloca() kinds.
---------------------------------------------------------------
ERROR-CHECKING
---------------------------------------------------------------
text.h: Create ASSERT_ASCTEXT_ASCII() and ASSERT_ASCTEXT_ASCII_LEN()
from similar Eistring checkers and change the Eistring checkers to
use them instead.
---------------------------------------------------------------
MACROS IN LISP.H
---------------------------------------------------------------
lisp.h: Redo GCPRO declarations. Create a "base" set of functions that can
be used to generate any kind of gcpro sets -- regular, ngcpro,
nngcpro, private ones used in GC_EXTERNAL_LIST_LOOP_2.
buffer.c, callint.c, chartab.c, console-msw.c, device-x.c, dialog-msw.c, dired.c, extents.c, ui-gtk.c, rangetab.c, nt.c, mule-coding.c, minibuf.c, menubar-msw.c, menubar.c, menubar-gtk.c, lread.c, lisp.h, gutter.c, glyphs.c, glyphs-widget.c, fns.c, fileio.c, file-coding.c, specifier.c: Eliminate EXTERNAL_LIST_LOOP, which does not check for circularities.
Use EXTERNAL_LIST_LOOP_2 instead or EXTERNAL_LIST_LOOP_3
or EXTERNAL_PROPERTY_LIST_LOOP_3 or GC_EXTERNAL_LIST_LOOP_2
(new macro). Removed/redid comments on EXTERNAL_LIST_LOOP.
---------------------------------------------------------------
SPACING FIXES
---------------------------------------------------------------
callint.c, hftctl.c, number-gmp.c, process-unix.c: Spacing fixes.
---------------------------------------------------------------
FIX FOR GEOMETRY PROBLEM IN FIRST FRAME
---------------------------------------------------------------
unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by
release 1.5.12 of Cygwin].
toolbar.c: bug fix for problem of initial frame being 77 chars wide on Windows.
will be overridden by my other ws.
---------------------------------------------------------------
FIX FOR LEAKING PROCESS HANDLES:
---------------------------------------------------------------
process-nt.c: Fixes for leaking handles. Inspired by work done by Adrian Aichner
<adrian@xemacs.org>.
---------------------------------------------------------------
FIX FOR CYGWIN BUG (Unicode-related):
---------------------------------------------------------------
unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by
release 1.5.12 of Cygwin].
---------------------------------------------------------------
WARNING FIXES:
---------------------------------------------------------------
console-stream.c: `reinit' is unused.
compiler.h, event-msw.c, frame-msw.c, intl-encap-win32.c, text.h: Add stuff to deal with ANSI-aliasing warnings I got.
regex.c: Gather includes together to avoid warning.
---------------------------------------------------------------
CHANGES TO INITIALIZATION ROUTINES:
---------------------------------------------------------------
buffer.c, emacs.c, console.c, debug.c, device-x.c, device.c, dragdrop.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, font-lock.c, frame-msw.c, glyphs-widget.c, glyphs.c, gui-x.c, insdel.c, lread.c, lstream.c, menubar-gtk.c, menubar-x.c, minibuf.c, mule-wnnfns.c, objects-msw.c, objects.c, print.c, scrollbar-x.c, search.c, select-x.c, text.c, undo.c, unicode.c, window.c, symsinit.h: Call reinit_*() functions directly from emacs.c, for clarity.
Factor out some redundant init code. Move disallowed stuff
that had crept into vars_of_glyphs() into complex_vars_of_glyphs().
Call init_eval_semi_early() from eval.c not in the middle of
vars_of_() in emacs.c since there should be no order dependency
in the latter calls.
---------------------------------------------------------------
ARMAGEDDON:
---------------------------------------------------------------
alloc.c, emacs.c, lisp.h, print.c: Rename inhibit_non_essential_printing_operations to
inhibit_non_essential_conversion_operations.
text.c: Assert on !inhibit_non_essential_conversion_operations.
console-msw.c, print.c: Don't do conversion in SetConsoleTitle or FindWindow to avoid
problems during armageddon. Put #errors for NON_ASCII_INTERNAL_FORMAT
in places where problems would arise.
---------------------------------------------------------------
CHANGES TO THE BUILD PROCEDURE:
---------------------------------------------------------------
config.h.in, s/cxux.h, s/usg5-4-2.h, m/powerpc.h: Add comment about correct ordering of this file.
Rearrange everything to follow this -- put all #undefs together
and before the s&m files. Add undefs for HAVE_ALLOCA, C_ALLOCA,
BROKEN_ALLOCA_IN_FUNCTION_CALLS, STACK_DIRECTION. Remove unused
HAVE_STPCPY, HAVE_GETWD, HAVE_SETLOCALE.
m/gec63.h: Deleted; totally broken, not used at all, not in FSF.
m/7300.h, m/acorn.h, m/alliant-2800.h, m/alliant.h, m/altos.h, m/amdahl.h, m/apollo.h, m/att3b.h, m/aviion.h, m/celerity.h, m/clipper.h, m/cnvrgnt.h, m/convex.h, m/cydra5.h, m/delta.h, m/delta88k.h, m/dpx2.h, m/elxsi.h, m/ews4800r.h, m/gould.h, m/hp300bsd.h, m/hp800.h, m/hp9000s300.h, m/i860.h, m/ibmps2-aix.h, m/ibmrs6000.h, m/ibmrt-aix.h, m/ibmrt.h, m/intel386.h, m/iris4d.h, m/iris5d.h, m/iris6d.h, m/irist.h, m/isi-ov.h, m/luna88k.h, m/m68k.h, m/masscomp.h, m/mg1.h, m/mips-nec.h, m/mips-siemens.h, m/mips.h, m/news.h, m/nh3000.h, m/nh4000.h, m/ns32000.h, m/orion105.h, m/pfa50.h, m/plexus.h, m/pmax.h, m/powerpc.h, m/pyrmips.h, m/sequent-ptx.h, m/sequent.h, m/sgi-challenge.h, m/symmetry.h, m/tad68k.h, m/tahoe.h, m/targon31.h, m/tekxd88.h, m/template.h, m/tower32.h, m/tower32v3.h, m/ustation.h, m/vax.h, m/wicat.h, m/xps100.h: Delete C_ALLOCA, HAVE_ALLOCA, STACK_DIRECTION,
BROKEN_ALLOCA_IN_FUNCTION_CALLS. All of this is auto-detected.
When in doubt, I followed recent FSF sources, which also have
these things deleted.
| author | ben |
|---|---|
| date | Thu, 04 Nov 2004 23:08:28 +0000 |
| parents | a8d8f419b459 |
| children | 304aebb79cd3 |
| rev | line source |
|---|---|
| 428 | 1 /* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc. |
| 771 | 2 Copyright (C) 2001 Ben Wing. |
| 428 | 3 |
| 613 | 4 This file is part of XEmacs. |
| 428 | 5 |
| 613 | 6 XEmacs is free software; you can redistribute it and/or modify |
| 428 | 7 it under the terms of the GNU General Public License as published by |
| 8 the Free Software Foundation; either version 2, or (at your option) | |
| 9 any later version. | |
| 10 | |
| 613 | 11 XEmacs is distributed in the hope that it will be useful, |
| 428 | 12 but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 14 GNU General Public License for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
| 613 | 17 along with XEmacs; see the file COPYING. If not, write to |
| 428 | 18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 19 Boston, MA 02111-1307, USA. */ | |
| 20 | |
| 21 /* Synced with FSF 20.2 */ | |
| 22 | |
| 23 #include <config.h> | |
| 24 #include "lisp.h" | |
| 25 | |
| 26 #include "buffer.h" | |
| 27 #include <paths.h> | |
| 28 | |
| 859 | 29 #include "sysdir.h" |
| 428 | 30 #include "sysfile.h" |
| 859 | 31 #include "sysproc.h" /* for qxe_getpid() */ |
| 428 | 32 #include "syspwd.h" |
| 859 | 33 #include "syssignal.h" /* for kill. */ |
| 428 | 34 |
| 35 Lisp_Object Qask_user_about_supersession_threat; | |
| 36 Lisp_Object Qask_user_about_lock; | |
| 444 | 37 int inhibit_clash_detection; |
| 428 | 38 |
| 39 #ifdef CLASH_DETECTION | |
| 442 | 40 |
| 428 | 41 /* The strategy: to lock a file FN, create a symlink .#FN in FN's |
| 42 directory, with link data `user@host.pid'. This avoids a single | |
| 43 mount (== failure) point for lock files. | |
| 44 | |
| 45 When the host in the lock data is the current host, we can check if | |
| 46 the pid is valid with kill. | |
| 442 | 47 |
| 428 | 48 Otherwise, we could look at a separate file that maps hostnames to |
| 49 reboot times to see if the remote pid can possibly be valid, since we | |
| 50 don't want Emacs to have to communicate via pipes or sockets or | |
| 51 whatever to other processes, either locally or remotely; rms says | |
| 52 that's too unreliable. Hence the separate file, which could | |
| 53 theoretically be updated by daemons running separately -- but this | |
| 54 whole idea is unimplemented; in practice, at least in our | |
| 55 environment, it seems such stale locks arise fairly infrequently, and | |
| 56 Emacs' standard methods of dealing with clashes suffice. | |
| 57 | |
| 58 We use symlinks instead of normal files because (1) they can be | |
| 59 stored more efficiently on the filesystem, since the kernel knows | |
| 60 they will be small, and (2) all the info about the lock can be read | |
| 61 in a single system call (readlink). Although we could use regular | |
| 62 files to be useful on old systems lacking symlinks, nowadays | |
| 63 virtually all such systems are probably single-user anyway, so it | |
| 64 didn't seem worth the complication. | |
| 65 | |
| 66 Similarly, we don't worry about a possible 14-character limit on | |
| 67 file names, because those are all the same systems that don't have | |
| 68 symlinks. | |
| 442 | 69 |
| 428 | 70 This is compatible with the locking scheme used by Interleaf (which |
| 71 has contributed this implementation for Emacs), and was designed by | |
| 72 Ethan Jacobson, Kimbo Mundy, and others. | |
| 442 | 73 |
| 428 | 74 --karl@cs.umb.edu/karl@hq.ileaf.com. */ |
| 75 | |
| 76 | |
| 77 /* Here is the structure that stores information about a lock. */ | |
| 78 | |
| 79 typedef struct | |
| 80 { | |
| 867 | 81 Ibyte *user; |
| 82 Ibyte *host; | |
| 647 | 83 pid_t pid; |
| 428 | 84 } lock_info_type; |
| 85 | |
| 86 /* When we read the info back, we might need this much more, | |
| 87 enough for decimal representation plus null. */ | |
| 647 | 88 #define LOCK_PID_MAX (4 * sizeof (pid_t)) |
| 428 | 89 |
| 90 /* Free the two dynamically-allocated pieces in PTR. */ | |
| 1726 | 91 #define FREE_LOCK_INFO(i) do { \ |
| 92 xfree ((i).user, Ibyte *); \ | |
| 93 xfree ((i).host, Ibyte *); \ | |
| 94 } while (0) | |
| 428 | 95 |
| 96 /* Write the name of the lock file for FN into LFNAME. Length will be | |
| 97 that of FN plus two more for the leading `.#' plus one for the null. */ | |
| 98 #define MAKE_LOCK_NAME(lock, file) \ | |
| 2367 | 99 (lock = alloca_ibytes (XSTRING_LENGTH (file) + 2 + 1), \ |
| 771 | 100 fill_in_lock_file_name (lock, file)) |
| 428 | 101 |
| 102 static void | |
| 867 | 103 fill_in_lock_file_name (Ibyte *lockfile, Lisp_Object fn) |
| 428 | 104 { |
| 867 | 105 Ibyte *file_name = XSTRING_DATA (fn); |
| 106 Ibyte *p; | |
| 647 | 107 Bytecount dirlen; |
| 428 | 108 |
| 442 | 109 for (p = file_name + XSTRING_LENGTH (fn) - 1; |
| 110 p > file_name && !IS_ANY_SEP (p[-1]); | |
| 111 p--) | |
| 112 ; | |
| 113 dirlen = p - file_name; | |
| 428 | 114 |
| 442 | 115 memcpy (lockfile, file_name, dirlen); |
| 116 p = lockfile + dirlen; | |
| 117 *(p++) = '.'; | |
| 118 *(p++) = '#'; | |
| 119 memcpy (p, file_name + dirlen, XSTRING_LENGTH (fn) - dirlen + 1); | |
| 428 | 120 } |
| 121 | |
| 122 /* Lock the lock file named LFNAME. | |
| 123 If FORCE is nonzero, we do so even if it is already locked. | |
| 124 Return 1 if successful, 0 if not. */ | |
| 125 | |
| 126 static int | |
| 867 | 127 lock_file_1 (Ibyte *lfname, int force) |
| 428 | 128 { |
| 442 | 129 /* Does not GC. */ |
| 130 int err; | |
| 867 | 131 Ibyte *lock_info_str; |
| 132 Ibyte *host_name; | |
| 133 Ibyte *user_name = user_login_name (NULL); | |
| 428 | 134 |
| 442 | 135 if (user_name == NULL) |
| 867 | 136 user_name = (Ibyte *) ""; |
| 442 | 137 |
| 138 if (STRINGP (Vsystem_name)) | |
| 771 | 139 host_name = XSTRING_DATA (Vsystem_name); |
| 428 | 140 else |
| 867 | 141 host_name = (Ibyte *) ""; |
| 442 | 142 |
| 771 | 143 lock_info_str = |
| 2367 | 144 alloca_ibytes (qxestrlen (user_name) + qxestrlen (host_name) |
| 145 + LOCK_PID_MAX + 5); | |
| 428 | 146 |
| 771 | 147 qxesprintf (lock_info_str, "%s@%s.%d", user_name, host_name, qxe_getpid ()); |
| 428 | 148 |
| 771 | 149 err = qxe_symlink (lock_info_str, lfname); |
| 442 | 150 if (err != 0 && errno == EEXIST && force) |
| 428 | 151 { |
| 771 | 152 qxe_unlink (lfname); |
| 153 err = qxe_symlink (lock_info_str, lfname); | |
| 428 | 154 } |
| 155 | |
| 156 return err == 0; | |
| 157 } | |
| 158 | |
| 159 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete, | |
| 160 1 if another process owns it (and set OWNER (if non-null) to info), | |
| 161 2 if the current process owns it, | |
| 162 or -1 if something is wrong with the locking mechanism. */ | |
| 163 | |
| 164 static int | |
| 867 | 165 current_lock_owner (lock_info_type *owner, Ibyte *lfname) |
| 428 | 166 { |
| 442 | 167 /* Does not GC. */ |
| 168 int len, ret; | |
| 428 | 169 int local_owner = 0; |
| 867 | 170 Ibyte *at, *dot; |
| 171 Ibyte *lfinfo = 0; | |
| 428 | 172 int bufsize = 50; |
| 173 /* Read arbitrarily-long contents of symlink. Similar code in | |
| 174 file-symlink-p in fileio.c. */ | |
| 175 do | |
| 176 { | |
| 177 bufsize *= 2; | |
| 867 | 178 lfinfo = (Ibyte *) xrealloc (lfinfo, bufsize); |
| 771 | 179 len = qxe_readlink (lfname, lfinfo, bufsize); |
| 428 | 180 } |
| 181 while (len >= bufsize); | |
| 442 | 182 |
| 428 | 183 /* If nonexistent lock file, all is well; otherwise, got strange error. */ |
| 184 if (len == -1) | |
| 185 { | |
| 1726 | 186 xfree (lfinfo, Ibyte *); |
| 428 | 187 return errno == ENOENT ? 0 : -1; |
| 188 } | |
| 189 | |
| 190 /* Link info exists, so `len' is its length. Null terminate. */ | |
| 191 lfinfo[len] = 0; | |
| 442 | 192 |
| 428 | 193 /* Even if the caller doesn't want the owner info, we still have to |
| 194 read it to determine return value, so allocate it. */ | |
| 195 if (!owner) | |
| 196 { | |
| 2367 | 197 owner = alloca_new (lock_info_type); |
| 428 | 198 local_owner = 1; |
| 199 } | |
| 442 | 200 |
| 428 | 201 /* Parse USER@HOST.PID. If can't parse, return -1. */ |
| 202 /* The USER is everything before the first @. */ | |
| 771 | 203 at = qxestrchr (lfinfo, '@'); |
| 204 dot = qxestrrchr (lfinfo, '.'); | |
| 428 | 205 if (!at || !dot) { |
| 1726 | 206 xfree (lfinfo, Ibyte *); |
| 428 | 207 return -1; |
| 208 } | |
| 209 len = at - lfinfo; | |
| 2367 | 210 owner->user = xnew_ibytes (len + 1); |
| 771 | 211 qxestrncpy (owner->user, lfinfo, len); |
| 428 | 212 owner->user[len] = 0; |
| 442 | 213 |
| 428 | 214 /* The PID is everything after the last `.'. */ |
| 867 | 215 owner->pid = atoi ((CIbyte *) dot + 1); |
| 428 | 216 |
| 217 /* The host is everything in between. */ | |
| 218 len = dot - at - 1; | |
| 2367 | 219 owner->host = xnew_ibytes (len + 1); |
| 771 | 220 qxestrncpy (owner->host, at + 1, len); |
| 428 | 221 owner->host[len] = 0; |
| 222 | |
| 223 /* We're done looking at the link info. */ | |
| 1726 | 224 xfree (lfinfo, Ibyte *); |
| 442 | 225 |
| 428 | 226 /* On current host? */ |
| 442 | 227 if (STRINGP (Fsystem_name ()) |
| 771 | 228 && qxestrcmp (owner->host, XSTRING_DATA (Fsystem_name ())) == 0) |
| 428 | 229 { |
| 771 | 230 if (owner->pid == qxe_getpid ()) |
| 428 | 231 ret = 2; /* We own it. */ |
| 232 else if (owner->pid > 0 | |
| 233 && (kill (owner->pid, 0) >= 0 || errno == EPERM)) | |
| 234 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 | |
| 236 zap the lockfile. */ | |
| 771 | 237 else if (qxe_unlink (lfname) < 0) |
| 428 | 238 ret = -1; |
| 239 else | |
| 240 ret = 0; | |
| 241 } | |
| 242 else | |
| 243 { /* If we wanted to support the check for stale locks on remote machines, | |
| 244 here's where we'd do it. */ | |
| 245 ret = 1; | |
| 246 } | |
| 442 | 247 |
| 428 | 248 /* Avoid garbage. */ |
| 249 if (local_owner || ret <= 0) | |
| 250 { | |
| 251 FREE_LOCK_INFO (*owner); | |
| 252 } | |
| 253 return ret; | |
| 254 } | |
| 255 | |
| 256 /* Lock the lock named LFNAME if possible. | |
| 257 Return 0 in that case. | |
| 258 Return positive if some other process owns the lock, and info about | |
| 259 that process in CLASHER. | |
| 260 Return -1 if cannot lock for any other reason. */ | |
| 261 | |
| 262 static int | |
| 867 | 263 lock_if_free (lock_info_type *clasher, Ibyte *lfname) |
| 428 | 264 { |
| 442 | 265 /* Does not GC. */ |
| 867 | 266 if (lock_file_1 ((Ibyte *) lfname, 0) == 0) |
| 428 | 267 { |
| 268 int locker; | |
| 269 | |
| 270 if (errno != EEXIST) | |
| 271 return -1; | |
| 442 | 272 |
| 428 | 273 locker = current_lock_owner (clasher, lfname); |
| 274 if (locker == 2) | |
| 275 { | |
| 276 FREE_LOCK_INFO (*clasher); | |
| 277 return 0; /* We ourselves locked it. */ | |
| 278 } | |
| 279 else if (locker == 1) | |
| 280 return 1; /* Someone else has it. */ | |
| 281 | |
| 282 return -1; /* Something's wrong. */ | |
| 283 } | |
| 284 return 0; | |
| 285 } | |
| 286 | |
| 287 /* lock_file locks file FN, | |
| 288 meaning it serves notice on the world that you intend to edit that file. | |
| 289 This should be done only when about to modify a file-visiting | |
| 290 buffer previously unmodified. | |
| 291 Do not (normally) call this for a buffer already modified, | |
| 292 as either the file is already locked, or the user has already | |
| 293 decided to go ahead without locking. | |
| 294 | |
| 295 When this returns, either the lock is locked for us, | |
| 296 or the user has said to go ahead without locking. | |
| 297 | |
| 298 If the file is locked by someone else, this calls | |
| 299 ask-user-about-lock (a Lisp function) with two arguments, | |
| 300 the file name and info about the user who did the locking. | |
| 301 This function can signal an error, or return t meaning | |
| 302 take away the lock, or return nil meaning ignore the lock. */ | |
| 303 | |
| 304 void | |
| 305 lock_file (Lisp_Object fn) | |
| 306 { | |
| 442 | 307 /* This function can GC. GC checked 7-11-00 ben */ |
| 428 | 308 /* dmoore - and can destroy current_buffer and all sorts of other |
| 309 mean nasty things with pointy teeth. If you call this make sure | |
| 310 you protect things right. */ | |
| 442 | 311 /* Somebody updated the code in this function and removed the previous |
| 428 | 312 comment. -slb */ |
| 313 | |
| 314 register Lisp_Object attack, orig_fn; | |
| 867 | 315 register Ibyte *lfname, *locker; |
| 428 | 316 lock_info_type lock_info; |
| 444 | 317 struct gcpro gcpro1, gcpro2, gcpro3; |
| 318 Lisp_Object old_current_buffer; | |
| 428 | 319 Lisp_Object subject_buf; |
| 320 | |
| 444 | 321 if (inhibit_clash_detection) |
| 322 return; | |
| 323 | |
| 793 | 324 old_current_buffer = wrap_buffer (current_buffer); |
| 446 | 325 subject_buf = Qnil; |
| 444 | 326 GCPRO3 (fn, subject_buf, old_current_buffer); |
| 428 | 327 orig_fn = fn; |
| 328 fn = Fexpand_file_name (fn, Qnil); | |
| 329 | |
| 330 /* Create the name of the lock-file for file fn */ | |
| 331 MAKE_LOCK_NAME (lfname, fn); | |
| 332 | |
| 333 /* See if this file is visited and has changed on disk since it was | |
| 334 visited. */ | |
| 335 { | |
| 336 subject_buf = get_truename_buffer (orig_fn); | |
| 337 if (!NILP (subject_buf) | |
| 338 && NILP (Fverify_visited_file_modtime (subject_buf)) | |
| 339 && !NILP (Ffile_exists_p (fn))) | |
| 442 | 340 call1_in_buffer (XBUFFER (subject_buf), |
| 341 Qask_user_about_supersession_threat, fn); | |
| 428 | 342 } |
| 343 | |
| 344 /* Try to lock the lock. */ | |
| 444 | 345 if (current_buffer != XBUFFER (old_current_buffer) |
| 346 || lock_if_free (&lock_info, lfname) <= 0) | |
| 347 /* Return now if we have locked it, or if lock creation failed | |
| 348 or current buffer is killed. */ | |
| 428 | 349 goto done; |
| 350 | |
| 351 /* Else consider breaking the lock */ | |
| 2367 | 352 locker = alloca_ibytes (qxestrlen (lock_info.user) |
| 353 + qxestrlen (lock_info.host) | |
| 354 + LOCK_PID_MAX + 9); | |
| 771 | 355 qxesprintf (locker, "%s@%s (pid %d)", lock_info.user, lock_info.host, |
| 356 lock_info.pid); | |
| 428 | 357 FREE_LOCK_INFO (lock_info); |
| 442 | 358 |
| 428 | 359 attack = call2_in_buffer (BUFFERP (subject_buf) ? XBUFFER (subject_buf) : |
| 360 current_buffer, Qask_user_about_lock , fn, | |
| 771 | 361 build_intstring (locker)); |
| 444 | 362 if (!NILP (attack) && current_buffer == XBUFFER (old_current_buffer)) |
| 428 | 363 /* User says take the lock */ |
| 364 { | |
| 365 lock_file_1 (lfname, 1); | |
| 366 goto done; | |
| 367 } | |
| 368 /* User says ignore the lock */ | |
| 369 done: | |
| 370 UNGCPRO; | |
| 371 } | |
| 372 | |
| 373 void | |
| 374 unlock_file (Lisp_Object fn) | |
| 375 { | |
| 442 | 376 /* This can GC */ |
| 867 | 377 register Ibyte *lfname; |
| 442 | 378 struct gcpro gcpro1; |
| 379 | |
| 380 GCPRO1 (fn); | |
| 428 | 381 |
| 382 fn = Fexpand_file_name (fn, Qnil); | |
| 383 | |
| 384 MAKE_LOCK_NAME (lfname, fn); | |
| 385 | |
| 386 if (current_lock_owner (0, lfname) == 2) | |
| 771 | 387 qxe_unlink (lfname); |
| 442 | 388 |
| 389 UNGCPRO; | |
| 428 | 390 } |
| 391 | |
| 392 void | |
| 442 | 393 unlock_all_files (void) |
| 428 | 394 { |
| 395 register Lisp_Object tail; | |
| 396 | |
| 434 | 397 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) |
| 428 | 398 { |
| 442 | 399 struct buffer *b = XBUFFER (XCDR (XCAR (tail))); |
| 428 | 400 if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) |
| 401 unlock_file (b->file_truename); | |
| 402 } | |
| 403 } | |
| 404 | |
| 405 DEFUN ("lock-buffer", Flock_buffer, 0, 1, 0, /* | |
| 442 | 406 Lock FILE, if current buffer is modified. |
| 407 FILE defaults to current buffer's visited file, | |
| 428 | 408 or else nothing is done if current buffer isn't visiting a file. |
| 409 */ | |
| 442 | 410 (file)) |
| 428 | 411 { |
| 412 if (NILP (file)) | |
| 413 file = current_buffer->file_truename; | |
| 414 CHECK_STRING (file); | |
| 415 if (BUF_SAVE_MODIFF (current_buffer) < BUF_MODIFF (current_buffer) | |
| 416 && !NILP (file)) | |
| 417 lock_file (file); | |
| 418 return Qnil; | |
| 419 } | |
| 420 | |
| 421 DEFUN ("unlock-buffer", Funlock_buffer, 0, 0, 0, /* | |
| 422 Unlock the file visited in the current buffer, | |
| 423 if it should normally be locked. | |
| 424 */ | |
| 425 ()) | |
| 426 { | |
| 427 /* This function can GC */ | |
| 428 /* dmoore - and can destroy current_buffer and all sorts of other | |
| 429 mean nasty things with pointy teeth. If you call this make sure | |
| 430 you protect things right. */ | |
| 431 | |
| 432 if (BUF_SAVE_MODIFF (current_buffer) < BUF_MODIFF (current_buffer) | |
| 433 && STRINGP (current_buffer->file_truename)) | |
| 434 unlock_file (current_buffer->file_truename); | |
| 435 return Qnil; | |
| 436 } | |
| 437 | |
| 438 /* Unlock the file visited in buffer BUFFER. */ | |
| 439 | |
| 440 | |
| 441 void | |
| 442 unlock_buffer (struct buffer *buffer) | |
| 443 { | |
| 444 /* This function can GC */ | |
| 445 /* dmoore - and can destroy current_buffer and all sorts of other | |
| 446 mean nasty things with pointy teeth. If you call this make sure | |
| 447 you protect things right. */ | |
| 448 if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer) | |
| 449 && STRINGP (buffer->file_truename)) | |
| 450 unlock_file (buffer->file_truename); | |
| 451 } | |
| 452 | |
| 453 DEFUN ("file-locked-p", Ffile_locked_p, 0, 1, 0, /* | |
| 442 | 454 Return nil if the FILENAME is not locked, |
| 428 | 455 t if it is locked by you, else a string of the name of the locker. |
| 456 */ | |
| 442 | 457 (filename)) |
| 428 | 458 { |
| 459 Lisp_Object ret; | |
| 867 | 460 register Ibyte *lfname; |
| 428 | 461 int owner; |
| 462 lock_info_type locker; | |
| 442 | 463 struct gcpro gcpro1; |
| 464 | |
| 465 GCPRO1 (filename); | |
| 428 | 466 |
| 467 filename = Fexpand_file_name (filename, Qnil); | |
| 468 | |
| 469 MAKE_LOCK_NAME (lfname, filename); | |
| 470 | |
| 471 owner = current_lock_owner (&locker, lfname); | |
| 472 if (owner <= 0) | |
| 473 ret = Qnil; | |
| 474 else if (owner == 2) | |
| 475 ret = Qt; | |
| 476 else | |
| 771 | 477 ret = build_intstring (locker.user); |
| 428 | 478 |
| 479 if (owner > 0) | |
| 480 FREE_LOCK_INFO (locker); | |
| 481 | |
| 442 | 482 UNGCPRO; |
| 483 | |
| 428 | 484 return ret; |
| 485 } | |
| 486 | |
| 487 | |
| 488 /* Initialization functions. */ | |
| 489 | |
| 490 void | |
| 491 syms_of_filelock (void) | |
| 492 { | |
| 493 /* This function can GC */ | |
| 494 DEFSUBR (Funlock_buffer); | |
| 495 DEFSUBR (Flock_buffer); | |
| 496 DEFSUBR (Ffile_locked_p); | |
| 497 | |
| 563 | 498 DEFSYMBOL (Qask_user_about_supersession_threat); |
| 499 DEFSYMBOL (Qask_user_about_lock); | |
| 428 | 500 } |
| 501 | |
| 444 | 502 void |
| 503 vars_of_filelock (void) | |
| 504 { | |
| 505 DEFVAR_BOOL ("inhibit-clash-detection", &inhibit_clash_detection /* | |
| 506 Non-nil inhibits creation of lock file to detect clash. | |
| 507 */); | |
| 508 inhibit_clash_detection = 0; | |
| 509 } | |
| 428 | 510 |
| 511 #endif /* CLASH_DETECTION */ |