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

Move checking against RLIMIT_FSIZE into one place, vn_rlimit_fsize().

Browse Source 
Reviewed by:	kib
This commit is contained in:
Edward Tomasz Napierala 2010-05-05 16:44:25 +00:00
parent 213c077f62
commit b5f770bd86
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=207662
12 changed files with 42 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
sys/fs/ext2fs/ext2_readwrite.c
View File

@ -168,7 +168,6 @@ WRITE(ap)
struct inode *ip;
FS *fs;
struct buf *bp;
struct thread *td;
daddr_t lbn;
off_t osize;
int blkoffset, error, flags, ioflag, resid, size, seqcount, xfersize;
@ -213,17 +212,8 @@ WRITE(ap)
* Maybe this should be above the vnode op call, but so long as
* file servers have no limits, I don't think it matters.
*/
td = uio->uio_td;
if (vp->v_type == VREG && td != NULL) {
PROC_LOCK(td->td_proc);
if (uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uio, uio->uio_td))
return (EFBIG);
resid = uio->uio_resid;
osize = ip->i_size;

3
sys/fs/ext2fs/ext2_vnops.c
View File

@ -46,7 +46,6 @@
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h>
#include <sys/kernel.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
@ -54,7 +53,6 @@
#include <sys/buf.h>
#include <sys/endian.h>
#include <sys/priv.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/unistd.h>
#include <sys/time.h>
@ -71,7 +69,6 @@
#include <fs/fifofs/fifo.h>
#include <sys/signalvar.h>
#include <ufs/ufs/dir.h>
#include <fs/ext2fs/inode.h>

15
sys/fs/msdosfs/msdosfs_vnops.c
View File

@ -61,9 +61,6 @@
#include <sys/mutex.h>
#include <sys/namei.h>
#include <sys/priv.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
@ -699,16 +696,8 @@ msdosfs_write(ap)
/*
* If they've exceeded their filesize limit, tell them about it.
*/
if (td != NULL) {
PROC_LOCK(td->td_proc);
if ((uoff_t)uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uio, td))
return (EFBIG);
/*
* If the offset we are starting the write at is beyond the end of

16
sys/fs/nfsclient/nfs_clbio.c
View File

@ -41,9 +41,6 @@ __FBSDID("$FreeBSD$");
#include <sys/buf.h>
#include <sys/kernel.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
#include <sys/vmmeter.h>
#include <sys/vnode.h>
@ -880,7 +877,6 @@ ncl_write(struct vop_write_args *ap)
daddr_t lbn;
int bcount;
int n, on, error = 0;
struct proc *p = td?td->td_proc:NULL;
#ifdef DIAGNOSTIC
if (uio->uio_rw != UIO_WRITE)
@ -962,16 +958,8 @@ ncl_write(struct vop_write_args *ap)
* Maybe this should be above the vnode op call, but so long as
* file servers have no limits, i don't think it matters
*/
if (p != NULL) {
PROC_LOCK(p);
if (uio->uio_offset + uio->uio_resid >
lim_cur(p, RLIMIT_FSIZE)) {
psignal(p, SIGXFSZ);
PROC_UNLOCK(p);
return (EFBIG);
}
PROC_UNLOCK(p);
}
if (vn_rlimit_fsize(vp, uio, td))
return (EFBIG);
biosize = vp->v_mount->mnt_stat.f_iosize;
/*

17
sys/fs/nwfs/nwfs_io.c
View File

@ -28,16 +28,13 @@
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h> /* defines plimit structure in proc struct */
#include <sys/kernel.h>
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/dirent.h>
#include <sys/signalvar.h>
#include <sys/sysctl.h>
#include <vm/vm.h>
@ -229,16 +226,10 @@ nwfs_writevnode(vp, uiop, cred, ioflag)
}
}
if (uiop->uio_resid == 0) return 0;
if (td != NULL) {
PROC_LOCK(td->td_proc);
if (uiop->uio_offset + uiop->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uiop, td))
return (EFBIG);
error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cred);
NCPVNDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
if (!error) {

18
sys/fs/smbfs/smbfs_io.c
View File

@ -28,9 +28,7 @@
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h> /* defines plimit structure in proc struct */
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/fcntl.h>
#include <sys/bio.h>
#include <sys/buf.h>
@ -235,7 +233,6 @@ smbfs_writevnode(struct vnode *vp, struct uio *uiop,
struct smbmount *smp = VTOSMBFS(vp);
struct smbnode *np = VTOSMB(vp);
struct smb_cred scred;
struct proc *p;
struct thread *td;
int error = 0;
@ -249,7 +246,6 @@ smbfs_writevnode(struct vnode *vp, struct uio *uiop,
/* if (uiop->uio_offset + uiop->uio_resid > smp->nm_maxfilesize)
return (EFBIG);*/
td = uiop->uio_td;
p = td->td_proc;
if (ioflag & (IO_APPEND | IO_SYNC)) {
if (np->n_flag & NMODIFIED) {
smbfs_attr_cacheremove(vp);
@ -271,16 +267,10 @@ smbfs_writevnode(struct vnode *vp, struct uio *uiop,
}
if (uiop->uio_resid == 0)
return 0;
if (p != NULL) {
PROC_LOCK(p);
if (uiop->uio_offset + uiop->uio_resid >
lim_cur(p, RLIMIT_FSIZE)) {
psignal(p, SIGXFSZ);
PROC_UNLOCK(p);
return EFBIG;
}
PROC_UNLOCK(p);
}
if (vn_rlimit_fsize(vp, uiop, td))
return (EFBIG);
smb_makescred(&scred, td, cred);
error = smb_write(smp->sm_share, np->n_fid, uiop, &scred);
SMBVDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);

13
sys/fs/tmpfs/tmpfs_vnops.c
View File

@ -42,7 +42,6 @@ __FBSDID("$FreeBSD$");
#include <sys/namei.h>
#include <sys/priv.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/sched.h>
#include <sys/sf_buf.h>
#include <sys/stat.h>
@ -748,16 +747,8 @@ tmpfs_write(struct vop_write_args *v)
VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
return (EFBIG);
if (vp->v_type == VREG && td != NULL) {
PROC_LOCK(td->td_proc);
if (uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uio, td))
return (EFBIG);
extended = uio->uio_offset + uio->uio_resid > node->tn_size;
if (extended) {

12
sys/gnu/fs/xfs/FreeBSD/xfs_vnops.c
View File

@ -598,16 +598,8 @@ xfs_write_file(xfs_inode_t *xip, struct uio *uio, int ioflag)
*/
#if 0
td = uio->uio_td;
if (vp->v_type == VREG && td != NULL) {
PROC_LOCK(td->td_proc);
if (uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uio, uio->uio_td))
return (EFBIG);
#endif
resid = uio->uio_resid;

19
sys/kern/vfs_vnops.c
View File

@ -54,6 +54,7 @@ __FBSDID("$FreeBSD$");
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/filio.h>
#include <sys/resourcevar.h>
#include <sys/sx.h>
#include <sys/ttycom.h>
#include <sys/conf.h>
@ -1338,3 +1339,21 @@ vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags, struct vnode **rvp)
}
return (error);
}
int
vn_rlimit_fsize(const struct vnode *vp, const struct uio *uio, const struct thread *td)
{
if (vp->v_type != VREG || td == NULL)
return (0);
PROC_LOCK(td->td_proc);
if (uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
return (0);
}

15
sys/nfsclient/nfs_bio.c
View File

@ -45,8 +45,6 @@ __FBSDID("$FreeBSD$");
#include <sys/mbuf.h>
#include <sys/mount.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
#include <sys/vmmeter.h>
#include <sys/vnode.h>
@ -873,7 +871,6 @@ nfs_write(struct vop_write_args *ap)
daddr_t lbn;
int bcount;
int n, on, error = 0;
struct proc *p = td?td->td_proc:NULL;
#ifdef DIAGNOSTIC
if (uio->uio_rw != UIO_WRITE)
@ -954,16 +951,8 @@ nfs_write(struct vop_write_args *ap)
* Maybe this should be above the vnode op call, but so long as
* file servers have no limits, i don't think it matters
*/
if (p != NULL) {
PROC_LOCK(p);
if (uio->uio_offset + uio->uio_resid >
lim_cur(p, RLIMIT_FSIZE)) {
psignal(p, SIGXFSZ);
PROC_UNLOCK(p);
return (EFBIG);
}
PROC_UNLOCK(p);
}
if (vn_rlimit_fsize(vp, uio, td))
return (EFBIG);
biosize = vp->v_mount->mnt_stat.f_iosize;
/*

1
sys/sys/vnode.h
View File

@ -780,6 +780,7 @@ struct dirent;
int vfs_read_dirent(struct vop_readdir_args *ap, struct dirent *dp, off_t off);
int vfs_unixify_accmode(accmode_t *accmode);
int vn_rlimit_fsize(const struct vnode *vn, const struct uio *uio, const struct thread *td);
#endif /* _KERNEL */

17
sys/ufs/ffs/ffs_vnops.c
View File

@ -75,9 +75,6 @@ __FBSDID("$FreeBSD$");
#include <sys/malloc.h>
#include <sys/mount.h>
#include <sys/priv.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
#include <sys/stat.h>
#include <sys/vmmeter.h>
#include <sys/vnode.h>
@ -652,7 +649,6 @@ ffs_write(ap)
struct inode *ip;
struct fs *fs;
struct buf *bp;
struct thread *td;
ufs_lbn_t lbn;
off_t osize;
int seqcount;
@ -704,17 +700,8 @@ ffs_write(ap)
* Maybe this should be above the vnode op call, but so long as
* file servers have no limits, I don't think it matters.
*/
td = uio->uio_td;
if (vp->v_type == VREG && td != NULL) {
PROC_LOCK(td->td_proc);
if (uio->uio_offset + uio->uio_resid >
lim_cur(td->td_proc, RLIMIT_FSIZE)) {
psignal(td->td_proc, SIGXFSZ);
PROC_UNLOCK(td->td_proc);
return (EFBIG);
}
PROC_UNLOCK(td->td_proc);
}
if (vn_rlimit_fsize(vp, uio, uio->uio_td))
return (EFBIG);
resid = uio->uio_resid;
osize = ip->i_size;