1/*
2 * Copyright (c) 1997-2006 Erez Zadok
3 * Copyright (c) 1989 Jan-Simon Pendry
4 * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
5 * Copyright (c) 1989 The Regents of the University of California.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * Jan-Simon Pendry at Imperial College, London.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 *    must display the following acknowledgment:
21 *      This product includes software developed by the University of
22 *      California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 *    may be used to endorse or promote products derived from this software
25 *    without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 *
40 * File: am-utils/fsinfo/fsi_analyze.c
41 *
42 */
43
44/*
45 * Analyze filesystem declarations
46 *
47 * Note: most of this is magic!
48 */
49
50#ifdef HAVE_CONFIG_H
51# include <config.h>
52#endif /* HAVE_CONFIG_H */
53#include <am_defs.h>
54#include <fsi_data.h>
55#include <fsinfo.h>
56
57char *disk_fs_strings[] =
58{
59  "fstype", "opts", "dumpset", "passno", "freq", "mount", "log", 0,
60};
61
62char *mount_strings[] =
63{
64  "volname", "exportfs", 0,
65};
66
67char *fsmount_strings[] =
68{
69  "as", "volname", "fstype", "opts", "from", 0,
70};
71
72char *host_strings[] =
73{
74  "host", "netif", "config", "arch", "cluster", "os", 0,
75};
76
77char *ether_if_strings[] =
78{
79  "inaddr", "netmask", "hwaddr", 0,
80};
81
82
83/*
84 * Strip off the trailing part of a domain
85 * to produce a short-form domain relative
86 * to the local host domain.
87 * Note that this has no effect if the domain
88 * names do not have the same number of
89 * components.  If that restriction proves
90 * to be a problem then the loop needs recoding
91 * to skip from right to left and do partial
92 * matches along the way -- ie more expensive.
93 */
94void
95domain_strip(char *otherdom, char *localdom)
96{
97  char *p1, *p2;
98
99  if ((p1 = strchr(otherdom, '.')) &&
100      (p2 = strchr(localdom, '.')) &&
101      STREQ(p1 + 1, p2 + 1))
102    *p1 = '\0';
103}
104
105
106/*
107 * Take a little-endian domain name and
108 * transform into a big-endian Un*x pathname.
109 * For example: kiska.doc.ic -> ic/doc/kiska
110 */
111static char *
112compute_hostpath(char *hn)
113{
114  char *p = xmalloc(MAXPATHLEN);
115  char *d;
116  char path[MAXPATHLEN];
117
118  xstrlcpy(p, hn, MAXPATHLEN);
119  domain_strip(p, hostname);
120  path[0] = '\0';
121
122  do {
123    d = strrchr(p, '.');
124    if (d) {
125      *d = 0;
126      xstrlcat(path, d + 1, sizeof(path));
127      xstrlcat(path, "/", sizeof(path));
128    } else {
129      xstrlcat(path, p, sizeof(path));
130    }
131  } while (d);
132
133  fsi_log("hostpath of '%s' is '%s'", hn, path);
134
135  xstrlcpy(p, path, MAXPATHLEN);
136  return p;
137}
138
139
140static dict_ent *
141find_volname(char *nn)
142{
143  dict_ent *de;
144  char *p = strdup(nn);
145  char *q;
146
147  do {
148    fsi_log("Searching for volname %s", p);
149    de = dict_locate(dict_of_volnames, p);
150    q = strrchr(p, '/');
151    if (q)
152      *q = '\0';
153  } while (!de && q);
154
155  XFREE(p);
156  return de;
157}
158
159
160static void
161show_required(ioloc *l, int mask, char *info, char *hostname, char *strings[])
162{
163  int i;
164  fsi_log("mask left for %s:%s is %#x", hostname, info, mask);
165
166  for (i = 0; strings[i]; i++)
167    if (ISSET(mask, i))
168      lerror(l, "%s:%s needs field \"%s\"", hostname, info, strings[i]);
169}
170
171
172/*
173 * Check and fill in "exportfs" details.
174 * Make sure the m_exported field references
175 * the most local node with an "exportfs" entry.
176 */
177static int
178check_exportfs(qelem *q, fsi_mount *e)
179{
180  fsi_mount *mp;
181  int errors = 0;
182
183  ITER(mp, fsi_mount, q) {
184    if (ISSET(mp->m_mask, DM_EXPORTFS)) {
185      if (e)
186	lwarning(mp->m_ioloc, "%s has duplicate exportfs data", mp->m_name);
187      mp->m_exported = mp;
188      if (!ISSET(mp->m_mask, DM_VOLNAME))
189	set_mount(mp, DM_VOLNAME, strdup(mp->m_name));
190    } else {
191      mp->m_exported = e;
192    }
193
194    /*
195     * Recursively descend the mount tree
196     */
197    if (mp->m_mount)
198      errors += check_exportfs(mp->m_mount, mp->m_exported);
199
200    /*
201     * If a volume name has been specified, but this node and none
202     * of its parents has been exported, report an error.
203     */
204    if (ISSET(mp->m_mask, DM_VOLNAME) && !mp->m_exported) {
205      lerror(mp->m_ioloc, "%s has a volname but no exportfs data", mp->m_name);
206      errors++;
207    }
208  }
209
210  return errors;
211}
212
213
214static int
215analyze_dkmount_tree(qelem *q, fsi_mount *parent, disk_fs *dk)
216{
217  fsi_mount *mp;
218  int errors = 0;
219
220  ITER(mp, fsi_mount, q) {
221    fsi_log("Mount %s:", mp->m_name);
222    if (parent) {
223      char n[MAXPATHLEN];
224      xsnprintf(n, sizeof(n), "%s/%s", parent->m_name, mp->m_name);
225      if (*mp->m_name == '/')
226	lerror(mp->m_ioloc, "sub-directory %s of %s starts with '/'", mp->m_name, parent->m_name);
227      else if (STREQ(mp->m_name, "default"))
228	lwarning(mp->m_ioloc, "sub-directory of %s is named \"default\"", parent->m_name);
229      fsi_log("Changing name %s to %s", mp->m_name, n);
230      XFREE(mp->m_name);
231      mp->m_name = strdup(n);
232    }
233
234    mp->m_name_len = strlen(mp->m_name);
235    mp->m_parent = parent;
236    mp->m_dk = dk;
237    if (mp->m_mount)
238      analyze_dkmount_tree(mp->m_mount, mp, dk);
239  }
240
241  return errors;
242}
243
244
245/*
246 * The mount tree is a singleton list
247 * containing the top-level mount
248 * point for a disk.
249 */
250static int
251analyze_dkmounts(disk_fs *dk, qelem *q)
252{
253  int errors = 0;
254  fsi_mount *mp, *mp2 = 0;
255  int i = 0;
256
257  /*
258   * First scan the list of subdirs to make
259   * sure there is only one - and remember it
260   */
261  if (q) {
262    ITER(mp, fsi_mount, q) {
263      mp2 = mp;
264      i++;
265    }
266  }
267
268  /*
269   * Check...
270   */
271  if (i < 1) {
272    lerror(dk->d_ioloc, "%s:%s has no mount point", dk->d_host->h_hostname, dk->d_dev);
273    return 1;
274  }
275
276  if (i > 1) {
277    lerror(dk->d_ioloc, "%s:%s has more than one mount point", dk->d_host->h_hostname, dk->d_dev);
278    errors++;
279  }
280
281  /*
282   * Now see if a default mount point is required
283   */
284  if (mp2 && STREQ(mp2->m_name, "default")) {
285    if (ISSET(mp2->m_mask, DM_VOLNAME)) {
286      char nbuf[1024];
287      compute_automount_point(nbuf, sizeof(nbuf), dk->d_host, mp2->m_volname);
288      XFREE(mp2->m_name);
289      mp2->m_name = strdup(nbuf);
290      fsi_log("%s:%s has default mount on %s", dk->d_host->h_hostname, dk->d_dev, mp2->m_name);
291    } else {
292      lerror(dk->d_ioloc, "no volname given for %s:%s", dk->d_host->h_hostname, dk->d_dev);
293      errors++;
294    }
295  }
296
297  /*
298   * Fill in the disk mount point
299   */
300  if (!errors && mp2 && mp2->m_name)
301    dk->d_mountpt = strdup(mp2->m_name);
302  else
303    dk->d_mountpt = strdup("error");
304
305  /*
306   * Analyze the mount tree
307   */
308  errors += analyze_dkmount_tree(q, 0, dk);
309
310  /*
311   * Analyze the export tree
312   */
313  errors += check_exportfs(q, 0);
314
315  return errors;
316}
317
318
319static void
320fixup_required_disk_info(disk_fs *dp)
321{
322  /*
323   * "fstype"
324   */
325  if (ISSET(dp->d_mask, DF_FSTYPE)) {
326    if (STREQ(dp->d_fstype, "swap")) {
327
328      /*
329       * Fixup for a swap device
330       */
331      if (!ISSET(dp->d_mask, DF_PASSNO)) {
332	dp->d_passno = 0;
333	BITSET(dp->d_mask, DF_PASSNO);
334      } else if (dp->d_freq != 0) {
335	lwarning(dp->d_ioloc,
336		 "Pass number for %s:%s is non-zero",
337		 dp->d_host->h_hostname, dp->d_dev);
338      }
339
340      /*
341       * "freq"
342       */
343      if (!ISSET(dp->d_mask, DF_FREQ)) {
344	dp->d_freq = 0;
345	BITSET(dp->d_mask, DF_FREQ);
346      } else if (dp->d_freq != 0) {
347	lwarning(dp->d_ioloc,
348		 "dump frequency for %s:%s is non-zero",
349		 dp->d_host->h_hostname, dp->d_dev);
350      }
351
352      /*
353       * "opts"
354       */
355      if (!ISSET(dp->d_mask, DF_OPTS))
356	set_disk_fs(dp, DF_OPTS, strdup("swap"));
357
358      /*
359       * "mount"
360       */
361      if (!ISSET(dp->d_mask, DF_MOUNT)) {
362	qelem *q = new_que();
363	fsi_mount *m = new_mount();
364
365	m->m_name = strdup("swap");
366	m->m_mount = new_que();
367	ins_que(&m->m_q, q->q_back);
368	dp->d_mount = q;
369	BITSET(dp->d_mask, DF_MOUNT);
370      } else {
371	lerror(dp->d_ioloc, "%s: mount field specified for swap partition", dp->d_host->h_hostname);
372      }
373    } else if (STREQ(dp->d_fstype, "export")) {
374
375      /*
376       * "passno"
377       */
378      if (!ISSET(dp->d_mask, DF_PASSNO)) {
379	dp->d_passno = 0;
380	BITSET(dp->d_mask, DF_PASSNO);
381      } else if (dp->d_passno != 0) {
382	lwarning(dp->d_ioloc,
383		 "pass number for %s:%s is non-zero",
384		 dp->d_host->h_hostname, dp->d_dev);
385      }
386
387      /*
388       * "freq"
389       */
390      if (!ISSET(dp->d_mask, DF_FREQ)) {
391	dp->d_freq = 0;
392	BITSET(dp->d_mask, DF_FREQ);
393      } else if (dp->d_freq != 0) {
394	lwarning(dp->d_ioloc,
395		 "dump frequency for %s:%s is non-zero",
396		 dp->d_host->h_hostname, dp->d_dev);
397      }
398
399      /*
400       * "opts"
401       */
402      if (!ISSET(dp->d_mask, DF_OPTS))
403	set_disk_fs(dp, DF_OPTS, strdup("rw,defaults"));
404
405    }
406  }
407}
408
409
410static void
411fixup_required_mount_info(fsmount *fp, dict_ent *de)
412{
413  if (!ISSET(fp->f_mask, FM_FROM)) {
414    if (de->de_count != 1) {
415      lerror(fp->f_ioloc, "ambiguous mount: %s is a replicated filesystem", fp->f_volname);
416    } else {
417      dict_data *dd;
418      fsi_mount *mp = 0;
419      dd = AM_FIRST(dict_data, &de->de_q);
420      mp = (fsi_mount *) dd->dd_data;
421      if (!mp)
422	abort();
423      fp->f_ref = mp;
424      set_fsmount(fp, FM_FROM, mp->m_dk->d_host->h_hostname);
425      fsi_log("set: %s comes from %s", fp->f_volname, fp->f_from);
426    }
427  }
428
429  if (!ISSET(fp->f_mask, FM_FSTYPE)) {
430    set_fsmount(fp, FM_FSTYPE, strdup("nfs"));
431    fsi_log("set: fstype is %s", fp->f_fstype);
432  }
433
434  if (!ISSET(fp->f_mask, FM_OPTS)) {
435    set_fsmount(fp, FM_OPTS, strdup("rw,nosuid,grpid,defaults"));
436    fsi_log("set: opts are %s", fp->f_opts);
437  }
438
439  if (!ISSET(fp->f_mask, FM_LOCALNAME)) {
440    if (fp->f_ref) {
441      set_fsmount(fp, FM_LOCALNAME, strdup(fp->f_volname));
442      fsi_log("set: localname is %s", fp->f_localname);
443    } else {
444      lerror(fp->f_ioloc, "cannot determine localname since volname %s is not uniquely defined", fp->f_volname);
445    }
446  }
447}
448
449
450/*
451 * For each disk on a host
452 * analyze the mount information
453 * and fill in any derivable
454 * details.
455 */
456static void
457analyze_drives(host *hp)
458{
459  qelem *q = hp->h_disk_fs;
460  disk_fs *dp;
461
462  ITER(dp, disk_fs, q) {
463    int req;
464    fsi_log("Disk %s:", dp->d_dev);
465    dp->d_host = hp;
466    fixup_required_disk_info(dp);
467    req = ~dp->d_mask & DF_REQUIRED;
468    if (req)
469      show_required(dp->d_ioloc, req, dp->d_dev, hp->h_hostname, disk_fs_strings);
470    analyze_dkmounts(dp, dp->d_mount);
471  }
472}
473
474
475/*
476 * Check that all static mounts make sense and
477 * that the source volumes exist.
478 */
479static void
480analyze_mounts(host *hp)
481{
482  qelem *q = hp->h_mount;
483  fsmount *fp;
484  int netbootp = 0;
485
486  ITER(fp, fsmount, q) {
487    char *p;
488    char *nn = strdup(fp->f_volname);
489    int req;
490    dict_ent *de = (dict_ent *) NULL;
491    int found = 0;
492    int matched = 0;
493
494    if (ISSET(fp->f_mask, FM_DIRECT)) {
495      found = 1;
496      matched = 1;
497    } else
498      do {
499	p = 0;
500	de = find_volname(nn);
501	fsi_log("Mount: %s (trying %s)", fp->f_volname, nn);
502
503	if (de) {
504	  found = 1;
505
506	  /*
507	   * Check that the from field is really exporting
508	   * the filesystem requested.
509	   * LBL: If fake mount, then don't care about
510	   *      consistency check.
511	   */
512	  if (ISSET(fp->f_mask, FM_FROM) && !ISSET(fp->f_mask, FM_DIRECT)) {
513	    dict_data *dd;
514	    fsi_mount *mp2 = 0;
515
516	    ITER(dd, dict_data, &de->de_q) {
517	      fsi_mount *mp = (fsi_mount *) dd->dd_data;
518
519	      if (fp->f_from &&
520		  STREQ(mp->m_dk->d_host->h_hostname, fp->f_from)) {
521		mp2 = mp;
522		break;
523	      }
524	    }
525
526	    if (mp2) {
527	      fp->f_ref = mp2;
528	      matched = 1;
529	      break;
530	    }
531	  } else {
532	    matched = 1;
533	    break;
534	  }
535	}
536	p = strrchr(nn, '/');
537	if (p)
538	  *p = 0;
539      } while (de && p);
540    XFREE(nn);
541
542    if (!found) {
543      lerror(fp->f_ioloc, "volname %s unknown", fp->f_volname);
544    } else if (matched) {
545
546      if (de)
547	fixup_required_mount_info(fp, de);
548      req = ~fp->f_mask & FM_REQUIRED;
549      if (req) {
550	show_required(fp->f_ioloc, req, fp->f_volname, hp->h_hostname,
551		      fsmount_strings);
552      } else if (STREQ(fp->f_localname, "/")) {
553	hp->h_netroot = fp;
554	netbootp |= FM_NETROOT;
555      } else if (STREQ(fp->f_localname, "swap")) {
556	hp->h_netswap = fp;
557	netbootp |= FM_NETSWAP;
558      }
559
560    } else {
561      lerror(fp->f_ioloc, "volname %s not exported from %s", fp->f_volname,
562	     fp->f_from ? fp->f_from : "anywhere");
563    }
564  }
565
566  if (netbootp && (netbootp != FM_NETBOOT))
567    lerror(hp->h_ioloc, "network booting requires both root and swap areas");
568}
569
570
571void
572analyze_hosts(qelem *q)
573{
574  host *hp;
575
576  show_area_being_processed("analyze hosts", 5);
577
578  /*
579   * Check all drives
580   */
581  ITER(hp, host, q) {
582    fsi_log("disks on host %s", hp->h_hostname);
583    show_new("ana-host");
584    hp->h_hostpath = compute_hostpath(hp->h_hostname);
585
586    if (hp->h_disk_fs)
587      analyze_drives(hp);
588
589  }
590
591  show_area_being_processed("analyze mounts", 5);
592
593  /*
594   * Check static mounts
595   */
596  ITER(hp, host, q) {
597    fsi_log("mounts on host %s", hp->h_hostname);
598    show_new("ana-mount");
599    if (hp->h_mount)
600      analyze_mounts(hp);
601
602  }
603}
604
605
606/*
607 * Check an automount request
608 */
609static void
610analyze_automount(automount *ap)
611{
612  dict_ent *de = find_volname(ap->a_volname);
613
614  if (de) {
615    ap->a_mounted = de;
616  } else {
617    if (STREQ(ap->a_volname, ap->a_name))
618      lerror(ap->a_ioloc, "unknown volname %s automounted", ap->a_volname);
619    else
620      lerror(ap->a_ioloc, "unknown volname %s automounted on %s", ap->a_volname, ap->a_name);
621  }
622}
623
624
625static void
626analyze_automount_tree(qelem *q, char *pref, int lvl)
627{
628  automount *ap;
629
630  ITER(ap, automount, q) {
631    char nname[1024];
632
633    if (lvl > 0 || ap->a_mount)
634      if (ap->a_name[1] && strchr(ap->a_name + 1, '/'))
635	lerror(ap->a_ioloc, "not allowed '/' in a directory name");
636    xsnprintf(nname, sizeof(nname), "%s/%s", pref, ap->a_name);
637    XFREE(ap->a_name);
638    ap->a_name = strdup(nname[1] == '/' ? nname + 1 : nname);
639    fsi_log("automount point %s:", ap->a_name);
640    show_new("ana-automount");
641
642    if (ap->a_mount) {
643      analyze_automount_tree(ap->a_mount, ap->a_name, lvl + 1);
644    } else if (ap->a_hardwiredfs) {
645      fsi_log("\thardwired from %s to %s", ap->a_volname, ap->a_hardwiredfs);
646    } else if (ap->a_volname) {
647      fsi_log("\tautomount from %s", ap->a_volname);
648      analyze_automount(ap);
649    } else if (ap->a_symlink) {
650      fsi_log("\tsymlink to %s", ap->a_symlink);
651    } else {
652      ap->a_volname = strdup(ap->a_name);
653      fsi_log("\timplicit automount from %s", ap->a_volname);
654      analyze_automount(ap);
655    }
656  }
657}
658
659
660void
661analyze_automounts(qelem *q)
662{
663  auto_tree *tp;
664
665  show_area_being_processed("analyze automount", 5);
666
667  /*
668   * q is a list of automounts
669   */
670  ITER(tp, auto_tree, q)
671    analyze_automount_tree(tp->t_mount, "", 0);
672}
673