![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtab_file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / amd / config|
Return to mtab_file.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / amd / config |
1.1 root 1: /*
2: * $Id: mtab_file.c,v 5.2 90/06/23 22:20:54 jsp Rel $
3: *
4: * Copyright (c) 1990 Jan-Simon Pendry
5: * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
6: * Copyright (c) 1990 The Regents of the University of California.
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to Berkeley by
10: * Jan-Simon Pendry at Imperial College, London.
11: *
12: * Redistribution and use in source and binary forms are permitted provided
13: * that: (1) source distributions retain this entire copyright notice and
14: * comment, and (2) distributions including binaries display the following
15: * acknowledgement: ``This product includes software developed by the
16: * University of California, Berkeley and its contributors'' in the
17: * documentation or other materials provided with the distribution and in
18: * all advertising materials mentioning features or use of this software.
19: * Neither the name of the University nor the names of its contributors may
20: * be used to endorse or promote products derived from this software without
21: * specific prior written permission.
22: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
23: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
24: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
25: *
26: * @(#)mtab_file.c 5.1 (Berkeley) 6/29/90
27: */
28:
29: #include "am.h"
30:
31: #ifdef READ_MTAB_FROM_FILE
32:
33: #ifdef USE_FCNTL
34: #include <fcntl.h>
35: #else
36: #include <sys/file.h>
37: #endif /* USE_FCNTL */
38:
39: #ifdef UPDATE_MTAB
40:
41: /*
42: * Do strict /etc/mtab locking
43: */
44: #define MTAB_LOCKING
45:
46: /*
47: * Firewall mtab entries
48: */
49: #define MTAB_STRIPNL
50:
51: #include <sys/stat.h>
52: static FILE *mnt_file;
53:
54: /*
55: * If the system is being trashed by something, then
56: * opening mtab may fail with ENFILE. So, go to sleep
57: * for a second and try again. (Yes - this has happened to me.)
58: *
59: * Note that this *may* block the automounter, oh well.
60: * If we get to this state then things are badly wrong anyway...
61: *
62: * Give the system 10 seconds to recover but then give up.
63: * Hopefully something else will exit and free up some file
64: * table slots in that time.
65: */
66: #define NFILE_RETRIES 10 /* seconds */
67:
68: #ifdef MTAB_LOCKING
69: #ifdef LOCK_FCNTL
70: static int lock(fd)
71: {
72: int rc;
73: struct flock lk;
74:
75: lk.l_type = F_WRLCK;
76: lk.l_whence = 0;
77: lk.l_start = 0;
78: lk.l_len = 0;
79:
80: again:
81: rc = fcntl(fd, F_SETLKW, (caddr_t) &lk);
82: if (rc < 0 && (errno == EACCES || errno == EAGAIN)) {
83: #ifdef DEBUG
84: dlog("Blocked, trying to obtain exclusive mtab lock");
85: #endif /* DEBUG */
86: sleep(1);
87: goto again;
88: }
89: return rc;
90: }
91: #else
92: #define lock(fd) (flock((fd), LOCK_EX))
93: #endif /* LOCK_FCNTL */
94: #endif /* MTAB_LOCKING */
95:
96: /*
97: * Unlock the mount table
98: */
99: void unlock_mntlist()
100: {
101: /*
102: * Release file lock, by closing the file
103: */
104: if (mnt_file) {
105: endmntent(mnt_file);
106: mnt_file = 0;
107: }
108: }
109:
110: /*
111: * Write out a mount list
112: */
113: void rewrite_mtab(mp)
114: mntlist *mp;
115: {
116: FILE *mfp;
117:
118: /*
119: * Concoct a temporary name in the same
120: * directory as the target mount table
121: * so that rename() will work.
122: */
123: char tmpname[64];
124: int retries;
125: int tmpfd;
126: char *cp;
127: char *mcp = mtab;
128: cp = strrchr(mcp, '/');
129: if (cp) {
130: bcopy(mcp, tmpname, cp - mcp);
131: tmpname[cp-mcp] = '\0';
132: } else {
133: plog(XLOG_WARNING, "No '/' in mtab (%s), using \".\" as tmp directory", mtab);
134: tmpname[0] = '.'; tmpname[1] = '\0';
135: }
136: strcat(tmpname, "/mtabXXXXXX");
137: mktemp(tmpname);
138: retries = 0;
139: enfile1:
140: if ((tmpfd = open(tmpname, O_RDWR|O_CREAT|O_TRUNC, 0644)) < 0) {
141: if (errno == ENFILE && retries++ < NFILE_RETRIES) {
142: sleep(1);
143: goto enfile1;
144: }
145: plog(XLOG_ERROR, "%s: open: %m", tmpname);
146: return;
147: }
148: if (close(tmpfd) < 0)
149: plog(XLOG_ERROR, "Couldn't close tmp file descriptor: %m");
150:
151: retries = 0;
152: enfile2:
153: mfp = setmntent(tmpname, "w");
154: if (!mfp) {
155: if (errno == ENFILE && retries++ < NFILE_RETRIES) {
156: sleep(1);
157: goto enfile2;
158: }
159: plog(XLOG_ERROR, "setmntent(\"%s\", \"w\"): %m", tmpname);
160: return;
161: }
162:
163: while (mp) {
164: if (mp->mnt)
165: if (addmntent(mfp, mp->mnt))
166: plog(XLOG_ERROR, "Can't write entry to %s", tmpname);
167: mp = mp->mnext;
168: }
169:
170: endmntent(mfp);
171:
172: /*
173: * Rename temporary mtab to real mtab
174: */
175: if (rename(tmpname, mtab) < 0)
176: plog(XLOG_ERROR, "rename %s to %s: %m", tmpname, mtab);
177: }
178:
179: #ifdef MTAB_STRIPNL
180: static void mtab_stripnl(s)
181: char *s;
182: {
183: do {
184: s = strchr(s, '\n');
185: if (s)
186: *s++ = ' ';
187: } while (s);
188: }
189: #endif /* MTAB_STRIPNL */
190:
191: /*
192: * Append a mntent structure to the
193: * current mount table.
194: */
195: void write_mntent(mp)
196: struct mntent *mp;
197: {
198: int retries = 0;
199: FILE *mfp;
200: enfile:
201: mfp = setmntent(mtab, "a");
202: if (mfp) {
203: #ifdef MTAB_STRIPNL
204: mtab_stripnl(mp->mnt_opts);
205: #endif /* MTAB_STRIPNL */
206: if (addmntent(mfp, mp))
207: plog(XLOG_ERROR, "Couldn't write %s: %m", mtab);
208: endmntent(mfp);
209: } else {
210: if (errno == ENFILE && retries < NFILE_RETRIES) {
211: sleep(1);
212: goto enfile;
213: }
214: plog(XLOG_ERROR, "setmntent(\"%s\", \"a\"): %m", mtab);
215: }
216: }
217:
218: #endif /* UPDATE_MTAB */
219:
220: static struct mntent *mnt_dup(mp)
221: struct mntent *mp;
222: {
223: struct mntent *new_mp = ALLOC(mntent);
224:
225: new_mp->mnt_fsname = strdup(mp->mnt_fsname);
226: new_mp->mnt_dir = strdup(mp->mnt_dir);
227: new_mp->mnt_type = strdup(mp->mnt_type);
228: new_mp->mnt_opts = strdup(mp->mnt_opts);
229:
230: new_mp->mnt_freq = mp->mnt_freq;
231: new_mp->mnt_passno = mp->mnt_passno;
232:
233: return new_mp;
234: }
235:
236: /*
237: * Read a mount table into memory
238: */
239: mntlist *read_mtab(fs)
240: char *fs;
241: {
242: mntlist **mpp, *mhp;
243:
244: struct mntent *mep;
245: FILE *mfp = 0;
246:
247: #ifdef UPDATE_MTAB
248: /*
249: * There is a possible race condition if two processes enter
250: * this routine at the same time. One will be blocked by the
251: * exclusive lock below (or by the shared lock in setmntent)
252: * and by the time the second process has the exclusive lock
253: * it will be on the wrong underlying object. To check for this
254: * the mtab file is stat'ed before and after all the locking
255: * sequence, and if it is a different file then we assume that
256: * it may be the wrong file (only "may", since there is another
257: * race between the initial stat and the setmntent).
258: *
259: * Simpler solutions to this problem are invited...
260: */
261: int racing = 0;
262: #ifdef MTAB_LOCKING
263: int rc;
264: int retries = 0;
265: struct stat st_before, st_after;
266: #endif /* MTAB_LOCKING */
267:
268: if (mnt_file) {
269: #ifdef DEBUG
270: dlog("Forced close on %s in read_mtab", mtab);
271: #endif /* DEBUG */
272: endmntent(mnt_file);
273: mnt_file = 0;
274: }
275:
276: #ifdef MTAB_LOCKING
277: again:
278: if (mfp) {
279: endmntent(mfp);
280: mfp = 0;
281: }
282:
283: clock_valid = 0;
284: if (stat(mtab, &st_before) < 0) {
285: plog(XLOG_ERROR, "%s: stat: %m", mtab);
286: if (errno == ESTALE) {
287: /* happens occasionally */
288: sleep(1);
289: goto again;
290: }
291: return 0;
292: }
293: #endif /* MTAB_LOCKING */
294: #endif /* UPDATE_MTAB */
295:
296: eacces:
297: mfp = setmntent(mtab, "r+");
298: if (!mfp) {
299: /*
300: * Since setmntent locks the descriptor, it
301: * is possible it can fail... so retry if
302: * needed.
303: */
304: if (errno == EACCES || errno == EAGAIN) {
305: #ifdef DEBUG
306: dlog("Blocked, trying to obtain exclusive mtab lock");
307: #endif /* DEBUG */
308: goto eacces;
309: } else if (errno == ENFILE && retries++ < NFILE_RETRIES) {
310: sleep(1);
311: goto eacces;
312: }
313:
314: plog(XLOG_ERROR, "setmntent(\"%s\", \"r+\"): %m", mtab);
315: return 0;
316: }
317:
318: #ifdef MTAB_LOCKING
319: #ifdef UPDATE_MTAB
320: /*
321: * At this point we have an exclusive lock on the mount list,
322: * but it may be the wrong one so...
323: */
324:
325: /*
326: * Need to get an exclusive lock on the current
327: * mount table until we have a new copy written
328: * out, when the lock is released in free_mntlist.
329: * flock is good enough since the mount table is
330: * not shared between machines.
331: */
332: do
333: rc = lock(fileno(mfp));
334: while (rc < 0 && errno == EINTR);
335: if (rc < 0) {
336: plog(XLOG_ERROR, "Couldn't lock %s: %m", mtab);
337: endmntent(mfp);
338: return 0;
339: }
340: /*
341: * Now check whether the mtab file has changed under our feet
342: */
343: if (stat(mtab, &st_after) < 0) {
344: plog(XLOG_ERROR, "%s: stat", mtab);
345: goto again;
346: }
347:
348: if (st_before.st_dev != st_after.st_dev ||
349: st_before.st_ino != st_after.st_ino) {
350: if (racing == 0) {
351: /* Sometimes print a warning */
352: plog(XLOG_WARNING,
353: "Possible mount table race - retrying %s", fs);
354: }
355: racing = (racing+1) & 3;
356: goto again;
357: }
358: #endif /* UPDATE_MTAB */
359: #endif /* MTAB_LOCKING */
360:
361: mpp = &mhp;
362:
363: /*
364: * XXX - In SunOS 4 there is (yet another) memory leak
365: * which loses 1K the first time getmntent is called.
366: * (jsp)
367: */
368: while (mep = getmntent(mfp)) {
369: /*
370: * Allocate a new slot
371: */
372: *mpp = ALLOC(mntlist);
373:
374: /*
375: * Copy the data returned by getmntent
376: */
377: (*mpp)->mnt = mnt_dup(mep);
378:
379: /*
380: * Move to next pointer
381: */
382: mpp = &(*mpp)->mnext;
383: }
384: *mpp = 0;
385:
386: #ifdef UPDATE_MTAB
387: /*
388: * If we are not updating the mount table then we
389: * can free the resources held here, otherwise they
390: * must be held until the mount table update is complete
391: */
392: mnt_file = mfp;
393: #else
394: endmntent(mfp);
395: #endif /* UPDATE_MTAB */
396:
397: return mhp;
398: }
399:
400: #endif /* READ_MTAB_FROM_FILE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.