sys/vfs/ufs/ffs_balloc.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)ffs_balloc.c        8.8 (Berkeley) 6/16/95
  34  * $FreeBSD: src/sys/ufs/ffs/ffs_balloc.c,v 1.26.2.1 2002/10/10 19:48:20 dillon Exp $
  35  * $DragonFly: src/sys/vfs/ufs/ffs_balloc.c,v 1.11 2004/08/24 16:32:11 drhodus Exp $
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/proc.h>
  41 #include <sys/buf.h>
  42 #include <sys/lock.h>
  43 #include <sys/mount.h>
  44 #include <sys/vnode.h>
  45
  46 #include "quota.h"
  47 #include "inode.h"
  48 #include "ufs_extern.h"
  49
  50 #include "fs.h"
  51 #include "ffs_extern.h"
  52
  53 /*
  54  * Balloc defines the structure of filesystem storage
  55  * by allocating the physical blocks on a device given
  56  * the inode and the logical block number in a file.
  57  *
  58  * ffs_balloc(struct vnode *a_vp, ufs_daddr_t a_lbn, int a_size,
  59  *            struct ucred *a_cred, int a_flags, struct buf *a_bpp)
  60  */
  61 int
  62 ffs_balloc(struct vop_balloc_args *ap)
  63 {
  64         struct inode *ip;
  65         ufs_daddr_t lbn;
  66         int size;
  67         struct ucred *cred;
  68         int flags;
  69         struct fs *fs;
  70         ufs_daddr_t nb;
  71         struct buf *bp, *nbp;
  72         struct vnode *vp;
  73         struct indir indirs[NIADDR + 2];
  74         ufs_daddr_t newb, *bap, pref;
  75         int deallocated, osize, nsize, num, i, error;
  76         ufs_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1];
  77         int unwindidx = -1;
  78         struct thread *td = curthread;  /* XXX */
  79
  80         vp = ap->a_vp;
  81         ip = VTOI(vp);
  82         fs = ip->i_fs;
  83         lbn = lblkno(fs, ap->a_startoffset);
  84         size = blkoff(fs, ap->a_startoffset) + ap->a_size;
  85         if (size > fs->fs_bsize)
  86                 panic("ffs_balloc: blk too big");
  87         *ap->a_bpp = NULL;
  88         if (lbn < 0)
  89                 return (EFBIG);
  90         cred = ap->a_cred;
  91         flags = ap->a_flags;
  92
  93         /*
  94          * If the next write will extend the file into a new block,
  95          * and the file is currently composed of a fragment
  96          * this fragment has to be extended to be a full block.
  97          */
  98         nb = lblkno(fs, ip->i_size);
  99         if (nb < NDADDR && nb < lbn) {
 100                 /*
 101                  * The filesize prior to this write can fit in direct
 102                  * blocks (ex. fragmentation is possibly done)
 103                  * we are now extending the file write beyond
 104                  * the block which has end of the file prior to this write.
 105                  */
 106                 osize = blksize(fs, ip, nb);
 107                 /*
 108                  * osize gives disk allocated size in the last block. It is
 109                  * either in fragments or a file system block size.
 110                  */
 111                 if (osize < fs->fs_bsize && osize > 0) {
 112                         /* A few fragments are already allocated, since the
 113                          * current extends beyond this block allocated the
 114                          * complete block as fragments are on in last block.
 115                          */
 116                         error = ffs_realloccg(ip, nb,
 117                                 ffs_blkpref(ip, nb, (int)nb, &ip->i_db[0]),
 118                                 osize, (int)fs->fs_bsize, cred, &bp);
 119                         if (error)
 120                                 return (error);
 121                         if (DOINGSOFTDEP(vp))
 122                                 softdep_setup_allocdirect(ip, nb,
 123                                     dbtofsb(fs, bp->b_blkno), ip->i_db[nb],
 124                                     fs->fs_bsize, osize, bp);
 125                         /* adjust the inode size, we just grew */
 126                         ip->i_size = smalllblktosize(fs, nb + 1);
 127                         ip->i_db[nb] = dbtofsb(fs, bp->b_blkno);
 128                         ip->i_flag |= IN_CHANGE | IN_UPDATE;
 129                         if (flags & B_SYNC)
 130                                 bwrite(bp);
 131                         else
 132                                 bawrite(bp);
 133                         /* bp is already released here */
 134                 }
 135         }
 136         /*
 137          * The first NDADDR blocks are direct blocks
 138          */
 139         if (lbn < NDADDR) {
 140                 nb = ip->i_db[lbn];
 141                 if (nb != 0 && ip->i_size >= smalllblktosize(fs, lbn + 1)) {
 142                         error = bread(vp, lbn, fs->fs_bsize, &bp);
 143                         if (error) {
 144                                 brelse(bp);
 145                                 return (error);
 146                         }
 147                         bp->b_blkno = fsbtodb(fs, nb);
 148                         *ap->a_bpp = bp;
 149                         return (0);
 150                 }
 151                 if (nb != 0) {
 152                         /*
 153                          * Consider need to reallocate a fragment.
 154                          */
 155                         osize = fragroundup(fs, blkoff(fs, ip->i_size));
 156                         nsize = fragroundup(fs, size);
 157                         if (nsize <= osize) {
 158                                 error = bread(vp, lbn, osize, &bp);
 159                                 if (error) {
 160                                         brelse(bp);
 161                                         return (error);
 162                                 }
 163                                 bp->b_blkno = fsbtodb(fs, nb);
 164                         } else {
 165                                 error = ffs_realloccg(ip, lbn,
 166                                     ffs_blkpref(ip, lbn, (int)lbn,
 167                                         &ip->i_db[0]), osize, nsize, cred, &bp);
 168                                 if (error)
 169                                         return (error);
 170                                 if (DOINGSOFTDEP(vp))
 171                                         softdep_setup_allocdirect(ip, lbn,
 172                                             dbtofsb(fs, bp->b_blkno), nb,
 173                                             nsize, osize, bp);
 174                         }
 175                 } else {
 176                         if (ip->i_size < smalllblktosize(fs, lbn + 1))
 177                                 nsize = fragroundup(fs, size);
 178                         else
 179                                 nsize = fs->fs_bsize;
 180                         error = ffs_alloc(ip, lbn,
 181                             ffs_blkpref(ip, lbn, (int)lbn, &ip->i_db[0]),
 182                             nsize, cred, &newb);
 183                         if (error)
 184                                 return (error);
 185                         bp = getblk(vp, lbn, nsize, 0, 0);
 186                         bp->b_blkno = fsbtodb(fs, newb);
 187                         if (flags & B_CLRBUF)
 188                                 vfs_bio_clrbuf(bp);
 189                         if (DOINGSOFTDEP(vp))
 190                                 softdep_setup_allocdirect(ip, lbn, newb, 0,
 191                                     nsize, 0, bp);
 192                 }
 193                 ip->i_db[lbn] = dbtofsb(fs, bp->b_blkno);
 194                 ip->i_flag |= IN_CHANGE | IN_UPDATE;
 195                 *ap->a_bpp = bp;
 196                 return (0);
 197         }
 198         /*
 199          * Determine the number of levels of indirection.
 200          */
 201         pref = 0;
 202         if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0)
 203                 return(error);
 204 #ifdef DIAGNOSTIC
 205         if (num < 1)
 206                 panic ("ffs_balloc: ufs_bmaparray returned indirect block");
 207 #endif
 208         /*
 209          * Fetch the first indirect block allocating if necessary.
 210          */
 211         --num;
 212         nb = ip->i_ib[indirs[0].in_off];
 213         allocib = NULL;
 214         allocblk = allociblk;
 215         if (nb == 0) {
 216                 pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0);
 217                 if ((error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
 218                     cred, &newb)) != 0)
 219                         return (error);
 220                 nb = newb;
 221                 *allocblk++ = nb;
 222                 bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
 223                 bp->b_blkno = fsbtodb(fs, nb);
 224                 vfs_bio_clrbuf(bp);
 225                 if (DOINGSOFTDEP(vp)) {
 226                         softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
 227                             newb, 0, fs->fs_bsize, 0, bp);
 228                         bdwrite(bp);
 229                 } else {
 230                         /*
 231                          * Write synchronously so that indirect blocks
 232                          * never point at garbage.
 233                          */
 234                         if (DOINGASYNC(vp))
 235                                 bdwrite(bp);
 236                         else if ((error = bwrite(bp)) != 0)
 237                                 goto fail;
 238                 }
 239                 allocib = &ip->i_ib[indirs[0].in_off];
 240                 *allocib = nb;
 241                 ip->i_flag |= IN_CHANGE | IN_UPDATE;
 242         }
 243         /*
 244          * Fetch through the indirect blocks, allocating as necessary.
 245          */
 246         for (i = 1;;) {
 247                 error = bread(vp, indirs[i].in_lbn, (int)fs->fs_bsize, &bp);
 248                 if (error) {
 249                         brelse(bp);
 250                         goto fail;
 251                 }
 252                 bap = (ufs_daddr_t *)bp->b_data;
 253                 nb = bap[indirs[i].in_off];
 254                 if (i == num)
 255                         break;
 256                 i += 1;
 257                 if (nb != 0) {
 258                         bqrelse(bp);
 259                         continue;
 260                 }
 261                 if (pref == 0)
 262                         pref = ffs_blkpref(ip, lbn, 0, (ufs_daddr_t *)0);
 263                 if ((error =
 264                     ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred, &newb)) != 0) {
 265                         brelse(bp);
 266                         goto fail;
 267                 }
 268                 nb = newb;
 269                 *allocblk++ = nb;
 270                 nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
 271                 nbp->b_blkno = fsbtodb(fs, nb);
 272                 vfs_bio_clrbuf(nbp);
 273                 if (DOINGSOFTDEP(vp)) {
 274                         softdep_setup_allocindir_meta(nbp, ip, bp,
 275                             indirs[i - 1].in_off, nb);
 276                         bdwrite(nbp);
 277                 } else {
 278                         /*
 279                          * Write synchronously so that indirect blocks
 280                          * never point at garbage.
 281                          */
 282                         if ((error = bwrite(nbp)) != 0) {
 283                                 brelse(bp);
 284                                 goto fail;
 285                         }
 286                 }
 287                 bap[indirs[i - 1].in_off] = nb;
 288                 if (allocib == NULL && unwindidx < 0)
 289                         unwindidx = i - 1;
 290                 /*
 291                  * If required, write synchronously, otherwise use
 292                  * delayed write.
 293                  */
 294                 if (flags & B_SYNC) {
 295                         bwrite(bp);
 296                 } else {
 297                         if (bp->b_bufsize == fs->fs_bsize)
 298                                 bp->b_flags |= B_CLUSTEROK;
 299                         bdwrite(bp);
 300                 }
 301         }
 302         /*
 303          * Get the data block, allocating if necessary.
 304          */
 305         if (nb == 0) {
 306                 pref = ffs_blkpref(ip, lbn, indirs[i].in_off, &bap[0]);
 307                 error = ffs_alloc(ip,
 308                     lbn, pref, (int)fs->fs_bsize, cred, &newb);
 309                 if (error) {
 310                         brelse(bp);
 311                         goto fail;
 312                 }
 313                 nb = newb;
 314                 *allocblk++ = nb;
 315                 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
 316                 nbp->b_blkno = fsbtodb(fs, nb);
 317                 if (flags & B_CLRBUF)
 318                         vfs_bio_clrbuf(nbp);
 319                 if (DOINGSOFTDEP(vp))
 320                         softdep_setup_allocindir_page(ip, lbn, bp,
 321                             indirs[i].in_off, nb, 0, nbp);
 322                 bap[indirs[i].in_off] = nb;
 323                 /*
 324                  * If required, write synchronously, otherwise use
 325                  * delayed write.
 326                  */
 327                 if (flags & B_SYNC) {
 328                         bwrite(bp);
 329                 } else {
 330                         if (bp->b_bufsize == fs->fs_bsize)
 331                                 bp->b_flags |= B_CLUSTEROK;
 332                         bdwrite(bp);
 333                 }
 334                 *ap->a_bpp = nbp;
 335                 return (0);
 336         }
 337         brelse(bp);
 338         /*
 339          * If requested clear invalid portions of the buffer.  If we
 340          * have to do a read-before-write (typical if B_CLRBUF is set),
 341          * try to do some read-ahead in the sequential case to reduce
 342          * the number of I/O transactions.
 343          */
 344         if (flags & B_CLRBUF) {
 345                 int seqcount = (flags & B_SEQMASK) >> B_SEQSHIFT;
 346                 if (seqcount &&
 347                     (vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
 348                         error = cluster_read(vp, ip->i_size, lbn,
 349                                     (int)fs->fs_bsize,
 350                                     MAXBSIZE, seqcount, &nbp);
 351                 } else {
 352                         error = bread(vp, lbn, (int)fs->fs_bsize, &nbp);
 353                 }
 354                 if (error) {
 355                         brelse(nbp);
 356                         goto fail;
 357                 }
 358         } else {
 359                 nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
 360                 nbp->b_blkno = fsbtodb(fs, nb);
 361         }
 362         *ap->a_bpp = nbp;
 363         return (0);
 364 fail:
 365         /*
 366          * If we have failed part way through block allocation, we
 367          * have to deallocate any indirect blocks that we have allocated.
 368          * We have to fsync the file before we start to get rid of all
 369          * of its dependencies so that we do not leave them dangling.
 370          * We have to sync it at the end so that the soft updates code
 371          * does not find any untracked changes. Although this is really
 372          * slow, running out of disk space is not expected to be a common
 373          * occurence. The error return from fsync is ignored as we already
 374          * have an error to return to the user.
 375          */
 376         (void) VOP_FSYNC(vp, MNT_WAIT, td);
 377         for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) {
 378                 ffs_blkfree(ip, *blkp, fs->fs_bsize);
 379                 deallocated += fs->fs_bsize;
 380         }
 381         if (allocib != NULL) {
 382                 *allocib = 0;
 383         } else if (unwindidx >= 0) {
 384                 int r;
 385
 386                 r = bread(vp, indirs[unwindidx].in_lbn, (int)fs->fs_bsize, &bp);
 387                 if (r) {
 388                         panic("Could not unwind indirect block, error %d", r);
 389                         brelse(bp);
 390                 } else {
 391                         bap = (ufs_daddr_t *)bp->b_data;
 392                         bap[indirs[unwindidx].in_off] = 0;
 393                         if (flags & B_SYNC) {
 394                                 bwrite(bp);
 395                         } else {
 396                                 if (bp->b_bufsize == fs->fs_bsize)
 397                                         bp->b_flags |= B_CLUSTEROK;
 398                                 bdwrite(bp);
 399                         }
 400                 }
 401         }
 402         if (deallocated) {
 403 #ifdef QUOTA
 404                 /*
 405                  * Restore user's disk quota because allocation failed.
 406                  */
 407                 (void) chkdq(ip, (long)-btodb(deallocated), cred, FORCE);
 408 #endif
 409                 ip->i_blocks -= btodb(deallocated);
 410                 ip->i_flag |= IN_CHANGE | IN_UPDATE;
 411         }
 412         (void) VOP_FSYNC(vp, MNT_WAIT, td);
 413         return (error);
 414 }