1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * linux/fs/isofs/rock.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * (C) 1992, 1993 Eric Youngdale
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * Rock Ridge Extensions to iso9660
81da177e4SLinus Torvalds */
91da177e4SLinus Torvalds
101da177e4SLinus Torvalds #include <linux/slab.h>
111da177e4SLinus Torvalds #include <linux/pagemap.h>
121da177e4SLinus Torvalds
1394f2f715SAl Viro #include "isofs.h"
141da177e4SLinus Torvalds #include "rock.h"
151da177e4SLinus Torvalds
167373909dSAndrew Morton /*
177373909dSAndrew Morton * These functions are designed to read the system areas of a directory record
181da177e4SLinus Torvalds * and extract relevant information. There are different functions provided
191da177e4SLinus Torvalds * depending upon what information we need at the time. One function fills
201da177e4SLinus Torvalds * out an inode structure, a second one extracts a filename, a third one
211da177e4SLinus Torvalds * returns a symbolic link name, and a fourth one returns the extent number
227373909dSAndrew Morton * for the file.
237373909dSAndrew Morton */
241da177e4SLinus Torvalds
251da177e4SLinus Torvalds #define SIG(A,B) ((A) | ((B) << 8)) /* isonum_721() */
261da177e4SLinus Torvalds
27ba40aaf0SAndrew Morton struct rock_state {
28ba40aaf0SAndrew Morton void *buffer;
29ba40aaf0SAndrew Morton unsigned char *chr;
30ba40aaf0SAndrew Morton int len;
31ba40aaf0SAndrew Morton int cont_size;
32ba40aaf0SAndrew Morton int cont_extent;
33ba40aaf0SAndrew Morton int cont_offset;
34f54e18f1SJan Kara int cont_loops;
35ba40aaf0SAndrew Morton struct inode *inode;
36ba40aaf0SAndrew Morton };
37ba40aaf0SAndrew Morton
3812121714SAndrew Morton /*
3912121714SAndrew Morton * This is a way of ensuring that we have something in the system
4012121714SAndrew Morton * use fields that is compatible with Rock Ridge. Return zero on success.
4112121714SAndrew Morton */
4212121714SAndrew Morton
check_sp(struct rock_ridge * rr,struct inode * inode)4312121714SAndrew Morton static int check_sp(struct rock_ridge *rr, struct inode *inode)
4412121714SAndrew Morton {
4512121714SAndrew Morton if (rr->u.SP.magic[0] != 0xbe)
4612121714SAndrew Morton return -1;
4712121714SAndrew Morton if (rr->u.SP.magic[1] != 0xef)
4812121714SAndrew Morton return -1;
491da177e4SLinus Torvalds ISOFS_SB(inode->i_sb)->s_rock_offset = rr->u.SP.skip;
5012121714SAndrew Morton return 0;
5112121714SAndrew Morton }
5212121714SAndrew Morton
setup_rock_ridge(struct iso_directory_record * de,struct inode * inode,struct rock_state * rs)5376ab07ebSAndrew Morton static void setup_rock_ridge(struct iso_directory_record *de,
54ba40aaf0SAndrew Morton struct inode *inode, struct rock_state *rs)
5576ab07ebSAndrew Morton {
56ba40aaf0SAndrew Morton rs->len = sizeof(struct iso_directory_record) + de->name_len[0];
57ba40aaf0SAndrew Morton if (rs->len & 1)
58ba40aaf0SAndrew Morton (rs->len)++;
59ba40aaf0SAndrew Morton rs->chr = (unsigned char *)de + rs->len;
60ba40aaf0SAndrew Morton rs->len = *((unsigned char *)de) - rs->len;
61ba40aaf0SAndrew Morton if (rs->len < 0)
62ba40aaf0SAndrew Morton rs->len = 0;
6376ab07ebSAndrew Morton
6476ab07ebSAndrew Morton if (ISOFS_SB(inode->i_sb)->s_rock_offset != -1) {
65ba40aaf0SAndrew Morton rs->len -= ISOFS_SB(inode->i_sb)->s_rock_offset;
66ba40aaf0SAndrew Morton rs->chr += ISOFS_SB(inode->i_sb)->s_rock_offset;
67ba40aaf0SAndrew Morton if (rs->len < 0)
68ba40aaf0SAndrew Morton rs->len = 0;
6976ab07ebSAndrew Morton }
701da177e4SLinus Torvalds }
711da177e4SLinus Torvalds
init_rock_state(struct rock_state * rs,struct inode * inode)72ba40aaf0SAndrew Morton static void init_rock_state(struct rock_state *rs, struct inode *inode)
73ba40aaf0SAndrew Morton {
74ba40aaf0SAndrew Morton memset(rs, 0, sizeof(*rs));
75ba40aaf0SAndrew Morton rs->inode = inode;
76ba40aaf0SAndrew Morton }
77ba40aaf0SAndrew Morton
78f54e18f1SJan Kara /* Maximum number of Rock Ridge continuation entries */
79f54e18f1SJan Kara #define RR_MAX_CE_ENTRIES 32
80f54e18f1SJan Kara
81ba40aaf0SAndrew Morton /*
82ba40aaf0SAndrew Morton * Returns 0 if the caller should continue scanning, 1 if the scan must end
83ba40aaf0SAndrew Morton * and -ve on error.
84ba40aaf0SAndrew Morton */
rock_continue(struct rock_state * rs)85ba40aaf0SAndrew Morton static int rock_continue(struct rock_state *rs)
86ba40aaf0SAndrew Morton {
87ba40aaf0SAndrew Morton int ret = 1;
88e595447eSAndrew Morton int blocksize = 1 << rs->inode->i_blkbits;
89e595447eSAndrew Morton const int min_de_size = offsetof(struct rock_ridge, u);
90ba40aaf0SAndrew Morton
91ba40aaf0SAndrew Morton kfree(rs->buffer);
92ba40aaf0SAndrew Morton rs->buffer = NULL;
93e595447eSAndrew Morton
94e595447eSAndrew Morton if ((unsigned)rs->cont_offset > blocksize - min_de_size ||
95e595447eSAndrew Morton (unsigned)rs->cont_size > blocksize ||
96e595447eSAndrew Morton (unsigned)(rs->cont_offset + rs->cont_size) > blocksize) {
97e595447eSAndrew Morton printk(KERN_NOTICE "rock: corrupted directory entry. "
98e595447eSAndrew Morton "extent=%d, offset=%d, size=%d\n",
99e595447eSAndrew Morton rs->cont_extent, rs->cont_offset, rs->cont_size);
100e595447eSAndrew Morton ret = -EIO;
101e595447eSAndrew Morton goto out;
102e595447eSAndrew Morton }
103e595447eSAndrew Morton
104ba40aaf0SAndrew Morton if (rs->cont_extent) {
105ba40aaf0SAndrew Morton struct buffer_head *bh;
106ba40aaf0SAndrew Morton
107ba40aaf0SAndrew Morton rs->buffer = kmalloc(rs->cont_size, GFP_KERNEL);
108ba40aaf0SAndrew Morton if (!rs->buffer) {
109ba40aaf0SAndrew Morton ret = -ENOMEM;
110ba40aaf0SAndrew Morton goto out;
111ba40aaf0SAndrew Morton }
112ba40aaf0SAndrew Morton ret = -EIO;
113f54e18f1SJan Kara if (++rs->cont_loops >= RR_MAX_CE_ENTRIES)
114f54e18f1SJan Kara goto out;
115ba40aaf0SAndrew Morton bh = sb_bread(rs->inode->i_sb, rs->cont_extent);
116ba40aaf0SAndrew Morton if (bh) {
117ba40aaf0SAndrew Morton memcpy(rs->buffer, bh->b_data + rs->cont_offset,
118ba40aaf0SAndrew Morton rs->cont_size);
119ba40aaf0SAndrew Morton put_bh(bh);
120ba40aaf0SAndrew Morton rs->chr = rs->buffer;
121ba40aaf0SAndrew Morton rs->len = rs->cont_size;
122ba40aaf0SAndrew Morton rs->cont_extent = 0;
123ba40aaf0SAndrew Morton rs->cont_size = 0;
124ba40aaf0SAndrew Morton rs->cont_offset = 0;
125ba40aaf0SAndrew Morton return 0;
126ba40aaf0SAndrew Morton }
127ba40aaf0SAndrew Morton printk("Unable to read rock-ridge attributes\n");
128ba40aaf0SAndrew Morton }
129ba40aaf0SAndrew Morton out:
130ba40aaf0SAndrew Morton kfree(rs->buffer);
131ba40aaf0SAndrew Morton rs->buffer = NULL;
132ba40aaf0SAndrew Morton return ret;
133ba40aaf0SAndrew Morton }
1341da177e4SLinus Torvalds
1357373909dSAndrew Morton /*
136f2966632SAndrew Morton * We think there's a record of type `sig' at rs->chr. Parse the signature
137f2966632SAndrew Morton * and make sure that there's really room for a record of that type.
138f2966632SAndrew Morton */
rock_check_overflow(struct rock_state * rs,int sig)139f2966632SAndrew Morton static int rock_check_overflow(struct rock_state *rs, int sig)
140f2966632SAndrew Morton {
141f2966632SAndrew Morton int len;
142f2966632SAndrew Morton
143f2966632SAndrew Morton switch (sig) {
144f2966632SAndrew Morton case SIG('S', 'P'):
145f2966632SAndrew Morton len = sizeof(struct SU_SP_s);
146f2966632SAndrew Morton break;
147f2966632SAndrew Morton case SIG('C', 'E'):
148f2966632SAndrew Morton len = sizeof(struct SU_CE_s);
149f2966632SAndrew Morton break;
150f2966632SAndrew Morton case SIG('E', 'R'):
151f2966632SAndrew Morton len = sizeof(struct SU_ER_s);
152f2966632SAndrew Morton break;
153f2966632SAndrew Morton case SIG('R', 'R'):
154f2966632SAndrew Morton len = sizeof(struct RR_RR_s);
155f2966632SAndrew Morton break;
156f2966632SAndrew Morton case SIG('P', 'X'):
157f2966632SAndrew Morton len = sizeof(struct RR_PX_s);
158f2966632SAndrew Morton break;
159f2966632SAndrew Morton case SIG('P', 'N'):
160f2966632SAndrew Morton len = sizeof(struct RR_PN_s);
161f2966632SAndrew Morton break;
162f2966632SAndrew Morton case SIG('S', 'L'):
163f2966632SAndrew Morton len = sizeof(struct RR_SL_s);
164f2966632SAndrew Morton break;
165f2966632SAndrew Morton case SIG('N', 'M'):
166f2966632SAndrew Morton len = sizeof(struct RR_NM_s);
167f2966632SAndrew Morton break;
168f2966632SAndrew Morton case SIG('C', 'L'):
169f2966632SAndrew Morton len = sizeof(struct RR_CL_s);
170f2966632SAndrew Morton break;
171f2966632SAndrew Morton case SIG('P', 'L'):
172f2966632SAndrew Morton len = sizeof(struct RR_PL_s);
173f2966632SAndrew Morton break;
174f2966632SAndrew Morton case SIG('T', 'F'):
175f2966632SAndrew Morton len = sizeof(struct RR_TF_s);
176f2966632SAndrew Morton break;
177f2966632SAndrew Morton case SIG('Z', 'F'):
178f2966632SAndrew Morton len = sizeof(struct RR_ZF_s);
179f2966632SAndrew Morton break;
180f2966632SAndrew Morton default:
181f2966632SAndrew Morton len = 0;
182f2966632SAndrew Morton break;
183f2966632SAndrew Morton }
184f2966632SAndrew Morton len += offsetof(struct rock_ridge, u);
185f2966632SAndrew Morton if (len > rs->len) {
186f2966632SAndrew Morton printk(KERN_NOTICE "rock: directory entry would overflow "
187f2966632SAndrew Morton "storage\n");
188f2966632SAndrew Morton printk(KERN_NOTICE "rock: sig=0x%02x, size=%d, remaining=%d\n",
189f2966632SAndrew Morton sig, len, rs->len);
190f2966632SAndrew Morton return -EIO;
191f2966632SAndrew Morton }
192f2966632SAndrew Morton return 0;
193f2966632SAndrew Morton }
194f2966632SAndrew Morton
195f2966632SAndrew Morton /*
1967373909dSAndrew Morton * return length of name field; 0: not found, -1: to be ignored
1977373909dSAndrew Morton */
get_rock_ridge_filename(struct iso_directory_record * de,char * retname,struct inode * inode)1981da177e4SLinus Torvalds int get_rock_ridge_filename(struct iso_directory_record *de,
1991da177e4SLinus Torvalds char *retname, struct inode *inode)
2001da177e4SLinus Torvalds {
201ba40aaf0SAndrew Morton struct rock_state rs;
2027fa393a1SAndrew Morton struct rock_ridge *rr;
2037fa393a1SAndrew Morton int sig;
2047fa393a1SAndrew Morton int retnamlen = 0;
2057fa393a1SAndrew Morton int truncate = 0;
206ba40aaf0SAndrew Morton int ret = 0;
20799d82582SAl Viro char *p;
20899d82582SAl Viro int len;
2091da177e4SLinus Torvalds
2101d372116SAndrew Morton if (!ISOFS_SB(inode->i_sb)->s_rock)
2111d372116SAndrew Morton return 0;
2121da177e4SLinus Torvalds *retname = 0;
2131da177e4SLinus Torvalds
214ba40aaf0SAndrew Morton init_rock_state(&rs, inode);
215ba40aaf0SAndrew Morton setup_rock_ridge(de, inode, &rs);
2161da177e4SLinus Torvalds repeat:
2171da177e4SLinus Torvalds
218ba40aaf0SAndrew Morton while (rs.len > 2) { /* There may be one byte for padding somewhere */
219ba40aaf0SAndrew Morton rr = (struct rock_ridge *)rs.chr;
220c0a1633bSAdam Greenblatt /*
221c0a1633bSAdam Greenblatt * Ignore rock ridge info if rr->len is out of range, but
222c0a1633bSAdam Greenblatt * don't return -EIO because that would make the file
223c0a1633bSAdam Greenblatt * invisible.
224c0a1633bSAdam Greenblatt */
2251d372116SAndrew Morton if (rr->len < 3)
2261d372116SAndrew Morton goto out; /* Something got screwed up here */
227ba40aaf0SAndrew Morton sig = isonum_721(rs.chr);
228f2966632SAndrew Morton if (rock_check_overflow(&rs, sig))
229f2966632SAndrew Morton goto eio;
230ba40aaf0SAndrew Morton rs.chr += rr->len;
231ba40aaf0SAndrew Morton rs.len -= rr->len;
232c0a1633bSAdam Greenblatt /*
233c0a1633bSAdam Greenblatt * As above, just ignore the rock ridge info if rr->len
234c0a1633bSAdam Greenblatt * is bogus.
235c0a1633bSAdam Greenblatt */
236ba40aaf0SAndrew Morton if (rs.len < 0)
237c0a1633bSAdam Greenblatt goto out; /* Something got screwed up here */
2381da177e4SLinus Torvalds
2391da177e4SLinus Torvalds switch (sig) {
2401da177e4SLinus Torvalds case SIG('R', 'R'):
2411d372116SAndrew Morton if ((rr->u.RR.flags[0] & RR_NM) == 0)
2421d372116SAndrew Morton goto out;
2431da177e4SLinus Torvalds break;
2441da177e4SLinus Torvalds case SIG('S', 'P'):
24512121714SAndrew Morton if (check_sp(rr, inode))
24612121714SAndrew Morton goto out;
2471da177e4SLinus Torvalds break;
2481da177e4SLinus Torvalds case SIG('C', 'E'):
249ba40aaf0SAndrew Morton rs.cont_extent = isonum_733(rr->u.CE.extent);
250ba40aaf0SAndrew Morton rs.cont_offset = isonum_733(rr->u.CE.offset);
251ba40aaf0SAndrew Morton rs.cont_size = isonum_733(rr->u.CE.size);
2521da177e4SLinus Torvalds break;
2531da177e4SLinus Torvalds case SIG('N', 'M'):
2541d372116SAndrew Morton if (truncate)
2551d372116SAndrew Morton break;
2561d372116SAndrew Morton if (rr->len < 5)
2571d372116SAndrew Morton break;
2581da177e4SLinus Torvalds /*
2591da177e4SLinus Torvalds * If the flags are 2 or 4, this indicates '.' or '..'.
2601da177e4SLinus Torvalds * We don't want to do anything with this, because it
2611da177e4SLinus Torvalds * screws up the code that calls us. We don't really
2621da177e4SLinus Torvalds * care anyways, since we can just use the non-RR
2631da177e4SLinus Torvalds * name.
2641da177e4SLinus Torvalds */
2657fa393a1SAndrew Morton if (rr->u.NM.flags & 6)
2661da177e4SLinus Torvalds break;
2671da177e4SLinus Torvalds
2681da177e4SLinus Torvalds if (rr->u.NM.flags & ~1) {
2697fa393a1SAndrew Morton printk("Unsupported NM flag settings (%d)\n",
2701d372116SAndrew Morton rr->u.NM.flags);
2711da177e4SLinus Torvalds break;
2721da177e4SLinus Torvalds }
27399d82582SAl Viro len = rr->len - 5;
27499d82582SAl Viro if (retnamlen + len >= 254) {
2751da177e4SLinus Torvalds truncate = 1;
2761da177e4SLinus Torvalds break;
2771da177e4SLinus Torvalds }
27899d82582SAl Viro p = memchr(rr->u.NM.name, '\0', len);
27999d82582SAl Viro if (unlikely(p))
28099d82582SAl Viro len = p - rr->u.NM.name;
28199d82582SAl Viro memcpy(retname + retnamlen, rr->u.NM.name, len);
28299d82582SAl Viro retnamlen += len;
28399d82582SAl Viro retname[retnamlen] = '\0';
2841da177e4SLinus Torvalds break;
2851da177e4SLinus Torvalds case SIG('R', 'E'):
286ba40aaf0SAndrew Morton kfree(rs.buffer);
2871da177e4SLinus Torvalds return -1;
2881da177e4SLinus Torvalds default:
2891da177e4SLinus Torvalds break;
2901da177e4SLinus Torvalds }
2911da177e4SLinus Torvalds }
292ba40aaf0SAndrew Morton ret = rock_continue(&rs);
293ba40aaf0SAndrew Morton if (ret == 0)
294ba40aaf0SAndrew Morton goto repeat;
295ba40aaf0SAndrew Morton if (ret == 1)
2961da177e4SLinus Torvalds return retnamlen; /* If 0, this file did not have a NM field */
2971da177e4SLinus Torvalds out:
298ba40aaf0SAndrew Morton kfree(rs.buffer);
299ba40aaf0SAndrew Morton return ret;
300f2966632SAndrew Morton eio:
301f2966632SAndrew Morton ret = -EIO;
302f2966632SAndrew Morton goto out;
3031da177e4SLinus Torvalds }
3041da177e4SLinus Torvalds
305410dd3cfSJan Kara #define RR_REGARD_XA 1
306410dd3cfSJan Kara #define RR_RELOC_DE 2
307410dd3cfSJan Kara
3081da177e4SLinus Torvalds static int
parse_rock_ridge_inode_internal(struct iso_directory_record * de,struct inode * inode,int flags)3091da177e4SLinus Torvalds parse_rock_ridge_inode_internal(struct iso_directory_record *de,
310410dd3cfSJan Kara struct inode *inode, int flags)
3111da177e4SLinus Torvalds {
3121da177e4SLinus Torvalds int symlink_len = 0;
3137fa393a1SAndrew Morton int cnt, sig;
314410dd3cfSJan Kara unsigned int reloc_block;
3157fa393a1SAndrew Morton struct inode *reloc;
3167fa393a1SAndrew Morton struct rock_ridge *rr;
3177fa393a1SAndrew Morton int rootflag;
318ba40aaf0SAndrew Morton struct rock_state rs;
319ba40aaf0SAndrew Morton int ret = 0;
3201da177e4SLinus Torvalds
3211d372116SAndrew Morton if (!ISOFS_SB(inode->i_sb)->s_rock)
3221d372116SAndrew Morton return 0;
3231da177e4SLinus Torvalds
324ba40aaf0SAndrew Morton init_rock_state(&rs, inode);
325ba40aaf0SAndrew Morton setup_rock_ridge(de, inode, &rs);
326410dd3cfSJan Kara if (flags & RR_REGARD_XA) {
327ba40aaf0SAndrew Morton rs.chr += 14;
328ba40aaf0SAndrew Morton rs.len -= 14;
329ba40aaf0SAndrew Morton if (rs.len < 0)
330ba40aaf0SAndrew Morton rs.len = 0;
3311da177e4SLinus Torvalds }
3321da177e4SLinus Torvalds
3331da177e4SLinus Torvalds repeat:
334ba40aaf0SAndrew Morton while (rs.len > 2) { /* There may be one byte for padding somewhere */
335ba40aaf0SAndrew Morton rr = (struct rock_ridge *)rs.chr;
336c0a1633bSAdam Greenblatt /*
337c0a1633bSAdam Greenblatt * Ignore rock ridge info if rr->len is out of range, but
338c0a1633bSAdam Greenblatt * don't return -EIO because that would make the file
339c0a1633bSAdam Greenblatt * invisible.
340c0a1633bSAdam Greenblatt */
3411d372116SAndrew Morton if (rr->len < 3)
3421d372116SAndrew Morton goto out; /* Something got screwed up here */
343ba40aaf0SAndrew Morton sig = isonum_721(rs.chr);
344f2966632SAndrew Morton if (rock_check_overflow(&rs, sig))
345f2966632SAndrew Morton goto eio;
346ba40aaf0SAndrew Morton rs.chr += rr->len;
347ba40aaf0SAndrew Morton rs.len -= rr->len;
348c0a1633bSAdam Greenblatt /*
349c0a1633bSAdam Greenblatt * As above, just ignore the rock ridge info if rr->len
350c0a1633bSAdam Greenblatt * is bogus.
351c0a1633bSAdam Greenblatt */
352ba40aaf0SAndrew Morton if (rs.len < 0)
353c0a1633bSAdam Greenblatt goto out; /* Something got screwed up here */
3541da177e4SLinus Torvalds
3551da177e4SLinus Torvalds switch (sig) {
3561da177e4SLinus Torvalds #ifndef CONFIG_ZISOFS /* No flag for SF or ZF */
3571da177e4SLinus Torvalds case SIG('R', 'R'):
3581da177e4SLinus Torvalds if ((rr->u.RR.flags[0] &
3591d372116SAndrew Morton (RR_PX | RR_TF | RR_SL | RR_CL)) == 0)
3601d372116SAndrew Morton goto out;
3611da177e4SLinus Torvalds break;
3621da177e4SLinus Torvalds #endif
3631da177e4SLinus Torvalds case SIG('S', 'P'):
36412121714SAndrew Morton if (check_sp(rr, inode))
36512121714SAndrew Morton goto out;
3661da177e4SLinus Torvalds break;
3671da177e4SLinus Torvalds case SIG('C', 'E'):
368ba40aaf0SAndrew Morton rs.cont_extent = isonum_733(rr->u.CE.extent);
369ba40aaf0SAndrew Morton rs.cont_offset = isonum_733(rr->u.CE.offset);
370ba40aaf0SAndrew Morton rs.cont_size = isonum_733(rr->u.CE.size);
3711da177e4SLinus Torvalds break;
3721da177e4SLinus Torvalds case SIG('E', 'R'):
3734e202462SJan Kara /* Invalid length of ER tag id? */
3744e202462SJan Kara if (rr->u.ER.len_id + offsetof(struct rock_ridge, u.ER.data) > rr->len)
3754e202462SJan Kara goto out;
3761da177e4SLinus Torvalds ISOFS_SB(inode->i_sb)->s_rock = 1;
3771da177e4SLinus Torvalds printk(KERN_DEBUG "ISO 9660 Extensions: ");
3781d372116SAndrew Morton {
3791d372116SAndrew Morton int p;
3801d372116SAndrew Morton for (p = 0; p < rr->u.ER.len_id; p++)
381a107bf8bSMike Rapoport printk(KERN_CONT "%c", rr->u.ER.data[p]);
3821da177e4SLinus Torvalds }
383a107bf8bSMike Rapoport printk(KERN_CONT "\n");
3841da177e4SLinus Torvalds break;
3851da177e4SLinus Torvalds case SIG('P', 'X'):
3861da177e4SLinus Torvalds inode->i_mode = isonum_733(rr->u.PX.mode);
387bfe86848SMiklos Szeredi set_nlink(inode, isonum_733(rr->u.PX.n_links));
388ba64e2b9SEric W. Biederman i_uid_write(inode, isonum_733(rr->u.PX.uid));
389ba64e2b9SEric W. Biederman i_gid_write(inode, isonum_733(rr->u.PX.gid));
3901da177e4SLinus Torvalds break;
3911da177e4SLinus Torvalds case SIG('P', 'N'):
3921d372116SAndrew Morton {
3931d372116SAndrew Morton int high, low;
3941da177e4SLinus Torvalds high = isonum_733(rr->u.PN.dev_high);
3951da177e4SLinus Torvalds low = isonum_733(rr->u.PN.dev_low);
3961da177e4SLinus Torvalds /*
3977fa393a1SAndrew Morton * The Rock Ridge standard specifies that if
3987fa393a1SAndrew Morton * sizeof(dev_t) <= 4, then the high field is
3997fa393a1SAndrew Morton * unused, and the device number is completely
4007fa393a1SAndrew Morton * stored in the low field. Some writers may
4017fa393a1SAndrew Morton * ignore this subtlety,
4027fa393a1SAndrew Morton * and as a result we test to see if the entire
4037fa393a1SAndrew Morton * device number is
4041da177e4SLinus Torvalds * stored in the low field, and use that.
4051da177e4SLinus Torvalds */
4061da177e4SLinus Torvalds if ((low & ~0xff) && high == 0) {
4071d372116SAndrew Morton inode->i_rdev =
4081d372116SAndrew Morton MKDEV(low >> 8, low & 0xff);
4091da177e4SLinus Torvalds } else {
4101d372116SAndrew Morton inode->i_rdev =
4111d372116SAndrew Morton MKDEV(high, low);
4121da177e4SLinus Torvalds }
4131da177e4SLinus Torvalds }
4141da177e4SLinus Torvalds break;
4151da177e4SLinus Torvalds case SIG('T', 'F'):
4167fa393a1SAndrew Morton /*
4177fa393a1SAndrew Morton * Some RRIP writers incorrectly place ctime in the
4187fa393a1SAndrew Morton * TF_CREATE field. Try to handle this correctly for
4197fa393a1SAndrew Morton * either case.
4207fa393a1SAndrew Morton */
4217fa393a1SAndrew Morton /* Rock ridge never appears on a High Sierra disk */
4227fa393a1SAndrew Morton cnt = 0;
4231da177e4SLinus Torvalds if (rr->u.TF.flags & TF_CREATE) {
424*2f06e4baSJeff Layton inode_set_ctime(inode,
425*2f06e4baSJeff Layton iso_date(rr->u.TF.times[cnt++].time, 0),
4261d372116SAndrew Morton 0);
4271da177e4SLinus Torvalds }
4281da177e4SLinus Torvalds if (rr->u.TF.flags & TF_MODIFY) {
4291d372116SAndrew Morton inode->i_mtime.tv_sec =
4301d372116SAndrew Morton iso_date(rr->u.TF.times[cnt++].time,
4311d372116SAndrew Morton 0);
4321da177e4SLinus Torvalds inode->i_mtime.tv_nsec = 0;
4331da177e4SLinus Torvalds }
4341da177e4SLinus Torvalds if (rr->u.TF.flags & TF_ACCESS) {
4351d372116SAndrew Morton inode->i_atime.tv_sec =
4361d372116SAndrew Morton iso_date(rr->u.TF.times[cnt++].time,
4371d372116SAndrew Morton 0);
4381da177e4SLinus Torvalds inode->i_atime.tv_nsec = 0;
4391da177e4SLinus Torvalds }
4401da177e4SLinus Torvalds if (rr->u.TF.flags & TF_ATTRIBUTES) {
441*2f06e4baSJeff Layton inode_set_ctime(inode,
442*2f06e4baSJeff Layton iso_date(rr->u.TF.times[cnt++].time, 0),
4431d372116SAndrew Morton 0);
4441da177e4SLinus Torvalds }
4451da177e4SLinus Torvalds break;
4461da177e4SLinus Torvalds case SIG('S', 'L'):
4471d372116SAndrew Morton {
4481d372116SAndrew Morton int slen;
4491da177e4SLinus Torvalds struct SL_component *slp;
4501da177e4SLinus Torvalds struct SL_component *oldslp;
4511da177e4SLinus Torvalds slen = rr->len - 5;
4521da177e4SLinus Torvalds slp = &rr->u.SL.link;
4531da177e4SLinus Torvalds inode->i_size = symlink_len;
4541da177e4SLinus Torvalds while (slen > 1) {
4551da177e4SLinus Torvalds rootflag = 0;
4561da177e4SLinus Torvalds switch (slp->flags & ~1) {
4571da177e4SLinus Torvalds case 0:
4581d372116SAndrew Morton inode->i_size +=
4591d372116SAndrew Morton slp->len;
4601da177e4SLinus Torvalds break;
4611da177e4SLinus Torvalds case 2:
4621da177e4SLinus Torvalds inode->i_size += 1;
4631da177e4SLinus Torvalds break;
4641da177e4SLinus Torvalds case 4:
4651da177e4SLinus Torvalds inode->i_size += 2;
4661da177e4SLinus Torvalds break;
4671da177e4SLinus Torvalds case 8:
4681da177e4SLinus Torvalds rootflag = 1;
4691da177e4SLinus Torvalds inode->i_size += 1;
4701da177e4SLinus Torvalds break;
4711da177e4SLinus Torvalds default:
4727fa393a1SAndrew Morton printk("Symlink component flag "
4737fa393a1SAndrew Morton "not implemented\n");
4741da177e4SLinus Torvalds }
4751da177e4SLinus Torvalds slen -= slp->len + 2;
4761da177e4SLinus Torvalds oldslp = slp;
4777fa393a1SAndrew Morton slp = (struct SL_component *)
4787fa393a1SAndrew Morton (((char *)slp) + slp->len + 2);
4791da177e4SLinus Torvalds
4801da177e4SLinus Torvalds if (slen < 2) {
4811d372116SAndrew Morton if (((rr->u.SL.
4821d372116SAndrew Morton flags & 1) != 0)
4831d372116SAndrew Morton &&
4841d372116SAndrew Morton ((oldslp->
4851d372116SAndrew Morton flags & 1) == 0))
4861d372116SAndrew Morton inode->i_size +=
4871d372116SAndrew Morton 1;
4881da177e4SLinus Torvalds break;
4891da177e4SLinus Torvalds }
4901da177e4SLinus Torvalds
4911da177e4SLinus Torvalds /*
4927fa393a1SAndrew Morton * If this component record isn't
4937fa393a1SAndrew Morton * continued, then append a '/'.
4941da177e4SLinus Torvalds */
4951d372116SAndrew Morton if (!rootflag
4961d372116SAndrew Morton && (oldslp->flags & 1) == 0)
4971da177e4SLinus Torvalds inode->i_size += 1;
4981da177e4SLinus Torvalds }
4991da177e4SLinus Torvalds }
5001da177e4SLinus Torvalds symlink_len = inode->i_size;
5011da177e4SLinus Torvalds break;
5021da177e4SLinus Torvalds case SIG('R', 'E'):
5037fa393a1SAndrew Morton printk(KERN_WARNING "Attempt to read inode for "
5047fa393a1SAndrew Morton "relocated directory\n");
5051da177e4SLinus Torvalds goto out;
5061da177e4SLinus Torvalds case SIG('C', 'L'):
507410dd3cfSJan Kara if (flags & RR_RELOC_DE) {
508410dd3cfSJan Kara printk(KERN_ERR
509410dd3cfSJan Kara "ISOFS: Recursive directory relocation "
510410dd3cfSJan Kara "is not supported\n");
511410dd3cfSJan Kara goto eio;
512410dd3cfSJan Kara }
513410dd3cfSJan Kara reloc_block = isonum_733(rr->u.CL.location);
514410dd3cfSJan Kara if (reloc_block == ISOFS_I(inode)->i_iget5_block &&
515410dd3cfSJan Kara ISOFS_I(inode)->i_iget5_offset == 0) {
516410dd3cfSJan Kara printk(KERN_ERR
517410dd3cfSJan Kara "ISOFS: Directory relocation points to "
518410dd3cfSJan Kara "itself\n");
519410dd3cfSJan Kara goto eio;
520410dd3cfSJan Kara }
521410dd3cfSJan Kara ISOFS_I(inode)->i_first_extent = reloc_block;
522410dd3cfSJan Kara reloc = isofs_iget_reloc(inode->i_sb, reloc_block, 0);
523c4386c83SDavid Howells if (IS_ERR(reloc)) {
524c4386c83SDavid Howells ret = PTR_ERR(reloc);
5251da177e4SLinus Torvalds goto out;
526c4386c83SDavid Howells }
5271da177e4SLinus Torvalds inode->i_mode = reloc->i_mode;
528bfe86848SMiklos Szeredi set_nlink(inode, reloc->i_nlink);
5291da177e4SLinus Torvalds inode->i_uid = reloc->i_uid;
5301da177e4SLinus Torvalds inode->i_gid = reloc->i_gid;
5311da177e4SLinus Torvalds inode->i_rdev = reloc->i_rdev;
5321da177e4SLinus Torvalds inode->i_size = reloc->i_size;
5331da177e4SLinus Torvalds inode->i_blocks = reloc->i_blocks;
5341da177e4SLinus Torvalds inode->i_atime = reloc->i_atime;
535*2f06e4baSJeff Layton inode_set_ctime_to_ts(inode, inode_get_ctime(reloc));
5361da177e4SLinus Torvalds inode->i_mtime = reloc->i_mtime;
5371da177e4SLinus Torvalds iput(reloc);
5381da177e4SLinus Torvalds break;
5391da177e4SLinus Torvalds #ifdef CONFIG_ZISOFS
5407fa393a1SAndrew Morton case SIG('Z', 'F'): {
5411da177e4SLinus Torvalds int algo;
5427fa393a1SAndrew Morton
5437fa393a1SAndrew Morton if (ISOFS_SB(inode->i_sb)->s_nocompress)
5447fa393a1SAndrew Morton break;
5451da177e4SLinus Torvalds algo = isonum_721(rr->u.ZF.algorithm);
5461da177e4SLinus Torvalds if (algo == SIG('p', 'z')) {
5471d372116SAndrew Morton int block_shift =
5487fa393a1SAndrew Morton isonum_711(&rr->u.ZF.parms[1]);
54959bc0552SJan Kara if (block_shift > 17) {
5507fa393a1SAndrew Morton printk(KERN_WARNING "isofs: "
5517fa393a1SAndrew Morton "Can't handle ZF block "
5527fa393a1SAndrew Morton "size of 2^%d\n",
5531d372116SAndrew Morton block_shift);
5541da177e4SLinus Torvalds } else {
5557fa393a1SAndrew Morton /*
5567fa393a1SAndrew Morton * Note: we don't change
5577fa393a1SAndrew Morton * i_blocks here
5587fa393a1SAndrew Morton */
5597fa393a1SAndrew Morton ISOFS_I(inode)->i_file_format =
5601d372116SAndrew Morton isofs_file_compressed;
5617fa393a1SAndrew Morton /*
5627fa393a1SAndrew Morton * Parameters to compression
5637fa393a1SAndrew Morton * algorithm (header size,
5647fa393a1SAndrew Morton * block size)
5657fa393a1SAndrew Morton */
5667fa393a1SAndrew Morton ISOFS_I(inode)->i_format_parm[0] =
5677fa393a1SAndrew Morton isonum_711(&rr->u.ZF.parms[0]);
5687fa393a1SAndrew Morton ISOFS_I(inode)->i_format_parm[1] =
5697fa393a1SAndrew Morton isonum_711(&rr->u.ZF.parms[1]);
5701d372116SAndrew Morton inode->i_size =
5711d372116SAndrew Morton isonum_733(rr->u.ZF.
5721d372116SAndrew Morton real_size);
5731da177e4SLinus Torvalds }
5741da177e4SLinus Torvalds } else {
5751d372116SAndrew Morton printk(KERN_WARNING
5767fa393a1SAndrew Morton "isofs: Unknown ZF compression "
5777fa393a1SAndrew Morton "algorithm: %c%c\n",
5781d372116SAndrew Morton rr->u.ZF.algorithm[0],
5791d372116SAndrew Morton rr->u.ZF.algorithm[1]);
5801da177e4SLinus Torvalds }
5811da177e4SLinus Torvalds break;
5827fa393a1SAndrew Morton }
5831da177e4SLinus Torvalds #endif
5841da177e4SLinus Torvalds default:
5851da177e4SLinus Torvalds break;
5861da177e4SLinus Torvalds }
5871da177e4SLinus Torvalds }
588ba40aaf0SAndrew Morton ret = rock_continue(&rs);
589ba40aaf0SAndrew Morton if (ret == 0)
590ba40aaf0SAndrew Morton goto repeat;
591ba40aaf0SAndrew Morton if (ret == 1)
592ba40aaf0SAndrew Morton ret = 0;
5931da177e4SLinus Torvalds out:
594ba40aaf0SAndrew Morton kfree(rs.buffer);
595ba40aaf0SAndrew Morton return ret;
596f2966632SAndrew Morton eio:
597f2966632SAndrew Morton ret = -EIO;
598f2966632SAndrew Morton goto out;
5991da177e4SLinus Torvalds }
6001da177e4SLinus Torvalds
get_symlink_chunk(char * rpnt,struct rock_ridge * rr,char * plimit)6011da177e4SLinus Torvalds static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr, char *plimit)
6021da177e4SLinus Torvalds {
6031da177e4SLinus Torvalds int slen;
6041da177e4SLinus Torvalds int rootflag;
6051da177e4SLinus Torvalds struct SL_component *oldslp;
6061da177e4SLinus Torvalds struct SL_component *slp;
6071da177e4SLinus Torvalds slen = rr->len - 5;
6081da177e4SLinus Torvalds slp = &rr->u.SL.link;
6091da177e4SLinus Torvalds while (slen > 1) {
6101da177e4SLinus Torvalds rootflag = 0;
6111da177e4SLinus Torvalds switch (slp->flags & ~1) {
6121da177e4SLinus Torvalds case 0:
6131da177e4SLinus Torvalds if (slp->len > plimit - rpnt)
6141da177e4SLinus Torvalds return NULL;
6151da177e4SLinus Torvalds memcpy(rpnt, slp->text, slp->len);
6161da177e4SLinus Torvalds rpnt += slp->len;
6171da177e4SLinus Torvalds break;
6181da177e4SLinus Torvalds case 2:
6191da177e4SLinus Torvalds if (rpnt >= plimit)
6201da177e4SLinus Torvalds return NULL;
6211da177e4SLinus Torvalds *rpnt++ = '.';
6221da177e4SLinus Torvalds break;
6231da177e4SLinus Torvalds case 4:
6241da177e4SLinus Torvalds if (2 > plimit - rpnt)
6251da177e4SLinus Torvalds return NULL;
6261da177e4SLinus Torvalds *rpnt++ = '.';
6271da177e4SLinus Torvalds *rpnt++ = '.';
6281da177e4SLinus Torvalds break;
6291da177e4SLinus Torvalds case 8:
6301da177e4SLinus Torvalds if (rpnt >= plimit)
6311da177e4SLinus Torvalds return NULL;
6321da177e4SLinus Torvalds rootflag = 1;
6331da177e4SLinus Torvalds *rpnt++ = '/';
6341da177e4SLinus Torvalds break;
6351da177e4SLinus Torvalds default:
6361da177e4SLinus Torvalds printk("Symlink component flag not implemented (%d)\n",
6371da177e4SLinus Torvalds slp->flags);
6381da177e4SLinus Torvalds }
6391da177e4SLinus Torvalds slen -= slp->len + 2;
6401da177e4SLinus Torvalds oldslp = slp;
6411da177e4SLinus Torvalds slp = (struct SL_component *)((char *)slp + slp->len + 2);
6421da177e4SLinus Torvalds
6431da177e4SLinus Torvalds if (slen < 2) {
6441da177e4SLinus Torvalds /*
6451da177e4SLinus Torvalds * If there is another SL record, and this component
6461da177e4SLinus Torvalds * record isn't continued, then add a slash.
6471da177e4SLinus Torvalds */
6481da177e4SLinus Torvalds if ((!rootflag) && (rr->u.SL.flags & 1) &&
6491da177e4SLinus Torvalds !(oldslp->flags & 1)) {
6501da177e4SLinus Torvalds if (rpnt >= plimit)
6511da177e4SLinus Torvalds return NULL;
6521da177e4SLinus Torvalds *rpnt++ = '/';
6531da177e4SLinus Torvalds }
6541da177e4SLinus Torvalds break;
6551da177e4SLinus Torvalds }
6561da177e4SLinus Torvalds
6571da177e4SLinus Torvalds /*
6581da177e4SLinus Torvalds * If this component record isn't continued, then append a '/'.
6591da177e4SLinus Torvalds */
6601da177e4SLinus Torvalds if (!rootflag && !(oldslp->flags & 1)) {
6611da177e4SLinus Torvalds if (rpnt >= plimit)
6621da177e4SLinus Torvalds return NULL;
6631da177e4SLinus Torvalds *rpnt++ = '/';
6641da177e4SLinus Torvalds }
6651da177e4SLinus Torvalds }
6661da177e4SLinus Torvalds return rpnt;
6671da177e4SLinus Torvalds }
6681da177e4SLinus Torvalds
parse_rock_ridge_inode(struct iso_directory_record * de,struct inode * inode,int relocated)669410dd3cfSJan Kara int parse_rock_ridge_inode(struct iso_directory_record *de, struct inode *inode,
670410dd3cfSJan Kara int relocated)
6711da177e4SLinus Torvalds {
672410dd3cfSJan Kara int flags = relocated ? RR_RELOC_DE : 0;
673410dd3cfSJan Kara int result = parse_rock_ridge_inode_internal(de, inode, flags);
6747373909dSAndrew Morton
6757373909dSAndrew Morton /*
6767373909dSAndrew Morton * if rockridge flag was reset and we didn't look for attributes
6777373909dSAndrew Morton * behind eventual XA attributes, have a look there
6787373909dSAndrew Morton */
6791da177e4SLinus Torvalds if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1)
6801d372116SAndrew Morton && (ISOFS_SB(inode->i_sb)->s_rock == 2)) {
681410dd3cfSJan Kara result = parse_rock_ridge_inode_internal(de, inode,
682410dd3cfSJan Kara flags | RR_REGARD_XA);
6831da177e4SLinus Torvalds }
6841da177e4SLinus Torvalds return result;
6851da177e4SLinus Torvalds }
6861da177e4SLinus Torvalds
6877373909dSAndrew Morton /*
688551cb124SMatthew Wilcox (Oracle) * read_folio() for symlinks: reads symlink contents into the folio and either
6897373909dSAndrew Morton * makes it uptodate and returns 0 or returns error (-EIO)
6907373909dSAndrew Morton */
rock_ridge_symlink_read_folio(struct file * file,struct folio * folio)691551cb124SMatthew Wilcox (Oracle) static int rock_ridge_symlink_read_folio(struct file *file, struct folio *folio)
6921da177e4SLinus Torvalds {
693551cb124SMatthew Wilcox (Oracle) struct page *page = &folio->page;
6941da177e4SLinus Torvalds struct inode *inode = page->mapping->host;
6951da177e4SLinus Torvalds struct iso_inode_info *ei = ISOFS_I(inode);
6964f819a78SArnd Bergmann struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb);
69721fc61c7SAl Viro char *link = page_address(page);
6981da177e4SLinus Torvalds unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
6991da177e4SLinus Torvalds struct buffer_head *bh;
7001da177e4SLinus Torvalds char *rpnt = link;
7011da177e4SLinus Torvalds unsigned char *pnt;
70276ab07ebSAndrew Morton struct iso_directory_record *raw_de;
7031da177e4SLinus Torvalds unsigned long block, offset;
7041da177e4SLinus Torvalds int sig;
7051da177e4SLinus Torvalds struct rock_ridge *rr;
706ba40aaf0SAndrew Morton struct rock_state rs;
707ba40aaf0SAndrew Morton int ret;
7081da177e4SLinus Torvalds
7094f819a78SArnd Bergmann if (!sbi->s_rock)
7101da177e4SLinus Torvalds goto error;
7111da177e4SLinus Torvalds
712ba40aaf0SAndrew Morton init_rock_state(&rs, inode);
7131da177e4SLinus Torvalds block = ei->i_iget5_block;
7141da177e4SLinus Torvalds bh = sb_bread(inode->i_sb, block);
7151da177e4SLinus Torvalds if (!bh)
7161da177e4SLinus Torvalds goto out_noread;
7171da177e4SLinus Torvalds
7181da177e4SLinus Torvalds offset = ei->i_iget5_offset;
7191da177e4SLinus Torvalds pnt = (unsigned char *)bh->b_data + offset;
7201da177e4SLinus Torvalds
72176ab07ebSAndrew Morton raw_de = (struct iso_directory_record *)pnt;
7221da177e4SLinus Torvalds
7231da177e4SLinus Torvalds /*
7241da177e4SLinus Torvalds * If we go past the end of the buffer, there is some sort of error.
7251da177e4SLinus Torvalds */
7261da177e4SLinus Torvalds if (offset + *pnt > bufsize)
7271da177e4SLinus Torvalds goto out_bad_span;
7281da177e4SLinus Torvalds
7297373909dSAndrew Morton /*
7307373909dSAndrew Morton * Now test for possible Rock Ridge extensions which will override
7317373909dSAndrew Morton * some of these numbers in the inode structure.
7327373909dSAndrew Morton */
7331da177e4SLinus Torvalds
734ba40aaf0SAndrew Morton setup_rock_ridge(raw_de, inode, &rs);
7351da177e4SLinus Torvalds
7361da177e4SLinus Torvalds repeat:
737ba40aaf0SAndrew Morton while (rs.len > 2) { /* There may be one byte for padding somewhere */
738ba40aaf0SAndrew Morton rr = (struct rock_ridge *)rs.chr;
7391da177e4SLinus Torvalds if (rr->len < 3)
7401da177e4SLinus Torvalds goto out; /* Something got screwed up here */
741ba40aaf0SAndrew Morton sig = isonum_721(rs.chr);
742f2966632SAndrew Morton if (rock_check_overflow(&rs, sig))
743f2966632SAndrew Morton goto out;
744ba40aaf0SAndrew Morton rs.chr += rr->len;
745ba40aaf0SAndrew Morton rs.len -= rr->len;
746ba40aaf0SAndrew Morton if (rs.len < 0)
7471da177e4SLinus Torvalds goto out; /* corrupted isofs */
7481da177e4SLinus Torvalds
7491da177e4SLinus Torvalds switch (sig) {
7501da177e4SLinus Torvalds case SIG('R', 'R'):
7511da177e4SLinus Torvalds if ((rr->u.RR.flags[0] & RR_SL) == 0)
7521da177e4SLinus Torvalds goto out;
7531da177e4SLinus Torvalds break;
7541da177e4SLinus Torvalds case SIG('S', 'P'):
75512121714SAndrew Morton if (check_sp(rr, inode))
75612121714SAndrew Morton goto out;
7571da177e4SLinus Torvalds break;
7581da177e4SLinus Torvalds case SIG('S', 'L'):
7591da177e4SLinus Torvalds rpnt = get_symlink_chunk(rpnt, rr,
7601da177e4SLinus Torvalds link + (PAGE_SIZE - 1));
7611da177e4SLinus Torvalds if (rpnt == NULL)
7621da177e4SLinus Torvalds goto out;
7631da177e4SLinus Torvalds break;
7641da177e4SLinus Torvalds case SIG('C', 'E'):
7651da177e4SLinus Torvalds /* This tells is if there is a continuation record */
766ba40aaf0SAndrew Morton rs.cont_extent = isonum_733(rr->u.CE.extent);
767ba40aaf0SAndrew Morton rs.cont_offset = isonum_733(rr->u.CE.offset);
768ba40aaf0SAndrew Morton rs.cont_size = isonum_733(rr->u.CE.size);
769b4ca4c01SGustavo A. R. Silva break;
7701da177e4SLinus Torvalds default:
7711da177e4SLinus Torvalds break;
7721da177e4SLinus Torvalds }
7731da177e4SLinus Torvalds }
774ba40aaf0SAndrew Morton ret = rock_continue(&rs);
775ba40aaf0SAndrew Morton if (ret == 0)
776ba40aaf0SAndrew Morton goto repeat;
777ba40aaf0SAndrew Morton if (ret < 0)
778ba40aaf0SAndrew Morton goto fail;
7791da177e4SLinus Torvalds
7801da177e4SLinus Torvalds if (rpnt == link)
7811da177e4SLinus Torvalds goto fail;
7821da177e4SLinus Torvalds brelse(bh);
7831da177e4SLinus Torvalds *rpnt = '\0';
7841da177e4SLinus Torvalds SetPageUptodate(page);
7851da177e4SLinus Torvalds unlock_page(page);
7861da177e4SLinus Torvalds return 0;
7871da177e4SLinus Torvalds
7881da177e4SLinus Torvalds /* error exit from macro */
7891da177e4SLinus Torvalds out:
790ba40aaf0SAndrew Morton kfree(rs.buffer);
7911da177e4SLinus Torvalds goto fail;
7921da177e4SLinus Torvalds out_noread:
7931da177e4SLinus Torvalds printk("unable to read i-node block");
7941da177e4SLinus Torvalds goto fail;
7951da177e4SLinus Torvalds out_bad_span:
7961da177e4SLinus Torvalds printk("symlink spans iso9660 blocks\n");
7971da177e4SLinus Torvalds fail:
7981da177e4SLinus Torvalds brelse(bh);
7991da177e4SLinus Torvalds error:
8001da177e4SLinus Torvalds SetPageError(page);
8011da177e4SLinus Torvalds unlock_page(page);
8021da177e4SLinus Torvalds return -EIO;
8031da177e4SLinus Torvalds }
8041da177e4SLinus Torvalds
805f5e54d6eSChristoph Hellwig const struct address_space_operations isofs_symlink_aops = {
806551cb124SMatthew Wilcox (Oracle) .read_folio = rock_ridge_symlink_read_folio
8071da177e4SLinus Torvalds };
808