Oops I included ufs/ufs_extattr.c (the FFSv1 ones) not ffs/ffs_extattr.c which is the new file, so let's try again:
? o ? ffs/ffs_inode.c.debug Index: files.ufs =================================================================== RCS file: /cvsroot/src/sys/ufs/files.ufs,v retrieving revision 1.45 diff -u -u -r1.45 files.ufs --- files.ufs 17 Jun 2019 03:32:58 -0000 1.45 +++ files.ufs 11 Apr 2020 00:13:05 -0000 @@ -52,6 +52,7 @@ file ufs/ffs/ffs_alloc.c ffs file ufs/ffs/ffs_balloc.c ffs file ufs/ffs/ffs_bswap.c (ffs | mfs) & ffs_ei +file ufs/ffs/ffs_extattr.c ffs & ufs_extattr file ufs/ffs/ffs_inode.c ffs file ufs/ffs/ffs_snapshot.c ffs file ufs/ffs/ffs_subr.c ffs Index: ffs/ffs_alloc.c =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/ffs_alloc.c,v retrieving revision 1.166 diff -u -u -r1.166 ffs_alloc.c --- ffs/ffs_alloc.c 23 Feb 2020 15:46:42 -0000 1.166 +++ ffs/ffs_alloc.c 11 Apr 2020 00:13:05 -0000 @@ -257,7 +257,10 @@ bno = ffs_hashalloc(ip, cg, bpref, size, 0, flags, ffs_alloccg); if (bno > 0) { DIP_ADD(ip, blocks, btodb(size)); - ip->i_flag |= IN_CHANGE | IN_UPDATE; + if (flags & IO_EXT) + ip->i_flag |= IN_CHANGE; + else + ip->i_flag |= IN_CHANGE | IN_UPDATE; *bnp = bno; return (0); } @@ -300,14 +303,15 @@ * => return with um_lock released */ int -ffs_realloccg(struct inode *ip, daddr_t lbprev, daddr_t bpref, int osize, - int nsize, kauth_cred_t cred, struct buf **bpp, daddr_t *blknop) +ffs_realloccg(struct inode *ip, daddr_t lbprev, daddr_t bprev, daddr_t bpref, + int osize, int nsize, int flags, kauth_cred_t cred, struct buf **bpp, + daddr_t *blknop) { struct ufsmount *ump; struct fs *fs; struct buf *bp; int cg, request, error; - daddr_t bprev, bno; + daddr_t bno; fs = ip->i_fs; ump = ip->i_ump; @@ -368,10 +372,6 @@ mutex_exit(&ump->um_lock); goto nospace; } - if (fs->fs_magic == FS_UFS2_MAGIC) - bprev = ufs_rw64(ip->i_ffs2_db[lbprev], UFS_FSNEEDSWAP(fs)); - else - bprev = ufs_rw32(ip->i_ffs1_db[lbprev], UFS_FSNEEDSWAP(fs)); if (bprev == 0) { panic("%s: bad bprev: dev = 0x%llx, bsize = %d, bprev = %" @@ -403,7 +403,10 @@ mutex_enter(&ump->um_lock); if ((bno = ffs_fragextend(ip, cg, bprev, osize, nsize)) != 0) { DIP_ADD(ip, blocks, btodb(nsize - osize)); - ip->i_flag |= IN_CHANGE | IN_UPDATE; + if (flags & IO_EXT) + ip->i_flag |= IN_CHANGE; + else + ip->i_flag |= IN_CHANGE | IN_UPDATE; if (bpp != NULL) { if (bp->b_blkno != FFS_FSBTODB(fs, bno)) { @@ -503,7 +506,10 @@ ip->i_number); } DIP_ADD(ip, blocks, btodb(nsize - osize)); - ip->i_flag |= IN_CHANGE | IN_UPDATE; + if (flags & IO_EXT) + ip->i_flag |= IN_CHANGE; + else + ip->i_flag |= IN_CHANGE | IN_UPDATE; if (bpp != NULL) { bp->b_blkno = FFS_FSBTODB(fs, bno); allocbuf(bp, nsize, 1); Index: ffs/ffs_balloc.c =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/ffs_balloc.c,v retrieving revision 1.63 diff -u -u -r1.63 ffs_balloc.c --- ffs/ffs_balloc.c 28 Oct 2017 00:37:13 -0000 1.63 +++ ffs/ffs_balloc.c 11 Apr 2020 00:13:05 -0000 @@ -72,6 +72,12 @@ static int ffs_balloc_ufs2(struct vnode *, off_t, int, kauth_cred_t, int, struct buf **); +static daddr_t +ffs_extb(struct fs *fs, struct ufs2_dinode *dp, daddr_t nb) +{ + return ufs_rw64(dp->di_extb[nb], UFS_FSNEEDSWAP(fs)); +} + /* * Balloc defines the structure of file system storage * by allocating the physical blocks on a device given @@ -139,10 +145,11 @@ osize = ffs_blksize(fs, ip, nb); if (osize < fs->fs_bsize && osize > 0) { mutex_enter(&ump->um_lock); - error = ffs_realloccg(ip, nb, + error = ffs_realloccg(ip, nb, ffs_getdb(fs, ip, nb), ffs_blkpref_ufs1(ip, lastlbn, nb, flags, &ip->i_ffs1_db[0]), - osize, (int)fs->fs_bsize, cred, bpp, &newb); + osize, (int)fs->fs_bsize, flags, cred, bpp, + &newb); if (error) return (error); ip->i_size = ffs_lblktosize(fs, nb + 1); @@ -215,9 +222,10 @@ */ mutex_enter(&ump->um_lock); error = ffs_realloccg(ip, lbn, + ffs_getdb(fs, ip, lbn), ffs_blkpref_ufs1(ip, lbn, (int)lbn, flags, &ip->i_ffs1_db[0]), - osize, nsize, cred, bpp, &newb); + osize, nsize, flags, cred, bpp, &newb); if (error) return (error); } @@ -543,11 +551,11 @@ if (lbn < 0) return (EFBIG); -#ifdef notyet /* * Check for allocating external data. */ if (flags & IO_EXT) { + struct ufs2_dinode *dp = ip->i_din.ffs2_din; if (lbn >= UFS_NXADDR) return (EFBIG); /* @@ -562,16 +570,15 @@ if (osize < fs->fs_bsize && osize > 0) { mutex_enter(&ump->um_lock); error = ffs_realloccg(ip, -1 - nb, - dp->di_extb[nb], + ffs_extb(fs, dp, nb), ffs_blkpref_ufs2(ip, lastlbn, (int)nb, flags, &dp->di_extb[0]), - osize, - (int)fs->fs_bsize, cred, &bp); + osize, (int)fs->fs_bsize, flags, cred, + &bp, &newb); if (error) return (error); - dp->di_extsize = smalllblktosize(fs, nb + 1); + dp->di_extsize = ffs_lblktosize(fs, nb + 1); dp->di_extb[nb] = FFS_DBTOFSB(fs, bp->b_blkno); - bp->b_xflags |= BX_ALTDATA; ip->i_flag |= IN_CHANGE | IN_UPDATE; if (flags & IO_SYNC) bwrite(bp); @@ -582,19 +589,16 @@ /* * All blocks are direct blocks */ - if (flags & BA_METAONLY) - panic("ffs_balloc_ufs2: BA_METAONLY for ext block"); nb = dp->di_extb[lbn]; - if (nb != 0 && dp->di_extsize >= smalllblktosize(fs, lbn + 1)) { + if (nb != 0 && dp->di_extsize >= ffs_lblktosize(fs, lbn + 1)) { error = bread(vp, -1 - lbn, fs->fs_bsize, 0, &bp); if (error) { return (error); } - mutex_enter(&bp->b_interlock); + mutex_enter(bp->b_objlock); bp->b_blkno = FFS_FSBTODB(fs, nb); - bp->b_xflags |= BX_ALTDATA; - mutex_exit(&bp->b_interlock); + mutex_exit(bp->b_objlock); *bpp = bp; return (0); } @@ -610,23 +614,21 @@ if (error) { return (error); } - mutex_enter(&bp->b_interlock); + mutex_enter(bp->b_objlock); bp->b_blkno = FFS_FSBTODB(fs, nb); - bp->b_xflags |= BX_ALTDATA; - mutex_exit(&bp->b_interlock); + mutex_exit(bp->b_objlock); } else { mutex_enter(&ump->um_lock); error = ffs_realloccg(ip, -1 - lbn, - dp->di_extb[lbn], + ffs_extb(fs, dp, lbn), ffs_blkpref_ufs2(ip, lbn, (int)lbn, flags, &dp->di_extb[0]), - osize, nsize, cred, &bp); + osize, nsize, flags, cred, &bp, &newb); if (error) return (error); - bp->b_xflags |= BX_ALTDATA; } } else { - if (dp->di_extsize < smalllblktosize(fs, lbn + 1)) + if (dp->di_extsize < ffs_lblktosize(fs, lbn + 1)) nsize = ffs_fragroundup(fs, size); else nsize = fs->fs_bsize; @@ -641,14 +643,12 @@ nsize, (flags & B_CLRBUF) != 0, &bp); if (error) return error; - bp->b_xflags |= BX_ALTDATA; } dp->di_extb[lbn] = FFS_DBTOFSB(fs, bp->b_blkno); ip->i_flag |= IN_CHANGE | IN_UPDATE; *bpp = bp; return (0); } -#endif /* * If the next write will extend the file into a new block, * and the file is currently composed of a fragment @@ -661,10 +661,11 @@ osize = ffs_blksize(fs, ip, nb); if (osize < fs->fs_bsize && osize > 0) { mutex_enter(&ump->um_lock); - error = ffs_realloccg(ip, nb, + error = ffs_realloccg(ip, nb, ffs_getdb(fs, ip, lbn), ffs_blkpref_ufs2(ip, lastlbn, nb, flags, &ip->i_ffs2_db[0]), - osize, (int)fs->fs_bsize, cred, bpp, &newb); + osize, (int)fs->fs_bsize, flags, cred, bpp, + &newb); if (error) return (error); ip->i_size = ffs_lblktosize(fs, nb + 1); @@ -737,9 +738,10 @@ */ mutex_enter(&ump->um_lock); error = ffs_realloccg(ip, lbn, + ffs_getdb(fs, ip, lbn), ffs_blkpref_ufs2(ip, lbn, (int)lbn, flags, &ip->i_ffs2_db[0]), - osize, nsize, cred, bpp, &newb); + osize, nsize, flags, cred, bpp, &newb); if (error) return (error); } Index: ffs/ffs_extattr.c =================================================================== RCS file: ffs/ffs_extattr.c diff -N ffs/ffs_extattr.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ ffs/ffs_extattr.c 11 Apr 2020 00:13:05 -0000 @@ -0,0 +1,983 @@ +/* $NetBSD: ffs_vnops.c,v 1.130 2020/02/23 15:46:42 ad Exp $ */ + +/*- + * SPDX-License-Identifier: (BSD-2-Clause-FreeBSD AND BSD-3-Clause) + * + * Copyright (c) 2002, 2003 Networks Associates Technology, Inc. + * All rights reserved. + * + * This software was developed for the FreeBSD Project by Marshall + * Kirk McKusick and Network Associates Laboratories, the Security + * Research Division of Network Associates, Inc. under DARPA/SPAWAR + * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS + * research program + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * Copyright (c) 1982, 1986, 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * from: @(#)ufs_readwrite.c 8.11 (Berkeley) 5/8/95 + * from: $FreeBSD: .../ufs/ufs_readwrite.c,v 1.96 2002/08/12 09:22:11 phk ... + * @(#)ffs_vnops.c 8.15 (Berkeley) 5/14/95 + */ + +#include <sys/cdefs.h> +__KERNEL_RCSID(0, "$NetBSD: ffs_extattr.c,v 1.130 2020/02/23 15:46:42 ad Exp $"); + +#if defined(_KERNEL_OPT) +#include "opt_ffs.h" +#include "opt_wapbl.h" +#endif + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/resourcevar.h> +#include <sys/kernel.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/buf.h> +#include <sys/event.h> +#include <sys/extattr.h> +#include <sys/kauth.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/vnode.h> +#include <sys/malloc.h> +#include <sys/pool.h> +#include <sys/signalvar.h> +#include <sys/kauth.h> +#include <sys/wapbl.h> + +#include <miscfs/fifofs/fifo.h> +#include <miscfs/genfs/genfs.h> +#include <miscfs/specfs/specdev.h> + +#include <ufs/ufs/inode.h> +#include <ufs/ufs/dir.h> +#include <ufs/ufs/ufs_extern.h> +#include <ufs/ufs/ufsmount.h> +#include <ufs/ufs/ufs_wapbl.h> + +#include <ufs/ffs/fs.h> +#include <ufs/ffs/ffs_extern.h> + +#include <uvm/uvm.h> + +#define ALIGNED_TO(ptr, s) \ + (((uintptr_t)(ptr) & (_Alignof(s) - 1)) == 0) +#define uoff_t uintmax_t +#define ITOFS(ip) (ip)->i_fs +#define i_din2 i_din.ffs2_din +#define VI_LOCK(vp) mutex_enter((vp)->v_interlock) +#define VI_UNLOCK(vp) mutex_exit((vp)->v_interlock) +#define UFS_INODE_SET_FLAG(ip, f) ((ip)->i_flag |= (f)) +#define ASSERT_VOP_ELOCKED(vp, m) KASSERT(VOP_ISLOCKED(vp)) +#define I_IS_UFS2(ip) (ITOFS(ip)->fs_magic == FS_UFS2_MAGIC) +#define lblktosize(fs, o) ffs_lblktosize(fs, o) +#define lblkno(fs, o) ffs_lblkno(fs, o) +#define blkoff(fs, o) ffs_blkoff(fs, o) +#define sblksize(fs, o, lbn) ffs_sblksize(fs, o, lbn) +typedef mode_t accmode_t; /* so that it breaks soon */ +typedef daddr_t ufs_lbn_t; +#define msleep(chan, mtx, pri, wmesg, timeo) \ + mtsleep((chan), (pri), (wmesg), (timeo), *(mtx)) +#define vm_page_count_severe() 0 +#define buf_dirty_count_severe() 0 +#define BA_CLRBUF B_CLRBUF +#define IO_ASYNC 0 +#define vfs_bio_brelse(bp, ioflag) brelse(bp, 0) +#define vfs_bio_clrbuf(bp) clrbuf(bp) +#define vfs_bio_set_flags(bp, ioflag) __nothing + +/* + * Credential check based on process requesting service, and per-attribute + * permissions. + */ +static int +ffs_extattr_check_cred(struct vnode *vp, int attrnamespace, kauth_cred_t cred, + accmode_t accmode) +{ + + /* + * Kernel-invoked always succeeds. + */ + if (cred == NOCRED) + return 0; + + /* + * Do not allow privileged processes in jail to directly manipulate + * system attributes. + */ + switch (attrnamespace) { + case EXTATTR_NAMESPACE_SYSTEM: + /* Potentially with privs */ + return EPERM; + case EXTATTR_NAMESPACE_USER: + return VOP_ACCESS(vp, accmode, cred); + default: + return EPERM; + } +} +/* + * Extended attribute area reading. + */ +static int +ffs_extread(struct vnode *vp, struct uio *uio, int ioflag) +{ + struct inode *ip; + struct ufs2_dinode *dp; + struct fs *fs; + struct buf *bp; + ufs_lbn_t lbn, nextlbn; + off_t bytesinfile; + long size, xfersize, blkoffset; + ssize_t orig_resid; + int error; + + ip = VTOI(vp); + fs = ITOFS(ip); + dp = ip->i_din2; + +#ifdef INVARIANTS + if (uio->uio_rw != UIO_READ || fs->fs_magic != FS_UFS2_MAGIC) + panic("ffs_extread: mode"); + +#endif + orig_resid = uio->uio_resid; + KASSERT(orig_resid >= 0); + if (orig_resid == 0) + return (0); + KASSERT(uio->uio_offset >= 0); + + for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) { + if ((bytesinfile = dp->di_extsize - uio->uio_offset) <= 0) + break; + lbn = lblkno(fs, uio->uio_offset); + nextlbn = lbn + 1; + + /* + * size of buffer. The buffer representing the + * end of the file is rounded up to the size of + * the block type ( fragment or full block, + * depending ). + */ + size = sblksize(fs, dp->di_extsize, lbn); + blkoffset = blkoff(fs, uio->uio_offset); + + /* + * The amount we want to transfer in this iteration is + * one FS block less the amount of the data before + * our startpoint (duh!) + */ + xfersize = fs->fs_bsize - blkoffset; + + /* + * But if we actually want less than the block, + * or the file doesn't have a whole block more of data, + * then use the lesser number. + */ + if (uio->uio_resid < xfersize) + xfersize = uio->uio_resid; + if (bytesinfile < xfersize) + xfersize = bytesinfile; + + if (lblktosize(fs, nextlbn) >= dp->di_extsize) { + /* + * Don't do readahead if this is the end of the info. + */ + error = bread(vp, -1 - lbn, size, 0, &bp); + } else { + /* + * If we have a second block, then + * fire off a request for a readahead + * as well as a read. Note that the 4th and 5th + * arguments point to arrays of the size specified in + * the 6th argument. + */ + u_int nextsize = sblksize(fs, dp->di_extsize, nextlbn); + + nextlbn = -1 - nextlbn; + error = breadn(vp, -1 - lbn, + size, &nextlbn, &nextsize, 1, 0, &bp); + } + if (error) { + brelse(bp, 0); + bp = NULL; + break; + } + + /* + * We should only get non-zero b_resid when an I/O error + * has occurred, which should cause us to break above. + * However, if the short read did not cause an error, + * then we want to ensure that we do not uiomove bad + * or uninitialized data. + */ + size -= bp->b_resid; + if (size < xfersize) { + if (size == 0) + break; + xfersize = size; + } + + error = uiomove((char *)bp->b_data + blkoffset, + (int)xfersize, uio); + if (error) + break; + vfs_bio_brelse(bp, ioflag); + } + + /* + * This can only happen in the case of an error + * because the loop above resets bp to NULL on each iteration + * and on normal completion has not set a new value into it. + * so it must have come from a 'break' statement + */ + if (bp != NULL) + vfs_bio_brelse(bp, ioflag); + return (error); +} +/* + * Extended attribute area writing. + */ +static int +ffs_extwrite(struct vnode *vp, struct uio *uio, int ioflag, kauth_cred_t ucred) +{ + struct inode *ip; + struct ufs2_dinode *dp; + struct fs *fs; + struct buf *bp; + ufs_lbn_t lbn; + off_t osize; + ssize_t resid; + int blkoffset, error, flags, size, xfersize; + + ip = VTOI(vp); + fs = ITOFS(ip); + dp = ip->i_din2; + +#ifdef INVARIANTS + if (uio->uio_rw != UIO_WRITE || fs->fs_magic != FS_UFS2_MAGIC) + panic("ffs_extwrite: mode"); +#endif + + if (ioflag & IO_APPEND) + uio->uio_offset = dp->di_extsize; + KASSERT(uio->uio_offset >= 0); + if ((uoff_t)uio->uio_offset + uio->uio_resid > + UFS_NXADDR * fs->fs_bsize) + return (EFBIG); + + resid = uio->uio_resid; + osize = dp->di_extsize; + flags = IO_EXT; + if (ioflag & IO_SYNC) + flags |= IO_SYNC; + + if ((error = UFS_WAPBL_BEGIN(vp->v_mount)) != 0) { + printf("%s: wapbl begin: %d\n", __func__, error); + return error; + } + + for (error = 0; uio->uio_resid > 0;) { + lbn = lblkno(fs, uio->uio_offset); + blkoffset = blkoff(fs, uio->uio_offset); + xfersize = fs->fs_bsize - blkoffset; + if (uio->uio_resid < xfersize) + xfersize = uio->uio_resid; + + /* + * We must perform a read-before-write if the transfer size + * does not cover the entire buffer. + */ + if (fs->fs_bsize > xfersize) + flags |= BA_CLRBUF; + else + flags &= ~BA_CLRBUF; + error = UFS_BALLOC(vp, uio->uio_offset, xfersize, + ucred, flags, &bp); + if (error != 0) + break; + /* + * If the buffer is not valid we have to clear out any + * garbage data from the pages instantiated for the buffer. + * If we do not, a failed uiomove() during a write can leave + * the prior contents of the pages exposed to a userland + * mmap(). XXX deal with uiomove() errors a better way. + */ + if ((bp->b_flags & BC_NOCACHE) && fs->fs_bsize <= xfersize) + vfs_bio_clrbuf(bp); + + if (uio->uio_offset + xfersize > dp->di_extsize) + dp->di_extsize = uio->uio_offset + xfersize; + + size = sblksize(fs, dp->di_extsize, lbn) - bp->b_resid; + if (size < xfersize) + xfersize = size; + + error = + uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio); + + vfs_bio_set_flags(bp, ioflag); + + /* + * If IO_SYNC each buffer is written synchronously. Otherwise + * if we have a severe page deficiency write the buffer + * asynchronously. Otherwise try to cluster, and if that + * doesn't do it then either do an async write (if O_DIRECT), + * or a delayed write (if not). + */ + if (ioflag & IO_SYNC) { + (void)bwrite(bp); + } else if (vm_page_count_severe() || + buf_dirty_count_severe() || + xfersize + blkoffset == fs->fs_bsize || + (ioflag & (IO_ASYNC | IO_DIRECT))) + bawrite(bp); + else + bdwrite(bp); + if (error || xfersize == 0) + break; + UFS_INODE_SET_FLAG(ip, IN_CHANGE); + } + /* + * If we successfully wrote any data, and we are not the superuser + * we clear the setuid and setgid bits as a precaution against + * tampering. + */ + if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid && ucred) { + ip->i_mode &= ~(ISUID | ISGID); + dp->di_mode = ip->i_mode; + } + if (error) { + if (ioflag & IO_UNIT) { + (void)ffs_truncate(vp, osize, + IO_EXT | (ioflag&IO_SYNC), ucred); + uio->uio_offset -= resid - uio->uio_resid; + uio->uio_resid = resid; + } + } else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) + error = ffs_update(vp, NULL, NULL, UPDATE_WAIT); + UFS_WAPBL_END(vp->v_mount); + return (error); +} + +/* + * Vnode operating to retrieve a named extended attribute. + * + * Locate a particular EA (nspace:name) in the area (ptr:length), and return + * the length of the EA, and possibly the pointer to the entry and to the data. + */ +static int +ffs_findextattr(u_char *ptr, u_int length, int nspace, const char *name, + struct extattr **eapp, u_char **eac) +{ + struct extattr *eap, *eaend; + size_t nlen; + + nlen = strlen(name); + KASSERT(ALIGNED_TO(ptr, struct extattr)); + eap = (struct extattr *)ptr; + eaend = (struct extattr *)(ptr + length); + for (; eap < eaend; eap = EXTATTR_NEXT(eap)) { + /* make sure this entry is complete */ + if (EXTATTR_NEXT(eap) > eaend) + break; + if (eap->ea_namespace != nspace || eap->ea_namelength != nlen + || memcmp(eap->ea_name, name, nlen) != 0) + continue; + if (eapp != NULL) + *eapp = eap; + if (eac != NULL) + *eac = EXTATTR_CONTENT(eap); + return (EXTATTR_CONTENT_SIZE(eap)); + } + return (-1); +} + +static int +ffs_rdextattr(u_char **p, struct vnode *vp, int extra) +{ + struct inode *ip; + struct ufs2_dinode *dp; + struct fs *fs; + struct uio luio; + struct iovec liovec; + u_int easize; + int error; + u_char *eae; + + ip = VTOI(vp); + fs = ITOFS(ip); + dp = ip->i_din2; + easize = dp->di_extsize; + if ((uoff_t)easize + extra > UFS_NXADDR * fs->fs_bsize) + return (EFBIG); + + eae = malloc(easize + extra, M_TEMP, M_WAITOK); + + liovec.iov_base = eae; + liovec.iov_len = easize; + luio.uio_iov = &liovec; + luio.uio_iovcnt = 1; + luio.uio_offset = 0; + luio.uio_resid = easize; + luio.uio_vmspace = vmspace_kernel(); + luio.uio_rw = UIO_READ; + + error = ffs_extread(vp, &luio, IO_EXT | IO_SYNC); + if (error) { + free(eae, M_TEMP); + return(error); + } + *p = eae; + return (0); +} + +static void +ffs_lock_ea(struct vnode *vp) +{ + struct inode *ip; + + ip = VTOI(vp); + VI_LOCK(vp); + while (ip->i_flag & IN_EA_LOCKED) { + UFS_INODE_SET_FLAG(ip, IN_EA_LOCKWAIT); + msleep(&ip->i_ea_refs, &vp->v_interlock, PINOD + 2, "ufs_ea", + 0); + } + UFS_INODE_SET_FLAG(ip, IN_EA_LOCKED); + VI_UNLOCK(vp); +} + +static void +ffs_unlock_ea(struct vnode *vp) +{ + struct inode *ip; + + ip = VTOI(vp); + VI_LOCK(vp); + if (ip->i_flag & IN_EA_LOCKWAIT) + wakeup(&ip->i_ea_refs); + ip->i_flag &= ~(IN_EA_LOCKED | IN_EA_LOCKWAIT); + VI_UNLOCK(vp); +} + +static int +ffs_open_ea(struct vnode *vp, kauth_cred_t cred) +{ + struct inode *ip; + struct ufs2_dinode *dp; + int error; + + ip = VTOI(vp); + + ffs_lock_ea(vp); + if (ip->i_ea_area != NULL) { + ip->i_ea_refs++; + ffs_unlock_ea(vp); + return (0); + } + dp = ip->i_din2; + error = ffs_rdextattr(&ip->i_ea_area, vp, 0); + if (error) { + ffs_unlock_ea(vp); + return (error); + } + ip->i_ea_len = dp->di_extsize; + ip->i_ea_error = 0; + ip->i_ea_refs++; + ffs_unlock_ea(vp); + return (0); +} + +/* + * Vnode extattr transaction commit/abort + */ +static int +ffs_close_ea(struct vnode *vp, int commit, kauth_cred_t cred) +{ + struct inode *ip; + struct uio luio; + struct iovec liovec; + int error; + struct ufs2_dinode *dp; + + ip = VTOI(vp); + + ffs_lock_ea(vp); + if (ip->i_ea_area == NULL) { + ffs_unlock_ea(vp); + return (EINVAL); + } + dp = ip->i_din2; + error = ip->i_ea_error; + if (commit && error == 0) { + ASSERT_VOP_ELOCKED(vp, "ffs_close_ea commit"); + if (cred == NOCRED) + cred = lwp0.l_cred; + liovec.iov_base = ip->i_ea_area; + liovec.iov_len = ip->i_ea_len; + luio.uio_iov = &liovec; + luio.uio_iovcnt = 1; + luio.uio_offset = 0; + luio.uio_resid = ip->i_ea_len; + luio.uio_vmspace = vmspace_kernel(); + luio.uio_rw = UIO_WRITE; + /* XXX: I'm not happy about truncating to zero size */ + if (ip->i_ea_len < dp->di_extsize) + error = ffs_truncate(vp, 0, IO_EXT, cred); + error = ffs_extwrite(vp, &luio, IO_EXT | IO_SYNC, cred); + } + if (--ip->i_ea_refs == 0) { + free(ip->i_ea_area, M_TEMP); + ip->i_ea_area = NULL; + ip->i_ea_len = 0; + ip->i_ea_error = 0; + } + ffs_unlock_ea(vp); + return (error); +} + +/* + * Vnode extattr strategy routine for fifos. + * + * We need to check for a read or write of the external attributes. + * Otherwise we just fall through and do the usual thing. + */ +int +ffsext_strategy(void *v) +{ + struct vop_strategy_args /* { + struct vnodeop_desc *a_desc; + struct vnode *a_vp; + struct buf *a_bp; + } */ *ap = v; + struct vnode *vp; + daddr_t lbn; + + vp = ap->a_vp; + lbn = ap->a_bp->b_lblkno; + if (I_IS_UFS2(VTOI(vp)) && lbn < 0 && lbn >= -UFS_NXADDR) + return ufs_strategy(ap); + if (vp->v_type == VFIFO) + return vn_fifo_bypass(ap); + panic("spec nodes went here"); +} + +/* + * Vnode extattr transaction commit/abort + */ +int +ffs_openextattr(void *v) +{ + struct vop_openextattr_args /* { + struct vnode *a_vp; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct inode *ip = VTOI(ap->a_vp); + struct fs *fs = ip->i_fs; + + /* Not supported for UFS1 file systems. */ + if (fs->fs_magic == FS_UFS1_MAGIC) + return (EOPNOTSUPP); + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + return (ffs_open_ea(ap->a_vp, ap->a_cred)); +} + +/* + * Vnode extattr transaction commit/abort + */ +int +ffs_closeextattr(void *v) +{ + struct vop_closeextattr_args /* { + struct vnode *a_vp; + int a_commit; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct inode *ip = VTOI(ap->a_vp); + struct fs *fs = ip->i_fs; + + /* Not supported for UFS1 file systems. */ + if (fs->fs_magic == FS_UFS1_MAGIC) + return (EOPNOTSUPP); + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + if (ap->a_commit && (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) + return (EROFS); + + return (ffs_close_ea(ap->a_vp, ap->a_commit, ap->a_cred)); +} + +/* + * Vnode operation to retrieve a named extended attribute. + */ +int +ffs_getextattr(void *v) +{ + struct vop_getextattr_args /* { + struct vnode *a_vp; + int a_attrnamespace; + const char *a_name; + struct uio *a_uio; + size_t *a_size; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct fs *fs = ip->i_fs; + + if (fs->fs_magic == FS_UFS1_MAGIC) { + return ufs_getextattr(ap); + } + + u_char *eae, *p; + unsigned easize; + int error, ealen; + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + error = ffs_extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, VREAD); + if (error) + return (error); + + error = ffs_open_ea(ap->a_vp, ap->a_cred); + if (error) + return (error); + + eae = ip->i_ea_area; + easize = ip->i_ea_len; + + ealen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name, + NULL, &p); + if (ealen >= 0) { + error = 0; + if (ap->a_size != NULL) + *ap->a_size = ealen; + else if (ap->a_uio != NULL) + error = uiomove(p, ealen, ap->a_uio); + } else + error = ENOATTR; + + ffs_close_ea(ap->a_vp, 0, ap->a_cred); + return (error); +} + +/* + * Vnode operation to set a named attribute. + */ +int +ffs_setextattr(void *v) +{ + struct vop_setextattr_args /* { + struct vnode *a_vp; + int a_attrnamespace; + const char *a_name; + struct uio *a_uio; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct fs *fs = ip->i_fs; + + if (fs->fs_magic == FS_UFS1_MAGIC) { + return ufs_setextattr(ap); + } + + struct extattr *eap; + uint32_t ealength, ul; + ssize_t ealen; + int olen, eapad1, eapad2, error, i, easize; + u_char *eae; + void *tmp; + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + if (strlen(ap->a_name) == 0) + return (EINVAL); + + /* XXX Now unsupported API to delete EAs using NULL uio. */ + if (ap->a_uio == NULL) + return (EOPNOTSUPP); + + if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); + + ealen = ap->a_uio->uio_resid; + if (ealen < 0 || ealen > lblktosize(fs, UFS_NXADDR)) + return (EINVAL); + + error = ffs_extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, VWRITE); + if (error) { + + /* + * ffs_lock_ea is not needed there, because the vnode + * must be exclusively locked. + */ + if (ip->i_ea_area != NULL && ip->i_ea_error == 0) + ip->i_ea_error = error; + return (error); + } + + error = ffs_open_ea(ap->a_vp, ap->a_cred); + if (error) + return (error); + + ealength = sizeof(uint32_t) + 3 + strlen(ap->a_name); + eapad1 = roundup2(ealength, 8) - ealength; + eapad2 = roundup2(ealen, 8) - ealen; + ealength += eapad1 + ealen + eapad2; + + /* + * CEM: rewrites of the same size or smaller could be done in-place + * instead. (We don't acquire any fine-grained locks in here either, + * so we could also do bigger writes in-place.) + */ + eae = malloc(ip->i_ea_len + ealength, M_TEMP, M_WAITOK); + bcopy(ip->i_ea_area, eae, ip->i_ea_len); + easize = ip->i_ea_len; + + olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name, + &eap, NULL); + if (olen == -1) { + /* new, append at end */ + KASSERT(ALIGNED_TO(eae + easize, struct extattr)); + eap = (struct extattr *)(eae + easize); + easize += ealength; + } else { + ul = eap->ea_length; + i = (u_char *)EXTATTR_NEXT(eap) - eae; + if (ul != ealength) { + bcopy(EXTATTR_NEXT(eap), (u_char *)eap + ealength, + easize - i); + easize += (ealength - ul); + } + } + if (easize > lblktosize(fs, UFS_NXADDR)) { + free(eae, M_TEMP); + ffs_close_ea(ap->a_vp, 0, ap->a_cred); + if (ip->i_ea_area != NULL && ip->i_ea_error == 0) + ip->i_ea_error = ENOSPC; + return (ENOSPC); + } + eap->ea_length = ealength; + eap->ea_namespace = ap->a_attrnamespace; + eap->ea_contentpadlen = eapad2; + eap->ea_namelength = strlen(ap->a_name); + memcpy(eap->ea_name, ap->a_name, strlen(ap->a_name)); + bzero(&eap->ea_name[strlen(ap->a_name)], eapad1); + error = uiomove(EXTATTR_CONTENT(eap), ealen, ap->a_uio); + if (error) { + free(eae, M_TEMP); + ffs_close_ea(ap->a_vp, 0, ap->a_cred); + if (ip->i_ea_area != NULL && ip->i_ea_error == 0) + ip->i_ea_error = error; + return (error); + } + bzero((u_char *)EXTATTR_CONTENT(eap) + ealen, eapad2); + + tmp = ip->i_ea_area; + ip->i_ea_area = eae; + ip->i_ea_len = easize; + free(tmp, M_TEMP); + error = ffs_close_ea(ap->a_vp, 1, ap->a_cred); + return (error); +} + +/* + * Vnode operation to retrieve extended attributes on a vnode. + */ +int +ffs_listextattr(void *v) +{ + struct vop_listextattr_args /* { + struct vnode *a_vp; + int a_attrnamespace; + struct uio *a_uio; + size_t *a_size; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct inode *ip = VTOI(ap->a_vp); + struct fs *fs = ip->i_fs; + + if (fs->fs_magic == FS_UFS1_MAGIC) { + return ufs_listextattr(ap); + } + + struct extattr *eap, *eaend; + int error, ealen; + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + error = ffs_extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, VREAD); + if (error) + return (error); + + error = ffs_open_ea(ap->a_vp, ap->a_cred); + if (error) + return (error); + + error = 0; + if (ap->a_size != NULL) + *ap->a_size = 0; + + KASSERT(ALIGNED_TO(ip->i_ea_area, struct extattr)); + eap = (struct extattr *)ip->i_ea_area; + eaend = (struct extattr *)(ip->i_ea_area + ip->i_ea_len); + for (; error == 0 && eap < eaend; eap = EXTATTR_NEXT(eap)) { + /* make sure this entry is complete */ + if (EXTATTR_NEXT(eap) > eaend) + break; + if (eap->ea_namespace != ap->a_attrnamespace) + continue; + + ealen = eap->ea_namelength; + if (ap->a_size != NULL) + *ap->a_size += ealen + 1; + else if (ap->a_uio != NULL) + error = uiomove(&eap->ea_namelength, ealen + 1, + ap->a_uio); + } + + ffs_close_ea(ap->a_vp, 0, ap->a_cred); + return (error); +} + +/* + * Vnode operation to remove a named attribute. + */ +int +ffs_deleteextattr(void *v) +{ + struct vop_deleteextattr_args /* { + struct vnode *a_vp; + int a_attrnamespace; + kauth_cred_t a_cred; + struct proc *a_p; + } */ *ap = v; + struct vnode *vp = ap->a_vp; + struct inode *ip = VTOI(vp); + struct fs *fs = ip->i_fs; + + if (fs->fs_magic == FS_UFS1_MAGIC) { + return ufs_deleteextattr(ap); + } + + struct extattr *eap; + uint32_t ul; + int olen, error, i, easize; + u_char *eae; + void *tmp; + + if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) + return (EOPNOTSUPP); + + if (strlen(ap->a_name) == 0) + return (EINVAL); + + if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) + return (EROFS); + + error = ffs_extattr_check_cred(ap->a_vp, ap->a_attrnamespace, + ap->a_cred, VWRITE); + if (error) { + + /* + * ffs_lock_ea is not needed there, because the vnode + * must be exclusively locked. + */ + if (ip->i_ea_area != NULL && ip->i_ea_error == 0) + ip->i_ea_error = error; + return (error); + } + + error = ffs_open_ea(ap->a_vp, ap->a_cred); + if (error) + return (error); + + /* CEM: delete could be done in-place instead */ + eae = malloc(ip->i_ea_len, M_TEMP, M_WAITOK); + bcopy(ip->i_ea_area, eae, ip->i_ea_len); + easize = ip->i_ea_len; + + olen = ffs_findextattr(eae, easize, ap->a_attrnamespace, ap->a_name, + &eap, NULL); + if (olen == -1) { + /* delete but nonexistent */ + free(eae, M_TEMP); + ffs_close_ea(ap->a_vp, 0, ap->a_cred); + return (ENOATTR); + } + ul = eap->ea_length; + i = (u_char *)EXTATTR_NEXT(eap) - eae; + bcopy(EXTATTR_NEXT(eap), eap, easize - i); + easize -= ul; + + tmp = ip->i_ea_area; + ip->i_ea_area = eae; + ip->i_ea_len = easize; + free(tmp, M_TEMP); + error = ffs_close_ea(ap->a_vp, 1, ap->a_cred); + return error; +} Index: ffs/ffs_extern.h =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/ffs_extern.h,v retrieving revision 1.85 diff -u -u -r1.85 ffs_extern.h --- ffs/ffs_extern.h 22 Aug 2018 01:05:24 -0000 1.85 +++ ffs/ffs_extern.h 11 Apr 2020 00:13:05 -0000 @@ -89,8 +89,8 @@ /* ffs_alloc.c */ int ffs_alloc(struct inode *, daddr_t, daddr_t , int, int, kauth_cred_t, daddr_t *); -int ffs_realloccg(struct inode *, daddr_t, daddr_t, int, int , - kauth_cred_t, struct buf **, daddr_t *); +int ffs_realloccg(struct inode *, daddr_t, daddr_t, daddr_t, int, int, + int, kauth_cred_t, struct buf **, daddr_t *); int ffs_valloc(struct vnode *, int, kauth_cred_t, ino_t *); daddr_t ffs_blkpref_ufs1(struct inode *, daddr_t, int, int, int32_t *); daddr_t ffs_blkpref_ufs2(struct inode *, daddr_t, int, int, int64_t *); @@ -135,16 +135,31 @@ int ffs_reclaim(void *); int ffs_getpages(void *); void ffs_gop_size(struct vnode *, off_t, off_t *, int); +int ffs_lock(void *); +int ffs_unlock(void *); +int ffs_islocked(void *); +int ffs_full_fsync(struct vnode *, int); + +/* ffs_extattr.c */ +#ifdef UFS_EXTATTR int ffs_openextattr(void *); int ffs_closeextattr(void *); int ffs_getextattr(void *); int ffs_setextattr(void *); int ffs_listextattr(void *); int ffs_deleteextattr(void *); -int ffs_lock(void *); -int ffs_unlock(void *); -int ffs_islocked(void *); -int ffs_full_fsync(struct vnode *, int); +int ffsext_strategy(void *); +#else + +#define ffs_notsupp ((void (*)(void *))eopnotsupp) +#define ffs_openextattr ffsnotsupp +#define ffs_closeextattr ffsnotsupp +#define ffs_getextattr ffsnotsupp +#define ffs_setextattr ffsnotsupp +#define ffs_listextattr ffsnotsupp +#define ffs_deleteextattr ffsnotsupp +#define ffsext_strategy vn_fifo_bypass +#endif /* * Snapshot function prototypes. Index: ffs/ffs_inode.c =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/ffs_inode.c,v retrieving revision 1.126 diff -u -u -r1.126 ffs_inode.c --- ffs/ffs_inode.c 23 Feb 2020 15:46:42 -0000 1.126 +++ ffs/ffs_inode.c 11 Apr 2020 00:13:05 -0000 @@ -209,10 +209,11 @@ daddr_t lastblock; struct inode *oip = VTOI(ovp); daddr_t bn, lastiblock[UFS_NIADDR], indir_lbn[UFS_NIADDR]; - daddr_t blks[UFS_NDADDR + UFS_NIADDR]; + daddr_t blks[UFS_NDADDR + UFS_NIADDR], oldblks[UFS_NDADDR + UFS_NIADDR]; struct fs *fs; + int extblocks; int offset, pgoffset, level; - int64_t blocksreleased = 0; + int64_t blocksreleased = 0, datablocks; int i, aflag, nblocks; int error, allerror = 0; off_t osize; @@ -231,9 +232,44 @@ if (length < 0) return (EINVAL); + fs = oip->i_fs; +#define i_din2 i_din.ffs2_din + extblocks = 0; + datablocks = DIP(oip, blocks); + if (fs->fs_magic == FS_UFS2_MAGIC && oip->i_din2->di_extsize > 0) { + extblocks = btodb(ffs_fragroundup(fs, oip->i_din2->di_extsize)); + datablocks -= extblocks; + } + if ((ioflag & IO_EXT) && extblocks > 0) { + if (length != 0) + panic("ffs_truncate: partial trunc of extdata"); + { +#ifdef QUOTA + (void) chkdq(oip, -extblocks, NOCRED, FORCE); +#endif + vinvalbuf(ovp, 0, cred, curlwp, 0, 0); + osize = oip->i_din2->di_extsize; + oip->i_din2->di_blocks -= extblocks; + oip->i_din2->di_extsize = 0; + for (i = 0; i < UFS_NXADDR; i++) { + oldblks[i] = oip->i_din2->di_extb[i]; + oip->i_din2->di_extb[i] = 0; + } + oip->i_flag |= IN_CHANGE; + if ((error = ffs_update(ovp, NULL, NULL, 0))) + return (error); + for (i = 0; i < UFS_NXADDR; i++) { + if (oldblks[i] == 0) + continue; + ffs_blkfree(fs, oip->i_devvp, oldblks[i], + ffs_sblksize(fs, osize, i), oip->i_number); + } + extblocks = 0; + } + } if (ovp->v_type == VLNK && (oip->i_size < ump->um_maxsymlinklen || - (ump->um_maxsymlinklen == 0 && DIP(oip, blocks) == 0))) { + (ump->um_maxsymlinklen == 0 && datablocks == 0))) { KDASSERT(length == 0); memset(SHORTLINK(oip), 0, (size_t)oip->i_size); oip->i_size = 0; @@ -247,7 +283,6 @@ oip->i_flag |= IN_CHANGE | IN_UPDATE; return (ffs_update(ovp, NULL, NULL, 0)); } - fs = oip->i_fs; if (length > ump->um_maxfilesize) return (EFBIG); @@ -415,10 +450,7 @@ indir_lbn[DOUBLE] = indir_lbn[SINGLE] - FFS_NINDIR(fs) - 1; indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - FFS_NINDIR(fs) * FFS_NINDIR(fs) - 1; for (level = TRIPLE; level >= SINGLE; level--) { - if (oip->i_ump->um_fstype == UFS1) - bn = ufs_rw32(oip->i_ffs1_ib[level],UFS_FSNEEDSWAP(fs)); - else - bn = ufs_rw64(oip->i_ffs2_ib[level],UFS_FSNEEDSWAP(fs)); + bn = ffs_getib(fs, oip, level); if (bn != 0) { if (lastiblock[level] < 0 && oip->i_ump->um_mountp->mnt_wapbl) { @@ -461,10 +493,7 @@ for (i = UFS_NDADDR - 1; i > lastblock; i--) { long bsize; - if (oip->i_ump->um_fstype == UFS1) - bn = ufs_rw32(oip->i_ffs1_db[i], UFS_FSNEEDSWAP(fs)); - else - bn = ufs_rw64(oip->i_ffs2_db[i], UFS_FSNEEDSWAP(fs)); + bn = ffs_getdb(fs, oip, i); if (bn == 0) continue; @@ -488,10 +517,7 @@ * Finally, look for a change in size of the * last direct block; release any frags. */ - if (oip->i_ump->um_fstype == UFS1) - bn = ufs_rw32(oip->i_ffs1_db[lastblock], UFS_FSNEEDSWAP(fs)); - else - bn = ufs_rw64(oip->i_ffs2_db[lastblock], UFS_FSNEEDSWAP(fs)); + bn = ffs_getdb(fs, oip, lastblock); if (bn != 0) { long oldspace, newspace; @@ -536,9 +562,9 @@ KASSERTMSG((blks[i] == DIP(oip, db[i])), "itrunc2 blk mismatch: %jx != %jx", (uintmax_t)blks[i], (uintmax_t)DIP(oip, db[i])); - KASSERTMSG((length != 0 || LIST_EMPTY(&ovp->v_cleanblkhd)), + KASSERTMSG((length != 0 || extblocks || LIST_EMPTY(&ovp->v_cleanblkhd)), "itrunc3: zero length and nonempty cleanblkhd"); - KASSERTMSG((length != 0 || LIST_EMPTY(&ovp->v_dirtyblkhd)), + KASSERTMSG((length != 0 || extblocks || LIST_EMPTY(&ovp->v_dirtyblkhd)), "itrunc3: zero length and nonempty dirtyblkhd"); out: Index: ffs/ffs_vnops.c =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/ffs_vnops.c,v retrieving revision 1.130 diff -u -u -r1.130 ffs_vnops.c --- ffs/ffs_vnops.c 23 Feb 2020 15:46:42 -0000 1.130 +++ ffs/ffs_vnops.c 11 Apr 2020 00:13:05 -0000 @@ -612,160 +612,3 @@ *eobp = ffs_blkroundup(fs, size); } } - -int -ffs_openextattr(void *v) -{ - struct vop_openextattr_args /* { - struct vnode *a_vp; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct inode *ip = VTOI(ap->a_vp); - struct fs *fs = ip->i_fs; - - /* Not supported for UFS1 file systems. */ - if (fs->fs_magic == FS_UFS1_MAGIC) - return (EOPNOTSUPP); - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} - -int -ffs_closeextattr(void *v) -{ - struct vop_closeextattr_args /* { - struct vnode *a_vp; - int a_commit; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct inode *ip = VTOI(ap->a_vp); - struct fs *fs = ip->i_fs; - - /* Not supported for UFS1 file systems. */ - if (fs->fs_magic == FS_UFS1_MAGIC) - return (EOPNOTSUPP); - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} - -int -ffs_getextattr(void *v) -{ - struct vop_getextattr_args /* { - struct vnode *a_vp; - int a_attrnamespace; - const char *a_name; - struct uio *a_uio; - size_t *a_size; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct vnode *vp = ap->a_vp; - struct inode *ip = VTOI(vp); - struct fs *fs = ip->i_fs; - - if (fs->fs_magic == FS_UFS1_MAGIC) { -#ifdef UFS_EXTATTR - int error; - - error = ufs_getextattr(ap); - return error; -#else - return (EOPNOTSUPP); -#endif - } - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} - -int -ffs_setextattr(void *v) -{ - struct vop_setextattr_args /* { - struct vnode *a_vp; - int a_attrnamespace; - const char *a_name; - struct uio *a_uio; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct vnode *vp = ap->a_vp; - struct inode *ip = VTOI(vp); - struct fs *fs = ip->i_fs; - - if (fs->fs_magic == FS_UFS1_MAGIC) { -#ifdef UFS_EXTATTR - int error; - - error = ufs_setextattr(ap); - return error; -#else - return (EOPNOTSUPP); -#endif - } - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} - -int -ffs_listextattr(void *v) -{ - struct vop_listextattr_args /* { - struct vnode *a_vp; - int a_attrnamespace; - struct uio *a_uio; - size_t *a_size; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct inode *ip = VTOI(ap->a_vp); - struct fs *fs = ip->i_fs; - - if (fs->fs_magic == FS_UFS1_MAGIC) { -#ifdef UFS_EXTATTR - int error; - - error = ufs_listextattr(ap); - return error; -#else - return (EOPNOTSUPP); -#endif - } - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} - -int -ffs_deleteextattr(void *v) -{ - struct vop_deleteextattr_args /* { - struct vnode *a_vp; - int a_attrnamespace; - kauth_cred_t a_cred; - struct proc *a_p; - } */ *ap = v; - struct vnode *vp = ap->a_vp; - struct inode *ip = VTOI(vp); - struct fs *fs = ip->i_fs; - - if (fs->fs_magic == FS_UFS1_MAGIC) { -#ifdef UFS_EXTATTR - int error; - - error = ufs_deleteextattr(ap); - return error; -#else - return (EOPNOTSUPP); -#endif - } - - /* XXX Not implemented for UFS2 file systems. */ - return (EOPNOTSUPP); -} Index: ffs/fs.h =================================================================== RCS file: /cvsroot/src/sys/ufs/ffs/fs.h,v retrieving revision 1.66 diff -u -u -r1.66 fs.h --- ffs/fs.h 14 Feb 2015 09:06:11 -0000 1.66 +++ ffs/fs.h 11 Apr 2020 00:13:05 -0000 @@ -692,6 +692,14 @@ ((fsb) & ((fs)->fs_frag - 1)) #define ffs_blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \ ((fsb) &~ ((fs)->fs_frag - 1)) +#define ffs_getdb(fs, ip, lb) \ + ((fs)->fs_magic == FS_UFS2_MAGIC ? \ + (daddr_t)ufs_rw64((ip)->i_ffs2_db[lb], UFS_FSNEEDSWAP(fs)) : \ + (daddr_t)ufs_rw32((ip)->i_ffs1_db[lb], UFS_FSNEEDSWAP(fs))) +#define ffs_getib(fs, ip, lb) \ + ((fs)->fs_magic == FS_UFS2_MAGIC ? \ + (daddr_t)ufs_rw64((ip)->i_ffs2_ib[lb], UFS_FSNEEDSWAP(fs)) : \ + (daddr_t)ufs_rw32((ip)->i_ffs1_ib[lb], UFS_FSNEEDSWAP(fs))) /* * Determine the number of available frags given a Index: ufs/extattr.h =================================================================== RCS file: /cvsroot/src/sys/ufs/ufs/extattr.h,v retrieving revision 1.11 diff -u -u -r1.11 extattr.h --- ufs/extattr.h 19 Dec 2014 10:59:21 -0000 1.11 +++ ufs/extattr.h 11 Apr 2020 00:13:05 -0000 @@ -72,6 +72,39 @@ /* data follows the header */ }; +/* + * This structure defines the required fields of an extended-attribute header. + */ +struct extattr { + uint32_t ea_length; /* length of this attribute */ + uint8_t ea_namespace; /* name space of this attribute */ + uint8_t ea_contentpadlen; /* bytes of padding at end of attribute */ + uint8_t ea_namelength; /* length of attribute name */ + char ea_name[1]; /* attribute name (NOT nul-terminated) */ + /* padding, if any, to align attribute content to 8 byte boundary */ + /* extended attribute content follows */ +}; + +/* + * These macros are used to access and manipulate an extended attribute: + * + * EXTATTR_NEXT(eap) returns a pointer to the next extended attribute + * following eap. + * EXTATTR_CONTENT(eap) returns a pointer to the extended attribute + * content referenced by eap. + * EXTATTR_CONTENT_SIZE(eap) returns the size of the extended attribute + * content referenced by eap. + */ +#define EXTATTR_NEXT(eap) \ + ((struct extattr *)(((u_char *)(eap)) + (eap)->ea_length)) +#define EXTATTR_CONTENT(eap) \ + (void *)(((u_char *)(eap)) + EXTATTR_BASE_LENGTH(eap)) +#define EXTATTR_CONTENT_SIZE(eap) \ + ((eap)->ea_length - EXTATTR_BASE_LENGTH(eap) - (eap)->ea_contentpadlen) +/* -1 below compensates for ea_name[1] */ +#define EXTATTR_BASE_LENGTH(eap) \ + roundup2((sizeof(struct extattr) - 1 + (eap)->ea_namelength), 8) + #ifdef _KERNEL #ifdef MALLOC_DECLARE Index: ufs/inode.h =================================================================== RCS file: /cvsroot/src/sys/ufs/ufs/inode.h,v retrieving revision 1.76 diff -u -u -r1.76 inode.h --- ufs/inode.h 20 Aug 2017 12:09:06 -0000 1.76 +++ ufs/inode.h 11 Apr 2020 00:13:05 -0000 @@ -156,6 +156,14 @@ struct dirhash *i_dirhash; /* Hashing for large directories */ /* + * Data for extended attribute modification. + */ + u_char *i_ea_area; /* Pointer to malloced copy of EA area */ + unsigned i_ea_len; /* Length of i_ea_area */ + int i_ea_error; /* First errno in transaction */ + int i_ea_refs; /* Number of users of EA area */ + + /* * The on-disk dinode itself. */ union { @@ -219,8 +227,8 @@ /* unused 0x0020 */ /* was IN_RENAME */ #define IN_SHLOCK 0x0040 /* File has shared lock. */ #define IN_EXLOCK 0x0080 /* File has exclusive lock. */ -/* unused 0x0100 */ /* was LFS-only IN_CLEANING */ -/* unused 0x0200 */ /* was LFS-only IN_ADIROP */ +#define IN_EA_LOCKED 0x0100 /* was LFS-only IN_CLEANING */ +#define IN_EA_LOCKWAIT 0x0200 /* was LFS-only IN_ADIROP */ #define IN_SPACECOUNTED 0x0400 /* Blocks to be freed in free count. */ /* unused 0x0800 */ /* what was that? */ /* unused 0x1000 */ /* was LFS-only IN_PAGING */ Index: ufs/ufs_inode.c =================================================================== RCS file: /cvsroot/src/sys/ufs/ufs/ufs_inode.c,v retrieving revision 1.109 diff -u -u -r1.109 ufs_inode.c --- ufs/ufs_inode.c 23 Feb 2020 15:46:43 -0000 1.109 +++ ufs/ufs_inode.c 11 Apr 2020 00:13:05 -0000 @@ -308,7 +308,7 @@ if (error) goto out; - error = UFS_TRUNCATE(vp, newsize, 0, cred); + error = UFS_TRUNCATE(vp, newsize, IO_EXT, cred); UFS_WAPBL_END(mp); if (error != 0 && error != EAGAIN)