*
* %sccs.include.redist.c%
*
- * @(#)ffs_alloc.c 7.20 (Berkeley) %G%
+ * @(#)ffs_alloc.c 7.30 (Berkeley) %G%
*/
-#include "param.h"
-#include "systm.h"
-#include "buf.h"
-#include "user.h"
-#include "vnode.h"
-#include "kernel.h"
-#include "syslog.h"
-#include "cmap.h"
-#include "../ufs/quota.h"
-#include "../ufs/inode.h"
-#include "../ufs/fs.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/kernel.h>
+#include <sys/syslog.h>
-extern u_long hashalloc();
-extern ino_t ialloccg();
-extern daddr_t alloccg();
-extern daddr_t alloccgblk();
-extern daddr_t fragextend();
-extern daddr_t blkpref();
-extern daddr_t mapsearch();
-extern int inside[], around[];
-extern unsigned char *fragtbl[];
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+
+#include <ufs/ffs/fs.h>
+#include <ufs/ffs/ffs_extern.h>
+
+extern u_long nextgennumber;
+
+static daddr_t ffs_alloccg __P((struct inode *, int, daddr_t, int));
+static daddr_t ffs_alloccgblk __P((struct fs *, struct cg *, daddr_t));
+static ino_t ffs_dirpref __P((struct fs *));
+static daddr_t ffs_fragextend __P((struct inode *, int, long, int, int));
+static void ffs_fserr __P((struct fs *, u_int, char *));
+static u_long ffs_hashalloc
+ __P((struct inode *, int, long, int, u_long (*)()));
+static ino_t ffs_ialloccg __P((struct inode *, int, daddr_t, int));
+static daddr_t ffs_mapsearch __P((struct fs *, struct cg *, daddr_t, int));
/*
* Allocate a block in the file system.
* 2) quadradically rehash into other cylinder groups, until an
* available block is located.
*/
-alloc(ip, lbn, bpref, size, bnp)
+ffs_alloc(ip, lbn, bpref, size, bnp)
register struct inode *ip;
daddr_t lbn, bpref;
int size;
register struct fs *fs;
register struct buf *bp;
int cg, error;
- struct ucred *cred = u.u_cred; /* XXX */
+ struct ucred *cred = curproc->p_ucred; /* XXX */
*bnp = 0;
fs = ip->i_fs;
if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) {
printf("dev = 0x%x, bsize = %d, size = %d, fs = %s\n",
ip->i_dev, fs->fs_bsize, size, fs->fs_fsmnt);
- panic("alloc: bad size");
+ panic("ffs_alloc: bad size");
}
if (size == fs->fs_bsize && fs->fs_cstotal.cs_nbfree == 0)
goto nospace;
cg = itog(fs, ip->i_number);
else
cg = dtog(fs, bpref);
- bno = (daddr_t)hashalloc(ip, cg, (long)bpref, size,
- (u_long (*)())alloccg);
+ bno = (daddr_t)ffs_hashalloc(ip, cg, (long)bpref, size,
+ (u_long (*)())ffs_alloccg);
if (bno > 0) {
ip->i_blocks += btodb(size);
ip->i_flag |= IUPD|ICHG;
*bnp = bno;
return (0);
}
+#ifdef QUOTA
+ /*
+ * Restore user's disk quota because allocation failed.
+ */
+ (void) chkdq(ip, (long)-btodb(size), cred, FORCE);
+#endif
nospace:
- fserr(fs, cred->cr_uid, "file system full");
+ ffs_fserr(fs, cred->cr_uid, "file system full");
uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);
return (ENOSPC);
}
* the original block. Failing that, the regular block allocator is
* invoked to get an appropriate block.
*/
-realloccg(ip, lbprev, bpref, osize, nsize, bpp)
+ffs_realloccg(ip, lbprev, bpref, osize, nsize, bpp)
register struct inode *ip;
off_t lbprev;
daddr_t bpref;
{
register struct fs *fs;
struct buf *bp, *obp;
- int cg, request;
- daddr_t bprev, bno, bn;
- int i, error, count;
- struct ucred *cred = u.u_cred; /* XXX */
+ int cg, request, error;
+ daddr_t bprev, bno;
+ struct ucred *cred = curproc->p_ucred; /* XXX */
*bpp = 0;
fs = ip->i_fs;
if ((unsigned)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
(unsigned)nsize > fs->fs_bsize || fragoff(fs, nsize) != 0) {
- printf("dev = 0x%x, bsize = %d, osize = %d, nsize = %d, fs = %s\n",
+ printf(
+ "dev = 0x%x, bsize = %d, osize = %d, nsize = %d, fs = %s\n",
ip->i_dev, fs->fs_bsize, osize, nsize, fs->fs_fsmnt);
- panic("realloccg: bad size");
+ panic("ffs_realloccg: bad size");
}
if (cred->cr_uid != 0 && freespace(fs, fs->fs_minfree) <= 0)
goto nospace;
if ((bprev = ip->i_db[lbprev]) == 0) {
printf("dev = 0x%x, bsize = %d, bprev = %d, fs = %s\n",
ip->i_dev, fs->fs_bsize, bprev, fs->fs_fsmnt);
- panic("realloccg: bad bprev");
+ panic("ffs_realloccg: bad bprev");
}
-#ifdef QUOTA
- if (error = chkdq(ip, (long)btodb(nsize - osize), cred, 0))
- return (error);
-#endif
/*
* Allocate the extra space in the buffer.
*/
brelse(bp);
return (error);
}
- brealloc(bp, nsize);
- bp->b_flags |= B_DONE;
- bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize);
+#ifdef QUOTA
+ if (error = chkdq(ip, (long)btodb(nsize - osize), cred, 0)) {
+ brelse(bp);
+ return (error);
+ }
+#endif
/*
* Check for extension in the existing location.
*/
cg = dtog(fs, bprev);
- if (bno = fragextend(ip, cg, (long)bprev, osize, nsize)) {
+ if (bno = ffs_fragextend(ip, cg, (long)bprev, osize, nsize)) {
if (bp->b_blkno != fsbtodb(fs, bno))
panic("bad blockno");
ip->i_blocks += btodb(nsize - osize);
ip->i_flag |= IUPD|ICHG;
+ allocbuf(bp, nsize);
+ bp->b_flags |= B_DONE;
+ bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize);
*bpp = bp;
return (0);
}
break;
case FS_OPTTIME:
/*
- * At this point we have discovered a file that is trying
- * to grow a small fragment to a larger fragment. To save
- * time, we allocate a full sized block, then free the
- * unused portion. If the file continues to grow, the
- * `fragextend' call above will be able to grow it in place
- * without further copying. If aberrant programs cause
- * disk fragmentation to grow within 2% of the free reserve,
- * we choose to begin optimizing for space.
+ * At this point we have discovered a file that is trying to
+ * grow a small fragment to a larger fragment. To save time,
+ * we allocate a full sized block, then free the unused portion.
+ * If the file continues to grow, the `ffs_fragextend' call
+ * above will be able to grow it in place without further
+ * copying. If aberrant programs cause disk fragmentation to
+ * grow within 2% of the free reserve, we choose to begin
+ * optimizing for space.
*/
request = fs->fs_bsize;
if (fs->fs_cstotal.cs_nffree <
default:
printf("dev = 0x%x, optim = %d, fs = %s\n",
ip->i_dev, fs->fs_optim, fs->fs_fsmnt);
- panic("realloccg: bad optim");
+ panic("ffs_realloccg: bad optim");
/* NOTREACHED */
}
- bno = (daddr_t)hashalloc(ip, cg, (long)bpref, request,
- (u_long (*)())alloccg);
+ bno = (daddr_t)ffs_hashalloc(ip, cg, (long)bpref, request,
+ (u_long (*)())ffs_alloccg);
if (bno > 0) {
#ifdef SECSIZE
obp = bread(ip->i_dev, fsbtodb(fs, bprev), osize,
fs->fs_dbsize);
#else SECSIZE
- bp->b_blkno = bn = fsbtodb(fs, bno);
count = howmany(osize, CLBYTES);
for (i = 0; i < count; i++)
#ifdef SECSIZE
#else SECSIZE
munhash(ip->i_dev, bn + i * CLBYTES / DEV_BSIZE);
#endif SECSIZE
- blkfree(ip, bprev, (off_t)osize);
+ ffs_blkfree(ip, bprev, (off_t)osize);
if (nsize < request)
- blkfree(ip, bno + numfrags(fs, nsize),
- (off_t)(request - nsize));
+ ffs_blkfree(ip, bno + numfrags(fs, nsize),
+ (off_t)(request - nsize));
ip->i_blocks += btodb(nsize - osize);
ip->i_flag |= IUPD|ICHG;
+ allocbuf(bp, nsize);
+ bp->b_flags |= B_DONE;
+ bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize);
*bpp = bp;
return (0);
}
+#ifdef QUOTA
+ /*
+ * Restore user's disk quota because allocation failed.
+ */
+ (void) chkdq(ip, (long)-btodb(nsize - osize), cred, FORCE);
+#endif
brelse(bp);
nospace:
/*
* no space available
*/
- fserr(fs, cred->cr_uid, "file system full");
+ ffs_fserr(fs, cred->cr_uid, "file system full");
uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);
return (ENOSPC);
}
/*
* Allocate an inode in the file system.
*
- * A preference may be optionally specified. If a preference is given
- * the following hierarchy is used to allocate an inode:
- * 1) allocate the requested inode.
+ * If allocating a directory, use ffs_dirpref to select the inode.
+ * If allocating in a directory, the following hierarchy is followed:
+ * 1) allocate the preferred inode.
* 2) allocate an inode in the same cylinder group.
* 3) quadradically rehash into other cylinder groups, until an
* available inode is located.
* 2) quadradically rehash into other cylinder groups, until an
* available inode is located.
*/
-ialloc(pip, ipref, mode, cred, ipp)
- register struct inode *pip;
- ino_t ipref;
+ffs_valloc(pvp, mode, cred, vpp)
+ register struct vnode *pvp;
int mode;
struct ucred *cred;
- struct inode **ipp;
+ struct vnode **vpp;
{
- ino_t ino;
+ register struct inode *pip;
register struct fs *fs;
register struct inode *ip;
+ ino_t ino, ipref;
int cg, error;
- *ipp = 0;
+ *vpp = NULL;
+ pip = VTOI(pvp);
fs = pip->i_fs;
if (fs->fs_cstotal.cs_nifree == 0)
goto noinodes;
+
+ if ((mode & IFMT) == IFDIR)
+ ipref = ffs_dirpref(fs);
+ else
+ ipref = pip->i_number;
if (ipref >= fs->fs_ncg * fs->fs_ipg)
ipref = 0;
cg = itog(fs, ipref);
- ino = (ino_t)hashalloc(pip, cg, (long)ipref, mode, ialloccg);
+ ino = (ino_t)ffs_hashalloc(pip, cg, (long)ipref, mode, ffs_ialloccg);
if (ino == 0)
goto noinodes;
- error = iget(pip, ino, ipp);
+ error = ffs_vget(pvp->v_mount, ino, vpp);
if (error) {
- ifree(pip, ino, mode);
+ ffs_vfree(pvp, ino, mode);
return (error);
}
- ip = *ipp;
+ ip = VTOI(*vpp);
if (ip->i_mode) {
printf("mode = 0%o, inum = %d, fs = %s\n",
ip->i_mode, ip->i_number, fs->fs_fsmnt);
- panic("ialloc: dup alloc");
+ panic("ffs_valloc: dup alloc");
}
if (ip->i_blocks) { /* XXX */
printf("free inode %s/%d had %d blocks\n",
ip->i_gen = nextgennumber;
return (0);
noinodes:
- fserr(fs, cred->cr_uid, "out of inodes");
+ ffs_fserr(fs, cred->cr_uid, "out of inodes");
uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);
return (ENOSPC);
}
* among those cylinder groups with above the average number of
* free inodes, the one with the smallest number of directories.
*/
-ino_t
-dirpref(fs)
+static ino_t
+ffs_dirpref(fs)
register struct fs *fs;
{
int cg, minndir, mincg, avgifree;
* schedule another I/O transfer.
*/
daddr_t
-blkpref(ip, lbn, indx, bap)
+ffs_blkpref(ip, lbn, indx, bap)
struct inode *ip;
daddr_t lbn;
int indx;
* 3) brute force search for a free block.
*/
/*VARARGS5*/
-u_long
-hashalloc(ip, cg, pref, size, allocator)
+static u_long
+ffs_hashalloc(ip, cg, pref, size, allocator)
struct inode *ip;
int cg;
long pref;
* Check to see if the necessary fragments are available, and
* if they are, allocate them.
*/
-daddr_t
-fragextend(ip, cg, bprev, osize, nsize)
+static daddr_t
+ffs_fragextend(ip, cg, bprev, osize, nsize)
struct inode *ip;
int cg;
long bprev;
fs->fs_cstotal.cs_nffree--;
fs->fs_cs(fs, cg).cs_nffree--;
}
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
bdwrite(bp);
return (bprev);
}
* Check to see if a block of the apprpriate size is available,
* and if it is, allocate it.
*/
-daddr_t
-alloccg(ip, cg, bpref, size)
+static daddr_t
+ffs_alloccg(ip, cg, bpref, size)
struct inode *ip;
int cg;
daddr_t bpref;
}
cgp->cg_time = time.tv_sec;
if (size == fs->fs_bsize) {
- bno = alloccgblk(fs, cgp, bpref);
+ bno = ffs_alloccgblk(fs, cgp, bpref);
bdwrite(bp);
return (bno);
}
brelse(bp);
return (NULL);
}
- bno = alloccgblk(fs, cgp, bpref);
+ bno = ffs_alloccgblk(fs, cgp, bpref);
bpref = dtogd(fs, bno);
for (i = frags; i < fs->fs_frag; i++)
setbit(cg_blksfree(cgp), bpref + i);
cgp->cg_cs.cs_nffree += i;
fs->fs_cstotal.cs_nffree += i;
fs->fs_cs(fs, cg).cs_nffree += i;
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
cgp->cg_frsum[i]++;
bdwrite(bp);
return (bno);
}
- bno = mapsearch(fs, cgp, bpref, allocsiz);
+ bno = ffs_mapsearch(fs, cgp, bpref, allocsiz);
if (bno < 0) {
brelse(bp);
return (NULL);
cgp->cg_cs.cs_nffree -= frags;
fs->fs_cstotal.cs_nffree -= frags;
fs->fs_cs(fs, cg).cs_nffree -= frags;
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
cgp->cg_frsum[allocsiz]--;
if (frags != allocsiz)
cgp->cg_frsum[allocsiz - frags]++;
* Note that this routine only allocates fs_bsize blocks; these
* blocks may be fragmented by the routine that allocates them.
*/
-daddr_t
-alloccgblk(fs, cgp, bpref)
+static daddr_t
+ffs_alloccgblk(fs, cgp, bpref)
register struct fs *fs;
register struct cg *cgp;
daddr_t bpref;
/*
* if the requested block is available, use it
*/
- if (isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bpref))) {
+ if (ffs_isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bpref))) {
bno = bpref;
goto gotit;
}
if (fs_postbl(fs, pos)[i] == -1) {
printf("pos = %d, i = %d, fs = %s\n",
pos, i, fs->fs_fsmnt);
- panic("alloccgblk: cyl groups corrupted");
+ panic("ffs_alloccgblk: cyl groups corrupted");
}
for (i = fs_postbl(fs, pos)[i];; ) {
- if (isblock(fs, cg_blksfree(cgp), bno + i)) {
+ if (ffs_isblock(fs, cg_blksfree(cgp), bno + i)) {
bno = blkstofrags(fs, (bno + i));
goto gotit;
}
i += delta;
}
printf("pos = %d, i = %d, fs = %s\n", pos, i, fs->fs_fsmnt);
- panic("alloccgblk: can't find blk in cyl");
+ panic("ffs_alloccgblk: can't find blk in cyl");
}
norot:
/*
* no blocks in the requested cylinder, so take next
* available one in this cylinder group.
*/
- bno = mapsearch(fs, cgp, bpref, (int)fs->fs_frag);
+ bno = ffs_mapsearch(fs, cgp, bpref, (int)fs->fs_frag);
if (bno < 0)
return (NULL);
cgp->cg_rotor = bno;
gotit:
- clrblock(fs, cg_blksfree(cgp), (long)fragstoblks(fs, bno));
+ ffs_clrblock(fs, cg_blksfree(cgp), (long)fragstoblks(fs, bno));
cgp->cg_cs.cs_nbfree--;
fs->fs_cstotal.cs_nbfree--;
fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
cylno = cbtocylno(fs, bno);
cg_blks(fs, cgp, cylno)[cbtorpos(fs, bno)]--;
cg_blktot(cgp)[cylno]--;
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
return (cgp->cg_cgx * fs->fs_fpg + bno);
}
* 2) allocate the next available inode after the requested
* inode in the specified cylinder group.
*/
-ino_t
-ialloccg(ip, cg, ipref, mode)
+static ino_t
+ffs_ialloccg(ip, cg, ipref, mode)
struct inode *ip;
int cg;
daddr_t ipref;
if (loc == 0) {
printf("cg = %s, irotor = %d, fs = %s\n",
cg, cgp->cg_irotor, fs->fs_fsmnt);
- panic("ialloccg: map corrupted");
+ panic("ffs_ialloccg: map corrupted");
/* NOTREACHED */
}
}
}
}
printf("fs = %s\n", fs->fs_fsmnt);
- panic("ialloccg: block not in map");
+ panic("ffs_ialloccg: block not in map");
/* NOTREACHED */
gotit:
setbit(cg_inosused(cgp), ipref);
cgp->cg_cs.cs_nifree--;
fs->fs_cstotal.cs_nifree--;
fs->fs_cs(fs, cg).cs_nifree--;
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
if ((mode & IFMT) == IFDIR) {
cgp->cg_cs.cs_ndir++;
fs->fs_cstotal.cs_ndir++;
* free map. If a fragment is deallocated, a possible
* block reassembly is checked.
*/
-blkfree(ip, bno, size)
+ffs_blkfree(ip, bno, size)
register struct inode *ip;
daddr_t bno;
off_t size;
struct buf *bp;
int error, cg, blk, frags, bbase;
register int i;
- struct ucred *cred = u.u_cred; /* XXX */
+ struct ucred *cred = curproc->p_ucred; /* XXX */
fs = ip->i_fs;
if ((unsigned)size > fs->fs_bsize || fragoff(fs, size) != 0) {
cg = dtog(fs, bno);
if ((unsigned)bno >= fs->fs_size) {
printf("bad block %d, ino %d\n", bno, ip->i_number);
- fserr(fs, cred->cr_uid, "bad block");
+ ffs_fserr(fs, cred->cr_uid, "bad block");
return;
}
#ifdef SECSIZE
cgp->cg_time = time.tv_sec;
bno = dtogd(fs, bno);
if (size == fs->fs_bsize) {
- if (isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno))) {
+ if (ffs_isblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno))) {
printf("dev = 0x%x, block = %d, fs = %s\n",
ip->i_dev, bno, fs->fs_fsmnt);
panic("blkfree: freeing free block");
}
- setblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno));
+ ffs_setblock(fs, cg_blksfree(cgp), fragstoblks(fs, bno));
cgp->cg_cs.cs_nbfree++;
fs->fs_cstotal.cs_nbfree++;
fs->fs_cs(fs, cg).cs_nbfree++;
* decrement the counts associated with the old frags
*/
blk = blkmap(fs, cg_blksfree(cgp), bbase);
- fragacct(fs, blk, cgp->cg_frsum, -1);
+ ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
/*
* deallocate the fragment
*/
* add back in counts associated with the new frags
*/
blk = blkmap(fs, cg_blksfree(cgp), bbase);
- fragacct(fs, blk, cgp->cg_frsum, 1);
+ ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
/*
* if a complete block has been reassembled, account for it
*/
- if (isblock(fs, cg_blksfree(cgp),
+ if (ffs_isblock(fs, cg_blksfree(cgp),
(daddr_t)fragstoblks(fs, bbase))) {
cgp->cg_cs.cs_nffree -= fs->fs_frag;
fs->fs_cstotal.cs_nffree -= fs->fs_frag;
cg_blktot(cgp)[i]++;
}
}
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
bdwrite(bp);
}
*
* The specified inode is placed back in the free map.
*/
-ifree(ip, ino, mode)
- struct inode *ip;
+void
+ffs_vfree(pvp, ino, mode)
+ struct vnode *pvp;
ino_t ino;
int mode;
{
register struct fs *fs;
register struct cg *cgp;
+ register struct inode *pip;
struct buf *bp;
int error, cg;
- fs = ip->i_fs;
- if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg) {
- printf("dev = 0x%x, ino = %d, fs = %s\n",
- ip->i_dev, ino, fs->fs_fsmnt);
- panic("ifree: range");
- }
+ pip = VTOI(pvp);
+ fs = pip->i_fs;
+ if ((u_int)ino >= fs->fs_ipg * fs->fs_ncg)
+ panic("ifree: range: dev = 0x%x, ino = %d, fs = %s\n",
+ pip->i_dev, ino, fs->fs_fsmnt);
cg = itog(fs, ino);
#ifdef SECSIZE
bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize,
fs->fs_dbsize);
#else SECSIZE
- error = bread(ip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
+ error = bread(pip->i_devvp, fsbtodb(fs, cgtod(fs, cg)),
(int)fs->fs_cgsize, NOCRED, &bp);
if (error) {
brelse(bp);
ino %= fs->fs_ipg;
if (isclr(cg_inosused(cgp), ino)) {
printf("dev = 0x%x, ino = %d, fs = %s\n",
- ip->i_dev, ino, fs->fs_fsmnt);
- panic("ifree: freeing free inode");
+ pip->i_dev, ino, fs->fs_fsmnt);
+ if (fs->fs_ronly == 0)
+ panic("ifree: freeing free inode");
}
clrbit(cg_inosused(cgp), ino);
if (ino < cgp->cg_irotor)
fs->fs_cstotal.cs_ndir--;
fs->fs_cs(fs, cg).cs_ndir--;
}
- fs->fs_fmod++;
+ fs->fs_fmod = 1;
bdwrite(bp);
}
* It is a panic if a request is made to find a block if none are
* available.
*/
-daddr_t
-mapsearch(fs, cgp, bpref, allocsiz)
+static daddr_t
+ffs_mapsearch(fs, cgp, bpref, allocsiz)
register struct fs *fs;
register struct cg *cgp;
daddr_t bpref;
if (loc == 0) {
printf("start = %d, len = %d, fs = %s\n",
start, len, fs->fs_fsmnt);
- panic("alloccg: map corrupted");
+ panic("ffs_alloccg: map corrupted");
/* NOTREACHED */
}
}
}
}
printf("bno = %d, fs = %s\n", bno, fs->fs_fsmnt);
- panic("alloccg: block not in map");
+ panic("ffs_alloccg: block not in map");
return (-1);
}
* The form of the error message is:
* fs: error message
*/
-fserr(fs, uid, cp)
+static void
+ffs_fserr(fs, uid, cp)
struct fs *fs;
- uid_t uid;
+ u_int uid;
char *cp;
{