1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) International Business Machines Corp., 2000-2004
4 */
5
6 #include <linux/fs.h>
7 #include <linux/quotaops.h>
8 #include "jfs_incore.h"
9 #include "jfs_inode.h"
10 #include "jfs_superblock.h"
11 #include "jfs_dmap.h"
12 #include "jfs_extent.h"
13 #include "jfs_debug.h"
14
15 /*
16 * forward references
17 */
18 static int extBalloc(struct inode *, s64, s64 *, s64 *);
19 #ifdef _NOTYET
20 static int extBrealloc(struct inode *, s64, s64, s64 *, s64 *);
21 #endif
22 static s64 extRoundDown(s64 nb);
23
24 #define DPD(a) (printk("(a): %d\n",(a)))
25 #define DPC(a) (printk("(a): %c\n",(a)))
26 #define DPL1(a) \
27 { \
28 if ((a) >> 32) \
29 printk("(a): %x%08x ",(a)); \
30 else \
31 printk("(a): %x ",(a) << 32); \
32 }
33 #define DPL(a) \
34 { \
35 if ((a) >> 32) \
36 printk("(a): %x%08x\n",(a)); \
37 else \
38 printk("(a): %x\n",(a) << 32); \
39 }
40
41 #define DPD1(a) (printk("(a): %d ",(a)))
42 #define DPX(a) (printk("(a): %08x\n",(a)))
43 #define DPX1(a) (printk("(a): %08x ",(a)))
44 #define DPS(a) (printk("%s\n",(a)))
45 #define DPE(a) (printk("\nENTERING: %s\n",(a)))
46 #define DPE1(a) (printk("\nENTERING: %s",(a)))
47 #define DPS1(a) (printk(" %s ",(a)))
48
49
50 /*
51 * NAME: extAlloc()
52 *
53 * FUNCTION: allocate an extent for a specified page range within a
54 * file.
55 *
56 * PARAMETERS:
57 * ip - the inode of the file.
58 * xlen - requested extent length.
59 * pno - the starting page number with the file.
60 * xp - pointer to an xad. on entry, xad describes an
61 * extent that is used as an allocation hint if the
62 * xaddr of the xad is non-zero. on successful exit,
63 * the xad describes the newly allocated extent.
64 * abnr - bool indicating whether the newly allocated extent
65 * should be marked as allocated but not recorded.
66 *
67 * RETURN VALUES:
68 * 0 - success
69 * -EIO - i/o error.
70 * -ENOSPC - insufficient disk resources.
71 */
72 int
73 extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
74 {
75 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
76 s64 nxlen, nxaddr, xoff, hint, xaddr = 0;
77 int rc;
78 int xflag;
79
80 /* This blocks if we are low on resources */
81 txBeginAnon(ip->i_sb);
82
83 /* Avoid race with jfs_commit_inode() */
84 mutex_lock(&JFS_IP(ip)->commit_mutex);
85
86 /* validate extent length */
87 if (xlen > MAXXLEN)
88 xlen = MAXXLEN;
89
90 /* get the page's starting extent offset */
91 xoff = pno << sbi->l2nbperpage;
92
93 /* check if an allocation hint was provided */
94 if ((hint = addressXAD(xp))) {
95 /* get the size of the extent described by the hint */
96 nxlen = lengthXAD(xp);
97
98 /* check if the hint is for the portion of the file
99 * immediately previous to the current allocation
100 * request and if hint extent has the same abnr
101 * value as the current request. if so, we can
102 * extend the hint extent to include the current
103 * extent if we can allocate the blocks immediately
104 * following the hint extent.
105 */
106 if (offsetXAD(xp) + nxlen == xoff &&
107 abnr == ((xp->flag & XAD_NOTRECORDED) ? true : false))
108 xaddr = hint + nxlen;
109
110 /* adjust the hint to the last block of the extent */
111 hint += (nxlen - 1);
112 }
113
114 /* allocate the disk blocks for the extent. initially, extBalloc()
115 * will try to allocate disk blocks for the requested size (xlen).
116 * if this fails (xlen contiguous free blocks not available), it'll
117 * try to allocate a smaller number of blocks (producing a smaller
118 * extent), with this smaller number of blocks consisting of the
119 * requested number of blocks rounded down to the next smaller
120 * power of 2 number (i.e. 16 -> 8). it'll continue to round down
121 * and retry the allocation until the number of blocks to allocate
122 * is smaller than the number of blocks per page.
123 */
124 nxlen = xlen;
125 if ((rc = extBalloc(ip, hint ? hint : INOHINT(ip), &nxlen, &nxaddr))) {
126 mutex_unlock(&JFS_IP(ip)->commit_mutex);
127 return (rc);
128 }
129
130 /* Allocate blocks to quota. */
131 rc = dquot_alloc_block(ip, nxlen);
132 if (rc) {
133 dbFree(ip, nxaddr, (s64) nxlen);
134 mutex_unlock(&JFS_IP(ip)->commit_mutex);
135 return rc;
136 }
137
138 /* determine the value of the extent flag */
139 xflag = abnr ? XAD_NOTRECORDED : 0;
140
141 /* if we can extend the hint extent to cover the current request,
142 * extend it. otherwise, insert a new extent to
143 * cover the current request.
144 */
145 if (xaddr && xaddr == nxaddr)
146 rc = xtExtend(0, ip, xoff, (int) nxlen, 0);
147 else
148 rc = xtInsert(0, ip, xflag, xoff, (int) nxlen, &nxaddr, 0);
149
150 /* if the extend or insert failed,
151 * free the newly allocated blocks and return the error.
152 */
153 if (rc) {
154 dbFree(ip, nxaddr, nxlen);
155 dquot_free_block(ip, nxlen);
156 mutex_unlock(&JFS_IP(ip)->commit_mutex);
157 return (rc);
158 }
159
160 /* set the results of the extent allocation */
161 XADaddress(xp, nxaddr);
162 XADlength(xp, nxlen);
163 XADoffset(xp, xoff);
164 xp->flag = xflag;
165
166 mark_inode_dirty(ip);
167
168 mutex_unlock(&JFS_IP(ip)->commit_mutex);
169 /*
170 * COMMIT_SyncList flags an anonymous tlock on page that is on
171 * sync list.
172 * We need to commit the inode to get the page written disk.
173 */
174 if (test_and_clear_cflag(COMMIT_Synclist,ip))
175 jfs_commit_inode(ip, 0);
176
177 return (0);
178 }
179
180
181 #ifdef _NOTYET
182 /*
183 * NAME: extRealloc()
184 *
185 * FUNCTION: extend the allocation of a file extent containing a
186 * partial back last page.
187 *
188 * PARAMETERS:
189 * ip - the inode of the file.
190 * cp - cbuf for the partial backed last page.
191 * xlen - request size of the resulting extent.
192 * xp - pointer to an xad. on successful exit, the xad
193 * describes the newly allocated extent.
194 * abnr - bool indicating whether the newly allocated extent
195 * should be marked as allocated but not recorded.
196 *
197 * RETURN VALUES:
198 * 0 - success
199 * -EIO - i/o error.
200 * -ENOSPC - insufficient disk resources.
201 */
202 int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
203 {
204 struct super_block *sb = ip->i_sb;
205 s64 xaddr, xlen, nxaddr, delta, xoff;
206 s64 ntail, nextend, ninsert;
207 int rc, nbperpage = JFS_SBI(sb)->nbperpage;
208 int xflag;
209
210 /* This blocks if we are low on resources */
211 txBeginAnon(ip->i_sb);
212
213 mutex_lock(&JFS_IP(ip)->commit_mutex);
214 /* validate extent length */
215 if (nxlen > MAXXLEN)
216 nxlen = MAXXLEN;
217
218 /* get the extend (partial) page's disk block address and
219 * number of blocks.
220 */
221 xaddr = addressXAD(xp);
222 xlen = lengthXAD(xp);
223 xoff = offsetXAD(xp);
224
225 /* if the extend page is abnr and if the request is for
226 * the extent to be allocated and recorded,
227 * make the page allocated and recorded.
228 */
229 if ((xp->flag & XAD_NOTRECORDED) && !abnr) {
230 xp->flag = 0;
231 if ((rc = xtUpdate(0, ip, xp)))
232 goto exit;
233 }
234
235 /* try to allocated the request number of blocks for the
236 * extent. dbRealloc() first tries to satisfy the request
237 * by extending the allocation in place. otherwise, it will
238 * try to allocate a new set of blocks large enough for the
239 * request. in satisfying a request, dbReAlloc() may allocate
240 * less than what was request but will always allocate enough
241 * space as to satisfy the extend page.
242 */
243 if ((rc = extBrealloc(ip, xaddr, xlen, &nxlen, &nxaddr)))
244 goto exit;
245
246 /* Allocat blocks to quota. */
247 rc = dquot_alloc_block(ip, nxlen);
248 if (rc) {
249 dbFree(ip, nxaddr, (s64) nxlen);
250 mutex_unlock(&JFS_IP(ip)->commit_mutex);
251 return rc;
252 }
253
254 delta = nxlen - xlen;
255
256 /* check if the extend page is not abnr but the request is abnr
257 * and the allocated disk space is for more than one page. if this
258 * is the case, there is a miss match of abnr between the extend page
259 * and the one or more pages following the extend page. as a result,
260 * two extents will have to be manipulated. the first will be that
261 * of the extent of the extend page and will be manipulated thru
262 * an xtExtend() or an xtTailgate(), depending upon whether the
263 * disk allocation occurred as an inplace extension. the second
264 * extent will be manipulated (created) through an xtInsert() and
265 * will be for the pages following the extend page.
266 */
267 if (abnr && (!(xp->flag & XAD_NOTRECORDED)) && (nxlen > nbperpage)) {
268 ntail = nbperpage;
269 nextend = ntail - xlen;
270 ninsert = nxlen - nbperpage;
271
272 xflag = XAD_NOTRECORDED;
273 } else {
274 ntail = nxlen;
275 nextend = delta;
276 ninsert = 0;
277
278 xflag = xp->flag;
279 }
280
281 /* if we were able to extend the disk allocation in place,
282 * extend the extent. otherwise, move the extent to a
283 * new disk location.
284 */
285 if (xaddr == nxaddr) {
286 /* extend the extent */
287 if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
288 dbFree(ip, xaddr + xlen, delta);
289 dquot_free_block(ip, nxlen);
290 goto exit;
291 }
292 } else {
293 /*
294 * move the extent to a new location:
295 *
296 * xtTailgate() accounts for relocated tail extent;
297 */
298 if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
299 dbFree(ip, nxaddr, nxlen);
300 dquot_free_block(ip, nxlen);
301 goto exit;
302 }
303 }
304
305
306 /* check if we need to also insert a new extent */
307 if (ninsert) {
308 /* perform the insert. if it fails, free the blocks
309 * to be inserted and make it appear that we only did
310 * the xtExtend() or xtTailgate() above.
311 */
312 xaddr = nxaddr + ntail;
313 if (xtInsert (0, ip, xflag, xoff + ntail, (int) ninsert,
314 &xaddr, 0)) {
315 dbFree(ip, xaddr, (s64) ninsert);
316 delta = nextend;
317 nxlen = ntail;
318 xflag = 0;
319 }
320 }
321
322 /* set the return results */
323 XADaddress(xp, nxaddr);
324 XADlength(xp, nxlen);
325 XADoffset(xp, xoff);
326 xp->flag = xflag;
327
328 mark_inode_dirty(ip);
329 exit:
330 mutex_unlock(&JFS_IP(ip)->commit_mutex);
331 return (rc);
332 }
333 #endif /* _NOTYET */
334
335
336 /*
337 * NAME: extHint()
338 *
339 * FUNCTION: produce an extent allocation hint for a file offset.
340 *
341 * PARAMETERS:
342 * ip - the inode of the file.
343 * offset - file offset for which the hint is needed.
344 * xp - pointer to the xad that is to be filled in with
345 * the hint.
346 *
347 * RETURN VALUES:
348 * 0 - success
349 * -EIO - i/o error.
350 */
351 int extHint(struct inode *ip, s64 offset, xad_t * xp)
352 {
353 struct super_block *sb = ip->i_sb;
354 int nbperpage = JFS_SBI(sb)->nbperpage;
355 s64 prev;
356 int rc = 0;
357 s64 xaddr;
358 int xlen;
359 int xflag;
360
361 /* init the hint as "no hint provided" */
362 XADaddress(xp, 0);
363
364 /* determine the starting extent offset of the page previous
365 * to the page containing the offset.
366 */
367 prev = ((offset & ~POFFSET) >> JFS_SBI(sb)->l2bsize) - nbperpage;
368
369 /* if the offset is in the first page of the file, no hint provided.
370 */
371 if (prev < 0)
372 goto out;
373
374 rc = xtLookup(ip, prev, nbperpage, &xflag, &xaddr, &xlen, 0);
375
376 if ((rc == 0) && xlen) {
377 if (xlen != nbperpage) {
378 jfs_error(ip->i_sb, "corrupt xtree\n");
379 rc = -EIO;
380 }
381 XADaddress(xp, xaddr);
382 XADlength(xp, xlen);
383 XADoffset(xp, prev);
384 /*
385 * only preserve the abnr flag within the xad flags
386 * of the returned hint.
387 */
388 xp->flag = xflag & XAD_NOTRECORDED;
389 } else
390 rc = 0;
391
392 out:
393 return (rc);
394 }
395
396
397 /*
398 * NAME: extRecord()
399 *
400 * FUNCTION: change a page with a file from not recorded to recorded.
401 *
402 * PARAMETERS:
403 * ip - inode of the file.
404 * cp - cbuf of the file page.
405 *
406 * RETURN VALUES:
407 * 0 - success
408 * -EIO - i/o error.
409 * -ENOSPC - insufficient disk resources.
410 */
411 int extRecord(struct inode *ip, xad_t * xp)
412 {
413 int rc;
414
415 txBeginAnon(ip->i_sb);
416
417 mutex_lock(&JFS_IP(ip)->commit_mutex);
418
419 /* update the extent */
420 rc = xtUpdate(0, ip, xp);
421
422 mutex_unlock(&JFS_IP(ip)->commit_mutex);
423 return rc;
424 }
425
426
427 #ifdef _NOTYET
428 /*
429 * NAME: extFill()
430 *
431 * FUNCTION: allocate disk space for a file page that represents
432 * a file hole.
433 *
434 * PARAMETERS:
435 * ip - the inode of the file.
436 * cp - cbuf of the file page represent the hole.
437 *
438 * RETURN VALUES:
439 * 0 - success
440 * -EIO - i/o error.
441 * -ENOSPC - insufficient disk resources.
442 */
443 int extFill(struct inode *ip, xad_t * xp)
444 {
445 int rc, nbperpage = JFS_SBI(ip->i_sb)->nbperpage;
446 s64 blkno = offsetXAD(xp) >> ip->i_blkbits;
447
448 // assert(ISSPARSE(ip));
449
450 /* initialize the extent allocation hint */
451 XADaddress(xp, 0);
452
453 /* allocate an extent to fill the hole */
454 if ((rc = extAlloc(ip, nbperpage, blkno, xp, false)))
455 return (rc);
456
457 assert(lengthPXD(xp) == nbperpage);
458
459 return (0);
460 }
461 #endif /* _NOTYET */
462
463
464 /*
465 * NAME: extBalloc()
466 *
467 * FUNCTION: allocate disk blocks to form an extent.
468 *
469 * initially, we will try to allocate disk blocks for the
470 * requested size (nblocks). if this fails (nblocks
471 * contiguous free blocks not available), we'll try to allocate
472 * a smaller number of blocks (producing a smaller extent), with
473 * this smaller number of blocks consisting of the requested
474 * number of blocks rounded down to the next smaller power of 2
475 * number (i.e. 16 -> 8). we'll continue to round down and
476 * retry the allocation until the number of blocks to allocate
477 * is smaller than the number of blocks per page.
478 *
479 * PARAMETERS:
480 * ip - the inode of the file.
481 * hint - disk block number to be used as an allocation hint.
482 * *nblocks - pointer to an s64 value. on entry, this value specifies
483 * the desired number of block to be allocated. on successful
484 * exit, this value is set to the number of blocks actually
485 * allocated.
486 * blkno - pointer to a block address that is filled in on successful
487 * return with the starting block number of the newly
488 * allocated block range.
489 *
490 * RETURN VALUES:
491 * 0 - success
492 * -EIO - i/o error.
493 * -ENOSPC - insufficient disk resources.
494 */
495 static int
496 extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno)
497 {
498 struct jfs_inode_info *ji = JFS_IP(ip);
499 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
500 s64 nb, nblks, daddr, max;
501 int rc, nbperpage = sbi->nbperpage;
502 struct bmap *bmp = sbi->bmap;
503 int ag;
504
505 /* get the number of blocks to initially attempt to allocate.
506 * we'll first try the number of blocks requested unless this
507 * number is greater than the maximum number of contiguous free
508 * blocks in the map. in that case, we'll start off with the
509 * maximum free.
510 */
511 max = (s64) 1 << bmp->db_maxfreebud;
512 if (*nblocks >= max && *nblocks > nbperpage)
513 nb = nblks = (max > nbperpage) ? max : nbperpage;
514 else
515 nb = nblks = *nblocks;
516
517 /* try to allocate blocks */
518 while ((rc = dbAlloc(ip, hint, nb, &daddr)) != 0) {
519 /* if something other than an out of space error,
520 * stop and return this error.
521 */
522 if (rc != -ENOSPC)
523 return (rc);
524
525 /* decrease the allocation request size */
526 nb = min(nblks, extRoundDown(nb));
527
528 /* give up if we cannot cover a page */
529 if (nb < nbperpage)
530 return (rc);
531 }
532
533 *nblocks = nb;
534 *blkno = daddr;
535
536 if (S_ISREG(ip->i_mode) && (ji->fileset == FILESYSTEM_I)) {
537 ag = BLKTOAG(daddr, sbi);
538 spin_lock_irq(&ji->ag_lock);
539 if (ji->active_ag == -1) {
540 atomic_inc(&bmp->db_active[ag]);
541 ji->active_ag = ag;
542 } else if (ji->active_ag != ag) {
543 atomic_dec(&bmp->db_active[ji->active_ag]);
544 atomic_inc(&bmp->db_active[ag]);
545 ji->active_ag = ag;
546 }
547 spin_unlock_irq(&ji->ag_lock);
548 }
549
550 return (0);
551 }
552
553
554 #ifdef _NOTYET
555 /*
556 * NAME: extBrealloc()
557 *
558 * FUNCTION: attempt to extend an extent's allocation.
559 *
560 * Initially, we will try to extend the extent's allocation
561 * in place. If this fails, we'll try to move the extent
562 * to a new set of blocks. If moving the extent, we initially
563 * will try to allocate disk blocks for the requested size
564 * (newnblks). if this fails (new contiguous free blocks not
565 * available), we'll try to allocate a smaller number of
566 * blocks (producing a smaller extent), with this smaller
567 * number of blocks consisting of the requested number of
568 * blocks rounded down to the next smaller power of 2
569 * number (i.e. 16 -> 8). We'll continue to round down and
570 * retry the allocation until the number of blocks to allocate
571 * is smaller than the number of blocks per page.
572 *
573 * PARAMETERS:
574 * ip - the inode of the file.
575 * blkno - starting block number of the extents current allocation.
576 * nblks - number of blocks within the extents current allocation.
577 * newnblks - pointer to a s64 value. on entry, this value is the
578 * the new desired extent size (number of blocks). on
579 * successful exit, this value is set to the extent's actual
580 * new size (new number of blocks).
581 * newblkno - the starting block number of the extents new allocation.
582 *
583 * RETURN VALUES:
584 * 0 - success
585 * -EIO - i/o error.
586 * -ENOSPC - insufficient disk resources.
587 */
588 static int
589 extBrealloc(struct inode *ip,
590 s64 blkno, s64 nblks, s64 * newnblks, s64 * newblkno)
591 {
592 int rc;
593
594 /* try to extend in place */
595 if ((rc = dbExtend(ip, blkno, nblks, *newnblks - nblks)) == 0) {
596 *newblkno = blkno;
597 return (0);
598 } else {
599 if (rc != -ENOSPC)
600 return (rc);
601 }
602
603 /* in place extension not possible.
604 * try to move the extent to a new set of blocks.
605 */
606 return (extBalloc(ip, blkno, newnblks, newblkno));
607 }
608 #endif /* _NOTYET */
609
610
611 /*
612 * NAME: extRoundDown()
613 *
614 * FUNCTION: round down a specified number of blocks to the next
615 * smallest power of 2 number.
616 *
617 * PARAMETERS:
618 * nb - the inode of the file.
619 *
620 * RETURN VALUES:
621 * next smallest power of 2 number.
622 */
623 static s64 extRoundDown(s64 nb)
624 {
625 int i;
626 u64 m, k;
627
628 for (i = 0, m = (u64) 1 << 63; i < 64; i++, m >>= 1) {
629 if (m & nb)
630 break;
631 }
632
633 i = 63 - i;
634 k = (u64) 1 << i;
635 k = ((k - 1) & nb) ? k : k >> 1;
636
637 return (k);
638 }