1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) International Business Machines Corp., 2000-2004 4 */ 5 6 /* 7 * jfs_imap.c: inode allocation map manager 8 * 9 * Serialization: 10 * Each AG has a simple lock which is used to control the serialization of 11 * the AG level lists. This lock should be taken first whenever an AG 12 * level list will be modified or accessed. 13 * 14 * Each IAG is locked by obtaining the buffer for the IAG page. 15 * 16 * There is also a inode lock for the inode map inode. A read lock needs to 17 * be taken whenever an IAG is read from the map or the global level 18 * information is read. A write lock needs to be taken whenever the global 19 * level information is modified or an atomic operation needs to be used. 20 * 21 * If more than one IAG is read at one time, the read lock may not 22 * be given up until all of the IAG's are read. Otherwise, a deadlock 23 * may occur when trying to obtain the read lock while another thread 24 * holding the read lock is waiting on the IAG already being held. 25 * 26 * The control page of the inode map is read into memory by diMount(). 27 * Thereafter it should only be modified in memory and then it will be 28 * written out when the filesystem is unmounted by diUnmount(). 29 */ 30 31 #include <linux/fs.h> 32 #include <linux/buffer_head.h> 33 #include <linux/pagemap.h> 34 #include <linux/quotaops.h> 35 #include <linux/slab.h> 36 37 #include "jfs_incore.h" 38 #include "jfs_inode.h" 39 #include "jfs_filsys.h" 40 #include "jfs_dinode.h" 41 #include "jfs_dmap.h" 42 #include "jfs_imap.h" 43 #include "jfs_metapage.h" 44 #include "jfs_superblock.h" 45 #include "jfs_debug.h" 46 47 /* 48 * imap locks 49 */ 50 /* iag free list lock */ 51 #define IAGFREE_LOCK_INIT(imap) mutex_init(&imap->im_freelock) 52 #define IAGFREE_LOCK(imap) mutex_lock(&imap->im_freelock) 53 #define IAGFREE_UNLOCK(imap) mutex_unlock(&imap->im_freelock) 54 55 /* per ag iag list locks */ 56 #define AG_LOCK_INIT(imap,index) mutex_init(&(imap->im_aglock[index])) 57 #define AG_LOCK(imap,agno) mutex_lock(&imap->im_aglock[agno]) 58 #define AG_UNLOCK(imap,agno) mutex_unlock(&imap->im_aglock[agno]) 59 60 /* 61 * forward references 62 */ 63 static int diAllocAG(struct inomap *, int, bool, struct inode *); 64 static int diAllocAny(struct inomap *, int, bool, struct inode *); 65 static int diAllocBit(struct inomap *, struct iag *, int); 66 static int diAllocExt(struct inomap *, int, struct inode *); 67 static int diAllocIno(struct inomap *, int, struct inode *); 68 static int diFindFree(u32, int); 69 static int diNewExt(struct inomap *, struct iag *, int); 70 static int diNewIAG(struct inomap *, int *, int, struct metapage **); 71 static void duplicateIXtree(struct super_block *, s64, int, s64 *); 72 73 static int diIAGRead(struct inomap * imap, int, struct metapage **); 74 static int copy_from_dinode(struct dinode *, struct inode *); 75 static void copy_to_dinode(struct dinode *, struct inode *); 76 77 /* 78 * NAME: diMount() 79 * 80 * FUNCTION: initialize the incore inode map control structures for 81 * a fileset or aggregate init time. 82 * 83 * the inode map's control structure (dinomap) is 84 * brought in from disk and placed in virtual memory. 85 * 86 * PARAMETERS: 87 * ipimap - pointer to inode map inode for the aggregate or fileset. 88 * 89 * RETURN VALUES: 90 * 0 - success 91 * -ENOMEM - insufficient free virtual memory. 92 * -EIO - i/o error. 93 */ 94 int diMount(struct inode *ipimap) 95 { 96 struct inomap *imap; 97 struct metapage *mp; 98 int index; 99 struct dinomap_disk *dinom_le; 100 101 /* 102 * allocate/initialize the in-memory inode map control structure 103 */ 104 /* allocate the in-memory inode map control structure. */ 105 imap = kmalloc(sizeof(struct inomap), GFP_KERNEL); 106 if (imap == NULL) 107 return -ENOMEM; 108 109 /* read the on-disk inode map control structure. */ 110 111 mp = read_metapage(ipimap, 112 IMAPBLKNO << JFS_SBI(ipimap->i_sb)->l2nbperpage, 113 PSIZE, 0); 114 if (mp == NULL) { 115 kfree(imap); 116 return -EIO; 117 } 118 119 /* copy the on-disk version to the in-memory version. */ 120 dinom_le = (struct dinomap_disk *) mp->data; 121 imap->im_freeiag = le32_to_cpu(dinom_le->in_freeiag); 122 imap->im_nextiag = le32_to_cpu(dinom_le->in_nextiag); 123 atomic_set(&imap->im_numinos, le32_to_cpu(dinom_le->in_numinos)); 124 atomic_set(&imap->im_numfree, le32_to_cpu(dinom_le->in_numfree)); 125 imap->im_nbperiext = le32_to_cpu(dinom_le->in_nbperiext); 126 imap->im_l2nbperiext = le32_to_cpu(dinom_le->in_l2nbperiext); 127 for (index = 0; index < MAXAG; index++) { 128 imap->im_agctl[index].inofree = 129 le32_to_cpu(dinom_le->in_agctl[index].inofree); 130 imap->im_agctl[index].extfree = 131 le32_to_cpu(dinom_le->in_agctl[index].extfree); 132 imap->im_agctl[index].numinos = 133 le32_to_cpu(dinom_le->in_agctl[index].numinos); 134 imap->im_agctl[index].numfree = 135 le32_to_cpu(dinom_le->in_agctl[index].numfree); 136 } 137 138 /* release the buffer. */ 139 release_metapage(mp); 140 141 /* 142 * allocate/initialize inode allocation map locks 143 */ 144 /* allocate and init iag free list lock */ 145 IAGFREE_LOCK_INIT(imap); 146 147 /* allocate and init ag list locks */ 148 for (index = 0; index < MAXAG; index++) { 149 AG_LOCK_INIT(imap, index); 150 } 151 152 /* bind the inode map inode and inode map control structure 153 * to each other. 154 */ 155 imap->im_ipimap = ipimap; 156 JFS_IP(ipimap)->i_imap = imap; 157 158 return (0); 159 } 160 161 162 /* 163 * NAME: diUnmount() 164 * 165 * FUNCTION: write to disk the incore inode map control structures for 166 * a fileset or aggregate at unmount time. 167 * 168 * PARAMETERS: 169 * ipimap - pointer to inode map inode for the aggregate or fileset. 170 * 171 * RETURN VALUES: 172 * 0 - success 173 * -ENOMEM - insufficient free virtual memory. 174 * -EIO - i/o error. 175 */ 176 int diUnmount(struct inode *ipimap, int mounterror) 177 { 178 struct inomap *imap = JFS_IP(ipimap)->i_imap; 179 180 /* 181 * update the on-disk inode map control structure 182 */ 183 184 if (!(mounterror || isReadOnly(ipimap))) 185 diSync(ipimap); 186 187 /* 188 * Invalidate the page cache buffers 189 */ 190 truncate_inode_pages(ipimap->i_mapping, 0); 191 192 /* 193 * free in-memory control structure 194 */ 195 kfree(imap); 196 JFS_IP(ipimap)->i_imap = NULL; 197 198 return (0); 199 } 200 201 202 /* 203 * diSync() 204 */ 205 int diSync(struct inode *ipimap) 206 { 207 struct dinomap_disk *dinom_le; 208 struct inomap *imp = JFS_IP(ipimap)->i_imap; 209 struct metapage *mp; 210 int index; 211 212 /* 213 * write imap global conrol page 214 */ 215 /* read the on-disk inode map control structure */ 216 mp = get_metapage(ipimap, 217 IMAPBLKNO << JFS_SBI(ipimap->i_sb)->l2nbperpage, 218 PSIZE, 0); 219 if (mp == NULL) { 220 jfs_err("diSync: get_metapage failed!"); 221 return -EIO; 222 } 223 224 /* copy the in-memory version to the on-disk version */ 225 dinom_le = (struct dinomap_disk *) mp->data; 226 dinom_le->in_freeiag = cpu_to_le32(imp->im_freeiag); 227 dinom_le->in_nextiag = cpu_to_le32(imp->im_nextiag); 228 dinom_le->in_numinos = cpu_to_le32(atomic_read(&imp->im_numinos)); 229 dinom_le->in_numfree = cpu_to_le32(atomic_read(&imp->im_numfree)); 230 dinom_le->in_nbperiext = cpu_to_le32(imp->im_nbperiext); 231 dinom_le->in_l2nbperiext = cpu_to_le32(imp->im_l2nbperiext); 232 for (index = 0; index < MAXAG; index++) { 233 dinom_le->in_agctl[index].inofree = 234 cpu_to_le32(imp->im_agctl[index].inofree); 235 dinom_le->in_agctl[index].extfree = 236 cpu_to_le32(imp->im_agctl[index].extfree); 237 dinom_le->in_agctl[index].numinos = 238 cpu_to_le32(imp->im_agctl[index].numinos); 239 dinom_le->in_agctl[index].numfree = 240 cpu_to_le32(imp->im_agctl[index].numfree); 241 } 242 243 /* write out the control structure */ 244 write_metapage(mp); 245 246 /* 247 * write out dirty pages of imap 248 */ 249 filemap_write_and_wait(ipimap->i_mapping); 250 251 diWriteSpecial(ipimap, 0); 252 253 return (0); 254 } 255 256 257 /* 258 * NAME: diRead() 259 * 260 * FUNCTION: initialize an incore inode from disk. 261 * 262 * on entry, the specifed incore inode should itself 263 * specify the disk inode number corresponding to the 264 * incore inode (i.e. i_number should be initialized). 265 * 266 * this routine handles incore inode initialization for 267 * both "special" and "regular" inodes. special inodes 268 * are those required early in the mount process and 269 * require special handling since much of the file system 270 * is not yet initialized. these "special" inodes are 271 * identified by a NULL inode map inode pointer and are 272 * actually initialized by a call to diReadSpecial(). 273 * 274 * for regular inodes, the iag describing the disk inode 275 * is read from disk to determine the inode extent address 276 * for the disk inode. with the inode extent address in 277 * hand, the page of the extent that contains the disk 278 * inode is read and the disk inode is copied to the 279 * incore inode. 280 * 281 * PARAMETERS: 282 * ip - pointer to incore inode to be initialized from disk. 283 * 284 * RETURN VALUES: 285 * 0 - success 286 * -EIO - i/o error. 287 * -ENOMEM - insufficient memory 288 * 289 */ 290 int diRead(struct inode *ip) 291 { 292 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 293 int iagno, ino, extno, rc, agno; 294 struct inode *ipimap; 295 struct dinode *dp; 296 struct iag *iagp; 297 struct metapage *mp; 298 s64 blkno, agstart; 299 struct inomap *imap; 300 int block_offset; 301 int inodes_left; 302 unsigned long pageno; 303 int rel_inode; 304 305 jfs_info("diRead: ino = %ld", ip->i_ino); 306 307 ipimap = sbi->ipimap; 308 JFS_IP(ip)->ipimap = ipimap; 309 310 /* determine the iag number for this inode (number) */ 311 iagno = INOTOIAG(ip->i_ino); 312 313 /* read the iag */ 314 IREAD_LOCK(ipimap, RDWRLOCK_IMAP); 315 imap = JFS_IP(ipimap)->i_imap; 316 rc = diIAGRead(imap, iagno, &mp); 317 IREAD_UNLOCK(ipimap); 318 if (rc) { 319 jfs_err("diRead: diIAGRead returned %d", rc); 320 return (rc); 321 } 322 323 iagp = (struct iag *) mp->data; 324 325 /* determine inode extent that holds the disk inode */ 326 ino = ip->i_ino & (INOSPERIAG - 1); 327 extno = ino >> L2INOSPEREXT; 328 329 if ((lengthPXD(&iagp->inoext[extno]) != imap->im_nbperiext) || 330 (addressPXD(&iagp->inoext[extno]) == 0)) { 331 release_metapage(mp); 332 return -ESTALE; 333 } 334 335 /* get disk block number of the page within the inode extent 336 * that holds the disk inode. 337 */ 338 blkno = INOPBLK(&iagp->inoext[extno], ino, sbi->l2nbperpage); 339 340 /* get the ag for the iag */ 341 agstart = le64_to_cpu(iagp->agstart); 342 agno = BLKTOAG(agstart, JFS_SBI(ip->i_sb)); 343 344 release_metapage(mp); 345 if (agno >= MAXAG || agno < 0) 346 return -EIO; 347 348 rel_inode = (ino & (INOSPERPAGE - 1)); 349 pageno = blkno >> sbi->l2nbperpage; 350 351 if ((block_offset = ((u32) blkno & (sbi->nbperpage - 1)))) { 352 /* 353 * OS/2 didn't always align inode extents on page boundaries 354 */ 355 inodes_left = 356 (sbi->nbperpage - block_offset) << sbi->l2niperblk; 357 358 if (rel_inode < inodes_left) 359 rel_inode += block_offset << sbi->l2niperblk; 360 else { 361 pageno += 1; 362 rel_inode -= inodes_left; 363 } 364 } 365 366 /* read the page of disk inode */ 367 mp = read_metapage(ipimap, pageno << sbi->l2nbperpage, PSIZE, 1); 368 if (!mp) { 369 jfs_err("diRead: read_metapage failed"); 370 return -EIO; 371 } 372 373 /* locate the disk inode requested */ 374 dp = (struct dinode *) mp->data; 375 dp += rel_inode; 376 377 if (ip->i_ino != le32_to_cpu(dp->di_number)) { 378 jfs_error(ip->i_sb, "i_ino != di_number\n"); 379 rc = -EIO; 380 } else if (le32_to_cpu(dp->di_nlink) == 0) 381 rc = -ESTALE; 382 else 383 /* copy the disk inode to the in-memory inode */ 384 rc = copy_from_dinode(dp, ip); 385 386 release_metapage(mp); 387 388 /* set the ag for the inode */ 389 JFS_IP(ip)->agstart = agstart; 390 JFS_IP(ip)->active_ag = -1; 391 392 return (rc); 393 } 394 395 396 /* 397 * NAME: diReadSpecial() 398 * 399 * FUNCTION: initialize a 'special' inode from disk. 400 * 401 * this routines handles aggregate level inodes. The 402 * inode cache cannot differentiate between the 403 * aggregate inodes and the filesystem inodes, so we 404 * handle these here. We don't actually use the aggregate 405 * inode map, since these inodes are at a fixed location 406 * and in some cases the aggregate inode map isn't initialized 407 * yet. 408 * 409 * PARAMETERS: 410 * sb - filesystem superblock 411 * inum - aggregate inode number 412 * secondary - 1 if secondary aggregate inode table 413 * 414 * RETURN VALUES: 415 * new inode - success 416 * NULL - i/o error. 417 */ 418 struct inode *diReadSpecial(struct super_block *sb, ino_t inum, int secondary) 419 { 420 struct jfs_sb_info *sbi = JFS_SBI(sb); 421 uint address; 422 struct dinode *dp; 423 struct inode *ip; 424 struct metapage *mp; 425 426 ip = new_inode(sb); 427 if (ip == NULL) { 428 jfs_err("diReadSpecial: new_inode returned NULL!"); 429 return ip; 430 } 431 432 if (secondary) { 433 address = addressPXD(&sbi->ait2) >> sbi->l2nbperpage; 434 JFS_IP(ip)->ipimap = sbi->ipaimap2; 435 } else { 436 address = AITBL_OFF >> L2PSIZE; 437 JFS_IP(ip)->ipimap = sbi->ipaimap; 438 } 439 440 ASSERT(inum < INOSPEREXT); 441 442 ip->i_ino = inum; 443 444 address += inum >> 3; /* 8 inodes per 4K page */ 445 446 /* read the page of fixed disk inode (AIT) in raw mode */ 447 mp = read_metapage(ip, address << sbi->l2nbperpage, PSIZE, 1); 448 if (mp == NULL) { 449 set_nlink(ip, 1); /* Don't want iput() deleting it */ 450 iput(ip); 451 return (NULL); 452 } 453 454 /* get the pointer to the disk inode of interest */ 455 dp = (struct dinode *) (mp->data); 456 dp += inum % 8; /* 8 inodes per 4K page */ 457 458 /* copy on-disk inode to in-memory inode */ 459 if ((copy_from_dinode(dp, ip)) != 0) { 460 /* handle bad return by returning NULL for ip */ 461 set_nlink(ip, 1); /* Don't want iput() deleting it */ 462 iput(ip); 463 /* release the page */ 464 release_metapage(mp); 465 return (NULL); 466 467 } 468 469 ip->i_mapping->a_ops = &jfs_metapage_aops; 470 mapping_set_gfp_mask(ip->i_mapping, GFP_NOFS); 471 472 /* Allocations to metadata inodes should not affect quotas */ 473 ip->i_flags |= S_NOQUOTA; 474 475 if ((inum == FILESYSTEM_I) && (JFS_IP(ip)->ipimap == sbi->ipaimap)) { 476 sbi->gengen = le32_to_cpu(dp->di_gengen); 477 sbi->inostamp = le32_to_cpu(dp->di_inostamp); 478 } 479 480 /* release the page */ 481 release_metapage(mp); 482 483 inode_fake_hash(ip); 484 485 return (ip); 486 } 487 488 /* 489 * NAME: diWriteSpecial() 490 * 491 * FUNCTION: Write the special inode to disk 492 * 493 * PARAMETERS: 494 * ip - special inode 495 * secondary - 1 if secondary aggregate inode table 496 * 497 * RETURN VALUES: none 498 */ 499 500 void diWriteSpecial(struct inode *ip, int secondary) 501 { 502 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 503 uint address; 504 struct dinode *dp; 505 ino_t inum = ip->i_ino; 506 struct metapage *mp; 507 508 if (secondary) 509 address = addressPXD(&sbi->ait2) >> sbi->l2nbperpage; 510 else 511 address = AITBL_OFF >> L2PSIZE; 512 513 ASSERT(inum < INOSPEREXT); 514 515 address += inum >> 3; /* 8 inodes per 4K page */ 516 517 /* read the page of fixed disk inode (AIT) in raw mode */ 518 mp = read_metapage(ip, address << sbi->l2nbperpage, PSIZE, 1); 519 if (mp == NULL) { 520 jfs_err("diWriteSpecial: failed to read aggregate inode extent!"); 521 return; 522 } 523 524 /* get the pointer to the disk inode of interest */ 525 dp = (struct dinode *) (mp->data); 526 dp += inum % 8; /* 8 inodes per 4K page */ 527 528 /* copy on-disk inode to in-memory inode */ 529 copy_to_dinode(dp, ip); 530 memcpy(&dp->di_xtroot, &JFS_IP(ip)->i_xtroot, 288); 531 532 if (inum == FILESYSTEM_I) 533 dp->di_gengen = cpu_to_le32(sbi->gengen); 534 535 /* write the page */ 536 write_metapage(mp); 537 } 538 539 /* 540 * NAME: diFreeSpecial() 541 * 542 * FUNCTION: Free allocated space for special inode 543 */ 544 void diFreeSpecial(struct inode *ip) 545 { 546 if (ip == NULL) { 547 jfs_err("diFreeSpecial called with NULL ip!"); 548 return; 549 } 550 filemap_write_and_wait(ip->i_mapping); 551 truncate_inode_pages(ip->i_mapping, 0); 552 iput(ip); 553 } 554 555 556 557 /* 558 * NAME: diWrite() 559 * 560 * FUNCTION: write the on-disk inode portion of the in-memory inode 561 * to its corresponding on-disk inode. 562 * 563 * on entry, the specifed incore inode should itself 564 * specify the disk inode number corresponding to the 565 * incore inode (i.e. i_number should be initialized). 566 * 567 * the inode contains the inode extent address for the disk 568 * inode. with the inode extent address in hand, the 569 * page of the extent that contains the disk inode is 570 * read and the disk inode portion of the incore inode 571 * is copied to the disk inode. 572 * 573 * PARAMETERS: 574 * tid - transacation id 575 * ip - pointer to incore inode to be written to the inode extent. 576 * 577 * RETURN VALUES: 578 * 0 - success 579 * -EIO - i/o error. 580 */ 581 int diWrite(tid_t tid, struct inode *ip) 582 { 583 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 584 struct jfs_inode_info *jfs_ip = JFS_IP(ip); 585 int rc = 0; 586 s32 ino; 587 struct dinode *dp; 588 s64 blkno; 589 int block_offset; 590 int inodes_left; 591 struct metapage *mp; 592 unsigned long pageno; 593 int rel_inode; 594 int dioffset; 595 struct inode *ipimap; 596 uint type; 597 lid_t lid; 598 struct tlock *ditlck, *tlck; 599 struct linelock *dilinelock, *ilinelock; 600 struct lv *lv; 601 int n; 602 603 ipimap = jfs_ip->ipimap; 604 605 ino = ip->i_ino & (INOSPERIAG - 1); 606 607 if (!addressPXD(&(jfs_ip->ixpxd)) || 608 (lengthPXD(&(jfs_ip->ixpxd)) != 609 JFS_IP(ipimap)->i_imap->im_nbperiext)) { 610 jfs_error(ip->i_sb, "ixpxd invalid\n"); 611 return -EIO; 612 } 613 614 /* 615 * read the page of disk inode containing the specified inode: 616 */ 617 /* compute the block address of the page */ 618 blkno = INOPBLK(&(jfs_ip->ixpxd), ino, sbi->l2nbperpage); 619 620 rel_inode = (ino & (INOSPERPAGE - 1)); 621 pageno = blkno >> sbi->l2nbperpage; 622 623 if ((block_offset = ((u32) blkno & (sbi->nbperpage - 1)))) { 624 /* 625 * OS/2 didn't always align inode extents on page boundaries 626 */ 627 inodes_left = 628 (sbi->nbperpage - block_offset) << sbi->l2niperblk; 629 630 if (rel_inode < inodes_left) 631 rel_inode += block_offset << sbi->l2niperblk; 632 else { 633 pageno += 1; 634 rel_inode -= inodes_left; 635 } 636 } 637 /* read the page of disk inode */ 638 retry: 639 mp = read_metapage(ipimap, pageno << sbi->l2nbperpage, PSIZE, 1); 640 if (!mp) 641 return -EIO; 642 643 /* get the pointer to the disk inode */ 644 dp = (struct dinode *) mp->data; 645 dp += rel_inode; 646 647 dioffset = (ino & (INOSPERPAGE - 1)) << L2DISIZE; 648 649 /* 650 * acquire transaction lock on the on-disk inode; 651 * N.B. tlock is acquired on ipimap not ip; 652 */ 653 if ((ditlck = 654 txLock(tid, ipimap, mp, tlckINODE | tlckENTRY)) == NULL) 655 goto retry; 656 dilinelock = (struct linelock *) & ditlck->lock; 657 658 /* 659 * copy btree root from in-memory inode to on-disk inode 660 * 661 * (tlock is taken from inline B+-tree root in in-memory 662 * inode when the B+-tree root is updated, which is pointed 663 * by jfs_ip->blid as well as being on tx tlock list) 664 * 665 * further processing of btree root is based on the copy 666 * in in-memory inode, where txLog() will log from, and, 667 * for xtree root, txUpdateMap() will update map and reset 668 * XAD_NEW bit; 669 */ 670 671 if (S_ISDIR(ip->i_mode) && (lid = jfs_ip->xtlid)) { 672 /* 673 * This is the special xtree inside the directory for storing 674 * the directory table 675 */ 676 xtroot_t *p, *xp; 677 xad_t *xad; 678 679 jfs_ip->xtlid = 0; 680 tlck = lid_to_tlock(lid); 681 assert(tlck->type & tlckXTREE); 682 tlck->type |= tlckBTROOT; 683 tlck->mp = mp; 684 ilinelock = (struct linelock *) & tlck->lock; 685 686 /* 687 * copy xtree root from inode to dinode: 688 */ 689 p = &jfs_ip->i_xtroot; 690 xp = (xtroot_t *) &dp->di_dirtable; 691 lv = ilinelock->lv; 692 for (n = 0; n < ilinelock->index; n++, lv++) { 693 memcpy(&xp->xad[lv->offset], &p->xad[lv->offset], 694 lv->length << L2XTSLOTSIZE); 695 } 696 697 /* reset on-disk (metadata page) xtree XAD_NEW bit */ 698 xad = &xp->xad[XTENTRYSTART]; 699 for (n = XTENTRYSTART; 700 n < le16_to_cpu(xp->header.nextindex); n++, xad++) 701 if (xad->flag & (XAD_NEW | XAD_EXTENDED)) 702 xad->flag &= ~(XAD_NEW | XAD_EXTENDED); 703 } 704 705 if ((lid = jfs_ip->blid) == 0) 706 goto inlineData; 707 jfs_ip->blid = 0; 708 709 tlck = lid_to_tlock(lid); 710 type = tlck->type; 711 tlck->type |= tlckBTROOT; 712 tlck->mp = mp; 713 ilinelock = (struct linelock *) & tlck->lock; 714 715 /* 716 * regular file: 16 byte (XAD slot) granularity 717 */ 718 if (type & tlckXTREE) { 719 xtroot_t *p, *xp; 720 xad_t *xad; 721 722 /* 723 * copy xtree root from inode to dinode: 724 */ 725 p = &jfs_ip->i_xtroot; 726 xp = &dp->di_xtroot; 727 lv = ilinelock->lv; 728 for (n = 0; n < ilinelock->index; n++, lv++) { 729 memcpy(&xp->xad[lv->offset], &p->xad[lv->offset], 730 lv->length << L2XTSLOTSIZE); 731 } 732 733 /* reset on-disk (metadata page) xtree XAD_NEW bit */ 734 xad = &xp->xad[XTENTRYSTART]; 735 for (n = XTENTRYSTART; 736 n < le16_to_cpu(xp->header.nextindex); n++, xad++) 737 if (xad->flag & (XAD_NEW | XAD_EXTENDED)) 738 xad->flag &= ~(XAD_NEW | XAD_EXTENDED); 739 } 740 /* 741 * directory: 32 byte (directory entry slot) granularity 742 */ 743 else if (type & tlckDTREE) { 744 dtpage_t *p, *xp; 745 746 /* 747 * copy dtree root from inode to dinode: 748 */ 749 p = (dtpage_t *) &jfs_ip->i_dtroot; 750 xp = (dtpage_t *) & dp->di_dtroot; 751 lv = ilinelock->lv; 752 for (n = 0; n < ilinelock->index; n++, lv++) { 753 memcpy(&xp->slot[lv->offset], &p->slot[lv->offset], 754 lv->length << L2DTSLOTSIZE); 755 } 756 } else { 757 jfs_err("diWrite: UFO tlock"); 758 } 759 760 inlineData: 761 /* 762 * copy inline symlink from in-memory inode to on-disk inode 763 */ 764 if (S_ISLNK(ip->i_mode) && ip->i_size < IDATASIZE) { 765 lv = & dilinelock->lv[dilinelock->index]; 766 lv->offset = (dioffset + 2 * 128) >> L2INODESLOTSIZE; 767 lv->length = 2; 768 memcpy(&dp->di_inline_all, jfs_ip->i_inline_all, IDATASIZE); 769 dilinelock->index++; 770 } 771 /* 772 * copy inline data from in-memory inode to on-disk inode: 773 * 128 byte slot granularity 774 */ 775 if (test_cflag(COMMIT_Inlineea, ip)) { 776 lv = & dilinelock->lv[dilinelock->index]; 777 lv->offset = (dioffset + 3 * 128) >> L2INODESLOTSIZE; 778 lv->length = 1; 779 memcpy(&dp->di_inlineea, jfs_ip->i_inline_ea, INODESLOTSIZE); 780 dilinelock->index++; 781 782 clear_cflag(COMMIT_Inlineea, ip); 783 } 784 785 /* 786 * lock/copy inode base: 128 byte slot granularity 787 */ 788 lv = & dilinelock->lv[dilinelock->index]; 789 lv->offset = dioffset >> L2INODESLOTSIZE; 790 copy_to_dinode(dp, ip); 791 if (test_and_clear_cflag(COMMIT_Dirtable, ip)) { 792 lv->length = 2; 793 memcpy(&dp->di_dirtable, &jfs_ip->i_dirtable, 96); 794 } else 795 lv->length = 1; 796 dilinelock->index++; 797 798 /* release the buffer holding the updated on-disk inode. 799 * the buffer will be later written by commit processing. 800 */ 801 write_metapage(mp); 802 803 return (rc); 804 } 805 806 807 /* 808 * NAME: diFree(ip) 809 * 810 * FUNCTION: free a specified inode from the inode working map 811 * for a fileset or aggregate. 812 * 813 * if the inode to be freed represents the first (only) 814 * free inode within the iag, the iag will be placed on 815 * the ag free inode list. 816 * 817 * freeing the inode will cause the inode extent to be 818 * freed if the inode is the only allocated inode within 819 * the extent. in this case all the disk resource backing 820 * up the inode extent will be freed. in addition, the iag 821 * will be placed on the ag extent free list if the extent 822 * is the first free extent in the iag. if freeing the 823 * extent also means that no free inodes will exist for 824 * the iag, the iag will also be removed from the ag free 825 * inode list. 826 * 827 * the iag describing the inode will be freed if the extent 828 * is to be freed and it is the only backed extent within 829 * the iag. in this case, the iag will be removed from the 830 * ag free extent list and ag free inode list and placed on 831 * the inode map's free iag list. 832 * 833 * a careful update approach is used to provide consistency 834 * in the face of updates to multiple buffers. under this 835 * approach, all required buffers are obtained before making 836 * any updates and are held until all updates are complete. 837 * 838 * PARAMETERS: 839 * ip - inode to be freed. 840 * 841 * RETURN VALUES: 842 * 0 - success 843 * -EIO - i/o error. 844 */ 845 int diFree(struct inode *ip) 846 { 847 int rc; 848 ino_t inum = ip->i_ino; 849 struct iag *iagp, *aiagp, *biagp, *ciagp, *diagp; 850 struct metapage *mp, *amp, *bmp, *cmp, *dmp; 851 int iagno, ino, extno, bitno, sword, agno; 852 int back, fwd; 853 u32 bitmap, mask; 854 struct inode *ipimap = JFS_SBI(ip->i_sb)->ipimap; 855 struct inomap *imap = JFS_IP(ipimap)->i_imap; 856 pxd_t freepxd; 857 tid_t tid; 858 struct inode *iplist[3]; 859 struct tlock *tlck; 860 struct pxd_lock *pxdlock; 861 862 /* 863 * This is just to suppress compiler warnings. The same logic that 864 * references these variables is used to initialize them. 865 */ 866 aiagp = biagp = ciagp = diagp = NULL; 867 868 /* get the iag number containing the inode. 869 */ 870 iagno = INOTOIAG(inum); 871 872 /* make sure that the iag is contained within 873 * the map. 874 */ 875 if (iagno >= imap->im_nextiag) { 876 print_hex_dump(KERN_ERR, "imap: ", DUMP_PREFIX_ADDRESS, 16, 4, 877 imap, 32, 0); 878 jfs_error(ip->i_sb, "inum = %d, iagno = %d, nextiag = %d\n", 879 (uint) inum, iagno, imap->im_nextiag); 880 return -EIO; 881 } 882 883 /* get the allocation group for this ino. 884 */ 885 agno = BLKTOAG(JFS_IP(ip)->agstart, JFS_SBI(ip->i_sb)); 886 887 /* Lock the AG specific inode map information 888 */ 889 AG_LOCK(imap, agno); 890 891 /* Obtain read lock in imap inode. Don't release it until we have 892 * read all of the IAG's that we are going to. 893 */ 894 IREAD_LOCK(ipimap, RDWRLOCK_IMAP); 895 896 /* read the iag. 897 */ 898 if ((rc = diIAGRead(imap, iagno, &mp))) { 899 IREAD_UNLOCK(ipimap); 900 AG_UNLOCK(imap, agno); 901 return (rc); 902 } 903 iagp = (struct iag *) mp->data; 904 905 /* get the inode number and extent number of the inode within 906 * the iag and the inode number within the extent. 907 */ 908 ino = inum & (INOSPERIAG - 1); 909 extno = ino >> L2INOSPEREXT; 910 bitno = ino & (INOSPEREXT - 1); 911 mask = HIGHORDER >> bitno; 912 913 if (!(le32_to_cpu(iagp->wmap[extno]) & mask)) { 914 jfs_error(ip->i_sb, "wmap shows inode already free\n"); 915 } 916 917 if (!addressPXD(&iagp->inoext[extno])) { 918 release_metapage(mp); 919 IREAD_UNLOCK(ipimap); 920 AG_UNLOCK(imap, agno); 921 jfs_error(ip->i_sb, "invalid inoext\n"); 922 return -EIO; 923 } 924 925 /* compute the bitmap for the extent reflecting the freed inode. 926 */ 927 bitmap = le32_to_cpu(iagp->wmap[extno]) & ~mask; 928 929 if (imap->im_agctl[agno].numfree > imap->im_agctl[agno].numinos) { 930 release_metapage(mp); 931 IREAD_UNLOCK(ipimap); 932 AG_UNLOCK(imap, agno); 933 jfs_error(ip->i_sb, "numfree > numinos\n"); 934 return -EIO; 935 } 936 /* 937 * inode extent still has some inodes or below low water mark: 938 * keep the inode extent; 939 */ 940 if (bitmap || 941 imap->im_agctl[agno].numfree < 96 || 942 (imap->im_agctl[agno].numfree < 288 && 943 (((imap->im_agctl[agno].numfree * 100) / 944 imap->im_agctl[agno].numinos) <= 25))) { 945 /* if the iag currently has no free inodes (i.e., 946 * the inode being freed is the first free inode of iag), 947 * insert the iag at head of the inode free list for the ag. 948 */ 949 if (iagp->nfreeinos == 0) { 950 /* check if there are any iags on the ag inode 951 * free list. if so, read the first one so that 952 * we can link the current iag onto the list at 953 * the head. 954 */ 955 if ((fwd = imap->im_agctl[agno].inofree) >= 0) { 956 /* read the iag that currently is the head 957 * of the list. 958 */ 959 if ((rc = diIAGRead(imap, fwd, &))) { 960 IREAD_UNLOCK(ipimap); 961 AG_UNLOCK(imap, agno); 962 release_metapage(mp); 963 return (rc); 964 } 965 aiagp = (struct iag *) amp->data; 966 967 /* make current head point back to the iag. 968 */ 969 aiagp->inofreeback = cpu_to_le32(iagno); 970 971 write_metapage(amp); 972 } 973 974 /* iag points forward to current head and iag 975 * becomes the new head of the list. 976 */ 977 iagp->inofreefwd = 978 cpu_to_le32(imap->im_agctl[agno].inofree); 979 iagp->inofreeback = cpu_to_le32(-1); 980 imap->im_agctl[agno].inofree = iagno; 981 } 982 IREAD_UNLOCK(ipimap); 983 984 /* update the free inode summary map for the extent if 985 * freeing the inode means the extent will now have free 986 * inodes (i.e., the inode being freed is the first free 987 * inode of extent), 988 */ 989 if (iagp->wmap[extno] == cpu_to_le32(ONES)) { 990 sword = extno >> L2EXTSPERSUM; 991 bitno = extno & (EXTSPERSUM - 1); 992 iagp->inosmap[sword] &= 993 cpu_to_le32(~(HIGHORDER >> bitno)); 994 } 995 996 /* update the bitmap. 997 */ 998 iagp->wmap[extno] = cpu_to_le32(bitmap); 999 1000 /* update the free inode counts at the iag, ag and 1001 * map level. 1002 */ 1003 le32_add_cpu(&iagp->nfreeinos, 1); 1004 imap->im_agctl[agno].numfree += 1; 1005 atomic_inc(&imap->im_numfree); 1006 1007 /* release the AG inode map lock 1008 */ 1009 AG_UNLOCK(imap, agno); 1010 1011 /* write the iag */ 1012 write_metapage(mp); 1013 1014 return (0); 1015 } 1016 1017 1018 /* 1019 * inode extent has become free and above low water mark: 1020 * free the inode extent; 1021 */ 1022 1023 /* 1024 * prepare to update iag list(s) (careful update step 1) 1025 */ 1026 amp = bmp = cmp = dmp = NULL; 1027 fwd = back = -1; 1028 1029 /* check if the iag currently has no free extents. if so, 1030 * it will be placed on the head of the ag extent free list. 1031 */ 1032 if (iagp->nfreeexts == 0) { 1033 /* check if the ag extent free list has any iags. 1034 * if so, read the iag at the head of the list now. 1035 * this (head) iag will be updated later to reflect 1036 * the addition of the current iag at the head of 1037 * the list. 1038 */ 1039 if ((fwd = imap->im_agctl[agno].extfree) >= 0) { 1040 if ((rc = diIAGRead(imap, fwd, &))) 1041 goto error_out; 1042 aiagp = (struct iag *) amp->data; 1043 } 1044 } else { 1045 /* iag has free extents. check if the addition of a free 1046 * extent will cause all extents to be free within this 1047 * iag. if so, the iag will be removed from the ag extent 1048 * free list and placed on the inode map's free iag list. 1049 */ 1050 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG - 1)) { 1051 /* in preparation for removing the iag from the 1052 * ag extent free list, read the iags preceding 1053 * and following the iag on the ag extent free 1054 * list. 1055 */ 1056 if ((fwd = le32_to_cpu(iagp->extfreefwd)) >= 0) { 1057 if ((rc = diIAGRead(imap, fwd, &))) 1058 goto error_out; 1059 aiagp = (struct iag *) amp->data; 1060 } 1061 1062 if ((back = le32_to_cpu(iagp->extfreeback)) >= 0) { 1063 if ((rc = diIAGRead(imap, back, &bmp))) 1064 goto error_out; 1065 biagp = (struct iag *) bmp->data; 1066 } 1067 } 1068 } 1069 1070 /* remove the iag from the ag inode free list if freeing 1071 * this extent cause the iag to have no free inodes. 1072 */ 1073 if (iagp->nfreeinos == cpu_to_le32(INOSPEREXT - 1)) { 1074 int inofreeback = le32_to_cpu(iagp->inofreeback); 1075 int inofreefwd = le32_to_cpu(iagp->inofreefwd); 1076 1077 /* in preparation for removing the iag from the 1078 * ag inode free list, read the iags preceding 1079 * and following the iag on the ag inode free 1080 * list. before reading these iags, we must make 1081 * sure that we already don't have them in hand 1082 * from up above, since re-reading an iag (buffer) 1083 * we are currently holding would cause a deadlock. 1084 */ 1085 if (inofreefwd >= 0) { 1086 1087 if (inofreefwd == fwd) 1088 ciagp = (struct iag *) amp->data; 1089 else if (inofreefwd == back) 1090 ciagp = (struct iag *) bmp->data; 1091 else { 1092 if ((rc = 1093 diIAGRead(imap, inofreefwd, &cmp))) 1094 goto error_out; 1095 ciagp = (struct iag *) cmp->data; 1096 } 1097 assert(ciagp != NULL); 1098 } 1099 1100 if (inofreeback >= 0) { 1101 if (inofreeback == fwd) 1102 diagp = (struct iag *) amp->data; 1103 else if (inofreeback == back) 1104 diagp = (struct iag *) bmp->data; 1105 else { 1106 if ((rc = 1107 diIAGRead(imap, inofreeback, &dmp))) 1108 goto error_out; 1109 diagp = (struct iag *) dmp->data; 1110 } 1111 assert(diagp != NULL); 1112 } 1113 } 1114 1115 IREAD_UNLOCK(ipimap); 1116 1117 /* 1118 * invalidate any page of the inode extent freed from buffer cache; 1119 */ 1120 freepxd = iagp->inoext[extno]; 1121 invalidate_pxd_metapages(ip, freepxd); 1122 1123 /* 1124 * update iag list(s) (careful update step 2) 1125 */ 1126 /* add the iag to the ag extent free list if this is the 1127 * first free extent for the iag. 1128 */ 1129 if (iagp->nfreeexts == 0) { 1130 if (fwd >= 0) 1131 aiagp->extfreeback = cpu_to_le32(iagno); 1132 1133 iagp->extfreefwd = 1134 cpu_to_le32(imap->im_agctl[agno].extfree); 1135 iagp->extfreeback = cpu_to_le32(-1); 1136 imap->im_agctl[agno].extfree = iagno; 1137 } else { 1138 /* remove the iag from the ag extent list if all extents 1139 * are now free and place it on the inode map iag free list. 1140 */ 1141 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG - 1)) { 1142 if (fwd >= 0) 1143 aiagp->extfreeback = iagp->extfreeback; 1144 1145 if (back >= 0) 1146 biagp->extfreefwd = iagp->extfreefwd; 1147 else 1148 imap->im_agctl[agno].extfree = 1149 le32_to_cpu(iagp->extfreefwd); 1150 1151 iagp->extfreefwd = iagp->extfreeback = cpu_to_le32(-1); 1152 1153 IAGFREE_LOCK(imap); 1154 iagp->iagfree = cpu_to_le32(imap->im_freeiag); 1155 imap->im_freeiag = iagno; 1156 IAGFREE_UNLOCK(imap); 1157 } 1158 } 1159 1160 /* remove the iag from the ag inode free list if freeing 1161 * this extent causes the iag to have no free inodes. 1162 */ 1163 if (iagp->nfreeinos == cpu_to_le32(INOSPEREXT - 1)) { 1164 if ((int) le32_to_cpu(iagp->inofreefwd) >= 0) 1165 ciagp->inofreeback = iagp->inofreeback; 1166 1167 if ((int) le32_to_cpu(iagp->inofreeback) >= 0) 1168 diagp->inofreefwd = iagp->inofreefwd; 1169 else 1170 imap->im_agctl[agno].inofree = 1171 le32_to_cpu(iagp->inofreefwd); 1172 1173 iagp->inofreefwd = iagp->inofreeback = cpu_to_le32(-1); 1174 } 1175 1176 /* update the inode extent address and working map 1177 * to reflect the free extent. 1178 * the permanent map should have been updated already 1179 * for the inode being freed. 1180 */ 1181 if (iagp->pmap[extno] != 0) { 1182 jfs_error(ip->i_sb, "the pmap does not show inode free\n"); 1183 } 1184 iagp->wmap[extno] = 0; 1185 PXDlength(&iagp->inoext[extno], 0); 1186 PXDaddress(&iagp->inoext[extno], 0); 1187 1188 /* update the free extent and free inode summary maps 1189 * to reflect the freed extent. 1190 * the inode summary map is marked to indicate no inodes 1191 * available for the freed extent. 1192 */ 1193 sword = extno >> L2EXTSPERSUM; 1194 bitno = extno & (EXTSPERSUM - 1); 1195 mask = HIGHORDER >> bitno; 1196 iagp->inosmap[sword] |= cpu_to_le32(mask); 1197 iagp->extsmap[sword] &= cpu_to_le32(~mask); 1198 1199 /* update the number of free inodes and number of free extents 1200 * for the iag. 1201 */ 1202 le32_add_cpu(&iagp->nfreeinos, -(INOSPEREXT - 1)); 1203 le32_add_cpu(&iagp->nfreeexts, 1); 1204 1205 /* update the number of free inodes and backed inodes 1206 * at the ag and inode map level. 1207 */ 1208 imap->im_agctl[agno].numfree -= (INOSPEREXT - 1); 1209 imap->im_agctl[agno].numinos -= INOSPEREXT; 1210 atomic_sub(INOSPEREXT - 1, &imap->im_numfree); 1211 atomic_sub(INOSPEREXT, &imap->im_numinos); 1212 1213 if (amp) 1214 write_metapage(amp); 1215 if (bmp) 1216 write_metapage(bmp); 1217 if (cmp) 1218 write_metapage(cmp); 1219 if (dmp) 1220 write_metapage(dmp); 1221 1222 /* 1223 * start transaction to update block allocation map 1224 * for the inode extent freed; 1225 * 1226 * N.B. AG_LOCK is released and iag will be released below, and 1227 * other thread may allocate inode from/reusing the ixad freed 1228 * BUT with new/different backing inode extent from the extent 1229 * to be freed by the transaction; 1230 */ 1231 tid = txBegin(ipimap->i_sb, COMMIT_FORCE); 1232 mutex_lock(&JFS_IP(ipimap)->commit_mutex); 1233 1234 /* acquire tlock of the iag page of the freed ixad 1235 * to force the page NOHOMEOK (even though no data is 1236 * logged from the iag page) until NOREDOPAGE|FREEXTENT log 1237 * for the free of the extent is committed; 1238 * write FREEXTENT|NOREDOPAGE log record 1239 * N.B. linelock is overlaid as freed extent descriptor; 1240 */ 1241 tlck = txLock(tid, ipimap, mp, tlckINODE | tlckFREE); 1242 pxdlock = (struct pxd_lock *) & tlck->lock; 1243 pxdlock->flag = mlckFREEPXD; 1244 pxdlock->pxd = freepxd; 1245 pxdlock->index = 1; 1246 1247 write_metapage(mp); 1248 1249 iplist[0] = ipimap; 1250 1251 /* 1252 * logredo needs the IAG number and IAG extent index in order 1253 * to ensure that the IMap is consistent. The least disruptive 1254 * way to pass these values through to the transaction manager 1255 * is in the iplist array. 1256 * 1257 * It's not pretty, but it works. 1258 */ 1259 iplist[1] = (struct inode *) (size_t)iagno; 1260 iplist[2] = (struct inode *) (size_t)extno; 1261 1262 rc = txCommit(tid, 1, &iplist[0], COMMIT_FORCE); 1263 1264 txEnd(tid); 1265 mutex_unlock(&JFS_IP(ipimap)->commit_mutex); 1266 1267 /* unlock the AG inode map information */ 1268 AG_UNLOCK(imap, agno); 1269 1270 return (0); 1271 1272 error_out: 1273 IREAD_UNLOCK(ipimap); 1274 1275 if (amp) 1276 release_metapage(amp); 1277 if (bmp) 1278 release_metapage(bmp); 1279 if (cmp) 1280 release_metapage(cmp); 1281 if (dmp) 1282 release_metapage(dmp); 1283 1284 AG_UNLOCK(imap, agno); 1285 1286 release_metapage(mp); 1287 1288 return (rc); 1289 } 1290 1291 /* 1292 * There are several places in the diAlloc* routines where we initialize 1293 * the inode. 1294 */ 1295 static inline void 1296 diInitInode(struct inode *ip, int iagno, int ino, int extno, struct iag * iagp) 1297 { 1298 struct jfs_inode_info *jfs_ip = JFS_IP(ip); 1299 1300 ip->i_ino = (iagno << L2INOSPERIAG) + ino; 1301 jfs_ip->ixpxd = iagp->inoext[extno]; 1302 jfs_ip->agstart = le64_to_cpu(iagp->agstart); 1303 jfs_ip->active_ag = -1; 1304 } 1305 1306 1307 /* 1308 * NAME: diAlloc(pip,dir,ip) 1309 * 1310 * FUNCTION: allocate a disk inode from the inode working map 1311 * for a fileset or aggregate. 1312 * 1313 * PARAMETERS: 1314 * pip - pointer to incore inode for the parent inode. 1315 * dir - 'true' if the new disk inode is for a directory. 1316 * ip - pointer to a new inode 1317 * 1318 * RETURN VALUES: 1319 * 0 - success. 1320 * -ENOSPC - insufficient disk resources. 1321 * -EIO - i/o error. 1322 */ 1323 int diAlloc(struct inode *pip, bool dir, struct inode *ip) 1324 { 1325 int rc, ino, iagno, addext, extno, bitno, sword; 1326 int nwords, rem, i, agno, dn_numag; 1327 u32 mask, inosmap, extsmap; 1328 struct inode *ipimap; 1329 struct metapage *mp; 1330 ino_t inum; 1331 struct iag *iagp; 1332 struct inomap *imap; 1333 1334 /* get the pointers to the inode map inode and the 1335 * corresponding imap control structure. 1336 */ 1337 ipimap = JFS_SBI(pip->i_sb)->ipimap; 1338 imap = JFS_IP(ipimap)->i_imap; 1339 JFS_IP(ip)->ipimap = ipimap; 1340 JFS_IP(ip)->fileset = FILESYSTEM_I; 1341 1342 /* for a directory, the allocation policy is to start 1343 * at the ag level using the preferred ag. 1344 */ 1345 if (dir) { 1346 agno = dbNextAG(JFS_SBI(pip->i_sb)->ipbmap); 1347 AG_LOCK(imap, agno); 1348 goto tryag; 1349 } 1350 1351 /* for files, the policy starts off by trying to allocate from 1352 * the same iag containing the parent disk inode: 1353 * try to allocate the new disk inode close to the parent disk 1354 * inode, using parent disk inode number + 1 as the allocation 1355 * hint. (we use a left-to-right policy to attempt to avoid 1356 * moving backward on the disk.) compute the hint within the 1357 * file system and the iag. 1358 */ 1359 1360 /* get the ag number of this iag */ 1361 agno = BLKTOAG(JFS_IP(pip)->agstart, JFS_SBI(pip->i_sb)); 1362 dn_numag = JFS_SBI(pip->i_sb)->bmap->db_numag; 1363 if (agno < 0 || agno > dn_numag || agno >= MAXAG) 1364 return -EIO; 1365 1366 if (atomic_read(&JFS_SBI(pip->i_sb)->bmap->db_active[agno])) { 1367 /* 1368 * There is an open file actively growing. We want to 1369 * allocate new inodes from a different ag to avoid 1370 * fragmentation problems. 1371 */ 1372 agno = dbNextAG(JFS_SBI(pip->i_sb)->ipbmap); 1373 AG_LOCK(imap, agno); 1374 goto tryag; 1375 } 1376 1377 inum = pip->i_ino + 1; 1378 ino = inum & (INOSPERIAG - 1); 1379 1380 /* back off the hint if it is outside of the iag */ 1381 if (ino == 0) 1382 inum = pip->i_ino; 1383 1384 /* lock the AG inode map information */ 1385 AG_LOCK(imap, agno); 1386 1387 /* Get read lock on imap inode */ 1388 IREAD_LOCK(ipimap, RDWRLOCK_IMAP); 1389 1390 /* get the iag number and read the iag */ 1391 iagno = INOTOIAG(inum); 1392 if ((rc = diIAGRead(imap, iagno, &mp))) { 1393 IREAD_UNLOCK(ipimap); 1394 AG_UNLOCK(imap, agno); 1395 return (rc); 1396 } 1397 iagp = (struct iag *) mp->data; 1398 1399 /* determine if new inode extent is allowed to be added to the iag. 1400 * new inode extent can be added to the iag if the ag 1401 * has less than 32 free disk inodes and the iag has free extents. 1402 */ 1403 addext = (imap->im_agctl[agno].numfree < 32 && iagp->nfreeexts); 1404 1405 /* 1406 * try to allocate from the IAG 1407 */ 1408 /* check if the inode may be allocated from the iag 1409 * (i.e. the inode has free inodes or new extent can be added). 1410 */ 1411 if (iagp->nfreeinos || addext) { 1412 /* determine the extent number of the hint. 1413 */ 1414 extno = ino >> L2INOSPEREXT; 1415 1416 /* check if the extent containing the hint has backed 1417 * inodes. if so, try to allocate within this extent. 1418 */ 1419 if (addressPXD(&iagp->inoext[extno])) { 1420 bitno = ino & (INOSPEREXT - 1); 1421 if ((bitno = 1422 diFindFree(le32_to_cpu(iagp->wmap[extno]), 1423 bitno)) 1424 < INOSPEREXT) { 1425 ino = (extno << L2INOSPEREXT) + bitno; 1426 1427 /* a free inode (bit) was found within this 1428 * extent, so allocate it. 1429 */ 1430 rc = diAllocBit(imap, iagp, ino); 1431 IREAD_UNLOCK(ipimap); 1432 if (rc) { 1433 assert(rc == -EIO); 1434 } else { 1435 /* set the results of the allocation 1436 * and write the iag. 1437 */ 1438 diInitInode(ip, iagno, ino, extno, 1439 iagp); 1440 mark_metapage_dirty(mp); 1441 } 1442 release_metapage(mp); 1443 1444 /* free the AG lock and return. 1445 */ 1446 AG_UNLOCK(imap, agno); 1447 return (rc); 1448 } 1449 1450 if (!addext) 1451 extno = 1452 (extno == 1453 EXTSPERIAG - 1) ? 0 : extno + 1; 1454 } 1455 1456 /* 1457 * no free inodes within the extent containing the hint. 1458 * 1459 * try to allocate from the backed extents following 1460 * hint or, if appropriate (i.e. addext is true), allocate 1461 * an extent of free inodes at or following the extent 1462 * containing the hint. 1463 * 1464 * the free inode and free extent summary maps are used 1465 * here, so determine the starting summary map position 1466 * and the number of words we'll have to examine. again, 1467 * the approach is to allocate following the hint, so we 1468 * might have to initially ignore prior bits of the summary 1469 * map that represent extents prior to the extent containing 1470 * the hint and later revisit these bits. 1471 */ 1472 bitno = extno & (EXTSPERSUM - 1); 1473 nwords = (bitno == 0) ? SMAPSZ : SMAPSZ + 1; 1474 sword = extno >> L2EXTSPERSUM; 1475 1476 /* mask any prior bits for the starting words of the 1477 * summary map. 1478 */ 1479 mask = (bitno == 0) ? 0 : (ONES << (EXTSPERSUM - bitno)); 1480 inosmap = le32_to_cpu(iagp->inosmap[sword]) | mask; 1481 extsmap = le32_to_cpu(iagp->extsmap[sword]) | mask; 1482 1483 /* scan the free inode and free extent summary maps for 1484 * free resources. 1485 */ 1486 for (i = 0; i < nwords; i++) { 1487 /* check if this word of the free inode summary 1488 * map describes an extent with free inodes. 1489 */ 1490 if (~inosmap) { 1491 /* an extent with free inodes has been 1492 * found. determine the extent number 1493 * and the inode number within the extent. 1494 */ 1495 rem = diFindFree(inosmap, 0); 1496 extno = (sword << L2EXTSPERSUM) + rem; 1497 rem = diFindFree(le32_to_cpu(iagp->wmap[extno]), 1498 0); 1499 if (rem >= INOSPEREXT) { 1500 IREAD_UNLOCK(ipimap); 1501 release_metapage(mp); 1502 AG_UNLOCK(imap, agno); 1503 jfs_error(ip->i_sb, 1504 "can't find free bit in wmap\n"); 1505 return -EIO; 1506 } 1507 1508 /* determine the inode number within the 1509 * iag and allocate the inode from the 1510 * map. 1511 */ 1512 ino = (extno << L2INOSPEREXT) + rem; 1513 rc = diAllocBit(imap, iagp, ino); 1514 IREAD_UNLOCK(ipimap); 1515 if (rc) 1516 assert(rc == -EIO); 1517 else { 1518 /* set the results of the allocation 1519 * and write the iag. 1520 */ 1521 diInitInode(ip, iagno, ino, extno, 1522 iagp); 1523 mark_metapage_dirty(mp); 1524 } 1525 release_metapage(mp); 1526 1527 /* free the AG lock and return. 1528 */ 1529 AG_UNLOCK(imap, agno); 1530 return (rc); 1531 1532 } 1533 1534 /* check if we may allocate an extent of free 1535 * inodes and whether this word of the free 1536 * extents summary map describes a free extent. 1537 */ 1538 if (addext && ~extsmap) { 1539 /* a free extent has been found. determine 1540 * the extent number. 1541 */ 1542 rem = diFindFree(extsmap, 0); 1543 extno = (sword << L2EXTSPERSUM) + rem; 1544 1545 /* allocate an extent of free inodes. 1546 */ 1547 if ((rc = diNewExt(imap, iagp, extno))) { 1548 /* if there is no disk space for a 1549 * new extent, try to allocate the 1550 * disk inode from somewhere else. 1551 */ 1552 if (rc == -ENOSPC) 1553 break; 1554 1555 assert(rc == -EIO); 1556 } else { 1557 /* set the results of the allocation 1558 * and write the iag. 1559 */ 1560 diInitInode(ip, iagno, 1561 extno << L2INOSPEREXT, 1562 extno, iagp); 1563 mark_metapage_dirty(mp); 1564 } 1565 release_metapage(mp); 1566 /* free the imap inode & the AG lock & return. 1567 */ 1568 IREAD_UNLOCK(ipimap); 1569 AG_UNLOCK(imap, agno); 1570 return (rc); 1571 } 1572 1573 /* move on to the next set of summary map words. 1574 */ 1575 sword = (sword == SMAPSZ - 1) ? 0 : sword + 1; 1576 inosmap = le32_to_cpu(iagp->inosmap[sword]); 1577 extsmap = le32_to_cpu(iagp->extsmap[sword]); 1578 } 1579 } 1580 /* unlock imap inode */ 1581 IREAD_UNLOCK(ipimap); 1582 1583 /* nothing doing in this iag, so release it. */ 1584 release_metapage(mp); 1585 1586 tryag: 1587 /* 1588 * try to allocate anywhere within the same AG as the parent inode. 1589 */ 1590 rc = diAllocAG(imap, agno, dir, ip); 1591 1592 AG_UNLOCK(imap, agno); 1593 1594 if (rc != -ENOSPC) 1595 return (rc); 1596 1597 /* 1598 * try to allocate in any AG. 1599 */ 1600 return (diAllocAny(imap, agno, dir, ip)); 1601 } 1602 1603 1604 /* 1605 * NAME: diAllocAG(imap,agno,dir,ip) 1606 * 1607 * FUNCTION: allocate a disk inode from the allocation group. 1608 * 1609 * this routine first determines if a new extent of free 1610 * inodes should be added for the allocation group, with 1611 * the current request satisfied from this extent. if this 1612 * is the case, an attempt will be made to do just that. if 1613 * this attempt fails or it has been determined that a new 1614 * extent should not be added, an attempt is made to satisfy 1615 * the request by allocating an existing (backed) free inode 1616 * from the allocation group. 1617 * 1618 * PRE CONDITION: Already have the AG lock for this AG. 1619 * 1620 * PARAMETERS: 1621 * imap - pointer to inode map control structure. 1622 * agno - allocation group to allocate from. 1623 * dir - 'true' if the new disk inode is for a directory. 1624 * ip - pointer to the new inode to be filled in on successful return 1625 * with the disk inode number allocated, its extent address 1626 * and the start of the ag. 1627 * 1628 * RETURN VALUES: 1629 * 0 - success. 1630 * -ENOSPC - insufficient disk resources. 1631 * -EIO - i/o error. 1632 */ 1633 static int 1634 diAllocAG(struct inomap * imap, int agno, bool dir, struct inode *ip) 1635 { 1636 int rc, addext, numfree, numinos; 1637 1638 /* get the number of free and the number of backed disk 1639 * inodes currently within the ag. 1640 */ 1641 numfree = imap->im_agctl[agno].numfree; 1642 numinos = imap->im_agctl[agno].numinos; 1643 1644 if (numfree > numinos) { 1645 jfs_error(ip->i_sb, "numfree > numinos\n"); 1646 return -EIO; 1647 } 1648 1649 /* determine if we should allocate a new extent of free inodes 1650 * within the ag: for directory inodes, add a new extent 1651 * if there are a small number of free inodes or number of free 1652 * inodes is a small percentage of the number of backed inodes. 1653 */ 1654 if (dir) 1655 addext = (numfree < 64 || 1656 (numfree < 256 1657 && ((numfree * 100) / numinos) <= 20)); 1658 else 1659 addext = (numfree == 0); 1660 1661 /* 1662 * try to allocate a new extent of free inodes. 1663 */ 1664 if (addext) { 1665 /* if free space is not available for this new extent, try 1666 * below to allocate a free and existing (already backed) 1667 * inode from the ag. 1668 */ 1669 if ((rc = diAllocExt(imap, agno, ip)) != -ENOSPC) 1670 return (rc); 1671 } 1672 1673 /* 1674 * try to allocate an existing free inode from the ag. 1675 */ 1676 return (diAllocIno(imap, agno, ip)); 1677 } 1678 1679 1680 /* 1681 * NAME: diAllocAny(imap,agno,dir,iap) 1682 * 1683 * FUNCTION: allocate a disk inode from any other allocation group. 1684 * 1685 * this routine is called when an allocation attempt within 1686 * the primary allocation group has failed. if attempts to 1687 * allocate an inode from any allocation group other than the 1688 * specified primary group. 1689 * 1690 * PARAMETERS: 1691 * imap - pointer to inode map control structure. 1692 * agno - primary allocation group (to avoid). 1693 * dir - 'true' if the new disk inode is for a directory. 1694 * ip - pointer to a new inode to be filled in on successful return 1695 * with the disk inode number allocated, its extent address 1696 * and the start of the ag. 1697 * 1698 * RETURN VALUES: 1699 * 0 - success. 1700 * -ENOSPC - insufficient disk resources. 1701 * -EIO - i/o error. 1702 */ 1703 static int 1704 diAllocAny(struct inomap * imap, int agno, bool dir, struct inode *ip) 1705 { 1706 int ag, rc; 1707 int maxag = JFS_SBI(imap->im_ipimap->i_sb)->bmap->db_maxag; 1708 1709 1710 /* try to allocate from the ags following agno up to 1711 * the maximum ag number. 1712 */ 1713 for (ag = agno + 1; ag <= maxag; ag++) { 1714 AG_LOCK(imap, ag); 1715 1716 rc = diAllocAG(imap, ag, dir, ip); 1717 1718 AG_UNLOCK(imap, ag); 1719 1720 if (rc != -ENOSPC) 1721 return (rc); 1722 } 1723 1724 /* try to allocate from the ags in front of agno. 1725 */ 1726 for (ag = 0; ag < agno; ag++) { 1727 AG_LOCK(imap, ag); 1728 1729 rc = diAllocAG(imap, ag, dir, ip); 1730 1731 AG_UNLOCK(imap, ag); 1732 1733 if (rc != -ENOSPC) 1734 return (rc); 1735 } 1736 1737 /* no free disk inodes. 1738 */ 1739 return -ENOSPC; 1740 } 1741 1742 1743 /* 1744 * NAME: diAllocIno(imap,agno,ip) 1745 * 1746 * FUNCTION: allocate a disk inode from the allocation group's free 1747 * inode list, returning an error if this free list is 1748 * empty (i.e. no iags on the list). 1749 * 1750 * allocation occurs from the first iag on the list using 1751 * the iag's free inode summary map to find the leftmost 1752 * free inode in the iag. 1753 * 1754 * PRE CONDITION: Already have AG lock for this AG. 1755 * 1756 * PARAMETERS: 1757 * imap - pointer to inode map control structure. 1758 * agno - allocation group. 1759 * ip - pointer to new inode to be filled in on successful return 1760 * with the disk inode number allocated, its extent address 1761 * and the start of the ag. 1762 * 1763 * RETURN VALUES: 1764 * 0 - success. 1765 * -ENOSPC - insufficient disk resources. 1766 * -EIO - i/o error. 1767 */ 1768 static int diAllocIno(struct inomap * imap, int agno, struct inode *ip) 1769 { 1770 int iagno, ino, rc, rem, extno, sword; 1771 struct metapage *mp; 1772 struct iag *iagp; 1773 1774 /* check if there are iags on the ag's free inode list. 1775 */ 1776 if ((iagno = imap->im_agctl[agno].inofree) < 0) 1777 return -ENOSPC; 1778 1779 /* obtain read lock on imap inode */ 1780 IREAD_LOCK(imap->im_ipimap, RDWRLOCK_IMAP); 1781 1782 /* read the iag at the head of the list. 1783 */ 1784 if ((rc = diIAGRead(imap, iagno, &mp))) { 1785 IREAD_UNLOCK(imap->im_ipimap); 1786 return (rc); 1787 } 1788 iagp = (struct iag *) mp->data; 1789 1790 /* better be free inodes in this iag if it is on the 1791 * list. 1792 */ 1793 if (!iagp->nfreeinos) { 1794 IREAD_UNLOCK(imap->im_ipimap); 1795 release_metapage(mp); 1796 jfs_error(ip->i_sb, "nfreeinos = 0, but iag on freelist\n"); 1797 return -EIO; 1798 } 1799 1800 /* scan the free inode summary map to find an extent 1801 * with free inodes. 1802 */ 1803 for (sword = 0;; sword++) { 1804 if (sword >= SMAPSZ) { 1805 IREAD_UNLOCK(imap->im_ipimap); 1806 release_metapage(mp); 1807 jfs_error(ip->i_sb, 1808 "free inode not found in summary map\n"); 1809 return -EIO; 1810 } 1811 1812 if (~iagp->inosmap[sword]) 1813 break; 1814 } 1815 1816 /* found a extent with free inodes. determine 1817 * the extent number. 1818 */ 1819 rem = diFindFree(le32_to_cpu(iagp->inosmap[sword]), 0); 1820 if (rem >= EXTSPERSUM) { 1821 IREAD_UNLOCK(imap->im_ipimap); 1822 release_metapage(mp); 1823 jfs_error(ip->i_sb, "no free extent found\n"); 1824 return -EIO; 1825 } 1826 extno = (sword << L2EXTSPERSUM) + rem; 1827 1828 /* find the first free inode in the extent. 1829 */ 1830 rem = diFindFree(le32_to_cpu(iagp->wmap[extno]), 0); 1831 if (rem >= INOSPEREXT) { 1832 IREAD_UNLOCK(imap->im_ipimap); 1833 release_metapage(mp); 1834 jfs_error(ip->i_sb, "free inode not found\n"); 1835 return -EIO; 1836 } 1837 1838 /* compute the inode number within the iag. 1839 */ 1840 ino = (extno << L2INOSPEREXT) + rem; 1841 1842 /* allocate the inode. 1843 */ 1844 rc = diAllocBit(imap, iagp, ino); 1845 IREAD_UNLOCK(imap->im_ipimap); 1846 if (rc) { 1847 release_metapage(mp); 1848 return (rc); 1849 } 1850 1851 /* set the results of the allocation and write the iag. 1852 */ 1853 diInitInode(ip, iagno, ino, extno, iagp); 1854 write_metapage(mp); 1855 1856 return (0); 1857 } 1858 1859 1860 /* 1861 * NAME: diAllocExt(imap,agno,ip) 1862 * 1863 * FUNCTION: add a new extent of free inodes to an iag, allocating 1864 * an inode from this extent to satisfy the current allocation 1865 * request. 1866 * 1867 * this routine first tries to find an existing iag with free 1868 * extents through the ag free extent list. if list is not 1869 * empty, the head of the list will be selected as the home 1870 * of the new extent of free inodes. otherwise (the list is 1871 * empty), a new iag will be allocated for the ag to contain 1872 * the extent. 1873 * 1874 * once an iag has been selected, the free extent summary map 1875 * is used to locate a free extent within the iag and diNewExt() 1876 * is called to initialize the extent, with initialization 1877 * including the allocation of the first inode of the extent 1878 * for the purpose of satisfying this request. 1879 * 1880 * PARAMETERS: 1881 * imap - pointer to inode map control structure. 1882 * agno - allocation group number. 1883 * ip - pointer to new inode to be filled in on successful return 1884 * with the disk inode number allocated, its extent address 1885 * and the start of the ag. 1886 * 1887 * RETURN VALUES: 1888 * 0 - success. 1889 * -ENOSPC - insufficient disk resources. 1890 * -EIO - i/o error. 1891 */ 1892 static int diAllocExt(struct inomap * imap, int agno, struct inode *ip) 1893 { 1894 int rem, iagno, sword, extno, rc; 1895 struct metapage *mp; 1896 struct iag *iagp; 1897 1898 /* check if the ag has any iags with free extents. if not, 1899 * allocate a new iag for the ag. 1900 */ 1901 if ((iagno = imap->im_agctl[agno].extfree) < 0) { 1902 /* If successful, diNewIAG will obtain the read lock on the 1903 * imap inode. 1904 */ 1905 if ((rc = diNewIAG(imap, &iagno, agno, &mp))) { 1906 return (rc); 1907 } 1908 iagp = (struct iag *) mp->data; 1909 1910 /* set the ag number if this a brand new iag 1911 */ 1912 iagp->agstart = 1913 cpu_to_le64(AGTOBLK(agno, imap->im_ipimap)); 1914 } else { 1915 /* read the iag. 1916 */ 1917 IREAD_LOCK(imap->im_ipimap, RDWRLOCK_IMAP); 1918 if ((rc = diIAGRead(imap, iagno, &mp))) { 1919 IREAD_UNLOCK(imap->im_ipimap); 1920 jfs_error(ip->i_sb, "error reading iag\n"); 1921 return rc; 1922 } 1923 iagp = (struct iag *) mp->data; 1924 } 1925 1926 /* using the free extent summary map, find a free extent. 1927 */ 1928 for (sword = 0;; sword++) { 1929 if (sword >= SMAPSZ) { 1930 release_metapage(mp); 1931 IREAD_UNLOCK(imap->im_ipimap); 1932 jfs_error(ip->i_sb, "free ext summary map not found\n"); 1933 return -EIO; 1934 } 1935 if (~iagp->extsmap[sword]) 1936 break; 1937 } 1938 1939 /* determine the extent number of the free extent. 1940 */ 1941 rem = diFindFree(le32_to_cpu(iagp->extsmap[sword]), 0); 1942 if (rem >= EXTSPERSUM) { 1943 release_metapage(mp); 1944 IREAD_UNLOCK(imap->im_ipimap); 1945 jfs_error(ip->i_sb, "free extent not found\n"); 1946 return -EIO; 1947 } 1948 extno = (sword << L2EXTSPERSUM) + rem; 1949 1950 /* initialize the new extent. 1951 */ 1952 rc = diNewExt(imap, iagp, extno); 1953 IREAD_UNLOCK(imap->im_ipimap); 1954 if (rc) { 1955 /* something bad happened. if a new iag was allocated, 1956 * place it back on the inode map's iag free list, and 1957 * clear the ag number information. 1958 */ 1959 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG)) { 1960 IAGFREE_LOCK(imap); 1961 iagp->iagfree = cpu_to_le32(imap->im_freeiag); 1962 imap->im_freeiag = iagno; 1963 IAGFREE_UNLOCK(imap); 1964 } 1965 write_metapage(mp); 1966 return (rc); 1967 } 1968 1969 /* set the results of the allocation and write the iag. 1970 */ 1971 diInitInode(ip, iagno, extno << L2INOSPEREXT, extno, iagp); 1972 1973 write_metapage(mp); 1974 1975 return (0); 1976 } 1977 1978 1979 /* 1980 * NAME: diAllocBit(imap,iagp,ino) 1981 * 1982 * FUNCTION: allocate a backed inode from an iag. 1983 * 1984 * this routine performs the mechanics of allocating a 1985 * specified inode from a backed extent. 1986 * 1987 * if the inode to be allocated represents the last free 1988 * inode within the iag, the iag will be removed from the 1989 * ag free inode list. 1990 * 1991 * a careful update approach is used to provide consistency 1992 * in the face of updates to multiple buffers. under this 1993 * approach, all required buffers are obtained before making 1994 * any updates and are held all are updates are complete. 1995 * 1996 * PRE CONDITION: Already have buffer lock on iagp. Already have AG lock on 1997 * this AG. Must have read lock on imap inode. 1998 * 1999 * PARAMETERS: 2000 * imap - pointer to inode map control structure. 2001 * iagp - pointer to iag. 2002 * ino - inode number to be allocated within the iag. 2003 * 2004 * RETURN VALUES: 2005 * 0 - success. 2006 * -ENOSPC - insufficient disk resources. 2007 * -EIO - i/o error. 2008 */ 2009 static int diAllocBit(struct inomap * imap, struct iag * iagp, int ino) 2010 { 2011 int extno, bitno, agno, sword, rc; 2012 struct metapage *amp = NULL, *bmp = NULL; 2013 struct iag *aiagp = NULL, *biagp = NULL; 2014 u32 mask; 2015 2016 /* check if this is the last free inode within the iag. 2017 * if so, it will have to be removed from the ag free 2018 * inode list, so get the iags preceding and following 2019 * it on the list. 2020 */ 2021 if (iagp->nfreeinos == cpu_to_le32(1)) { 2022 if ((int) le32_to_cpu(iagp->inofreefwd) >= 0) { 2023 if ((rc = 2024 diIAGRead(imap, le32_to_cpu(iagp->inofreefwd), 2025 &))) 2026 return (rc); 2027 aiagp = (struct iag *) amp->data; 2028 } 2029 2030 if ((int) le32_to_cpu(iagp->inofreeback) >= 0) { 2031 if ((rc = 2032 diIAGRead(imap, 2033 le32_to_cpu(iagp->inofreeback), 2034 &bmp))) { 2035 if (amp) 2036 release_metapage(amp); 2037 return (rc); 2038 } 2039 biagp = (struct iag *) bmp->data; 2040 } 2041 } 2042 2043 /* get the ag number, extent number, inode number within 2044 * the extent. 2045 */ 2046 agno = BLKTOAG(le64_to_cpu(iagp->agstart), JFS_SBI(imap->im_ipimap->i_sb)); 2047 extno = ino >> L2INOSPEREXT; 2048 bitno = ino & (INOSPEREXT - 1); 2049 2050 /* compute the mask for setting the map. 2051 */ 2052 mask = HIGHORDER >> bitno; 2053 2054 /* the inode should be free and backed. 2055 */ 2056 if (((le32_to_cpu(iagp->pmap[extno]) & mask) != 0) || 2057 ((le32_to_cpu(iagp->wmap[extno]) & mask) != 0) || 2058 (addressPXD(&iagp->inoext[extno]) == 0)) { 2059 if (amp) 2060 release_metapage(amp); 2061 if (bmp) 2062 release_metapage(bmp); 2063 2064 jfs_error(imap->im_ipimap->i_sb, "iag inconsistent\n"); 2065 return -EIO; 2066 } 2067 2068 /* mark the inode as allocated in the working map. 2069 */ 2070 iagp->wmap[extno] |= cpu_to_le32(mask); 2071 2072 /* check if all inodes within the extent are now 2073 * allocated. if so, update the free inode summary 2074 * map to reflect this. 2075 */ 2076 if (iagp->wmap[extno] == cpu_to_le32(ONES)) { 2077 sword = extno >> L2EXTSPERSUM; 2078 bitno = extno & (EXTSPERSUM - 1); 2079 iagp->inosmap[sword] |= cpu_to_le32(HIGHORDER >> bitno); 2080 } 2081 2082 /* if this was the last free inode in the iag, remove the 2083 * iag from the ag free inode list. 2084 */ 2085 if (iagp->nfreeinos == cpu_to_le32(1)) { 2086 if (amp) { 2087 aiagp->inofreeback = iagp->inofreeback; 2088 write_metapage(amp); 2089 } 2090 2091 if (bmp) { 2092 biagp->inofreefwd = iagp->inofreefwd; 2093 write_metapage(bmp); 2094 } else { 2095 imap->im_agctl[agno].inofree = 2096 le32_to_cpu(iagp->inofreefwd); 2097 } 2098 iagp->inofreefwd = iagp->inofreeback = cpu_to_le32(-1); 2099 } 2100 2101 /* update the free inode count at the iag, ag, inode 2102 * map levels. 2103 */ 2104 le32_add_cpu(&iagp->nfreeinos, -1); 2105 imap->im_agctl[agno].numfree -= 1; 2106 atomic_dec(&imap->im_numfree); 2107 2108 return (0); 2109 } 2110 2111 2112 /* 2113 * NAME: diNewExt(imap,iagp,extno) 2114 * 2115 * FUNCTION: initialize a new extent of inodes for an iag, allocating 2116 * the first inode of the extent for use for the current 2117 * allocation request. 2118 * 2119 * disk resources are allocated for the new extent of inodes 2120 * and the inodes themselves are initialized to reflect their 2121 * existence within the extent (i.e. their inode numbers and 2122 * inode extent addresses are set) and their initial state 2123 * (mode and link count are set to zero). 2124 * 2125 * if the iag is new, it is not yet on an ag extent free list 2126 * but will now be placed on this list. 2127 * 2128 * if the allocation of the new extent causes the iag to 2129 * have no free extent, the iag will be removed from the 2130 * ag extent free list. 2131 * 2132 * if the iag has no free backed inodes, it will be placed 2133 * on the ag free inode list, since the addition of the new 2134 * extent will now cause it to have free inodes. 2135 * 2136 * a careful update approach is used to provide consistency 2137 * (i.e. list consistency) in the face of updates to multiple 2138 * buffers. under this approach, all required buffers are 2139 * obtained before making any updates and are held until all 2140 * updates are complete. 2141 * 2142 * PRE CONDITION: Already have buffer lock on iagp. Already have AG lock on 2143 * this AG. Must have read lock on imap inode. 2144 * 2145 * PARAMETERS: 2146 * imap - pointer to inode map control structure. 2147 * iagp - pointer to iag. 2148 * extno - extent number. 2149 * 2150 * RETURN VALUES: 2151 * 0 - success. 2152 * -ENOSPC - insufficient disk resources. 2153 * -EIO - i/o error. 2154 */ 2155 static int diNewExt(struct inomap * imap, struct iag * iagp, int extno) 2156 { 2157 int agno, iagno, fwd, back, freei = 0, sword, rc; 2158 struct iag *aiagp = NULL, *biagp = NULL, *ciagp = NULL; 2159 struct metapage *amp, *bmp, *cmp, *dmp; 2160 struct inode *ipimap; 2161 s64 blkno, hint; 2162 int i, j; 2163 u32 mask; 2164 ino_t ino; 2165 struct dinode *dp; 2166 struct jfs_sb_info *sbi; 2167 2168 /* better have free extents. 2169 */ 2170 if (!iagp->nfreeexts) { 2171 jfs_error(imap->im_ipimap->i_sb, "no free extents\n"); 2172 return -EIO; 2173 } 2174 2175 /* get the inode map inode. 2176 */ 2177 ipimap = imap->im_ipimap; 2178 sbi = JFS_SBI(ipimap->i_sb); 2179 2180 amp = bmp = cmp = NULL; 2181 2182 /* get the ag and iag numbers for this iag. 2183 */ 2184 agno = BLKTOAG(le64_to_cpu(iagp->agstart), sbi); 2185 if (agno >= MAXAG || agno < 0) 2186 return -EIO; 2187 2188 iagno = le32_to_cpu(iagp->iagnum); 2189 2190 /* check if this is the last free extent within the 2191 * iag. if so, the iag must be removed from the ag 2192 * free extent list, so get the iags preceding and 2193 * following the iag on this list. 2194 */ 2195 if (iagp->nfreeexts == cpu_to_le32(1)) { 2196 if ((fwd = le32_to_cpu(iagp->extfreefwd)) >= 0) { 2197 if ((rc = diIAGRead(imap, fwd, &))) 2198 return (rc); 2199 aiagp = (struct iag *) amp->data; 2200 } 2201 2202 if ((back = le32_to_cpu(iagp->extfreeback)) >= 0) { 2203 if ((rc = diIAGRead(imap, back, &bmp))) 2204 goto error_out; 2205 biagp = (struct iag *) bmp->data; 2206 } 2207 } else { 2208 /* the iag has free extents. if all extents are free 2209 * (as is the case for a newly allocated iag), the iag 2210 * must be added to the ag free extent list, so get 2211 * the iag at the head of the list in preparation for 2212 * adding this iag to this list. 2213 */ 2214 fwd = back = -1; 2215 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG)) { 2216 if ((fwd = imap->im_agctl[agno].extfree) >= 0) { 2217 if ((rc = diIAGRead(imap, fwd, &))) 2218 goto error_out; 2219 aiagp = (struct iag *) amp->data; 2220 } 2221 } 2222 } 2223 2224 /* check if the iag has no free inodes. if so, the iag 2225 * will have to be added to the ag free inode list, so get 2226 * the iag at the head of the list in preparation for 2227 * adding this iag to this list. in doing this, we must 2228 * check if we already have the iag at the head of 2229 * the list in hand. 2230 */ 2231 if (iagp->nfreeinos == 0) { 2232 freei = imap->im_agctl[agno].inofree; 2233 2234 if (freei >= 0) { 2235 if (freei == fwd) { 2236 ciagp = aiagp; 2237 } else if (freei == back) { 2238 ciagp = biagp; 2239 } else { 2240 if ((rc = diIAGRead(imap, freei, &cmp))) 2241 goto error_out; 2242 ciagp = (struct iag *) cmp->data; 2243 } 2244 if (ciagp == NULL) { 2245 jfs_error(imap->im_ipimap->i_sb, 2246 "ciagp == NULL\n"); 2247 rc = -EIO; 2248 goto error_out; 2249 } 2250 } 2251 } 2252 2253 /* allocate disk space for the inode extent. 2254 */ 2255 if ((extno == 0) || (addressPXD(&iagp->inoext[extno - 1]) == 0)) 2256 hint = ((s64) agno << sbi->bmap->db_agl2size) - 1; 2257 else 2258 hint = addressPXD(&iagp->inoext[extno - 1]) + 2259 lengthPXD(&iagp->inoext[extno - 1]) - 1; 2260 2261 if ((rc = dbAlloc(ipimap, hint, (s64) imap->im_nbperiext, &blkno))) 2262 goto error_out; 2263 2264 /* compute the inode number of the first inode within the 2265 * extent. 2266 */ 2267 ino = (iagno << L2INOSPERIAG) + (extno << L2INOSPEREXT); 2268 2269 /* initialize the inodes within the newly allocated extent a 2270 * page at a time. 2271 */ 2272 for (i = 0; i < imap->im_nbperiext; i += sbi->nbperpage) { 2273 /* get a buffer for this page of disk inodes. 2274 */ 2275 dmp = get_metapage(ipimap, blkno + i, PSIZE, 1); 2276 if (dmp == NULL) { 2277 rc = -EIO; 2278 goto error_out; 2279 } 2280 dp = (struct dinode *) dmp->data; 2281 2282 /* initialize the inode number, mode, link count and 2283 * inode extent address. 2284 */ 2285 for (j = 0; j < INOSPERPAGE; j++, dp++, ino++) { 2286 dp->di_inostamp = cpu_to_le32(sbi->inostamp); 2287 dp->di_number = cpu_to_le32(ino); 2288 dp->di_fileset = cpu_to_le32(FILESYSTEM_I); 2289 dp->di_mode = 0; 2290 dp->di_nlink = 0; 2291 PXDaddress(&(dp->di_ixpxd), blkno); 2292 PXDlength(&(dp->di_ixpxd), imap->im_nbperiext); 2293 } 2294 write_metapage(dmp); 2295 } 2296 2297 /* if this is the last free extent within the iag, remove the 2298 * iag from the ag free extent list. 2299 */ 2300 if (iagp->nfreeexts == cpu_to_le32(1)) { 2301 if (fwd >= 0) 2302 aiagp->extfreeback = iagp->extfreeback; 2303 2304 if (back >= 0) 2305 biagp->extfreefwd = iagp->extfreefwd; 2306 else 2307 imap->im_agctl[agno].extfree = 2308 le32_to_cpu(iagp->extfreefwd); 2309 2310 iagp->extfreefwd = iagp->extfreeback = cpu_to_le32(-1); 2311 } else { 2312 /* if the iag has all free extents (newly allocated iag), 2313 * add the iag to the ag free extent list. 2314 */ 2315 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG)) { 2316 if (fwd >= 0) 2317 aiagp->extfreeback = cpu_to_le32(iagno); 2318 2319 iagp->extfreefwd = cpu_to_le32(fwd); 2320 iagp->extfreeback = cpu_to_le32(-1); 2321 imap->im_agctl[agno].extfree = iagno; 2322 } 2323 } 2324 2325 /* if the iag has no free inodes, add the iag to the 2326 * ag free inode list. 2327 */ 2328 if (iagp->nfreeinos == 0) { 2329 if (freei >= 0) 2330 ciagp->inofreeback = cpu_to_le32(iagno); 2331 2332 iagp->inofreefwd = 2333 cpu_to_le32(imap->im_agctl[agno].inofree); 2334 iagp->inofreeback = cpu_to_le32(-1); 2335 imap->im_agctl[agno].inofree = iagno; 2336 } 2337 2338 /* initialize the extent descriptor of the extent. */ 2339 PXDlength(&iagp->inoext[extno], imap->im_nbperiext); 2340 PXDaddress(&iagp->inoext[extno], blkno); 2341 2342 /* initialize the working and persistent map of the extent. 2343 * the working map will be initialized such that 2344 * it indicates the first inode of the extent is allocated. 2345 */ 2346 iagp->wmap[extno] = cpu_to_le32(HIGHORDER); 2347 iagp->pmap[extno] = 0; 2348 2349 /* update the free inode and free extent summary maps 2350 * for the extent to indicate the extent has free inodes 2351 * and no longer represents a free extent. 2352 */ 2353 sword = extno >> L2EXTSPERSUM; 2354 mask = HIGHORDER >> (extno & (EXTSPERSUM - 1)); 2355 iagp->extsmap[sword] |= cpu_to_le32(mask); 2356 iagp->inosmap[sword] &= cpu_to_le32(~mask); 2357 2358 /* update the free inode and free extent counts for the 2359 * iag. 2360 */ 2361 le32_add_cpu(&iagp->nfreeinos, (INOSPEREXT - 1)); 2362 le32_add_cpu(&iagp->nfreeexts, -1); 2363 2364 /* update the free and backed inode counts for the ag. 2365 */ 2366 imap->im_agctl[agno].numfree += (INOSPEREXT - 1); 2367 imap->im_agctl[agno].numinos += INOSPEREXT; 2368 2369 /* update the free and backed inode counts for the inode map. 2370 */ 2371 atomic_add(INOSPEREXT - 1, &imap->im_numfree); 2372 atomic_add(INOSPEREXT, &imap->im_numinos); 2373 2374 /* write the iags. 2375 */ 2376 if (amp) 2377 write_metapage(amp); 2378 if (bmp) 2379 write_metapage(bmp); 2380 if (cmp) 2381 write_metapage(cmp); 2382 2383 return (0); 2384 2385 error_out: 2386 2387 /* release the iags. 2388 */ 2389 if (amp) 2390 release_metapage(amp); 2391 if (bmp) 2392 release_metapage(bmp); 2393 if (cmp) 2394 release_metapage(cmp); 2395 2396 return (rc); 2397 } 2398 2399 2400 /* 2401 * NAME: diNewIAG(imap,iagnop,agno) 2402 * 2403 * FUNCTION: allocate a new iag for an allocation group. 2404 * 2405 * first tries to allocate the iag from the inode map 2406 * iagfree list: 2407 * if the list has free iags, the head of the list is removed 2408 * and returned to satisfy the request. 2409 * if the inode map's iag free list is empty, the inode map 2410 * is extended to hold a new iag. this new iag is initialized 2411 * and returned to satisfy the request. 2412 * 2413 * PARAMETERS: 2414 * imap - pointer to inode map control structure. 2415 * iagnop - pointer to an iag number set with the number of the 2416 * newly allocated iag upon successful return. 2417 * agno - allocation group number. 2418 * bpp - Buffer pointer to be filled in with new IAG's buffer 2419 * 2420 * RETURN VALUES: 2421 * 0 - success. 2422 * -ENOSPC - insufficient disk resources. 2423 * -EIO - i/o error. 2424 * 2425 * serialization: 2426 * AG lock held on entry/exit; 2427 * write lock on the map is held inside; 2428 * read lock on the map is held on successful completion; 2429 * 2430 * note: new iag transaction: 2431 * . synchronously write iag; 2432 * . write log of xtree and inode of imap; 2433 * . commit; 2434 * . synchronous write of xtree (right to left, bottom to top); 2435 * . at start of logredo(): init in-memory imap with one additional iag page; 2436 * . at end of logredo(): re-read imap inode to determine 2437 * new imap size; 2438 */ 2439 static int 2440 diNewIAG(struct inomap * imap, int *iagnop, int agno, struct metapage ** mpp) 2441 { 2442 int rc; 2443 int iagno, i, xlen; 2444 struct inode *ipimap; 2445 struct super_block *sb; 2446 struct jfs_sb_info *sbi; 2447 struct metapage *mp; 2448 struct iag *iagp; 2449 s64 xaddr = 0; 2450 s64 blkno; 2451 tid_t tid; 2452 struct inode *iplist[1]; 2453 2454 /* pick up pointers to the inode map and mount inodes */ 2455 ipimap = imap->im_ipimap; 2456 sb = ipimap->i_sb; 2457 sbi = JFS_SBI(sb); 2458 2459 /* acquire the free iag lock */ 2460 IAGFREE_LOCK(imap); 2461 2462 /* if there are any iags on the inode map free iag list, 2463 * allocate the iag from the head of the list. 2464 */ 2465 if (imap->im_freeiag >= 0) { 2466 /* pick up the iag number at the head of the list */ 2467 iagno = imap->im_freeiag; 2468 2469 /* determine the logical block number of the iag */ 2470 blkno = IAGTOLBLK(iagno, sbi->l2nbperpage); 2471 } else { 2472 /* no free iags. the inode map will have to be extented 2473 * to include a new iag. 2474 */ 2475 2476 /* acquire inode map lock */ 2477 IWRITE_LOCK(ipimap, RDWRLOCK_IMAP); 2478 2479 if (ipimap->i_size >> L2PSIZE != imap->im_nextiag + 1) { 2480 IWRITE_UNLOCK(ipimap); 2481 IAGFREE_UNLOCK(imap); 2482 jfs_error(imap->im_ipimap->i_sb, 2483 "ipimap->i_size is wrong\n"); 2484 return -EIO; 2485 } 2486 2487 2488 /* get the next available iag number */ 2489 iagno = imap->im_nextiag; 2490 2491 /* make sure that we have not exceeded the maximum inode 2492 * number limit. 2493 */ 2494 if (iagno > (MAXIAGS - 1)) { 2495 /* release the inode map lock */ 2496 IWRITE_UNLOCK(ipimap); 2497 2498 rc = -ENOSPC; 2499 goto out; 2500 } 2501 2502 /* 2503 * synchronously append new iag page. 2504 */ 2505 /* determine the logical address of iag page to append */ 2506 blkno = IAGTOLBLK(iagno, sbi->l2nbperpage); 2507 2508 /* Allocate extent for new iag page */ 2509 xlen = sbi->nbperpage; 2510 if ((rc = dbAlloc(ipimap, 0, (s64) xlen, &xaddr))) { 2511 /* release the inode map lock */ 2512 IWRITE_UNLOCK(ipimap); 2513 2514 goto out; 2515 } 2516 2517 /* 2518 * start transaction of update of the inode map 2519 * addressing structure pointing to the new iag page; 2520 */ 2521 tid = txBegin(sb, COMMIT_FORCE); 2522 mutex_lock(&JFS_IP(ipimap)->commit_mutex); 2523 2524 /* update the inode map addressing structure to point to it */ 2525 if ((rc = 2526 xtInsert(tid, ipimap, 0, blkno, xlen, &xaddr, 0))) { 2527 txEnd(tid); 2528 mutex_unlock(&JFS_IP(ipimap)->commit_mutex); 2529 /* Free the blocks allocated for the iag since it was 2530 * not successfully added to the inode map 2531 */ 2532 dbFree(ipimap, xaddr, (s64) xlen); 2533 2534 /* release the inode map lock */ 2535 IWRITE_UNLOCK(ipimap); 2536 2537 goto out; 2538 } 2539 2540 /* update the inode map's inode to reflect the extension */ 2541 ipimap->i_size += PSIZE; 2542 inode_add_bytes(ipimap, PSIZE); 2543 2544 /* assign a buffer for the page */ 2545 mp = get_metapage(ipimap, blkno, PSIZE, 0); 2546 if (!mp) { 2547 /* 2548 * This is very unlikely since we just created the 2549 * extent, but let's try to handle it correctly 2550 */ 2551 xtTruncate(tid, ipimap, ipimap->i_size - PSIZE, 2552 COMMIT_PWMAP); 2553 2554 txAbort(tid, 0); 2555 txEnd(tid); 2556 mutex_unlock(&JFS_IP(ipimap)->commit_mutex); 2557 2558 /* release the inode map lock */ 2559 IWRITE_UNLOCK(ipimap); 2560 2561 rc = -EIO; 2562 goto out; 2563 } 2564 iagp = (struct iag *) mp->data; 2565 2566 /* init the iag */ 2567 memset(iagp, 0, sizeof(struct iag)); 2568 iagp->iagnum = cpu_to_le32(iagno); 2569 iagp->inofreefwd = iagp->inofreeback = cpu_to_le32(-1); 2570 iagp->extfreefwd = iagp->extfreeback = cpu_to_le32(-1); 2571 iagp->iagfree = cpu_to_le32(-1); 2572 iagp->nfreeinos = 0; 2573 iagp->nfreeexts = cpu_to_le32(EXTSPERIAG); 2574 2575 /* initialize the free inode summary map (free extent 2576 * summary map initialization handled by bzero). 2577 */ 2578 for (i = 0; i < SMAPSZ; i++) 2579 iagp->inosmap[i] = cpu_to_le32(ONES); 2580 2581 /* 2582 * Write and sync the metapage 2583 */ 2584 flush_metapage(mp); 2585 2586 /* 2587 * txCommit(COMMIT_FORCE) will synchronously write address 2588 * index pages and inode after commit in careful update order 2589 * of address index pages (right to left, bottom up); 2590 */ 2591 iplist[0] = ipimap; 2592 rc = txCommit(tid, 1, &iplist[0], COMMIT_FORCE); 2593 2594 txEnd(tid); 2595 mutex_unlock(&JFS_IP(ipimap)->commit_mutex); 2596 2597 duplicateIXtree(sb, blkno, xlen, &xaddr); 2598 2599 /* update the next available iag number */ 2600 imap->im_nextiag += 1; 2601 2602 /* Add the iag to the iag free list so we don't lose the iag 2603 * if a failure happens now. 2604 */ 2605 imap->im_freeiag = iagno; 2606 2607 /* Until we have logredo working, we want the imap inode & 2608 * control page to be up to date. 2609 */ 2610 diSync(ipimap); 2611 2612 /* release the inode map lock */ 2613 IWRITE_UNLOCK(ipimap); 2614 } 2615 2616 /* obtain read lock on map */ 2617 IREAD_LOCK(ipimap, RDWRLOCK_IMAP); 2618 2619 /* read the iag */ 2620 if ((rc = diIAGRead(imap, iagno, &mp))) { 2621 IREAD_UNLOCK(ipimap); 2622 rc = -EIO; 2623 goto out; 2624 } 2625 iagp = (struct iag *) mp->data; 2626 2627 /* remove the iag from the iag free list */ 2628 imap->im_freeiag = le32_to_cpu(iagp->iagfree); 2629 iagp->iagfree = cpu_to_le32(-1); 2630 2631 /* set the return iag number and buffer pointer */ 2632 *iagnop = iagno; 2633 *mpp = mp; 2634 2635 out: 2636 /* release the iag free lock */ 2637 IAGFREE_UNLOCK(imap); 2638 2639 return (rc); 2640 } 2641 2642 /* 2643 * NAME: diIAGRead() 2644 * 2645 * FUNCTION: get the buffer for the specified iag within a fileset 2646 * or aggregate inode map. 2647 * 2648 * PARAMETERS: 2649 * imap - pointer to inode map control structure. 2650 * iagno - iag number. 2651 * bpp - point to buffer pointer to be filled in on successful 2652 * exit. 2653 * 2654 * SERIALIZATION: 2655 * must have read lock on imap inode 2656 * (When called by diExtendFS, the filesystem is quiesced, therefore 2657 * the read lock is unnecessary.) 2658 * 2659 * RETURN VALUES: 2660 * 0 - success. 2661 * -EIO - i/o error. 2662 */ 2663 static int diIAGRead(struct inomap * imap, int iagno, struct metapage ** mpp) 2664 { 2665 struct inode *ipimap = imap->im_ipimap; 2666 s64 blkno; 2667 2668 /* compute the logical block number of the iag. */ 2669 blkno = IAGTOLBLK(iagno, JFS_SBI(ipimap->i_sb)->l2nbperpage); 2670 2671 /* read the iag. */ 2672 *mpp = read_metapage(ipimap, blkno, PSIZE, 0); 2673 if (*mpp == NULL) { 2674 return -EIO; 2675 } 2676 2677 return (0); 2678 } 2679 2680 /* 2681 * NAME: diFindFree() 2682 * 2683 * FUNCTION: find the first free bit in a word starting at 2684 * the specified bit position. 2685 * 2686 * PARAMETERS: 2687 * word - word to be examined. 2688 * start - starting bit position. 2689 * 2690 * RETURN VALUES: 2691 * bit position of first free bit in the word or 32 if 2692 * no free bits were found. 2693 */ 2694 static int diFindFree(u32 word, int start) 2695 { 2696 int bitno; 2697 assert(start < 32); 2698 /* scan the word for the first free bit. */ 2699 for (word <<= start, bitno = start; bitno < 32; 2700 bitno++, word <<= 1) { 2701 if ((word & HIGHORDER) == 0) 2702 break; 2703 } 2704 return (bitno); 2705 } 2706 2707 /* 2708 * NAME: diUpdatePMap() 2709 * 2710 * FUNCTION: Update the persistent map in an IAG for the allocation or 2711 * freeing of the specified inode. 2712 * 2713 * PRE CONDITIONS: Working map has already been updated for allocate. 2714 * 2715 * PARAMETERS: 2716 * ipimap - Incore inode map inode 2717 * inum - Number of inode to mark in permanent map 2718 * is_free - If 'true' indicates inode should be marked freed, otherwise 2719 * indicates inode should be marked allocated. 2720 * 2721 * RETURN VALUES: 2722 * 0 for success 2723 */ 2724 int 2725 diUpdatePMap(struct inode *ipimap, 2726 unsigned long inum, bool is_free, struct tblock * tblk) 2727 { 2728 int rc; 2729 struct iag *iagp; 2730 struct metapage *mp; 2731 int iagno, ino, extno, bitno; 2732 struct inomap *imap; 2733 u32 mask; 2734 struct jfs_log *log; 2735 int lsn, difft, diffp; 2736 unsigned long flags; 2737 2738 imap = JFS_IP(ipimap)->i_imap; 2739 /* get the iag number containing the inode */ 2740 iagno = INOTOIAG(inum); 2741 /* make sure that the iag is contained within the map */ 2742 if (iagno >= imap->im_nextiag) { 2743 jfs_error(ipimap->i_sb, "the iag is outside the map\n"); 2744 return -EIO; 2745 } 2746 /* read the iag */ 2747 IREAD_LOCK(ipimap, RDWRLOCK_IMAP); 2748 rc = diIAGRead(imap, iagno, &mp); 2749 IREAD_UNLOCK(ipimap); 2750 if (rc) 2751 return (rc); 2752 metapage_wait_for_io(mp); 2753 iagp = (struct iag *) mp->data; 2754 /* get the inode number and extent number of the inode within 2755 * the iag and the inode number within the extent. 2756 */ 2757 ino = inum & (INOSPERIAG - 1); 2758 extno = ino >> L2INOSPEREXT; 2759 bitno = ino & (INOSPEREXT - 1); 2760 mask = HIGHORDER >> bitno; 2761 /* 2762 * mark the inode free in persistent map: 2763 */ 2764 if (is_free) { 2765 /* The inode should have been allocated both in working 2766 * map and in persistent map; 2767 * the inode will be freed from working map at the release 2768 * of last reference release; 2769 */ 2770 if (!(le32_to_cpu(iagp->wmap[extno]) & mask)) { 2771 jfs_error(ipimap->i_sb, 2772 "inode %ld not marked as allocated in wmap!\n", 2773 inum); 2774 } 2775 if (!(le32_to_cpu(iagp->pmap[extno]) & mask)) { 2776 jfs_error(ipimap->i_sb, 2777 "inode %ld not marked as allocated in pmap!\n", 2778 inum); 2779 } 2780 /* update the bitmap for the extent of the freed inode */ 2781 iagp->pmap[extno] &= cpu_to_le32(~mask); 2782 } 2783 /* 2784 * mark the inode allocated in persistent map: 2785 */ 2786 else { 2787 /* The inode should be already allocated in the working map 2788 * and should be free in persistent map; 2789 */ 2790 if (!(le32_to_cpu(iagp->wmap[extno]) & mask)) { 2791 release_metapage(mp); 2792 jfs_error(ipimap->i_sb, 2793 "the inode is not allocated in the working map\n"); 2794 return -EIO; 2795 } 2796 if ((le32_to_cpu(iagp->pmap[extno]) & mask) != 0) { 2797 release_metapage(mp); 2798 jfs_error(ipimap->i_sb, 2799 "the inode is not free in the persistent map\n"); 2800 return -EIO; 2801 } 2802 /* update the bitmap for the extent of the allocated inode */ 2803 iagp->pmap[extno] |= cpu_to_le32(mask); 2804 } 2805 /* 2806 * update iag lsn 2807 */ 2808 lsn = tblk->lsn; 2809 log = JFS_SBI(tblk->sb)->log; 2810 LOGSYNC_LOCK(log, flags); 2811 if (mp->lsn != 0) { 2812 /* inherit older/smaller lsn */ 2813 logdiff(difft, lsn, log); 2814 logdiff(diffp, mp->lsn, log); 2815 if (difft < diffp) { 2816 mp->lsn = lsn; 2817 /* move mp after tblock in logsync list */ 2818 list_move(&mp->synclist, &tblk->synclist); 2819 } 2820 /* inherit younger/larger clsn */ 2821 assert(mp->clsn); 2822 logdiff(difft, tblk->clsn, log); 2823 logdiff(diffp, mp->clsn, log); 2824 if (difft > diffp) 2825 mp->clsn = tblk->clsn; 2826 } else { 2827 mp->log = log; 2828 mp->lsn = lsn; 2829 /* insert mp after tblock in logsync list */ 2830 log->count++; 2831 list_add(&mp->synclist, &tblk->synclist); 2832 mp->clsn = tblk->clsn; 2833 } 2834 LOGSYNC_UNLOCK(log, flags); 2835 write_metapage(mp); 2836 return (0); 2837 } 2838 2839 /* 2840 * diExtendFS() 2841 * 2842 * function: update imap for extendfs(); 2843 * 2844 * note: AG size has been increased s.t. each k old contiguous AGs are 2845 * coalesced into a new AG; 2846 */ 2847 int diExtendFS(struct inode *ipimap, struct inode *ipbmap) 2848 { 2849 int rc, rcx = 0; 2850 struct inomap *imap = JFS_IP(ipimap)->i_imap; 2851 struct iag *iagp = NULL, *hiagp = NULL; 2852 struct bmap *mp = JFS_SBI(ipbmap->i_sb)->bmap; 2853 struct metapage *bp, *hbp; 2854 int i, n, head; 2855 int numinos, xnuminos = 0, xnumfree = 0; 2856 s64 agstart; 2857 2858 jfs_info("diExtendFS: nextiag:%d numinos:%d numfree:%d", 2859 imap->im_nextiag, atomic_read(&imap->im_numinos), 2860 atomic_read(&imap->im_numfree)); 2861 2862 /* 2863 * reconstruct imap 2864 * 2865 * coalesce contiguous k (newAGSize/oldAGSize) AGs; 2866 * i.e., (AGi, ..., AGj) where i = k*n and j = k*(n+1) - 1 to AGn; 2867 * note: new AG size = old AG size * (2**x). 2868 */ 2869 2870 /* init per AG control information im_agctl[] */ 2871 for (i = 0; i < MAXAG; i++) { 2872 imap->im_agctl[i].inofree = -1; 2873 imap->im_agctl[i].extfree = -1; 2874 imap->im_agctl[i].numinos = 0; /* number of backed inodes */ 2875 imap->im_agctl[i].numfree = 0; /* number of free backed inodes */ 2876 } 2877 2878 /* 2879 * process each iag page of the map. 2880 * 2881 * rebuild AG Free Inode List, AG Free Inode Extent List; 2882 */ 2883 for (i = 0; i < imap->im_nextiag; i++) { 2884 if ((rc = diIAGRead(imap, i, &bp))) { 2885 rcx = rc; 2886 continue; 2887 } 2888 iagp = (struct iag *) bp->data; 2889 if (le32_to_cpu(iagp->iagnum) != i) { 2890 release_metapage(bp); 2891 jfs_error(ipimap->i_sb, "unexpected value of iagnum\n"); 2892 return -EIO; 2893 } 2894 2895 /* leave free iag in the free iag list */ 2896 if (iagp->nfreeexts == cpu_to_le32(EXTSPERIAG)) { 2897 release_metapage(bp); 2898 continue; 2899 } 2900 2901 agstart = le64_to_cpu(iagp->agstart); 2902 n = agstart >> mp->db_agl2size; 2903 iagp->agstart = cpu_to_le64((s64)n << mp->db_agl2size); 2904 2905 /* compute backed inodes */ 2906 numinos = (EXTSPERIAG - le32_to_cpu(iagp->nfreeexts)) 2907 << L2INOSPEREXT; 2908 if (numinos > 0) { 2909 /* merge AG backed inodes */ 2910 imap->im_agctl[n].numinos += numinos; 2911 xnuminos += numinos; 2912 } 2913 2914 /* if any backed free inodes, insert at AG free inode list */ 2915 if ((int) le32_to_cpu(iagp->nfreeinos) > 0) { 2916 if ((head = imap->im_agctl[n].inofree) == -1) { 2917 iagp->inofreefwd = cpu_to_le32(-1); 2918 iagp->inofreeback = cpu_to_le32(-1); 2919 } else { 2920 if ((rc = diIAGRead(imap, head, &hbp))) { 2921 rcx = rc; 2922 goto nextiag; 2923 } 2924 hiagp = (struct iag *) hbp->data; 2925 hiagp->inofreeback = iagp->iagnum; 2926 iagp->inofreefwd = cpu_to_le32(head); 2927 iagp->inofreeback = cpu_to_le32(-1); 2928 write_metapage(hbp); 2929 } 2930 2931 imap->im_agctl[n].inofree = 2932 le32_to_cpu(iagp->iagnum); 2933 2934 /* merge AG backed free inodes */ 2935 imap->im_agctl[n].numfree += 2936 le32_to_cpu(iagp->nfreeinos); 2937 xnumfree += le32_to_cpu(iagp->nfreeinos); 2938 } 2939 2940 /* if any free extents, insert at AG free extent list */ 2941 if (le32_to_cpu(iagp->nfreeexts) > 0) { 2942 if ((head = imap->im_agctl[n].extfree) == -1) { 2943 iagp->extfreefwd = cpu_to_le32(-1); 2944 iagp->extfreeback = cpu_to_le32(-1); 2945 } else { 2946 if ((rc = diIAGRead(imap, head, &hbp))) { 2947 rcx = rc; 2948 goto nextiag; 2949 } 2950 hiagp = (struct iag *) hbp->data; 2951 hiagp->extfreeback = iagp->iagnum; 2952 iagp->extfreefwd = cpu_to_le32(head); 2953 iagp->extfreeback = cpu_to_le32(-1); 2954 write_metapage(hbp); 2955 } 2956 2957 imap->im_agctl[n].extfree = 2958 le32_to_cpu(iagp->iagnum); 2959 } 2960 2961 nextiag: 2962 write_metapage(bp); 2963 } 2964 2965 if (xnuminos != atomic_read(&imap->im_numinos) || 2966 xnumfree != atomic_read(&imap->im_numfree)) { 2967 jfs_error(ipimap->i_sb, "numinos or numfree incorrect\n"); 2968 return -EIO; 2969 } 2970 2971 return rcx; 2972 } 2973 2974 2975 /* 2976 * duplicateIXtree() 2977 * 2978 * serialization: IWRITE_LOCK held on entry/exit 2979 * 2980 * note: shadow page with regular inode (rel.2); 2981 */ 2982 static void duplicateIXtree(struct super_block *sb, s64 blkno, 2983 int xlen, s64 *xaddr) 2984 { 2985 struct jfs_superblock *j_sb; 2986 struct buffer_head *bh; 2987 struct inode *ip; 2988 tid_t tid; 2989 2990 /* if AIT2 ipmap2 is bad, do not try to update it */ 2991 if (JFS_SBI(sb)->mntflag & JFS_BAD_SAIT) /* s_flag */ 2992 return; 2993 ip = diReadSpecial(sb, FILESYSTEM_I, 1); 2994 if (ip == NULL) { 2995 JFS_SBI(sb)->mntflag |= JFS_BAD_SAIT; 2996 if (readSuper(sb, &bh)) 2997 return; 2998 j_sb = (struct jfs_superblock *)bh->b_data; 2999 j_sb->s_flag |= cpu_to_le32(JFS_BAD_SAIT); 3000 3001 mark_buffer_dirty(bh); 3002 sync_dirty_buffer(bh); 3003 brelse(bh); 3004 return; 3005 } 3006 3007 /* start transaction */ 3008 tid = txBegin(sb, COMMIT_FORCE); 3009 /* update the inode map addressing structure to point to it */ 3010 if (xtInsert(tid, ip, 0, blkno, xlen, xaddr, 0)) { 3011 JFS_SBI(sb)->mntflag |= JFS_BAD_SAIT; 3012 txAbort(tid, 1); 3013 goto cleanup; 3014 3015 } 3016 /* update the inode map's inode to reflect the extension */ 3017 ip->i_size += PSIZE; 3018 inode_add_bytes(ip, PSIZE); 3019 txCommit(tid, 1, &ip, COMMIT_FORCE); 3020 cleanup: 3021 txEnd(tid); 3022 diFreeSpecial(ip); 3023 } 3024 3025 /* 3026 * NAME: copy_from_dinode() 3027 * 3028 * FUNCTION: Copies inode info from disk inode to in-memory inode 3029 * 3030 * RETURN VALUES: 3031 * 0 - success 3032 * -ENOMEM - insufficient memory 3033 */ 3034 static int copy_from_dinode(struct dinode * dip, struct inode *ip) 3035 { 3036 struct jfs_inode_info *jfs_ip = JFS_IP(ip); 3037 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 3038 3039 jfs_ip->fileset = le32_to_cpu(dip->di_fileset); 3040 jfs_ip->mode2 = le32_to_cpu(dip->di_mode); 3041 jfs_set_inode_flags(ip); 3042 3043 ip->i_mode = le32_to_cpu(dip->di_mode) & 0xffff; 3044 if (sbi->umask != -1) { 3045 ip->i_mode = (ip->i_mode & ~0777) | (0777 & ~sbi->umask); 3046 /* For directories, add x permission if r is allowed by umask */ 3047 if (S_ISDIR(ip->i_mode)) { 3048 if (ip->i_mode & 0400) 3049 ip->i_mode |= 0100; 3050 if (ip->i_mode & 0040) 3051 ip->i_mode |= 0010; 3052 if (ip->i_mode & 0004) 3053 ip->i_mode |= 0001; 3054 } 3055 } 3056 set_nlink(ip, le32_to_cpu(dip->di_nlink)); 3057 3058 jfs_ip->saved_uid = make_kuid(&init_user_ns, le32_to_cpu(dip->di_uid)); 3059 if (!uid_valid(sbi->uid)) 3060 ip->i_uid = jfs_ip->saved_uid; 3061 else { 3062 ip->i_uid = sbi->uid; 3063 } 3064 3065 jfs_ip->saved_gid = make_kgid(&init_user_ns, le32_to_cpu(dip->di_gid)); 3066 if (!gid_valid(sbi->gid)) 3067 ip->i_gid = jfs_ip->saved_gid; 3068 else { 3069 ip->i_gid = sbi->gid; 3070 } 3071 3072 ip->i_size = le64_to_cpu(dip->di_size); 3073 ip->i_atime.tv_sec = le32_to_cpu(dip->di_atime.tv_sec); 3074 ip->i_atime.tv_nsec = le32_to_cpu(dip->di_atime.tv_nsec); 3075 ip->i_mtime.tv_sec = le32_to_cpu(dip->di_mtime.tv_sec); 3076 ip->i_mtime.tv_nsec = le32_to_cpu(dip->di_mtime.tv_nsec); 3077 inode_set_ctime(ip, le32_to_cpu(dip->di_ctime.tv_sec), 3078 le32_to_cpu(dip->di_ctime.tv_nsec)); 3079 ip->i_blocks = LBLK2PBLK(ip->i_sb, le64_to_cpu(dip->di_nblocks)); 3080 ip->i_generation = le32_to_cpu(dip->di_gen); 3081 3082 jfs_ip->ixpxd = dip->di_ixpxd; /* in-memory pxd's are little-endian */ 3083 jfs_ip->acl = dip->di_acl; /* as are dxd's */ 3084 jfs_ip->ea = dip->di_ea; 3085 jfs_ip->next_index = le32_to_cpu(dip->di_next_index); 3086 jfs_ip->otime = le32_to_cpu(dip->di_otime.tv_sec); 3087 jfs_ip->acltype = le32_to_cpu(dip->di_acltype); 3088 3089 if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode)) { 3090 jfs_ip->dev = le32_to_cpu(dip->di_rdev); 3091 ip->i_rdev = new_decode_dev(jfs_ip->dev); 3092 } 3093 3094 if (S_ISDIR(ip->i_mode)) { 3095 memcpy(&jfs_ip->u.dir, &dip->u._dir, 384); 3096 } else if (S_ISREG(ip->i_mode) || S_ISLNK(ip->i_mode)) { 3097 memcpy(&jfs_ip->i_xtroot, &dip->di_xtroot, 288); 3098 } else 3099 memcpy(&jfs_ip->i_inline_ea, &dip->di_inlineea, 128); 3100 3101 /* Zero the in-memory-only stuff */ 3102 jfs_ip->cflag = 0; 3103 jfs_ip->btindex = 0; 3104 jfs_ip->btorder = 0; 3105 jfs_ip->bxflag = 0; 3106 jfs_ip->blid = 0; 3107 jfs_ip->atlhead = 0; 3108 jfs_ip->atltail = 0; 3109 jfs_ip->xtlid = 0; 3110 return (0); 3111 } 3112 3113 /* 3114 * NAME: copy_to_dinode() 3115 * 3116 * FUNCTION: Copies inode info from in-memory inode to disk inode 3117 */ 3118 static void copy_to_dinode(struct dinode * dip, struct inode *ip) 3119 { 3120 struct jfs_inode_info *jfs_ip = JFS_IP(ip); 3121 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); 3122 3123 dip->di_fileset = cpu_to_le32(jfs_ip->fileset); 3124 dip->di_inostamp = cpu_to_le32(sbi->inostamp); 3125 dip->di_number = cpu_to_le32(ip->i_ino); 3126 dip->di_gen = cpu_to_le32(ip->i_generation); 3127 dip->di_size = cpu_to_le64(ip->i_size); 3128 dip->di_nblocks = cpu_to_le64(PBLK2LBLK(ip->i_sb, ip->i_blocks)); 3129 dip->di_nlink = cpu_to_le32(ip->i_nlink); 3130 if (!uid_valid(sbi->uid)) 3131 dip->di_uid = cpu_to_le32(i_uid_read(ip)); 3132 else 3133 dip->di_uid =cpu_to_le32(from_kuid(&init_user_ns, 3134 jfs_ip->saved_uid)); 3135 if (!gid_valid(sbi->gid)) 3136 dip->di_gid = cpu_to_le32(i_gid_read(ip)); 3137 else 3138 dip->di_gid = cpu_to_le32(from_kgid(&init_user_ns, 3139 jfs_ip->saved_gid)); 3140 /* 3141 * mode2 is only needed for storing the higher order bits. 3142 * Trust i_mode for the lower order ones 3143 */ 3144 if (sbi->umask == -1) 3145 dip->di_mode = cpu_to_le32((jfs_ip->mode2 & 0xffff0000) | 3146 ip->i_mode); 3147 else /* Leave the original permissions alone */ 3148 dip->di_mode = cpu_to_le32(jfs_ip->mode2); 3149 3150 dip->di_atime.tv_sec = cpu_to_le32(ip->i_atime.tv_sec); 3151 dip->di_atime.tv_nsec = cpu_to_le32(ip->i_atime.tv_nsec); 3152 dip->di_ctime.tv_sec = cpu_to_le32(inode_get_ctime(ip).tv_sec); 3153 dip->di_ctime.tv_nsec = cpu_to_le32(inode_get_ctime(ip).tv_nsec); 3154 dip->di_mtime.tv_sec = cpu_to_le32(ip->i_mtime.tv_sec); 3155 dip->di_mtime.tv_nsec = cpu_to_le32(ip->i_mtime.tv_nsec); 3156 dip->di_ixpxd = jfs_ip->ixpxd; /* in-memory pxd's are little-endian */ 3157 dip->di_acl = jfs_ip->acl; /* as are dxd's */ 3158 dip->di_ea = jfs_ip->ea; 3159 dip->di_next_index = cpu_to_le32(jfs_ip->next_index); 3160 dip->di_otime.tv_sec = cpu_to_le32(jfs_ip->otime); 3161 dip->di_otime.tv_nsec = 0; 3162 dip->di_acltype = cpu_to_le32(jfs_ip->acltype); 3163 if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode)) 3164 dip->di_rdev = cpu_to_le32(jfs_ip->dev); 3165 } 3166