d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert commits 6d3e78ad6c and 54256e7954

Browse Source 
Parts of libprocstat like to pretend they're kernel components for the
sake of including mount.h, and including sys/types.h in the _KERNEL
case doesn't fix the build for some reason.  Revert both the
VFS_QUOTACTL() change and the follow-up "fix" for now.
This commit is contained in:
Jason A. Harmening 2021-05-29 17:46:46 -07:00
parent 331a7601c9
commit 271fcf1c28
13 changed files with 53 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
share/man/man9/VFS_QUOTACTL.9
View File

@ -28,7 +28,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd May 29, 2021
.Dd December 17, 2020
.Dt VFS_QUOTACTL 9
.Os
.Sh NAME
@ -39,38 +39,12 @@
.In sys/mount.h
.In sys/vnode.h
.Ft int
.Fn VFS_QUOTACTL "struct mount *mp" "int cmds" "uid_t uid" "void *arg" "bool *mp_busy"
.Fn VFS_QUOTACTL "struct mount *mp" "int cmds" "uid_t uid" "void *arg"
.Sh DESCRIPTION
Implement file system quotas.
.Pp
The
.Fa mp_busy
argument is an input/output parameter.
.Fn VFS_QUOTACTL
must be called with
.Fa mp
marked busy through
.Xr vfs_busy 9
and
.Fa *mp_busy
set to true.
The filesystem implementation of
.Fn VFS_QUOTACTL
may then unbusy
.Fa mp
using
.Xr vfs_unbusy 9
prior to performing quota file I/O.
In this case the implementation must set
.Fa *mp_busy
to false to indicate that the caller must not unbusy
.Fa mp
upon completion of
.Fn VFS_QUOTACTL .
.Pp
See
.Xr quotactl 2
for a description of the remaining arguments.
for a description of the arguments.
.Sh SEE ALSO
.Xr quotactl 2 ,
.Xr vnode 9

15
sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c
View File

@ -102,12 +102,7 @@ SYSCTL_INT(_vfs_zfs_version, OID_AUTO, zpl, CTLFLAG_RD, &zfs_version_zpl, 0,
"ZPL_VERSION");
/* END CSTYLED */
#if __FreeBSD_version >= 1400018
static int zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg,
bool *mp_busy);
#else
static int zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg);
#endif
static int zfs_mount(vfs_t *vfsp);
static int zfs_umount(vfs_t *vfsp, int fflag);
static int zfs_root(vfs_t *vfsp, int flags, vnode_t **vpp);
@ -272,11 +267,7 @@ zfs_getquota(zfsvfs_t *zfsvfs, uid_t id, int isgroup, struct dqblk64 *dqp)
}
static int
#if __FreeBSD_version >= 1400018
zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg, bool *mp_busy)
#else
zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg)
#endif
{
zfsvfs_t *zfsvfs = vfsp->vfs_data;
struct thread *td;
@ -300,10 +291,8 @@ zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg)
break;
default:
error = EINVAL;
#if __FreeBSD_version < 1400018
if (cmd == Q_QUOTAON || cmd == Q_QUOTAOFF)
vfs_unbusy(vfsp);
#endif
goto done;
}
}
@ -362,15 +351,11 @@ zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg)
case Q_QUOTAON:
// As far as I can tell, you can't turn quotas on or off on zfs
error = 0;
#if __FreeBSD_version < 1400018
vfs_unbusy(vfsp);
#endif
break;
case Q_QUOTAOFF:
error = ENOTSUP;
#if __FreeBSD_version < 1400018
vfs_unbusy(vfsp);
#endif
break;
case Q_SETQUOTA:
error = copyin(arg, &dqblk, sizeof (dqblk));

30
sys/fs/nullfs/null_vfsops.c
View File

@ -294,39 +294,13 @@ nullfs_root(mp, flags, vpp)
}
static int
nullfs_quotactl(mp, cmd, uid, arg, mp_busy)
nullfs_quotactl(mp, cmd, uid, arg)
struct mount *mp;
int cmd;
uid_t uid;
void *arg;
bool *mp_busy;
{
struct mount *lowermp;
struct null_mount *mntdata;
int error;
bool unbusy;
mntdata = MOUNTTONULLMOUNT(mp);
lowermp = atomic_load_ptr(&mntdata->nullm_vfs);
KASSERT(*mp_busy == true, ("upper mount not busy"));
/*
* See comment in sys_quotactl() for an explanation of why the
* lower mount needs to be busied by the caller of VFS_QUOTACTL()
* but may be unbusied by the implementation. We must unbusy
* the upper mount for the same reason; otherwise a namei lookup
* issued by the VFS_QUOTACTL() implementation could traverse the
* upper mount and deadlock.
*/
vfs_unbusy(mp);
*mp_busy = false;
unbusy = true;
error = vfs_busy(lowermp, 0);
if (error == 0)
error = VFS_QUOTACTL(lowermp, cmd, uid, arg, &unbusy);
if (unbusy)
vfs_unbusy(lowermp);
return (error);
return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg);
}
static int

3
sys/fs/smbfs/smbfs_vfsops.c
View File

@ -352,12 +352,11 @@ smbfs_root(struct mount *mp, int flags, struct vnode **vpp)
*/
/* ARGSUSED */
static int
smbfs_quotactl(mp, cmd, uid, arg, mp_busy)
smbfs_quotactl(mp, cmd, uid, arg)
struct mount *mp;
int cmd;
uid_t uid;
void *arg;
bool *mp_busy;
{
SMBVDEBUG("return EOPNOTSUPP\n");
return EOPNOTSUPP;

28
sys/fs/unionfs/union_vfsops.c
View File

@ -371,38 +371,16 @@ unionfs_root(struct mount *mp, int flags, struct vnode **vpp)
}
static int
unionfs_quotactl(struct mount *mp, int cmd, uid_t uid, void *arg,
bool *mp_busy)
unionfs_quotactl(struct mount *mp, int cmd, uid_t uid, void *arg)
{
struct mount *uppermp;
struct unionfs_mount *ump;
int error;
bool unbusy;
ump = MOUNTTOUNIONFSMOUNT(mp);
uppermp = atomic_load_ptr(&ump->um_uppervp->v_mount);
KASSERT(*mp_busy == true, ("upper mount not busy"));
/*
* See comment in sys_quotactl() for an explanation of why the
* lower mount needs to be busied by the caller of VFS_QUOTACTL()
* but may be unbusied by the implementation. We must unbusy
* the upper mount for the same reason; otherwise a namei lookup
* issued by the VFS_QUOTACTL() implementation could traverse the
* upper mount and deadlock.
*/
vfs_unbusy(mp);
*mp_busy = false;
unbusy = true;
error = vfs_busy(uppermp, 0);
/*
* Writing is always performed to upper vnode.
*/
if (error == 0)
error = VFS_QUOTACTL(uppermp, cmd, uid, arg, &unbusy);
if (unbusy)
vfs_unbusy(uppermp);
return (error);
return (VFS_QUOTACTL(ump->um_uppervp->v_mount, cmd, uid, arg));
}
static int

4
sys/kern/vfs_default.c
View File

@ -1350,13 +1350,13 @@ vfs_stdstatfs (mp, sbp)
}
int
vfs_stdquotactl (mp, cmds, uid, arg, mp_busy)
vfs_stdquotactl (mp, cmds, uid, arg)
struct mount *mp;
int cmds;
uid_t uid;
void *arg;
bool *mp_busy;
{
return (EOPNOTSUPP);
}

6
sys/kern/vfs_init.c
View File

@ -212,14 +212,12 @@ vfs_cachedroot_sigdefer(struct mount *mp, int flags, struct vnode **vpp)
}
static int
vfs_quotactl_sigdefer(struct mount *mp, int cmd, uid_t uid, void *arg,
bool *mp_busy)
vfs_quotactl_sigdefer(struct mount *mp, int cmd, uid_t uid, void *arg)
{
int prev_stops, rc;
prev_stops = sigdeferstop(SIGDEFERSTOP_SILENT);
rc = (*mp->mnt_vfc->vfc_vfsops_sd->vfs_quotactl)(mp, cmd, uid, arg,
mp_busy);
rc = (*mp->mnt_vfc->vfc_vfsops_sd->vfs_quotactl)(mp, cmd, uid, arg);
sigallowstop(prev_stops);
return (rc);
}

19
sys/kern/vfs_syscalls.c
View File

@ -89,6 +89,8 @@ __FBSDID("$FreeBSD$");
#include <fs/devfs/devfs.h>
#include <ufs/ufs/quota.h>
MALLOC_DEFINE(M_FADVISE, "fadvise", "posix_fadvise(2) information");
static int kern_chflagsat(struct thread *td, int fd, const char *path,
@ -193,7 +195,6 @@ sys_quotactl(struct thread *td, struct quotactl_args *uap)
struct mount *mp;
struct nameidata nd;
int error;
bool mp_busy;
AUDIT_ARG_CMD(uap->cmd);
AUDIT_ARG_UID(uap->uid);
@ -212,21 +213,21 @@ sys_quotactl(struct thread *td, struct quotactl_args *uap)
vfs_rel(mp);
return (error);
}
mp_busy = true;
error = VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg, &mp_busy);
error = VFS_QUOTACTL(mp, uap->cmd, uap->uid, uap->arg);
/*
* Since quota on/off operations typically need to open quota
* files, the implementation may need to unbusy the mount point
* Since quota on operation typically needs to open quota
* file, the Q_QUOTAON handler needs to unbusy the mount point
* before calling into namei. Otherwise, unmount might be
* started between two vfs_busy() invocations (first is ours,
* started between two vfs_busy() invocations (first is our,
* second is from mount point cross-walk code in lookup()),
* causing deadlock.
*
* Avoid unbusying mp if the implementation indicates it has
* already done so.
* Require that Q_QUOTAON handles the vfs_busy() reference on
* its own, always returning with ubusied mount point.
*/
if (mp_busy)
if ((uap->cmd >> SUBCMDSHIFT) != Q_QUOTAON &&
(uap->cmd >> SUBCMDSHIFT) != Q_QUOTAOFF)
vfs_unbusy(mp);
vfs_rel(mp);
return (error);

9
sys/sys/mount.h
View File

@ -43,8 +43,6 @@
#include <sys/tslog.h>
#include <sys/_mutex.h>
#include <sys/_sx.h>
#else
#include <stdbool.h>
#endif
/*
@ -761,8 +759,7 @@ struct mntarg;
typedef int vfs_cmount_t(struct mntarg *ma, void *data, uint64_t flags);
typedef int vfs_unmount_t(struct mount *mp, int mntflags);
typedef int vfs_root_t(struct mount *mp, int flags, struct vnode **vpp);
typedef int vfs_quotactl_t(struct mount *mp, int cmds, uid_t uid, void *arg,
bool *mp_busy);
typedef int vfs_quotactl_t(struct mount *mp, int cmds, uid_t uid, void *arg);
typedef int vfs_statfs_t(struct mount *mp, struct statfs *sbp);
typedef int vfs_sync_t(struct mount *mp, int waitfor);
typedef int vfs_vget_t(struct mount *mp, ino_t ino, int flags,
@ -835,10 +832,10 @@ vfs_statfs_t __vfs_statfs;
_rc = (*(MP)->mnt_op->vfs_cachedroot)(MP, FLAGS, VPP); \
_rc; })
#define VFS_QUOTACTL(MP, C, U, A, MP_BUSY) ({ \
#define VFS_QUOTACTL(MP, C, U, A) ({ \
int _rc; \
\
_rc = (*(MP)->mnt_op->vfs_quotactl)(MP, C, U, A, MP_BUSY); \
_rc = (*(MP)->mnt_op->vfs_quotactl)(MP, C, U, A); \
_rc; })
#define VFS_STATFS(MP, SBP) ({ \

2
sys/sys/param.h
View File

@ -76,7 +76,7 @@
* cannot include sys/param.h and should only be updated here.
*/
#undef __FreeBSD_version
#define __FreeBSD_version 1400018
#define __FreeBSD_version 1400017
/*
* __FreeBSD_kernel__ indicates that this system uses the kernel of FreeBSD,

2
sys/ufs/ufs/quota.h
View File

@ -232,7 +232,7 @@ int getinoquota(struct inode *);
int qsync(struct mount *);
int qsyncvp(struct vnode *);
int quotaoff(struct thread *, struct mount *, int);
int quotaon(struct thread *, struct mount *, int, void *, bool *);
int quotaon(struct thread *, struct mount *, int, void *);
int getquota32(struct thread *, struct mount *, u_long, int, void *);
int setquota32(struct thread *, struct mount *, u_long, int, void *);
int setuse32(struct thread *, struct mount *, u_long, int, void *);

21
sys/ufs/ufs/ufs_quota.c
View File

@ -492,8 +492,7 @@ chkdquot(struct inode *ip)
* Q_QUOTAON - set up a quota file for a particular filesystem.
*/
int
quotaon(struct thread *td, struct mount *mp, int type, void *fname,
bool *mp_busy)
quotaon(struct thread *td, struct mount *mp, int type, void *fname)
{
struct ufsmount *ump;
struct vnode *vp, **vpp;
@ -503,11 +502,15 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
struct nameidata nd;
error = priv_check(td, PRIV_UFS_QUOTAON);
if (error != 0)
if (error != 0) {
vfs_unbusy(mp);
return (error);
}
if ((mp->mnt_flag & MNT_RDONLY) != 0)
if ((mp->mnt_flag & MNT_RDONLY) != 0) {
vfs_unbusy(mp);
return (EROFS);
}
ump = VFSTOUFS(mp);
dq = NODQUOT;
@ -515,9 +518,7 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, fname, td);
flags = FREAD | FWRITE;
vfs_ref(mp);
KASSERT(*mp_busy, ("%s called without busied mount", __func__));
vfs_unbusy(mp);
*mp_busy = false;
error = vn_open(&nd, &flags, 0, NULL);
if (error != 0) {
vfs_rel(mp);
@ -528,9 +529,10 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
error = vfs_busy(mp, MBF_NOWAIT);
vfs_rel(mp);
if (error == 0) {
*mp_busy = true;
if (vp->v_type != VREG)
if (vp->v_type != VREG) {
error = EACCES;
vfs_unbusy(mp);
}
}
if (error != 0) {
VOP_UNLOCK(vp);
@ -543,6 +545,7 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
UFS_UNLOCK(ump);
VOP_UNLOCK(vp);
(void) vn_close(vp, FREAD|FWRITE, td->td_ucred, td);
vfs_unbusy(mp);
return (EALREADY);
}
ump->um_qflags[type] |= QTF_OPENING|QTF_CLOSING;
@ -553,6 +556,7 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
ump->um_qflags[type] &= ~(QTF_OPENING|QTF_CLOSING);
UFS_UNLOCK(ump);
(void) vn_close(vp, FREAD|FWRITE, td->td_ucred, td);
vfs_unbusy(mp);
return (error);
}
VOP_UNLOCK(vp);
@ -636,6 +640,7 @@ quotaon(struct thread *td, struct mount *mp, int type, void *fname,
("quotaon: leaking flags"));
UFS_UNLOCK(ump);
vfs_unbusy(mp);
return (error);
}

19
sys/ufs/ufs/ufs_vfsops.c
View File

@ -87,14 +87,17 @@ ufs_root(mp, flags, vpp)
* Do operations associated with quotas
*/
int
ufs_quotactl(mp, cmds, id, arg, mp_busy)
ufs_quotactl(mp, cmds, id, arg)
struct mount *mp;
int cmds;
uid_t id;
void *arg;
bool *mp_busy;
{
#ifndef QUOTA
if ((cmds >> SUBCMDSHIFT) == Q_QUOTAON ||
(cmds >> SUBCMDSHIFT) == Q_QUOTAOFF)
vfs_unbusy(mp);
return (EOPNOTSUPP);
#else
struct thread *td;
@ -114,23 +117,25 @@ ufs_quotactl(mp, cmds, id, arg, mp_busy)
break;
default:
if (cmd == Q_QUOTAON || cmd == Q_QUOTAOFF)
vfs_unbusy(mp);
return (EINVAL);
}
}
if ((u_int)type >= MAXQUOTAS)
if ((u_int)type >= MAXQUOTAS) {
if (cmd == Q_QUOTAON || cmd == Q_QUOTAOFF)
vfs_unbusy(mp);
return (EINVAL);
}
switch (cmd) {
case Q_QUOTAON:
error = quotaon(td, mp, type, arg, mp_busy);
error = quotaon(td, mp, type, arg);
break;
case Q_QUOTAOFF:
vfs_ref(mp);
KASSERT(*mp_busy,
("%s called without busied mount", __func__));
vfs_unbusy(mp);
*mp_busy = false;
vn_start_write(NULL, &mp, V_WAIT | V_MNTREF);
error = quotaoff(td, mp, type);
vn_finished_write(mp);