int
VAttachPartitions(void)
{
int errors = 0;
int nmounts;
struct vmount *vmountp;
if ((nmounts = getmount(&vmountp)) <= 0) {
Log("Problems in getting # of mount entries(getmount)\n");
exit(-1);
}
for (; nmounts;
nmounts--, vmountp =
(struct vmount *)((int)vmountp + vmountp->vmt_length)) {
char *part = vmt2dataptr(vmountp, VMT_STUB);
if (vmountp->vmt_flags & (MNT_READONLY | MNT_REMOVABLE | MNT_REMOTE))
continue; /* Ignore any "special" partitions */
#ifdef AFS_AIX42_ENV
#ifndef AFS_NAMEI_ENV
{
struct superblock fs;
/* The Log statements are non-sequiters in the SalvageLog and don't
* even appear in the VolserLog, so restrict them to the FileLog.
*/
if (ReadSuper(&fs, vmt2dataptr(vmountp, VMT_OBJECT)) < 0) {
if (programType == fileServer)
Log("Can't read superblock for %s, ignoring it.\n", part);
continue;
}
if (IsBigFilesFileSystem(&fs)) {
if (programType == fileServer)
Log("%s is a big files filesystem, ignoring it.\n", part);
continue;
}
}
#endif
#endif
/* Skip this Partition? */
if (VIsNeverAttach(part))
continue;
/* If we're going to always attach this partition, do it later. */
if (VIsAlwaysAttach(part, NULL))
continue;
if (VCheckPartition(part, vmt2dataptr(vmountp, VMT_OBJECT), 0) < 0)
errors++;
}
/* Process the always-attach partitions, if any. */
VAttachPartitions2();
return errors;
}
static mntent_t *
mnt_dup(struct vmount *mp)
{
mntent_t *new_mp = ALLOC(mntent_t);
char *ty;
char *fsname = strdup(vmt2dataptr(mp, VMT_OBJECT));
new_mp->mnt_dir = strdup(vmt2dataptr(mp, VMT_STUB));
new_mp->mnt_opts = strdup(vmt2dataptr(mp, VMT_ARGS));
switch (mp->vmt_gfstype) {
case MOUNT_TYPE_UFS:
ty = MNTTAB_TYPE_UFS;
new_mp->mnt_fsname = strdup(fsname);
break;
case MOUNT_TYPE_NFS:
ty = MNTTAB_TYPE_NFS;
new_mp->mnt_fsname = str3cat((char *) 0,
vmt2dataptr(mp, VMT_HOSTNAME), ":",
fsname);
break;
#ifdef HAVE_FS_NFS3
case MOUNT_TYPE_NFS3:
ty = MNTTAB_TYPE_NFS3;
new_mp->mnt_fsname = str3cat((char *) 0,
vmt2dataptr(mp, VMT_HOSTNAME), ":",
fsname);
break;
#endif /* HAVE_FS_NFS3 */
default:
ty = "unknown";
new_mp->mnt_fsname = strdup(fsname);
break;
}
new_mp->mnt_type = strdup(ty);
/* store the VFS ID for uvmount() */
new_mp->mnt_passno = mp->vmt_vfsnumber;
new_mp->mnt_freq = 0;
XFREE(fsname);
return new_mp;
}
static int
set_vmount(psi_mountinfo_t *mounti, const struct vmount *mnt)
{
mounti->mount_type = map_fstype(mnt->vmt_gfstype);
if (mounti->mount_type == NULL)
return -1;
mounti->mount_type_status = PSI_STATUS_OK;
/* XXX Debatable, options should maybe be flags instead of args. */
STRDUP(mounti->mount_options, vmt2dataptr(mnt, VMT_ARGS));
STRDUP(mounti->mount_path, vmt2dataptr(mnt, VMT_STUB));
if (strcmp(vmt2dataptr(mnt, VMT_HOST), "-") != 0)
STRDUP(mounti->filesystem_host, vmt2dataptr(mnt, VMT_HOST));
STRDUP(mounti->filesystem_path, vmt2dataptr(mnt, VMT_OBJECT));
return 0;
}
/*
* Check whether AHAFS is mounted.
* Returns 0 if AHAFS is mounted, or an error code < 0 on failure
*/
static int uv__is_ahafs_mounted(void){
char rawbuf[FILENAME_MAX+1];
int rv, i = 2;
struct vmount *p;
int size_multiplier = 10;
size_t siz = sizeof(struct vmount)*size_multiplier;
struct vmount *vmt;
const char *dev = "/aha";
char *obj, *stub;
p = uv__malloc(siz);
if (p == NULL)
return UV__ERR(errno);
/* Retrieve all mounted filesystems */
rv = mntctl(MCTL_QUERY, siz, (char*)p);
if (rv < 0)
return UV__ERR(errno);
if (rv == 0) {
/* buffer was not large enough, reallocate to correct size */
siz = *(int*)p;
uv__free(p);
p = uv__malloc(siz);
if (p == NULL)
return UV__ERR(errno);
rv = mntctl(MCTL_QUERY, siz, (char*)p);
if (rv < 0)
return UV__ERR(errno);
}
/* Look for dev in filesystems mount info */
for(vmt = p, i = 0; i < rv; i++) {
obj = vmt2dataptr(vmt, VMT_OBJECT); /* device */
stub = vmt2dataptr(vmt, VMT_STUB); /* mount point */
if (EQ(obj, dev) || EQ(uv__rawname(obj, &rawbuf), dev) || EQ(stub, dev)) {
uv__free(p); /* Found a match */
return 0;
}
vmt = (struct vmount *) ((char *) vmt + vmt->vmt_length);
}
/* /aha is required for monitoring filesystem changes */
return -1;
}
int
fixmount_check_mount(char *host, struct in_addr hostaddr, char *path)
{
int ret, i;
char *mntinfo = 0, *cp;
char *short_hostname, *long_hostname, *mount_point;
struct vmount *vp;
/*
* First figure out size of mount table and allocate space for a copy...
* Then get mount table for real.
*/
ret = mntctl(MCTL_QUERY, sizeof(i), (char *) &i);
if (ret == 0) {
mntinfo = xmalloc(i);
ret = mntctl(MCTL_QUERY, i, mntinfo);
}
if (ret <= 0) {
fprintf(stderr, "mntctl: %m");
XFREE(mntinfo);
exit(1);
}
/* iterate over each vmount structure */
for (i = 0, cp = mntinfo; i < ret; i++, cp += vp->vmt_length) {
vp = (struct vmount *) cp;
mount_point = vmt2dataptr(vp, VMT_STUB);
long_hostname = vmt2dataptr(vp, VMT_HOSTNAME);
short_hostname = vmt2dataptr(vp, VMT_HOST);
if (STREQ(path, mount_point) &&
(is_same_host(long_hostname, host, hostaddr) ||
is_same_host(short_hostname, host, hostaddr)))
return 1;
}
return 0;
}
vmountdata(struct vmount * vmtp, char *obj, char *stub, char *host,
char *hostsname, char *info, char *args)
{
struct data {
short vmt_off;
short vmt_size;
} *vdp, *vdprev;
int size;
vdp = (struct data *)vmtp->vmt_data;
vdp->vmt_off = sizeof(struct vmount);
size = ROUNDUP(strlen(obj) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_OBJECT), obj);
vdprev = vdp;
vdp++;
vdp->vmt_off = vdprev->vmt_off + size;
size = ROUNDUP(strlen(stub) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_STUB), stub);
vdprev = vdp;
vdp++;
vdp->vmt_off = vdprev->vmt_off + size;
size = ROUNDUP(strlen(host) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_HOST), host);
vdprev = vdp;
vdp++;
vdp->vmt_off = vdprev->vmt_off + size;
size = ROUNDUP(strlen(hostsname) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_HOSTNAME), hostsname);
vdprev = vdp;
vdp++;
vdp->vmt_off = vdprev->vmt_off + size;
size = ROUNDUP(strlen(info) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_INFO), info);
vdprev = vdp;
vdp++;
vdp->vmt_off = vdprev->vmt_off + size;
size = ROUNDUP(strlen(args) + 1);
vdp->vmt_size = size;
strcpy(vmt2dataptr(vmtp, VMT_ARGS), args);
}
void
netsnmp_fsys_arch_load( void )
{
int ret = 0;
uint size = 0;
struct vmount *aixmnt, *aixcurr;
char *path;
struct statfs stat_buf;
netsnmp_fsys_info *entry;
char tmpbuf[1024];
/*
* Retrieve information about the currently mounted filesystems...
*/
ret = mntctl(MCTL_QUERY, sizeof(uint), &size);
if ( ret != 0 || size<=0 ) {
snmp_log_perror( "initial mntctl failed" );
return;
}
aixmnt = (struct vmount *)malloc( size );
if ( aixmnt == NULL ) {
snmp_log_perror( "cannot allocate memory for mntctl data" );
return;
}
ret = mntctl(MCTL_QUERY, size, aixmnt );
if ( ret <= 0 ) {
free(aixmnt);
snmp_log_perror( "main mntctl failed" );
return;
}
aixcurr = aixmnt;
/*
* ... and insert this into the filesystem container.
*/
for ( aixcurr = aixmnt;
(aixcurr-aixmnt) >= size;
aixcurr = (char*)aixcurr + aixcurr->vmt_length ) {
path = vmt2dataptr( aixcurr, VMT_OBJECT );
entry = netsnmp_fsys_by_path( path, NETSNMP_FS_FIND_CREATE );
if (!entry) {
continue;
}
strncpy( entry->path, path, sizeof( entry->path ));
strncpy( entry->device, vmt2dataptr( aixcurr, VMT_STUB),
sizeof( entry->device ));
entry->type = _fsys_type( aixcurr->vmt_gfstype );
if (!(entry->type & _NETSNMP_FS_TYPE_SKIP_BIT))
entry->flags |= NETSNMP_FS_FLAG_ACTIVE;
if ( _fsys_remote( entry->device, entry->type, vmt2dataptr( aixcurr, VMT_HOST) ))
entry->flags |= NETSNMP_FS_FLAG_REMOTE;
if ( aixcurr->vmt_flags & MNT_READONLY )
entry->flags |= NETSNMP_FS_FLAG_RONLY;
/*
* The root device is presumably bootable.
* Other partitions probably aren't!
*/
if ((entry->path[0] == '/') &&
(entry->path[1] == '\0'))
entry->flags |= NETSNMP_FS_FLAG_BOOTABLE;
/*
* XXX - identify removeable disks
*/
/*
* Optionally skip retrieving statistics for remote mounts
*/
if ( (entry->flags & NETSNMP_FS_FLAG_REMOTE) &&
netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
NETSNMP_DS_AGENT_SKIPNFSINHOSTRESOURCES))
continue;
if ( statfs( entry->path, &stat_buf ) < 0 ) {
snprintf( tmpbuf, sizeof(tmpbuf), "Cannot statfs %s\n", entry->path );
snmp_log_perror( tmpbuf );
continue;
}
entry->units = stat_buf.f_bsize;
entry->size = stat_buf.f_blocks;
entry->used = (stat_buf.f_blocks - stat_buf.f_bfree);
entry->avail = stat_buf.f_bavail;
entry->inums_total = stat_buf.f_files;
entry->inums_avail = stat_buf.f_ffree;
netsnmp_fsys_calculate32(entry);
}
free(aixmnt);
aixmnt = NULL;
aixcurr = NULL;
}
Mnt_t*
mntread(void* handle)
{
register Handle_t* mp = (Handle_t*)handle;
register char* s;
register char* t;
register char* o;
if (mp->count > 0)
{
if (vmt2datasize(mp->next, VMT_HOST) && (s = vmt2dataptr(mp->next, VMT_HOST)) && !streq(s, "-"))
{
sfsprintf(mp->remote, sizeof(mp->remote) - 1, "%s:%s", s, vmt2dataptr(mp->next, VMT_OBJECT));
s = mp->remote;
}
else
s = vmt2dataptr(mp->next, VMT_OBJECT);
if (vmt2datasize(mp->next, VMT_ARGS))
o = vmt2dataptr(mp->next, VMT_ARGS);
else
o = NiL;
switch (mp->next->vmt_gfstype)
{
#ifdef MNT_AIX
case MNT_AIX:
t = "aix";
break;
#endif
#ifdef MNT_NFS
case MNT_NFS:
t = "nfs";
break;
#endif
#ifdef MNT_JFS
case MNT_JFS:
t = "jfs";
break;
#endif
#ifdef MNT_CDROM
case MNT_CDROM:
t = "cdrom";
break;
#endif
#ifdef MNT_SFS
case MNT_SFS:
t = "sfs";
break;
#endif
#ifdef MNT_CACHEFS
case MNT_CACHEFS:
t = "cachefs";
break;
#endif
#ifdef MNT_NFS3
case MNT_NFS3:
t = "nfs3";
break;
#endif
#ifdef MNT_AUTOFS
case MNT_AUTOFS:
t = "autofs";
break;
#endif
default:
sfsprintf(t = mp->type, sizeof(mp->type), "aix%+d", mp->next->vmt_gfstype);
break;
}
set(&mp->hdr, s, vmt2dataptr(mp->next, VMT_STUB), t, o);
if (--mp->count > 0)
mp->next = (struct vmount*)((char*)mp->next + mp->next->vmt_length);
return &mp->hdr.mnt;
}
return 0;
}
/* ensure that we don't have a "/" instead of a "/dev/rxd0a" type of device.
* returns pointer to static storage; copy it out quickly!
*/
char *
vol_DevName(dev_t adev, char *wpath)
{
static char pbuffer[128];
char pbuf[128], *ptr;
#ifdef AFS_SUN5_ENV
struct mnttab mnt;
FILE *mntfile;
#else
#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX22_ENV)
struct mntent *mntent;
FILE *mfd;
#else
struct fstab *fsent;
#endif
#endif
#ifdef AFS_AIX_ENV
int nmounts;
struct vmount *vmountp;
#endif
#ifdef AFS_AIX_ENV
if ((nmounts = getmount(&vmountp)) <= 0) {
return NULL;
}
for (; nmounts;
nmounts--, vmountp =
(struct vmount *)((int)vmountp + vmountp->vmt_length)) {
char *part = vmt2dataptr(vmountp, VMT_STUB);
#else
#ifdef AFS_SUN5_ENV
if (!(mntfile = fopen(MNTTAB, "r"))) {
return NULL;
}
while (!getmntent(mntfile, &mnt)) {
char *part = mnt.mnt_mountp;
#else
#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX22_ENV)
#ifdef AFS_LINUX22_ENV
if ((mfd = setmntent("/proc/mounts", "r")) == NULL) {
if ((mfd = setmntent("/etc/mtab", "r")) == NULL) {
return NULL;
}
}
#else
if ((mfd = setmntent(MOUNTED /*MNTTAB*/, "r")) == NULL) {
return NULL;
}
#endif
while ((mntent = getmntent(mfd))) {
char *part = mntent->mnt_dir;
#else
setfsent();
while ((fsent = getfsent())) {
char *part = fsent->fs_file;
#endif
#endif /* AFS_SGI_ENV */
#endif
struct stat status;
#ifdef AFS_AIX_ENV
if (vmountp->vmt_flags & (MNT_READONLY | MNT_REMOVABLE | MNT_REMOTE))
continue; /* Ignore any "special" partitions */
#else
#ifdef AFS_SUN5_ENV
/* Ignore non ufs or non read/write partitions */
if ((strcmp(mnt.mnt_fstype, "ufs") != 0)
|| (strncmp(mnt.mnt_mntopts, "ro,ignore", 9) == 0))
continue;
#else
#if defined(AFS_LINUX22_ENV)
if (strcmp(mntent->mnt_type, "ext2"))
continue;
#else
#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV)
if (!hasmntopt(mntent, MNTOPT_RW))
continue;
#else
if (strcmp(fsent->fs_type, "rw") != 0)
continue; /* Ignore non read/write partitions */
#endif /* AFS_LINUX22_ENV */
#endif /* AFS_SGI_ENV */
#endif
#endif
/* Only keep track of "/vicepx" partitions since it can get hairy when NFS mounts are involved.. */
if (strncmp(part, VICE_PARTITION_PREFIX, VICE_PREFIX_SIZE)) {
continue; /* Non /vicepx; ignore */
}
if (stat(part, &status) == -1) {
continue;
}
#if !defined(AFS_SGI_XFS_IOPS_ENV) && !defined(AFS_LINUX22_ENV) && !defined(AFS_DARWIN_ENV)
if ((status.st_ino !=
ROOTINO) /*|| ((status.st_mode & S_IFMT) != S_IFBLK) */ ) {
continue;
}
#endif
if (status.st_dev == adev) {
#ifdef AFS_AIX_ENV
strcpy(pbuffer, vmt2dataptr(vmountp, VMT_OBJECT));
#else
#ifdef AFS_SUN5_ENV
strcpy(pbuffer, mnt.mnt_special);
#else
#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX22_ENV)
strcpy(pbuffer, mntent->mnt_fsname);
#else
strcpy(pbuffer, fsent->fs_spec);
#endif
#endif /* AFS_SGI_ENV */
#endif
if (wpath) {
strcpy(pbuf, pbuffer);
ptr = (char *)strrchr(pbuf, OS_DIRSEPC);
if (ptr) {
*ptr = '\0';
strcpy(wpath, pbuf);
} else
return NULL;
}
ptr = (char *)strrchr(pbuffer, OS_DIRSEPC);
if (ptr) {
strcpy(pbuffer, ptr + 1);
return pbuffer;
} else
return NULL;
}
}
#ifdef AFS_SUN5_ENV
(void)fclose(mntfile);
#else
#if defined(AFS_SGI_ENV) || defined(AFS_SUN_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_LINUX22_ENV)
endmntent(mfd);
#else
#ifndef AFS_AIX_ENV
endfsent();
#endif
#endif
#endif /* AFS_SGI_ENV */
return NULL;
}
/* Search for the raw device name. Will put an "r" in front of each
* directory and file entry of the pathname until we find a character
* device.
*/
char *
afs_rawname(char *devfile)
{
static char rawname[100];
struct stat statbuf;
int code, i;
i = strlen(devfile);
while (i >= 0) {
strcpy(rawname, devfile);
if (devfile[i] == OS_DIRSEPC) {
rawname[i + 1] = 'r';
rawname[i + 2] = 0;
strcat(rawname, &devfile[i + 1]);
}
code = stat(rawname, &statbuf);
if (!code && S_ISCHR(statbuf.st_mode))
return rawname;
while ((--i >= 0) && (devfile[i] != OS_DIRSEPC));
}
return NULL;
}
KMountPoint::List KMountPoint::currentMountPoints(int infoNeeded)
{
KMountPoint::List result;
#ifdef HAVE_GETMNTINFO
#ifdef GETMNTINFO_USES_STATVFS
struct statvfs *mounted;
#else
struct statfs *mounted;
#endif
int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
for (int i=0;i<num_fs;i++)
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mounted[i].f_mntfromname);
mp->m_mountPoint = TQFile::decodeName(mounted[i].f_mntonname);
#ifdef __osf__
mp->m_mountType = TQFile::decodeName(mnt_names[mounted[i].f_type]);
#else
mp->m_mountType = TQFile::decodeName(mounted[i].f_fstypename);
#endif
if (infoNeeded & NeedMountOptions)
{
struct fstab *ft = getfsfile(mounted[i].f_mntonname);
TQString options = TQFile::decodeName(ft->fs_mntops);
mp->m_mountOptions = TQStringList::split(',', options);
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
#elif defined(_AIX)
struct vmount *mntctl_buffer;
struct vmount *vm;
char *mountedfrom;
char *mountedto;
int fsname_len, num;
int buf_sz = 4096;
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
if (num == 0)
{
buf_sz = *(int*)mntctl_buffer;
free(mntctl_buffer);
mntctl_buffer = (struct vmount*)malloc(buf_sz);
num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
}
if (num > 0)
{
/* iterate through items in the vmount structure: */
vm = (struct vmount *)mntctl_buffer;
for ( ; num > 0; num-- )
{
/* get the name of the mounted file systems: */
fsname_len = vmt2datasize(vm, VMT_STUB);
mountedto = (char*)malloc(fsname_len + 1);
mountedto[fsname_len] = '\0';
strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
fsname_len = vmt2datasize(vm, VMT_OBJECT);
mountedfrom = (char*)malloc(fsname_len + 1);
mountedfrom[fsname_len] = '\0';
strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
/* Look up the string for the file system type,
* as listed in /etc/vfs.
* ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs
*/
struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(mountedfrom);
mp->m_mountPoint = TQFile::decodeName(mountedto);
mp->m_mountType = TQFile::decodeName(ent->vfsent_name);
free(mountedfrom);
free(mountedto);
if (infoNeeded & NeedMountOptions)
{
// TODO
}
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
result.append(mp);
/* goto the next vmount structure: */
vm = (struct vmount *)((char *)vm + vm->vmt_length);
}
endvfsent( );
}
free( mntctl_buffer );
#elif defined(Q_WS_WIN)
//TODO?
#else
STRUCT_SETMNTENT mnttab;
if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0)
return result;
STRUCT_MNTENT fe;
while (GETMNTENT(mnttab, fe))
{
KMountPoint *mp = new KMountPoint();
mp->m_mountedFrom = TQFile::decodeName(FSNAME(fe));
mp->m_mountPoint = TQFile::decodeName(MOUNTPOINT(fe));
mp->m_mountType = TQFile::decodeName(MOUNTTYPE(fe));
//Devices using supermount have their device names in the mount options
//instead of the device field. That's why we need to read the mount options
if (infoNeeded & NeedMountOptions || (mp->m_mountType == "supermount"))
{
TQString options = TQFile::decodeName(MOUNTOPTIONS(fe));
mp->m_mountOptions = TQStringList::split(',', options);
}
if (mp->m_mountType == "supermount")
mp->m_mountedFrom = devNameFromOptions(mp->m_mountOptions);
if (infoNeeded & NeedRealDeviceName)
{
if (mp->m_mountedFrom.startsWith("/"))
mp->m_device = TDEStandardDirs::realPath(mp->m_mountedFrom);
}
// TODO: Strip trailing '/' ?
result.append(mp);
}
ENDMNTENT(mnttab);
#endif
return result;
}
psi_mountlist_t *
psi_arch_mountlist(const int remote)
{
psi_mountlist_t *ml;
psi_mountinfo_t *mounti;
struct vmount *mnt;
char *vmounts;
int vmounts_size = sizeof(struct vmount);
int nmounts;
int offset = 0;
int i;
vmounts = psi_malloc(vmounts_size);
if (vmounts == NULL)
return NULL;
nmounts = mntctl(MCTL_QUERY, vmounts_size, vmounts);
if (nmounts == 0) {
mnt = (struct vmount *)vmounts;
vmounts_size = mnt->vmt_revision;
psi_free(vmounts);
vmounts = psi_malloc(vmounts_size);
if (vmounts == NULL)
return NULL;
nmounts = mntctl(MCTL_QUERY, vmounts_size, vmounts);
}
if (nmounts == -1) {
psi_free(vmounts);
PyErr_SetFromErrno(PyExc_OSError);
return NULL;
} else if (nmounts == 0) {
psi_free(vmounts);
PyErr_SetString(PyExc_OSError, "Internal race condition");
return NULL;
}
ml = (psi_mountlist_t *)psi_calloc(sizeof(psi_mountlist_t));
if (ml == NULL) {
psi_free(vmounts);
return NULL;
}
ml->mounts = (psi_mountinfo_t **)psi_calloc(
nmounts*sizeof(psi_mountinfo_t *));
if (ml->mounts == NULL) {
psi_free(vmounts);
psi_free(ml);
return NULL;
}
ml->count = 0;
for (i = 0; i < nmounts; i++) {
mnt = (struct vmount *)(vmounts + offset);
if (!remote && strcmp(vmt2dataptr(mnt, VMT_HOST), "-") != 0)
continue;
mounti = psi_calloc(sizeof(psi_mountinfo_t));
ml->mounts[ml->count] = mounti;
ml->count += 1;
if (set_vmount(mounti, mnt) < 0) {
psi_free(vmounts);
psi_free_mountlist(ml);
return NULL;
}
if (posix_set_vfs(mounti) < 0) {
psi_free(vmounts);
psi_free_mountlist(ml);
return NULL;
}
}
return ml;
}
