Annotation of fam/fam/FileSystemTable.c++, Revision 1.1.1.1
1.1 trev 1: // Copyright (C) 1999 Silicon Graphics, Inc. All Rights Reserved.
2: //
3: // This program is free software; you can redistribute it and/or modify it
4: // under the terms of version 2 of the GNU General Public License as
5: // published by the Free Software Foundation.
6: //
7: // This program is distributed in the hope that it would be useful, but
8: // WITHOUT ANY WARRANTY; without even the implied warranty of
9: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, any
10: // license provided herein, whether implied or otherwise, is limited to
11: // this program in accordance with the express provisions of the GNU
12: // General Public License. Patent licenses, if any, provided herein do not
13: // apply to combinations of this program with other product or programs, or
14: // any other product whatsoever. This program is distributed without any
15: // warranty that the program is delivered free of the rightful claim of any
16: // third person by way of infringement or the like. See the GNU General
17: // Public License for more details.
18: //
19: // You should have received a copy of the GNU General Public License along
20: // with this program; if not, write the Free Software Foundation, Inc., 59
21: // Temple Place - Suite 330, Boston MA 02111-1307, USA.
22:
23: #include <stddef.h>
24: #include "FileSystemTable.h"
25:
26: #include <mntent.h>
27: #include <stdlib.h>
28: #include <string.h>
29:
30: #if HAVE_STATVFS
31: #include <sys/statvfs.h>
32: #endif
33:
34: #include "Cred.h"
35: #include "Event.h"
36: #include "FileSystem.h"
37: #include "InternalClient.h"
38: #include "LocalFileSystem.h"
39: #include "Log.h"
40: #include "NFSFileSystem.h"
41:
42: // Fam has two tables of mounted filesystems -- fs_by_name and
43: // fs_by_id. They are keyed by mountpoint and by filesystem ID,
44: // respectively. fs_by_id is lazily filled in as needed (so we only
45: // do as many statvfs calls as needed -- fam may hang if the NFS
46: // server is down). fs_by_name is completely rebuilt when /etc/mtab
47: // is changed, and fs_by_id is destroyed, to be lazily re-filled
48: // later.
49:
50: // Class Variables
51:
52: unsigned int FileSystemTable::count;
53: FileSystemTable::IDTable FileSystemTable::fs_by_id;
54: FileSystemTable::NameTable *FileSystemTable::fs_by_name;
55: const char FileSystemTable::mtab_name[] = MOUNTED;
56: InternalClient *FileSystemTable::mtab_watcher;
57: FileSystem *FileSystemTable::root;
58:
59: #ifdef HAPPY_PURIFY
60:
61: //////////////////////////////////////////////////////////////////////////////
62: // The constructor and destructor simply maintain a refcount of the
63: // files that include FileSystemTable.h. When the last reference
64: // is destroyed, the mtab watcher is turned off, and the fs_by_name
65: // table is destroyed.
66:
67: FileSystemTable::FileSystemTable()
68: {
69: count++;
70: }
71:
72: FileSystemTable::~FileSystemTable()
73: {
74: if (!--count)
75: { delete mtab_watcher;
76: mtab_watcher = NULL;
77: if (fs_by_name)
78: { destroy_fses(fs_by_name);
79: delete fs_by_name;
80: fs_by_name = NULL;
81: }
82: }
83: }
84:
85: #endif /* HAPPY_PURIFY */
86:
87: //////////////////////////////////////////////////////////////////////////////
88: // fs_by_name is a table that maps mount directories to FileSystem pointers.
89: //
90: // It is built the first time FileSystemTable::find() is called, and
91: // it's rebuilt whenever /etc/mtab changes. When it is rebuilt,
92: // existing FileSystems are moved to the new table. This is done
93: // because each ClientInterest has a pointer to its FileSystem,
94: // and we don't want to change all ClientInterests, nor do we want
95: // two FileSystem structures representing the same file system.
96:
97:
98: void
99: FileSystemTable::create_fs_by_name()
100: {
101: NameTable *new_fs_by_name = new NameTable;
102: NameTable mount_parents, dismounted_fses;
103:
104: if (fs_by_name)
105: dismounted_fses = *fs_by_name;
106:
107: // Read /etc/mtab.
108: Cred::SuperUser.become_user();
109: FILE *mtab = setmntent(mtab_name, "r");
110: if(mtab == NULL)
111: {
112: Log::error("couldn't open %s for reading", mtab_name);
113: delete new_fs_by_name;
114: return;
115: }
116: root = NULL;
117: for (mntent *mp; ((mp = getmntent(mtab)) != NULL); )
118: {
119: FileSystem *fs = fs_by_name ? fs_by_name->find(mp->mnt_dir) : NULL;
120: if (fs && fs->matches(*mp))
121: {
122: Log::debug("mtab: MATCH \"%s\" on \"%s\" using type <%s>",
123: mp->mnt_fsname, mp->mnt_dir, mp->mnt_type);
124:
125: new_fs_by_name->insert(mp->mnt_dir, fs);
126: if (dismounted_fses.find(mp->mnt_dir))
127: dismounted_fses.remove(mp->mnt_dir);
128: }
129: else
130: {
131:
132: if ((!strcmp(mp->mnt_type, MNTTYPE_NFS)
133: #if HAVE_MNTTYPE_NFS2
134: || !strcmp(mp->mnt_type, MNTTYPE_NFS2)
135: #endif
136: #if HAVE_MNTTYPE_NFS3
137: || !strcmp(mp->mnt_type, MNTTYPE_NFS3)
138: #endif
139: #if HAVE_MNTTYPE_CACHEFS
140: || !strcmp(mp->mnt_type, MNTTYPE_CACHEFS)
141: #endif
142: ) && strchr(mp->mnt_fsname, ':'))
143: {
144: if(Log::get_level() == Log::DEBUG)
145: {
146: const char *mntopt = hasmntopt(mp, "dev");
147: if(mntopt == NULL) mntopt = "";
148: Log::debug("mtab: new NFS \"%s\" on \"%s\" %s using <%s>",
149: mp->mnt_fsname, mp->mnt_dir, mntopt,
150: mp->mnt_type);
151: }
152:
153: fs = new NFSFileSystem(*mp);
154: }
155: else
156: {
157: Log::debug("mtab: new local \"%s\" on \"%s\"",
158: mp->mnt_fsname, mp->mnt_dir);
159:
160: fs = new LocalFileSystem(*mp);
161: }
162: new_fs_by_name->insert(mp->mnt_dir, fs);
163: if (fs_by_name)
164: {
165: // Find parent filesystem.
166:
167: FileSystem *parent = longest_prefix(mp->mnt_dir);
168: assert(parent);
169: mount_parents.insert(parent->dir(), parent);
170: }
171: }
172: if (!strcmp(mp->mnt_dir, "/"))
173: root = fs;
174: }
175: endmntent(mtab);
176:
177: if(root == NULL)
178: {
179: assert(root);
180: Log::error("couldn't find / in %s", mtab_name);
181: delete new_fs_by_name;
182: return; // horrible... we're not in a good state, the
183: // now-brain-damaged fs_by_name is hanging around, etc.
184: // It might be better to exit.
185: }
186:
187: // Install the new table.
188:
189: delete fs_by_name;
190: fs_by_name = new_fs_by_name;
191:
192: // Relocate all interests in parents of new filesystems.
193: // We relocate interests out of parents before relocating
194: // out of dismounted filesystems in the hope that we can
195: // avoid relocating some interests twice. Consider the case
196: // where /mnt/foo is an interest, and we simultaneously
197: // learn that /mnt was dismounted and /fred was mounted.
198: // We don't want to relocate /mnt/foo to /, then test
199: // it for relocation to /fred.
200:
201: unsigned i;
202: FileSystem *fs;
203: for (i = 0; ((fs = mount_parents.value(i)) != NULL); i++)
204: {
205: Log::debug("mtab: relocating in parent \"%s\"", fs->dir());
206: fs->relocate_interests();
207: }
208:
209: // Relocate all interests in dismounted filesystems and destroy
210: // the filesystems.
211:
212: for (i = 0; ((fs = dismounted_fses.value(i)) != NULL); i++)
213: {
214: Log::debug("mtab: dismount \"%s\" on \"%s\"",
215: fs->fsname(), fs->dir());
216:
217: fs->relocate_interests();
218: delete fs;
219: }
220: Log::debug("mtab done.");
221: }
222:
223: void
224: FileSystemTable::destroy_fses(NameTable *fstab)
225: {
226: // Destroy any unreclaimed filesystems.
227:
228: for (unsigned i = 0; fstab->key(i); i++)
229: delete fstab->value(i);
230: }
231:
232: void
233: FileSystemTable::mtab_event_handler(const Event& event, void *)
234: {
235: if (event == Event::Changed)
236: {
237: Log::debug("%s changed, rebuilding filesystem table", mtab_name);
238: fs_by_id.removeAll();
239: create_fs_by_name();
240: }
241: }
242:
243: //////////////////////////////////////////////////////////////////////////////
244: //
245:
246: FileSystem *
247: FileSystemTable::find(const char *path, const Cred& cr)
248: {
249: char temp_path[PATH_MAX];
250: FileSystem *fs = NULL;
251:
252: assert(path[0] == '/');
253:
254: // (Initialize fs_by_name if necessary.) As a side effect,
255: // create_fs_by_name initializes our "root" member variable.
256: if (!fs_by_name)
257: { create_fs_by_name();
258: mtab_watcher = new InternalClient(mtab_name, mtab_event_handler, NULL);
259: }
260:
261: cr.become_user();
262:
263: // If !HAVE_STATVFS, we could use statfs instead, but the statfs.f_fsid
264: // is not set reliably on Linux, so it's useless. We'll do every lookup
265: // by name; hopefully that doesn't suck.
266: #if HAVE_STATVFS
267:
268: // Perform a statvfs(2) on the first existing ancestor.
269:
270: struct statvfs fs_status;
271: int rc = statvfs(path, &fs_status);
272: if (rc < 0)
273: { (void) strcpy(temp_path, path);
274: while (rc < 0)
275: { char *slash = strrchr(temp_path, '/');
276: if (!slash)
277: return root;
278: *slash = '\0';
279: rc = statvfs(temp_path, &fs_status);
280: }
281: }
282:
283: // Look up filesystem by ID.
284:
285: fs = fs_by_id.find(fs_status.f_fsid);
286: if (fs)
287: return fs;
288: #endif
289:
290: // Convert to real path. Look up real path in fs_by_name().
291:
292: cr.become_user();
293: (void) realpath(path, temp_path);
294: fs = longest_prefix(temp_path);
295:
296: // Insert into fs_by_id.
297:
298: #if HAVE_STATVFS
299: fs_by_id.insert(fs_status.f_fsid, fs);
300: #endif
301:
302: return fs;
303: }
304:
305: FileSystem *
306: FileSystemTable::longest_prefix(const char *path)
307: {
308: FileSystem * bestmatch = root;
309: int maxmatch = -1;
310: const char *key;
311: for (unsigned i = 0; ((key = fs_by_name->key(i)) != NULL); i++)
312: { for (int j = 0; ; j++)
313: { if (!key[j])
314: { if ((!path[j] || path[j] == '/') && j > maxmatch)
315: { maxmatch = j;
316: bestmatch = fs_by_name->value(i);
317: }
318: break;
319: }
320: if (key[j] != path[j])
321: break;
322: }
323: }
324: assert(bestmatch);
325: return bestmatch;
326: }
327:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to FileSystemTable.c++ CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / fam / fam