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