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 27struct 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 43static 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 53static 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 72static 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 */ 85static 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 } 129out: 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 */ 139static 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 */ 198int 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); 216repeat: 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 */ 297out: 298 kfree(rs.buffer); 299 return ret; 300eio: 301 ret = -EIO; 302 goto out; 303} 304 305#define RR_REGARD_XA 1 306#define RR_RELOC_DE 2 307 308static int 309parse_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 333repeat: 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->i_mtime.tv_sec = 430 iso_date(rr->u.TF.times[cnt++].time, 431 0); 432 inode->i_mtime.tv_nsec = 0; 433 } 434 if (rr->u.TF.flags & TF_ACCESS) { 435 inode->i_atime.tv_sec = 436 iso_date(rr->u.TF.times[cnt++].time, 437 0); 438 inode->i_atime.tv_nsec = 0; 439 } 440 if (rr->u.TF.flags & TF_ATTRIBUTES) { 441 inode_set_ctime(inode, 442 iso_date(rr->u.TF.times[cnt++].time, 0), 443 0); 444 } 445 break; 446 case SIG('S', 'L'): 447 { 448 int slen; 449 struct SL_component *slp; 450 struct SL_component *oldslp; 451 slen = rr->len - 5; 452 slp = &rr->u.SL.link; 453 inode->i_size = symlink_len; 454 while (slen > 1) { 455 rootflag = 0; 456 switch (slp->flags & ~1) { 457 case 0: 458 inode->i_size += 459 slp->len; 460 break; 461 case 2: 462 inode->i_size += 1; 463 break; 464 case 4: 465 inode->i_size += 2; 466 break; 467 case 8: 468 rootflag = 1; 469 inode->i_size += 1; 470 break; 471 default: 472 printk("Symlink component flag " 473 "not implemented\n"); 474 } 475 slen -= slp->len + 2; 476 oldslp = slp; 477 slp = (struct SL_component *) 478 (((char *)slp) + slp->len + 2); 479 480 if (slen < 2) { 481 if (((rr->u.SL. 482 flags & 1) != 0) 483 && 484 ((oldslp-> 485 flags & 1) == 0)) 486 inode->i_size += 487 1; 488 break; 489 } 490 491 /* 492 * If this component record isn't 493 * continued, then append a '/'. 494 */ 495 if (!rootflag 496 && (oldslp->flags & 1) == 0) 497 inode->i_size += 1; 498 } 499 } 500 symlink_len = inode->i_size; 501 break; 502 case SIG('R', 'E'): 503 printk(KERN_WARNING "Attempt to read inode for " 504 "relocated directory\n"); 505 goto out; 506 case SIG('C', 'L'): 507 if (flags & RR_RELOC_DE) { 508 printk(KERN_ERR 509 "ISOFS: Recursive directory relocation " 510 "is not supported\n"); 511 goto eio; 512 } 513 reloc_block = isonum_733(rr->u.CL.location); 514 if (reloc_block == ISOFS_I(inode)->i_iget5_block && 515 ISOFS_I(inode)->i_iget5_offset == 0) { 516 printk(KERN_ERR 517 "ISOFS: Directory relocation points to " 518 "itself\n"); 519 goto eio; 520 } 521 ISOFS_I(inode)->i_first_extent = reloc_block; 522 reloc = isofs_iget_reloc(inode->i_sb, reloc_block, 0); 523 if (IS_ERR(reloc)) { 524 ret = PTR_ERR(reloc); 525 goto out; 526 } 527 inode->i_mode = reloc->i_mode; 528 set_nlink(inode, reloc->i_nlink); 529 inode->i_uid = reloc->i_uid; 530 inode->i_gid = reloc->i_gid; 531 inode->i_rdev = reloc->i_rdev; 532 inode->i_size = reloc->i_size; 533 inode->i_blocks = reloc->i_blocks; 534 inode->i_atime = reloc->i_atime; 535 inode_set_ctime_to_ts(inode, inode_get_ctime(reloc)); 536 inode->i_mtime = reloc->i_mtime; 537 iput(reloc); 538 break; 539#ifdef CONFIG_ZISOFS 540 case SIG('Z', 'F'): { 541 int algo; 542 543 if (ISOFS_SB(inode->i_sb)->s_nocompress) 544 break; 545 algo = isonum_721(rr->u.ZF.algorithm); 546 if (algo == SIG('p', 'z')) { 547 int block_shift = 548 isonum_711(&rr->u.ZF.parms[1]); 549 if (block_shift > 17) { 550 printk(KERN_WARNING "isofs: " 551 "Can't handle ZF block " 552 "size of 2^%d\n", 553 block_shift); 554 } else { 555 /* 556 * Note: we don't change 557 * i_blocks here 558 */ 559 ISOFS_I(inode)->i_file_format = 560 isofs_file_compressed; 561 /* 562 * Parameters to compression 563 * algorithm (header size, 564 * block size) 565 */ 566 ISOFS_I(inode)->i_format_parm[0] = 567 isonum_711(&rr->u.ZF.parms[0]); 568 ISOFS_I(inode)->i_format_parm[1] = 569 isonum_711(&rr->u.ZF.parms[1]); 570 inode->i_size = 571 isonum_733(rr->u.ZF. 572 real_size); 573 } 574 } else { 575 printk(KERN_WARNING 576 "isofs: Unknown ZF compression " 577 "algorithm: %c%c\n", 578 rr->u.ZF.algorithm[0], 579 rr->u.ZF.algorithm[1]); 580 } 581 break; 582 } 583#endif 584 default: 585 break; 586 } 587 } 588 ret = rock_continue(&rs); 589 if (ret == 0) 590 goto repeat; 591 if (ret == 1) 592 ret = 0; 593out: 594 kfree(rs.buffer); 595 return ret; 596eio: 597 ret = -EIO; 598 goto out; 599} 600 601static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr, char *plimit) 602{ 603 int slen; 604 int rootflag; 605 struct SL_component *oldslp; 606 struct SL_component *slp; 607 slen = rr->len - 5; 608 slp = &rr->u.SL.link; 609 while (slen > 1) { 610 rootflag = 0; 611 switch (slp->flags & ~1) { 612 case 0: 613 if (slp->len > plimit - rpnt) 614 return NULL; 615 memcpy(rpnt, slp->text, slp->len); 616 rpnt += slp->len; 617 break; 618 case 2: 619 if (rpnt >= plimit) 620 return NULL; 621 *rpnt++ = '.'; 622 break; 623 case 4: 624 if (2 > plimit - rpnt) 625 return NULL; 626 *rpnt++ = '.'; 627 *rpnt++ = '.'; 628 break; 629 case 8: 630 if (rpnt >= plimit) 631 return NULL; 632 rootflag = 1; 633 *rpnt++ = '/'; 634 break; 635 default: 636 printk("Symlink component flag not implemented (%d)\n", 637 slp->flags); 638 } 639 slen -= slp->len + 2; 640 oldslp = slp; 641 slp = (struct SL_component *)((char *)slp + slp->len + 2); 642 643 if (slen < 2) { 644 /* 645 * If there is another SL record, and this component 646 * record isn't continued, then add a slash. 647 */ 648 if ((!rootflag) && (rr->u.SL.flags & 1) && 649 !(oldslp->flags & 1)) { 650 if (rpnt >= plimit) 651 return NULL; 652 *rpnt++ = '/'; 653 } 654 break; 655 } 656 657 /* 658 * If this component record isn't continued, then append a '/'. 659 */ 660 if (!rootflag && !(oldslp->flags & 1)) { 661 if (rpnt >= plimit) 662 return NULL; 663 *rpnt++ = '/'; 664 } 665 } 666 return rpnt; 667} 668 669int parse_rock_ridge_inode(struct iso_directory_record *de, struct inode *inode, 670 int relocated) 671{ 672 int flags = relocated ? RR_RELOC_DE : 0; 673 int result = parse_rock_ridge_inode_internal(de, inode, flags); 674 675 /* 676 * if rockridge flag was reset and we didn't look for attributes 677 * behind eventual XA attributes, have a look there 678 */ 679 if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1) 680 && (ISOFS_SB(inode->i_sb)->s_rock == 2)) { 681 result = parse_rock_ridge_inode_internal(de, inode, 682 flags | RR_REGARD_XA); 683 } 684 return result; 685} 686 687/* 688 * read_folio() for symlinks: reads symlink contents into the folio and either 689 * makes it uptodate and returns 0 or returns error (-EIO) 690 */ 691static int rock_ridge_symlink_read_folio(struct file *file, struct folio *folio) 692{ 693 struct page *page = &folio->page; 694 struct inode *inode = page->mapping->host; 695 struct iso_inode_info *ei = ISOFS_I(inode); 696 struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb); 697 char *link = page_address(page); 698 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode); 699 struct buffer_head *bh; 700 char *rpnt = link; 701 unsigned char *pnt; 702 struct iso_directory_record *raw_de; 703 unsigned long block, offset; 704 int sig; 705 struct rock_ridge *rr; 706 struct rock_state rs; 707 int ret; 708 709 if (!sbi->s_rock) 710 goto error; 711 712 init_rock_state(&rs, inode); 713 block = ei->i_iget5_block; 714 bh = sb_bread(inode->i_sb, block); 715 if (!bh) 716 goto out_noread; 717 718 offset = ei->i_iget5_offset; 719 pnt = (unsigned char *)bh->b_data + offset; 720 721 raw_de = (struct iso_directory_record *)pnt; 722 723 /* 724 * If we go past the end of the buffer, there is some sort of error. 725 */ 726 if (offset + *pnt > bufsize) 727 goto out_bad_span; 728 729 /* 730 * Now test for possible Rock Ridge extensions which will override 731 * some of these numbers in the inode structure. 732 */ 733 734 setup_rock_ridge(raw_de, inode, &rs); 735 736repeat: 737 while (rs.len > 2) { /* There may be one byte for padding somewhere */ 738 rr = (struct rock_ridge *)rs.chr; 739 if (rr->len < 3) 740 goto out; /* Something got screwed up here */ 741 sig = isonum_721(rs.chr); 742 if (rock_check_overflow(&rs, sig)) 743 goto out; 744 rs.chr += rr->len; 745 rs.len -= rr->len; 746 if (rs.len < 0) 747 goto out; /* corrupted isofs */ 748 749 switch (sig) { 750 case SIG('R', 'R'): 751 if ((rr->u.RR.flags[0] & RR_SL) == 0) 752 goto out; 753 break; 754 case SIG('S', 'P'): 755 if (check_sp(rr, inode)) 756 goto out; 757 break; 758 case SIG('S', 'L'): 759 rpnt = get_symlink_chunk(rpnt, rr, 760 link + (PAGE_SIZE - 1)); 761 if (rpnt == NULL) 762 goto out; 763 break; 764 case SIG('C', 'E'): 765 /* This tells is if there is a continuation record */ 766 rs.cont_extent = isonum_733(rr->u.CE.extent); 767 rs.cont_offset = isonum_733(rr->u.CE.offset); 768 rs.cont_size = isonum_733(rr->u.CE.size); 769 break; 770 default: 771 break; 772 } 773 } 774 ret = rock_continue(&rs); 775 if (ret == 0) 776 goto repeat; 777 if (ret < 0) 778 goto fail; 779 780 if (rpnt == link) 781 goto fail; 782 brelse(bh); 783 *rpnt = '\0'; 784 SetPageUptodate(page); 785 unlock_page(page); 786 return 0; 787 788 /* error exit from macro */ 789out: 790 kfree(rs.buffer); 791 goto fail; 792out_noread: 793 printk("unable to read i-node block"); 794 goto fail; 795out_bad_span: 796 printk("symlink spans iso9660 blocks\n"); 797fail: 798 brelse(bh); 799error: 800 SetPageError(page); 801 unlock_page(page); 802 return -EIO; 803} 804 805const struct address_space_operations isofs_symlink_aops = { 806 .read_folio = rock_ridge_symlink_read_folio 807}; 808