blob: 46a5ff39e2eb72981fca6533822d77a351e8bc38 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*/
#include <mntent.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/sysinfo.h>
#include "platform_defs.h"
#include "xfs.h"
#include "init.h"
#include "libfrog/platform.h"
extern char *progname;
static int max_block_alignment;
#ifndef BLKGETSIZE64
# define BLKGETSIZE64 _IOR(0x12,114,size_t)
#endif
#ifndef BLKBSZSET
# define BLKBSZSET _IOW(0x12,113,size_t)
#endif
#ifndef BLKSSZGET
# define BLKSSZGET _IO(0x12,104)
#endif
#ifndef RAMDISK_MAJOR
#define RAMDISK_MAJOR 1 /* ramdisk major number */
#endif
#define PROC_MOUNTED "/proc/mounts"
/*
* Check if the filesystem is mounted. Be verbose if asked, and
* optionally restrict check to /writable/ mounts (i.e. RO is OK)
*/
#define CHECK_MOUNT_VERBOSE 0x1
#define CHECK_MOUNT_WRITABLE 0x2
static int
platform_check_mount(char *name, char *block, struct stat *s, int flags)
{
FILE *f;
struct stat st, mst;
struct mntent *mnt;
char mounts[MAXPATHLEN];
if (!s) {
/* If either fails we are not mounted */
if (stat(block, &st) < 0)
return 0;
if ((st.st_mode & S_IFMT) != S_IFBLK)
return 0;
s = &st;
}
strcpy(mounts, (!access(PROC_MOUNTED, R_OK)) ? PROC_MOUNTED : MOUNTED);
if ((f = setmntent(mounts, "r")) == NULL) {
/* Unexpected failure, warn unconditionally */
fprintf(stderr,
_("%s: %s possibly contains a mounted filesystem\n"),
progname, name);
return 1;
}
/*
* This whole business is to work out if our block device is mounted
* after we lost ustat(2), see:
* 4e7a824 libxfs/linux.c: Replace use of ustat by stat
* We don't really want to stat every single mounted directory,
* as that may include tmpfs, cgroups, procfs or - worst - hung nfs
* servers. So first, a simple check: does the "dev" start with "/" ?
*/
while ((mnt = getmntent(f)) != NULL) {
if (!strcmp(mnt->mnt_type, "autofs"))
continue;
if (mnt->mnt_fsname[0] != '/')
continue;
if (stat(mnt->mnt_dir, &mst) < 0)
continue;
if (mst.st_dev != s->st_rdev)
continue;
/* Found our device, is RO OK? */
if ((flags & CHECK_MOUNT_WRITABLE) && hasmntopt(mnt, MNTOPT_RO))
continue;
else
break;
}
endmntent(f);
/* No mounts contained the condition we were looking for */
if (mnt == NULL)
return 0;
if (flags & CHECK_MOUNT_VERBOSE) {
if (flags & CHECK_MOUNT_WRITABLE) {
fprintf(stderr,
_("%s: %s contains a mounted and writable filesystem\n"),
progname, name);
} else {
fprintf(stderr,
_("%s: %s contains a mounted filesystem\n"),
progname, name);
}
}
return 1;
}
int
platform_check_ismounted(char *name, char *block, struct stat *s, int verbose)
{
int flags;
flags = verbose ? CHECK_MOUNT_VERBOSE : 0;
return platform_check_mount(name, block, s, flags);
}
int
platform_check_iswritable(char *name, char *block, struct stat *s)
{
int flags;
/* Writable checks are always verbose */
flags = CHECK_MOUNT_WRITABLE | CHECK_MOUNT_VERBOSE;
return platform_check_mount(name, block, s, flags);
}
void
platform_set_blocksize(int fd, char *path, dev_t device, int blocksize,
bool fatal)
{
int error;
if (major(device) == RAMDISK_MAJOR)
return;
error = ioctl(fd, BLKBSZSET, &blocksize);
if (error < 0) {
fprintf(stderr, _("%s: %s - cannot set blocksize "
"%d on block device %s: %s\n"),
progname, fatal ? "error": "warning",
blocksize, path, strerror(errno));
if (fatal)
exit(1);
}
}
/*
* Flush dirty pagecache and disk write cache to stable media. Returns 0 for
* success or -1 (with errno set) for failure.
*/
int
platform_flush_device(
int fd,
dev_t device)
{
struct stat st;
int ret;
if (major(device) == RAMDISK_MAJOR)
return 0;
ret = fsync(fd);
if (ret)
return ret;
ret = fstat(fd, &st);
if (ret)
return ret;
if (S_ISBLK(st.st_mode))
return ioctl(fd, BLKFLSBUF, 0);
return 0;
}
void
platform_findsizes(char *path, int fd, long long *sz, int *bsz)
{
struct stat st;
uint64_t size;
int error;
if (fstat(fd, &st) < 0) {
fprintf(stderr, _("%s: "
"cannot stat the device file \"%s\": %s\n"),
progname, path, strerror(errno));
exit(1);
}
if ((st.st_mode & S_IFMT) == S_IFREG) {
struct dioattr da;
*sz = (long long)(st.st_size >> 9);
if (ioctl(fd, XFS_IOC_DIOINFO, &da) < 0) {
/*
* fall back to BBSIZE; mkfs might fail if there's a
* size mismatch between the image & the host fs...
*/
*bsz = BBSIZE;
} else
*bsz = da.d_miniosz;
if (*bsz > max_block_alignment)
max_block_alignment = *bsz;
return;
}
error = ioctl(fd, BLKGETSIZE64, &size);
if (error >= 0) {
/* BLKGETSIZE64 returns size in bytes not 512-byte blocks */
*sz = (long long)(size >> 9);
} else {
/* If BLKGETSIZE64 fails, try BLKGETSIZE */
unsigned long tmpsize;
error = ioctl(fd, BLKGETSIZE, &tmpsize);
if (error < 0) {
fprintf(stderr, _("%s: can't determine device size\n"),
progname);
exit(1);
}
*sz = (long long)tmpsize;
}
if (ioctl(fd, BLKSSZGET, bsz) < 0) {
fprintf(stderr, _("%s: warning - cannot get sector size "
"from block device %s: %s\n"),
progname, path, strerror(errno));
*bsz = BBSIZE;
}
if (*bsz > max_block_alignment)
max_block_alignment = *bsz;
}
int
platform_direct_blockdev(void)
{
return 1;
}
int
platform_align_blockdev(void)
{
if (!max_block_alignment)
return getpagesize();
return max_block_alignment;
}
/* How many CPUs are online? */
int
platform_nproc(void)
{
long nproc = sysconf(_SC_NPROCESSORS_ONLN);
if (nproc < 1)
return 1;
if (nproc >= INT_MAX)
return INT_MAX;
return nproc;
}
unsigned long
platform_physmem(void)
{
struct sysinfo si;
if (sysinfo(&si) < 0) {
fprintf(stderr, _("%s: can't determine memory size\n"),
progname);
exit(1);
}
return (si.totalram >> 10) * si.mem_unit; /* kilobytes */
}