![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix|
Return to lock.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / unix |
1.1 root 1: /* lock.c
2: Lock and unlock a file name.
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; if not, write to the Free Software
20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21:
22: The author of the program may be contacted at [email protected] or
23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
24: */
25:
26: #include "uucp.h"
27:
28: #if USE_RCS_ID
29: const char lock_rcsid[] = "$Id: lock.c,v 1.1 93/07/30 08:02:37 bin Exp Locker: bin $";
30: #endif
31:
32: #include "uudefs.h"
33: #include "sysdep.h"
34: #include "system.h"
35:
36: #include <errno.h>
37:
38: #if HAVE_FCNTL_H
39: #include <fcntl.h>
40: #else
41: #if HAVE_SYS_FILE_H
42: #include <sys/file.h>
43: #endif
44: #endif
45:
46: #ifndef O_RDONLY
47: #define O_RDONLY 0
48: #define O_WRONLY 1
49: #define O_RDWR 2
50: #endif
51:
52: #ifndef O_NOCTTY
53: #define O_NOCTTY 0
54: #endif
55:
56: #ifndef SEEK_SET
57: #define SEEK_SET 0
58: #endif
59:
60: /* Lock something. If the fspooldir argument is TRUE, the argument is
61: a file name relative to the spool directory; otherwise the argument
62: is a simple file name which should be created in the system lock
63: directory (under HDB this is /etc/locks). */
64:
65: boolean
66: fsdo_lock (zlock, fspooldir, pferr)
67: const char *zlock;
68: boolean fspooldir;
69: boolean *pferr;
70: {
71: char *zfree;
72: const char *zpath, *zslash;
73: size_t cslash;
74: pid_t ime;
75: char *ztempfile;
76: char abtempfile[sizeof "TMP1234567890"];
77: int o;
78: #if HAVE_V2_LOCKFILES
79: int i;
80: #else
81: char ab[12];
82: #endif
83: int cwrote;
84: const char *zerr;
85: boolean fret;
86:
87: if (pferr != NULL)
88: *pferr = TRUE;
89:
90: if (fspooldir)
91: {
92: zfree = NULL;
93: zpath = zlock;
94: }
95: else
96: {
97: zfree = zsysdep_in_dir (zSlockdir, zlock);
98: zpath = zfree;
99: }
100:
101: ime = getpid ();
102:
103: /* We do the actual lock by creating a file and then linking it to
104: the final file name we want. This avoids race conditions due to
105: one process checking the file before we have finished writing it,
106: and also works even if we are somehow running as root.
107:
108: First, create the file in the right directory (we must create the
109: file in the same directory since otherwise we might attempt a
110: cross-device link). */
111: zslash = strrchr (zpath, '/');
112: if (zslash == NULL)
113: cslash = 0;
114: else
115: cslash = zslash - zpath + 1;
116:
117: sprintf (abtempfile, "TMP%010lx", (unsigned long) ime);
118: ztempfile = zbufalc (cslash + sizeof abtempfile);
119: memcpy (ztempfile, zpath, cslash);
120: memcpy (ztempfile + cslash, abtempfile, sizeof abtempfile);
121:
122: o = creat (ztempfile, IPUBLIC_FILE_MODE);
123: if (o < 0)
124: {
125: if (errno == ENOENT)
126: {
127: if (! fsysdep_make_dirs (ztempfile, FALSE))
128: {
129: ubuffree (zfree);
130: ubuffree (ztempfile);
131: return FALSE;
132: }
133: o = creat (ztempfile, IPUBLIC_FILE_MODE);
134: }
135: if (o < 0)
136: {
137: ulog (LOG_ERROR, "creat (%s): %s", ztempfile, strerror (errno));
138: ubuffree (zfree);
139: ubuffree (ztempfile);
140: return FALSE;
141: }
142: }
143:
144: #if HAVE_V2_LOCKFILES
145: i = ime;
146: cwrote = write (o, &i, sizeof i);
147: #else
148: sprintf (ab, "%10d\n", (int) ime);
149: cwrote = write (o, ab, strlen (ab));
150: #endif
151:
152: zerr = NULL;
153: if (cwrote < 0)
154: zerr = "write";
155: if (close (o) < 0)
156: zerr = "close";
157: if (zerr != NULL)
158: {
159: ulog (LOG_ERROR, "%s (%s): %s", zerr, ztempfile, strerror (errno));
160: (void) remove (ztempfile);
161: ubuffree (zfree);
162: ubuffree (ztempfile);
163: return FALSE;
164: }
165:
166: /* Now try to link the file we just created to the lock file that we
167: want. If it fails, try reading the existing file to make sure
168: the process that created it still exists. We do this in a loop
169: to make it easy to retry if the old locking process no longer
170: exists. */
171: fret = TRUE;
172: if (pferr != NULL)
173: *pferr = FALSE;
174: o = -1;
175: zerr = NULL;
176:
177: while (link (ztempfile, zpath) != 0)
178: {
179: int cgot;
180: int ipid;
181: boolean freadonly;
182:
183: fret = FALSE;
184:
185: if (errno != EEXIST)
186: {
187: ulog (LOG_ERROR, "link (%s, %s): %s", ztempfile, zpath,
188: strerror (errno));
189: if (pferr != NULL)
190: *pferr = TRUE;
191: break;
192: }
193:
194: freadonly = FALSE;
195: o = open ((char *) zpath, O_RDWR | O_NOCTTY, 0);
196: if (o < 0)
197: {
198: if (errno == EACCES)
199: {
200: freadonly = TRUE;
201: o = open ((char *) zpath, O_RDONLY, 0);
202: }
203: if (o < 0)
204: {
205: if (errno == ENOENT)
206: {
207: /* The file was presumably removed between the link
208: and the open. Try the link again. */
209: fret = TRUE;
210: continue;
211: }
212: zerr = "open";
213: break;
214: }
215: }
216:
217: /* The race starts here. See below for a discussion. */
218:
219: #if HAVE_V2_LOCKFILES
220: cgot = read (o, &i, sizeof i);
221: #else
222: cgot = read (o, ab, sizeof ab - 1);
223: #endif
224:
225: if (cgot < 0)
226: {
227: zerr = "read";
228: break;
229: }
230:
231: #if HAVE_V2_LOCKFILES
232: ipid = i;
233: #else
234: ab[cgot] = '\0';
235: ipid = strtol (ab, (char **) NULL, 10);
236: #endif
237:
238: /* On NFS, the link might have actually succeeded even though we
239: got a failure return. This can happen if the original
240: acknowledgement was lost or delayed and the operation was
241: retried. In this case the pid will be our own. This
242: introduces a rather improbable race condition: if a stale
243: lock was left with our process ID in it, and another process
244: just did the kill, below, but has not yet changed the lock
245: file to hold its own process ID, we could start up and make
246: it all the way to here and think we have the lock. I'm not
247: going to worry about this possibility. */
248: if (ipid == ime)
249: {
250: fret = TRUE;
251: break;
252: }
253:
254: /* If the process still exists, we will get EPERM rather than
255: ESRCH. We then return FALSE to indicate that we cannot make
256: the lock. */
257: if (kill (ipid, 0) == 0 || errno == EPERM)
258: break;
259:
260: ulog (LOG_ERROR, "Found stale lock %s held by process %d",
261: zpath, ipid);
262:
263: /* This is a stale lock, created by a process that no longer
264: exists.
265:
266: Now we could remove the file (and, if the file mode disallows
267: writing, that's what we have to do), but we try to avoid
268: doing so since it causes a race condition. If we remove the
269: file, and are interrupted any time after we do the read until
270: we do the remove, another process could get in, open the
271: file, find that it was a stale lock, remove the file and
272: create a new one. When we regained control we would remove
273: the file the other process just created.
274:
275: These files are being generated partially for the benefit of
276: cu, and it would be nice to avoid the race however cu avoids
277: it, so that the programs remain compatible. Unfortunately,
278: nobody seems to know how cu avoids the race, or even if it
279: tries to avoid it at all.
280:
281: There are a few ways to avoid the race. We could use kernel
282: locking primitives, but they may not be available. We could
283: link to a special file name, but if that file were left lying
284: around then no stale lock could ever be broken (Henry Spencer
285: would think this was a good thing).
286:
287: Instead I've implemented the following procedure: seek to the
288: start of the file, write our pid into it, sleep for five
289: seconds, and then make sure our pid is still there. Anybody
290: who checks the file while we're asleep will find our pid
291: there and fail the lock. The only race will come from
292: another process which has done the read by the time we do our
293: write. That process will then have five seconds to do its
294: own write. When we wake up, we'll notice that our pid is no
295: longer in the file, and retry the lock from the beginning.
296:
297: This relies on the atomicity of write(2). If it possible for
298: the writes of two processes to be interleaved, the two
299: processes could livelock. POSIX unfortunately leaves this
300: case explicitly undefined; however, given that the write is
301: of less than a disk block, it's difficult to imagine an
302: interleave occurring.
303:
304: Note that this is still a race. If it takes the second
305: process more than five seconds to do the kill, the lseek, and
306: the write, both processes will think they have the lock.
307: Perhaps the length of time to sleep should be configurable.
308: Even better, perhaps I should add a configuration option to
309: use a permanent lock file, which eliminates any race and
310: forces the installer to be aware of the existence of the
311: permanent lock file.
312:
313: We stat the file after the sleep, to make sure some other
314: program hasn't deleted it for us. */
315: if (freadonly)
316: {
317: (void) close (o);
318: o = -1;
319: (void) remove (zpath);
320: continue;
321: }
322:
323: if (lseek (o, (off_t) 0, SEEK_SET) != 0)
324: {
325: zerr = "lseek";
326: break;
327: }
328:
329: #if HAVE_V2_LOCKFILES
330: i = ime;
331: cwrote = write (o, &i, sizeof i);
332: #else
333: sprintf (ab, "%10d\n", (int) ime);
334: cwrote = write (o, ab, strlen (ab));
335: #endif
336:
337: if (cwrote < 0)
338: {
339: zerr = "write";
340: break;
341: }
342:
343: (void) sleep (5);
344:
345: if (lseek (o, (off_t) 0, SEEK_SET) != 0)
346: {
347: zerr = "lseek";
348: break;
349: }
350:
351: #if HAVE_V2_LOCKFILES
352: cgot = read (o, &i, sizeof i);
353: #else
354: cgot = read (o, ab, sizeof ab - 1);
355: #endif
356:
357: if (cgot < 0)
358: {
359: zerr = "read";
360: break;
361: }
362:
363: #if HAVE_V2_LOCKFILES
364: ipid = i;
365: #else
366: ab[cgot] = '\0';
367: ipid = strtol (ab, (char **) NULL, 10);
368: #endif
369:
370: if (ipid == ime)
371: {
372: struct stat sfile, sdescriptor;
373:
374: /* It looks like we have the lock. Do the final stat
375: check. */
376: if (stat ((char *) zpath, &sfile) < 0)
377: {
378: if (errno != ENOENT)
379: {
380: zerr = "stat";
381: break;
382: }
383: /* Loop around and try again. */
384: }
385: else
386: {
387: if (fstat (o, &sdescriptor) < 0)
388: {
389: zerr = "fstat";
390: break;
391: }
392:
393: if (sfile.st_ino == sdescriptor.st_ino
394: && sfile.st_dev == sdescriptor.st_dev)
395: {
396: /* Close the file before assuming we've succeeded to
397: pick up any trailing errors. */
398: if (close (o) < 0)
399: {
400: zerr = "close";
401: break;
402: }
403:
404: o = -1;
405:
406: /* We have the lock. */
407: fret = TRUE;
408: break;
409: }
410: }
411: }
412:
413: /* Loop around and try the lock again. We keep doing this until
414: the lock file holds a pid that exists. */
415: (void) close (o);
416: o = -1;
417: fret = TRUE;
418: }
419:
420: if (zerr != NULL)
421: {
422: ulog (LOG_ERROR, "%s (%s): %s", zerr, zpath, strerror (errno));
423: if (pferr != NULL)
424: *pferr = TRUE;
425: }
426:
427: if (o >= 0)
428: (void) close (o);
429:
430: ubuffree (zfree);
431:
432: /* It would be nice if we could leave the temporary file around for
433: future calls, but considering that we create lock files in
434: various different directories it's probably more trouble than
435: it's worth. */
436: if (remove (ztempfile) != 0)
437: ulog (LOG_ERROR, "remove (%s): %s", ztempfile, strerror (errno));
438:
439: ubuffree (ztempfile);
440:
441: return fret;
442: }
443:
444: /* Unlock something. The fspooldir argument is as in fsdo_lock. */
445:
446: boolean
447: fsdo_unlock (zlock, fspooldir)
448: const char *zlock;
449: boolean fspooldir;
450: {
451: char *zfree;
452: const char *zpath;
453:
454: if (fspooldir)
455: {
456: zfree = NULL;
457: zpath = zlock;
458: }
459: else
460: {
461: zfree = zsysdep_in_dir (zSlockdir, zlock);
462: zpath = zfree;
463: }
464:
465: if (remove (zpath) == 0
466: || errno == ENOENT)
467: {
468: ubuffree (zfree);
469: return TRUE;
470: }
471: else
472: {
473: ulog (LOG_ERROR, "remove (%s): %s", zpath, strerror (errno));
474: ubuffree (zfree);
475: return FALSE;
476: }
477: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.