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 static s64 extRoundDown(s64 nb); 20 21 #define DPD(a) (printk("(a): %d\n",(a))) 22 #define DPC(a) (printk("(a): %c\n",(a))) 23 #define DPL1(a) \ 24 { \ 25 if ((a) >> 32) \ 26 printk("(a): %x%08x ",(a)); \ 27 else \ 28 printk("(a): %x ",(a) << 32); \ 29 } 30 #define DPL(a) \ 31 { \ 32 if ((a) >> 32) \ 33 printk("(a): %x%08x\n",(a)); \ 34 else \ 35 printk("(a): %x\n",(a) << 32); \ 36 } 37 38 #define DPD1(a) (printk("(a): %d ",(a))) 39 #define DPX(a) (printk("(a): %08x\n",(a))) 40 #define DPX1(a) (printk("(a): %08x ",(a))) 41 #define DPS(a) (printk("%s\n",(a))) 42 #define DPE(a) (printk("\nENTERING: %s\n",(a))) 43 #define DPE1(a) (printk("\nENTERING: %s",(a))) 44 #define DPS1(a) (printk(" %s ",(a))) 45 46 47 /* 48 * NAME: extAlloc() 49 * 50 * FUNCTION: allocate an extent for a specified page range within a 51 * file. 52 * 53 * PARAMETERS: 54 * ip - the inode of the file. 55 * xlen - requested extent length. 56 * pno - the starting page number with the file. 57 * xp - pointer to an xad. on entry, xad describes an 58 * extent that is used as an allocation hint if the 59 * xaddr of the xad is non-zero. on successful exit, 60 * the xad describes the newly allocated extent. 61 * abnr - bool indicating whether the newly allocated extent 62 * should be marked as allocated but not recorded. 63 * 64 * RETURN VALUES: 65 * 0 - success 66 * -EIO - i/o error. 67 * -ENOSPC - insufficient disk resources. 68 */ 69 int 70 extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr) 71 { 72 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 73 s64 nxlen, nxaddr, xoff, hint, xaddr = 0; 74 int rc; 75 int xflag; 76 77 /* This blocks if we are low on resources */ 78 txBeginAnon(ip->i_sb); 79 80 /* Avoid race with jfs_commit_inode() */ 81 mutex_lock(&JFS_IP(ip)->commit_mutex); 82 83 /* validate extent length */ 84 if (xlen > MAXXLEN) 85 xlen = MAXXLEN; 86 87 /* get the page's starting extent offset */ 88 xoff = pno << sbi->l2nbperpage; 89 90 /* check if an allocation hint was provided */ 91 if ((hint = addressXAD(xp))) { 92 /* get the size of the extent described by the hint */ 93 nxlen = lengthXAD(xp); 94 95 /* check if the hint is for the portion of the file 96 * immediately previous to the current allocation 97 * request and if hint extent has the same abnr 98 * value as the current request. if so, we can 99 * extend the hint extent to include the current 100 * extent if we can allocate the blocks immediately 101 * following the hint extent. 102 */ 103 if (offsetXAD(xp) + nxlen == xoff && 104 abnr == ((xp->flag & XAD_NOTRECORDED) ? true : false)) 105 xaddr = hint + nxlen; 106 107 /* adjust the hint to the last block of the extent */ 108 hint += (nxlen - 1); 109 } 110 111 /* allocate the disk blocks for the extent. initially, extBalloc() 112 * will try to allocate disk blocks for the requested size (xlen). 113 * if this fails (xlen contiguous free blocks not available), it'll 114 * try to allocate a smaller number of blocks (producing a smaller 115 * extent), with this smaller number of blocks consisting of the 116 * requested number of blocks rounded down to the next smaller 117 * power of 2 number (i.e. 16 -> 8). it'll continue to round down 118 * and retry the allocation until the number of blocks to allocate 119 * is smaller than the number of blocks per page. 120 */ 121 nxlen = xlen; 122 if ((rc = extBalloc(ip, hint ? hint : INOHINT(ip), &nxlen, &nxaddr))) { 123 mutex_unlock(&JFS_IP(ip)->commit_mutex); 124 return (rc); 125 } 126 127 /* Allocate blocks to quota. */ 128 rc = dquot_alloc_block(ip, nxlen); 129 if (rc) { 130 dbFree(ip, nxaddr, (s64) nxlen); 131 mutex_unlock(&JFS_IP(ip)->commit_mutex); 132 return rc; 133 } 134 135 /* determine the value of the extent flag */ 136 xflag = abnr ? XAD_NOTRECORDED : 0; 137 138 /* if we can extend the hint extent to cover the current request, 139 * extend it. otherwise, insert a new extent to 140 * cover the current request. 141 */ 142 if (xaddr && xaddr == nxaddr) 143 rc = xtExtend(0, ip, xoff, (int) nxlen, 0); 144 else 145 rc = xtInsert(0, ip, xflag, xoff, (int) nxlen, &nxaddr, 0); 146 147 /* if the extend or insert failed, 148 * free the newly allocated blocks and return the error. 149 */ 150 if (rc) { 151 dbFree(ip, nxaddr, nxlen); 152 dquot_free_block(ip, nxlen); 153 mutex_unlock(&JFS_IP(ip)->commit_mutex); 154 return (rc); 155 } 156 157 /* set the results of the extent allocation */ 158 XADaddress(xp, nxaddr); 159 XADlength(xp, nxlen); 160 XADoffset(xp, xoff); 161 xp->flag = xflag; 162 163 mark_inode_dirty(ip); 164 165 mutex_unlock(&JFS_IP(ip)->commit_mutex); 166 /* 167 * COMMIT_SyncList flags an anonymous tlock on page that is on 168 * sync list. 169 * We need to commit the inode to get the page written to the disk. 170 */ 171 if (test_and_clear_cflag(COMMIT_Synclist,ip)) 172 jfs_commit_inode(ip, 0); 173 174 return (0); 175 } 176 177 /* 178 * NAME: extHint() 179 * 180 * FUNCTION: produce an extent allocation hint for a file offset. 181 * 182 * PARAMETERS: 183 * ip - the inode of the file. 184 * offset - file offset for which the hint is needed. 185 * xp - pointer to the xad that is to be filled in with 186 * the hint. 187 * 188 * RETURN VALUES: 189 * 0 - success 190 * -EIO - i/o error. 191 */ 192 int extHint(struct inode *ip, s64 offset, xad_t * xp) 193 { 194 struct super_block *sb = ip->i_sb; 195 int nbperpage = JFS_SBI(sb)->nbperpage; 196 s64 prev; 197 int rc = 0; 198 s64 xaddr; 199 int xlen; 200 int xflag; 201 202 /* init the hint as "no hint provided" */ 203 XADaddress(xp, 0); 204 205 /* determine the starting extent offset of the page previous 206 * to the page containing the offset. 207 */ 208 prev = ((offset & ~POFFSET) >> JFS_SBI(sb)->l2bsize) - nbperpage; 209 210 /* if the offset is in the first page of the file, no hint provided. 211 */ 212 if (prev < 0) 213 goto out; 214 215 rc = xtLookup(ip, prev, nbperpage, &xflag, &xaddr, &xlen, 0); 216 217 if ((rc == 0) && xlen) { 218 if (xlen != nbperpage) { 219 jfs_error(ip->i_sb, "corrupt xtree\n"); 220 rc = -EIO; 221 } 222 XADaddress(xp, xaddr); 223 XADlength(xp, xlen); 224 XADoffset(xp, prev); 225 /* 226 * only preserve the abnr flag within the xad flags 227 * of the returned hint. 228 */ 229 xp->flag = xflag & XAD_NOTRECORDED; 230 } else 231 rc = 0; 232 233 out: 234 return (rc); 235 } 236 237 238 /* 239 * NAME: extRecord() 240 * 241 * FUNCTION: change a page with a file from not recorded to recorded. 242 * 243 * PARAMETERS: 244 * ip - inode of the file. 245 * cp - cbuf of the file page. 246 * 247 * RETURN VALUES: 248 * 0 - success 249 * -EIO - i/o error. 250 * -ENOSPC - insufficient disk resources. 251 */ 252 int extRecord(struct inode *ip, xad_t * xp) 253 { 254 int rc; 255 256 txBeginAnon(ip->i_sb); 257 258 mutex_lock(&JFS_IP(ip)->commit_mutex); 259 260 /* update the extent */ 261 rc = xtUpdate(0, ip, xp); 262 263 mutex_unlock(&JFS_IP(ip)->commit_mutex); 264 return rc; 265 } 266 267 /* 268 * NAME: extBalloc() 269 * 270 * FUNCTION: allocate disk blocks to form an extent. 271 * 272 * initially, we will try to allocate disk blocks for the 273 * requested size (nblocks). if this fails (nblocks 274 * contiguous free blocks not available), we'll try to allocate 275 * a smaller number of blocks (producing a smaller extent), with 276 * this smaller number of blocks consisting of the requested 277 * number of blocks rounded down to the next smaller power of 2 278 * number (i.e. 16 -> 8). we'll continue to round down and 279 * retry the allocation until the number of blocks to allocate 280 * is smaller than the number of blocks per page. 281 * 282 * PARAMETERS: 283 * ip - the inode of the file. 284 * hint - disk block number to be used as an allocation hint. 285 * *nblocks - pointer to an s64 value. on entry, this value specifies 286 * the desired number of block to be allocated. on successful 287 * exit, this value is set to the number of blocks actually 288 * allocated. 289 * blkno - pointer to a block address that is filled in on successful 290 * return with the starting block number of the newly 291 * allocated block range. 292 * 293 * RETURN VALUES: 294 * 0 - success 295 * -EIO - i/o error. 296 * -ENOSPC - insufficient disk resources. 297 */ 298 static int 299 extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno) 300 { 301 struct jfs_inode_info *ji = JFS_IP(ip); 302 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 303 s64 nb, nblks, daddr, max; 304 int rc, nbperpage = sbi->nbperpage; 305 struct bmap *bmp = sbi->bmap; 306 int ag; 307 308 /* get the number of blocks to initially attempt to allocate. 309 * we'll first try the number of blocks requested unless this 310 * number is greater than the maximum number of contiguous free 311 * blocks in the map. in that case, we'll start off with the 312 * maximum free. 313 */ 314 315 /* give up if no space left */ 316 if (bmp->db_maxfreebud == -1) 317 return -ENOSPC; 318 319 max = (s64) 1 << bmp->db_maxfreebud; 320 if (*nblocks >= max && *nblocks > nbperpage) 321 nb = nblks = (max > nbperpage) ? max : nbperpage; 322 else 323 nb = nblks = *nblocks; 324 325 /* try to allocate blocks */ 326 while ((rc = dbAlloc(ip, hint, nb, &daddr)) != 0) { 327 /* if something other than an out of space error, 328 * stop and return this error. 329 */ 330 if (rc != -ENOSPC) 331 return (rc); 332 333 /* decrease the allocation request size */ 334 nb = min(nblks, extRoundDown(nb)); 335 336 /* give up if we cannot cover a page */ 337 if (nb < nbperpage) 338 return (rc); 339 } 340 341 *nblocks = nb; 342 *blkno = daddr; 343 344 if (S_ISREG(ip->i_mode) && (ji->fileset == FILESYSTEM_I)) { 345 ag = BLKTOAG(daddr, sbi); 346 spin_lock_irq(&ji->ag_lock); 347 if (ji->active_ag == -1) { 348 atomic_inc(&bmp->db_active[ag]); 349 ji->active_ag = ag; 350 } else if (ji->active_ag != ag) { 351 atomic_dec(&bmp->db_active[ji->active_ag]); 352 atomic_inc(&bmp->db_active[ag]); 353 ji->active_ag = ag; 354 } 355 spin_unlock_irq(&ji->ag_lock); 356 } 357 358 return (0); 359 } 360 361 /* 362 * NAME: extRoundDown() 363 * 364 * FUNCTION: round down a specified number of blocks to the next 365 * smallest power of 2 number. 366 * 367 * PARAMETERS: 368 * nb - the inode of the file. 369 * 370 * RETURN VALUES: 371 * next smallest power of 2 number. 372 */ 373 static s64 extRoundDown(s64 nb) 374 { 375 int i; 376 u64 m, k; 377 378 for (i = 0, m = (u64) 1 << 63; i < 64; i++, m >>= 1) { 379 if (m & nb) 380 break; 381 } 382 383 i = 63 - i; 384 k = (u64) 1 << i; 385 k = ((k - 1) & nb) ? k : k >> 1; 386 387 return (k); 388 } 389