rock.c 18 KB

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