/*
- Bacula® - The Network Backup Solution
-
- Copyright (C) 2004-2007 Free Software Foundation Europe e.V.
-
- The main author of Bacula is Kern Sibbald, with contributions from
- many others, a complete list can be found in the file AUTHORS.
- This program is Free Software; you can redistribute it and/or
- modify it under the terms of version three of the GNU Affero General Public
- License as published by the Free Software Foundation and included
- in the file LICENSE.
-
- 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 Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA.
-
- Bacula® is a registered trademark of Kern Sibbald.
- The licensor of Bacula is the Free Software Foundation Europe
- (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
- Switzerland, email:ftf@fsfeurope.org.
+ Bacula(R) - The Network Backup Solution
+
+ Copyright (C) 2000-2018 Kern Sibbald
+
+ The original author of Bacula is Kern Sibbald, with contributions
+ from many others, a complete list can be found in the file AUTHORS.
+
+ You may use this file and others of this release according to the
+ license defined in the LICENSE file, which includes the Affero General
+ Public License, v3.0 ("AGPLv3") and some additional permissions and
+ terms pursuant to its AGPLv3 Section 7.
+
+ This notice must be preserved when any source code is
+ conveyed and/or propagated.
+
+ Bacula(R) is a registered trademark of Kern Sibbald.
*/
/*
* Implement routines to determine file system types.
*
* Written by Preben 'Peppe' Guldberg, December MMIV
- *
- * Version $Id$
+ * Updated by Kern Sibbald, April MMXV
*/
#include "bacula.h"
#include "find.h"
-
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_SUN_OS
+ #include <sys/mnttab.h>
+#endif
#else /* Set up for testing a stand alone program */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#define SUPPORTEDOSES \
- "HAVE_DARWIN_OS\n" \
- "HAVE_FREEBSD_OS\n" \
- "HAVE_HPUX_OS\n" \
- "HAVE_IRIX_OS\n" \
- "HAVE_LINUX_OS\n" \
- "HAVE_NETBSD_OS\n" \
- "HAVE_OPENBSD_OS\n" \
- "HAVE_SUN_OS\n" \
- "HAVE_OSF1_OS\n" \
- "HAVE_WIN32\n"
-#define false 0
-#define true 1
#define bstrncpy strncpy
-#define bstrcmp(s1, s2) !strcmp(s1, s2)
#define Dmsg0(n,s) fprintf(stderr, s)
#define Dmsg1(n,s,a1) fprintf(stderr, s, a1)
#define Dmsg2(n,s,a1,a2) fprintf(stderr, s, a1, a2)
#endif
+#define is_rootfs(x) bstrcmp("rootfs", x)
+
+#if defined(HAVE_GETMNTINFO) || defined(HAVE_GETMNTENT)
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+struct mtab_item {
+ rblink link;
+ uint64_t dev;
+ char fstype[1];
+};
+
+/* Compare two device types */
+static int compare_mtab_items(void *item1, void *item2)
+{
+ mtab_item *mtab1, *mtab2;
+ mtab1 = (mtab_item *)item1;
+ mtab2 = (mtab_item *)item2;
+ if (mtab1->dev < mtab2->dev) return -1;
+ if (mtab1->dev > mtab2->dev) return 1;
+ return 0;
+}
+
+void add_mtab_item(void *user_ctx, struct stat *st, const char *fstype,
+ const char *mountpoint, const char *mntopts,
+ const char *fsname)
+{
+ rblist *mtab_list = (rblist *)user_ctx;
+ mtab_item *item, *ritem;
+ int len = strlen(fstype) + 1;
+
+ item = (mtab_item *)malloc(sizeof(mtab_item) + len);
+ item->dev = (uint64_t)st->st_dev;
+ bstrncpy(item->fstype, fstype, len);
+ ritem = (mtab_item *)mtab_list->insert((void *)item, compare_mtab_items);
+ if (ritem != item) {
+ /* Item already inserted, so we discard this one */
+ free(item);
+ }
+}
+
+
/*
* These functions should be implemented for each OS
*
- * bool fstype(const char *fname, char *fs, int fslen);
+ * bool fstype(FF_PKT *ff_pkt, char *fs, int fslen);
*/
-#if defined(HAVE_DARWIN_OS) || \
- defined(HAVE_FREEBSD_OS) || \
- defined(HAVE_OPENBSD_OS)
+#if defined(HAVE_DARWIN_OS) \
+ || defined(HAVE_FREEBSD_OS ) \
+ || defined(HAVE_OPENBSD_OS)
#include <sys/param.h>
#include <sys/mount.h>
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
+ char *fname = ff_pkt->fname;
struct statfs st;
-
+
if (statfs(fname, &st) == 0) {
bstrncpy(fs, st.f_fstypename, fslen);
return true;
}
-
Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
return false;
}
-
#elif defined(HAVE_NETBSD_OS)
#include <sys/param.h>
#include <sys/mount.h>
#define statvfs statfs
#endif
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
+ char *fname = ff_pkt->fname;
struct statvfs st;
-
if (statvfs(fname, &st) == 0) {
bstrncpy(fs, st.f_fstypename, fslen);
return true;
}
-
Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
return false;
}
-
-#elif defined(HAVE_HPUX_OS) || \
- defined(HAVE_IRIX_OS)
+#elif defined(HAVE_HPUX_OS) \
+ || defined(HAVE_IRIX_OS)
#include <sys/types.h>
#include <sys/statvfs.h>
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
+ char *fname = ff_pkt->fname;
struct statvfs st;
-
if (statvfs(fname, &st) == 0) {
bstrncpy(fs, st.f_basetype, fslen);
return true;
}
-
Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
return false;
}
-#elif defined(HAVE_LINUX_OS) || \
- defined(HAVE_OSF1_OS)
+#elif defined(HAVE_LINUX_OS)
-#include <sys/stat.h>
-#include "lib/mntent_cache.h"
+#include <sys/vfs.h>
+#include <mntent.h>
-bool fstype(const char *fname, char *fs, int fslen)
+/*
+ * Linux statfs() does not return the filesystem name type. It
+ * only returns a binary fstype, so we must look up the type name
+ * in mtab.
+ */
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
- struct stat st;
- mntent_cache_entry_t *mce;
+ char *fname = ff_pkt->fname;
+ struct statfs st;
+ const char *fstype;
- if (lstat(fname, &st) == 0) {
- if ((mce = find_mntent_mapping(st.st_dev)) != NULL) {
- bstrncpy(fs, mce->fstype, fslen);
+ if (statfs(fname, &st) == 0) {
+ mtab_item *item, search_item;
+ if (*ff_pkt->last_fstypename && ff_pkt->last_fstype == (uint64_t)st.f_type) {
+ bstrncpy(fs, ff_pkt->last_fstypename, fslen);
+ return true;
+ }
+ if (!ff_pkt->mtab_list) {
+ ff_pkt->mtab_list = New(rblist());
+ read_mtab(add_mtab_item, ff_pkt->mtab_list);
+ }
+ search_item.dev = st.f_type;
+ item = (mtab_item *)ff_pkt->mtab_list->search((void *)&search_item, compare_mtab_items);
+ if (item) {
+ ff_pkt->last_fstype = st.f_type;
+ bstrncpy(ff_pkt->last_fstypename, item->fstype, sizeof(ff_pkt->last_fstypename));
+ bstrncpy(fs, ff_pkt->last_fstypename, fslen);
return true;
}
- return false;
- }
+ /*
+ * Values obtained from statfs(2), testing and
+ *
+ * $ grep -r SUPER_MAGIC /usr/include/linux
+ */
+ switch (st.f_type) {
+ /* Known good values */
+ /* ext2, ext3, and ext4 have the same code */
+ case 0xef53: fstype = "ext2"; break; /* EXT2_SUPER_MAGIC */
+ case 0x3153464a: fstype = "jfs"; break; /* JFS_SUPER_MAGIC */
+ case 0x5346544e: fstype = "ntfs"; break; /* NTFS_SB_MAGIC */
+ case 0x9fa0: fstype = "proc"; break; /* PROC_SUPER_MAGIC */
+ case 0x52654973: fstype = "reiserfs"; break; /* REISERFS_SUPER_MAGIC */
+ case 0x58465342: fstype = "xfs"; break; /* XFS_SB_MAGIC */
+ case 0x9fa2: fstype = "usbdevfs"; break; /* USBDEVICE_SUPER_MAGIC */
+ case 0x62656572: fstype = "sysfs"; break; /* SYSFS_MAGIC */
+ case 0x517B: fstype = "smbfs"; break; /* SMB_SUPER_MAGIC */
+ case 0x9660: fstype = "iso9660"; break; /* ISOFS_SUPER_MAGIC */
+ case 0xadf5: fstype = "adfs"; break; /* ADFS_SUPER_MAGIC */
+ case 0xadff: fstype = "affs"; break; /* AFFS_SUPER_MAGIC */
+ case 0x42465331: fstype = "befs"; break; /* BEFS_SUPER_MAGIC */
+ case 0xFF534D42: fstype = "cifs"; break; /* CIFS_MAGIC_NUMBER */
+ case 0x73757245: fstype = "coda"; break; /* CODA_SUPER_MAGIC */
+ case 0x012ff7b7: fstype = "coherent"; break; /* COH_SUPER_MAGIC */
+ case 0x28cd3d45: fstype = "cramfs"; break; /* CRAMFS_MAGIC */
+ case 0x1373: fstype = "devfs"; break; /* DEVFS_SUPER_MAGIC */
+ case 0x414A53: fstype = "efs"; break; /* EFS_SUPER_MAGIC */
+ case 0x137d: fstype = "ext"; break; /* EXT_SUPER_MAGIC */
+ case 0xef51: fstype = "oldext2"; break; /* EXT2_OLD_SUPER_MAGIC */
+ case 0x4244: fstype = "hfs"; break; /* EXT2_OLD_SUPER_MAGIC */
+ case 0xf995e849: fstype = "hpfs"; break; /* HPFS_SUPER_MAGIC */
+ case 0x958458f6: fstype = "hugetlbfs"; break; /* HUGETLBFS_MAGIC */
+ case 0x72b6: fstype = "jffs2"; break; /* JFFS2_SUPER_MAGIC */
+ case 0x2468: fstype = "minix"; break; /* MINIX2_SUPER_MAGIC */
+ case 0x2478: fstype = "minix"; break; /* MINIX2_SUPER_MAGIC2 */
+ case 0x137f: fstype = "minix"; break; /* MINIX_SUPER_MAGIC */
+ case 0x138f: fstype = "minix"; break; /* MINIX_SUPER_MAGIC2 */
+ case 0x4d44: fstype = "msdos"; break; /* MSDOS_SUPER_MAGIC */
+ case 0x564c: fstype = "ncpfs"; break; /* NCP_SUPER_MAGIC */
+ case 0x6969: fstype = "nfs"; break; /* NFS_SUPER_MAGIC */
+ case 0x9fa1: fstype = "openpromfs"; break; /* OPENPROM_SUPER_MAGIC */
+ case 0x002f: fstype = "qnx4"; break; /* QNX4_SUPER_MAGIC */
+ case 0x7275: fstype = "romfs"; break; /* QNX4_SUPER_MAGIC */
+ case 0x012ff7b6: fstype = "sysv2"; break;
+ case 0x012ff7b5: fstype = "sysv4"; break;
+ case 0x01021994: fstype = "tmpfs"; break;
+ case 0x15013346: fstype = "udf"; break;
+ case 0x00011954: fstype = "ufs"; break;
+ case 0xa501FCF5: fstype = "vxfs"; break;
+ case 0x012FF7B4: fstype = "xenix"; break;
+ case 0x012FD16D: fstype = "xiafs"; break;
+ case 0x9123683e: fstype = "btrfs"; break;
+
+#if 0 /* These need confirmation */
+ case 0x6B414653: fstype = "afs"; break; /* AFS_FS_MAGIC */
+ case 0x0187: fstype = "autofs"; break; /* AUTOFS_SUPER_MAGIC */
+ case 0x62646576: fstype = "bdev"; break; /* ??? */
+ case 0x1BADFACE: fstype = "bfs"; break; /* BFS_MAGIC */
+ case 0x42494e4d: fstype = "binfmt_misc"; break; /* ??? */
+ case (('C'<<8)|'N'): fstype = "capifs"; break; /* CAPIFS_SUPER_MAGIC */
+ case 0x1cd1: fstype = "devpts"; break; /* ??? */
+ case 0x03111965: fstype = "eventpollfs"; break; /* EVENTPOLLFS_MAGIC */
+ case 0xBAD1DEA: fstype = "futexfs"; break; /* ??? */
+ case 0xaee71ee7: fstype = "gadgetfs"; break; /* GADGETFS_MAGIC */
+ case 0x00c0ffee: fstype = "hostfs"; break; /* HOSTFS_SUPER_MAGIC */
+ case 0xb00000ee: fstype = "hppfs"; break; /* HPPFS_SUPER_MAGIC */
+ case 0x12061983: fstype = "hwgfs"; break; /* HWGFS_MAGIC */
+ case 0x66726f67: fstype = "ibmasmfs"; break; /* IBMASMFS_MAGIC */
+ case 0x19800202: fstype = "mqueue"; break; /* MQUEUE_MAGIC */
+ case 0x6f70726f: fstype = "oprofilefs"; break; /* OPROFILEFS_MAGIC */
+ case 0xa0b4d889: fstype = "pfmfs"; break; /* PFMFS_MAGIC */
+ case 0x50495045: fstype = "pipfs"; break; /* PIPEFS_MAGIC */
+ case 0x858458f6: fstype = "ramfs"; break; /* RAMFS_MAGIC */
+ case 0x7275: fstype = "romfs"; break; /* ROMFS_MAGIC */
+ case 0x858458f6: fstype = "rootfs"; break; /* RAMFS_MAGIC */
+ case 0x67596969: fstype = "rpc_pipefs"; break; /* RPCAUTH_GSSMAGIC */
+ case 0x534F434B: fstype = "sockfs"; break; /* SOCKFS_MAGIC */
+ case 0x858458f6: fstype = "tmpfs"; break; /* RAMFS_MAGIC */
+ case 0x01021994: fstype = "tmpfs"; break; /* TMPFS_MAGIC */
+#endif
- Dmsg1(50, "lstat() failed for \"%s\"\n", fname);
+ default:
+ Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
+ fname);
+ return false;
+ }
+ ff_pkt->last_fstype = st.f_type;
+ bstrncpy(ff_pkt->last_fstypename, fstype, sizeof(ff_pkt->last_fstypename));
+ bstrncpy(fs, fstype, fslen);
+ return true;
+ }
+ Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
return false;
}
#include <sys/types.h>
#include <sys/stat.h>
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
- struct stat st;
+ /* Solaris has the filesystem type name in the lstat packet */
+ bstrncpy(fs, ff_pkt->statp.st_fstype, fslen);
+ return true;
+}
+
+#elif defined (__digital__) && defined (__unix__) /* Tru64 */
+/* Tru64 */
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <sys/mnttab.h>
- if (lstat(fname, &st) == 0) {
- bstrncpy(fs, st.st_fstype, fslen);
- return true;
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
+{
+ char *fname = ff_pkt->fname;
+ struct statfs st;
+ if (statfs((char *)fname, &st) == 0) {
+ switch (st.f_type) {
+ /* Known good values */
+ case 0xa: bstrncpy(fs, "advfs", fslen); return true; /* Tru64 AdvFS */
+ case 0xe: bstrncpy(fs, "nfs", fslen); return true; /* Tru64 NFS */
+ default:
+ Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
+ fname);
+ return false;
+ }
}
-
- Dmsg1(50, "lstat() failed for \"%s\"\n", fname);
+ Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
return false;
}
+/* Tru64 */
#elif defined (HAVE_WIN32)
/* Windows */
-
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
+ char *fname = ff_pkt->fname;
DWORD componentlength;
DWORD fsflags;
CHAR rootpath[4];
/* We don't want any popups if there isn't any media in the drive */
oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
-
result = GetVolumeInformation(rootpath, NULL, 0, NULL, &componentlength, &fsflags, fs, fslen);
-
SetErrorMode(oldmode);
if (result) {
} else {
Dmsg2(10, "GetVolumeInformation() failed for \"%s\", Error = %d.\n", rootpath, GetLastError());
}
-
return result != 0;
}
-
/* Windows */
#else /* No recognised OS */
-bool fstype(const char *fname, char *fs, int fslen)
+bool fstype(FF_PKT *ff_pkt, char *fs, int fslen)
{
+ char *fname = ff_pkt->fname;
Dmsg0(10, "!!! fstype() not implemented for this OS. !!!\n");
-#ifdef TEST_PROGRAM
- Dmsg1(10, "Please define one of the following when compiling:\n\n%s\n",
- SUPPORTEDOSES);
- exit(EXIT_FAILURE);
-#endif
-
return false;
}
#endif
-/*
- * Compare function build on top of fstype, OS independent.
- *
- * bool fstype_equals(const char *fname, const char *fstypename);
- */
-bool fstype_equals(const char *fname, const char *fstypename)
-{
- char fs_typename[128];
+/* Read mtab entries */
+bool read_mtab(mtab_handler_t *mtab_handler, void *user_ctx)
+{
+#ifdef HAVE_GETMNTENT
+ FILE *mntfp;
+ struct stat st;
+
+#ifdef HAVE_LINUX_OS
+ struct mntent *mnt;
+ P(mutex);
+ if ((mntfp = setmntent("/proc/mounts", "r")) == NULL) {
+ if ((mntfp = setmntent(_PATH_MOUNTED, "r")) == NULL) {
+ V(mutex);
+ return false;
+ }
+ }
+ while ((mnt = getmntent(mntfp)) != NULL) {
+ if (is_rootfs(mnt->mnt_type)) {
+ continue;
+ }
- if (fstype(fname, fs_typename, sizeof(fs_typename))) {
- return bstrcmp(fs_typename, fstypename);
+ if (stat(mnt->mnt_dir, &st) < 0) {
+ continue;
+ }
+ mtab_handler(user_ctx, &st, mnt->mnt_type, mnt->mnt_dir,
+ mnt->mnt_opts, mnt->mnt_fsname);
}
+ endmntent(mntfp);
+ V(mutex);
+#endif
- return false;
-}
+#ifdef HAVE_SUN_OS
+ struct mnttab mnt;
+
+ P(mutex);
+ if ((mntfp = bfopen(MNTTAB, "r")) == NULL) {
+ V(mutex);
+ return false;
+ }
+
+ while (getmntent(mntfp, &mnt) == 0) {
+ if (is_rootfs(mnt.mnt_fstype)) {
+ continue;
+ }
+ if (stat(mnt.mnt_mountp, &st) < 0) {
+ continue;
+ }
+ mtab_handler(user_ctx, &st, mnt.mnt_fstype, mnt.mnt_mountp,
+ mnt.mnt_mntopts, mnt.mnt_special);
+ }
+ fclose(mntfp);
+ V(mutex);
+#endif
+
+#endif /* HAVE_GETMNTENT */
+
+#ifdef HAVE_GETMNTINFO
+ struct stat st;
+#if defined(ST_NOWAIT)
+ int flags = ST_NOWAIT;
+#elif defined(MNT_NOWAIT)
+ int flags = MNT_NOWAIT;
+#else
+ int flags = 0;
+#endif
+#if defined(HAVE_NETBSD_OS)
+ struct statvfs *mntinfo;
+#else
+ struct statfs *mntinfo;
+#endif
+ int nument;
+
+ P(mutex);
+ if ((nument = getmntinfo(&mntinfo, flags)) > 0) {
+ while (nument-- > 0) {
+ if (is_rootfs(mntinfo->f_fstypename)) {
+ continue;
+ }
+ if (stat(mntinfo->f_mntonname, &st) < 0) {
+ continue;
+ }
+ mtab_handler(user_ctx, &st, mntinfo->f_mntfromname,
+ mntinfo->f_mntonname, mntinfo->f_fstypename, NULL);
+ mntinfo++;
+ }
+ }
+ V(mutex);
+#endif /* HAVE_GETMNTINFO */
+ return true;
+}
#ifdef TEST_PROGRAM
int main(int argc, char **argv)
projects / bacula / bacula / blobdiff