19404f5f5Smckusick /*
2b6149518Sbostic * Copyright (c) 1989, 1991, 1993
3b6149518Sbostic * The Regents of the University of California. All rights reserved.
49404f5f5Smckusick *
5dd22d480Sbostic * %sccs.include.redist.c%
63c0618ecSmckusick *
7*7c5a2ee6Smckusick * @(#)lfs_balloc.c 8.4 (Berkeley) 05/08/95
89404f5f5Smckusick */
993a16c77Sbostic #include <sys/param.h>
1093a16c77Sbostic #include <sys/buf.h>
1193a16c77Sbostic #include <sys/proc.h>
1293a16c77Sbostic #include <sys/vnode.h>
1393a16c77Sbostic #include <sys/mount.h>
1493a16c77Sbostic #include <sys/resourcevar.h>
1593a16c77Sbostic #include <sys/trace.h>
1626a59bf8Skarels
175cf619c8Smckusick #include <miscfs/specfs/specdev.h>
185cf619c8Smckusick
19dc73499dSbostic #include <ufs/ufs/quota.h>
20dc73499dSbostic #include <ufs/ufs/inode.h>
21dc73499dSbostic #include <ufs/ufs/ufsmount.h>
2293a16c77Sbostic
23dc73499dSbostic #include <ufs/lfs/lfs.h>
24dc73499dSbostic #include <ufs/lfs/lfs_extern.h>
25e6ecc35eSroot
2692b50907Sbostic int
lfs_balloc(vp,offset,iosize,lbn,bpp)2701979c5aSmckusick lfs_balloc(vp, offset, iosize, lbn, bpp)
2892b50907Sbostic struct vnode *vp;
2901979c5aSmckusick int offset;
3092b50907Sbostic u_long iosize;
316b8e5290Smckusick ufs_daddr_t lbn;
3292b50907Sbostic struct buf **bpp;
3392b50907Sbostic {
34efd5f688Smargo struct buf *ibp, *bp;
3592b50907Sbostic struct inode *ip;
3692b50907Sbostic struct lfs *fs;
37efd5f688Smargo struct indir indirs[NIADDR+2];
38*7c5a2ee6Smckusick ufs_daddr_t daddr, lastblock;
3901979c5aSmckusick int bb; /* number of disk blocks in a block disk blocks */
4001979c5aSmckusick int error, frags, i, nsize, osize, num;
4192b50907Sbostic
4292b50907Sbostic ip = VTOI(vp);
4392b50907Sbostic fs = ip->i_lfs;
4492b50907Sbostic
4592b50907Sbostic /*
4692b50907Sbostic * Three cases: it's a block beyond the end of file, it's a block in
4792b50907Sbostic * the file that may or may not have been assigned a disk address or
4892b50907Sbostic * we're writing an entire block. Note, if the daddr is unassigned,
49efd5f688Smargo * the block might still have existed in the cache (if it was read
50efd5f688Smargo * or written earlier). If it did, make sure we don't count it as a
51efd5f688Smargo * new block or zero out its contents. If it did not, make sure
52efd5f688Smargo * we allocate any necessary indirect blocks.
5301979c5aSmckusick * If we are writing a block beyond the end of the file, we need to
5401979c5aSmckusick * check if the old last block was a fragment. If it was, we need
5501979c5aSmckusick * to rewrite it.
5692b50907Sbostic */
5738533b9bSbostic
5838533b9bSbostic *bpp = NULL;
59efd5f688Smargo if (error = ufs_bmaparray(vp, lbn, &daddr, &indirs[0], &num, NULL ))
6092b50907Sbostic return (error);
6192b50907Sbostic
6201979c5aSmckusick /* Check for block beyond end of file and fragment extension needed. */
6301979c5aSmckusick lastblock = lblkno(fs, ip->i_size);
6401979c5aSmckusick if (lastblock < NDADDR && lastblock < lbn) {
6501979c5aSmckusick osize = blksize(fs, ip, lastblock);
6601979c5aSmckusick if (osize < fs->lfs_bsize && osize > 0) {
6701979c5aSmckusick if (error = lfs_fragextend(vp, osize, fs->lfs_bsize,
6801979c5aSmckusick lastblock, &bp))
6901979c5aSmckusick return(error);
7001979c5aSmckusick ip->i_size = (lastblock + 1) * fs->lfs_bsize;
7101979c5aSmckusick vnode_pager_setsize(vp, (u_long)ip->i_size);
7201979c5aSmckusick ip->i_flag |= IN_CHANGE | IN_UPDATE;
7301979c5aSmckusick VOP_BWRITE(bp);
7401979c5aSmckusick }
7501979c5aSmckusick }
7601979c5aSmckusick
77efd5f688Smargo bb = VFSTOUFS(vp->v_mount)->um_seqinc;
78efd5f688Smargo if (daddr == UNASSIGNED)
79efd5f688Smargo /* May need to allocate indirect blocks */
80efd5f688Smargo for (i = 1; i < num; ++i)
81efd5f688Smargo if (!indirs[i].in_exists) {
8201979c5aSmckusick ibp = getblk(vp, indirs[i].in_lbn, fs->lfs_bsize,
835a834517Smckusick 0, 0);
8401979c5aSmckusick if ((ibp->b_flags & (B_DONE | B_DELWRI)))
8501979c5aSmckusick panic ("Indirect block should not exist");
8601979c5aSmckusick
87efd5f688Smargo if (!ISSPACE(fs, bb, curproc->p_ucred)){
88efd5f688Smargo ibp->b_flags |= B_INVAL;
89efd5f688Smargo brelse(ibp);
9001979c5aSmckusick return(ENOSPC);
91efd5f688Smargo } else {
92efd5f688Smargo ip->i_blocks += bb;
93efd5f688Smargo ip->i_lfs->lfs_bfree -= bb;
94efd5f688Smargo clrbuf(ibp);
9501979c5aSmckusick if(error = VOP_BWRITE(ibp))
96efd5f688Smargo return(error);
97efd5f688Smargo }
9801979c5aSmckusick }
99efd5f688Smargo
10001979c5aSmckusick /*
10101979c5aSmckusick * If the block we are writing is a direct block, it's the last
10201979c5aSmckusick * block in the file, and offset + iosize is less than a full
10301979c5aSmckusick * block, we can write one or more fragments. There are two cases:
10401979c5aSmckusick * the block is brand new and we should allocate it the correct
10501979c5aSmckusick * size or it already exists and contains some fragments and
10601979c5aSmckusick * may need to extend it.
10701979c5aSmckusick */
10801979c5aSmckusick if (lbn < NDADDR && lblkno(fs, ip->i_size) == lbn) {
10901979c5aSmckusick nsize = fragroundup(fs, offset + iosize);
11001979c5aSmckusick frags = numfrags(fs, nsize);
11101979c5aSmckusick bb = fragstodb(fs, frags);
11201979c5aSmckusick if (lblktosize(fs, lbn) == ip->i_size)
11301979c5aSmckusick /* Brand new block or fragment */
11401979c5aSmckusick *bpp = bp = getblk(vp, lbn, nsize, 0, 0);
11501979c5aSmckusick else {
11601979c5aSmckusick /* Extend existing block */
11701979c5aSmckusick if (error = lfs_fragextend(vp, (int)blksize(fs, ip, lbn),
11801979c5aSmckusick nsize, lbn, &bp))
11901979c5aSmckusick return(error);
12001979c5aSmckusick *bpp = bp;
12101979c5aSmckusick }
12201979c5aSmckusick } else {
12301979c5aSmckusick /*
12401979c5aSmckusick * Get the existing block from the cache either because the
12501979c5aSmckusick * block is 1) not a direct block or because it's not the last
12601979c5aSmckusick * block in the file.
12701979c5aSmckusick */
12801979c5aSmckusick frags = dbtofrags(fs, bb);
12901979c5aSmckusick *bpp = bp = getblk(vp, lbn, blksize(fs, ip, lbn), 0, 0);
13001979c5aSmckusick }
131efd5f688Smargo
13201979c5aSmckusick /*
13301979c5aSmckusick * The block we are writing may be a brand new block
13401979c5aSmckusick * in which case we need to do accounting (i.e. check
13501979c5aSmckusick * for free space and update the inode number of blocks.
13601979c5aSmckusick */
137efd5f688Smargo if (!(bp->b_flags & (B_CACHE | B_DONE | B_DELWRI))) {
138efd5f688Smargo if (daddr == UNASSIGNED)
139efd5f688Smargo if (!ISSPACE(fs, bb, curproc->p_ucred)) {
140d7a077dcSmargo bp->b_flags |= B_INVAL;
141d7a077dcSmargo brelse(bp);
142d7a077dcSmargo return(ENOSPC);
143efd5f688Smargo } else {
144d7a077dcSmargo ip->i_blocks += bb;
145efd5f688Smargo ip->i_lfs->lfs_bfree -= bb;
14692b50907Sbostic if (iosize != fs->lfs_bsize)
14792b50907Sbostic clrbuf(bp);
14892b50907Sbostic }
149efd5f688Smargo else if (iosize == fs->lfs_bsize)
15001979c5aSmckusick /* Optimization: I/O is unnecessary. */
15101979c5aSmckusick bp->b_blkno = daddr;
152efd5f688Smargo else {
15301979c5aSmckusick /*
15401979c5aSmckusick * We need to read the block to preserve the
15501979c5aSmckusick * existing bytes.
15601979c5aSmckusick */
157efd5f688Smargo bp->b_blkno = daddr;
15808d10bb7Smargo bp->b_flags |= B_READ;
159efd5f688Smargo VOP_STRATEGY(bp);
1602eb24d0aSmargo return(biowait(bp));
16192b50907Sbostic }
162efd5f688Smargo }
16301979c5aSmckusick return (0);
16401979c5aSmckusick }
16501979c5aSmckusick
16601979c5aSmckusick lfs_fragextend(vp, osize, nsize, lbn, bpp)
16701979c5aSmckusick struct vnode *vp;
16801979c5aSmckusick int osize;
16901979c5aSmckusick int nsize;
17001979c5aSmckusick daddr_t lbn;
17101979c5aSmckusick struct buf **bpp;
17201979c5aSmckusick {
17301979c5aSmckusick struct inode *ip;
17401979c5aSmckusick struct lfs *fs;
17501979c5aSmckusick long bb;
17601979c5aSmckusick int error;
17701979c5aSmckusick
17801979c5aSmckusick ip = VTOI(vp);
17901979c5aSmckusick fs = ip->i_lfs;
18001979c5aSmckusick bb = (long)fragstodb(fs, numfrags(fs, nsize - osize));
18101979c5aSmckusick if (!ISSPACE(fs, bb, curproc->p_ucred)) {
18201979c5aSmckusick return(ENOSPC);
18301979c5aSmckusick }
18401979c5aSmckusick
18501979c5aSmckusick if (error = bread(vp, lbn, osize, NOCRED, bpp)) {
18601979c5aSmckusick brelse(*bpp);
187efd5f688Smargo return(error);
18892b50907Sbostic }
18901979c5aSmckusick #ifdef QUOTA
19001979c5aSmckusick if (error = chkdq(ip, bb, curproc->p_ucred, 0)) {
19101979c5aSmckusick brelse(*bpp);
19201979c5aSmckusick return (error);
19301979c5aSmckusick }
19401979c5aSmckusick #endif
19501979c5aSmckusick ip->i_blocks += bb;
19601979c5aSmckusick ip->i_flag |= IN_CHANGE | IN_UPDATE;
19701979c5aSmckusick fs->lfs_bfree -= fragstodb(fs, numfrags(fs, (nsize - osize)));
19801979c5aSmckusick allocbuf(*bpp, nsize);
19901979c5aSmckusick bzero((char *)((*bpp)->b_data) + osize, (u_int)(nsize - osize));
20001979c5aSmckusick return(0);
20101979c5aSmckusick }
202