1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/isofs/rock.c 4 * 5 * (C) 1992, 1993 Eric Youngdale 6 * 7 * Rock Ridge Extensions to iso9660 8 */ 9 10 #include <linux/slab.h> 11 #include <linux/pagemap.h> 12 13 #include "isofs.h" 14 #include "rock.h" 15 16 /* 17 * These functions are designed to read the system areas of a directory record 18 * and extract relevant information. There are different functions provided 19 * depending upon what information we need at the time. One function fills 20 * out an inode structure, a second one extracts a filename, a third one 21 * returns a symbolic link name, and a fourth one returns the extent number 22 * for the file. 23 */ 24 25 #define SIG(A,B) ((A) | ((B) << 8)) /* isonum_721() */ 26 27 struct rock_state { 28 void *buffer; 29 unsigned char *chr; 30 int len; 31 int cont_size; 32 int cont_extent; 33 int cont_offset; 34 int cont_loops; 35 struct inode *inode; 36 }; 37 38 /* 39 * This is a way of ensuring that we have something in the system 40 * use fields that is compatible with Rock Ridge. Return zero on success. 41 */ 42 43 static int check_sp(struct rock_ridge *rr, struct inode *inode) 44 { 45 if (rr->u.SP.magic[0] != 0xbe) 46 return -1; 47 if (rr->u.SP.magic[1] != 0xef) 48 return -1; 49 ISOFS_SB(inode->i_sb)->s_rock_offset = rr->u.SP.skip; 50 return 0; 51 } 52 53 static void setup_rock_ridge(struct iso_directory_record *de, 54 struct inode *inode, struct rock_state *rs) 55 { 56 rs->len = sizeof(struct iso_directory_record) + de->name_len[0]; 57 if (rs->len & 1) 58 (rs->len)++; 59 rs->chr = (unsigned char *)de + rs->len; 60 rs->len = *((unsigned char *)de) - rs->len; 61 if (rs->len < 0) 62 rs->len = 0; 63 64 if (ISOFS_SB(inode->i_sb)->s_rock_offset != -1) { 65 rs->len -= ISOFS_SB(inode->i_sb)->s_rock_offset; 66 rs->chr += ISOFS_SB(inode->i_sb)->s_rock_offset; 67 if (rs->len < 0) 68 rs->len = 0; 69 } 70 } 71 72 static void init_rock_state(struct rock_state *rs, struct inode *inode) 73 { 74 memset(rs, 0, sizeof(*rs)); 75 rs->inode = inode; 76 } 77 78 /* Maximum number of Rock Ridge continuation entries */ 79 #define RR_MAX_CE_ENTRIES 32 80 81 /* 82 * Returns 0 if the caller should continue scanning, 1 if the scan must end 83 * and -ve on error. 84 */ 85 static int rock_continue(struct rock_state *rs) 86 { 87 int ret = 1; 88 int blocksize = 1 << rs->inode->i_blkbits; 89 const int min_de_size = offsetof(struct rock_ridge, u); 90 91 kfree(rs->buffer); 92 rs->buffer = NULL; 93 94 if ((unsigned)rs->cont_offset > blocksize - min_de_size || 95 (unsigned)rs->cont_size > blocksize || 96 (unsigned)(rs->cont_offset + rs->cont_size) > blocksize) { 97 printk(KERN_NOTICE "rock: corrupted directory entry. " 98 "extent=%d, offset=%d, size=%d\n", 99 rs->cont_extent, rs->cont_offset, rs->cont_size); 100 ret = -EIO; 101 goto out; 102 } 103 104 if (rs->cont_extent) { 105 struct buffer_head *bh; 106 107 rs->buffer = kmalloc(rs->cont_size, GFP_KERNEL); 108 if (!rs->buffer) { 109 ret = -ENOMEM; 110 goto out; 111 } 112 ret = -EIO; 113 if (++rs->cont_loops >= RR_MAX_CE_ENTRIES) 114 goto out; 115 bh = sb_bread(rs->inode->i_sb, rs->cont_extent); 116 if (bh) { 117 memcpy(rs->buffer, bh->b_data + rs->cont_offset, 118 rs->cont_size); 119 put_bh(bh); 120 rs->chr = rs->buffer; 121 rs->len = rs->cont_size; 122 rs->cont_extent = 0; 123 rs->cont_size = 0; 124 rs->cont_offset = 0; 125 return 0; 126 } 127 printk("Unable to read rock-ridge attributes\n"); 128 } 129 out: 130 kfree(rs->buffer); 131 rs->buffer = NULL; 132 return ret; 133 } 134 135 /* 136 * We think there's a record of type `sig' at rs->chr. Parse the signature 137 * and make sure that there's really room for a record of that type. 138 */ 139 static int rock_check_overflow(struct rock_state *rs, int sig) 140 { 141 int len; 142 143 switch (sig) { 144 case SIG('S', 'P'): 145 len = sizeof(struct SU_SP_s); 146 break; 147 case SIG('C', 'E'): 148 len = sizeof(struct SU_CE_s); 149 break; 150 case SIG('E', 'R'): 151 len = sizeof(struct SU_ER_s); 152 break; 153 case SIG('R', 'R'): 154 len = sizeof(struct RR_RR_s); 155 break; 156 case SIG('P', 'X'): 157 len = sizeof(struct RR_PX_s); 158 break; 159 case SIG('P', 'N'): 160 len = sizeof(struct RR_PN_s); 161 break; 162 case SIG('S', 'L'): 163 len = sizeof(struct RR_SL_s); 164 break; 165 case SIG('N', 'M'): 166 len = sizeof(struct RR_NM_s); 167 break; 168 case SIG('C', 'L'): 169 len = sizeof(struct RR_CL_s); 170 break; 171 case SIG('P', 'L'): 172 len = sizeof(struct RR_PL_s); 173 break; 174 case SIG('T', 'F'): 175 len = sizeof(struct RR_TF_s); 176 break; 177 case SIG('Z', 'F'): 178 len = sizeof(struct RR_ZF_s); 179 break; 180 default: 181 len = 0; 182 break; 183 } 184 len += offsetof(struct rock_ridge, u); 185 if (len > rs->len) { 186 printk(KERN_NOTICE "rock: directory entry would overflow " 187 "storage\n"); 188 printk(KERN_NOTICE "rock: sig=0x%02x, size=%d, remaining=%d\n", 189 sig, len, rs->len); 190 return -EIO; 191 } 192 return 0; 193 } 194 195 /* 196 * return length of name field; 0: not found, -1: to be ignored 197 */ 198 int get_rock_ridge_filename(struct iso_directory_record *de, 199 char *retname, struct inode *inode) 200 { 201 struct rock_state rs; 202 struct rock_ridge *rr; 203 int sig; 204 int retnamlen = 0; 205 int truncate = 0; 206 int ret = 0; 207 char *p; 208 int len; 209 210 if (!ISOFS_SB(inode->i_sb)->s_rock) 211 return 0; 212 *retname = 0; 213 214 init_rock_state(&rs, inode); 215 setup_rock_ridge(de, inode, &rs); 216 repeat: 217 218 while (rs.len > 2) { /* There may be one byte for padding somewhere */ 219 rr = (struct rock_ridge *)rs.chr; 220 /* 221 * Ignore rock ridge info if rr->len is out of range, but 222 * don't return -EIO because that would make the file 223 * invisible. 224 */ 225 if (rr->len < 3) 226 goto out; /* Something got screwed up here */ 227 sig = isonum_721(rs.chr); 228 if (rock_check_overflow(&rs, sig)) 229 goto eio; 230 rs.chr += rr->len; 231 rs.len -= rr->len; 232 /* 233 * As above, just ignore the rock ridge info if rr->len 234 * is bogus. 235 */ 236 if (rs.len < 0) 237 goto out; /* Something got screwed up here */ 238 239 switch (sig) { 240 case SIG('R', 'R'): 241 if ((rr->u.RR.flags[0] & RR_NM) == 0) 242 goto out; 243 break; 244 case SIG('S', 'P'): 245 if (check_sp(rr, inode)) 246 goto out; 247 break; 248 case SIG('C', 'E'): 249 rs.cont_extent = isonum_733(rr->u.CE.extent); 250 rs.cont_offset = isonum_733(rr->u.CE.offset); 251 rs.cont_size = isonum_733(rr->u.CE.size); 252 break; 253 case SIG('N', 'M'): 254 if (truncate) 255 break; 256 if (rr->len < 5) 257 break; 258 /* 259 * If the flags are 2 or 4, this indicates '.' or '..'. 260 * We don't want to do anything with this, because it 261 * screws up the code that calls us. We don't really 262 * care anyways, since we can just use the non-RR 263 * name. 264 */ 265 if (rr->u.NM.flags & 6) 266 break; 267 268 if (rr->u.NM.flags & ~1) { 269 printk("Unsupported NM flag settings (%d)\n", 270 rr->u.NM.flags); 271 break; 272 } 273 len = rr->len - 5; 274 if (retnamlen + len >= 254) { 275 truncate = 1; 276 break; 277 } 278 p = memchr(rr->u.NM.name, '\0', len); 279 if (unlikely(p)) 280 len = p - rr->u.NM.name; 281 memcpy(retname + retnamlen, rr->u.NM.name, len); 282 retnamlen += len; 283 retname[retnamlen] = '\0'; 284 break; 285 case SIG('R', 'E'): 286 kfree(rs.buffer); 287 return -1; 288 default: 289 break; 290 } 291 } 292 ret = rock_continue(&rs); 293 if (ret == 0) 294 goto repeat; 295 if (ret == 1) 296 return retnamlen; /* If 0, this file did not have a NM field */ 297 out: 298 kfree(rs.buffer); 299 return ret; 300 eio: 301 ret = -EIO; 302 goto out; 303 } 304 305 #define RR_REGARD_XA 1 306 #define RR_RELOC_DE 2 307 308 static int 309 parse_rock_ridge_inode_internal(struct iso_directory_record *de, 310 struct inode *inode, int flags) 311 { 312 int symlink_len = 0; 313 int cnt, sig; 314 unsigned int reloc_block; 315 struct inode *reloc; 316 struct rock_ridge *rr; 317 int rootflag; 318 struct rock_state rs; 319 int ret = 0; 320 321 if (!ISOFS_SB(inode->i_sb)->s_rock) 322 return 0; 323 324 init_rock_state(&rs, inode); 325 setup_rock_ridge(de, inode, &rs); 326 if (flags & RR_REGARD_XA) { 327 rs.chr += 14; 328 rs.len -= 14; 329 if (rs.len < 0) 330 rs.len = 0; 331 } 332 333 repeat: 334 while (rs.len > 2) { /* There may be one byte for padding somewhere */ 335 rr = (struct rock_ridge *)rs.chr; 336 /* 337 * Ignore rock ridge info if rr->len is out of range, but 338 * don't return -EIO because that would make the file 339 * invisible. 340 */ 341 if (rr->len < 3) 342 goto out; /* Something got screwed up here */ 343 sig = isonum_721(rs.chr); 344 if (rock_check_overflow(&rs, sig)) 345 goto eio; 346 rs.chr += rr->len; 347 rs.len -= rr->len; 348 /* 349 * As above, just ignore the rock ridge info if rr->len 350 * is bogus. 351 */ 352 if (rs.len < 0) 353 goto out; /* Something got screwed up here */ 354 355 switch (sig) { 356 #ifndef CONFIG_ZISOFS /* No flag for SF or ZF */ 357 case SIG('R', 'R'): 358 if ((rr->u.RR.flags[0] & 359 (RR_PX | RR_TF | RR_SL | RR_CL)) == 0) 360 goto out; 361 break; 362 #endif 363 case SIG('S', 'P'): 364 if (check_sp(rr, inode)) 365 goto out; 366 break; 367 case SIG('C', 'E'): 368 rs.cont_extent = isonum_733(rr->u.CE.extent); 369 rs.cont_offset = isonum_733(rr->u.CE.offset); 370 rs.cont_size = isonum_733(rr->u.CE.size); 371 break; 372 case SIG('E', 'R'): 373 /* Invalid length of ER tag id? */ 374 if (rr->u.ER.len_id + offsetof(struct rock_ridge, u.ER.data) > rr->len) 375 goto out; 376 ISOFS_SB(inode->i_sb)->s_rock = 1; 377 printk(KERN_DEBUG "ISO 9660 Extensions: "); 378 { 379 int p; 380 for (p = 0; p < rr->u.ER.len_id; p++) 381 printk(KERN_CONT "%c", rr->u.ER.data[p]); 382 } 383 printk(KERN_CONT "\n"); 384 break; 385 case SIG('P', 'X'): 386 inode->i_mode = isonum_733(rr->u.PX.mode); 387 set_nlink(inode, isonum_733(rr->u.PX.n_links)); 388 i_uid_write(inode, isonum_733(rr->u.PX.uid)); 389 i_gid_write(inode, isonum_733(rr->u.PX.gid)); 390 break; 391 case SIG('P', 'N'): 392 { 393 int high, low; 394 high = isonum_733(rr->u.PN.dev_high); 395 low = isonum_733(rr->u.PN.dev_low); 396 /* 397 * The Rock Ridge standard specifies that if 398 * sizeof(dev_t) <= 4, then the high field is 399 * unused, and the device number is completely 400 * stored in the low field. Some writers may 401 * ignore this subtlety, 402 * and as a result we test to see if the entire 403 * device number is 404 * stored in the low field, and use that. 405 */ 406 if ((low & ~0xff) && high == 0) { 407 inode->i_rdev = 408 MKDEV(low >> 8, low & 0xff); 409 } else { 410 inode->i_rdev = 411 MKDEV(high, low); 412 } 413 } 414 break; 415 case SIG('T', 'F'): 416 /* 417 * Some RRIP writers incorrectly place ctime in the 418 * TF_CREATE field. Try to handle this correctly for 419 * either case. 420 */ 421 /* Rock ridge never appears on a High Sierra disk */ 422 cnt = 0; 423 if (rr->u.TF.flags & TF_CREATE) { 424 inode_set_ctime(inode, 425 iso_date(rr->u.TF.times[cnt++].time, 0), 426 0); 427 } 428 if (rr->u.TF.flags & TF_MODIFY) { 429 inode_set_mtime(inode, 430 iso_date(rr->u.TF.times[cnt++].time, 0), 431 0); 432 } 433 if (rr->u.TF.flags & TF_ACCESS) { 434 inode_set_atime(inode, 435 iso_date(rr->u.TF.times[cnt++].time, 0), 436 0); 437 } 438 if (rr->u.TF.flags & TF_ATTRIBUTES) { 439 inode_set_ctime(inode, 440 iso_date(rr->u.TF.times[cnt++].time, 0), 441 0); 442 } 443 break; 444 case SIG('S', 'L'): 445 { 446 int slen; 447 struct SL_component *slp; 448 struct SL_component *oldslp; 449 slen = rr->len - 5; 450 slp = &rr->u.SL.link; 451 inode->i_size = symlink_len; 452 while (slen > 1) { 453 rootflag = 0; 454 switch (slp->flags & ~1) { 455 case 0: 456 inode->i_size += 457 slp->len; 458 break; 459 case 2: 460 inode->i_size += 1; 461 break; 462 case 4: 463 inode->i_size += 2; 464 break; 465 case 8: 466 rootflag = 1; 467 inode->i_size += 1; 468 break; 469 default: 470 printk("Symlink component flag " 471 "not implemented\n"); 472 } 473 slen -= slp->len + 2; 474 oldslp = slp; 475 slp = (struct SL_component *) 476 (((char *)slp) + slp->len + 2); 477 478 if (slen < 2) { 479 if (((rr->u.SL. 480 flags & 1) != 0) 481 && 482 ((oldslp-> 483 flags & 1) == 0)) 484 inode->i_size += 485 1; 486 break; 487 } 488 489 /* 490 * If this component record isn't 491 * continued, then append a '/'. 492 */ 493 if (!rootflag 494 && (oldslp->flags & 1) == 0) 495 inode->i_size += 1; 496 } 497 } 498 symlink_len = inode->i_size; 499 break; 500 case SIG('R', 'E'): 501 printk(KERN_WARNING "Attempt to read inode for " 502 "relocated directory\n"); 503 goto out; 504 case SIG('C', 'L'): 505 if (flags & RR_RELOC_DE) { 506 printk(KERN_ERR 507 "ISOFS: Recursive directory relocation " 508 "is not supported\n"); 509 goto eio; 510 } 511 reloc_block = isonum_733(rr->u.CL.location); 512 if (reloc_block == ISOFS_I(inode)->i_iget5_block && 513 ISOFS_I(inode)->i_iget5_offset == 0) { 514 printk(KERN_ERR 515 "ISOFS: Directory relocation points to " 516 "itself\n"); 517 goto eio; 518 } 519 ISOFS_I(inode)->i_first_extent = reloc_block; 520 reloc = isofs_iget_reloc(inode->i_sb, reloc_block, 0); 521 if (IS_ERR(reloc)) { 522 ret = PTR_ERR(reloc); 523 goto out; 524 } 525 inode->i_mode = reloc->i_mode; 526 set_nlink(inode, reloc->i_nlink); 527 inode->i_uid = reloc->i_uid; 528 inode->i_gid = reloc->i_gid; 529 inode->i_rdev = reloc->i_rdev; 530 inode->i_size = reloc->i_size; 531 inode->i_blocks = reloc->i_blocks; 532 inode_set_atime_to_ts(inode, inode_get_atime(reloc)); 533 inode_set_ctime_to_ts(inode, inode_get_ctime(reloc)); 534 inode_set_mtime_to_ts(inode, inode_get_mtime(reloc)); 535 iput(reloc); 536 break; 537 #ifdef CONFIG_ZISOFS 538 case SIG('Z', 'F'): { 539 int algo; 540 541 if (ISOFS_SB(inode->i_sb)->s_nocompress) 542 break; 543 algo = isonum_721(rr->u.ZF.algorithm); 544 if (algo == SIG('p', 'z')) { 545 int block_shift = 546 isonum_711(&rr->u.ZF.parms[1]); 547 if (block_shift > 17) { 548 printk(KERN_WARNING "isofs: " 549 "Can't handle ZF block " 550 "size of 2^%d\n", 551 block_shift); 552 } else { 553 /* 554 * Note: we don't change 555 * i_blocks here 556 */ 557 ISOFS_I(inode)->i_file_format = 558 isofs_file_compressed; 559 /* 560 * Parameters to compression 561 * algorithm (header size, 562 * block size) 563 */ 564 ISOFS_I(inode)->i_format_parm[0] = 565 isonum_711(&rr->u.ZF.parms[0]); 566 ISOFS_I(inode)->i_format_parm[1] = 567 isonum_711(&rr->u.ZF.parms[1]); 568 inode->i_size = 569 isonum_733(rr->u.ZF. 570 real_size); 571 } 572 } else { 573 printk(KERN_WARNING 574 "isofs: Unknown ZF compression " 575 "algorithm: %c%c\n", 576 rr->u.ZF.algorithm[0], 577 rr->u.ZF.algorithm[1]); 578 } 579 break; 580 } 581 #endif 582 default: 583 break; 584 } 585 } 586 ret = rock_continue(&rs); 587 if (ret == 0) 588 goto repeat; 589 if (ret == 1) 590 ret = 0; 591 out: 592 kfree(rs.buffer); 593 return ret; 594 eio: 595 ret = -EIO; 596 goto out; 597 } 598 599 static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr, char *plimit) 600 { 601 int slen; 602 int rootflag; 603 struct SL_component *oldslp; 604 struct SL_component *slp; 605 slen = rr->len - 5; 606 slp = &rr->u.SL.link; 607 while (slen > 1) { 608 rootflag = 0; 609 switch (slp->flags & ~1) { 610 case 0: 611 if (slp->len > plimit - rpnt) 612 return NULL; 613 memcpy(rpnt, slp->text, slp->len); 614 rpnt += slp->len; 615 break; 616 case 2: 617 if (rpnt >= plimit) 618 return NULL; 619 *rpnt++ = '.'; 620 break; 621 case 4: 622 if (2 > plimit - rpnt) 623 return NULL; 624 *rpnt++ = '.'; 625 *rpnt++ = '.'; 626 break; 627 case 8: 628 if (rpnt >= plimit) 629 return NULL; 630 rootflag = 1; 631 *rpnt++ = '/'; 632 break; 633 default: 634 printk("Symlink component flag not implemented (%d)\n", 635 slp->flags); 636 } 637 slen -= slp->len + 2; 638 oldslp = slp; 639 slp = (struct SL_component *)((char *)slp + slp->len + 2); 640 641 if (slen < 2) { 642 /* 643 * If there is another SL record, and this component 644 * record isn't continued, then add a slash. 645 */ 646 if ((!rootflag) && (rr->u.SL.flags & 1) && 647 !(oldslp->flags & 1)) { 648 if (rpnt >= plimit) 649 return NULL; 650 *rpnt++ = '/'; 651 } 652 break; 653 } 654 655 /* 656 * If this component record isn't continued, then append a '/'. 657 */ 658 if (!rootflag && !(oldslp->flags & 1)) { 659 if (rpnt >= plimit) 660 return NULL; 661 *rpnt++ = '/'; 662 } 663 } 664 return rpnt; 665 } 666 667 int parse_rock_ridge_inode(struct iso_directory_record *de, struct inode *inode, 668 int relocated) 669 { 670 int flags = relocated ? RR_RELOC_DE : 0; 671 int result = parse_rock_ridge_inode_internal(de, inode, flags); 672 673 /* 674 * if rockridge flag was reset and we didn't look for attributes 675 * behind eventual XA attributes, have a look there 676 */ 677 if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1) 678 && (ISOFS_SB(inode->i_sb)->s_rock == 2)) { 679 result = parse_rock_ridge_inode_internal(de, inode, 680 flags | RR_REGARD_XA); 681 } 682 return result; 683 } 684 685 /* 686 * read_folio() for symlinks: reads symlink contents into the folio and either 687 * makes it uptodate and returns 0 or returns error (-EIO) 688 */ 689 static int rock_ridge_symlink_read_folio(struct file *file, struct folio *folio) 690 { 691 struct page *page = &folio->page; 692 struct inode *inode = page->mapping->host; 693 struct iso_inode_info *ei = ISOFS_I(inode); 694 struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb); 695 char *link = page_address(page); 696 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode); 697 struct buffer_head *bh; 698 char *rpnt = link; 699 unsigned char *pnt; 700 struct iso_directory_record *raw_de; 701 unsigned long block, offset; 702 int sig; 703 struct rock_ridge *rr; 704 struct rock_state rs; 705 int ret; 706 707 if (!sbi->s_rock) 708 goto error; 709 710 init_rock_state(&rs, inode); 711 block = ei->i_iget5_block; 712 bh = sb_bread(inode->i_sb, block); 713 if (!bh) 714 goto out_noread; 715 716 offset = ei->i_iget5_offset; 717 pnt = (unsigned char *)bh->b_data + offset; 718 719 raw_de = (struct iso_directory_record *)pnt; 720 721 /* 722 * If we go past the end of the buffer, there is some sort of error. 723 */ 724 if (offset + *pnt > bufsize) 725 goto out_bad_span; 726 727 /* 728 * Now test for possible Rock Ridge extensions which will override 729 * some of these numbers in the inode structure. 730 */ 731 732 setup_rock_ridge(raw_de, inode, &rs); 733 734 repeat: 735 while (rs.len > 2) { /* There may be one byte for padding somewhere */ 736 rr = (struct rock_ridge *)rs.chr; 737 if (rr->len < 3) 738 goto out; /* Something got screwed up here */ 739 sig = isonum_721(rs.chr); 740 if (rock_check_overflow(&rs, sig)) 741 goto out; 742 rs.chr += rr->len; 743 rs.len -= rr->len; 744 if (rs.len < 0) 745 goto out; /* corrupted isofs */ 746 747 switch (sig) { 748 case SIG('R', 'R'): 749 if ((rr->u.RR.flags[0] & RR_SL) == 0) 750 goto out; 751 break; 752 case SIG('S', 'P'): 753 if (check_sp(rr, inode)) 754 goto out; 755 break; 756 case SIG('S', 'L'): 757 rpnt = get_symlink_chunk(rpnt, rr, 758 link + (PAGE_SIZE - 1)); 759 if (rpnt == NULL) 760 goto out; 761 break; 762 case SIG('C', 'E'): 763 /* This tells is if there is a continuation record */ 764 rs.cont_extent = isonum_733(rr->u.CE.extent); 765 rs.cont_offset = isonum_733(rr->u.CE.offset); 766 rs.cont_size = isonum_733(rr->u.CE.size); 767 break; 768 default: 769 break; 770 } 771 } 772 ret = rock_continue(&rs); 773 if (ret == 0) 774 goto repeat; 775 if (ret < 0) 776 goto fail; 777 778 if (rpnt == link) 779 goto fail; 780 brelse(bh); 781 *rpnt = '\0'; 782 SetPageUptodate(page); 783 unlock_page(page); 784 return 0; 785 786 /* error exit from macro */ 787 out: 788 kfree(rs.buffer); 789 goto fail; 790 out_noread: 791 printk("unable to read i-node block"); 792 goto fail; 793 out_bad_span: 794 printk("symlink spans iso9660 blocks\n"); 795 fail: 796 brelse(bh); 797 error: 798 SetPageError(page); 799 unlock_page(page); 800 return -EIO; 801 } 802 803 const struct address_space_operations isofs_symlink_aops = { 804 .read_folio = rock_ridge_symlink_read_folio 805 }; 806