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