filelock.c 13.3 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1
/* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
2 3 4 5 6

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Jim Blandy's avatar
Jim Blandy committed
7
the Free Software Foundation; either version 2, or (at your option)
Richard M. Stallman's avatar
Richard M. Stallman committed
8 9 10 11 12 13 14 15 16
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
17 18
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
19 20 21 22


#include <sys/types.h>
#include <sys/stat.h>
23
#include <config.h>
Jim Blandy's avatar
Jim Blandy committed
24 25

#ifdef VMS
Jim Blandy's avatar
Jim Blandy committed
26
#include "vms-pwd.h"
Jim Blandy's avatar
Jim Blandy committed
27
#else
Richard M. Stallman's avatar
Richard M. Stallman committed
28
#include <pwd.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
29
#endif /* not VMS */
Jim Blandy's avatar
Jim Blandy committed
30

Richard M. Stallman's avatar
Richard M. Stallman committed
31 32 33
#include <sys/file.h>
#ifdef USG
#include <fcntl.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
34
#include <string.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
35 36 37 38 39
#endif /* USG */

#include "lisp.h"
#include "buffer.h"

Richard M. Stallman's avatar
Richard M. Stallman committed
40 41
#include <errno.h>
#ifndef errno
Richard M. Stallman's avatar
Richard M. Stallman committed
42
extern int errno;
43 44
#endif

Richard M. Stallman's avatar
Richard M. Stallman committed
45 46
#ifdef CLASH_DETECTION
  
Richard M. Stallman's avatar
Richard M. Stallman committed
47 48 49 50 51 52 53 54 55 56 57 58 59 60
/* The strategy: to lock a file FN, create a symlink .#FN in FN's
   directory, with link data `user@host.pid'.  This avoids a single
   mount (== failure) point for lock files.

   When the host in the lock data is the current host, we can check if
   the pid is valid with kill.
   
   Otherwise, we could look at a separate file that maps hostnames to
   reboot times to see if the remote pid can possibly be valid, since we
   don't want Emacs to have to communicate via pipes or sockets or
   whatever to other processes, either locally or remotely; rms says
   that's too unreliable.  Hence the separate file, which could
   theoretically be updated by daemons running separately -- but this
   whole idea is unimplemented; in practice, at least in our
Karl Heuer's avatar
Karl Heuer committed
61
   environment, it seems such stale locks arise fairly infrequently, and
Richard M. Stallman's avatar
Richard M. Stallman committed
62 63 64 65 66 67
   Emacs' standard methods of dealing with clashes suffice.

   We use symlinks instead of normal files because (1) they can be
   stored more efficiently on the filesystem, since the kernel knows
   they will be small, and (2) all the info about the lock can be read
   in a single system call (readlink).  Although we could use regular
Karl Heuer's avatar
Karl Heuer committed
68
   files to be useful on old systems lacking symlinks, nowadays
Richard M. Stallman's avatar
Richard M. Stallman committed
69 70 71 72 73 74 75 76 77 78 79 80
   virtually all such systems are probably single-user anyway, so it
   didn't seem worth the complication.
   
   Similarly, we don't worry about a possible 14-character limit on
   file names, because those are all the same systems that don't have
   symlinks.
   
   This is compatible with the locking scheme used by Interleaf (which
   has contributed this implementation for Emacs), and was designed by
   Ethan Jacobson, Kimbo Mundy, and others.
   
   --karl@cs.umb.edu/karl@hq.ileaf.com.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
81

Richard M. Stallman's avatar
Richard M. Stallman committed
82 83

/* Here is the structure that stores information about a lock.  */
Jim Blandy's avatar
Jim Blandy committed
84

Richard M. Stallman's avatar
Richard M. Stallman committed
85 86 87 88
typedef struct
{
  char *user;
  char *host;
89
  unsigned long pid;
Richard M. Stallman's avatar
Richard M. Stallman committed
90
} lock_info_type;
Jim Blandy's avatar
Jim Blandy committed
91

92 93 94
/* When we read the info back, we might need this much more,
   enough for decimal representation plus null.  */
#define LOCK_PID_MAX (4 * sizeof (unsigned long))
Jim Blandy's avatar
Jim Blandy committed
95

Richard M. Stallman's avatar
Richard M. Stallman committed
96 97
/* Free the two dynamically-allocated pieces in PTR.  */
#define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
98 99


Richard M. Stallman's avatar
Richard M. Stallman committed
100 101
/* Write the name of the lock file for FN into LFNAME.  Length will be
   that of FN plus two more for the leading `.#' plus one for the null.  */
102
#define MAKE_LOCK_NAME(lock, file) \
Richard M. Stallman's avatar
Richard M. Stallman committed
103 104
  (lock = (char *) alloca (XSTRING (file)->size + 2 + 1), \
   fill_in_lock_file_name (lock, (file)))
105

Richard M. Stallman's avatar
Richard M. Stallman committed
106 107
static void
fill_in_lock_file_name (lockfile, fn)
108 109 110
     register char *lockfile;
     register Lisp_Object fn;
{
Richard M. Stallman's avatar
Richard M. Stallman committed
111 112 113 114 115 116 117 118 119
  register char *p;

  strcpy (lockfile, XSTRING (fn)->data);

  /* Shift the nondirectory part of the file name (including the null)
     right two characters.  Here is one of the places where we'd have to
     do something to support 14-character-max file names.  */
  for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
    p[2] = *p;
120
  
Richard M. Stallman's avatar
Richard M. Stallman committed
121 122 123 124
  /* Insert the `.#'.  */
  p[1] = '.';
  p[2] = '#';
}
125

Richard M. Stallman's avatar
Richard M. Stallman committed
126 127 128
/* Lock the lock file named LFNAME.
   If FORCE is nonzero, we do so even if it is already locked.
   Return 1 if successful, 0 if not.  */
129

Richard M. Stallman's avatar
Richard M. Stallman committed
130 131 132 133 134 135
static int
lock_file_1 (lfname, force)
     char *lfname; 
     int force;
{
  register int err;
136 137
  char *user_name = (char *) XSTRING (Fuser_login_name (Qnil))->data;
  char *host_name = (char *) XSTRING (Fsystem_name ())->data;
138 139
  char *lock_info_str = alloca (strlen (user_name) + strlen (host_name)
                                + LOCK_PID_MAX + 5);
Richard M. Stallman's avatar
Richard M. Stallman committed
140

141 142
  sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
           (unsigned long) getpid ());
Richard M. Stallman's avatar
Richard M. Stallman committed
143 144 145

  err = symlink (lock_info_str, lfname);
  if (errno == EEXIST && force)
146
    {
Richard M. Stallman's avatar
Richard M. Stallman committed
147 148
      unlink (lfname);
      err = symlink (lock_info_str, lfname);
149 150
    }

Richard M. Stallman's avatar
Richard M. Stallman committed
151 152
  return err == 0;
}
153

Jim Blandy's avatar
Jim Blandy committed
154

Richard M. Stallman's avatar
Richard M. Stallman committed
155 156 157 158 159

/* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
   1 if another process owns it (and set OWNER (if non-null) to info),
   2 if the current process owns it,
   or -1 if something is wrong with the locking mechanism.  */
160

Richard M. Stallman's avatar
Richard M. Stallman committed
161 162 163 164
static int
current_lock_owner (owner, lfname)
     lock_info_type *owner;
     char *lfname;
Jim Blandy's avatar
Jim Blandy committed
165
{
Richard M. Stallman's avatar
Richard M. Stallman committed
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
#ifndef index
  extern char *rindex (), *index ();
#endif
  int o, p, len, ret;
  int local_owner = 0;
  char *at, *dot;
  char *lfinfo = 0;
  int bufsize = 50;
  /* Read arbitrarily-long contents of symlink.  Similar code in
     file-symlink-p in fileio.c.  */
  do
    {
      bufsize *= 2;
      lfinfo = (char *) xrealloc (lfinfo, bufsize);
      len = readlink (lfname, lfinfo, bufsize);
    }
  while (len >= bufsize);
  
  /* If nonexistent lock file, all is well; otherwise, got strange error. */
  if (len == -1)
    {
      xfree (lfinfo);
      return errno == ENOENT ? 0 : -1;
    }
Jim Blandy's avatar
Jim Blandy committed
190

Richard M. Stallman's avatar
Richard M. Stallman committed
191 192 193 194 195 196 197
  /* Link info exists, so `len' is its length.  Null terminate.  */
  lfinfo[len] = 0;
  
  /* Even if the caller doesn't want the owner info, we still have to
     read it to determine return value, so allocate it.  */
  if (!owner)
    {
198
      owner = (lock_info_type *) alloca (sizeof (lock_info_type));
Richard M. Stallman's avatar
Richard M. Stallman committed
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
      local_owner = 1;
    }
  
  /* Parse USER@HOST.PID.  If can't parse, return -1.  */
  /* The USER is everything before the first @.  */
  at = index (lfinfo, '@');
  dot = rindex (lfinfo, '.');
  if (!at || !dot) {
    xfree (lfinfo);
    return -1;
  }
  len = at - lfinfo;
  owner->user = (char *) xmalloc (len + 1);
  strncpy (owner->user, lfinfo, len);
  owner->user[len] = 0;
  
  /* The PID is everything after the last `.'.  */
  owner->pid = atoi (dot + 1);
Jim Blandy's avatar
Jim Blandy committed
217

Richard M. Stallman's avatar
Richard M. Stallman committed
218 219 220 221 222
  /* The host is everything in between.  */
  len = dot - at - 1;
  owner->host = (char *) xmalloc (len + 1);
  strncpy (owner->host, at + 1, len);
  owner->host[len] = 0;
Jim Blandy's avatar
Jim Blandy committed
223

Richard M. Stallman's avatar
Richard M. Stallman committed
224 225 226 227 228
  /* We're done looking at the link info.  */
  xfree (lfinfo);
  
  /* On current host?  */
  if (strcmp (owner->host, XSTRING (Fsystem_name ())->data) == 0)
Jim Blandy's avatar
Jim Blandy committed
229
    {
Richard M. Stallman's avatar
Richard M. Stallman committed
230 231 232 233 234 235 236 237 238 239 240 241 242
      if (owner->pid == getpid ())
        ret = 2; /* We own it.  */
      
      if (owner->pid > 0
               && (kill (owner->pid, 0) >= 0 || errno == EPERM))
        ret = 1; /* An existing process on this machine owns it.  */
      
      /* The owner process is dead or has a strange pid (<=0), so try to
         zap the lockfile.  */
      if (unlink (lfname) < 0)
        ret = -1;
      
      ret = 0;
Jim Blandy's avatar
Jim Blandy committed
243
    }
Richard M. Stallman's avatar
Richard M. Stallman committed
244 245 246 247 248 249 250 251 252 253 254 255
  else
    { /* If we wanted to support the check for stale locks on remote machines,
         here's where we'd do it.  */
      ret = 1;
    }
  
  /* Avoid garbage.  */
  if (local_owner || ret <= 0)
    {
      FREE_LOCK_INFO (*owner);
    }
  return ret;
Jim Blandy's avatar
Jim Blandy committed
256 257
}

Richard M. Stallman's avatar
Richard M. Stallman committed
258 259 260 261 262 263

/* Lock the lock named LFNAME if possible.
   Return 0 in that case.
   Return positive if some other process owns the lock, and info about
     that process in CLASHER.
   Return -1 if cannot lock for any other reason.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
264

Richard M. Stallman's avatar
Richard M. Stallman committed
265 266 267 268 269 270 271 272
static int
lock_if_free (clasher, lfname)
     lock_info_type *clasher;
     register char *lfname; 
{
  while (lock_file_1 (lfname, 0) == 0)
    {
      int locker;
273

Richard M. Stallman's avatar
Richard M. Stallman committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
      if (errno != EEXIST)
	return -1;
      
      locker = current_lock_owner (clasher, lfname);
      if (locker == 2)
        {
          FREE_LOCK_INFO (*clasher);
          return 0;   /* We ourselves locked it.  */
        }
      else if (locker == 1)
        return 1;  /* Someone else has it.  */
      else if (locker == -1)
        return -1; /* Something's wrong.  */

       /* If some other error, or no such lock, try to lock again.  */
       /* Is there a case where we loop forever?  */
    }
  return 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
292 293
}

Richard M. Stallman's avatar
Richard M. Stallman committed
294
/* lock_file locks file FN,
Richard M. Stallman's avatar
Richard M. Stallman committed
295 296 297
   meaning it serves notice on the world that you intend to edit that file.
   This should be done only when about to modify a file-visiting
   buffer previously unmodified.
Richard M. Stallman's avatar
Richard M. Stallman committed
298
   Do not (normally) call this for a buffer already modified,
Richard M. Stallman's avatar
Richard M. Stallman committed
299 300 301
   as either the file is already locked, or the user has already
   decided to go ahead without locking.

Richard M. Stallman's avatar
Richard M. Stallman committed
302
   When this returns, either the lock is locked for us,
Richard M. Stallman's avatar
Richard M. Stallman committed
303 304
   or the user has said to go ahead without locking.

Richard M. Stallman's avatar
Richard M. Stallman committed
305
   If the file is locked by someone else, this calls
Richard M. Stallman's avatar
Richard M. Stallman committed
306
   ask-user-about-lock (a Lisp function) with two arguments,
Richard M. Stallman's avatar
Richard M. Stallman committed
307
   the file name and info about the user who did the locking.
Richard M. Stallman's avatar
Richard M. Stallman committed
308 309 310 311 312
   This function can signal an error, or return t meaning
   take away the lock, or return nil meaning ignore the lock.  */

void
lock_file (fn)
Richard M. Stallman's avatar
Richard M. Stallman committed
313
    register Lisp_Object fn;
Richard M. Stallman's avatar
Richard M. Stallman committed
314
{
315
  register Lisp_Object attack, orig_fn;
Richard M. Stallman's avatar
Richard M. Stallman committed
316 317
  register char *lfname, *locker;
  lock_info_type lock_info;
Richard M. Stallman's avatar
Richard M. Stallman committed
318

319
  orig_fn = fn;
320 321
  fn = Fexpand_file_name (fn, Qnil);

Richard M. Stallman's avatar
Richard M. Stallman committed
322
  /* Create the name of the lock-file for file fn */
323
  MAKE_LOCK_NAME (lfname, fn);
Richard M. Stallman's avatar
Richard M. Stallman committed
324

Jim Blandy's avatar
Jim Blandy committed
325 326
  /* See if this file is visited and has changed on disk since it was
     visited.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
327
  {
328
    register Lisp_Object subject_buf;
329
    subject_buf = get_truename_buffer (orig_fn);
Jim Blandy's avatar
Jim Blandy committed
330 331 332
    if (!NILP (subject_buf)
	&& NILP (Fverify_visited_file_modtime (subject_buf))
	&& !NILP (Ffile_exists_p (fn)))
Richard M. Stallman's avatar
Richard M. Stallman committed
333 334 335 336
      call1 (intern ("ask-user-about-supersession-threat"), fn);
  }

  /* Try to lock the lock. */
Richard M. Stallman's avatar
Richard M. Stallman committed
337 338
  if (lock_if_free (&lock_info, lfname) <= 0)
    /* Return now if we have locked it, or if lock creation failed */
Richard M. Stallman's avatar
Richard M. Stallman committed
339 340 341
    return;

  /* Else consider breaking the lock */
Richard M. Stallman's avatar
Richard M. Stallman committed
342 343 344 345 346 347 348
  locker = alloca (strlen (lock_info.user) + strlen (lock_info.host)
                   + LOCK_PID_MAX + 9);
  sprintf (locker, "%s@%s (pid %d)", lock_info.user, lock_info.host,
           lock_info.pid);
  FREE_LOCK_INFO (lock_info);
  
  attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
Jim Blandy's avatar
Jim Blandy committed
349
  if (!NILP (attack))
Richard M. Stallman's avatar
Richard M. Stallman committed
350 351
    /* User says take the lock */
    {
Richard M. Stallman's avatar
Richard M. Stallman committed
352
      lock_file_1 (lfname, 1);
Richard M. Stallman's avatar
Richard M. Stallman committed
353 354 355 356 357 358 359 360 361 362 363
      return;
    }
  /* User says ignore the lock */
}

void
unlock_file (fn)
     register Lisp_Object fn;
{
  register char *lfname;

364 365
  fn = Fexpand_file_name (fn, Qnil);

366
  MAKE_LOCK_NAME (lfname, fn);
Richard M. Stallman's avatar
Richard M. Stallman committed
367

Richard M. Stallman's avatar
Richard M. Stallman committed
368
  if (current_lock_owner (0, lfname) == 2)
Richard M. Stallman's avatar
Richard M. Stallman committed
369 370 371 372 373 374 375 376 377
    unlink (lfname);
}

void
unlock_all_files ()
{
  register Lisp_Object tail;
  register struct buffer *b;

378
  for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
Richard M. Stallman's avatar
Richard M. Stallman committed
379 380
    {
      b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
381 382
      if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
	unlock_file (b->file_truename);
Richard M. Stallman's avatar
Richard M. Stallman committed
383 384 385 386 387 388 389 390
    }
}

DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
  0, 1, 0,
  "Lock FILE, if current buffer is modified.\n\
FILE defaults to current buffer's visited file,\n\
or else nothing is done if current buffer isn't visiting a file.")
391 392
  (file)
     Lisp_Object file;
Richard M. Stallman's avatar
Richard M. Stallman committed
393
{
394 395
  if (NILP (file))
    file = current_buffer->file_truename;
Richard M. Stallman's avatar
Richard M. Stallman committed
396
  else
397
    CHECK_STRING (file, 0);
398
  if (SAVE_MODIFF < MODIFF
399 400
      && !NILP (file))
    lock_file (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
401 402 403 404 405 406 407 408 409
  return Qnil;    
}

DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
  0, 0, 0,
 "Unlock the file visited in the current buffer,\n\
if it should normally be locked.")
  ()
{
410
  if (SAVE_MODIFF < MODIFF
411 412
      && STRINGP (current_buffer->file_truename))
    unlock_file (current_buffer->file_truename);
Richard M. Stallman's avatar
Richard M. Stallman committed
413 414 415 416 417 418 419 420
  return Qnil;
}

/* Unlock the file visited in buffer BUFFER.  */

unlock_buffer (buffer)
     struct buffer *buffer;
{
421
  if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
422 423
      && STRINGP (buffer->file_truename))
    unlock_file (buffer->file_truename);
Richard M. Stallman's avatar
Richard M. Stallman committed
424 425 426 427 428
}

DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
  "Return nil if the FILENAME is not locked,\n\
t if it is locked by you, else a string of the name of the locker.")
429 430
  (filename)
  Lisp_Object filename;
Richard M. Stallman's avatar
Richard M. Stallman committed
431
{
Richard M. Stallman's avatar
Richard M. Stallman committed
432
  Lisp_Object ret;
Richard M. Stallman's avatar
Richard M. Stallman committed
433 434
  register char *lfname;
  int owner;
Richard M. Stallman's avatar
Richard M. Stallman committed
435
  lock_info_type locker;
Richard M. Stallman's avatar
Richard M. Stallman committed
436

437
  filename = Fexpand_file_name (filename, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
438

439
  MAKE_LOCK_NAME (lfname, filename);
Richard M. Stallman's avatar
Richard M. Stallman committed
440

Richard M. Stallman's avatar
Richard M. Stallman committed
441
  owner = current_lock_owner (&locker, lfname);
Richard M. Stallman's avatar
Richard M. Stallman committed
442
  if (owner <= 0)
Richard M. Stallman's avatar
Richard M. Stallman committed
443 444 445 446 447 448 449 450 451 452
    ret = Qnil;
  else if (owner == 2)
    ret = Qt;
  else
    ret = build_string (locker.user);

  if (owner > 0)
    FREE_LOCK_INFO (locker);

  return ret;
Richard M. Stallman's avatar
Richard M. Stallman committed
453 454
}

Jim Blandy's avatar
Jim Blandy committed
455 456 457 458 459

/* Initialization functions.  */

init_filelock ()
{
Richard M. Stallman's avatar
Richard M. Stallman committed
460
#if 0
461
  char *new_name;
462

463 464 465
  lock_dir = egetenv ("EMACSLOCKDIR");
  if (! lock_dir)
    lock_dir = PATH_LOCK;
Jim Blandy's avatar
Jim Blandy committed
466

467 468 469 470
  /* Copy the name in case egetenv got it from a Lisp string.  */
  new_name = (char *) xmalloc (strlen (lock_dir) + 2);
  strcpy (new_name, lock_dir);
  lock_dir = new_name;
471

Jim Blandy's avatar
Jim Blandy committed
472
  /* Make sure it ends with a slash.  */
473 474
  if (lock_dir[strlen (lock_dir) - 1] != '/')
    strcat (lock_dir, "/");
Jim Blandy's avatar
Jim Blandy committed
475

476
  superlock_file = (char *) xmalloc ((strlen (lock_dir)
Jim Blandy's avatar
Jim Blandy committed
477
				      + sizeof (SUPERLOCK_NAME)));
478 479
  strcpy (superlock_file, lock_dir);
  strcat (superlock_file, SUPERLOCK_NAME);
Richard M. Stallman's avatar
Richard M. Stallman committed
480
#endif
Jim Blandy's avatar
Jim Blandy committed
481 482
}

Richard M. Stallman's avatar
Richard M. Stallman committed
483 484 485 486 487 488 489 490
syms_of_filelock ()
{
  defsubr (&Sunlock_buffer);
  defsubr (&Slock_buffer);
  defsubr (&Sfile_locked_p);
}

#endif /* CLASH_DETECTION */