2 * Implement routines to determine file system types.
4 * Written by Preben 'Peppe' Guldberg, December MMIV
9 Bacula® - The Network Backup Solution
11 Copyright (C) 2004-2006 Free Software Foundation Europe e.V.
13 The main author of Bacula is Kern Sibbald, with contributions from
14 many others, a complete list can be found in the file AUTHORS.
15 This program is Free Software; you can redistribute it and/or
16 modify it under the terms of version two of the GNU General Public
17 License as published by the Free Software Foundation plus additions
18 that are listed in the file LICENSE.
20 This program is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
30 Bacula® is a registered trademark of John Walker.
31 The licensor of Bacula is the Free Software Foundation Europe
32 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
33 Switzerland, email:ftf@fsfeurope.org.
42 #else /* Set up for testing a stand alone program */
47 #define SUPPORTEDOSES \
59 #define bstrncpy strncpy
60 #define Dmsg0(n,s) fprintf(stderr, s)
61 #define Dmsg1(n,s,a1) fprintf(stderr, s, a1)
62 #define Dmsg2(n,s,a1,a2) fprintf(stderr, s, a1, a2)
66 * These functions should be implemented for each OS
68 * bool fstype(const char *fname, char *fs, int fslen);
70 #if defined(HAVE_DARWIN_OS) \
71 || defined(HAVE_FREEBSD_OS ) \
72 || defined(HAVE_OPENBSD_OS)
74 #include <sys/param.h>
75 #include <sys/mount.h>
77 bool fstype(const char *fname, char *fs, int fslen)
80 if (statfs(fname, &st) == 0) {
81 bstrncpy(fs, st.f_fstypename, fslen);
84 Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
87 #elif defined(HAVE_NETBSD_OS)
88 #include <sys/param.h>
89 #include <sys/mount.h>
90 #ifdef HAVE_SYS_STATVFS_H
91 #include <sys/statvfs.h>
93 #define statvfs statfs
96 bool fstype(const char *fname, char *fs, int fslen)
99 if (statvfs(fname, &st) == 0) {
100 bstrncpy(fs, st.f_fstypename, fslen);
103 Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
106 #elif defined(HAVE_HPUX_OS) \
107 || defined(HAVE_IRIX_OS)
109 #include <sys/types.h>
110 #include <sys/statvfs.h>
112 bool fstype(const char *fname, char *fs, int fslen)
115 if (statvfs(fname, &st) == 0) {
116 bstrncpy(fs, st.f_basetype, fslen);
119 Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
123 #elif defined(HAVE_LINUX_OS)
127 bool fstype(const char *fname, char *fs, int fslen)
130 if (statfs(fname, &st) == 0) {
132 * Values nicked from statfs(2), testing and
134 * $ grep -r SUPER_MAGIC /usr/include/linux
136 * Entries are sorted on ("fsname")
140 /* Known good values */
141 case 0xef53: bstrncpy(fs, "ext2", fslen); return true; /* EXT2_SUPER_MAGIC */
142 /* case 0xef53: ext2 and ext3 are the same */ /* EXT3_SUPER_MAGIC */
143 case 0x3153464a: bstrncpy(fs, "jfs", fslen); return true; /* JFS_SUPER_MAGIC */
144 case 0x5346544e: bstrncpy(fs, "ntfs", fslen); return true; /* NTFS_SB_MAGIC */
145 case 0x9fa0: bstrncpy(fs, "proc", fslen); return true; /* PROC_SUPER_MAGIC */
146 case 0x52654973: bstrncpy(fs, "reiserfs", fslen); return true; /* REISERFS_SUPER_MAGIC */
147 case 0x58465342: bstrncpy(fs, "xfs", fslen); return true; /* XFS_SB_MAGIC */
148 case 0x9fa2: bstrncpy(fs, "usbdevfs", fslen); return true; /* USBDEVICE_SUPER_MAGIC */
149 case 0x62656572: bstrncpy(fs, "sysfs", fslen); return true; /* SYSFS_MAGIC */
150 case 0x517B: bstrncpy(fs, "smbfs", fslen); return true; /* SMB_SUPER_MAGIC */
151 case 0x9660: bstrncpy(fs, "iso9660", fslen); return true; /* ISOFS_SUPER_MAGIC */
153 #if 0 /* These need confirmation */
154 case 0xadf5: bstrncpy(fs, "adfs", fslen); return true; /* ADFS_SUPER_MAGIC */
155 case 0xadff: bstrncpy(fs, "affs", fslen); return true; /* AFFS_SUPER_MAGIC */
156 case 0x6B414653: bstrncpy(fs, "afs", fslen); return true; /* AFS_FS_MAGIC */
157 case 0x0187: bstrncpy(fs, "autofs", fslen); return true; /* AUTOFS_SUPER_MAGIC */
158 case 0x62646576: bstrncpy(fs, "bdev", fslen); return true; /* ??? */
159 case 0x42465331: bstrncpy(fs, "befs", fslen); return true; /* BEFS_SUPER_MAGIC */
160 case 0x1BADFACE: bstrncpy(fs, "bfs", fslen); return true; /* BFS_MAGIC */
161 case 0x42494e4d: bstrncpy(fs, "binfmt_misc", fslen); return true; /* ??? */
162 case (('C'<<8)|'N'): bstrncpy(fs, "capifs", fslen); return true; /* CAPIFS_SUPER_MAGIC */
163 case 0xFF534D42: bstrncpy(fs, "cifs", fslen); return true; /* CIFS_MAGIC_NUMBER */
164 case 0x73757245: bstrncpy(fs, "coda", fslen); return true; /* CODA_SUPER_MAGIC */
165 case 0x012ff7b7: bstrncpy(fs, "coherent", fslen); return true; /* COH_SUPER_MAGIC */
166 case 0x28cd3d45: bstrncpy(fs, "cramfs", fslen); return true; /* CRAMFS_MAGIC */
167 case 0x1373: bstrncpy(fs, "devfs", fslen); return true; /* DEVFS_SUPER_MAGIC */
168 case 0x1cd1: bstrncpy(fs, "devpts", fslen); return true; /* ??? */
169 case 0x414A53: bstrncpy(fs, "efs", fslen); return true; /* EFS_SUPER_MAGIC */
170 case 0x03111965: bstrncpy(fs, "eventpollfs", fslen); return true; /* EVENTPOLLFS_MAGIC */
171 case 0x137d: bstrncpy(fs, "ext", fslen); return true; /* EXT_SUPER_MAGIC */
172 case 0xef51: bstrncpy(fs, "ext2", fslen); return true; /* EXT2_OLD_SUPER_MAGIC */
173 case 0xBAD1DEA: bstrncpy(fs, "futexfs", fslen); return true; /* ??? */
174 case 0xaee71ee7: bstrncpy(fs, "gadgetfs", fslen); return true; /* GADGETFS_MAGIC */
175 case 0x00c0ffee: bstrncpy(fs, "hostfs", fslen); return true; /* HOSTFS_SUPER_MAGIC */
176 case 0xf995e849: bstrncpy(fs, "hpfs", fslen); return true; /* HPFS_SUPER_MAGIC */
177 case 0xb00000ee: bstrncpy(fs, "hppfs", fslen); return true; /* HPPFS_SUPER_MAGIC */
178 case 0x958458f6: bstrncpy(fs, "hugetlbfs", fslen); return true; /* HUGETLBFS_MAGIC */
179 case 0x12061983: bstrncpy(fs, "hwgfs", fslen); return true; /* HWGFS_MAGIC */
180 case 0x66726f67: bstrncpy(fs, "ibmasmfs", fslen); return true; /* IBMASMFS_MAGIC */
181 case 0x9660: bstrncpy(fs, "isofs", fslen); return true; /* ISOFS_SUPER_MAGIC */
182 case 0x07c0: bstrncpy(fs, "jffs", fslen); return true; /* JFFS_MAGIC_SB_BITMASK */
183 case 0x72b6: bstrncpy(fs, "jffs2", fslen); return true; /* JFFS2_SUPER_MAGIC */
184 case 0x2468: bstrncpy(fs, "minix", fslen); return true; /* MINIX2_SUPER_MAGIC */
185 case 0x2478: bstrncpy(fs, "minix", fslen); return true; /* MINIX2_SUPER_MAGIC2 */
186 case 0x137f: bstrncpy(fs, "minix", fslen); return true; /* MINIX_SUPER_MAGIC */
187 case 0x138f: bstrncpy(fs, "minix", fslen); return true; /* MINIX_SUPER_MAGIC2 */
188 case 0x19800202: bstrncpy(fs, "mqueue", fslen); return true; /* MQUEUE_MAGIC */
189 case 0x4d44: bstrncpy(fs, "msdos", fslen); return true; /* MSDOS_SUPER_MAGIC */
190 case 0x564c: bstrncpy(fs, "ncpfs", fslen); return true; /* NCP_SUPER_MAGIC */
191 case 0x6969: bstrncpy(fs, "nfs", fslen); return true; /* NFS_SUPER_MAGIC */
192 case 0x9fa1: bstrncpy(fs, "openpromfs", fslen); return true; /* OPENPROM_SUPER_MAGIC */
193 case 0x6f70726f: bstrncpy(fs, "oprofilefs", fslen); return true; /* OPROFILEFS_MAGIC */
194 case 0xa0b4d889: bstrncpy(fs, "pfmfs", fslen); return true; /* PFMFS_MAGIC */
195 case 0x50495045: bstrncpy(fs, "pipfs", fslen); return true; /* PIPEFS_MAGIC */
196 case 0x002f: bstrncpy(fs, "qnx4", fslen); return true; /* QNX4_SUPER_MAGIC */
197 case 0x858458f6: bstrncpy(fs, "ramfs", fslen); return true; /* RAMFS_MAGIC */
198 case 0x7275: bstrncpy(fs, "romfs", fslen); return true; /* ROMFS_MAGIC */
199 case 0x858458f6: bstrncpy(fs, "rootfs", fslen); return true; /* RAMFS_MAGIC */
200 case 0x67596969: bstrncpy(fs, "rpc_pipefs", fslen); return true; /* RPCAUTH_GSSMAGIC */
201 case 0x534F434B: bstrncpy(fs, "sockfs", fslen); return true; /* SOCKFS_MAGIC */
202 case 0x012ff7b6: bstrncpy(fs, "sysv2", fslen); return true; /* SYSV2_SUPER_MAGIC */
203 case 0x012ff7b5: bstrncpy(fs, "sysv4", fslen); return true; /* SYSV4_SUPER_MAGIC */
204 case 0x858458f6: bstrncpy(fs, "tmpfs", fslen); return true; /* RAMFS_MAGIC */
205 case 0x01021994: bstrncpy(fs, "tmpfs", fslen); return true; /* TMPFS_MAGIC */
206 case 0x15013346: bstrncpy(fs, "udf", fslen); return true; /* UDF_SUPER_MAGIC */
207 case 0x00011954: bstrncpy(fs, "ufs", fslen); return true; /* UFS_MAGIC */
208 case 0xa501FCF5: bstrncpy(fs, "vxfs", fslen); return true; /* VXFS_SUPER_MAGIC */
209 case 0x012ff7b4: bstrncpy(fs, "xenix", fslen); return true; /* XENIX_SUPER_MAGIC */
210 case 0x012fd16d: bstrncpy(fs, "xiafs", fslen); return true; /* _XIAFS_SUPER_MAGIC */
214 Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
219 Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
223 #elif defined(HAVE_SUN_OS)
225 #include <sys/types.h>
226 #include <sys/stat.h>
228 bool fstype(const char *fname, char *fs, int fslen)
231 if (lstat(fname, &st) == 0) {
232 bstrncpy(fs, st.st_fstype, fslen);
235 Dmsg1(50, "lstat() failed for \"%s\"\n", fname);
239 #elif defined (__digital__) && defined (__unix__) /* Tru64 */
241 #include <sys/stat.h>
242 #include <sys/mount.h>
244 bool fstype(const char *fname, char *fs, int fslen)
247 if (statfs((char *)fname, &st) == 0) {
249 /* Known good values */
250 case 0xa: bstrncpy(fs, "advfs", fslen); return true; /* Tru64 AdvFS */
251 case 0xe: bstrncpy(fs, "nfs", fslen); return true; /* Tru64 NFS */
253 Dmsg2(10, "Unknown file system type \"0x%x\" for \"%s\".\n", st.f_type,
258 Dmsg1(50, "statfs() failed for \"%s\"\n", fname);
263 #elif defined (HAVE_WIN32)
266 bool fstype(const char *fname, char *fs, int fslen)
268 DWORD componentlength;
274 /* Copy Drive Letter, colon, and backslash to rootpath */
275 bstrncpy(rootpath, fname, sizeof(rootpath));
277 /* We don't want any popups if there isn't any media in the drive */
278 oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
280 result = GetVolumeInformation(rootpath, NULL, 0, NULL, &componentlength, &fsflags, fs, fslen);
282 SetErrorMode(oldmode);
285 /* Windows returns NTFS, FAT, etc. Make it lowercase to be consistent with other OSes */
288 Dmsg2(10, "GetVolumeInformation() failed for \"%s\", Error = %d.\n", rootpath, GetLastError());
295 #else /* No recognised OS */
297 bool fstype(const char *fname, char *fs, int fslen)
299 Dmsg0(10, "!!! fstype() not implemented for this OS. !!!\n");
301 Dmsg1(10, "Please define one of the following when compiling:\n\n%s\n",
311 int main(int argc, char **argv)
318 p = (argc < 1) ? "fstype" : argv[0];
319 printf("usage:\t%s path ...\n"
320 "\t%s prints the file system type and pathname of the paths.\n",
325 if (!fstype(*argv, fs, sizeof(fs))) {
326 status = EXIT_FAILURE;
328 printf("%s\t%s\n", fs, *argv);