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