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