2 * linux/fs/isofs/rock.c
4 * (C) 1992, 1993 Eric Youngdale
6 * Rock Ridge Extensions to iso9660
9 #include <linux/slab.h>
10 #include <linux/pagemap.h>
16 * These functions are designed to read the system areas of a directory record
17 * and extract relevant information. There are different functions provided
18 * depending upon what information we need at the time. One function fills
19 * out an inode structure, a second one extracts a filename, a third one
20 * returns a symbolic link name, and a fourth one returns the extent number
24 #define SIG(A,B) ((A) | ((B) << 8)) /* isonum_721() */
38 * This is a way of ensuring that we have something in the system
39 * use fields that is compatible with Rock Ridge. Return zero on success.
42 static int check_sp(struct rock_ridge *rr, struct inode *inode)
44 if (rr->u.SP.magic[0] != 0xbe)
46 if (rr->u.SP.magic[1] != 0xef)
48 ISOFS_SB(inode->i_sb)->s_rock_offset = rr->u.SP.skip;
52 static void setup_rock_ridge(struct iso_directory_record *de,
53 struct inode *inode, struct rock_state *rs)
55 rs->len = sizeof(struct iso_directory_record) + de->name_len[0];
58 rs->chr = (unsigned char *)de + rs->len;
59 rs->len = *((unsigned char *)de) - rs->len;
63 if (ISOFS_SB(inode->i_sb)->s_rock_offset != -1) {
64 rs->len -= ISOFS_SB(inode->i_sb)->s_rock_offset;
65 rs->chr += ISOFS_SB(inode->i_sb)->s_rock_offset;
71 static void init_rock_state(struct rock_state *rs, struct inode *inode)
73 memset(rs, 0, sizeof(*rs));
77 /* Maximum number of Rock Ridge continuation entries */
78 #define RR_MAX_CE_ENTRIES 32
81 * Returns 0 if the caller should continue scanning, 1 if the scan must end
84 static int rock_continue(struct rock_state *rs)
87 int blocksize = 1 << rs->inode->i_blkbits;
88 const int min_de_size = offsetof(struct rock_ridge, u);
93 if ((unsigned)rs->cont_offset > blocksize - min_de_size ||
94 (unsigned)rs->cont_size > blocksize ||
95 (unsigned)(rs->cont_offset + rs->cont_size) > blocksize) {
96 printk(KERN_NOTICE "rock: corrupted directory entry. "
97 "extent=%d, offset=%d, size=%d\n",
98 rs->cont_extent, rs->cont_offset, rs->cont_size);
103 if (rs->cont_extent) {
104 struct buffer_head *bh;
106 rs->buffer = kmalloc(rs->cont_size, GFP_KERNEL);
112 if (++rs->cont_loops >= RR_MAX_CE_ENTRIES)
114 bh = sb_bread(rs->inode->i_sb, rs->cont_extent);
116 memcpy(rs->buffer, bh->b_data + rs->cont_offset,
119 rs->chr = rs->buffer;
120 rs->len = rs->cont_size;
126 printk("Unable to read rock-ridge attributes\n");
135 * We think there's a record of type `sig' at rs->chr. Parse the signature
136 * and make sure that there's really room for a record of that type.
138 static int rock_check_overflow(struct rock_state *rs, int sig)
144 len = sizeof(struct SU_SP_s);
147 len = sizeof(struct SU_CE_s);
150 len = sizeof(struct SU_ER_s);
153 len = sizeof(struct RR_RR_s);
156 len = sizeof(struct RR_PX_s);
159 len = sizeof(struct RR_PN_s);
162 len = sizeof(struct RR_SL_s);
165 len = sizeof(struct RR_NM_s);
168 len = sizeof(struct RR_CL_s);
171 len = sizeof(struct RR_PL_s);
174 len = sizeof(struct RR_TF_s);
177 len = sizeof(struct RR_ZF_s);
183 len += offsetof(struct rock_ridge, u);
185 printk(KERN_NOTICE "rock: directory entry would overflow "
187 printk(KERN_NOTICE "rock: sig=0x%02x, size=%d, remaining=%d\n",
195 * return length of name field; 0: not found, -1: to be ignored
197 int get_rock_ridge_filename(struct iso_directory_record *de,
198 char *retname, struct inode *inode)
200 struct rock_state rs;
201 struct rock_ridge *rr;
207 if (!ISOFS_SB(inode->i_sb)->s_rock)
211 init_rock_state(&rs, inode);
212 setup_rock_ridge(de, inode, &rs);
215 while (rs.len > 2) { /* There may be one byte for padding somewhere */
216 rr = (struct rock_ridge *)rs.chr;
218 * Ignore rock ridge info if rr->len is out of range, but
219 * don't return -EIO because that would make the file
223 goto out; /* Something got screwed up here */
224 sig = isonum_721(rs.chr);
225 if (rock_check_overflow(&rs, sig))
230 * As above, just ignore the rock ridge info if rr->len
234 goto out; /* Something got screwed up here */
238 if ((rr->u.RR.flags[0] & RR_NM) == 0)
242 if (check_sp(rr, inode))
246 rs.cont_extent = isonum_733(rr->u.CE.extent);
247 rs.cont_offset = isonum_733(rr->u.CE.offset);
248 rs.cont_size = isonum_733(rr->u.CE.size);
256 * If the flags are 2 or 4, this indicates '.' or '..'.
257 * We don't want to do anything with this, because it
258 * screws up the code that calls us. We don't really
259 * care anyways, since we can just use the non-RR
262 if (rr->u.NM.flags & 6)
265 if (rr->u.NM.flags & ~1) {
266 printk("Unsupported NM flag settings (%d)\n",
270 if ((strlen(retname) + rr->len - 5) >= 254) {
274 strncat(retname, rr->u.NM.name, rr->len - 5);
275 retnamlen += rr->len - 5;
284 ret = rock_continue(&rs);
288 return retnamlen; /* If 0, this file did not have a NM field */
297 #define RR_REGARD_XA 1
298 #define RR_RELOC_DE 2
301 parse_rock_ridge_inode_internal(struct iso_directory_record *de,
302 struct inode *inode, int flags)
306 unsigned int reloc_block;
308 struct rock_ridge *rr;
310 struct rock_state rs;
313 if (!ISOFS_SB(inode->i_sb)->s_rock)
316 init_rock_state(&rs, inode);
317 setup_rock_ridge(de, inode, &rs);
318 if (flags & RR_REGARD_XA) {
326 while (rs.len > 2) { /* There may be one byte for padding somewhere */
327 rr = (struct rock_ridge *)rs.chr;
329 * Ignore rock ridge info if rr->len is out of range, but
330 * don't return -EIO because that would make the file
334 goto out; /* Something got screwed up here */
335 sig = isonum_721(rs.chr);
336 if (rock_check_overflow(&rs, sig))
341 * As above, just ignore the rock ridge info if rr->len
345 goto out; /* Something got screwed up here */
348 #ifndef CONFIG_ZISOFS /* No flag for SF or ZF */
350 if ((rr->u.RR.flags[0] &
351 (RR_PX | RR_TF | RR_SL | RR_CL)) == 0)
356 if (check_sp(rr, inode))
360 rs.cont_extent = isonum_733(rr->u.CE.extent);
361 rs.cont_offset = isonum_733(rr->u.CE.offset);
362 rs.cont_size = isonum_733(rr->u.CE.size);
365 ISOFS_SB(inode->i_sb)->s_rock = 1;
366 printk(KERN_DEBUG "ISO 9660 Extensions: ");
369 for (p = 0; p < rr->u.ER.len_id; p++)
370 printk("%c", rr->u.ER.data[p]);
375 inode->i_mode = isonum_733(rr->u.PX.mode);
376 set_nlink(inode, isonum_733(rr->u.PX.n_links));
377 i_uid_write(inode, isonum_733(rr->u.PX.uid));
378 i_gid_write(inode, isonum_733(rr->u.PX.gid));
383 high = isonum_733(rr->u.PN.dev_high);
384 low = isonum_733(rr->u.PN.dev_low);
386 * The Rock Ridge standard specifies that if
387 * sizeof(dev_t) <= 4, then the high field is
388 * unused, and the device number is completely
389 * stored in the low field. Some writers may
390 * ignore this subtlety,
391 * and as a result we test to see if the entire
393 * stored in the low field, and use that.
395 if ((low & ~0xff) && high == 0) {
397 MKDEV(low >> 8, low & 0xff);
406 * Some RRIP writers incorrectly place ctime in the
407 * TF_CREATE field. Try to handle this correctly for
410 /* Rock ridge never appears on a High Sierra disk */
412 if (rr->u.TF.flags & TF_CREATE) {
413 inode->i_ctime.tv_sec =
414 iso_date(rr->u.TF.times[cnt++].time,
416 inode->i_ctime.tv_nsec = 0;
418 if (rr->u.TF.flags & TF_MODIFY) {
419 inode->i_mtime.tv_sec =
420 iso_date(rr->u.TF.times[cnt++].time,
422 inode->i_mtime.tv_nsec = 0;
424 if (rr->u.TF.flags & TF_ACCESS) {
425 inode->i_atime.tv_sec =
426 iso_date(rr->u.TF.times[cnt++].time,
428 inode->i_atime.tv_nsec = 0;
430 if (rr->u.TF.flags & TF_ATTRIBUTES) {
431 inode->i_ctime.tv_sec =
432 iso_date(rr->u.TF.times[cnt++].time,
434 inode->i_ctime.tv_nsec = 0;
440 struct SL_component *slp;
441 struct SL_component *oldslp;
443 slp = &rr->u.SL.link;
444 inode->i_size = symlink_len;
447 switch (slp->flags & ~1) {
463 printk("Symlink component flag "
464 "not implemented\n");
466 slen -= slp->len + 2;
468 slp = (struct SL_component *)
469 (((char *)slp) + slp->len + 2);
483 * If this component record isn't
484 * continued, then append a '/'.
487 && (oldslp->flags & 1) == 0)
491 symlink_len = inode->i_size;
494 printk(KERN_WARNING "Attempt to read inode for "
495 "relocated directory\n");
498 if (flags & RR_RELOC_DE) {
500 "ISOFS: Recursive directory relocation "
501 "is not supported\n");
504 reloc_block = isonum_733(rr->u.CL.location);
505 if (reloc_block == ISOFS_I(inode)->i_iget5_block &&
506 ISOFS_I(inode)->i_iget5_offset == 0) {
508 "ISOFS: Directory relocation points to "
512 ISOFS_I(inode)->i_first_extent = reloc_block;
513 reloc = isofs_iget_reloc(inode->i_sb, reloc_block, 0);
515 ret = PTR_ERR(reloc);
518 inode->i_mode = reloc->i_mode;
519 set_nlink(inode, reloc->i_nlink);
520 inode->i_uid = reloc->i_uid;
521 inode->i_gid = reloc->i_gid;
522 inode->i_rdev = reloc->i_rdev;
523 inode->i_size = reloc->i_size;
524 inode->i_blocks = reloc->i_blocks;
525 inode->i_atime = reloc->i_atime;
526 inode->i_ctime = reloc->i_ctime;
527 inode->i_mtime = reloc->i_mtime;
531 case SIG('Z', 'F'): {
534 if (ISOFS_SB(inode->i_sb)->s_nocompress)
536 algo = isonum_721(rr->u.ZF.algorithm);
537 if (algo == SIG('p', 'z')) {
539 isonum_711(&rr->u.ZF.parms[1]);
540 if (block_shift > 17) {
541 printk(KERN_WARNING "isofs: "
542 "Can't handle ZF block "
547 * Note: we don't change
550 ISOFS_I(inode)->i_file_format =
551 isofs_file_compressed;
553 * Parameters to compression
554 * algorithm (header size,
557 ISOFS_I(inode)->i_format_parm[0] =
558 isonum_711(&rr->u.ZF.parms[0]);
559 ISOFS_I(inode)->i_format_parm[1] =
560 isonum_711(&rr->u.ZF.parms[1]);
567 "isofs: Unknown ZF compression "
569 rr->u.ZF.algorithm[0],
570 rr->u.ZF.algorithm[1]);
579 ret = rock_continue(&rs);
592 static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr, char *plimit)
596 struct SL_component *oldslp;
597 struct SL_component *slp;
599 slp = &rr->u.SL.link;
602 switch (slp->flags & ~1) {
604 if (slp->len > plimit - rpnt)
606 memcpy(rpnt, slp->text, slp->len);
615 if (2 > plimit - rpnt)
627 printk("Symlink component flag not implemented (%d)\n",
630 slen -= slp->len + 2;
632 slp = (struct SL_component *)((char *)slp + slp->len + 2);
636 * If there is another SL record, and this component
637 * record isn't continued, then add a slash.
639 if ((!rootflag) && (rr->u.SL.flags & 1) &&
640 !(oldslp->flags & 1)) {
649 * If this component record isn't continued, then append a '/'.
651 if (!rootflag && !(oldslp->flags & 1)) {
660 int parse_rock_ridge_inode(struct iso_directory_record *de, struct inode *inode,
663 int flags = relocated ? RR_RELOC_DE : 0;
664 int result = parse_rock_ridge_inode_internal(de, inode, flags);
667 * if rockridge flag was reset and we didn't look for attributes
668 * behind eventual XA attributes, have a look there
670 if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1)
671 && (ISOFS_SB(inode->i_sb)->s_rock == 2)) {
672 result = parse_rock_ridge_inode_internal(de, inode,
673 flags | RR_REGARD_XA);
679 * readpage() for symlinks: reads symlink contents into the page and either
680 * makes it uptodate and returns 0 or returns error (-EIO)
682 static int rock_ridge_symlink_readpage(struct file *file, struct page *page)
684 struct inode *inode = page->mapping->host;
685 struct iso_inode_info *ei = ISOFS_I(inode);
686 struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb);
687 char *link = kmap(page);
688 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
689 struct buffer_head *bh;
692 struct iso_directory_record *raw_de;
693 unsigned long block, offset;
695 struct rock_ridge *rr;
696 struct rock_state rs;
702 init_rock_state(&rs, inode);
703 block = ei->i_iget5_block;
704 bh = sb_bread(inode->i_sb, block);
708 offset = ei->i_iget5_offset;
709 pnt = (unsigned char *)bh->b_data + offset;
711 raw_de = (struct iso_directory_record *)pnt;
714 * If we go past the end of the buffer, there is some sort of error.
716 if (offset + *pnt > bufsize)
720 * Now test for possible Rock Ridge extensions which will override
721 * some of these numbers in the inode structure.
724 setup_rock_ridge(raw_de, inode, &rs);
727 while (rs.len > 2) { /* There may be one byte for padding somewhere */
728 rr = (struct rock_ridge *)rs.chr;
730 goto out; /* Something got screwed up here */
731 sig = isonum_721(rs.chr);
732 if (rock_check_overflow(&rs, sig))
737 goto out; /* corrupted isofs */
741 if ((rr->u.RR.flags[0] & RR_SL) == 0)
745 if (check_sp(rr, inode))
749 rpnt = get_symlink_chunk(rpnt, rr,
750 link + (PAGE_SIZE - 1));
755 /* This tells is if there is a continuation record */
756 rs.cont_extent = isonum_733(rr->u.CE.extent);
757 rs.cont_offset = isonum_733(rr->u.CE.offset);
758 rs.cont_size = isonum_733(rr->u.CE.size);
763 ret = rock_continue(&rs);
773 SetPageUptodate(page);
778 /* error exit from macro */
783 printk("unable to read i-node block");
786 printk("symlink spans iso9660 blocks\n");
796 const struct address_space_operations isofs_symlink_aops = {
797 .readpage = rock_ridge_symlink_readpage