rock.c

  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			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;
597out:
598	kfree(rs.buffer);
599	return ret;
600eio:
601	ret = -EIO;
602	goto out;
603}
604
605static 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
673int 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 */
695static 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
739repeat:
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;
788end:
789	folio_end_read(folio, ret == 0);
790	return ret;
791
792	/* error exit from macro */
793out:
794	kfree(rs.buffer);
795	goto fail;
796out_noread:
797	printk("unable to read i-node block");
798	goto fail;
799out_bad_span:
800	printk("symlink spans iso9660 blocks\n");
801fail:
802	brelse(bh);
803error:
804	ret = -EIO;
805	goto end;
806}
807
808const struct address_space_operations isofs_symlink_aops = {
809	.read_folio = rock_ridge_symlink_read_folio
810};