]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * namei.c | |
3 | * | |
4 | * PURPOSE | |
5 | * Inode name handling routines for the OSTA-UDF(tm) filesystem. | |
6 | * | |
1da177e4 LT |
7 | * COPYRIGHT |
8 | * This file is distributed under the terms of the GNU General Public | |
9 | * License (GPL). Copies of the GPL can be obtained from: | |
10 | * ftp://prep.ai.mit.edu/pub/gnu/GPL | |
11 | * Each contributing author retains all rights to their own work. | |
12 | * | |
13 | * (C) 1998-2004 Ben Fennema | |
14 | * (C) 1999-2000 Stelias Computing Inc | |
15 | * | |
16 | * HISTORY | |
17 | * | |
18 | * 12/12/98 blf Created. Split out the lookup code from dir.c | |
19 | * 04/19/99 blf link, mknod, symlink support | |
20 | */ | |
21 | ||
22 | #include "udfdecl.h" | |
23 | ||
24 | #include "udf_i.h" | |
25 | #include "udf_sb.h" | |
26 | #include <linux/string.h> | |
27 | #include <linux/errno.h> | |
28 | #include <linux/mm.h> | |
29 | #include <linux/slab.h> | |
30 | #include <linux/quotaops.h> | |
31 | #include <linux/smp_lock.h> | |
32 | #include <linux/buffer_head.h> | |
e8edc6e0 | 33 | #include <linux/sched.h> |
f845fced | 34 | #include <linux/crc-itu-t.h> |
1da177e4 | 35 | |
cb00ea35 CG |
36 | static inline int udf_match(int len1, const char *name1, int len2, |
37 | const char *name2) | |
1da177e4 LT |
38 | { |
39 | if (len1 != len2) | |
40 | return 0; | |
28de7948 | 41 | |
1da177e4 LT |
42 | return !memcmp(name1, name2, len1); |
43 | } | |
44 | ||
45 | int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi, | |
cb00ea35 | 46 | struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh, |
4b11111a | 47 | uint8_t *impuse, uint8_t *fileident) |
1da177e4 LT |
48 | { |
49 | uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag); | |
50 | uint16_t crc; | |
1da177e4 LT |
51 | int offset; |
52 | uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse); | |
53 | uint8_t lfi = cfi->lengthFileIdent; | |
54 | int padlen = fibh->eoffset - fibh->soffset - liu - lfi - | |
28de7948 | 55 | sizeof(struct fileIdentDesc); |
1da177e4 LT |
56 | int adinicb = 0; |
57 | ||
c0b34438 | 58 | if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 LT |
59 | adinicb = 1; |
60 | ||
61 | offset = fibh->soffset + sizeof(struct fileIdentDesc); | |
62 | ||
cb00ea35 | 63 | if (impuse) { |
28de7948 CG |
64 | if (adinicb || (offset + liu < 0)) { |
65 | memcpy((uint8_t *)sfi->impUse, impuse, liu); | |
66 | } else if (offset >= 0) { | |
1da177e4 | 67 | memcpy(fibh->ebh->b_data + offset, impuse, liu); |
28de7948 CG |
68 | } else { |
69 | memcpy((uint8_t *)sfi->impUse, impuse, -offset); | |
4b11111a MS |
70 | memcpy(fibh->ebh->b_data, impuse - offset, |
71 | liu + offset); | |
1da177e4 LT |
72 | } |
73 | } | |
74 | ||
75 | offset += liu; | |
76 | ||
cb00ea35 | 77 | if (fileident) { |
28de7948 CG |
78 | if (adinicb || (offset + lfi < 0)) { |
79 | memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi); | |
80 | } else if (offset >= 0) { | |
1da177e4 | 81 | memcpy(fibh->ebh->b_data + offset, fileident, lfi); |
28de7948 | 82 | } else { |
4b11111a MS |
83 | memcpy((uint8_t *)sfi->fileIdent + liu, fileident, |
84 | -offset); | |
85 | memcpy(fibh->ebh->b_data, fileident - offset, | |
86 | lfi + offset); | |
1da177e4 LT |
87 | } |
88 | } | |
89 | ||
90 | offset += lfi; | |
91 | ||
28de7948 CG |
92 | if (adinicb || (offset + padlen < 0)) { |
93 | memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen); | |
94 | } else if (offset >= 0) { | |
1da177e4 | 95 | memset(fibh->ebh->b_data + offset, 0x00, padlen); |
28de7948 CG |
96 | } else { |
97 | memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset); | |
1da177e4 LT |
98 | memset(fibh->ebh->b_data, 0x00, padlen + offset); |
99 | } | |
100 | ||
f845fced BC |
101 | crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(tag), |
102 | sizeof(struct fileIdentDesc) - sizeof(tag)); | |
28de7948 CG |
103 | |
104 | if (fibh->sbh == fibh->ebh) { | |
f845fced | 105 | crc = crc_itu_t(crc, (uint8_t *)sfi->impUse, |
4b11111a | 106 | crclen + sizeof(tag) - |
f845fced | 107 | sizeof(struct fileIdentDesc)); |
28de7948 | 108 | } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) { |
f845fced | 109 | crc = crc_itu_t(crc, fibh->ebh->b_data + |
4b11111a MS |
110 | sizeof(struct fileIdentDesc) + |
111 | fibh->soffset, | |
112 | crclen + sizeof(tag) - | |
f845fced | 113 | sizeof(struct fileIdentDesc)); |
28de7948 | 114 | } else { |
f845fced BC |
115 | crc = crc_itu_t(crc, (uint8_t *)sfi->impUse, |
116 | -fibh->soffset - sizeof(struct fileIdentDesc)); | |
117 | crc = crc_itu_t(crc, fibh->ebh->b_data, fibh->eoffset); | |
1da177e4 LT |
118 | } |
119 | ||
120 | cfi->descTag.descCRC = cpu_to_le16(crc); | |
121 | cfi->descTag.descCRCLength = cpu_to_le16(crclen); | |
3f2587bb | 122 | cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag); |
1da177e4 | 123 | |
28de7948 | 124 | if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) { |
4b11111a MS |
125 | memcpy((uint8_t *)sfi, (uint8_t *)cfi, |
126 | sizeof(struct fileIdentDesc)); | |
28de7948 CG |
127 | } else { |
128 | memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset); | |
129 | memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset, | |
cb00ea35 | 130 | sizeof(struct fileIdentDesc) + fibh->soffset); |
1da177e4 LT |
131 | } |
132 | ||
28de7948 | 133 | if (adinicb) { |
1da177e4 | 134 | mark_inode_dirty(inode); |
28de7948 | 135 | } else { |
1da177e4 LT |
136 | if (fibh->sbh != fibh->ebh) |
137 | mark_buffer_dirty_inode(fibh->ebh, inode); | |
138 | mark_buffer_dirty_inode(fibh->sbh, inode); | |
139 | } | |
140 | return 0; | |
141 | } | |
142 | ||
cb00ea35 CG |
143 | static struct fileIdentDesc *udf_find_entry(struct inode *dir, |
144 | struct dentry *dentry, | |
145 | struct udf_fileident_bh *fibh, | |
146 | struct fileIdentDesc *cfi) | |
1da177e4 | 147 | { |
cb00ea35 | 148 | struct fileIdentDesc *fi = NULL; |
1da177e4 LT |
149 | loff_t f_pos; |
150 | int block, flen; | |
b80697c1 | 151 | char *fname = NULL; |
1da177e4 LT |
152 | char *nameptr; |
153 | uint8_t lfi; | |
154 | uint16_t liu; | |
ec471dc4 | 155 | loff_t size; |
ff116fc8 JK |
156 | kernel_lb_addr eloc; |
157 | uint32_t elen; | |
60448b1d | 158 | sector_t offset; |
28de7948 | 159 | struct extent_position epos = {}; |
48d6d8ff | 160 | struct udf_inode_info *dinfo = UDF_I(dir); |
1da177e4 | 161 | |
af793295 JK |
162 | size = udf_ext0_offset(dir) + dir->i_size; |
163 | f_pos = udf_ext0_offset(dir); | |
1da177e4 | 164 | |
b80697c1 | 165 | fibh->sbh = fibh->ebh = NULL; |
af793295 | 166 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); |
b80697c1 JK |
167 | if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
168 | if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, | |
169 | &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) | |
170 | goto out_err; | |
1da177e4 | 171 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
cb00ea35 | 172 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
48d6d8ff | 173 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
ff116fc8 | 174 | epos.offset -= sizeof(short_ad); |
48d6d8ff | 175 | else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) |
ff116fc8 | 176 | epos.offset -= sizeof(long_ad); |
4b11111a | 177 | } else |
1da177e4 LT |
178 | offset = 0; |
179 | ||
4b11111a | 180 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); |
b80697c1 JK |
181 | if (!fibh->sbh) |
182 | goto out_err; | |
1da177e4 LT |
183 | } |
184 | ||
b80697c1 JK |
185 | fname = kmalloc(UDF_NAME_LEN, GFP_NOFS); |
186 | if (!fname) | |
187 | goto out_err; | |
188 | ||
af793295 | 189 | while (f_pos < size) { |
cb00ea35 CG |
190 | fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, |
191 | &elen, &offset); | |
b80697c1 JK |
192 | if (!fi) |
193 | goto out_err; | |
1da177e4 LT |
194 | |
195 | liu = le16_to_cpu(cfi->lengthOfImpUse); | |
196 | lfi = cfi->lengthFileIdent; | |
197 | ||
cb00ea35 | 198 | if (fibh->sbh == fibh->ebh) { |
1da177e4 | 199 | nameptr = fi->fileIdent + liu; |
cb00ea35 | 200 | } else { |
1da177e4 LT |
201 | int poffset; /* Unpaded ending offset */ |
202 | ||
4b11111a MS |
203 | poffset = fibh->soffset + sizeof(struct fileIdentDesc) + |
204 | liu + lfi; | |
1da177e4 | 205 | |
4b11111a MS |
206 | if (poffset >= lfi) |
207 | nameptr = (uint8_t *)(fibh->ebh->b_data + | |
208 | poffset - lfi); | |
209 | else { | |
1da177e4 | 210 | nameptr = fname; |
4b11111a MS |
211 | memcpy(nameptr, fi->fileIdent + liu, |
212 | lfi - poffset); | |
213 | memcpy(nameptr + lfi - poffset, | |
214 | fibh->ebh->b_data, poffset); | |
1da177e4 LT |
215 | } |
216 | } | |
217 | ||
cb00ea35 CG |
218 | if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { |
219 | if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE)) | |
1da177e4 LT |
220 | continue; |
221 | } | |
cb00ea35 CG |
222 | |
223 | if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) { | |
224 | if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE)) | |
1da177e4 LT |
225 | continue; |
226 | } | |
227 | ||
228 | if (!lfi) | |
229 | continue; | |
230 | ||
4b11111a MS |
231 | flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); |
232 | if (flen && udf_match(flen, fname, dentry->d_name.len, | |
b80697c1 JK |
233 | dentry->d_name.name)) |
234 | goto out_ok; | |
1da177e4 | 235 | } |
28de7948 | 236 | |
b80697c1 JK |
237 | out_err: |
238 | fi = NULL; | |
1da177e4 | 239 | if (fibh->sbh != fibh->ebh) |
3bf25cb4 JK |
240 | brelse(fibh->ebh); |
241 | brelse(fibh->sbh); | |
b80697c1 | 242 | out_ok: |
3bf25cb4 | 243 | brelse(epos.bh); |
b80697c1 | 244 | kfree(fname); |
28de7948 | 245 | |
b80697c1 | 246 | return fi; |
1da177e4 LT |
247 | } |
248 | ||
cb00ea35 CG |
249 | static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry, |
250 | struct nameidata *nd) | |
1da177e4 LT |
251 | { |
252 | struct inode *inode = NULL; | |
db9a369e | 253 | struct fileIdentDesc cfi; |
1da177e4 LT |
254 | struct udf_fileident_bh fibh; |
255 | ||
cb00ea35 | 256 | if (dentry->d_name.len > UDF_NAME_LEN - 2) |
1da177e4 LT |
257 | return ERR_PTR(-ENAMETOOLONG); |
258 | ||
259 | lock_kernel(); | |
260 | #ifdef UDF_RECOVERY | |
261 | /* temporary shorthand for specifying files by inode number */ | |
cb00ea35 | 262 | if (!strncmp(dentry->d_name.name, ".B=", 3)) { |
28de7948 CG |
263 | kernel_lb_addr lb = { |
264 | .logicalBlockNum = 0, | |
4b11111a MS |
265 | .partitionReferenceNum = |
266 | simple_strtoul(dentry->d_name.name + 3, | |
267 | NULL, 0), | |
28de7948 | 268 | }; |
1da177e4 | 269 | inode = udf_iget(dir->i_sb, lb); |
cb00ea35 | 270 | if (!inode) { |
1da177e4 LT |
271 | unlock_kernel(); |
272 | return ERR_PTR(-EACCES); | |
273 | } | |
4b11111a | 274 | } else |
28de7948 | 275 | #endif /* UDF_RECOVERY */ |
1da177e4 | 276 | |
cb00ea35 | 277 | if (udf_find_entry(dir, dentry, &fibh, &cfi)) { |
1da177e4 | 278 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
279 | brelse(fibh.ebh); |
280 | brelse(fibh.sbh); | |
1da177e4 LT |
281 | |
282 | inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation)); | |
cb00ea35 | 283 | if (!inode) { |
1da177e4 LT |
284 | unlock_kernel(); |
285 | return ERR_PTR(-EACCES); | |
286 | } | |
287 | } | |
288 | unlock_kernel(); | |
289 | d_add(dentry, inode); | |
28de7948 | 290 | |
1da177e4 LT |
291 | return NULL; |
292 | } | |
293 | ||
cb00ea35 CG |
294 | static struct fileIdentDesc *udf_add_entry(struct inode *dir, |
295 | struct dentry *dentry, | |
296 | struct udf_fileident_bh *fibh, | |
297 | struct fileIdentDesc *cfi, int *err) | |
1da177e4 | 298 | { |
6c79e987 | 299 | struct super_block *sb = dir->i_sb; |
cb00ea35 | 300 | struct fileIdentDesc *fi = NULL; |
b80697c1 | 301 | char *name = NULL; |
1da177e4 LT |
302 | int namelen; |
303 | loff_t f_pos; | |
af793295 | 304 | loff_t size = udf_ext0_offset(dir) + dir->i_size; |
1da177e4 LT |
305 | int nfidlen; |
306 | uint8_t lfi; | |
307 | uint16_t liu; | |
308 | int block; | |
ff116fc8 JK |
309 | kernel_lb_addr eloc; |
310 | uint32_t elen; | |
60448b1d | 311 | sector_t offset; |
28de7948 | 312 | struct extent_position epos = {}; |
48d6d8ff | 313 | struct udf_inode_info *dinfo; |
1da177e4 | 314 | |
b80697c1 JK |
315 | fibh->sbh = fibh->ebh = NULL; |
316 | name = kmalloc(UDF_NAME_LEN, GFP_NOFS); | |
317 | if (!name) { | |
318 | *err = -ENOMEM; | |
319 | goto out_err; | |
320 | } | |
321 | ||
cb00ea35 CG |
322 | if (dentry) { |
323 | if (!dentry->d_name.len) { | |
1da177e4 | 324 | *err = -EINVAL; |
b80697c1 | 325 | goto out_err; |
1da177e4 | 326 | } |
4b11111a MS |
327 | namelen = udf_put_filename(sb, dentry->d_name.name, name, |
328 | dentry->d_name.len); | |
329 | if (!namelen) { | |
1da177e4 | 330 | *err = -ENAMETOOLONG; |
b80697c1 | 331 | goto out_err; |
1da177e4 | 332 | } |
28de7948 | 333 | } else { |
1da177e4 | 334 | namelen = 0; |
28de7948 | 335 | } |
1da177e4 LT |
336 | |
337 | nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3; | |
338 | ||
af793295 | 339 | f_pos = udf_ext0_offset(dir); |
1da177e4 | 340 | |
af793295 | 341 | fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); |
48d6d8ff | 342 | dinfo = UDF_I(dir); |
b80697c1 JK |
343 | if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
344 | if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, | |
345 | &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) { | |
346 | block = udf_get_lb_pblock(dir->i_sb, | |
347 | dinfo->i_location, 0); | |
348 | fibh->soffset = fibh->eoffset = sb->s_blocksize; | |
349 | goto add; | |
350 | } | |
1da177e4 | 351 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
cb00ea35 | 352 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
48d6d8ff | 353 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
ff116fc8 | 354 | epos.offset -= sizeof(short_ad); |
48d6d8ff | 355 | else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) |
ff116fc8 | 356 | epos.offset -= sizeof(long_ad); |
4b11111a | 357 | } else |
1da177e4 LT |
358 | offset = 0; |
359 | ||
4b11111a MS |
360 | fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); |
361 | if (!fibh->sbh) { | |
1da177e4 | 362 | *err = -EIO; |
b80697c1 | 363 | goto out_err; |
1da177e4 LT |
364 | } |
365 | ||
48d6d8ff | 366 | block = dinfo->i_location.logicalBlockNum; |
1da177e4 LT |
367 | } |
368 | ||
af793295 | 369 | while (f_pos < size) { |
cb00ea35 CG |
370 | fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, |
371 | &elen, &offset); | |
1da177e4 | 372 | |
cb00ea35 | 373 | if (!fi) { |
1da177e4 | 374 | *err = -EIO; |
b80697c1 | 375 | goto out_err; |
1da177e4 LT |
376 | } |
377 | ||
378 | liu = le16_to_cpu(cfi->lengthOfImpUse); | |
379 | lfi = cfi->lengthFileIdent; | |
380 | ||
cb00ea35 | 381 | if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) { |
4b11111a MS |
382 | if (((sizeof(struct fileIdentDesc) + |
383 | liu + lfi + 3) & ~3) == nfidlen) { | |
1da177e4 LT |
384 | cfi->descTag.tagSerialNum = cpu_to_le16(1); |
385 | cfi->fileVersionNum = cpu_to_le16(1); | |
386 | cfi->fileCharacteristics = 0; | |
387 | cfi->lengthFileIdent = namelen; | |
388 | cfi->lengthOfImpUse = cpu_to_le16(0); | |
4b11111a MS |
389 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, |
390 | name)) | |
b80697c1 | 391 | goto out_ok; |
4b11111a | 392 | else { |
1da177e4 | 393 | *err = -EIO; |
b80697c1 | 394 | goto out_err; |
1da177e4 LT |
395 | } |
396 | } | |
397 | } | |
1da177e4 LT |
398 | } |
399 | ||
28de7948 | 400 | add: |
05343c4f JK |
401 | if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
402 | elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1); | |
403 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) | |
404 | epos.offset -= sizeof(short_ad); | |
405 | else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) | |
406 | epos.offset -= sizeof(long_ad); | |
407 | udf_write_aext(dir, &epos, eloc, elen, 1); | |
408 | } | |
1da177e4 LT |
409 | f_pos += nfidlen; |
410 | ||
48d6d8ff | 411 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB && |
cb00ea35 | 412 | sb->s_blocksize - fibh->eoffset < nfidlen) { |
3bf25cb4 | 413 | brelse(epos.bh); |
ff116fc8 | 414 | epos.bh = NULL; |
1da177e4 LT |
415 | fibh->soffset -= udf_ext0_offset(dir); |
416 | fibh->eoffset -= udf_ext0_offset(dir); | |
af793295 | 417 | f_pos -= udf_ext0_offset(dir); |
1da177e4 | 418 | if (fibh->sbh != fibh->ebh) |
3bf25cb4 JK |
419 | brelse(fibh->ebh); |
420 | brelse(fibh->sbh); | |
4b11111a MS |
421 | fibh->sbh = fibh->ebh = |
422 | udf_expand_dir_adinicb(dir, &block, err); | |
423 | if (!fibh->sbh) | |
b80697c1 | 424 | goto out_err; |
48d6d8ff | 425 | epos.block = dinfo->i_location; |
ff116fc8 | 426 | epos.offset = udf_file_entry_alloc_offset(dir); |
05343c4f JK |
427 | /* Load extent udf_expand_dir_adinicb() has created */ |
428 | udf_current_aext(dir, &epos, &eloc, &elen, 1); | |
1da177e4 LT |
429 | } |
430 | ||
cb00ea35 | 431 | if (sb->s_blocksize - fibh->eoffset >= nfidlen) { |
1da177e4 LT |
432 | fibh->soffset = fibh->eoffset; |
433 | fibh->eoffset += nfidlen; | |
cb00ea35 | 434 | if (fibh->sbh != fibh->ebh) { |
3bf25cb4 | 435 | brelse(fibh->sbh); |
1da177e4 LT |
436 | fibh->sbh = fibh->ebh; |
437 | } | |
438 | ||
48d6d8ff MS |
439 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { |
440 | block = dinfo->i_location.logicalBlockNum; | |
4b11111a | 441 | fi = (struct fileIdentDesc *) |
48d6d8ff | 442 | (dinfo->i_ext.i_data + |
c0b34438 | 443 | fibh->soffset - |
4b11111a | 444 | udf_ext0_offset(dir) + |
48d6d8ff | 445 | dinfo->i_lenEAttr); |
cb00ea35 | 446 | } else { |
4b11111a MS |
447 | block = eloc.logicalBlockNum + |
448 | ((elen - 1) >> | |
449 | dir->i_sb->s_blocksize_bits); | |
450 | fi = (struct fileIdentDesc *) | |
451 | (fibh->sbh->b_data + fibh->soffset); | |
1da177e4 | 452 | } |
cb00ea35 | 453 | } else { |
1da177e4 LT |
454 | fibh->soffset = fibh->eoffset - sb->s_blocksize; |
455 | fibh->eoffset += nfidlen - sb->s_blocksize; | |
cb00ea35 | 456 | if (fibh->sbh != fibh->ebh) { |
3bf25cb4 | 457 | brelse(fibh->sbh); |
1da177e4 LT |
458 | fibh->sbh = fibh->ebh; |
459 | } | |
460 | ||
461 | block = eloc.logicalBlockNum + ((elen - 1) >> | |
cb00ea35 | 462 | dir->i_sb->s_blocksize_bits); |
4b11111a | 463 | fibh->ebh = udf_bread(dir, |
af793295 | 464 | f_pos >> dir->i_sb->s_blocksize_bits, 1, err); |
b80697c1 JK |
465 | if (!fibh->ebh) |
466 | goto out_err; | |
1da177e4 | 467 | |
28de7948 | 468 | if (!fibh->soffset) { |
ff116fc8 | 469 | if (udf_next_aext(dir, &epos, &eloc, &elen, 1) == |
cb00ea35 | 470 | (EXT_RECORDED_ALLOCATED >> 30)) { |
1da177e4 | 471 | block = eloc.logicalBlockNum + ((elen - 1) >> |
28de7948 | 472 | dir->i_sb->s_blocksize_bits); |
4b11111a | 473 | } else |
cb00ea35 | 474 | block++; |
1da177e4 | 475 | |
3bf25cb4 | 476 | brelse(fibh->sbh); |
1da177e4 LT |
477 | fibh->sbh = fibh->ebh; |
478 | fi = (struct fileIdentDesc *)(fibh->sbh->b_data); | |
cb00ea35 | 479 | } else { |
1da177e4 | 480 | fi = (struct fileIdentDesc *) |
4b11111a MS |
481 | (fibh->sbh->b_data + sb->s_blocksize + |
482 | fibh->soffset); | |
1da177e4 LT |
483 | } |
484 | } | |
485 | ||
486 | memset(cfi, 0, sizeof(struct fileIdentDesc)); | |
6c79e987 | 487 | if (UDF_SB(sb)->s_udfrev >= 0x0200) |
4b11111a MS |
488 | udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, |
489 | sizeof(tag)); | |
1da177e4 | 490 | else |
4b11111a MS |
491 | udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, |
492 | sizeof(tag)); | |
1da177e4 LT |
493 | cfi->fileVersionNum = cpu_to_le16(1); |
494 | cfi->lengthFileIdent = namelen; | |
495 | cfi->lengthOfImpUse = cpu_to_le16(0); | |
cb00ea35 | 496 | if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) { |
1da177e4 | 497 | dir->i_size += nfidlen; |
48d6d8ff MS |
498 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
499 | dinfo->i_lenAlloc += nfidlen; | |
1da177e4 | 500 | mark_inode_dirty(dir); |
b80697c1 | 501 | goto out_ok; |
cb00ea35 | 502 | } else { |
1da177e4 | 503 | *err = -EIO; |
b80697c1 | 504 | goto out_err; |
1da177e4 | 505 | } |
b80697c1 JK |
506 | |
507 | out_err: | |
508 | fi = NULL; | |
509 | if (fibh->sbh != fibh->ebh) | |
510 | brelse(fibh->ebh); | |
511 | brelse(fibh->sbh); | |
512 | out_ok: | |
513 | brelse(epos.bh); | |
514 | kfree(name); | |
515 | return fi; | |
1da177e4 LT |
516 | } |
517 | ||
518 | static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi, | |
cb00ea35 CG |
519 | struct udf_fileident_bh *fibh, |
520 | struct fileIdentDesc *cfi) | |
1da177e4 LT |
521 | { |
522 | cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED; | |
28de7948 | 523 | |
1da177e4 LT |
524 | if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) |
525 | memset(&(cfi->icb), 0x00, sizeof(long_ad)); | |
28de7948 | 526 | |
1da177e4 LT |
527 | return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL); |
528 | } | |
529 | ||
cb00ea35 CG |
530 | static int udf_create(struct inode *dir, struct dentry *dentry, int mode, |
531 | struct nameidata *nd) | |
1da177e4 LT |
532 | { |
533 | struct udf_fileident_bh fibh; | |
534 | struct inode *inode; | |
535 | struct fileIdentDesc cfi, *fi; | |
536 | int err; | |
48d6d8ff | 537 | struct udf_inode_info *iinfo; |
1da177e4 LT |
538 | |
539 | lock_kernel(); | |
540 | inode = udf_new_inode(dir, mode, &err); | |
cb00ea35 | 541 | if (!inode) { |
1da177e4 LT |
542 | unlock_kernel(); |
543 | return err; | |
544 | } | |
545 | ||
48d6d8ff MS |
546 | iinfo = UDF_I(inode); |
547 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) | |
1da177e4 LT |
548 | inode->i_data.a_ops = &udf_adinicb_aops; |
549 | else | |
550 | inode->i_data.a_ops = &udf_aops; | |
551 | inode->i_op = &udf_file_inode_operations; | |
552 | inode->i_fop = &udf_file_operations; | |
553 | inode->i_mode = mode; | |
554 | mark_inode_dirty(inode); | |
555 | ||
4b11111a MS |
556 | fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); |
557 | if (!fi) { | |
cb00ea35 | 558 | inode->i_nlink--; |
1da177e4 LT |
559 | mark_inode_dirty(inode); |
560 | iput(inode); | |
561 | unlock_kernel(); | |
562 | return err; | |
563 | } | |
564 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
48d6d8ff | 565 | cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); |
28de7948 | 566 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
48d6d8ff | 567 | cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); |
1da177e4 | 568 | udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); |
c0b34438 | 569 | if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 570 | mark_inode_dirty(dir); |
1da177e4 | 571 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
572 | brelse(fibh.ebh); |
573 | brelse(fibh.sbh); | |
1da177e4 LT |
574 | unlock_kernel(); |
575 | d_instantiate(dentry, inode); | |
28de7948 | 576 | |
1da177e4 LT |
577 | return 0; |
578 | } | |
579 | ||
cb00ea35 CG |
580 | static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode, |
581 | dev_t rdev) | |
1da177e4 | 582 | { |
cb00ea35 | 583 | struct inode *inode; |
1da177e4 LT |
584 | struct udf_fileident_bh fibh; |
585 | struct fileIdentDesc cfi, *fi; | |
586 | int err; | |
48d6d8ff | 587 | struct udf_inode_info *iinfo; |
1da177e4 LT |
588 | |
589 | if (!old_valid_dev(rdev)) | |
590 | return -EINVAL; | |
591 | ||
592 | lock_kernel(); | |
593 | err = -EIO; | |
594 | inode = udf_new_inode(dir, mode, &err); | |
595 | if (!inode) | |
596 | goto out; | |
597 | ||
48d6d8ff | 598 | iinfo = UDF_I(inode); |
1da177e4 LT |
599 | inode->i_uid = current->fsuid; |
600 | init_special_inode(inode, mode, rdev); | |
4b11111a MS |
601 | fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); |
602 | if (!fi) { | |
cb00ea35 | 603 | inode->i_nlink--; |
1da177e4 LT |
604 | mark_inode_dirty(inode); |
605 | iput(inode); | |
606 | unlock_kernel(); | |
607 | return err; | |
608 | } | |
609 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
48d6d8ff | 610 | cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); |
28de7948 | 611 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
48d6d8ff | 612 | cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); |
1da177e4 | 613 | udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); |
c0b34438 | 614 | if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 615 | mark_inode_dirty(dir); |
1da177e4 LT |
616 | mark_inode_dirty(inode); |
617 | ||
618 | if (fibh.sbh != fibh.ebh) | |
3bf25cb4 JK |
619 | brelse(fibh.ebh); |
620 | brelse(fibh.sbh); | |
1da177e4 LT |
621 | d_instantiate(dentry, inode); |
622 | err = 0; | |
28de7948 CG |
623 | |
624 | out: | |
1da177e4 LT |
625 | unlock_kernel(); |
626 | return err; | |
627 | } | |
628 | ||
cb00ea35 | 629 | static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode) |
1da177e4 | 630 | { |
cb00ea35 | 631 | struct inode *inode; |
1da177e4 LT |
632 | struct udf_fileident_bh fibh; |
633 | struct fileIdentDesc cfi, *fi; | |
634 | int err; | |
48d6d8ff MS |
635 | struct udf_inode_info *dinfo = UDF_I(dir); |
636 | struct udf_inode_info *iinfo; | |
1da177e4 LT |
637 | |
638 | lock_kernel(); | |
639 | err = -EMLINK; | |
cb00ea35 | 640 | if (dir->i_nlink >= (256 << sizeof(dir->i_nlink)) - 1) |
1da177e4 LT |
641 | goto out; |
642 | ||
643 | err = -EIO; | |
644 | inode = udf_new_inode(dir, S_IFDIR, &err); | |
645 | if (!inode) | |
646 | goto out; | |
647 | ||
48d6d8ff | 648 | iinfo = UDF_I(inode); |
1da177e4 LT |
649 | inode->i_op = &udf_dir_inode_operations; |
650 | inode->i_fop = &udf_dir_operations; | |
4b11111a MS |
651 | fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err); |
652 | if (!fi) { | |
1da177e4 LT |
653 | inode->i_nlink--; |
654 | mark_inode_dirty(inode); | |
655 | iput(inode); | |
656 | goto out; | |
657 | } | |
658 | inode->i_nlink = 2; | |
659 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
48d6d8ff | 660 | cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location); |
28de7948 | 661 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
48d6d8ff | 662 | cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL); |
4b11111a MS |
663 | cfi.fileCharacteristics = |
664 | FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT; | |
1da177e4 | 665 | udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL); |
3bf25cb4 | 666 | brelse(fibh.sbh); |
1da177e4 LT |
667 | inode->i_mode = S_IFDIR | mode; |
668 | if (dir->i_mode & S_ISGID) | |
669 | inode->i_mode |= S_ISGID; | |
670 | mark_inode_dirty(inode); | |
671 | ||
4b11111a MS |
672 | fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); |
673 | if (!fi) { | |
1da177e4 LT |
674 | inode->i_nlink = 0; |
675 | mark_inode_dirty(inode); | |
676 | iput(inode); | |
677 | goto out; | |
678 | } | |
679 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
48d6d8ff | 680 | cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); |
28de7948 | 681 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
48d6d8ff | 682 | cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL); |
1da177e4 LT |
683 | cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY; |
684 | udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); | |
d8c76e6f | 685 | inc_nlink(dir); |
1da177e4 LT |
686 | mark_inode_dirty(dir); |
687 | d_instantiate(dentry, inode); | |
688 | if (fibh.sbh != fibh.ebh) | |
3bf25cb4 JK |
689 | brelse(fibh.ebh); |
690 | brelse(fibh.sbh); | |
1da177e4 | 691 | err = 0; |
28de7948 CG |
692 | |
693 | out: | |
1da177e4 LT |
694 | unlock_kernel(); |
695 | return err; | |
696 | } | |
697 | ||
698 | static int empty_dir(struct inode *dir) | |
699 | { | |
700 | struct fileIdentDesc *fi, cfi; | |
701 | struct udf_fileident_bh fibh; | |
702 | loff_t f_pos; | |
af793295 | 703 | loff_t size = udf_ext0_offset(dir) + dir->i_size; |
1da177e4 | 704 | int block; |
ff116fc8 JK |
705 | kernel_lb_addr eloc; |
706 | uint32_t elen; | |
60448b1d | 707 | sector_t offset; |
28de7948 | 708 | struct extent_position epos = {}; |
48d6d8ff | 709 | struct udf_inode_info *dinfo = UDF_I(dir); |
1da177e4 | 710 | |
af793295 JK |
711 | f_pos = udf_ext0_offset(dir); |
712 | fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); | |
1da177e4 | 713 | |
48d6d8ff | 714 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 715 | fibh.sbh = fibh.ebh = NULL; |
af793295 | 716 | else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, |
4b11111a MS |
717 | &epos, &eloc, &elen, &offset) == |
718 | (EXT_RECORDED_ALLOCATED >> 30)) { | |
1da177e4 | 719 | block = udf_get_lb_pblock(dir->i_sb, eloc, offset); |
cb00ea35 | 720 | if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { |
48d6d8ff | 721 | if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
ff116fc8 | 722 | epos.offset -= sizeof(short_ad); |
48d6d8ff | 723 | else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) |
ff116fc8 | 724 | epos.offset -= sizeof(long_ad); |
4b11111a | 725 | } else |
1da177e4 LT |
726 | offset = 0; |
727 | ||
4b11111a MS |
728 | fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); |
729 | if (!fibh.sbh) { | |
3bf25cb4 | 730 | brelse(epos.bh); |
1da177e4 LT |
731 | return 0; |
732 | } | |
cb00ea35 | 733 | } else { |
3bf25cb4 | 734 | brelse(epos.bh); |
1da177e4 LT |
735 | return 0; |
736 | } | |
737 | ||
af793295 | 738 | while (f_pos < size) { |
cb00ea35 CG |
739 | fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, |
740 | &elen, &offset); | |
cb00ea35 | 741 | if (!fi) { |
1da177e4 | 742 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
743 | brelse(fibh.ebh); |
744 | brelse(fibh.sbh); | |
745 | brelse(epos.bh); | |
1da177e4 LT |
746 | return 0; |
747 | } | |
748 | ||
28de7948 CG |
749 | if (cfi.lengthFileIdent && |
750 | (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) { | |
1da177e4 | 751 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
752 | brelse(fibh.ebh); |
753 | brelse(fibh.sbh); | |
754 | brelse(epos.bh); | |
1da177e4 LT |
755 | return 0; |
756 | } | |
757 | } | |
28de7948 | 758 | |
1da177e4 | 759 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
760 | brelse(fibh.ebh); |
761 | brelse(fibh.sbh); | |
762 | brelse(epos.bh); | |
28de7948 | 763 | |
1da177e4 LT |
764 | return 1; |
765 | } | |
766 | ||
cb00ea35 | 767 | static int udf_rmdir(struct inode *dir, struct dentry *dentry) |
1da177e4 LT |
768 | { |
769 | int retval; | |
cb00ea35 | 770 | struct inode *inode = dentry->d_inode; |
1da177e4 LT |
771 | struct udf_fileident_bh fibh; |
772 | struct fileIdentDesc *fi, cfi; | |
773 | kernel_lb_addr tloc; | |
774 | ||
775 | retval = -ENOENT; | |
776 | lock_kernel(); | |
777 | fi = udf_find_entry(dir, dentry, &fibh, &cfi); | |
778 | if (!fi) | |
779 | goto out; | |
780 | ||
781 | retval = -EIO; | |
782 | tloc = lelb_to_cpu(cfi.icb.extLocation); | |
783 | if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino) | |
784 | goto end_rmdir; | |
785 | retval = -ENOTEMPTY; | |
786 | if (!empty_dir(inode)) | |
787 | goto end_rmdir; | |
788 | retval = udf_delete_entry(dir, fi, &fibh, &cfi); | |
789 | if (retval) | |
790 | goto end_rmdir; | |
791 | if (inode->i_nlink != 2) | |
792 | udf_warning(inode->i_sb, "udf_rmdir", | |
cb00ea35 CG |
793 | "empty directory has nlink != 2 (%d)", |
794 | inode->i_nlink); | |
ce71ec36 | 795 | clear_nlink(inode); |
1da177e4 | 796 | inode->i_size = 0; |
c007c06e | 797 | inode_dec_link_count(dir); |
4b11111a MS |
798 | inode->i_ctime = dir->i_ctime = dir->i_mtime = |
799 | current_fs_time(dir->i_sb); | |
1da177e4 LT |
800 | mark_inode_dirty(dir); |
801 | ||
28de7948 | 802 | end_rmdir: |
1da177e4 | 803 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
804 | brelse(fibh.ebh); |
805 | brelse(fibh.sbh); | |
28de7948 CG |
806 | |
807 | out: | |
1da177e4 LT |
808 | unlock_kernel(); |
809 | return retval; | |
810 | } | |
811 | ||
cb00ea35 | 812 | static int udf_unlink(struct inode *dir, struct dentry *dentry) |
1da177e4 LT |
813 | { |
814 | int retval; | |
cb00ea35 | 815 | struct inode *inode = dentry->d_inode; |
1da177e4 LT |
816 | struct udf_fileident_bh fibh; |
817 | struct fileIdentDesc *fi; | |
818 | struct fileIdentDesc cfi; | |
819 | kernel_lb_addr tloc; | |
820 | ||
821 | retval = -ENOENT; | |
822 | lock_kernel(); | |
823 | fi = udf_find_entry(dir, dentry, &fibh, &cfi); | |
824 | if (!fi) | |
825 | goto out; | |
826 | ||
827 | retval = -EIO; | |
828 | tloc = lelb_to_cpu(cfi.icb.extLocation); | |
829 | if (udf_get_lb_pblock(dir->i_sb, tloc, 0) != inode->i_ino) | |
830 | goto end_unlink; | |
831 | ||
cb00ea35 | 832 | if (!inode->i_nlink) { |
1da177e4 | 833 | udf_debug("Deleting nonexistent file (%lu), %d\n", |
cb00ea35 | 834 | inode->i_ino, inode->i_nlink); |
1da177e4 LT |
835 | inode->i_nlink = 1; |
836 | } | |
837 | retval = udf_delete_entry(dir, fi, &fibh, &cfi); | |
838 | if (retval) | |
839 | goto end_unlink; | |
840 | dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); | |
841 | mark_inode_dirty(dir); | |
9a53c3a7 | 842 | inode_dec_link_count(inode); |
1da177e4 LT |
843 | inode->i_ctime = dir->i_ctime; |
844 | retval = 0; | |
845 | ||
28de7948 | 846 | end_unlink: |
1da177e4 | 847 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
848 | brelse(fibh.ebh); |
849 | brelse(fibh.sbh); | |
28de7948 CG |
850 | |
851 | out: | |
1da177e4 LT |
852 | unlock_kernel(); |
853 | return retval; | |
854 | } | |
855 | ||
cb00ea35 CG |
856 | static int udf_symlink(struct inode *dir, struct dentry *dentry, |
857 | const char *symname) | |
1da177e4 | 858 | { |
cb00ea35 | 859 | struct inode *inode; |
1da177e4 LT |
860 | struct pathComponent *pc; |
861 | char *compstart; | |
862 | struct udf_fileident_bh fibh; | |
28de7948 | 863 | struct extent_position epos = {}; |
1da177e4 LT |
864 | int eoffset, elen = 0; |
865 | struct fileIdentDesc *fi; | |
866 | struct fileIdentDesc cfi; | |
867 | char *ea; | |
868 | int err; | |
869 | int block; | |
b80697c1 | 870 | char *name = NULL; |
1da177e4 | 871 | int namelen; |
6c79e987 | 872 | struct buffer_head *bh; |
48d6d8ff | 873 | struct udf_inode_info *iinfo; |
1da177e4 LT |
874 | |
875 | lock_kernel(); | |
4b11111a MS |
876 | inode = udf_new_inode(dir, S_IFLNK, &err); |
877 | if (!inode) | |
1da177e4 LT |
878 | goto out; |
879 | ||
b80697c1 JK |
880 | name = kmalloc(UDF_NAME_LEN, GFP_NOFS); |
881 | if (!name) { | |
882 | err = -ENOMEM; | |
883 | goto out_no_entry; | |
884 | } | |
885 | ||
48d6d8ff | 886 | iinfo = UDF_I(inode); |
1da177e4 LT |
887 | inode->i_mode = S_IFLNK | S_IRWXUGO; |
888 | inode->i_data.a_ops = &udf_symlink_aops; | |
889 | inode->i_op = &page_symlink_inode_operations; | |
890 | ||
48d6d8ff | 891 | if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { |
ff116fc8 JK |
892 | kernel_lb_addr eloc; |
893 | uint32_t elen; | |
1da177e4 LT |
894 | |
895 | block = udf_new_block(inode->i_sb, inode, | |
48d6d8ff MS |
896 | iinfo->i_location.partitionReferenceNum, |
897 | iinfo->i_location.logicalBlockNum, &err); | |
1da177e4 LT |
898 | if (!block) |
899 | goto out_no_entry; | |
48d6d8ff | 900 | epos.block = iinfo->i_location; |
ff116fc8 JK |
901 | epos.offset = udf_file_entry_alloc_offset(inode); |
902 | epos.bh = NULL; | |
1da177e4 | 903 | eloc.logicalBlockNum = block; |
4b11111a | 904 | eloc.partitionReferenceNum = |
48d6d8ff | 905 | iinfo->i_location.partitionReferenceNum; |
1da177e4 | 906 | elen = inode->i_sb->s_blocksize; |
48d6d8ff | 907 | iinfo->i_lenExtents = elen; |
ff116fc8 | 908 | udf_add_aext(inode, &epos, eloc, elen, 0); |
3bf25cb4 | 909 | brelse(epos.bh); |
1da177e4 LT |
910 | |
911 | block = udf_get_pblock(inode->i_sb, block, | |
48d6d8ff | 912 | iinfo->i_location.partitionReferenceNum, |
4b11111a | 913 | 0); |
ff116fc8 JK |
914 | epos.bh = udf_tread(inode->i_sb, block); |
915 | lock_buffer(epos.bh); | |
916 | memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize); | |
917 | set_buffer_uptodate(epos.bh); | |
918 | unlock_buffer(epos.bh); | |
919 | mark_buffer_dirty_inode(epos.bh, inode); | |
920 | ea = epos.bh->b_data + udf_ext0_offset(inode); | |
48d6d8ff MS |
921 | } else |
922 | ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr; | |
1da177e4 LT |
923 | |
924 | eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode); | |
925 | pc = (struct pathComponent *)ea; | |
926 | ||
cb00ea35 CG |
927 | if (*symname == '/') { |
928 | do { | |
1da177e4 LT |
929 | symname++; |
930 | } while (*symname == '/'); | |
931 | ||
932 | pc->componentType = 1; | |
933 | pc->lengthComponentIdent = 0; | |
934 | pc->componentFileVersionNum = 0; | |
935 | pc += sizeof(struct pathComponent); | |
936 | elen += sizeof(struct pathComponent); | |
937 | } | |
938 | ||
939 | err = -ENAMETOOLONG; | |
940 | ||
cb00ea35 | 941 | while (*symname) { |
1da177e4 LT |
942 | if (elen + sizeof(struct pathComponent) > eoffset) |
943 | goto out_no_entry; | |
944 | ||
945 | pc = (struct pathComponent *)(ea + elen); | |
946 | ||
947 | compstart = (char *)symname; | |
948 | ||
cb00ea35 | 949 | do { |
1da177e4 LT |
950 | symname++; |
951 | } while (*symname && *symname != '/'); | |
952 | ||
953 | pc->componentType = 5; | |
954 | pc->lengthComponentIdent = 0; | |
955 | pc->componentFileVersionNum = 0; | |
cb00ea35 CG |
956 | if (compstart[0] == '.') { |
957 | if ((symname - compstart) == 1) | |
1da177e4 | 958 | pc->componentType = 4; |
4b11111a MS |
959 | else if ((symname - compstart) == 2 && |
960 | compstart[1] == '.') | |
1da177e4 LT |
961 | pc->componentType = 3; |
962 | } | |
963 | ||
cb00ea35 | 964 | if (pc->componentType == 5) { |
28de7948 CG |
965 | namelen = udf_put_filename(inode->i_sb, compstart, name, |
966 | symname - compstart); | |
967 | if (!namelen) | |
1da177e4 LT |
968 | goto out_no_entry; |
969 | ||
4b11111a MS |
970 | if (elen + sizeof(struct pathComponent) + namelen > |
971 | eoffset) | |
1da177e4 LT |
972 | goto out_no_entry; |
973 | else | |
974 | pc->lengthComponentIdent = namelen; | |
975 | ||
976 | memcpy(pc->componentIdent, name, namelen); | |
977 | } | |
978 | ||
979 | elen += sizeof(struct pathComponent) + pc->lengthComponentIdent; | |
980 | ||
cb00ea35 CG |
981 | if (*symname) { |
982 | do { | |
1da177e4 LT |
983 | symname++; |
984 | } while (*symname == '/'); | |
985 | } | |
986 | } | |
987 | ||
3bf25cb4 | 988 | brelse(epos.bh); |
1da177e4 | 989 | inode->i_size = elen; |
48d6d8ff MS |
990 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
991 | iinfo->i_lenAlloc = inode->i_size; | |
1da177e4 LT |
992 | mark_inode_dirty(inode); |
993 | ||
4b11111a MS |
994 | fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); |
995 | if (!fi) | |
1da177e4 LT |
996 | goto out_no_entry; |
997 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
48d6d8ff | 998 | cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location); |
6c79e987 MS |
999 | bh = UDF_SB(inode->i_sb)->s_lvid_bh; |
1000 | if (bh) { | |
4b11111a MS |
1001 | struct logicalVolIntegrityDesc *lvid = |
1002 | (struct logicalVolIntegrityDesc *)bh->b_data; | |
1da177e4 LT |
1003 | struct logicalVolHeaderDesc *lvhd; |
1004 | uint64_t uniqueID; | |
4b11111a MS |
1005 | lvhd = (struct logicalVolHeaderDesc *) |
1006 | lvid->logicalVolContentsUse; | |
1da177e4 | 1007 | uniqueID = le64_to_cpu(lvhd->uniqueID); |
28de7948 CG |
1008 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
1009 | cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); | |
1da177e4 LT |
1010 | if (!(++uniqueID & 0x00000000FFFFFFFFUL)) |
1011 | uniqueID += 16; | |
1012 | lvhd->uniqueID = cpu_to_le64(uniqueID); | |
6c79e987 | 1013 | mark_buffer_dirty(bh); |
1da177e4 LT |
1014 | } |
1015 | udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); | |
c0b34438 | 1016 | if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 1017 | mark_inode_dirty(dir); |
1da177e4 | 1018 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
1019 | brelse(fibh.ebh); |
1020 | brelse(fibh.sbh); | |
1da177e4 LT |
1021 | d_instantiate(dentry, inode); |
1022 | err = 0; | |
1023 | ||
28de7948 | 1024 | out: |
b80697c1 | 1025 | kfree(name); |
1da177e4 LT |
1026 | unlock_kernel(); |
1027 | return err; | |
1028 | ||
28de7948 | 1029 | out_no_entry: |
9a53c3a7 | 1030 | inode_dec_link_count(inode); |
1da177e4 LT |
1031 | iput(inode); |
1032 | goto out; | |
1033 | } | |
1034 | ||
cb00ea35 CG |
1035 | static int udf_link(struct dentry *old_dentry, struct inode *dir, |
1036 | struct dentry *dentry) | |
1da177e4 LT |
1037 | { |
1038 | struct inode *inode = old_dentry->d_inode; | |
1039 | struct udf_fileident_bh fibh; | |
1040 | struct fileIdentDesc cfi, *fi; | |
1041 | int err; | |
6c79e987 | 1042 | struct buffer_head *bh; |
1da177e4 LT |
1043 | |
1044 | lock_kernel(); | |
cb00ea35 | 1045 | if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) { |
1da177e4 LT |
1046 | unlock_kernel(); |
1047 | return -EMLINK; | |
1048 | } | |
1049 | ||
4b11111a MS |
1050 | fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err); |
1051 | if (!fi) { | |
1da177e4 LT |
1052 | unlock_kernel(); |
1053 | return err; | |
1054 | } | |
1055 | cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); | |
c0b34438 | 1056 | cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location); |
6c79e987 MS |
1057 | bh = UDF_SB(inode->i_sb)->s_lvid_bh; |
1058 | if (bh) { | |
4b11111a MS |
1059 | struct logicalVolIntegrityDesc *lvid = |
1060 | (struct logicalVolIntegrityDesc *)bh->b_data; | |
1da177e4 LT |
1061 | struct logicalVolHeaderDesc *lvhd; |
1062 | uint64_t uniqueID; | |
4b11111a MS |
1063 | lvhd = (struct logicalVolHeaderDesc *) |
1064 | (lvid->logicalVolContentsUse); | |
1da177e4 | 1065 | uniqueID = le64_to_cpu(lvhd->uniqueID); |
28de7948 CG |
1066 | *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse = |
1067 | cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL); | |
1da177e4 LT |
1068 | if (!(++uniqueID & 0x00000000FFFFFFFFUL)) |
1069 | uniqueID += 16; | |
1070 | lvhd->uniqueID = cpu_to_le64(uniqueID); | |
6c79e987 | 1071 | mark_buffer_dirty(bh); |
1da177e4 LT |
1072 | } |
1073 | udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL); | |
c0b34438 | 1074 | if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 1075 | mark_inode_dirty(dir); |
28de7948 | 1076 | |
1da177e4 | 1077 | if (fibh.sbh != fibh.ebh) |
3bf25cb4 JK |
1078 | brelse(fibh.ebh); |
1079 | brelse(fibh.sbh); | |
d8c76e6f | 1080 | inc_nlink(inode); |
1da177e4 LT |
1081 | inode->i_ctime = current_fs_time(inode->i_sb); |
1082 | mark_inode_dirty(inode); | |
1083 | atomic_inc(&inode->i_count); | |
1084 | d_instantiate(dentry, inode); | |
1085 | unlock_kernel(); | |
28de7948 | 1086 | |
1da177e4 LT |
1087 | return 0; |
1088 | } | |
1089 | ||
1090 | /* Anybody can rename anything with this: the permission checks are left to the | |
1091 | * higher-level routines. | |
1092 | */ | |
cb00ea35 CG |
1093 | static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, |
1094 | struct inode *new_dir, struct dentry *new_dentry) | |
1da177e4 | 1095 | { |
cb00ea35 CG |
1096 | struct inode *old_inode = old_dentry->d_inode; |
1097 | struct inode *new_inode = new_dentry->d_inode; | |
1da177e4 | 1098 | struct udf_fileident_bh ofibh, nfibh; |
4b11111a MS |
1099 | struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL; |
1100 | struct fileIdentDesc ocfi, ncfi; | |
1da177e4 LT |
1101 | struct buffer_head *dir_bh = NULL; |
1102 | int retval = -ENOENT; | |
1103 | kernel_lb_addr tloc; | |
48d6d8ff | 1104 | struct udf_inode_info *old_iinfo = UDF_I(old_inode); |
1da177e4 LT |
1105 | |
1106 | lock_kernel(); | |
4b11111a MS |
1107 | ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi); |
1108 | if (ofi) { | |
1da177e4 | 1109 | if (ofibh.sbh != ofibh.ebh) |
3bf25cb4 JK |
1110 | brelse(ofibh.ebh); |
1111 | brelse(ofibh.sbh); | |
1da177e4 LT |
1112 | } |
1113 | tloc = lelb_to_cpu(ocfi.icb.extLocation); | |
1114 | if (!ofi || udf_get_lb_pblock(old_dir->i_sb, tloc, 0) | |
cb00ea35 | 1115 | != old_inode->i_ino) |
1da177e4 LT |
1116 | goto end_rename; |
1117 | ||
1118 | nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi); | |
cb00ea35 CG |
1119 | if (nfi) { |
1120 | if (!new_inode) { | |
1da177e4 | 1121 | if (nfibh.sbh != nfibh.ebh) |
3bf25cb4 JK |
1122 | brelse(nfibh.ebh); |
1123 | brelse(nfibh.sbh); | |
1da177e4 LT |
1124 | nfi = NULL; |
1125 | } | |
1126 | } | |
cb00ea35 | 1127 | if (S_ISDIR(old_inode->i_mode)) { |
7f3fbd08 | 1128 | int offset = udf_ext0_offset(old_inode); |
1da177e4 | 1129 | |
cb00ea35 | 1130 | if (new_inode) { |
1da177e4 LT |
1131 | retval = -ENOTEMPTY; |
1132 | if (!empty_dir(new_inode)) | |
1133 | goto end_rename; | |
1134 | } | |
1135 | retval = -EIO; | |
48d6d8ff | 1136 | if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) { |
4b11111a | 1137 | dir_fi = udf_get_fileident( |
48d6d8ff MS |
1138 | old_iinfo->i_ext.i_data - |
1139 | (old_iinfo->i_efe ? | |
4b11111a MS |
1140 | sizeof(struct extendedFileEntry) : |
1141 | sizeof(struct fileEntry)), | |
1142 | old_inode->i_sb->s_blocksize, &offset); | |
cb00ea35 | 1143 | } else { |
1da177e4 LT |
1144 | dir_bh = udf_bread(old_inode, 0, 0, &retval); |
1145 | if (!dir_bh) | |
1146 | goto end_rename; | |
4b11111a MS |
1147 | dir_fi = udf_get_fileident(dir_bh->b_data, |
1148 | old_inode->i_sb->s_blocksize, &offset); | |
1da177e4 LT |
1149 | } |
1150 | if (!dir_fi) | |
1151 | goto end_rename; | |
1152 | tloc = lelb_to_cpu(dir_fi->icb.extLocation); | |
4b11111a MS |
1153 | if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) != |
1154 | old_dir->i_ino) | |
1da177e4 LT |
1155 | goto end_rename; |
1156 | ||
1157 | retval = -EMLINK; | |
4b11111a MS |
1158 | if (!new_inode && |
1159 | new_dir->i_nlink >= | |
1160 | (256 << sizeof(new_dir->i_nlink)) - 1) | |
1da177e4 LT |
1161 | goto end_rename; |
1162 | } | |
cb00ea35 | 1163 | if (!nfi) { |
4b11111a MS |
1164 | nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, |
1165 | &retval); | |
1da177e4 LT |
1166 | if (!nfi) |
1167 | goto end_rename; | |
1168 | } | |
1169 | ||
1170 | /* | |
1171 | * Like most other Unix systems, set the ctime for inodes on a | |
1172 | * rename. | |
1173 | */ | |
1174 | old_inode->i_ctime = current_fs_time(old_inode->i_sb); | |
1175 | mark_inode_dirty(old_inode); | |
1176 | ||
1177 | /* | |
1178 | * ok, that's it | |
1179 | */ | |
1180 | ncfi.fileVersionNum = ocfi.fileVersionNum; | |
1181 | ncfi.fileCharacteristics = ocfi.fileCharacteristics; | |
1182 | memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(long_ad)); | |
1183 | udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL); | |
1184 | ||
1185 | /* The old fid may have moved - find it again */ | |
1186 | ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi); | |
1187 | udf_delete_entry(old_dir, ofi, &ofibh, &ocfi); | |
1188 | ||
cb00ea35 | 1189 | if (new_inode) { |
1da177e4 | 1190 | new_inode->i_ctime = current_fs_time(new_inode->i_sb); |
9a53c3a7 | 1191 | inode_dec_link_count(new_inode); |
1da177e4 LT |
1192 | } |
1193 | old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); | |
1194 | mark_inode_dirty(old_dir); | |
1195 | ||
cb00ea35 | 1196 | if (dir_fi) { |
c0b34438 | 1197 | dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location); |
4b11111a MS |
1198 | udf_update_tag((char *)dir_fi, |
1199 | (sizeof(struct fileIdentDesc) + | |
1200 | le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3); | |
48d6d8ff | 1201 | if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) |
1da177e4 | 1202 | mark_inode_dirty(old_inode); |
4b11111a | 1203 | else |
1da177e4 | 1204 | mark_buffer_dirty_inode(dir_bh, old_inode); |
4b11111a | 1205 | |
9a53c3a7 | 1206 | inode_dec_link_count(old_dir); |
4b11111a | 1207 | if (new_inode) |
9a53c3a7 | 1208 | inode_dec_link_count(new_inode); |
4b11111a | 1209 | else { |
d8c76e6f | 1210 | inc_nlink(new_dir); |
1da177e4 LT |
1211 | mark_inode_dirty(new_dir); |
1212 | } | |
1213 | } | |
1214 | ||
cb00ea35 | 1215 | if (ofi) { |
1da177e4 | 1216 | if (ofibh.sbh != ofibh.ebh) |
3bf25cb4 JK |
1217 | brelse(ofibh.ebh); |
1218 | brelse(ofibh.sbh); | |
1da177e4 LT |
1219 | } |
1220 | ||
1221 | retval = 0; | |
1222 | ||
28de7948 | 1223 | end_rename: |
3bf25cb4 | 1224 | brelse(dir_bh); |
cb00ea35 | 1225 | if (nfi) { |
1da177e4 | 1226 | if (nfibh.sbh != nfibh.ebh) |
3bf25cb4 JK |
1227 | brelse(nfibh.ebh); |
1228 | brelse(nfibh.sbh); | |
1da177e4 LT |
1229 | } |
1230 | unlock_kernel(); | |
28de7948 | 1231 | |
1da177e4 LT |
1232 | return retval; |
1233 | } | |
1234 | ||
c5ef1c42 | 1235 | const struct inode_operations udf_dir_inode_operations = { |
28de7948 CG |
1236 | .lookup = udf_lookup, |
1237 | .create = udf_create, | |
1238 | .link = udf_link, | |
1239 | .unlink = udf_unlink, | |
1240 | .symlink = udf_symlink, | |
1241 | .mkdir = udf_mkdir, | |
1242 | .rmdir = udf_rmdir, | |
1243 | .mknod = udf_mknod, | |
1244 | .rename = udf_rename, | |
1da177e4 | 1245 | }; |