projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lint; checkoverlap code is conditional on DIAGNOSTIC
[unix-history] / usr / src / sys / ufs / lfs / lfs_balloc.c
diff --git a/usr/src/sys/ufs/lfs/lfs_balloc.c b/usr/src/sys/ufs/lfs/lfs_balloc.c
index 5f90878..48f9eb9 100644 (file)
--- a/usr/src/sys/ufs/lfs/lfs_balloc.c
+++ b/usr/src/sys/ufs/lfs/lfs_balloc.c
@@ -1,45 +1,131 @@
-/*     lfs_balloc.c    5.2     82/09/25        */
+/*
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *     @(#)lfs_balloc.c        7.9 (Berkeley) %G%
+ */
 
 
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/conf.h"
-#include "../h/inode.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/buf.h"
-#include "../h/proc.h"
-#include "../h/fs.h"
+#include "param.h"
+#include "systm.h"
+#include "user.h"
+#include "buf.h"
+#include "proc.h"
+#include "file.h"
+#include "vnode.h"
+#include "../ufs/quota.h"
+#include "../ufs/inode.h"
+#include "../ufs/fs.h"
 
 /*
  * Bmap defines the structure of file system storage
 
 /*
  * Bmap defines the structure of file system storage
- * by returning the physical block number on a device given the
- * inode and the logical block number in a file.
- * When convenient, it also leaves the physical
- * block number of the next block of the file in rablock
- * for use in read-ahead.
+ * by returning the physical block number on a device
+ * given the inode and the logical block number in a file.
  */
  */
-/*VARARGS3*/
-daddr_t
-bmap(ip, bn, rwflg, size)
+bmap(ip, bn, bnp)
        register struct inode *ip;
        register struct inode *ip;
-       daddr_t bn;
-       int rwflg;
-       int size;       /* supplied only when rwflg == B_WRITE */
+       register daddr_t bn;
+       daddr_t *bnp;
 {
 {
-       register int i;
-       int osize, nsize;
-       struct buf *bp, *nbp;
-       struct fs *fs;
-       int j, sh;
-       daddr_t nb, lbn, *bap, pref, blkpref();
+       register struct fs *fs;
+       register daddr_t nb;
+       struct buf *bp;
+       daddr_t *bap;
+       int i, j, sh;
+       int error;
 
 
-       if (bn < 0) {
-               u.u_error = EFBIG;
-               return ((daddr_t)0);
+       if (bn < 0)
+               return (EFBIG);
+       fs = ip->i_fs;
+
+       /*
+        * The first NDADDR blocks are direct blocks
+        */
+       if (bn < NDADDR) {
+               nb = ip->i_db[bn];
+               if (nb == 0) {
+                       *bnp = (daddr_t)-1;
+                       return (0);
+               }
+               *bnp = fsbtodb(fs, nb);
+               return (0);
+       }
+       /*
+        * Determine the number of levels of indirection.
+        */
+       sh = 1;
+       bn -= NDADDR;
+       for (j = NIADDR; j > 0; j--) {
+               sh *= NINDIR(fs);
+               if (bn < sh)
+                       break;
+               bn -= sh;
+       }
+       if (j == 0)
+               return (EFBIG);
+       /*
+        * Fetch through the indirect blocks.
+        */
+       nb = ip->i_ib[NIADDR - j];
+       if (nb == 0) {
+               *bnp = (daddr_t)-1;
+               return (0);
+       }
+       for (; j <= NIADDR; j++) {
+               if (error = bread(ip->i_devvp, fsbtodb(fs, nb),
+                   (int)fs->fs_bsize, NOCRED, &bp)) {
+                       brelse(bp);
+                       return (error);
+               }
+               bap = bp->b_un.b_daddr;
+               sh /= NINDIR(fs);
+               i = (bn / sh) % NINDIR(fs);
+               nb = bap[i];
+               if (nb == 0) {
+                       *bnp = (daddr_t)-1;
+                       brelse(bp);
+                       return (0);
+               }
+               brelse(bp);
        }
        }
+       *bnp = fsbtodb(fs, nb);
+       return (0);
+}
+
+/*
+ * Balloc defines the structure of file system storage
+ * by allocating the physical blocks on a device given
+ * the inode and the logical block number in a file.
+ */
+balloc(ip, bn, size, bpp, flags)
+       register struct inode *ip;
+       register daddr_t bn;
+       int size;
+       struct buf **bpp;
+       int flags;
+{
+       register struct fs *fs;
+       register daddr_t nb;
+       struct buf *bp, *nbp;
+       struct vnode *vp = ITOV(ip);
+       int osize, nsize, i, j, sh, error;
+       daddr_t newb, lbn, *bap, pref, blkpref();
+
+       *bpp = (struct buf *)0;
+       if (bn < 0)
+               return (EFBIG);
        fs = ip->i_fs;
        fs = ip->i_fs;
-       rablock = 0;
-       rasize = 0;             /* conservative */
 
        /*
         * If the next write will extend the file into a new block,
 
        /*
         * If the next write will extend the file into a new block,
@@ -47,16 +133,21 @@ bmap(ip, bn, rwflg, size)
         * this fragment has to be extended to be a full block.
         */
        nb = lblkno(fs, ip->i_size);
         * this fragment has to be extended to be a full block.
         */
        nb = lblkno(fs, ip->i_size);
-       if (rwflg == B_WRITE && nb < NDADDR && nb < bn) {
+       if (nb < NDADDR && nb < bn) {
                osize = blksize(fs, ip, nb);
                if (osize < fs->fs_bsize && osize > 0) {
                osize = blksize(fs, ip, nb);
                if (osize < fs->fs_bsize && osize > 0) {
-                       bp = realloccg(ip, ip->i_db[nb],
-                               blkpref(ip, nb, nb, &ip->i_db[0]),
-                               osize, fs->fs_bsize);
+                       error = realloccg(ip, nb,
+                               blkpref(ip, nb, (int)nb, &ip->i_db[0]),
+                               osize, (int)fs->fs_bsize, &bp);
+                       if (error)
+                               return (error);
                        ip->i_size = (nb + 1) * fs->fs_bsize;
                        ip->i_db[nb] = dbtofsb(fs, bp->b_blkno);
                        ip->i_flag |= IUPD|ICHG;
                        ip->i_size = (nb + 1) * fs->fs_bsize;
                        ip->i_db[nb] = dbtofsb(fs, bp->b_blkno);
                        ip->i_flag |= IUPD|ICHG;
-                       bdwrite(bp);
+                       if (flags & B_SYNC)
+                               bwrite(bp);
+                       else
+                               bawrite(bp);
                }
        }
        /*
                }
        }
        /*
@@ -64,142 +155,188 @@ bmap(ip, bn, rwflg, size)
         */
        if (bn < NDADDR) {
                nb = ip->i_db[bn];
         */
        if (bn < NDADDR) {
                nb = ip->i_db[bn];
-               if (rwflg == B_READ) {
-                       if (nb == 0)
-                               return ((daddr_t)-1);
-                       goto gotit;
+               if (nb != 0 && ip->i_size >= (bn + 1) * fs->fs_bsize) {
+                       error = bread(vp, bn, fs->fs_bsize, NOCRED, &bp);
+                       if (error) {
+                               brelse(bp);
+                               return (error);
+                       }
+                       *bpp = bp;
+                       return (0);
                }
                }
-               if (nb == 0 || ip->i_size < (bn + 1) * fs->fs_bsize) {
-                       if (nb != 0) {
-                               /* consider need to reallocate a frag */
-                               osize = fragroundup(fs, blkoff(fs, ip->i_size));
-                               nsize = fragroundup(fs, size);
-                               if (nsize <= osize)
-                                       goto gotit;
-                               bp = realloccg(ip, nb,
-                                       blkpref(ip, bn, bn, &ip->i_db[0]),
-                                       osize, nsize);
+               if (nb != 0) {
+                       /*
+                        * Consider need to reallocate a fragment.
+                        */
+                       osize = fragroundup(fs, blkoff(fs, ip->i_size));
+                       nsize = fragroundup(fs, size);
+                       if (nsize <= osize) {
+                               error = bread(vp, bn, osize, NOCRED, &bp);
+                               if (error) {
+                                       brelse(bp);
+                                       return (error);
+                               }
                        } else {
                        } else {
-                               if (ip->i_size < (bn + 1) * fs->fs_bsize)
-                                       nsize = fragroundup(fs, size);
-                               else
-                                       nsize = fs->fs_bsize;
-                               bp = alloc(ip,
-                                       blkpref(ip, bn, bn, &ip->i_db[0]),
-                                       nsize);
+                               error = realloccg(ip, bn,
+                                       blkpref(ip, bn, (int)bn, &ip->i_db[0]),
+                                       osize, nsize, &bp);
+                               if (error)
+                                       return (error);
                        }
                        }
-                       if (bp == NULL)
-                               return ((daddr_t)-1);
-                       nb = dbtofsb(fs, bp->b_blkno);
-                       if ((ip->i_mode&IFMT) == IFDIR)
-                               /*
-                                * Write directory blocks synchronously
-                                * so they never appear with garbage in
-                                * them on the disk.
-                                */
-                               bwrite(bp);
+               } else {
+                       if (ip->i_size < (bn + 1) * fs->fs_bsize)
+                               nsize = fragroundup(fs, size);
                        else
                        else
-                               bdwrite(bp);
-                       ip->i_db[bn] = nb;
-                       ip->i_flag |= IUPD|ICHG;
+                               nsize = fs->fs_bsize;
+                       error = alloc(ip, bn,
+                               blkpref(ip, bn, (int)bn, &ip->i_db[0]),
+                               nsize, &newb);
+                       if (error)
+                               return (error);
+                       bp = getblk(vp, bn, nsize);
+                       bp->b_blkno = fsbtodb(fs, newb);
+                       if (flags & B_CLRBUF)
+                               clrbuf(bp);
                }
                }
-gotit:
-               if (bn < NDADDR - 1) {
-                       rablock = fsbtodb(fs, ip->i_db[bn + 1]);
-                       rasize = blksize(fs, ip, bn + 1);
-               }
-               return (nb);
+               ip->i_db[bn] = dbtofsb(fs, bp->b_blkno);
+               ip->i_flag |= IUPD|ICHG;
+               *bpp = bp;
+               return (0);
        }
        }
-
        /*
        /*
-        * Determine how many levels of indirection.
+        * Determine the number of levels of indirection.
         */
        pref = 0;
        sh = 1;
        lbn = bn;
        bn -= NDADDR;
         */
        pref = 0;
        sh = 1;
        lbn = bn;
        bn -= NDADDR;
-       for (j = NIADDR; j>0; j--) {
+       for (j = NIADDR; j > 0; j--) {
                sh *= NINDIR(fs);
                if (bn < sh)
                        break;
                bn -= sh;
        }
                sh *= NINDIR(fs);
                if (bn < sh)
                        break;
                bn -= sh;
        }
-       if (j == 0) {
-               u.u_error = EFBIG;
-               return ((daddr_t)0);
-       }
-
+       if (j == 0)
+               return (EFBIG);
        /*
        /*
-        * fetch the first indirect block
+        * Fetch the first indirect block allocating if necessary.
         */
        nb = ip->i_ib[NIADDR - j];
        if (nb == 0) {
         */
        nb = ip->i_ib[NIADDR - j];
        if (nb == 0) {
-               if (rwflg == B_READ)
-                       return ((daddr_t)-1);
-               pref = blkpref(ip, lbn, 0, 0);
-               bp = alloc(ip, pref, fs->fs_bsize);
-               if (bp == NULL)
-                       return ((daddr_t)-1);
-               nb = dbtofsb(fs, bp->b_blkno);
+               pref = blkpref(ip, lbn, 0, (daddr_t *)0);
+               if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb))
+                       return (error);
+               nb = newb;
+               bp = getblk(ip->i_devvp, fsbtodb(fs, nb), fs->fs_bsize);
+               clrbuf(bp);
                /*
                 * Write synchronously so that indirect blocks
                 * never point at garbage.
                 */
                /*
                 * Write synchronously so that indirect blocks
                 * never point at garbage.
                 */
-               bwrite(bp);
+               if (error = bwrite(bp)) {
+                       blkfree(ip, nb, fs->fs_bsize);
+                       return (error);
+               }
                ip->i_ib[NIADDR - j] = nb;
                ip->i_flag |= IUPD|ICHG;
        }
                ip->i_ib[NIADDR - j] = nb;
                ip->i_flag |= IUPD|ICHG;
        }
-
        /*
        /*
-        * fetch through the indirect blocks
+        * Fetch through the indirect blocks, allocating as necessary.
         */
         */
-       for (; j <= NIADDR; j++) {
-               bp = bread(ip->i_dev, fsbtodb(fs, nb), fs->fs_bsize);
-               if (bp->b_flags & B_ERROR) {
+       for (; ; j++) {
+               error = bread(ip->i_devvp, fsbtodb(fs, nb),
+                   (int)fs->fs_bsize, NOCRED, &bp);
+               if (error) {
                        brelse(bp);
                        brelse(bp);
-                       return ((daddr_t)0);
+                       return (error);
                }
                bap = bp->b_un.b_daddr;
                sh /= NINDIR(fs);
                i = (bn / sh) % NINDIR(fs);
                nb = bap[i];
                }
                bap = bp->b_un.b_daddr;
                sh /= NINDIR(fs);
                i = (bn / sh) % NINDIR(fs);
                nb = bap[i];
-               if (nb == 0) {
-                       if (rwflg==B_READ) {
-                               brelse(bp);
-                               return ((daddr_t)-1);
-                       }
-                       if (pref == 0)
-                               if (j < NIADDR)
-                                       pref = blkpref(ip, lbn, 0, 0);
-                               else
-                                       pref = blkpref(ip, lbn, i, &bap[0]);
-                       nbp = alloc(ip, pref, fs->fs_bsize);
-                       if (nbp == NULL) {
-                               brelse(bp);
-                               return ((daddr_t)-1);
-                       }
-                       nb = dbtofsb(fs, nbp->b_blkno);
-                       if (j < NIADDR || (ip->i_mode&IFMT) == IFDIR)
-                               /*
-                                * Write synchronously so indirect blocks
-                                * never point at garbage and blocks
-                                * in directories never contain garbage.
-                                */
-                               bwrite(nbp);
-                       else
-                               bdwrite(nbp);
-                       bap[i] = nb;
-                       bdwrite(bp);
-               } else
+               if (j == NIADDR)
+                       break;
+               if (nb != 0) {
+                       brelse(bp);
+                       continue;
+               }
+               if (pref == 0)
+                       pref = blkpref(ip, lbn, 0, (daddr_t *)0);
+               if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb)) {
                        brelse(bp);
                        brelse(bp);
+                       return (error);
+               }
+               nb = newb;
+               nbp = getblk(ip->i_devvp, fsbtodb(fs, nb), fs->fs_bsize);
+               clrbuf(nbp);
+               /*
+                * Write synchronously so that indirect blocks
+                * never point at garbage.
+                */
+               if (error = bwrite(nbp)) {
+                       blkfree(ip, nb, fs->fs_bsize);
+                       brelse(bp);
+                       return (error);
+               }
+               bap[i] = nb;
+               /*
+                * If required, write synchronously, otherwise use
+                * delayed write. If this is the first instance of
+                * the delayed write, reassociate the buffer with the
+                * file so it will be written if the file is sync'ed.
+                */
+               if (flags & B_SYNC) {
+                       bwrite(bp);
+               } else if (bp->b_flags & B_DELWRI) {
+                       bdwrite(bp);
+               } else {
+                       bdwrite(bp);
+                       reassignbuf(bp, vp);
+               }
        }
        }
-
        /*
        /*
-        * calculate read-ahead.
+        * Get the data block, allocating if necessary.
         */
         */
-       if (i < NINDIR(fs) - 1) {
-               rablock = fsbtodb(fs, bap[i+1]);
-               rasize = fs->fs_bsize;
+       if (nb == 0) {
+               pref = blkpref(ip, lbn, i, &bap[0]);
+               if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb)) {
+                       brelse(bp);
+                       return (error);
+               }
+               nb = newb;
+               nbp = getblk(vp, lbn, fs->fs_bsize);
+               nbp->b_blkno = fsbtodb(fs, nb);
+               if (flags & B_CLRBUF)
+                       clrbuf(nbp);
+               bap[i] = nb;
+               /*
+                * If required, write synchronously, otherwise use
+                * delayed write. If this is the first instance of
+                * the delayed write, reassociate the buffer with the
+                * file so it will be written if the file is sync'ed.
+                */
+               if (flags & B_SYNC) {
+                       bwrite(bp);
+               } else if (bp->b_flags & B_DELWRI) {
+                       bdwrite(bp);
+               } else {
+                       bdwrite(bp);
+                       reassignbuf(bp, vp);
+               }
+               *bpp = nbp;
+               return (0);
+       }
+       brelse(bp);
+       if (flags & B_CLRBUF) {
+               error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
+               if (error) {
+                       brelse(nbp);
+                       return (error);
+               }
+       } else {
+               nbp = getblk(vp, lbn, fs->fs_bsize);
+               nbp->b_blkno = fsbtodb(fs, nb);
        }
        }
-       return (nb);
+       *bpp = nbp;
+       return (0);
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.