1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "pal_config.h"
#include "pal_mount.h"
#include "pal_utilities.h"
#include <assert.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
// Check if we should use getmntinfo or /proc/mounts
#if HAVE_MNTINFO
#include <sys/mount.h>
#else
#include <sys/statfs.h>
#if HAVE_SYS_MNTENT_H
#include <sys/mntent.h>
#include <sys/mnttab.h>
#include <sys/statvfs.h>
#else
#include <mntent.h>
#endif
#define STRING_BUFFER_SIZE 8192
// Android does not define MNTOPT_RO
#ifndef MNTOPT_RO
#define MNTOPT_RO "r"
#endif
#endif
int32_t SystemNative_GetAllMountPoints(MountPointFound onFound)
{
#if HAVE_MNTINFO
// getmntinfo returns pointers to OS-internal structs, so we don't need to worry about free'ing the object
#if defined(HAVE_STATFS)
struct statfs* mounts = NULL;
#else
struct statvfs* mounts = NULL;
#endif
int count = getmntinfo(&mounts, MNT_WAIT);
for (int32_t i = 0; i < count; i++)
{
onFound(mounts[i].f_mntonname);
}
return 0;
}
#elif HAVE_SYS_MNTENT_H
int result = -1;
FILE* fp = fopen("/proc/mounts", MNTOPT_RO);
if (fp != NULL)
{
char buffer[STRING_BUFFER_SIZE] = {0};
struct mnttab entry;
while(getmntent(fp, &entry) == 0)
{
onFound(entry.mnt_mountp);
}
result = fclose(fp);
assert(result == 1); // documented to always return 1
result =
0; // We need to standardize a success return code between our implementations, so settle on 0 for success
}
return result;
}
#else
int result = -1;
FILE* fp = setmntent("/proc/mounts", MNTOPT_RO);
if (fp != NULL)
{
// The _r version of getmntent needs all buffers to be passed in; however, we don't know how big of a string
// buffer we will need, so pick something that seems like it will be big enough.
char buffer[STRING_BUFFER_SIZE] = {0};
struct mntent entry;
while (getmntent_r(fp, &entry, buffer, STRING_BUFFER_SIZE) != NULL)
{
onFound(entry.mnt_dir);
}
result = endmntent(fp);
assert(result == 1); // documented to always return 1
result =
0; // We need to standardize a success return code between our implementations, so settle on 0 for success
}
return result;
}
#endif
int32_t SystemNative_GetSpaceInfoForMountPoint(const char* name, MountPointInformation* mpi)
{
assert(name != NULL);
assert(mpi != NULL);
#if HAVE_NON_LEGACY_STATFS
struct statfs stats;
memset(&stats, 0, sizeof(struct statfs));
int result = statfs(name, &stats);
#else
struct statvfs stats;
memset(&stats, 0, sizeof(struct statvfs));
int result = statvfs(name, &stats);
#endif
if (result == 0)
{
// Note that these have signed integer types on some platforms but mustn't be negative.
// Also, upcast here (some platforms have smaller types) to 64-bit before multiplying to
// avoid overflow.
uint64_t bsize = (uint64_t)(stats.f_bsize);
uint64_t bavail = (uint64_t)(stats.f_bavail);
uint64_t bfree = (uint64_t)(stats.f_bfree);
uint64_t blocks = (uint64_t)(stats.f_blocks);
mpi->AvailableFreeSpace = bsize * bavail;
mpi->TotalFreeSpace = bsize * bfree;
mpi->TotalSize = bsize * blocks;
}
else
{
memset(mpi, 0, sizeof(MountPointInformation));
}
return result;
}
int32_t
SystemNative_GetFormatInfoForMountPoint(const char* name, char* formatNameBuffer, int32_t bufferLength, int64_t* formatType)
{
assert((formatNameBuffer != NULL) && (formatType != NULL));
assert(bufferLength > 0);
#if HAVE_NON_LEGACY_STATFS
struct statfs stats;
int result = statfs(name, &stats);
#else
struct statvfs stats;
int result = statvfs(name, &stats);
#endif
if (result == 0)
{
#if HAVE_STATFS_FSTYPENAME || HAVE_STATVFS_FSTYPENAME
#ifdef VFS_NAMELEN
if (bufferLength < VFS_NAMELEN)
#else
if (bufferLength < MFSNAMELEN)
#endif
{
result = ERANGE;
*formatType = 0;
}
else
{
SafeStringCopy(formatNameBuffer, Int32ToSizeT(bufferLength), stats.f_fstypename);
*formatType = -1;
}
#elif HAVE_NON_LEGACY_STATFS
assert(formatType != NULL);
*formatType = (int64_t)(stats.f_type);
SafeStringCopy(formatNameBuffer, Int32ToSizeT(bufferLength), "");
#else
*formatType = 0;
#endif
}
else
{
*formatType = 0;
}
return result;
}
|
