support/sys-statvfs.c

   1 /*
   2  * <sys/sendfile.h> wrapper functions.
   3  *
   4  * Authors:
   5  *   Jonathan Pryor (jonpryor@vt.edu)
   6  *
   7  * Copyright (C) 2004-2006 Jonathan Pryor
   8  */
   9
  10 #include <errno.h>
  11
  12 #include <string.h>
  13
  14 #include "mph.h"
  15 #include "map.h"
  16
  17 #ifdef HAVE_PATHCONF_H
  18 #include <pathconf.h>
  19 #endif
  20
  21 #ifdef HAVE_SYS_STATVFS_H
  22 #include <sys/statvfs.h>
  23 #elif defined (HAVE_STATFS) || defined (HAVE_FSTATFS)
  24 #include <sys/vfs.h>
  25 #endif /* def HAVE_SYS_STATVFS_H */
  26
  27 #ifdef HAVE_GETFSSTAT
  28 #ifdef HAVE_SYS_PARAM_H
  29 #include <sys/param.h>
  30 #endif
  31 #include <sys/ucred.h>
  32 #include <sys/mount.h>
  33 #include <unistd.h>     /* for pathconf */
  34 #endif /* def HAVE_GETFSSTAT */
  35
  36 #include "mono/utils/mono-compiler.h"
  37
  38 G_BEGIN_DECLS
  39
  40 #ifdef HAVE_SYS_STATVFS_H
  41 int
  42 Mono_Posix_ToStatvfs (void *_from, struct Mono_Posix_Statvfs *to)
  43 {
  44         struct statvfs *from = _from;
  45
  46         to->f_bsize   = from->f_bsize;
  47         to->f_frsize  = from->f_frsize;
  48         to->f_blocks  = from->f_blocks;
  49         to->f_bfree   = from->f_bfree;
  50         to->f_bavail  = from->f_bavail;
  51         to->f_files   = from->f_files;
  52         to->f_ffree   = from->f_ffree;
  53         to->f_favail  = from->f_favail;
  54         /*
  55          * On AIX with -D_ALL_SOURCE, fsid_t is a struct
  56          * See: github.com/python/cpython/pull/4972
  57          */
  58 #if defined(_AIX) && defined(_ALL_SOURCE)
  59         to->f_fsid    = from->f_fsid.val[0];
  60 #else
  61         to->f_fsid    = from->f_fsid;
  62 #endif
  63         to->f_namemax = from->f_namemax;
  64
  65         if (Mono_Posix_ToMountFlags (from->f_flag, &to->f_flag) != 0)
  66                 return -1;
  67
  68         return 0;
  69 }
  70
  71 int
  72 Mono_Posix_FromStatvfs (struct Mono_Posix_Statvfs *from, void *_to)
  73 {
  74         struct statvfs *to = _to;
  75         guint64 flag;
  76
  77         to->f_bsize   = from->f_bsize;
  78         to->f_frsize  = from->f_frsize;
  79         to->f_blocks  = from->f_blocks;
  80         to->f_bfree   = from->f_bfree;
  81         to->f_bavail  = from->f_bavail;
  82         to->f_files   = from->f_files;
  83         to->f_ffree   = from->f_ffree;
  84         to->f_favail  = from->f_favail;
  85 #if defined(_AIX) && defined(_ALL_SOURCE)
  86         to->f_fsid.val[0] = from->f_fsid;
  87 #else
  88         to->f_fsid    = from->f_fsid;
  89 #endif
  90         to->f_namemax = from->f_namemax;
  91
  92         if (Mono_Posix_FromMountFlags (from->f_flag, &flag) != 0)
  93                 return -1;
  94         to->f_flag = flag;
  95
  96         return 0;
  97 }
  98 #endif /* ndef HAVE_SYS_STATVFS_H */
  99
 100 /*
 101  * System V-compatible definitions
 102  */
 103
 104 #ifdef HAVE_STATVFS
 105 gint32
 106 Mono_Posix_Syscall_statvfs (const char *path, struct Mono_Posix_Statvfs *buf)
 107 {
 108         struct statvfs s;
 109         int r;
 110
 111         if (buf == NULL) {
 112                 errno = EFAULT;
 113                 return -1;
 114         }
 115
 116         if ((r = statvfs (path, &s)) == 0)
 117                 r = Mono_Posix_ToStatvfs (&s, buf);
 118
 119         return r;
 120 }
 121 #endif /* ndef HAVA_STATVFS */
 122
 123 #ifdef HAVE_FSTATVFS
 124 gint32
 125 Mono_Posix_Syscall_fstatvfs (gint32 fd, struct Mono_Posix_Statvfs *buf)
 126 {
 127         struct statvfs s;
 128         int r;
 129
 130         if (buf == NULL) {
 131                 errno = EFAULT;
 132                 return -1;
 133         }
 134
 135         if ((r = fstatvfs (fd, &s)) == 0)
 136                 r = Mono_Posix_ToStatvfs (&s, buf);
 137
 138         return r;
 139 }
 140 #endif /* ndef HAVA_FSTATVFS */
 141
 142 /*
 143  * BSD-compatible definitions.
 144  *
 145  * Linux also provides these, but are deprecated in favor of (f)statvfs.
 146  * Android NDK unified headers define HAVE_FSTATFS but also HAVE_SYS_STATVFS_H
 147  * which makes these duplicates of the functions defined above
 148  */
 149
 150 #if (defined (HAVE_STATFS) || defined (HAVE_FSTATFS)) && !defined (HAVE_STATVFS) && !defined(ANDROID_UNIFIED_HEADERS)
 151 int
 152 Mono_Posix_ToStatvfs (void *_from, struct Mono_Posix_Statvfs *to)
 153 {
 154         struct statfs *from = _from;
 155
 156         to->f_bsize   = from->f_bsize;
 157         to->f_frsize  = from->f_bsize;
 158         to->f_blocks  = from->f_blocks;
 159         to->f_bfree   = from->f_bfree;
 160         to->f_bavail  = from->f_bavail;
 161         to->f_files   = from->f_files;
 162         to->f_ffree   = from->f_ffree;
 163         to->f_favail  = from->f_ffree; /* OSX doesn't have f_avail */
 164
 165         // from->f_fsid is an int32[2], to->f_fsid is a uint64,
 166         // so this shouldn't lose anything.
 167         memcpy (&to->f_fsid, &from->f_fsid, sizeof(to->f_fsid));
 168
 169 #if HAVE_STRUCT_STATFS_F_FLAGS
 170         if (Mono_Posix_ToMountFlags (from->f_flags, &to->f_flag) != 0)
 171                 return -1;
 172 #endif  /* def HAVE_STRUCT_STATFS_F_FLAGS */
 173
 174         return 0;
 175 }
 176
 177 int
 178 Mono_Posix_FromStatvfs (struct Mono_Posix_Statvfs *from, void *_to)
 179 {
 180         struct statfs *to = _to;
 181         guint64 flag;
 182
 183         to->f_bsize   = from->f_bsize;
 184         to->f_blocks  = from->f_blocks;
 185         to->f_bfree   = from->f_bfree;
 186         to->f_bavail  = from->f_bavail;
 187         to->f_files   = from->f_files;
 188         to->f_ffree   = from->f_ffree;
 189
 190         // from->f_fsid is an int32[2], to->f_fsid is a uint64,
 191         // so this shouldn't lose anything.
 192         memcpy (&to->f_fsid, &from->f_fsid, sizeof(to->f_fsid));
 193
 194 #if HAVE_STRUCT_STATFS_F_FLAGS
 195         if (Mono_Posix_FromMountFlags (from->f_flag, &flag) != 0)
 196                 return -1;
 197         to->f_flags = flag;
 198 #endif  /* def HAVE_STRUCT_STATFS_F_FLAGS */
 199
 200         return 0;
 201 }
 202
 203 static void
 204 set_namemax (const char *path, struct Mono_Posix_Statvfs *buf)
 205 {
 206   buf->f_namemax = pathconf (path, _PC_NAME_MAX);
 207 }
 208
 209 static void
 210 set_fnamemax (int fd, struct Mono_Posix_Statvfs *buf)
 211 {
 212   buf->f_namemax = fpathconf (fd, _PC_NAME_MAX);
 213 }
 214 #endif /* (def HAVE_STATFS || def HAVE_FSTATFS) && !def HAVE_STATVFS */
 215
 216 #if !defined (HAVE_STATVFS) && defined (HAVE_STATFS) && (!defined(ANDROID_UNIFIED_HEADERS) || __ANDROID_API__ >= 19)
 217 gint32
 218 Mono_Posix_Syscall_statvfs (const char *path, struct Mono_Posix_Statvfs *buf)
 219 {
 220         struct statfs s;
 221         int r;
 222
 223         if (buf == NULL) {
 224                 errno = EFAULT;
 225                 return -1;
 226         }
 227
 228         if ((r = statfs (path, &s)) == 0 &&
 229                         (r = Mono_Posix_ToStatvfs (&s, buf)) == 0) {
 230                 set_namemax (path, buf);
 231         }
 232
 233         return r;
 234 }
 235 #endif /* !def HAVE_STATVFS && def HAVE_STATFS */
 236
 237 #if !defined (HAVE_STATVFS) && defined (HAVE_STATFS) && (!defined(ANDROID_UNIFIED_HEADERS) || __ANDROID_API__ >= 19)
 238 gint32
 239 Mono_Posix_Syscall_fstatvfs (gint32 fd, struct Mono_Posix_Statvfs *buf)
 240 {
 241         struct statfs s;
 242         int r;
 243
 244         if (buf == NULL) {
 245                 errno = EFAULT;
 246                 return -1;
 247         }
 248
 249         if ((r = fstatfs (fd, &s)) == 0 &&
 250                         (r = Mono_Posix_ToStatvfs (&s, buf)) == 0) {
 251                 set_fnamemax (fd, buf);
 252         }
 253
 254         return r;
 255 }
 256 #endif /* !def HAVE_FSTATVFS && def HAVE_STATFS */
 257
 258 G_END_DECLS
 259
 260 /*
 261  * vim: noexpandtab
 262  */