1 /* $NetBSD: ext2fs_balloc.c,v 1.43 2020/09/05 16:30:13 riastradh Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1986, 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * @(#)ffs_balloc.c 8.4 (Berkeley) 9/23/93
32 * Modified for ext2fs by Manuel Bouyer.
33 */
34
35 /*
36 * Copyright (c) 1997 Manuel Bouyer.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57 *
58 * @(#)ffs_balloc.c 8.4 (Berkeley) 9/23/93
59 * Modified for ext2fs by Manuel Bouyer.
60 */
61
62 #include <sys/cdefs.h>
63 __KERNEL_RCSID(0, "$NetBSD: ext2fs_balloc.c,v 1.43 2020/09/05 16:30:13 riastradh Exp $");
64
65 #if defined(_KERNEL_OPT)
66 #include "opt_uvmhist.h"
67 #endif
68
69 #include <sys/param.h>
70 #include <sys/systm.h>
71 #include <sys/buf.h>
72 #include <sys/proc.h>
73 #include <sys/file.h>
74 #include <sys/vnode.h>
75 #include <sys/mount.h>
76 #include <sys/kauth.h>
77
78 #ifdef UVMHIST
79 #include <uvm/uvm.h>
80 #endif
81 #include <uvm/uvm_stat.h>
82
83 #include <ufs/ufs/inode.h>
84 #include <ufs/ufs/ufs_extern.h>
85
86 #include <ufs/ext2fs/ext2fs.h>
87 #include <ufs/ext2fs/ext2fs_extern.h>
88
89 /*
90 * Balloc defines the structure of file system storage
91 * by allocating the physical blocks on a device given
92 * the inode and the logical block number in a file.
93 */
94 int
ext2fs_balloc(struct inode * ip,daddr_t bn,int size,kauth_cred_t cred,struct buf ** bpp,int flags)95 ext2fs_balloc(struct inode *ip, daddr_t bn, int size,
96 kauth_cred_t cred, struct buf **bpp, int flags)
97 {
98 struct m_ext2fs *fs;
99 daddr_t nb;
100 struct buf *bp, *nbp;
101 struct vnode *vp = ITOV(ip);
102 struct indir indirs[EXT2FS_NIADDR + 2];
103 daddr_t newb, lbn, pref;
104 int32_t *bap; /* XXX ondisk32 */
105 int num, i, error;
106 u_int deallocated;
107 daddr_t *blkp, *allocblk, allociblk[EXT2FS_NIADDR + 1];
108 int32_t *allocib; /* XXX ondisk32 */
109 int unwindidx = -1;
110 UVMHIST_FUNC("ext2fs_balloc"); UVMHIST_CALLED(ubchist);
111
112 UVMHIST_LOG(ubchist, "bn 0x%x", bn, 0, 0, 0);
113
114 if (bpp != NULL) {
115 *bpp = NULL;
116 }
117 if (bn < 0)
118 return EFBIG;
119 fs = ip->i_e2fs;
120 lbn = bn;
121
122 /*
123 * The first EXT2FS_NDADDR blocks are direct blocks
124 */
125 if (bn < EXT2FS_NDADDR) {
126 /* XXX ondisk32 */
127 nb = fs2h32(ip->i_e2fs_blocks[bn]);
128 if (nb != 0) {
129
130 /*
131 * the block is already allocated, just read it.
132 */
133
134 if (bpp != NULL) {
135 error = bread(vp, bn, fs->e2fs_bsize,
136 B_MODIFY, &bp);
137 if (error) {
138 return error;
139 }
140 *bpp = bp;
141 }
142 return 0;
143 }
144
145 /*
146 * allocate a new direct block.
147 */
148
149 error = ext2fs_alloc(ip, bn,
150 ext2fs_blkpref(ip, bn, bn, &ip->i_e2fs_blocks[0]),
151 cred, &newb);
152 if (error)
153 return error;
154 ip->i_e2fs_last_lblk = lbn;
155 ip->i_e2fs_last_blk = newb;
156 /* XXX ondisk32 */
157 ip->i_e2fs_blocks[bn] = h2fs32((int32_t)newb);
158 ip->i_flag |= IN_CHANGE | IN_UPDATE;
159 if (bpp != NULL) {
160 bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);
161 bp->b_blkno = EXT2_FSBTODB(fs, newb);
162 if (flags & B_CLRBUF)
163 clrbuf(bp);
164 *bpp = bp;
165 }
166 return 0;
167 }
168 /*
169 * Determine the number of levels of indirection.
170 */
171 pref = 0;
172 if ((error = ufs_getlbns(vp, bn, indirs, &num)) != 0)
173 return error;
174 #ifdef DIAGNOSTIC
175 if (num < 1)
176 panic("%s: ufs_getlbns returned indirect block\n", __func__);
177 #endif
178 /*
179 * Fetch the first indirect block allocating if necessary.
180 */
181 --num;
182 /* XXX ondisk32 */
183 nb = fs2h32(ip->i_e2fs_blocks[EXT2FS_NDADDR + indirs[0].in_off]);
184 allocib = NULL;
185 allocblk = allociblk;
186 if (nb == 0) {
187 pref = ext2fs_blkpref(ip, lbn, 0, (int32_t *)0);
188 error = ext2fs_alloc(ip, lbn, pref, cred, &newb);
189 if (error)
190 return error;
191 nb = newb;
192 *allocblk++ = nb;
193 ip->i_e2fs_last_blk = newb;
194 bp = getblk(vp, indirs[1].in_lbn, fs->e2fs_bsize, 0, 0);
195 bp->b_blkno = EXT2_FSBTODB(fs, newb);
196 clrbuf(bp);
197 /*
198 * Write synchronously so that indirect blocks
199 * never point at garbage.
200 */
201 if ((error = bwrite(bp)) != 0)
202 goto fail;
203 unwindidx = 0;
204 allocib = &ip->i_e2fs_blocks[EXT2FS_NDADDR + indirs[0].in_off];
205 /* XXX ondisk32 */
206 *allocib = h2fs32((int32_t)newb);
207 ip->i_flag |= IN_CHANGE | IN_UPDATE;
208 }
209 /*
210 * Fetch through the indirect blocks, allocating as necessary.
211 */
212 for (i = 1;;) {
213 error = bread(vp,
214 indirs[i].in_lbn, (int)fs->e2fs_bsize, 0, &bp);
215 if (error) {
216 goto fail;
217 }
218 bap = (int32_t *)bp->b_data; /* XXX ondisk32 */
219 nb = fs2h32(bap[indirs[i].in_off]);
220 if (i == num)
221 break;
222 i++;
223 if (nb != 0) {
224 brelse(bp, 0);
225 continue;
226 }
227 pref = ext2fs_blkpref(ip, lbn, 0, (int32_t *)0);
228 error = ext2fs_alloc(ip, lbn, pref, cred, &newb);
229 if (error) {
230 brelse(bp, 0);
231 goto fail;
232 }
233 nb = newb;
234 *allocblk++ = nb;
235 ip->i_e2fs_last_blk = newb;
236 nbp = getblk(vp, indirs[i].in_lbn, fs->e2fs_bsize, 0, 0);
237 nbp->b_blkno = EXT2_FSBTODB(fs, nb);
238 clrbuf(nbp);
239 /*
240 * Write synchronously so that indirect blocks
241 * never point at garbage.
242 */
243 if ((error = bwrite(nbp)) != 0) {
244 brelse(bp, 0);
245 goto fail;
246 }
247 if (unwindidx < 0)
248 unwindidx = i - 1;
249 /* XXX ondisk32 */
250 bap[indirs[i - 1].in_off] = h2fs32((int32_t)nb);
251 /*
252 * If required, write synchronously, otherwise use
253 * delayed write.
254 */
255 if (flags & B_SYNC) {
256 bwrite(bp);
257 } else {
258 bdwrite(bp);
259 }
260 }
261 /*
262 * Get the data block, allocating if necessary.
263 */
264 if (nb == 0) {
265 pref = ext2fs_blkpref(ip, lbn, indirs[num].in_off, &bap[0]);
266 error = ext2fs_alloc(ip, lbn, pref, cred, &newb);
267 if (error) {
268 brelse(bp, 0);
269 goto fail;
270 }
271 nb = newb;
272 *allocblk++ = nb;
273 ip->i_e2fs_last_lblk = lbn;
274 ip->i_e2fs_last_blk = newb;
275 /* XXX ondisk32 */
276 bap[indirs[num].in_off] = h2fs32((int32_t)nb);
277 /*
278 * If required, write synchronously, otherwise use
279 * delayed write.
280 */
281 if (flags & B_SYNC) {
282 bwrite(bp);
283 } else {
284 bdwrite(bp);
285 }
286 if (bpp != NULL) {
287 nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
288 nbp->b_blkno = EXT2_FSBTODB(fs, nb);
289 if (flags & B_CLRBUF)
290 clrbuf(nbp);
291 *bpp = nbp;
292 }
293 return 0;
294 }
295 brelse(bp, 0);
296 if (bpp != NULL) {
297 if (flags & B_CLRBUF) {
298 error = bread(vp, lbn, (int)fs->e2fs_bsize,
299 B_MODIFY, &nbp);
300 if (error) {
301 goto fail;
302 }
303 } else {
304 nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
305 nbp->b_blkno = EXT2_FSBTODB(fs, nb);
306 }
307 *bpp = nbp;
308 }
309 return 0;
310 fail:
311 /*
312 * If we have failed part way through block allocation, we
313 * have to deallocate any indirect blocks that we have allocated.
314 */
315 for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) {
316 ext2fs_blkfree(ip, *blkp);
317 deallocated += fs->e2fs_bsize;
318 }
319 if (unwindidx >= 0) {
320 if (unwindidx == 0) {
321 *allocib = 0;
322 } else {
323 int r;
324
325 r = bread(vp, indirs[unwindidx].in_lbn,
326 (int)fs->e2fs_bsize, B_MODIFY, &bp);
327 if (r) {
328 panic("%s: Could not unwind indirect block, "
329 "error %d", __func__, r);
330 } else {
331 bap = (int32_t *)bp->b_data; /* XXX ondisk32 */
332 bap[indirs[unwindidx].in_off] = 0;
333 if (flags & B_SYNC)
334 bwrite(bp);
335 else
336 bdwrite(bp);
337 }
338 }
339 for (i = unwindidx + 1; i <= num; i++) {
340 bp = getblk(vp, indirs[i].in_lbn, (int)fs->e2fs_bsize,
341 0, 0);
342 brelse(bp, BC_INVAL);
343 }
344 }
345 if (deallocated) {
346 ext2fs_setnblock(ip, ext2fs_nblock(ip) - btodb(deallocated));
347 ip->i_e2fs_flags |= IN_CHANGE | IN_UPDATE;
348 }
349 return error;
350 }
351
352 int
ext2fs_gop_alloc(struct vnode * vp,off_t off,off_t len,int flags,kauth_cred_t cred)353 ext2fs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
354 kauth_cred_t cred)
355 {
356 struct inode *ip = VTOI(vp);
357 struct m_ext2fs *fs = ip->i_e2fs;
358 int error, delta, bshift, bsize;
359 UVMHIST_FUNC("ext2fs_gop_alloc"); UVMHIST_CALLED(ubchist);
360
361 bshift = fs->e2fs_bshift;
362 bsize = 1 << bshift;
363
364 delta = off & (bsize - 1);
365 off -= delta;
366 len += delta;
367
368 while (len > 0) {
369 bsize = uimin(bsize, len);
370 UVMHIST_LOG(ubchist, "off 0x%x len 0x%x bsize 0x%x",
371 off, len, bsize, 0);
372
373 error = ext2fs_balloc(ip, ext2_lblkno(fs, off), bsize, cred,
374 NULL, flags);
375 if (error) {
376 UVMHIST_LOG(ubchist, "error %d", error, 0, 0, 0);
377 return error;
378 }
379
380 /*
381 * increase file size now, ext2fs_balloc() requires that
382 * EOF be up-to-date before each call.
383 */
384
385 if (ext2fs_size(ip) < off + bsize) {
386 UVMHIST_LOG(ubchist, "old 0x%lx%8lx new 0x%lx%8lx",
387 /* Note that arguments are always cast to u_long. */
388 ext2fs_size(ip) >> 32,
389 ext2fs_size(ip) & 0xffffffff,
390 (off + bsize) >> 32,
391 (off + bsize) & 0xffffffff);
392 error = ext2fs_setsize(ip, off + bsize);
393 if (error) {
394 UVMHIST_LOG(ubchist, "error %d",
395 error, 0, 0, 0);
396 return error;
397 }
398 }
399
400 off += bsize;
401 len -= bsize;
402 }
403 return 0;
404 }
405