Initial revision

sysdeps/common/fsusage.c

@@ -0,0 +1,274 @@
+/* fsusage.c -- return space usage of mounted filesystems
+   Copyright (C) 1991, 1992, 1996 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "fsusage.h"
+
+int statfs ();
+
+#if HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#endif
+
+#if HAVE_SYS_MOUNT_H
+# include <sys/mount.h>
+#endif
+
+#if HAVE_SYS_VFS_H
+# include <sys/vfs.h>
+#endif
+
+#if HAVE_SYS_FS_S5PARAM_H	/* Fujitsu UXP/V */
+# include <sys/fs/s5param.h>
+#endif
+
+#if defined (HAVE_SYS_FILSYS_H) && !defined (_CRAY)
+# include <sys/filsys.h>	/* SVR2 */
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SYS_STATFS_H
+# include <sys/statfs.h>
+#endif
+
+#if HAVE_DUSTAT_H		/* AIX PS/2 */
+# include <sys/dustat.h>
+#endif
+
+#if HAVE_SYS_STATVFS_H		/* SVR4 */
+# include <sys/statvfs.h>
+int statvfs ();
+#endif
+
+int safe_read ();
+
+/* Return the number of TOSIZE-byte blocks used by
+   BLOCKS FROMSIZE-byte blocks, rounding away from zero.
+   TOSIZE must be positive.  Return -1 if FROMSIZE is not positive.  */
+
+static long
+adjust_blocks (blocks, fromsize, tosize)
+     long blocks;
+     int fromsize, tosize;
+{
+  if (tosize <= 0)
+    abort ();
+  if (fromsize <= 0)
+    return -1;
+
+  if (fromsize == tosize)	/* e.g., from 512 to 512 */
+    return blocks;
+  else if (fromsize > tosize)	/* e.g., from 2048 to 512 */
+    return blocks * (fromsize / tosize);
+  else				/* e.g., from 256 to 512 */
+    return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
+}
+
+/* Fill in the fields of FSP with information about space usage for
+   the filesystem on which PATH resides.
+   DISK is the device on which PATH is mounted, for space-getting
+   methods that need to know it.
+   Return 0 if successful, -1 if not.  When returning -1, ensure that
+   ERRNO is either a system error value, or zero if DISK is NULL
+   on a system that requires a non-NULL value.  */
+int
+get_fs_usage (path, disk, fsp)
+     const char *path;
+     const char *disk;
+     struct fs_usage *fsp;
+{
+#ifdef STAT_STATFS3_OSF1
+# define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512)
+
+  struct statfs fsd;
+
+  if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
+    return -1;
+
+#endif /* STAT_STATFS3_OSF1 */
+
+#ifdef STAT_STATFS2_FS_DATA	/* Ultrix */
+# define CONVERT_BLOCKS(B) adjust_blocks ((B), 1024, 512)
+
+  struct fs_data fsd;
+
+  if (statfs (path, &fsd) != 1)
+    return -1;
+  fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot);
+  fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree);
+  fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen);
+  fsp->fsu_files = fsd.fd_req.gtot;
+  fsp->fsu_ffree = fsd.fd_req.gfree;
+
+#endif /* STAT_STATFS2_FS_DATA */
+
+#ifdef STAT_READ_FILSYS		/* SVR2 */
+# ifndef SUPERBOFF
+#  define SUPERBOFF (SUPERB * 512)
+# endif
+# define CONVERT_BLOCKS(B) \
+    adjust_blocks ((B), (fsd.s_type == Fs2b ? 1024 : 512), 512)
+
+  struct filsys fsd;
+  int fd;
+
+  if (! disk)
+    {
+      errno = 0;
+      return -1;
+    }
+
+  fd = open (disk, O_RDONLY);
+  if (fd < 0)
+    return -1;
+  lseek (fd, (long) SUPERBOFF, 0);
+  if (safe_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
+    {
+      close (fd);
+      return -1;
+    }
+  close (fd);
+  fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize);
+  fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree);
+  fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree);
+  fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1);
+  fsp->fsu_ffree = fsd.s_tinode;
+
+#endif /* STAT_READ_FILSYS */
+
+#ifdef STAT_STATFS2_BSIZE	/* 4.3BSD, SunOS 4, HP-UX, AIX */
+# define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512)
+
+  struct statfs fsd;
+
+  if (statfs (path, &fsd) < 0)
+    return -1;
+
+# ifdef STATFS_TRUNCATES_BLOCK_COUNTS
+
+  /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
+     struct statfs are truncated to 2GB.  These conditions detect that
+     truncation, presumably without botching the 4.1.1 case, in which
+     the values are not truncated.  The correct counts are stored in
+     undocumented spare fields.  */
+  if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0)
+    {
+      fsd.f_blocks = fsd.f_spare[0];
+      fsd.f_bfree = fsd.f_spare[1];
+      fsd.f_bavail = fsd.f_spare[2];
+    }
+# endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
+
+#endif /* STAT_STATFS2_BSIZE */
+
+#ifdef STAT_STATFS2_FSIZE	/* 4.4BSD */
+# define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512)
+
+  struct statfs fsd;
+
+  if (statfs (path, &fsd) < 0)
+    return -1;
+
+#endif /* STAT_STATFS2_FSIZE */
+
+#ifdef STAT_STATFS4		/* SVR3, Dynix, Irix, AIX */
+# if _AIX || defined(_CRAY)
+#  define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512)
+#  ifdef _CRAY
+#   define f_bavail f_bfree
+#  endif
+# else
+#  define CONVERT_BLOCKS(B) (B)
+#  ifndef _SEQUENT_		/* _SEQUENT_ is DYNIX/ptx */
+#   ifndef DOLPHIN		/* DOLPHIN 3.8.alfa/7.18 has f_bavail */
+#    define f_bavail f_bfree
+#   endif
+#  endif
+# endif
+
+  struct statfs fsd;
+
+  if (statfs (path, &fsd, sizeof fsd, 0) < 0)
+    return -1;
+  /* Empirically, the block counts on most SVR3 and SVR3-derived
+     systems seem to always be in terms of 512-byte blocks,
+     no matter what value f_bsize has.  */
+
+#endif /* STAT_STATFS4 */
+
+#ifdef STAT_STATVFS		/* SVR4 */
+# define CONVERT_BLOCKS(B) \
+    adjust_blocks ((B), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512)
+
+  struct statvfs fsd;
+
+  if (statvfs (path, &fsd) < 0)
+    return -1;
+  /* f_frsize isn't guaranteed to be supported.  */
+
+#endif /* STAT_STATVFS */
+
+#if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS)
+				/* !Ultrix && !SVR2 */
+
+  fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
+  fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
+  fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);
+  fsp->fsu_files = fsd.f_files;
+  fsp->fsu_ffree = fsd.f_ffree;
+
+#endif /* not STAT_STATFS2_FS_DATA && not STAT_READ_FILSYS */
+
+  return 0;
+}
+
+#if defined(_AIX) && defined(_I386)
+/* AIX PS/2 does not supply statfs.  */
+
+int
+statfs (path, fsb)
+     char *path;
+     struct statfs *fsb;
+{
+  struct stat stats;
+  struct dustat fsd;
+
+  if (stat (path, &stats))
+    return -1;
+  if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
+    return -1;
+  fsb->f_type   = 0;
+  fsb->f_bsize  = fsd.du_bsize;
+  fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
+  fsb->f_bfree  = fsd.du_tfree;
+  fsb->f_bavail = fsd.du_tfree;
+  fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
+  fsb->f_ffree  = fsd.du_tinode;
+  fsb->f_fsid.val[0] = fsd.du_site;
+  fsb->f_fsid.val[1] = fsd.du_pckno;
+  return 0;
+}
+
+#endif /* _AIX && _I386 */

sysdeps/common/fsusage.h

@@ -0,0 +1,37 @@
+/* fsusage.h -- declarations for filesystem space usage info
+   Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* Space usage statistics for a filesystem.  Blocks are 512-byte. */
+struct fs_usage
+{
+  long fsu_blocks;		/* Total blocks. */
+  long fsu_bfree;		/* Free blocks available to superuser. */
+  long fsu_bavail;		/* Free blocks available to non-superuser. */
+  long fsu_files;		/* Total file nodes. */
+  long fsu_ffree;		/* Free file nodes. */
+};
+
+#ifndef __P
+#if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif  /* GCC.  */
+#endif  /* Not __P.  */
+
+int get_fs_usage __P ((const char *path, const char *disk,
+		       struct fs_usage *fsp));

sysdeps/common/mountlist.c

@@ -0,0 +1,577 @@
+/* mountlist.c -- return a list of mounted filesystems
+   Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include "mountlist.h"
+
+#ifdef STDC_HEADERS
+#include <stdlib.h>
+#else
+void free ();
+#endif
+#if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+char *strstr ();
+char *xmalloc ();
+char *xrealloc ();
+char *xstrdup ();
+void error ();
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#if defined (MOUNTED_GETFSSTAT)	/* __alpha running OSF_1 */
+#  include <sys/mount.h>
+#  include <sys/fs_types.h>
+#endif /* MOUNTED_GETFSSTAT */
+
+#ifdef MOUNTED_GETMNTENT1	/* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
+#include <mntent.h>
+#if !defined(MOUNTED)
+#  if defined(MNT_MNTTAB)	/* HP-UX.  */
+#    define MOUNTED MNT_MNTTAB
+#  endif
+#  if defined(MNTTABNAME)	/* Dynix.  */
+#    define MOUNTED MNTTABNAME
+#  endif
+#endif
+#endif
+
+#ifdef MOUNTED_GETMNTINFO	/* 4.4BSD.  */
+#include <sys/mount.h>
+#endif
+
+#ifdef MOUNTED_GETMNT		/* Ultrix.  */
+#include <sys/mount.h>
+#include <sys/fs_types.h>
+#endif
+
+#ifdef MOUNTED_FREAD		/* SVR2.  */
+#include <mnttab.h>
+#endif
+
+#ifdef MOUNTED_FREAD_FSTYP	/* SVR3.  */
+#include <mnttab.h>
+#include <sys/fstyp.h>
+#include <sys/statfs.h>
+#endif
+
+#ifdef MOUNTED_LISTMNTENT
+#include <mntent.h>
+#endif
+
+#ifdef MOUNTED_GETMNTENT2	/* SVR4.  */
+#include <sys/mnttab.h>
+#endif
+
+#ifdef MOUNTED_VMOUNT		/* AIX.  */
+#include <fshelp.h>
+#include <sys/vfs.h>
+#endif
+
+#ifdef DOLPHIN
+/* So special that it's not worth putting this in autoconf.  */
+#undef MOUNTED_FREAD_FSTYP
+#define MOUNTED_GETMNTTBL
+#endif
+
+#ifdef MOUNTED_GETMNTENT1	/* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
+/* Return the value of the hexadecimal number represented by CP.
+   No prefix (like '0x') or suffix (like 'h') is expected to be
+   part of CP. */
+
+static int
+xatoi (cp)
+     char *cp;
+{
+  int val;
+
+  val = 0;
+  while (*cp)
+    {
+      if (*cp >= 'a' && *cp <= 'f')
+	val = val * 16 + *cp - 'a' + 10;
+      else if (*cp >= 'A' && *cp <= 'F')
+	val = val * 16 + *cp - 'A' + 10;
+      else if (*cp >= '0' && *cp <= '9')
+	val = val * 16 + *cp - '0';
+      else
+	break;
+      cp++;
+    }
+  return val;
+}
+#endif /* MOUNTED_GETMNTENT1.  */
+
+#if defined (MOUNTED_GETMNTINFO) && !defined (__NetBSD__)
+static char *
+fstype_to_string (t)
+     short t;
+{
+  switch (t)
+    {
+#ifdef MOUNT_PC
+    case MOUNT_PC:
+      return "pc";
+#endif
+#ifdef MOUNT_MFS
+    case MOUNT_MFS:
+      return "mfs";
+#endif
+#ifdef MOUNT_LO
+    case MOUNT_LO:
+      return "lo";
+#endif
+#ifdef MOUNT_TFS
+    case MOUNT_TFS:
+      return "tfs";
+#endif
+#ifdef MOUNT_TMP
+    case MOUNT_TMP:
+      return "tmp";
+#endif
+#ifdef MOUNT_UFS
+   case MOUNT_UFS:
+     return "ufs" ;
+#endif
+#ifdef MOUNT_NFS
+   case MOUNT_NFS:
+     return "nfs" ;
+#endif
+#ifdef MOUNT_MSDOS
+   case MOUNT_MSDOS:
+     return "msdos" ;
+#endif
+#ifdef MOUNT_LFS
+   case MOUNT_LFS:
+     return "lfs" ;
+#endif
+#ifdef MOUNT_LOFS
+   case MOUNT_LOFS:
+     return "lofs" ;
+#endif
+#ifdef MOUNT_FDESC
+   case MOUNT_FDESC:
+     return "fdesc" ;
+#endif
+#ifdef MOUNT_PORTAL
+   case MOUNT_PORTAL:
+     return "portal" ;
+#endif
+#ifdef MOUNT_NULL
+   case MOUNT_NULL:
+     return "null" ;
+#endif
+#ifdef MOUNT_UMAP
+   case MOUNT_UMAP:
+     return "umap" ;
+#endif
+#ifdef MOUNT_KERNFS
+   case MOUNT_KERNFS:
+     return "kernfs" ;
+#endif
+#ifdef MOUNT_PROCFS
+   case MOUNT_PROCFS:
+     return "procfs" ;
+#endif
+#ifdef MOUNT_AFS
+   case MOUNT_AFS:
+     return "afs" ;
+#endif
+#ifdef MOUNT_CD9660
+   case MOUNT_CD9660:
+     return "cd9660" ;
+#endif
+#ifdef MOUNT_UNION
+   case MOUNT_UNION:
+     return "union" ;
+#endif
+#ifdef MOUNT_DEVFS
+   case MOUNT_DEVFS:
+     return "devfs" ;
+#endif
+#ifdef MOUNT_EXT2FS
+   case MOUNT_EXT2FS:
+     return "ext2fs" ;
+#endif
+    default:
+      return "?";
+    }
+}
+#endif /* MOUNTED_GETMNTINFO */
+
+#ifdef MOUNTED_VMOUNT		/* AIX.  */
+static char *
+fstype_to_string (t)
+     int t;
+{
+  struct vfs_ent *e;
+
+  e = getvfsbytype (t);
+  if (!e || !e->vfsent_name)
+    return "none";
+  else
+    return e->vfsent_name;
+}
+#endif /* MOUNTED_VMOUNT */
+
+/* Return a list of the currently mounted filesystems, or NULL on error.
+   Add each entry to the tail of the list so that they stay in order.
+   If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in
+   the returned list are valid.  Otherwise, they might not be.
+   If ALL_FS is zero, do not return entries for filesystems that
+   are automounter (dummy) entries.  */
+
+struct mount_entry *
+read_filesystem_list (need_fs_type, all_fs)
+     int need_fs_type, all_fs;
+{
+  struct mount_entry *mount_list;
+  struct mount_entry *me;
+  struct mount_entry *mtail;
+
+  /* Start the list off with a dummy entry. */
+  me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+  me->me_next = NULL;
+  mount_list = mtail = me;
+
+#ifdef MOUNTED_LISTMNTENT
+  {
+    struct tabmntent *mntlist, *p;
+    struct mntent *mnt;
+    struct mount_entry *me;
+
+    /* the third and fourth arguments could be used to filter mounts,
+       but Crays doesn't seem to have any mounts that we want to
+       remove. Specifically, automount create normal NFS mounts.
+       */
+
+    if(listmntent(&mntlist, KMTAB, NULL, NULL) < 0)
+      return NULL;
+    p = mntlist;
+    while(p){
+      mnt = p->ment;
+      me = (struct mount_entry*) xmalloc(sizeof (struct mount_entry));
+      me->me_devname = xstrdup(mnt->mnt_fsname);
+      me->me_mountdir = xstrdup(mnt->mnt_dir);
+      me->me_type = xstrdup(mnt->mnt_type);
+      me->me_dev = -1;
+      me->me_next = NULL;
+      mtail->me_next = me;
+      mtail = me;
+      p = p->next;
+    }
+    freemntlist(mntlist);
+  }
+#endif
+
+#ifdef MOUNTED_GETMNTENT1	/* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
+  {
+    struct mntent *mnt;
+    char *table = MOUNTED;
+    FILE *fp;
+    char *devopt;
+
+    fp = setmntent (table, "r");
+    if (fp == NULL)
+      return NULL;
+
+    while ((mnt = getmntent (fp)))
+      {
+	if (!all_fs && (!strcmp (mnt->mnt_type, "ignore")
+			|| !strcmp (mnt->mnt_type, "auto")))
+	  continue;
+
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup (mnt->mnt_fsname);
+	me->me_mountdir = xstrdup (mnt->mnt_dir);
+	me->me_type = xstrdup (mnt->mnt_type);
+	devopt = strstr (mnt->mnt_opts, "dev=");
+	if (devopt)
+	  {
+	    if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X'))
+	      me->me_dev = xatoi (devopt + 6);
+	    else
+	      me->me_dev = xatoi (devopt + 4);
+	  }
+	else
+	  me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+
+    if (endmntent (fp) == 0)
+      return NULL;
+  }
+#endif /* MOUNTED_GETMNTENT1. */
+
+#ifdef MOUNTED_GETMNTINFO	/* 4.4BSD.  */
+  {
+    struct statfs *fsp;
+    int entries;
+
+    entries = getmntinfo (&fsp, MNT_NOWAIT);
+    if (entries < 0)
+      return NULL;
+    while (entries-- > 0)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup (fsp->f_mntfromname);
+	me->me_mountdir = xstrdup (fsp->f_mntonname);
+#ifdef __NetBSD__
+	me->me_type = xstrdup (fsp->f_fstypename);
+#else
+	me->me_type = fstype_to_string (fsp->f_type);
+#endif
+	me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+	fsp++;
+      }
+  }
+#endif /* MOUNTED_GETMNTINFO */
+
+#ifdef MOUNTED_GETMNT		/* Ultrix.  */
+  {
+    int offset = 0;
+    int val;
+    struct fs_data fsd;
+
+    while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY,
+			  (char *) 0)) > 0)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup (fsd.fd_req.devname);
+	me->me_mountdir = xstrdup (fsd.fd_req.path);
+	me->me_type = gt_names[fsd.fd_req.fstype];
+	me->me_dev = fsd.fd_req.dev;
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+    if (val < 0)
+      return NULL;
+  }
+#endif /* MOUNTED_GETMNT. */
+
+#if defined (MOUNTED_GETFSSTAT)	/* __alpha running OSF_1 */
+  {
+    int numsys, counter, bufsize;
+    struct statfs *stats;
+
+    numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT);
+    if (numsys < 0)
+      return (NULL);
+
+    bufsize = (1 + numsys) * sizeof (struct statfs);
+    stats = (struct statfs *)xmalloc (bufsize);
+    numsys = getfsstat (stats, bufsize, MNT_WAIT);
+
+    if (numsys < 0)
+      {
+	free (stats);
+	return (NULL);
+      }
+
+    for (counter = 0; counter < numsys; counter++)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup (stats[counter].f_mntfromname);
+	me->me_mountdir = xstrdup (stats[counter].f_mntonname);
+	me->me_type = mnt_names[stats[counter].f_type];
+	me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+
+    free (stats);
+  }
+#endif /* MOUNTED_GETFSSTAT */
+
+#if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP) /* SVR[23].  */
+  {
+    struct mnttab mnt;
+    char *table = "/etc/mnttab";
+    FILE *fp;
+
+    fp = fopen (table, "r");
+    if (fp == NULL)
+      return NULL;
+
+    while (fread (&mnt, sizeof mnt, 1, fp) > 0)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+#ifdef GETFSTYP			/* SVR3.  */
+	me->me_devname = xstrdup (mnt.mt_dev);
+#else
+	me->me_devname = xmalloc (strlen (mnt.mt_dev) + 6);
+	strcpy (me->me_devname, "/dev/");
+	strcpy (me->me_devname + 5, mnt.mt_dev);
+#endif
+	me->me_mountdir = xstrdup (mnt.mt_filsys);
+	me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_type = "";
+#ifdef GETFSTYP			/* SVR3.  */
+	if (need_fs_type)
+	  {
+	    struct statfs fsd;
+	    char typebuf[FSTYPSZ];
+
+	    if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1
+		&& sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1)
+	      me->me_type = xstrdup (typebuf);
+	  }
+#endif
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+
+    if (fclose (fp) == EOF)
+      return NULL;
+  }
+#endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP.  */
+
+#ifdef MOUNTED_GETMNTTBL	/* DolphinOS goes it's own way */
+  {
+    struct mntent **mnttbl=getmnttbl(),**ent;
+    for (ent=mnttbl;*ent;ent++)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup ( (*ent)->mt_resource);
+	me->me_mountdir = xstrdup( (*ent)->mt_directory);
+	me->me_type =  xstrdup ((*ent)->mt_fstype);
+	me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+    endmnttbl();
+  }
+#endif
+
+#ifdef MOUNTED_GETMNTENT2	/* SVR4.  */
+  {
+    struct mnttab mnt;
+    char *table = MNTTAB;
+    FILE *fp;
+    int ret;
+
+    fp = fopen (table, "r");
+    if (fp == NULL)
+      return NULL;
+
+    while ((ret = getmntent (fp, &mnt)) == 0)
+      {
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	me->me_devname = xstrdup (mnt.mnt_special);
+	me->me_mountdir = xstrdup (mnt.mnt_mountp);
+	me->me_type = xstrdup (mnt.mnt_fstype);
+	me->me_dev = (dev_t) -1;	/* Magic; means not known yet. */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+
+    if (ret > 0)
+      return NULL;
+   if (fclose (fp) == EOF)
+      return NULL;
+  }
+#endif /* MOUNTED_GETMNTENT2.  */
+
+#ifdef MOUNTED_VMOUNT		/* AIX.  */
+  {
+    int bufsize;
+    char *entries, *thisent;
+    struct vmount *vmp;
+
+    /* Ask how many bytes to allocate for the mounted filesystem info.  */
+    mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize);
+    entries = xmalloc (bufsize);
+
+    /* Get the list of mounted filesystems.  */
+    mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries);
+
+    for (thisent = entries; thisent < entries + bufsize;
+	 thisent += vmp->vmt_length)
+      {
+	vmp = (struct vmount *) thisent;
+	me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
+	if (vmp->vmt_flags & MNT_REMOTE)
+	  {
+	    char *host, *path;
+
+	    /* Prepend the remote pathname.  */
+	    host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
+	    path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
+	    me->me_devname = xmalloc (strlen (host) + strlen (path) + 2);
+	    strcpy (me->me_devname, host);
+	    strcat (me->me_devname, ":");
+	    strcat (me->me_devname, path);
+	  }
+	else
+	  {
+	    me->me_devname = xstrdup (thisent +
+				      vmp->vmt_data[VMT_OBJECT].vmt_off);
+	  }
+	me->me_mountdir = xstrdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off);
+	me->me_type = xstrdup (fstype_to_string (vmp->vmt_gfstype));
+	me->me_dev = (dev_t) -1; /* vmt_fsid might be the info we want.  */
+	me->me_next = NULL;
+
+	/* Add to the linked list. */
+	mtail->me_next = me;
+	mtail = me;
+      }
+    free (entries);
+  }
+#endif /* MOUNTED_VMOUNT. */
+
+  /* Free the dummy head. */
+  me = mount_list;
+  mount_list = mount_list->me_next;
+  free (me);
+  return mount_list;
+}

sysdeps/common/mountlist.h

@@ -0,0 +1,32 @@
+/* mountlist.h -- declarations for list of mounted filesystems
+   Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* A mount table entry. */
+struct mount_entry
+{
+  char *me_devname;		/* Device node pathname, including "/dev/". */
+  char *me_mountdir;		/* Mount point directory pathname. */
+  char *me_type;		/* "nfs", "4.2", etc. */
+  dev_t me_dev;			/* Device number of me_mountdir. */
+  struct mount_entry *me_next;
+};
+
+#if __STDC__
+struct mount_entry *read_filesystem_list (int need_fs_type, int all_fs);
+#else
+struct mount_entry *read_filesystem_list ();
+#endif