1*913768d6Sjoerg /* $NetBSD: lfs.c,v 1.75 2020/04/03 19:36:33 joerg Exp $ */
2ba10361aSperseant /*-
3ba10361aSperseant * Copyright (c) 2003 The NetBSD Foundation, Inc.
4ba10361aSperseant * All rights reserved.
5ba10361aSperseant *
6ba10361aSperseant * This code is derived from software contributed to The NetBSD Foundation
7ba10361aSperseant * by Konrad E. Schroder <perseant@hhhh.org>.
8ba10361aSperseant *
9ba10361aSperseant * Redistribution and use in source and binary forms, with or without
10ba10361aSperseant * modification, are permitted provided that the following conditions
11ba10361aSperseant * are met:
12ba10361aSperseant * 1. Redistributions of source code must retain the above copyright
13ba10361aSperseant * notice, this list of conditions and the following disclaimer.
14ba10361aSperseant * 2. Redistributions in binary form must reproduce the above copyright
15ba10361aSperseant * notice, this list of conditions and the following disclaimer in the
16ba10361aSperseant * documentation and/or other materials provided with the distribution.
17ba10361aSperseant *
18ba10361aSperseant * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
19ba10361aSperseant * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20ba10361aSperseant * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21ba10361aSperseant * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
22ba10361aSperseant * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23ba10361aSperseant * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24ba10361aSperseant * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25ba10361aSperseant * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26ba10361aSperseant * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27ba10361aSperseant * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28ba10361aSperseant * POSSIBILITY OF SUCH DAMAGE.
29ba10361aSperseant */
30ba10361aSperseant /*
31ba10361aSperseant * Copyright (c) 1989, 1991, 1993
32ba10361aSperseant * The Regents of the University of California. All rights reserved.
33ba10361aSperseant * (c) UNIX System Laboratories, Inc.
34ba10361aSperseant * All or some portions of this file are derived from material licensed
35ba10361aSperseant * to the University of California by American Telephone and Telegraph
36ba10361aSperseant * Co. or Unix System Laboratories, Inc. and are reproduced herein with
37ba10361aSperseant * the permission of UNIX System Laboratories, Inc.
38ba10361aSperseant *
39ba10361aSperseant * Redistribution and use in source and binary forms, with or without
40ba10361aSperseant * modification, are permitted provided that the following conditions
41ba10361aSperseant * are met:
42ba10361aSperseant * 1. Redistributions of source code must retain the above copyright
43ba10361aSperseant * notice, this list of conditions and the following disclaimer.
44ba10361aSperseant * 2. Redistributions in binary form must reproduce the above copyright
45ba10361aSperseant * notice, this list of conditions and the following disclaimer in the
46ba10361aSperseant * documentation and/or other materials provided with the distribution.
47276d62f6Sagc * 3. Neither the name of the University nor the names of its contributors
48ba10361aSperseant * may be used to endorse or promote products derived from this software
49ba10361aSperseant * without specific prior written permission.
50ba10361aSperseant *
51ba10361aSperseant * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
52ba10361aSperseant * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53ba10361aSperseant * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54ba10361aSperseant * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
55ba10361aSperseant * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
56ba10361aSperseant * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
57ba10361aSperseant * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58ba10361aSperseant * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
59ba10361aSperseant * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
60ba10361aSperseant * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61ba10361aSperseant * SUCH DAMAGE.
62ba10361aSperseant *
63ba10361aSperseant * @(#)ufs_bmap.c 8.8 (Berkeley) 8/11/95
64ba10361aSperseant */
65ba10361aSperseant
66ba10361aSperseant
67ba10361aSperseant #include <sys/types.h>
68ba10361aSperseant #include <sys/param.h>
69ba10361aSperseant #include <sys/time.h>
70ba10361aSperseant #include <sys/buf.h>
71ba10361aSperseant #include <sys/mount.h>
72ba10361aSperseant
73f5ac0b5fSdholland #define vnode uvnode
74ba10361aSperseant #include <ufs/lfs/lfs.h>
7579e35bebSdholland #include <ufs/lfs/lfs_inode.h>
76fec5e985Sdholland #include <ufs/lfs/lfs_accessors.h>
77ba10361aSperseant #undef vnode
78ba10361aSperseant
79ba10361aSperseant #include <assert.h>
80ba10361aSperseant #include <err.h>
81ba10361aSperseant #include <errno.h>
82ba10361aSperseant #include <stdarg.h>
831845f5a8Sriastradh #include <stdbool.h>
84ba10361aSperseant #include <stdio.h>
85ba10361aSperseant #include <stdlib.h>
86ba10361aSperseant #include <string.h>
87ba10361aSperseant #include <unistd.h>
88b6479e9fSchristos #include <util.h>
89ba10361aSperseant
90ba10361aSperseant #include "bufcache.h"
91*913768d6Sjoerg #include "extern.h"
92100801edSchristos #include "lfs_user.h"
93ba10361aSperseant #include "segwrite.h"
94709a4d5bSpooka #include "kernelops.h"
95ba10361aSperseant
96ba10361aSperseant #define panic call_panic
97ba10361aSperseant
98d3dff438Smlelstv long dev_bsize = DEV_BSIZE;
9979748725Smlelstv
10029f1062bSperseant static int
10129f1062bSperseant lfs_fragextend(struct uvnode *, int, int, daddr_t, struct ubuf **);
10229f1062bSperseant
103ba10361aSperseant int fsdirty = 0;
10417c417f1Sdholland void (*panic_func)(int, const char *, va_list) = my_vpanic;
105ba10361aSperseant
106ba10361aSperseant /*
107ba10361aSperseant * LFS buffer and uvnode operations
108ba10361aSperseant */
109ba10361aSperseant
110ba10361aSperseant int
lfs_vop_strategy(struct ubuf * bp)111ba10361aSperseant lfs_vop_strategy(struct ubuf * bp)
112ba10361aSperseant {
113ba10361aSperseant int count;
114ba10361aSperseant
115ba10361aSperseant if (bp->b_flags & B_READ) {
116709a4d5bSpooka count = kops.ko_pread(bp->b_vp->v_fd, bp->b_data, bp->b_bcount,
11779748725Smlelstv bp->b_blkno * dev_bsize);
118ba10361aSperseant if (count == bp->b_bcount)
119ba10361aSperseant bp->b_flags |= B_DONE;
120ba10361aSperseant } else {
121709a4d5bSpooka count = kops.ko_pwrite(bp->b_vp->v_fd, bp->b_data, bp->b_bcount,
12279748725Smlelstv bp->b_blkno * dev_bsize);
123ba10361aSperseant if (count == 0) {
124657e8b00Schristos perror("pwrite");
125ba10361aSperseant return -1;
126ba10361aSperseant }
127ba10361aSperseant bp->b_flags &= ~B_DELWRI;
128ba10361aSperseant reassignbuf(bp, bp->b_vp);
129ba10361aSperseant }
130ba10361aSperseant return 0;
131ba10361aSperseant }
132ba10361aSperseant
133ba10361aSperseant int
lfs_vop_bwrite(struct ubuf * bp)134ba10361aSperseant lfs_vop_bwrite(struct ubuf * bp)
135ba10361aSperseant {
136ba10361aSperseant struct lfs *fs;
137ba10361aSperseant
138ba10361aSperseant fs = bp->b_vp->v_fs;
139ba10361aSperseant if (!(bp->b_flags & B_DELWRI)) {
140576195d5Sdholland lfs_sb_subavail(fs, lfs_btofsb(fs, bp->b_bcount));
141ba10361aSperseant }
142ba10361aSperseant bp->b_flags |= B_DELWRI | B_LOCKED;
143ba10361aSperseant reassignbuf(bp, bp->b_vp);
144fe44973fSad brelse(bp, 0);
145ba10361aSperseant return 0;
146ba10361aSperseant }
147ba10361aSperseant
148ba10361aSperseant /*
1494f8bc7f7Sdholland * ulfs_bmaparray does the bmap conversion, and if requested returns the
150ba10361aSperseant * array of logical blocks which must be traversed to get to a block.
151ba10361aSperseant * Each entry contains the offset into that block that gets you to the
152ba10361aSperseant * next block and the disk address of the block (if it is assigned).
153ba10361aSperseant */
154ba10361aSperseant int
ulfs_bmaparray(struct lfs * fs,struct uvnode * vp,daddr_t bn,daddr_t * bnp,struct indir * ap,int * nump)1554f8bc7f7Sdholland ulfs_bmaparray(struct lfs * fs, struct uvnode * vp, daddr_t bn, daddr_t * bnp, struct indir * ap, int *nump)
156ba10361aSperseant {
157ba10361aSperseant struct inode *ip;
158ba10361aSperseant struct ubuf *bp;
1594f8bc7f7Sdholland struct indir a[ULFS_NIADDR + 1], *xap;
160ba10361aSperseant daddr_t daddr;
161ba10361aSperseant daddr_t metalbn;
162ba10361aSperseant int error, num;
163ba10361aSperseant
164ba10361aSperseant ip = VTOI(vp);
165ba10361aSperseant
1664f8bc7f7Sdholland if (bn >= 0 && bn < ULFS_NDADDR) {
167ba10361aSperseant if (nump != NULL)
168ba10361aSperseant *nump = 0;
169f4c19b7cSdholland *bnp = LFS_FSBTODB(fs, lfs_dino_getdb(fs, ip->i_din, bn));
170ba10361aSperseant if (*bnp == 0)
171ba10361aSperseant *bnp = -1;
172ba10361aSperseant return (0);
173ba10361aSperseant }
174ba10361aSperseant xap = ap == NULL ? a : ap;
175ba10361aSperseant if (!nump)
176ba10361aSperseant nump = #
1774f8bc7f7Sdholland if ((error = ulfs_getlbns(fs, vp, bn, xap, nump)) != 0)
178ba10361aSperseant return (error);
179ba10361aSperseant
180ba10361aSperseant num = *nump;
181ba10361aSperseant
182ba10361aSperseant /* Get disk address out of indirect block array */
183f4c19b7cSdholland daddr = lfs_dino_getib(fs, ip->i_din, xap->in_off);
184ba10361aSperseant
185ba10361aSperseant for (bp = NULL, ++xap; --num; ++xap) {
186ba10361aSperseant /* Exit the loop if there is no disk address assigned yet and
187ba10361aSperseant * the indirect block isn't in the cache, or if we were
188ba10361aSperseant * looking for an indirect block and we've found it. */
189ba10361aSperseant
190ba10361aSperseant metalbn = xap->in_lbn;
191ba10361aSperseant if ((daddr == 0 && !incore(vp, metalbn)) || metalbn == bn)
192ba10361aSperseant break;
193ba10361aSperseant /*
194ba10361aSperseant * If we get here, we've either got the block in the cache
195ba10361aSperseant * or we have a disk address for it, go fetch it.
196ba10361aSperseant */
197ba10361aSperseant if (bp)
198fe44973fSad brelse(bp, 0);
199ba10361aSperseant
200ba10361aSperseant xap->in_exists = 1;
201576195d5Sdholland bp = getblk(vp, metalbn, lfs_sb_getbsize(fs));
202ba10361aSperseant
203ba10361aSperseant if (!(bp->b_flags & (B_DONE | B_DELWRI))) {
2049ae6af71Schristos bp->b_blkno = LFS_FSBTODB(fs, daddr);
205ba10361aSperseant bp->b_flags |= B_READ;
206ba10361aSperseant VOP_STRATEGY(bp);
207ba10361aSperseant }
208639239a1Sdholland daddr = lfs_iblock_get(fs, bp->b_data, xap->in_off);
209ba10361aSperseant }
210ba10361aSperseant if (bp)
211fe44973fSad brelse(bp, 0);
212ba10361aSperseant
213639239a1Sdholland daddr = LFS_FSBTODB(fs, daddr);
214ba10361aSperseant *bnp = daddr == 0 ? -1 : daddr;
215ba10361aSperseant return (0);
216ba10361aSperseant }
217ba10361aSperseant
218ba10361aSperseant /*
219ba10361aSperseant * Create an array of logical block number/offset pairs which represent the
220ba10361aSperseant * path of indirect blocks required to access a data block. The first "pair"
221ba10361aSperseant * contains the logical block number of the appropriate single, double or
222ba10361aSperseant * triple indirect block and the offset into the inode indirect block array.
223ba10361aSperseant * Note, the logical block number of the inode single/double/triple indirect
224f4c19b7cSdholland * block appears twice in the array, once with the offset into di_ib and
225ba10361aSperseant * once with the offset into the page itself.
226ba10361aSperseant */
227ba10361aSperseant int
ulfs_getlbns(struct lfs * fs,struct uvnode * vp,daddr_t bn,struct indir * ap,int * nump)2284f8bc7f7Sdholland ulfs_getlbns(struct lfs * fs, struct uvnode * vp, daddr_t bn, struct indir * ap, int *nump)
229ba10361aSperseant {
230ba10361aSperseant daddr_t metalbn, realbn;
231ba10361aSperseant int64_t blockcnt;
232ba10361aSperseant int lbc;
233ba10361aSperseant int i, numlevels, off;
234ba10361aSperseant int lognindir, indir;
235ba10361aSperseant
23649c83b8eSjmc metalbn = 0; /* XXXGCC -Wuninitialized [sh3] */
23749c83b8eSjmc
238ba10361aSperseant if (nump)
239ba10361aSperseant *nump = 0;
240ba10361aSperseant numlevels = 0;
241ba10361aSperseant realbn = bn;
242ba10361aSperseant if (bn < 0)
243ba10361aSperseant bn = -bn;
244ba10361aSperseant
245ba10361aSperseant lognindir = -1;
246958ff91fSdholland for (indir = lfs_sb_getnindir(fs); indir; indir >>= 1)
247ba10361aSperseant ++lognindir;
248ba10361aSperseant
249ba10361aSperseant /* Determine the number of levels of indirection. After this loop is
250ba10361aSperseant * done, blockcnt indicates the number of data blocks possible at the
2514f8bc7f7Sdholland * given level of indirection, and ULFS_NIADDR - i is the number of levels
252ba10361aSperseant * of indirection needed to locate the requested block. */
253ba10361aSperseant
2544f8bc7f7Sdholland bn -= ULFS_NDADDR;
2554f8bc7f7Sdholland for (lbc = 0, i = ULFS_NIADDR;; i--, bn -= blockcnt) {
256ba10361aSperseant if (i == 0)
257ba10361aSperseant return (EFBIG);
258ba10361aSperseant
259ba10361aSperseant lbc += lognindir;
260ba10361aSperseant blockcnt = (int64_t) 1 << lbc;
261ba10361aSperseant
262ba10361aSperseant if (bn < blockcnt)
263ba10361aSperseant break;
264ba10361aSperseant }
265ba10361aSperseant
266ba10361aSperseant /* Calculate the address of the first meta-block. */
2674f8bc7f7Sdholland metalbn = -((realbn >= 0 ? realbn : -realbn) - bn + ULFS_NIADDR - i);
268ba10361aSperseant
269ba10361aSperseant /* At each iteration, off is the offset into the bap array which is an
270ba10361aSperseant * array of disk addresses at the current level of indirection. The
271ba10361aSperseant * logical block number and the offset in that block are stored into
272ba10361aSperseant * the argument array. */
273ba10361aSperseant ap->in_lbn = metalbn;
2744f8bc7f7Sdholland ap->in_off = off = ULFS_NIADDR - i;
275ba10361aSperseant ap->in_exists = 0;
276ba10361aSperseant ap++;
2774f8bc7f7Sdholland for (++numlevels; i <= ULFS_NIADDR; i++) {
278ba10361aSperseant /* If searching for a meta-data block, quit when found. */
279ba10361aSperseant if (metalbn == realbn)
280ba10361aSperseant break;
281ba10361aSperseant
282ba10361aSperseant lbc -= lognindir;
28378a13d74Sdholland /*blockcnt = (int64_t) 1 << lbc;*/
284958ff91fSdholland off = (bn >> lbc) & (lfs_sb_getnindir(fs) - 1);
285ba10361aSperseant
286ba10361aSperseant ++numlevels;
287ba10361aSperseant ap->in_lbn = metalbn;
288ba10361aSperseant ap->in_off = off;
289ba10361aSperseant ap->in_exists = 0;
290ba10361aSperseant ++ap;
291ba10361aSperseant
292ba10361aSperseant metalbn -= -1 + (off << lbc);
293ba10361aSperseant }
294ba10361aSperseant if (nump)
295ba10361aSperseant *nump = numlevels;
296ba10361aSperseant return (0);
297ba10361aSperseant }
298ba10361aSperseant
299ba10361aSperseant int
lfs_vop_bmap(struct uvnode * vp,daddr_t lbn,daddr_t * daddrp)300ba10361aSperseant lfs_vop_bmap(struct uvnode * vp, daddr_t lbn, daddr_t * daddrp)
301ba10361aSperseant {
3024f8bc7f7Sdholland return ulfs_bmaparray(vp->v_fs, vp, lbn, daddrp, NULL, NULL);
303ba10361aSperseant }
304ba10361aSperseant
305ba10361aSperseant /* Search a block for a specific dinode. */
30608d0c37fSdholland union lfs_dinode *
lfs_ifind(struct lfs * fs,ino_t ino,struct ubuf * bp)307ba10361aSperseant lfs_ifind(struct lfs *fs, ino_t ino, struct ubuf *bp)
308ba10361aSperseant {
30908d0c37fSdholland union lfs_dinode *ldip;
31008d0c37fSdholland unsigned i, num;
311ba10361aSperseant
31208d0c37fSdholland num = LFS_INOPB(fs);
313ba10361aSperseant
314ba10361aSperseant /*
315ba10361aSperseant * Read the inode block backwards, since later versions of the
316ba10361aSperseant * inode will supercede earlier ones. Though it is unlikely, it is
317ba10361aSperseant * possible that the same inode will appear in the same inode block.
318ba10361aSperseant */
31908d0c37fSdholland for (i = num; i-- > 0; ) {
32008d0c37fSdholland ldip = DINO_IN_BLOCK(fs, bp->b_data, i);
32108d0c37fSdholland if (lfs_dino_getinumber(fs, ldip) == ino)
322ba10361aSperseant return (ldip);
32308d0c37fSdholland }
324ba10361aSperseant return NULL;
325ba10361aSperseant }
326ba10361aSperseant
327ba10361aSperseant /*
328ba10361aSperseant * lfs_raw_vget makes us a new vnode from the inode at the given disk address.
329ba10361aSperseant * XXX it currently loses atime information.
330ba10361aSperseant */
331ba10361aSperseant struct uvnode *
lfs_raw_vget(struct lfs * fs,ino_t ino,int fd,daddr_t daddr)332247dd330Sdholland lfs_raw_vget(struct lfs * fs, ino_t ino, int fd, daddr_t daddr)
333ba10361aSperseant {
334ba10361aSperseant struct uvnode *vp;
335ba10361aSperseant struct inode *ip;
33608d0c37fSdholland union lfs_dinode *dip;
337ba10361aSperseant struct ubuf *bp;
3381d4cc6a1Sperseant int i, hash;
339ba10361aSperseant
340b6479e9fSchristos vp = ecalloc(1, sizeof(*vp));
341ba10361aSperseant vp->v_fd = fd;
342ba10361aSperseant vp->v_fs = fs;
343ba10361aSperseant vp->v_usecount = 0;
344ba10361aSperseant vp->v_strategy_op = lfs_vop_strategy;
345ba10361aSperseant vp->v_bwrite_op = lfs_vop_bwrite;
346ba10361aSperseant vp->v_bmap_op = lfs_vop_bmap;
347e01ace1fSyamt LIST_INIT(&vp->v_cleanblkhd);
348e01ace1fSyamt LIST_INIT(&vp->v_dirtyblkhd);
349ba10361aSperseant
350b6479e9fSchristos ip = ecalloc(1, sizeof(*ip));
351ba10361aSperseant
35240401aa6Sdholland ip->i_din = dip = ecalloc(1, sizeof(*dip));
35342614ed3Sfvdl
354ba10361aSperseant /* Initialize the inode -- from lfs_vcreate. */
355b6479e9fSchristos ip->inode_ext.lfs = ecalloc(1, sizeof(*ip->inode_ext.lfs));
356ba10361aSperseant vp->v_data = ip;
357ba10361aSperseant /* ip->i_vnode = vp; */
358ba10361aSperseant ip->i_lockf = 0;
359f2b481f7Spgoyette ip->i_state = 0;
360ba10361aSperseant
361ba10361aSperseant /* Load inode block and find inode */
3625d2f3e49Sperseant if (daddr > 0) {
363958ff91fSdholland bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),
3644ec44e9dSchopps 0, &bp);
365ba10361aSperseant bp->b_flags |= B_AGE;
366ba10361aSperseant dip = lfs_ifind(fs, ino, bp);
367ba10361aSperseant if (dip == NULL) {
368fe44973fSad brelse(bp, 0);
369daa5ce77Schristos free(ip->i_din);
370daa5ce77Schristos free(ip->inode_ext.lfs);
371a7f5ddbfSyamt free(ip);
372ba10361aSperseant free(vp);
373ba10361aSperseant return NULL;
374ba10361aSperseant }
37540401aa6Sdholland lfs_copy_dinode(fs, ip->i_din, dip);
376fe44973fSad brelse(bp, 0);
3775d2f3e49Sperseant }
378ba10361aSperseant ip->i_number = ino;
379dcba0206Sperseant /* ip->i_devvp = fs->lfs_devvp; */
380ba10361aSperseant ip->i_lfs = fs;
381ba10361aSperseant
382f4c19b7cSdholland ip->i_lfs_effnblks = lfs_dino_getblocks(fs, ip->i_din);
383f4c19b7cSdholland ip->i_lfs_osize = lfs_dino_getsize(fs, ip->i_din);
384ba10361aSperseant #if 0
385f4c19b7cSdholland if (lfs_sb_getversion(fs) > 1) {
386f4c19b7cSdholland lfs_dino_setatime(fs, ip->i_din, ts.tv_sec);
387f4c19b7cSdholland lfs_dino_setatimensec(fs, ip->i_din, ts.tv_nsec);
388ba10361aSperseant }
389ba10361aSperseant #endif
390ba10361aSperseant
3914f8bc7f7Sdholland memset(ip->i_lfs_fragsize, 0, ULFS_NDADDR * sizeof(*ip->i_lfs_fragsize));
3924f8bc7f7Sdholland for (i = 0; i < ULFS_NDADDR; i++)
393f4c19b7cSdholland if (lfs_dino_getdb(fs, ip->i_din, i) != 0)
3949ae6af71Schristos ip->i_lfs_fragsize[i] = lfs_blksize(fs, ip, i);
395ba10361aSperseant
396a7f5ddbfSyamt ++nvnodes;
3979edc4932Smartin hash = ((int)(intptr_t)fs + ino) & (VNODE_HASH_MAX - 1);
3981d4cc6a1Sperseant LIST_INSERT_HEAD(&getvnodelist[hash], vp, v_getvnodes);
399a7f5ddbfSyamt LIST_INSERT_HEAD(&vnodelist, vp, v_mntvnodes);
400a7f5ddbfSyamt
401ba10361aSperseant return vp;
402ba10361aSperseant }
403ba10361aSperseant
404ba10361aSperseant static struct uvnode *
lfs_vget(void * vfs,ino_t ino)405ba10361aSperseant lfs_vget(void *vfs, ino_t ino)
406ba10361aSperseant {
407ba10361aSperseant struct lfs *fs = (struct lfs *)vfs;
408247dd330Sdholland daddr_t daddr;
409ba10361aSperseant struct ubuf *bp;
410ba10361aSperseant IFILE *ifp;
411ba10361aSperseant
412ba10361aSperseant LFS_IENTRY(ifp, fs, ino, bp);
413daf91f9bSdholland daddr = lfs_if_getdaddr(fs, ifp);
414fe44973fSad brelse(bp, 0);
415958ff91fSdholland if (daddr <= 0 || lfs_dtosn(fs, daddr) >= lfs_sb_getnseg(fs))
416ba10361aSperseant return NULL;
417ba10361aSperseant return lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr);
418ba10361aSperseant }
419ba10361aSperseant
4202b4fdfc6Sdholland /*
4212b4fdfc6Sdholland * Check superblock magic number and checksum.
4222b4fdfc6Sdholland * Sets lfs_is64 and lfs_dobyteswap.
4232b4fdfc6Sdholland */
424ba10361aSperseant static int
check_sb(struct lfs * fs)425ba10361aSperseant check_sb(struct lfs *fs)
426ba10361aSperseant {
427ba10361aSperseant u_int32_t checksum;
428ce7ab97dSdholland u_int32_t magic;
429ba10361aSperseant
430ce7ab97dSdholland /* we can read the magic out of either the 32-bit or 64-bit dlfs */
431ce7ab97dSdholland magic = fs->lfs_dlfs_u.u_32.dlfs_magic;
432ce7ab97dSdholland
433d3859bd8Sdholland switch (magic) {
434d3859bd8Sdholland case LFS_MAGIC:
435d3859bd8Sdholland fs->lfs_is64 = false;
436d3859bd8Sdholland fs->lfs_dobyteswap = false;
437d3859bd8Sdholland break;
438d3859bd8Sdholland case LFS_MAGIC_SWAPPED:
439d3859bd8Sdholland fs->lfs_is64 = false;
440d3859bd8Sdholland fs->lfs_dobyteswap = true;
441d3859bd8Sdholland break;
442d3859bd8Sdholland case LFS64_MAGIC:
443d3859bd8Sdholland fs->lfs_is64 = true;
444d3859bd8Sdholland fs->lfs_dobyteswap = false;
445d3859bd8Sdholland break;
446d3859bd8Sdholland case LFS64_MAGIC_SWAPPED:
447d3859bd8Sdholland fs->lfs_is64 = true;
448d3859bd8Sdholland fs->lfs_dobyteswap = true;
449d3859bd8Sdholland break;
450d3859bd8Sdholland default:
451ba10361aSperseant printf("Superblock magic number (0x%lx) does not match "
452ce7ab97dSdholland "expected 0x%lx\n", (unsigned long) magic,
453ba10361aSperseant (unsigned long) LFS_MAGIC);
454ba10361aSperseant return 1;
455ba10361aSperseant }
4562b4fdfc6Sdholland
457ba10361aSperseant /* checksum */
458ce7ab97dSdholland checksum = lfs_sb_cksum(fs);
459958ff91fSdholland if (lfs_sb_getcksum(fs) != checksum) {
460ba10361aSperseant printf("Superblock checksum (%lx) does not match computed checksum (%lx)\n",
461958ff91fSdholland (unsigned long) lfs_sb_getcksum(fs), (unsigned long) checksum);
462ba10361aSperseant return 1;
463ba10361aSperseant }
464ba10361aSperseant return 0;
465ba10361aSperseant }
466ba10361aSperseant
467ba10361aSperseant /* Initialize LFS library; load superblocks and choose which to use. */
468ba10361aSperseant struct lfs *
lfs_init(int devfd,daddr_t sblkno,daddr_t idaddr,int dummy_read,int debug)4695d2f3e49Sperseant lfs_init(int devfd, daddr_t sblkno, daddr_t idaddr, int dummy_read, int debug)
470ba10361aSperseant {
471ba10361aSperseant struct uvnode *devvp;
472ba10361aSperseant struct ubuf *bp;
473ba10361aSperseant int tryalt;
474ba10361aSperseant struct lfs *fs, *altfs;
475ba10361aSperseant
476ba10361aSperseant vfs_init();
477ba10361aSperseant
478b6479e9fSchristos devvp = ecalloc(1, sizeof(*devvp));
479ba10361aSperseant devvp->v_fs = NULL;
480ba10361aSperseant devvp->v_fd = devfd;
481ba10361aSperseant devvp->v_strategy_op = raw_vop_strategy;
482ba10361aSperseant devvp->v_bwrite_op = raw_vop_bwrite;
483ba10361aSperseant devvp->v_bmap_op = raw_vop_bmap;
484e01ace1fSyamt LIST_INIT(&devvp->v_cleanblkhd);
485e01ace1fSyamt LIST_INIT(&devvp->v_dirtyblkhd);
486ba10361aSperseant
487ba10361aSperseant tryalt = 0;
4885d2f3e49Sperseant if (dummy_read) {
4895d2f3e49Sperseant if (sblkno == 0)
49079748725Smlelstv sblkno = LFS_LABELPAD / dev_bsize;
491b6479e9fSchristos fs = ecalloc(1, sizeof(*fs));
492dcba0206Sperseant fs->lfs_devvp = devvp;
4935d2f3e49Sperseant } else {
494ba10361aSperseant if (sblkno == 0) {
49579748725Smlelstv sblkno = LFS_LABELPAD / dev_bsize;
496ba10361aSperseant tryalt = 1;
497ba10361aSperseant } else if (debug) {
498ba10361aSperseant printf("No -b flag given, not attempting to verify checkpoint\n");
499ba10361aSperseant }
50079748725Smlelstv
50179748725Smlelstv dev_bsize = DEV_BSIZE;
50279748725Smlelstv
5034ec44e9dSchopps (void)bread(devvp, sblkno, LFS_SBPAD, 0, &bp);
504b6479e9fSchristos fs = ecalloc(1, sizeof(*fs));
505ce7ab97dSdholland __CTASSERT(sizeof(struct dlfs) == sizeof(struct dlfs64));
506ce7ab97dSdholland memcpy(&fs->lfs_dlfs_u, bp->b_data, sizeof(struct dlfs));
507dcba0206Sperseant fs->lfs_devvp = devvp;
508ba10361aSperseant bp->b_flags |= B_INVAL;
509fe44973fSad brelse(bp, 0);
510ba10361aSperseant
511958ff91fSdholland dev_bsize = lfs_sb_getfsize(fs) >> lfs_sb_getfsbtodb(fs);
51279748725Smlelstv
513ba10361aSperseant if (tryalt) {
514958ff91fSdholland (void)bread(devvp, LFS_FSBTODB(fs, lfs_sb_getsboff(fs, 1)),
5154ec44e9dSchopps LFS_SBPAD, 0, &bp);
516b6479e9fSchristos altfs = ecalloc(1, sizeof(*altfs));
517ce7ab97dSdholland memcpy(&altfs->lfs_dlfs_u, bp->b_data,
518ce7ab97dSdholland sizeof(struct dlfs));
519dcba0206Sperseant altfs->lfs_devvp = devvp;
520ba10361aSperseant bp->b_flags |= B_INVAL;
521fe44973fSad brelse(bp, 0);
522ba10361aSperseant
523576195d5Sdholland if (check_sb(fs) || lfs_sb_getidaddr(fs) <= 0) {
524ba10361aSperseant if (debug)
525ba10361aSperseant printf("Primary superblock is no good, using first alternate\n");
526ba10361aSperseant free(fs);
527ba10361aSperseant fs = altfs;
528ba10361aSperseant } else {
529ba10361aSperseant /* If both superblocks check out, try verification */
530ba10361aSperseant if (check_sb(altfs)) {
531ba10361aSperseant if (debug)
532ba10361aSperseant printf("First alternate superblock is no good, using primary\n");
533ba10361aSperseant free(altfs);
534ba10361aSperseant } else {
535ba10361aSperseant if (lfs_verify(fs, altfs, devvp, debug) == fs) {
536ba10361aSperseant free(altfs);
537ba10361aSperseant } else {
538ba10361aSperseant free(fs);
539ba10361aSperseant fs = altfs;
540ba10361aSperseant }
541ba10361aSperseant }
542ba10361aSperseant }
543ba10361aSperseant }
544ba10361aSperseant if (check_sb(fs)) {
545ba10361aSperseant free(fs);
546ba10361aSperseant return NULL;
547ba10361aSperseant }
5485d2f3e49Sperseant }
5495d2f3e49Sperseant
550ba10361aSperseant /* Compatibility */
55158e92fa6Sdholland if (lfs_sb_getversion(fs) < 2) {
552958ff91fSdholland lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
553958ff91fSdholland lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
554958ff91fSdholland lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
555576195d5Sdholland lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));
556958ff91fSdholland lfs_sb_setfsbtodb(fs, 0);
557ba10361aSperseant }
5585d2f3e49Sperseant
5595d2f3e49Sperseant if (!dummy_read) {
560b6479e9fSchristos fs->lfs_suflags = emalloc(2 * sizeof(u_int32_t *));
561958ff91fSdholland fs->lfs_suflags[0] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
562958ff91fSdholland fs->lfs_suflags[1] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
5635d2f3e49Sperseant }
564ba10361aSperseant
565ba10361aSperseant if (idaddr == 0)
566576195d5Sdholland idaddr = lfs_sb_getidaddr(fs);
5671d4cc6a1Sperseant else
568576195d5Sdholland lfs_sb_setidaddr(fs, idaddr);
5695d2f3e49Sperseant /* NB: If dummy_read!=0, idaddr==0 here so we get a fake inode. */
5703f43d41fSdholland fs->lfs_ivnode = lfs_raw_vget(fs, LFS_IFILE_INUM,
571576195d5Sdholland devvp->v_fd, idaddr);
5727700866eSperseant if (fs->lfs_ivnode == NULL)
5737700866eSperseant return NULL;
574ba10361aSperseant
575ba10361aSperseant register_vget((void *)fs, lfs_vget);
576ba10361aSperseant
577ba10361aSperseant return fs;
578ba10361aSperseant }
579ba10361aSperseant
580ba10361aSperseant /*
581ba10361aSperseant * Check partial segment validity between fs->lfs_offset and the given goal.
582a73b3b19Sperseant *
583a73b3b19Sperseant * If goal == 0, just keep on going until the segments stop making sense,
584a73b3b19Sperseant * and return the address of the last valid partial segment.
585a73b3b19Sperseant *
586a73b3b19Sperseant * If goal != 0, return the address of the first partial segment that failed,
587a73b3b19Sperseant * or "goal" if we reached it without failure (the partial segment *at* goal
588a73b3b19Sperseant * need not be valid).
589ba10361aSperseant */
5902d094336Sdholland daddr_t
try_verify(struct lfs * osb,struct uvnode * devvp,daddr_t goal,int debug)5912d094336Sdholland try_verify(struct lfs *osb, struct uvnode *devvp, daddr_t goal, int debug)
592ba10361aSperseant {
5932d094336Sdholland daddr_t daddr, odaddr;
594ba10361aSperseant SEGSUM *sp;
595cb2499acSperseant int i, bc, hitclean;
596ba10361aSperseant struct ubuf *bp;
5972d094336Sdholland daddr_t nodirop_daddr;
598ba10361aSperseant u_int64_t serial;
599ba10361aSperseant
600cb2499acSperseant bc = 0;
601cb2499acSperseant hitclean = 0;
602a73b3b19Sperseant odaddr = -1;
603576195d5Sdholland daddr = lfs_sb_getoffset(osb);
604ba10361aSperseant nodirop_daddr = daddr;
605576195d5Sdholland serial = lfs_sb_getserial(osb);
606ba10361aSperseant while (daddr != goal) {
60729f1062bSperseant /*
60829f1062bSperseant * Don't mistakenly read a superblock, if there is one here.
60929f1062bSperseant */
6109ae6af71Schristos if (lfs_sntod(osb, lfs_dtosn(osb, daddr)) == daddr) {
611958ff91fSdholland if (daddr == lfs_sb_gets0addr(osb))
6129ae6af71Schristos daddr += lfs_btofsb(osb, LFS_LABELPAD);
61329f1062bSperseant for (i = 0; i < LFS_MAXNUMSB; i++) {
6142d094336Sdholland /* XXX dholland 20150828 I think this is wrong */
615958ff91fSdholland if (lfs_sb_getsboff(osb, i) < daddr)
61629f1062bSperseant break;
617958ff91fSdholland if (lfs_sb_getsboff(osb, i) == daddr)
6189ae6af71Schristos daddr += lfs_btofsb(osb, LFS_SBPAD);
61929f1062bSperseant }
62029f1062bSperseant }
62129f1062bSperseant
622ba10361aSperseant /* Read in summary block */
623958ff91fSdholland bread(devvp, LFS_FSBTODB(osb, daddr), lfs_sb_getsumsize(osb),
6244ec44e9dSchopps 0, &bp);
625ba10361aSperseant sp = (SEGSUM *)bp->b_data;
626ba10361aSperseant
627ba10361aSperseant /*
62829f1062bSperseant * Check for a valid segment summary belonging to our fs.
629ba10361aSperseant */
6307f065009Sdholland if (lfs_ss_getmagic(osb, sp) != SS_MAGIC ||
6317f065009Sdholland lfs_ss_getident(osb, sp) != lfs_sb_getident(osb) ||
6327f065009Sdholland lfs_ss_getserial(osb, sp) < serial || /* XXX strengthen this */
6337f065009Sdholland lfs_ss_getsumsum(osb, sp) !=
6347f065009Sdholland cksum((char *)sp + lfs_ss_getsumstart(osb),
6357f065009Sdholland lfs_sb_getsumsize(osb) - lfs_ss_getsumstart(osb))) {
636fe44973fSad brelse(bp, 0);
63729f1062bSperseant if (debug) {
6387f065009Sdholland if (lfs_ss_getmagic(osb, sp) != SS_MAGIC)
639958ff91fSdholland pwarn("pseg at 0x%jx: "
64029f1062bSperseant "wrong magic number\n",
641958ff91fSdholland (uintmax_t)daddr);
6427f065009Sdholland else if (lfs_ss_getident(osb, sp) != lfs_sb_getident(osb))
643958ff91fSdholland pwarn("pseg at 0x%jx: "
644958ff91fSdholland "expected ident %jx, got %jx\n",
645958ff91fSdholland (uintmax_t)daddr,
6467f065009Sdholland (uintmax_t)lfs_ss_getident(osb, sp),
647958ff91fSdholland (uintmax_t)lfs_sb_getident(osb));
6487f065009Sdholland else if (lfs_ss_getserial(osb, sp) >= serial)
649958ff91fSdholland pwarn("pseg at 0x%jx: "
650958ff91fSdholland "serial %d < %d\n",
651958ff91fSdholland (uintmax_t)daddr,
6527f065009Sdholland (int)lfs_ss_getserial(osb, sp), (int)serial);
65329f1062bSperseant else
654958ff91fSdholland pwarn("pseg at 0x%jx: "
65529f1062bSperseant "summary checksum wrong\n",
656958ff91fSdholland (uintmax_t)daddr);
657ba10361aSperseant }
658ba10361aSperseant break;
659ba10361aSperseant }
6607f065009Sdholland if (debug && lfs_ss_getserial(osb, sp) != serial)
661cb2499acSperseant pwarn("warning, serial=%d ss_serial=%d\n",
6627f065009Sdholland (int)serial, (int)lfs_ss_getserial(osb, sp));
663ba10361aSperseant ++serial;
664ba10361aSperseant bc = check_summary(osb, sp, daddr, debug, devvp, NULL);
665ba10361aSperseant if (bc == 0) {
666fe44973fSad brelse(bp, 0);
667ba10361aSperseant break;
668ba10361aSperseant }
66929f1062bSperseant if (debug)
6708d3bc7a9Sdholland pwarn("summary good: 0x%x/%d\n", (uintmax_t)daddr,
6717f065009Sdholland (int)lfs_ss_getserial(osb, sp));
672ba10361aSperseant assert (bc > 0);
673ba10361aSperseant odaddr = daddr;
674958ff91fSdholland daddr += lfs_btofsb(osb, lfs_sb_getsumsize(osb) + bc);
6759ae6af71Schristos if (lfs_dtosn(osb, odaddr) != lfs_dtosn(osb, daddr) ||
6769ae6af71Schristos lfs_dtosn(osb, daddr) != lfs_dtosn(osb, daddr +
677958ff91fSdholland lfs_btofsb(osb, lfs_sb_getsumsize(osb) + lfs_sb_getbsize(osb)) - 1)) {
6787f065009Sdholland daddr = lfs_ss_getnext(osb, sp);
679ba10361aSperseant }
68029f1062bSperseant
68129f1062bSperseant /*
68229f1062bSperseant * Check for the beginning and ending of a sequence of
683cb2499acSperseant * dirops. Writes from the cleaner never involve new
684cb2499acSperseant * information, and are always checkpoints; so don't try
685cb2499acSperseant * to roll forward through them. Likewise, psegs written
686cb2499acSperseant * by a previous roll-forward attempt are not interesting.
68729f1062bSperseant */
6887f065009Sdholland if (lfs_ss_getflags(osb, sp) & (SS_CLEAN | SS_RFW))
689cb2499acSperseant hitclean = 1;
6907f065009Sdholland if (hitclean == 0 && (lfs_ss_getflags(osb, sp) & SS_CONT) == 0)
691ba10361aSperseant nodirop_daddr = daddr;
69229f1062bSperseant
693fe44973fSad brelse(bp, 0);
694ba10361aSperseant }
695ba10361aSperseant
696ba10361aSperseant if (goal == 0)
697ba10361aSperseant return nodirop_daddr;
698ba10361aSperseant else
699ba10361aSperseant return daddr;
700ba10361aSperseant }
701ba10361aSperseant
702ba10361aSperseant /* Use try_verify to check whether the newer superblock is valid. */
703ba10361aSperseant struct lfs *
lfs_verify(struct lfs * sb0,struct lfs * sb1,struct uvnode * devvp,int debug)704ba10361aSperseant lfs_verify(struct lfs *sb0, struct lfs *sb1, struct uvnode *devvp, int debug)
705ba10361aSperseant {
7062d094336Sdholland daddr_t daddr;
707ba10361aSperseant struct lfs *osb, *nsb;
708ba10361aSperseant
709ba10361aSperseant /*
710ba10361aSperseant * Verify the checkpoint of the newer superblock,
711ba10361aSperseant * if the timestamp/serial number of the two superblocks is
712ba10361aSperseant * different.
713ba10361aSperseant */
714ba10361aSperseant
7152b11c546Slukem osb = NULL;
716ba10361aSperseant if (debug)
717576195d5Sdholland pwarn("sb0 %ju, sb1 %ju",
718576195d5Sdholland (uintmax_t) lfs_sb_getserial(sb0),
719576195d5Sdholland (uintmax_t) lfs_sb_getserial(sb1));
720ba10361aSperseant
72158e92fa6Sdholland if ((lfs_sb_getversion(sb0) == 1 &&
722576195d5Sdholland lfs_sb_getotstamp(sb0) != lfs_sb_getotstamp(sb1)) ||
72358e92fa6Sdholland (lfs_sb_getversion(sb0) > 1 &&
724576195d5Sdholland lfs_sb_getserial(sb0) != lfs_sb_getserial(sb1))) {
72558e92fa6Sdholland if (lfs_sb_getversion(sb0) == 1) {
726576195d5Sdholland if (lfs_sb_getotstamp(sb0) > lfs_sb_getotstamp(sb1)) {
727ba10361aSperseant osb = sb1;
728ba10361aSperseant nsb = sb0;
729ba10361aSperseant } else {
730ba10361aSperseant osb = sb0;
731ba10361aSperseant nsb = sb1;
732ba10361aSperseant }
733ba10361aSperseant } else {
734576195d5Sdholland if (lfs_sb_getserial(sb0) > lfs_sb_getserial(sb1)) {
735ba10361aSperseant osb = sb1;
736ba10361aSperseant nsb = sb0;
737ba10361aSperseant } else {
738ba10361aSperseant osb = sb0;
739ba10361aSperseant nsb = sb1;
740ba10361aSperseant }
741ba10361aSperseant }
742ba10361aSperseant if (debug) {
743ba10361aSperseant printf("Attempting to verify newer checkpoint...");
744ba10361aSperseant fflush(stdout);
745ba10361aSperseant }
746576195d5Sdholland daddr = try_verify(osb, devvp, lfs_sb_getoffset(nsb), debug);
747ba10361aSperseant
748ba10361aSperseant if (debug)
749ba10361aSperseant printf("done.\n");
750576195d5Sdholland if (daddr == lfs_sb_getoffset(nsb)) {
751576195d5Sdholland pwarn("** Newer checkpoint verified; recovered %jd seconds of data\n",
752576195d5Sdholland (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb)));
753ba10361aSperseant sbdirty();
754ba10361aSperseant } else {
755576195d5Sdholland pwarn("** Newer checkpoint invalid; lost %jd seconds of data\n", (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb)));
756ba10361aSperseant }
757576195d5Sdholland return (daddr == lfs_sb_getoffset(nsb) ? nsb : osb);
758ba10361aSperseant }
759ba10361aSperseant /* Nothing to check */
760ba10361aSperseant return osb;
761ba10361aSperseant }
762ba10361aSperseant
763ba10361aSperseant /* Verify a partial-segment summary; return the number of bytes on disk. */
764ba10361aSperseant int
check_summary(struct lfs * fs,SEGSUM * sp,daddr_t pseg_addr,int debug,struct uvnode * devvp,void (func (daddr_t,FINFO *)))7652d094336Sdholland check_summary(struct lfs *fs, SEGSUM *sp, daddr_t pseg_addr, int debug,
7662d094336Sdholland struct uvnode *devvp, void (func(daddr_t, FINFO *)))
767ba10361aSperseant {
768ba10361aSperseant FINFO *fp;
769ba10361aSperseant int bc; /* Bytes in partial segment */
770ba10361aSperseant int nblocks;
7712d094336Sdholland daddr_t daddr;
77298067ce1Sdholland IINFO *iibase, *iip;
773ba10361aSperseant struct ubuf *bp;
774ba10361aSperseant int i, j, k, datac, len;
77511275149Sdholland lfs_checkword *datap;
776ba10361aSperseant u_int32_t ccksum;
777ba10361aSperseant
778ba10361aSperseant /* We've already checked the sumsum, just do the data bounds and sum */
779ba10361aSperseant
780ba10361aSperseant /* Count the blocks. */
7817f065009Sdholland nblocks = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));
78258e92fa6Sdholland bc = nblocks << (lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) : lfs_sb_getbshift(fs));
783ba10361aSperseant assert(bc >= 0);
784ba10361aSperseant
7857f065009Sdholland fp = SEGSUM_FINFOBASE(fs, sp);
7867f065009Sdholland for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) {
78731a155cfSdholland nblocks += lfs_fi_getnblocks(fs, fp);
78831a155cfSdholland bc += lfs_fi_getlastlength(fs, fp) + ((lfs_fi_getnblocks(fs, fp) - 1)
789958ff91fSdholland << lfs_sb_getbshift(fs));
790ba10361aSperseant assert(bc >= 0);
7917f065009Sdholland fp = NEXT_FINFO(fs, fp);
792958ff91fSdholland if (((char *)fp) - (char *)sp > lfs_sb_getsumsize(fs))
79329f1062bSperseant return 0;
794ba10361aSperseant }
795b6479e9fSchristos datap = emalloc(nblocks * sizeof(*datap));
796ba10361aSperseant datac = 0;
797ba10361aSperseant
79898067ce1Sdholland iibase = SEGSUM_IINFOSTART(fs, sp);
799ba10361aSperseant
80098067ce1Sdholland iip = iibase;
801958ff91fSdholland daddr = pseg_addr + lfs_btofsb(fs, lfs_sb_getsumsize(fs));
8027c745662Sdholland fp = SEGSUM_FINFOBASE(fs, sp);
803ba10361aSperseant for (i = 0, j = 0;
8047f065009Sdholland i < lfs_ss_getnfinfo(fs, sp) || j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {
80598067ce1Sdholland if (i >= lfs_ss_getnfinfo(fs, sp) && lfs_ii_getblock(fs, iip) != daddr) {
8062d094336Sdholland pwarn("Not enough inode blocks in pseg at 0x%jx: "
8072d094336Sdholland "found %d, wanted %d\n",
8087f065009Sdholland pseg_addr, j, howmany(lfs_ss_getninos(fs, sp),
8097f065009Sdholland LFS_INOPB(fs)));
810ba10361aSperseant if (debug)
81198067ce1Sdholland pwarn("iip=0x%jx, daddr=0x%jx\n",
81298067ce1Sdholland (uintmax_t)lfs_ii_getblock(fs, iip),
81398067ce1Sdholland (intmax_t)daddr);
814ba10361aSperseant break;
815ba10361aSperseant }
81698067ce1Sdholland while (j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) && lfs_ii_getblock(fs, iip) == daddr) {
817958ff91fSdholland bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),
8184ec44e9dSchopps 0, &bp);
81911275149Sdholland datap[datac++] = ((lfs_checkword *)bp->b_data)[0];
820fe44973fSad brelse(bp, 0);
821ba10361aSperseant
822ba10361aSperseant ++j;
823958ff91fSdholland daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs));
82498067ce1Sdholland iip = NEXTLOWER_IINFO(fs, iip);
825ba10361aSperseant }
8267f065009Sdholland if (i < lfs_ss_getnfinfo(fs, sp)) {
827ba10361aSperseant if (func)
828ba10361aSperseant func(daddr, fp);
82931a155cfSdholland for (k = 0; k < lfs_fi_getnblocks(fs, fp); k++) {
83031a155cfSdholland len = (k == lfs_fi_getnblocks(fs, fp) - 1 ?
83131a155cfSdholland lfs_fi_getlastlength(fs, fp)
832576195d5Sdholland : lfs_sb_getbsize(fs));
8339ae6af71Schristos bread(devvp, LFS_FSBTODB(fs, daddr), len,
8344ec44e9dSchopps 0, &bp);
83511275149Sdholland datap[datac++] = ((lfs_checkword *)bp->b_data)[0];
836fe44973fSad brelse(bp, 0);
8379ae6af71Schristos daddr += lfs_btofsb(fs, len);
838ba10361aSperseant }
8397f065009Sdholland fp = NEXT_FINFO(fs, fp);
840ba10361aSperseant }
841ba10361aSperseant }
842ba10361aSperseant
843ba10361aSperseant if (datac != nblocks) {
8448d3bc7a9Sdholland pwarn("Partial segment at 0x%jx expected %d blocks counted %d\n",
8458d3bc7a9Sdholland (intmax_t)pseg_addr, nblocks, datac);
846ba10361aSperseant }
84711275149Sdholland ccksum = cksum(datap, nblocks * sizeof(datap[0]));
848ba10361aSperseant /* Check the data checksum */
8497f065009Sdholland if (ccksum != lfs_ss_getdatasum(fs, sp)) {
8508d3bc7a9Sdholland pwarn("Partial segment at 0x%jx data checksum"
851ba10361aSperseant " mismatch: given 0x%x, computed 0x%x\n",
8527f065009Sdholland (uintmax_t)pseg_addr, lfs_ss_getdatasum(fs, sp), ccksum);
853ba10361aSperseant free(datap);
854ba10361aSperseant return 0;
855ba10361aSperseant }
856ba10361aSperseant free(datap);
857ba10361aSperseant assert(bc >= 0);
858ba10361aSperseant return bc;
859ba10361aSperseant }
860ba10361aSperseant
861ba10361aSperseant /* print message and exit */
862ba10361aSperseant void
my_vpanic(int fatal,const char * fmt,va_list ap)86317c417f1Sdholland my_vpanic(int fatal, const char *fmt, va_list ap)
86417c417f1Sdholland {
86517c417f1Sdholland (void) vprintf(fmt, ap);
86617c417f1Sdholland exit(8);
86717c417f1Sdholland }
86817c417f1Sdholland
86917c417f1Sdholland void
call_panic(const char * fmt,...)870ba10361aSperseant call_panic(const char *fmt, ...)
871ba10361aSperseant {
872ba10361aSperseant va_list ap;
873ba10361aSperseant
874ba10361aSperseant va_start(ap, fmt);
87517c417f1Sdholland panic_func(1, fmt, ap);
876ba10361aSperseant va_end(ap);
877ba10361aSperseant }
8784b8db838Sperseant
8794b8db838Sperseant /* Allocate a new inode. */
8804b8db838Sperseant struct uvnode *
lfs_valloc(struct lfs * fs,ino_t ino)8814b8db838Sperseant lfs_valloc(struct lfs *fs, ino_t ino)
8824b8db838Sperseant {
8834b8db838Sperseant struct ubuf *bp, *cbp;
884daf91f9bSdholland IFILE *ifp;
8854b8db838Sperseant ino_t new_ino;
8864b8db838Sperseant int error;
8874b8db838Sperseant CLEANERINFO *cip;
8884b8db838Sperseant
8894b8db838Sperseant /* Get the head of the freelist. */
8904b8db838Sperseant LFS_GET_HEADFREE(fs, cip, cbp, &new_ino);
8914b8db838Sperseant
8924b8db838Sperseant /*
8934b8db838Sperseant * Remove the inode from the free list and write the new start
8944b8db838Sperseant * of the free list into the superblock.
8954b8db838Sperseant */
8964b8db838Sperseant LFS_IENTRY(ifp, fs, new_ino, bp);
897daf91f9bSdholland if (lfs_if_getdaddr(fs, ifp) != LFS_UNUSED_DADDR)
8984b8db838Sperseant panic("lfs_valloc: inuse inode %d on the free list", new_ino);
899daf91f9bSdholland LFS_PUT_HEADFREE(fs, cip, cbp, lfs_if_getnextfree(fs, ifp));
9004b8db838Sperseant
901fe44973fSad brelse(bp, 0);
9024b8db838Sperseant
9034b8db838Sperseant /* Extend IFILE so that the next lfs_valloc will succeed. */
904576195d5Sdholland if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
9054b8db838Sperseant if ((error = extend_ifile(fs)) != 0) {
9064b8db838Sperseant LFS_PUT_HEADFREE(fs, cip, cbp, new_ino);
9074b8db838Sperseant return NULL;
9084b8db838Sperseant }
9094b8db838Sperseant }
9104b8db838Sperseant
9114b8db838Sperseant /* Set superblock modified bit and increment file count. */
9124b8db838Sperseant sbdirty();
913576195d5Sdholland lfs_sb_addnfiles(fs, 1);
9144b8db838Sperseant
9154b8db838Sperseant return lfs_raw_vget(fs, ino, fs->lfs_devvp->v_fd, 0x0);
9164b8db838Sperseant }
9174b8db838Sperseant
91829f1062bSperseant #ifdef IN_FSCK_LFS
91929f1062bSperseant void reset_maxino(ino_t);
92029f1062bSperseant #endif
92129f1062bSperseant
9224b8db838Sperseant /*
9234b8db838Sperseant * Add a new block to the Ifile, to accommodate future file creations.
9244b8db838Sperseant */
9254b8db838Sperseant int
extend_ifile(struct lfs * fs)9264b8db838Sperseant extend_ifile(struct lfs *fs)
9274b8db838Sperseant {
9284b8db838Sperseant struct uvnode *vp;
9294b8db838Sperseant struct inode *ip;
930daf91f9bSdholland IFILE64 *ifp64;
931daf91f9bSdholland IFILE32 *ifp32;
9324b8db838Sperseant IFILE_V1 *ifp_v1;
9334b8db838Sperseant struct ubuf *bp, *cbp;
9344b8db838Sperseant daddr_t i, blkno, max;
9354b8db838Sperseant ino_t oldlast;
9364b8db838Sperseant CLEANERINFO *cip;
9374b8db838Sperseant
9384b8db838Sperseant vp = fs->lfs_ivnode;
9394b8db838Sperseant ip = VTOI(vp);
940f4c19b7cSdholland blkno = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din));
9414b8db838Sperseant
942f4c19b7cSdholland lfs_balloc(vp, lfs_dino_getsize(fs, ip->i_din), lfs_sb_getbsize(fs), &bp);
943f4c19b7cSdholland lfs_dino_setsize(fs, ip->i_din,
944f4c19b7cSdholland lfs_dino_getsize(fs, ip->i_din) + lfs_sb_getbsize(fs));
945f2b481f7Spgoyette ip->i_state |= IN_MODIFIED;
9464b8db838Sperseant
947576195d5Sdholland i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *
948576195d5Sdholland lfs_sb_getifpb(fs);
9494b8db838Sperseant LFS_GET_HEADFREE(fs, cip, cbp, &oldlast);
9504b8db838Sperseant LFS_PUT_HEADFREE(fs, cip, cbp, i);
951576195d5Sdholland max = i + lfs_sb_getifpb(fs);
952576195d5Sdholland lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getbsize(fs)));
9534b8db838Sperseant
954daf91f9bSdholland if (fs->lfs_is64) {
955daf91f9bSdholland for (ifp64 = (IFILE64 *)bp->b_data; i < max; ++ifp64) {
956daf91f9bSdholland ifp64->if_version = 1;
957daf91f9bSdholland ifp64->if_daddr = LFS_UNUSED_DADDR;
958daf91f9bSdholland ifp64->if_nextfree = ++i;
959daf91f9bSdholland }
960daf91f9bSdholland ifp64--;
961daf91f9bSdholland ifp64->if_nextfree = oldlast;
962daf91f9bSdholland } else if (lfs_sb_getversion(fs) > 1) {
963daf91f9bSdholland for (ifp32 = (IFILE32 *)bp->b_data; i < max; ++ifp32) {
964daf91f9bSdholland ifp32->if_version = 1;
965daf91f9bSdholland ifp32->if_daddr = LFS_UNUSED_DADDR;
966daf91f9bSdholland ifp32->if_nextfree = ++i;
967daf91f9bSdholland }
968daf91f9bSdholland ifp32--;
969daf91f9bSdholland ifp32->if_nextfree = oldlast;
970daf91f9bSdholland } else {
9714b8db838Sperseant for (ifp_v1 = (IFILE_V1 *)bp->b_data; i < max; ++ifp_v1) {
9724b8db838Sperseant ifp_v1->if_version = 1;
9734b8db838Sperseant ifp_v1->if_daddr = LFS_UNUSED_DADDR;
9744b8db838Sperseant ifp_v1->if_nextfree = ++i;
9754b8db838Sperseant }
9764b8db838Sperseant ifp_v1--;
9774b8db838Sperseant ifp_v1->if_nextfree = oldlast;
9784b8db838Sperseant }
9794b8db838Sperseant LFS_PUT_TAILFREE(fs, cip, cbp, max - 1);
9804b8db838Sperseant
9814b8db838Sperseant LFS_BWRITE_LOG(bp);
9824b8db838Sperseant
98329f1062bSperseant #ifdef IN_FSCK_LFS
984f4c19b7cSdholland reset_maxino(((lfs_dino_getsize(fs, ip->i_din) >> lfs_sb_getbshift(fs))
985576195d5Sdholland - lfs_sb_getsegtabsz(fs)
986576195d5Sdholland - lfs_sb_getcleansz(fs)) * lfs_sb_getifpb(fs));
98729f1062bSperseant #endif
9884b8db838Sperseant return 0;
9894b8db838Sperseant }
9904b8db838Sperseant
99129f1062bSperseant /*
99229f1062bSperseant * Allocate a block, and to inode and filesystem block accounting for it
99329f1062bSperseant * and for any indirect blocks the may need to be created in order for
99429f1062bSperseant * this block to be created.
99529f1062bSperseant *
99629f1062bSperseant * Blocks which have never been accounted for (i.e., which "do not exist")
9974f8bc7f7Sdholland * have disk address 0, which is translated by ulfs_bmap to the special value
9984f8bc7f7Sdholland * UNASSIGNED == -1, as in the historical ULFS.
99929f1062bSperseant *
100029f1062bSperseant * Blocks which have been accounted for but which have not yet been written
100129f1062bSperseant * to disk are given the new special disk address UNWRITTEN == -2, so that
100229f1062bSperseant * they can be differentiated from completely new blocks.
100329f1062bSperseant */
100429f1062bSperseant int
lfs_balloc(struct uvnode * vp,off_t startoffset,int iosize,struct ubuf ** bpp)100529f1062bSperseant lfs_balloc(struct uvnode *vp, off_t startoffset, int iosize, struct ubuf **bpp)
100629f1062bSperseant {
100729f1062bSperseant int offset;
100829f1062bSperseant daddr_t daddr, idaddr;
100929f1062bSperseant struct ubuf *ibp, *bp;
101029f1062bSperseant struct inode *ip;
101129f1062bSperseant struct lfs *fs;
10124f8bc7f7Sdholland struct indir indirs[ULFS_NIADDR+2], *idp;
101329f1062bSperseant daddr_t lbn, lastblock;
101479748725Smlelstv int bcount;
101529f1062bSperseant int error, frags, i, nsize, osize, num;
101629f1062bSperseant
101729f1062bSperseant ip = VTOI(vp);
101829f1062bSperseant fs = ip->i_lfs;
10199ae6af71Schristos offset = lfs_blkoff(fs, startoffset);
10209ae6af71Schristos lbn = lfs_lblkno(fs, startoffset);
102129f1062bSperseant
102229f1062bSperseant /*
102329f1062bSperseant * Three cases: it's a block beyond the end of file, it's a block in
102429f1062bSperseant * the file that may or may not have been assigned a disk address or
102529f1062bSperseant * we're writing an entire block.
102629f1062bSperseant *
102729f1062bSperseant * Note, if the daddr is UNWRITTEN, the block already exists in
102829f1062bSperseant * the cache (it was read or written earlier). If so, make sure
102929f1062bSperseant * we don't count it as a new block or zero out its contents. If
103029f1062bSperseant * it did not, make sure we allocate any necessary indirect
103129f1062bSperseant * blocks.
103229f1062bSperseant *
103329f1062bSperseant * If we are writing a block beyond the end of the file, we need to
103429f1062bSperseant * check if the old last block was a fragment. If it was, we need
103529f1062bSperseant * to rewrite it.
103629f1062bSperseant */
103729f1062bSperseant
103829f1062bSperseant if (bpp)
103929f1062bSperseant *bpp = NULL;
104029f1062bSperseant
104129f1062bSperseant /* Check for block beyond end of file and fragment extension needed. */
1042f4c19b7cSdholland lastblock = lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din));
10434f8bc7f7Sdholland if (lastblock < ULFS_NDADDR && lastblock < lbn) {
10449ae6af71Schristos osize = lfs_blksize(fs, ip, lastblock);
1045576195d5Sdholland if (osize < lfs_sb_getbsize(fs) && osize > 0) {
1046576195d5Sdholland if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs),
104729f1062bSperseant lastblock,
104829f1062bSperseant (bpp ? &bp : NULL))))
104929f1062bSperseant return (error);
1050f4c19b7cSdholland lfs_dino_setsize(fs, ip->i_din, (lastblock + 1) * lfs_sb_getbsize(fs));
1051f2b481f7Spgoyette ip->i_state |= IN_CHANGE | IN_UPDATE;
105229f1062bSperseant if (bpp)
105329f1062bSperseant (void) VOP_BWRITE(bp);
105429f1062bSperseant }
105529f1062bSperseant }
105629f1062bSperseant
105729f1062bSperseant /*
105829f1062bSperseant * If the block we are writing is a direct block, it's the last
105929f1062bSperseant * block in the file, and offset + iosize is less than a full
106029f1062bSperseant * block, we can write one or more fragments. There are two cases:
106129f1062bSperseant * the block is brand new and we should allocate it the correct
106229f1062bSperseant * size or it already exists and contains some fragments and
106329f1062bSperseant * may need to extend it.
106429f1062bSperseant */
1065f4c19b7cSdholland if (lbn < ULFS_NDADDR && lfs_lblkno(fs, lfs_dino_getsize(fs, ip->i_din)) <= lbn) {
10669ae6af71Schristos osize = lfs_blksize(fs, ip, lbn);
10679ae6af71Schristos nsize = lfs_fragroundup(fs, offset + iosize);
1068f4c19b7cSdholland if (lfs_lblktosize(fs, lbn) >= lfs_dino_getsize(fs, ip->i_din)) {
106929f1062bSperseant /* Brand new block or fragment */
10709ae6af71Schristos frags = lfs_numfrags(fs, nsize);
107129f1062bSperseant if (bpp) {
107229f1062bSperseant *bpp = bp = getblk(vp, lbn, nsize);
107329f1062bSperseant bp->b_blkno = UNWRITTEN;
107429f1062bSperseant }
107579748725Smlelstv ip->i_lfs_effnblks += frags;
1076576195d5Sdholland lfs_sb_subbfree(fs, frags);
1077f4c19b7cSdholland lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);
107829f1062bSperseant } else {
107929f1062bSperseant if (nsize <= osize) {
108029f1062bSperseant /* No need to extend */
10815d2bff06Shannken if (bpp && (error = bread(vp, lbn, osize,
10824ec44e9dSchopps 0, &bp)))
108329f1062bSperseant return error;
108429f1062bSperseant } else {
108529f1062bSperseant /* Extend existing block */
108629f1062bSperseant if ((error =
108729f1062bSperseant lfs_fragextend(vp, osize, nsize, lbn,
108829f1062bSperseant (bpp ? &bp : NULL))))
108929f1062bSperseant return error;
109029f1062bSperseant }
109129f1062bSperseant if (bpp)
109229f1062bSperseant *bpp = bp;
109329f1062bSperseant }
109429f1062bSperseant return 0;
109529f1062bSperseant }
109629f1062bSperseant
10974f8bc7f7Sdholland error = ulfs_bmaparray(fs, vp, lbn, &daddr, &indirs[0], &num);
109829f1062bSperseant if (error)
109929f1062bSperseant return (error);
110029f1062bSperseant
110129f1062bSperseant /*
110229f1062bSperseant * Do byte accounting all at once, so we can gracefully fail *before*
110329f1062bSperseant * we start assigning blocks.
110429f1062bSperseant */
11059ae6af71Schristos frags = LFS_FSBTODB(fs, 1); /* frags = VFSTOULFS(vp->v_mount)->um_seqinc; */
110629f1062bSperseant bcount = 0;
110729f1062bSperseant if (daddr == UNASSIGNED) {
110879748725Smlelstv bcount = frags;
110929f1062bSperseant }
111029f1062bSperseant for (i = 1; i < num; ++i) {
111129f1062bSperseant if (!indirs[i].in_exists) {
111279748725Smlelstv bcount += frags;
111329f1062bSperseant }
111429f1062bSperseant }
1115576195d5Sdholland lfs_sb_subbfree(fs, bcount);
111629f1062bSperseant ip->i_lfs_effnblks += bcount;
111729f1062bSperseant
111829f1062bSperseant if (daddr == UNASSIGNED) {
1119f4c19b7cSdholland if (num > 0 && lfs_dino_getib(fs, ip->i_din, indirs[0].in_off) == 0) {
1120f4c19b7cSdholland lfs_dino_setib(fs, ip->i_din, indirs[0].in_off,
1121f4c19b7cSdholland UNWRITTEN);
112229f1062bSperseant }
112329f1062bSperseant
112429f1062bSperseant /*
112529f1062bSperseant * Create new indirect blocks if necessary
112629f1062bSperseant */
112729f1062bSperseant if (num > 1) {
1128f4c19b7cSdholland idaddr = lfs_dino_getib(fs, ip->i_din, indirs[0].in_off);
112929f1062bSperseant for (i = 1; i < num; ++i) {
113029f1062bSperseant ibp = getblk(vp, indirs[i].in_lbn,
1131576195d5Sdholland lfs_sb_getbsize(fs));
113229f1062bSperseant if (!indirs[i].in_exists) {
113329f1062bSperseant memset(ibp->b_data, 0, ibp->b_bufsize);
113429f1062bSperseant ibp->b_blkno = UNWRITTEN;
113529f1062bSperseant } else if (!(ibp->b_flags & (B_DELWRI | B_DONE))) {
11369ae6af71Schristos ibp->b_blkno = LFS_FSBTODB(fs, idaddr);
113729f1062bSperseant ibp->b_flags |= B_READ;
113829f1062bSperseant VOP_STRATEGY(ibp);
113929f1062bSperseant }
114029f1062bSperseant /*
114129f1062bSperseant * This block exists, but the next one may not.
114229f1062bSperseant * If that is the case mark it UNWRITTEN to
114329f1062bSperseant * keep the accounting straight.
114429f1062bSperseant */
114595fdd7d1Sdholland if (lfs_iblock_get(fs, ibp->b_data,
114695fdd7d1Sdholland indirs[i].in_off) == 0)
114795fdd7d1Sdholland lfs_iblock_set(fs, ibp->b_data,
114895fdd7d1Sdholland indirs[i].in_off, UNWRITTEN);
114995fdd7d1Sdholland idaddr = lfs_iblock_get(fs, ibp->b_data,
115095fdd7d1Sdholland indirs[i].in_off);
115129f1062bSperseant if ((error = VOP_BWRITE(ibp)))
115229f1062bSperseant return error;
115329f1062bSperseant }
115429f1062bSperseant }
115529f1062bSperseant }
115629f1062bSperseant
115729f1062bSperseant
115829f1062bSperseant /*
115929f1062bSperseant * Get the existing block from the cache, if requested.
116029f1062bSperseant */
116129f1062bSperseant if (bpp)
11629ae6af71Schristos *bpp = bp = getblk(vp, lbn, lfs_blksize(fs, ip, lbn));
116329f1062bSperseant
116429f1062bSperseant /*
116529f1062bSperseant * The block we are writing may be a brand new block
116629f1062bSperseant * in which case we need to do accounting.
116729f1062bSperseant *
11684f8bc7f7Sdholland * We can tell a truly new block because ulfs_bmaparray will say
116929f1062bSperseant * it is UNASSIGNED. Once we allocate it we will assign it the
117029f1062bSperseant * disk address UNWRITTEN.
117129f1062bSperseant */
117229f1062bSperseant if (daddr == UNASSIGNED) {
117329f1062bSperseant if (bpp) {
117429f1062bSperseant /* Note the new address */
117529f1062bSperseant bp->b_blkno = UNWRITTEN;
117629f1062bSperseant }
117729f1062bSperseant
117829f1062bSperseant switch (num) {
117929f1062bSperseant case 0:
1180f4c19b7cSdholland lfs_dino_setdb(fs, ip->i_din, lbn, UNWRITTEN);
118129f1062bSperseant break;
118229f1062bSperseant case 1:
1183f4c19b7cSdholland lfs_dino_setib(fs, ip->i_din, indirs[0].in_off,
1184f4c19b7cSdholland UNWRITTEN);
118529f1062bSperseant break;
118629f1062bSperseant default:
118729f1062bSperseant idp = &indirs[num - 1];
1188576195d5Sdholland if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs), 0, &ibp))
118929f1062bSperseant panic("lfs_balloc: bread bno %lld",
119029f1062bSperseant (long long)idp->in_lbn);
1191f4c19b7cSdholland lfs_iblock_set(fs, ibp->b_data, idp->in_off,
1192f4c19b7cSdholland UNWRITTEN);
119329f1062bSperseant VOP_BWRITE(ibp);
119429f1062bSperseant }
119529f1062bSperseant } else if (bpp && !(bp->b_flags & (B_DONE|B_DELWRI))) {
119629f1062bSperseant /*
119729f1062bSperseant * Not a brand new block, also not in the cache;
119829f1062bSperseant * read it in from disk.
119929f1062bSperseant */
1200576195d5Sdholland if (iosize == lfs_sb_getbsize(fs))
120129f1062bSperseant /* Optimization: I/O is unnecessary. */
120229f1062bSperseant bp->b_blkno = daddr;
120329f1062bSperseant else {
120429f1062bSperseant /*
120529f1062bSperseant * We need to read the block to preserve the
120629f1062bSperseant * existing bytes.
120729f1062bSperseant */
120829f1062bSperseant bp->b_blkno = daddr;
120929f1062bSperseant bp->b_flags |= B_READ;
121029f1062bSperseant VOP_STRATEGY(bp);
121129f1062bSperseant return 0;
121229f1062bSperseant }
121329f1062bSperseant }
121429f1062bSperseant
121529f1062bSperseant return (0);
121629f1062bSperseant }
121729f1062bSperseant
121829f1062bSperseant int
lfs_fragextend(struct uvnode * vp,int osize,int nsize,daddr_t lbn,struct ubuf ** bpp)121929f1062bSperseant lfs_fragextend(struct uvnode *vp, int osize, int nsize, daddr_t lbn,
122029f1062bSperseant struct ubuf **bpp)
122129f1062bSperseant {
122229f1062bSperseant struct inode *ip;
122329f1062bSperseant struct lfs *fs;
122479748725Smlelstv int frags;
122529f1062bSperseant int error;
122629f1062bSperseant
122729f1062bSperseant ip = VTOI(vp);
122829f1062bSperseant fs = ip->i_lfs;
12299ae6af71Schristos frags = (long)lfs_numfrags(fs, nsize - osize);
123029f1062bSperseant error = 0;
123129f1062bSperseant
123229f1062bSperseant /*
123329f1062bSperseant * If we are not asked to actually return the block, all we need
123429f1062bSperseant * to do is allocate space for it. UBC will handle dirtying the
123529f1062bSperseant * appropriate things and making sure it all goes to disk.
123629f1062bSperseant * Don't bother to read in that case.
123729f1062bSperseant */
12384ec44e9dSchopps if (bpp && (error = bread(vp, lbn, osize, 0, bpp))) {
1239fe44973fSad brelse(*bpp, 0);
124029f1062bSperseant goto out;
124129f1062bSperseant }
124229f1062bSperseant
1243576195d5Sdholland lfs_sb_subbfree(fs, frags);
124479748725Smlelstv ip->i_lfs_effnblks += frags;
1245f2b481f7Spgoyette ip->i_state |= IN_CHANGE | IN_UPDATE;
124629f1062bSperseant
124729f1062bSperseant if (bpp) {
1248b6479e9fSchristos (*bpp)->b_data = erealloc((*bpp)->b_data, nsize);
1249b6479e9fSchristos (void)memset((*bpp)->b_data + osize, 0, nsize - osize);
125029f1062bSperseant }
125129f1062bSperseant
125229f1062bSperseant out:
125329f1062bSperseant return (error);
125429f1062bSperseant }
1255