xref: /titanic_51/usr/src/uts/common/fs/udfs/udf_dir.c (revision 87ea2c5cd0f3df494543903cf61b4e5c10cc99b7)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 #include <sys/types.h>
26 #include <sys/t_lock.h>
27 #include <sys/param.h>
28 #include <sys/time.h>
29 #include <sys/systm.h>
30 #include <sys/sysmacros.h>
31 #include <sys/resource.h>
32 #include <sys/signal.h>
33 #include <sys/cred.h>
34 #include <sys/user.h>
35 #include <sys/buf.h>
36 #include <sys/vfs.h>
37 #include <sys/stat.h>
38 #include <sys/vnode.h>
39 #include <sys/mode.h>
40 #include <sys/proc.h>
41 #include <sys/disp.h>
42 #include <sys/file.h>
43 #include <sys/fcntl.h>
44 #include <sys/flock.h>
45 #include <sys/kmem.h>
46 #include <sys/uio.h>
47 #include <sys/dnlc.h>
48 #include <sys/conf.h>
49 #include <sys/errno.h>
50 #include <sys/mman.h>
51 #include <sys/fbuf.h>
52 #include <sys/pathname.h>
53 #include <sys/debug.h>
54 #include <sys/vmsystm.h>
55 #include <sys/cmn_err.h>
56 #include <sys/dirent.h>
57 #include <sys/errno.h>
58 #include <sys/modctl.h>
59 #include <sys/statvfs.h>
60 #include <sys/mount.h>
61 #include <sys/sunddi.h>
62 #include <sys/bootconf.h>
63 #include <sys/policy.h>
64 
65 #include <vm/hat.h>
66 #include <vm/page.h>
67 #include <vm/pvn.h>
68 #include <vm/as.h>
69 #include <vm/seg.h>
70 #include <vm/seg_map.h>
71 #include <vm/seg_kmem.h>
72 #include <vm/seg_vn.h>
73 #include <vm/rm.h>
74 #include <vm/page.h>
75 #include <sys/swap.h>
76 
77 
78 #include <fs/fs_subr.h>
79 
80 
81 #include <sys/fs/udf_volume.h>
82 #include <sys/fs/udf_inode.h>
83 
84 
85 struct slot {
86 	enum	{NONE, COMPACT, FOUND, EXIST} status;
87 	off_t	offset;		/* offset of area with free space */
88 	int	size;		/* size of area at slotoffset */
89 	struct	fbuf *fbp;	/* dir buf where slot is */
90 	struct file_id *ep;	/* pointer to slot */
91 	off_t	endoff;		/* last useful location found in search */
92 };
93 
94 
95 int32_t ud_dircheckforname(struct ud_inode *, char *, int,
96 		struct slot *, struct ud_inode **, uint8_t *, struct cred *);
97 int32_t ud_dirempty(struct ud_inode *, uint64_t, struct cred *);
98 int32_t str2cmp(char *, int32_t, char *, int32_t, char *, int32_t);
99 int32_t ud_dircheckpath(int32_t, struct ud_inode *, struct cred *);
100 int32_t ud_dirmakeinode(struct ud_inode *, struct ud_inode **,
101 	struct vattr *, enum de_op, struct cred *);
102 int32_t ud_diraddentry(struct ud_inode *, char *,
103 	enum de_op, int, struct slot *, struct ud_inode *,
104 	struct ud_inode *, struct cred *);
105 int32_t ud_dirmakedirect(struct ud_inode *, struct ud_inode *, struct cred *);
106 int32_t ud_dirrename(struct ud_inode *, struct ud_inode *,
107 	struct ud_inode *, struct ud_inode *, char *, uint8_t *,
108 	struct slot *, struct cred *);
109 int32_t ud_dirprepareentry(struct ud_inode *,
110 	struct slot *, uint8_t *, struct cred *);
111 int32_t ud_dirfixdotdot(struct ud_inode *, struct ud_inode *,
112 		struct ud_inode *);
113 int32_t ud_write_fid(struct ud_inode *, struct slot *, uint8_t *);
114 
115 int
116 ud_dirlook(struct ud_inode *dip,
117 	char *namep, struct ud_inode **ipp, struct cred *cr, int32_t skipdnlc)
118 {
119 	struct udf_vfs *udf_vfsp;
120 	int32_t error = 0, namelen, adhoc_search;
121 	u_offset_t offset, adhoc_offset, dirsize, end;
122 	struct vnode *dvp, *vp;
123 	struct fbuf *fbp;
124 	struct file_id *fid;
125 	uint8_t *fname, dummy[3];
126 	int32_t id_len, doingchk;
127 	uint32_t old_loc;
128 	uint16_t old_prn;
129 
130 	uint8_t *dname;
131 	uint8_t *buf = NULL;
132 
133 	ud_printf("ud_dirlook\n");
134 
135 	udf_vfsp = dip->i_udf;
136 
137 restart:
138 	doingchk = 0;
139 	old_prn = 0xFFFF;
140 	old_loc = 0;
141 	dvp = ITOV(dip);
142 	/*
143 	 * Check accessibility of directory.
144 	 */
145 	if (dip->i_type != VDIR) {
146 		return (ENOTDIR);
147 	}
148 	if (error = ud_iaccess(dip, IEXEC, cr, 1)) {
149 		return (error);
150 	}
151 
152 	/*
153 	 * Null component name is synonym for directory being searched.
154 	 */
155 	if (*namep == '\0') {
156 		VN_HOLD(dvp);
157 		*ipp = dip;
158 		return (0);
159 	}
160 	namelen = strlen(namep);
161 	if ((namelen == 1) &&
162 	    (namep[0] == '.') && (namep[1] == '\0')) {
163 		/* Current directory */
164 		VN_HOLD(dvp);
165 		*ipp = dip;
166 		dnlc_enter(dvp, namep, ITOV(*ipp));
167 		return (0);
168 	}
169 
170 	if ((!skipdnlc) && (vp = dnlc_lookup(dvp, namep))) {
171 		/* vp is already held from dnlc_lookup */
172 
173 		*ipp = VTOI(vp);
174 		return (0);
175 	}
176 
177 	dname = kmem_zalloc(1024, KM_SLEEP);
178 	buf = kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP);
179 
180 	/*
181 	 * Read lock the inode we are searching.  You will notice that we
182 	 * didn't hold the read lock while searching the dnlc.  This means
183 	 * that the entry could now be in the dnlc.  This doesn't cause any
184 	 * problems because dnlc_enter won't add an entry if it is already
185 	 * there.
186 	 */
187 	rw_enter(&dip->i_rwlock, RW_READER);
188 
189 	/*
190 	 * Take care to look at dip->i_diroff only once, as it
191 	 * may be changing due to other threads/cpus.
192 	 */
193 
194 recheck:
195 	offset = dip->i_diroff;
196 	end = dirsize = dip->i_size;
197 
198 	if (offset > dirsize) {
199 		offset = 0;
200 	}
201 	adhoc_offset = offset;
202 	adhoc_search = (offset == 0) ? 1 : 2;
203 
204 	fbp = NULL;
205 
206 	while (adhoc_search--) {
207 		while (offset < end) {
208 			error = ud_get_next_fid(dip, &fbp,
209 			    offset, &fid, &fname, buf);
210 			if (error != 0) {
211 				break;
212 			}
213 			if ((fid->fid_flags & FID_DELETED) == 0) {
214 				if (fid->fid_flags & FID_PARENT) {
215 					id_len = 2;
216 					fname = dummy;
217 					dummy[0] = '.';
218 					dummy[1] = '.';
219 					dummy[2] = '\0';
220 				} else {
221 					if ((error = ud_uncompress(
222 					    fid->fid_idlen, &id_len,
223 					    fname, dname)) != 0) {
224 						break;
225 					}
226 					fname = (uint8_t *)dname;
227 					fname[id_len] = '\0';
228 				}
229 				if ((namelen == id_len) &&
230 				    (strncmp(namep, (caddr_t)fname,
231 				    namelen) == 0)) {
232 					uint32_t loc;
233 					uint16_t prn;
234 
235 
236 					loc = SWAP_32(fid->fid_icb.lad_ext_loc);
237 					prn = SWAP_16(fid->fid_icb.lad_ext_prn);
238 					dip->i_diroff = offset + FID_LEN(fid);
239 
240 					if (doingchk) {
241 						if ((loc == old_loc) &&
242 						    (prn == old_prn)) {
243 							goto checkok;
244 						} else {
245 							if (fbp != NULL) {
246 								fbrelse(fbp,
247 								    S_READ);
248 								fbp = NULL;
249 							}
250 							VN_RELE(ITOV(*ipp));
251 							rw_exit(&dip->i_rwlock);
252 							goto restart;
253 						}
254 						/* NOTREACHED */
255 					}
256 
257 					if (namelen == 2 &&
258 					    fname[0] == '.' &&
259 					    fname[1] == '.') {
260 
261 						struct timespec32 omtime;
262 
263 						omtime = dip->i_mtime;
264 						rw_exit(&dip->i_rwlock);
265 
266 						error = ud_iget(dip->i_vfs, prn,
267 						    loc, ipp, NULL, cr);
268 
269 						rw_enter(&dip->i_rwlock,
270 						    RW_READER);
271 
272 						if (error) {
273 							goto done;
274 						}
275 
276 						if ((omtime.tv_sec !=
277 						    dip->i_mtime.tv_sec) ||
278 						    (omtime.tv_nsec !=
279 						    dip->i_mtime.tv_nsec)) {
280 
281 							doingchk = 1;
282 							old_prn = prn;
283 							old_loc = loc;
284 							dip->i_diroff = 0;
285 							if (fbp != NULL) {
286 								fbrelse(fbp,
287 								    S_READ);
288 								fbp = NULL;
289 							}
290 							goto recheck;
291 						}
292 					} else {
293 
294 						error = ud_iget(dip->i_vfs, prn,
295 						    loc, ipp, NULL, cr);
296 					}
297 checkok:
298 					if (error == 0) {
299 						dnlc_enter(dvp, namep,
300 						    ITOV(*ipp));
301 					}
302 					goto done;
303 				}
304 			}
305 			offset += FID_LEN(fid);
306 		}
307 		if (fbp != NULL) {
308 			fbrelse(fbp, S_READ);
309 			fbp = NULL;
310 		}
311 		end = adhoc_offset;
312 		offset = 0;
313 	}
314 	error = ENOENT;
315 done:
316 	kmem_free(buf, udf_vfsp->udf_lbsize);
317 	kmem_free(dname, 1024);
318 	if (fbp != NULL) {
319 		fbrelse(fbp, S_READ);
320 	}
321 	rw_exit(&dip->i_rwlock);
322 	return (error);
323 }
324 
325 int
326 ud_direnter(
327 	struct ud_inode *tdp,
328 	char *namep,
329 	enum de_op op,
330 	struct ud_inode *sdp,
331 	struct ud_inode *sip,
332 	struct vattr *vap,
333 	struct ud_inode **ipp,
334 	struct cred *cr,
335 	caller_context_t *ctp)
336 {
337 	struct udf_vfs *udf_vfsp;
338 	struct ud_inode *tip;
339 	struct slot slot;
340 	int32_t namlen, err;
341 	char *s;
342 
343 	uint8_t *buf = NULL;
344 
345 	ud_printf("ud_direnter\n");
346 
347 	udf_vfsp = tdp->i_udf;
348 	/* don't allow '/' characters in pathname component */
349 	for (s = namep, namlen = 0; *s; s++, namlen++) {
350 		if (*s == '/') {
351 			return (EACCES);
352 		}
353 	}
354 
355 	if (namlen == 0) {
356 		cmn_err(CE_WARN, "name length == 0 in ud_direnter");
357 		return (EINVAL);
358 	}
359 
360 	ASSERT(RW_WRITE_HELD(&tdp->i_rwlock));
361 	/*
362 	 * If name is "." or ".." then if this is a create look it up
363 	 * and return EEXIST.  Rename or link TO "." or ".." is forbidden.
364 	 */
365 	if (namep[0] == '.' &&
366 	    (namlen == 1 || (namlen == 2 && namep[1] == '.'))) {
367 		if (op == DE_RENAME) {
368 			return (EINVAL);	/* *SIGH* should be ENOTEMPTY */
369 		}
370 		if (ipp) {
371 			/*
372 			 * ud_dirlook will acquire the i_rwlock
373 			 */
374 			rw_exit(&tdp->i_rwlock);
375 			if (err = ud_dirlook(tdp, namep, ipp, cr, 0)) {
376 				rw_enter(&tdp->i_rwlock, RW_WRITER);
377 				return (err);
378 			}
379 			rw_enter(&tdp->i_rwlock, RW_WRITER);
380 		}
381 		return (EEXIST);
382 	}
383 
384 	tip = NULL;
385 	slot.status = NONE;
386 	slot.offset = 0;
387 	slot.size = 0;
388 	slot.fbp = NULL;
389 	slot.ep = NULL;
390 	slot.endoff = 0;
391 
392 	/*
393 	 * For link and rename lock the source entry and check the link count
394 	 * to see if it has been removed while it was unlocked.  If not, we
395 	 * increment the link count and force the inode to disk to make sure
396 	 * that it is there before any directory entry that points to it.
397 	 */
398 	if (op == DE_LINK || op == DE_RENAME) {
399 		rw_enter(&sip->i_contents, RW_WRITER);
400 		if (sip->i_nlink == 0) {
401 			rw_exit(&sip->i_contents);
402 			return (ENOENT);
403 		}
404 		if (sip->i_nlink == MAXLINK) {
405 			rw_exit(&sip->i_contents);
406 			return (EMLINK);
407 		}
408 
409 		sip->i_nlink++;
410 		mutex_enter(&sip->i_tlock);
411 		sip->i_flag |= ICHG;
412 		mutex_exit(&sip->i_tlock);
413 		ud_iupdat(sip, 1);
414 		rw_exit(&sip->i_contents);
415 	}
416 	/*
417 	 * If target directory has not been removed, then we can consider
418 	 * allowing file to be created.
419 	 */
420 	if (tdp->i_nlink == 0) {
421 		err = ENOENT;
422 		goto out2;
423 	}
424 	/*
425 	 * Check accessibility of directory.
426 	 */
427 	if (tdp->i_type != VDIR) {
428 		err = ENOTDIR;
429 		goto out2;
430 	}
431 	/*
432 	 * Execute access is required to search the directory.
433 	 */
434 	if (err = ud_iaccess(tdp, IEXEC, cr, 1)) {
435 		goto out2;
436 	}
437 	/*
438 	 * If this is a rename of a directory and the parent is
439 	 * different (".." must be changed), then the source
440 	 * directory must not be in the directory hierarchy
441 	 * above the target, as this would orphan everything
442 	 * below the source directory.  Also the user must have
443 	 * write permission in the source so as to be able to
444 	 * change "..".
445 	 */
446 	if (op == DE_RENAME) {
447 		if (sip == tdp) {
448 			err = EINVAL;
449 			goto out2;
450 		}
451 		rw_enter(&sip->i_contents, RW_READER);
452 		if ((sip->i_type == VDIR) && (sdp != tdp)) {
453 			uint32_t blkno;
454 
455 			if ((err = ud_iaccess(sip, IWRITE, cr, 0))) {
456 				rw_exit(&sip->i_contents);
457 				goto out2;
458 			}
459 			blkno = sip->i_icb_lbano;
460 			rw_exit(&sip->i_contents);
461 			if ((err = ud_dircheckpath(blkno, tdp, cr))) {
462 				goto out2;
463 			}
464 		} else {
465 			rw_exit(&sip->i_contents);
466 		}
467 	}
468 
469 	/*
470 	 * Search for the entry. Return VN_HELD tip if found.
471 	 */
472 	buf = kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP);
473 	rw_enter(&tdp->i_contents, RW_WRITER);
474 	if (err = ud_dircheckforname(tdp,
475 	    namep, namlen, &slot, &tip, buf, cr)) {
476 		goto out;
477 	}
478 	if (tip) {
479 		switch (op) {
480 			case DE_CREATE :
481 			case DE_MKDIR :
482 				if (ipp) {
483 					*ipp = tip;
484 					err = EEXIST;
485 				} else {
486 					VN_RELE(ITOV(tip));
487 				}
488 				break;
489 			case DE_RENAME :
490 				err = ud_dirrename(sdp, sip, tdp, tip,
491 				    namep, buf, &slot, cr);
492 				/*
493 				 * We used to VN_RELE() here, but this
494 				 * was moved down so that we could send
495 				 * a vnevent after the locks were dropped.
496 				 */
497 				break;
498 			case DE_LINK :
499 				/*
500 				 * Can't link to an existing file.
501 				 */
502 				VN_RELE(ITOV(tip));
503 				err = EEXIST;
504 				break;
505 		}
506 	} else {
507 		/*
508 		 * The entry does not exist. Check write permission in
509 		 * directory to see if entry can be created.
510 		 */
511 		if (err = ud_iaccess(tdp, IWRITE, cr, 0)) {
512 			goto out;
513 		}
514 		if ((op == DE_CREATE) || (op == DE_MKDIR)) {
515 			/*
516 			 * Make new inode and directory entry as required.
517 			 */
518 			if (err = ud_dirmakeinode(tdp, &sip, vap, op, cr))
519 				goto out;
520 		}
521 		if (err = ud_diraddentry(tdp, namep, op,
522 		    namlen, &slot, sip, sdp, cr)) {
523 			if ((op == DE_CREATE) || (op == DE_MKDIR)) {
524 				/*
525 				 * Unmake the inode we just made.
526 				 */
527 				rw_enter(&sip->i_contents, RW_WRITER);
528 				if (sip->i_type == VDIR) {
529 					tdp->i_nlink--;
530 				}
531 				sip->i_nlink = 0;
532 				mutex_enter(&sip->i_tlock);
533 				sip->i_flag |= ICHG;
534 				mutex_exit(&sip->i_tlock);
535 				rw_exit(&sip->i_contents);
536 				VN_RELE(ITOV(sip));
537 				sip = NULL;
538 			}
539 		} else if (ipp) {
540 			*ipp = sip;
541 		} else if ((op == DE_CREATE) || (op == DE_MKDIR)) {
542 			VN_RELE(ITOV(sip));
543 		}
544 	}
545 out:
546 	if (buf != NULL) {
547 		kmem_free(buf, udf_vfsp->udf_lbsize);
548 	}
549 	if (slot.fbp) {
550 		fbrelse(slot.fbp, S_OTHER);
551 	}
552 	rw_exit(&tdp->i_contents);
553 
554 	if (op == DE_RENAME) {
555 		/*
556 		 * If it's all good, send events after locks are dropped
557 		 * but before vnodes are released.
558 		 */
559 		if (err == 0) {
560 			if (tip) {
561 				vnevent_rename_dest(ITOV(tip), ITOV(tdp),
562 				    namep, ctp);
563 			}
564 
565 			if (sdp != tdp) {
566 				vnevent_rename_dest_dir(ITOV(tdp), ctp);
567 			}
568 		}
569 
570 		/*
571 		 * The following VN_RELE() was moved from the
572 		 * DE_RENAME case above
573 		 */
574 		if (tip) {
575 			VN_RELE(ITOV(tip));
576 		}
577 	}
578 
579 out2:
580 	if (err && ((op == DE_LINK) || (op == DE_RENAME))) {
581 		/*
582 		 * Undo bumped link count.
583 		 */
584 		rw_enter(&sip->i_contents, RW_WRITER);
585 		sip->i_nlink--;
586 		rw_exit(&sip->i_contents);
587 
588 		mutex_enter(&sip->i_tlock);
589 		sip->i_flag |= ICHG;
590 		mutex_exit(&sip->i_tlock);
591 	}
592 	return (err);
593 }
594 
595 /*
596  * Locking i_contents in this
597  * function seems to be really weird
598  */
599 int
600 ud_dirremove(
601 	struct ud_inode *dp,
602 	char *namep,
603 	struct ud_inode *oip,
604 	struct vnode *cdir,
605 	enum dr_op op,
606 	struct cred *cr,
607 	caller_context_t *ctp)
608 {
609 	struct udf_vfs *udf_vfsp;
610 	int32_t namelen, err = 0;
611 	struct slot slot;
612 	struct ud_inode *ip;
613 	mode_t mode;
614 	struct file_id *fid;
615 	uint8_t *buf = NULL;
616 	uint32_t tbno;
617 
618 	ud_printf("ud_dirremove\n");
619 
620 	ASSERT(RW_WRITE_HELD(&dp->i_rwlock));
621 
622 	udf_vfsp = dp->i_udf;
623 	namelen = (int)strlen(namep);
624 	if (namelen == 0) {
625 		cmn_err(CE_WARN, "name length == 0 in ud_dirremove");
626 		return (EINVAL);
627 	}
628 
629 	/*
630 	 * return err when removing . and ..
631 	 */
632 	if (namep[0] == '.') {
633 		if (namelen == 1) {
634 			return (EINVAL);
635 		} else if (namelen == 2 && namep[1] == '.') {
636 			return (EEXIST);	/* SIGH should be ENOTEMPTY */
637 		}
638 	}
639 
640 	ASSERT(RW_WRITE_HELD(&dp->i_rwlock));
641 
642 	/*
643 	 * Check accessibility of directory.
644 	 */
645 	if (dp->i_type != VDIR) {
646 		return (ENOTDIR);
647 	}
648 
649 	ip = NULL;
650 	slot.status = FOUND;	/* don't need to look for empty slot */
651 	slot.offset = 0;
652 	slot.size = 0;
653 	slot.fbp = NULL;
654 	slot.ep = NULL;
655 	slot.endoff = 0;
656 	/*
657 	 * Execute access is required to search the directory.
658 	 * Access for write is interpreted as allowing
659 	 * deletion of files in the directory.
660 	 */
661 	if (err = ud_iaccess(dp, IEXEC|IWRITE, cr, 1)) {
662 		return (err);
663 	}
664 
665 	buf = (uint8_t *)kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP);
666 
667 	rw_enter(&dp->i_contents, RW_WRITER);
668 
669 	if (err = ud_dircheckforname(dp, namep, namelen, &slot, &ip,
670 	    buf, cr)) {
671 		goto out_novfs;
672 	}
673 	if (ip == NULL) {
674 		err = ENOENT;
675 		goto out_novfs;
676 	}
677 	if (oip && oip != ip) {
678 		err = ENOENT;
679 		goto out_novfs;
680 	}
681 
682 	if ((mode = ip->i_type) == VDIR) {
683 		/*
684 		 * vn_vfswlock() prevents races between mount and rmdir.
685 		 */
686 		if (vn_vfswlock(ITOV(ip))) {
687 			err = EBUSY;
688 			goto out_novfs;
689 		}
690 		if (vn_mountedvfs(ITOV(ip)) != NULL && op != DR_RENAME) {
691 			err = EBUSY;
692 			goto out;
693 		}
694 		/*
695 		 * If we are removing a directory, get a lock on it.
696 		 * If the directory is empty, it will stay empty until
697 		 * we can remove it.
698 		 */
699 		rw_enter(&ip->i_rwlock, RW_READER);
700 	}
701 	/* We must be holding i_contents */
702 	rw_enter(&ip->i_contents, RW_READER);
703 
704 	if (err = ud_sticky_remove_access(dp, ip, cr)) {
705 		rw_exit(&ip->i_contents);
706 		if (mode == VDIR) {
707 			rw_exit(&ip->i_rwlock);
708 		}
709 		goto out;
710 	}
711 	if (op == DR_RMDIR) {
712 		/*
713 		 * For rmdir(2), some special checks are required.
714 		 * (a) Don't remove any alias of the parent (e.g. ".").
715 		 * (b) Don't remove the current directory.
716 		 * (c) Make sure the entry is (still) a directory.
717 		 * (d) Make sure the directory is empty.
718 		 */
719 
720 		if (dp == ip || ITOV(ip) == cdir) {
721 			err = EINVAL;
722 		} else if (ip->i_type != VDIR) {
723 			err = ENOTDIR;
724 		} else if ((ip->i_nlink != 1) ||
725 		    (!ud_dirempty(ip, dp->i_uniqid, cr))) {
726 			/*
727 			 * Directories do not have an
728 			 * entry for "." so only one link
729 			 * will be there
730 			 */
731 			err = EEXIST;	/* SIGH should be ENOTEMPTY */
732 		}
733 		if (err) {
734 			rw_exit(&ip->i_contents);
735 			if (mode == VDIR) {
736 				rw_exit(&ip->i_rwlock);
737 			}
738 			goto out;
739 		}
740 	} else if (op == DR_REMOVE)  {
741 		/*
742 		 * unlink(2) requires a different check: allow only
743 		 * privileged processes to unlink a directory.
744 		 */
745 		struct vnode *vp = ITOV(ip);
746 
747 		if (vp->v_type == VDIR &&
748 		    secpolicy_fs_linkdir(cr, vp->v_vfsp)) {
749 			err = EPERM;
750 			rw_exit(&ip->i_contents);
751 			rw_exit(&ip->i_rwlock);
752 			goto out;
753 		}
754 	}
755 	rw_exit(&ip->i_contents);
756 
757 	/*
758 	 * Remove the cache'd entry, if any.
759 	 */
760 	dnlc_remove(ITOV(dp), namep);
761 
762 	/*
763 	 * We can collapse all the directory
764 	 * entries that are deleted into one big entry
765 	 * but the better way is to
766 	 * defer it till next directory entry
767 	 * creation. where we can do this
768 	 * in a more efficient way
769 	 */
770 	fid = slot.ep;
771 
772 	/*
773 	 * If this is the last entry
774 	 * just truncate the file instead
775 	 * of marking it deleted
776 	 */
777 	if ((slot.offset + FID_LEN(fid)) == dp->i_size) {
778 		fbrelse(slot.fbp, S_OTHER);
779 		if ((err = ud_itrunc(dp, slot.offset, 0, cr)) != 0) {
780 			goto out;
781 		}
782 	} else {
783 		fid->fid_flags |= FID_DELETED;
784 
785 		if ((err = ud_ip_off2bno(dp, slot.offset, &tbno)) != 0) {
786 			goto out;
787 		}
788 
789 		ud_make_tag(dp->i_udf, &fid->fid_tag,
790 		    UD_FILE_ID_DESC, tbno, FID_LEN(fid));
791 
792 		err = ud_write_fid(dp, &slot, buf);
793 	}
794 
795 	slot.fbp = NULL;
796 
797 	/*
798 	 * If we were removing a directory, it is 'gone' now so we can
799 	 * unlock it.
800 	 */
801 	if (mode == VDIR) {
802 		rw_exit(&ip->i_rwlock);
803 	}
804 
805 	mutex_enter(&dp->i_tlock);
806 	dp->i_flag |= IUPD|ICHG;
807 	mutex_exit(&dp->i_tlock);
808 	mutex_enter(&ip->i_tlock);
809 	ip->i_flag |= ICHG;
810 	mutex_exit(&ip->i_tlock);
811 
812 	if (err != 0) {
813 		goto out;
814 	}
815 
816 	rw_enter(&ip->i_contents, RW_WRITER);
817 
818 	/*
819 	 * Now dispose of the inode.
820 	 */
821 	if (ip->i_nlink > 0) {
822 		if ((op == DR_RMDIR) && (ip->i_type == VDIR)) {
823 			/*
824 			 * Decrement by 1 because there is no "."
825 			 * Clear the inode, but there may be other hard
826 			 * links so don't free the inode.
827 			 * Decrement the dp linkcount because we're
828 			 * trashing the ".." entry.
829 			 */
830 			ip->i_nlink --;
831 			dp->i_nlink--;
832 			dnlc_remove(ITOV(ip), ".");
833 			dnlc_remove(ITOV(ip), "..");
834 /*
835  *			(void) ud_itrunc(ip, 0, 0, cr);
836  */
837 		} else {
838 			ip->i_nlink--;
839 		}
840 	}
841 	ITIMES_NOLOCK(dp);
842 	ITIMES_NOLOCK(ip);
843 	rw_exit(&ip->i_contents);
844 out:
845 	if (mode == VDIR) {
846 		vn_vfsunlock(ITOV(ip));
847 	}
848 out_novfs:
849 	ASSERT(RW_WRITE_HELD(&dp->i_contents));
850 
851 	if (slot.fbp != NULL) {
852 		fbrelse(slot.fbp, S_OTHER);
853 	}
854 	rw_exit(&dp->i_contents);
855 
856 	if (ip) {
857 		/*
858 		 * If no errors, send any events after locks are dropped,
859 		 * but before the VN_RELE().
860 		 */
861 		if (err == 0) {
862 			if (op == DR_REMOVE) {
863 				vnevent_remove(ITOV(ip), ITOV(dp), namep, ctp);
864 			} else if (op == DR_RMDIR) {
865 				vnevent_rmdir(ITOV(ip), ITOV(dp), namep, ctp);
866 			}
867 		}
868 		VN_RELE(ITOV(ip));
869 	}
870 
871 	kmem_free(buf, udf_vfsp->udf_lbsize);
872 	return (err);
873 }
874 
875 int
876 ud_dircheckforname(struct ud_inode *tdp,
877 	char *namep, int32_t namelen, struct slot *slotp,
878 	struct ud_inode **ipp, uint8_t *buf, struct cred *cr)
879 {
880 	struct udf_vfs *udf_vfsp;
881 	uint32_t dirsize, offset;
882 	struct fbuf *fbp;
883 	struct file_id *fid;
884 	int32_t sz, error = 0, sz_req, matched = 0;
885 	uint8_t *nm;
886 
887 	uint8_t *dname;
888 	int32_t id_len;
889 
890 	ud_printf("ud_dircheckforname\n");
891 
892 	ASSERT(RW_WRITE_HELD(&tdp->i_rwlock));
893 	fbp = NULL;
894 
895 	dname = (uint8_t *)kmem_zalloc(1024, KM_SLEEP);
896 
897 	udf_vfsp = tdp->i_udf;
898 
899 	offset = 0;
900 	dirsize = tdp->i_size;
901 
902 	if (slotp->status != FOUND) {
903 		int32_t temp;
904 
905 		temp = 1024; /* set to size of dname allocated above */
906 		if ((error = ud_compress(namelen, &temp,
907 		    (uint8_t *)namep, dname)) != 0) {
908 			goto end;
909 		}
910 		sz_req = F_LEN + temp;
911 		sz_req  = (sz_req + 3) & ~3;
912 	}
913 
914 	while (offset < dirsize) {
915 		if ((error = ud_get_next_fid(tdp, &fbp,
916 		    offset, &fid, &nm, buf)) != 0) {
917 			break;
918 		}
919 		if ((error = ud_uncompress(fid->fid_idlen,
920 		    &id_len, nm, dname)) != 0) {
921 			break;
922 		}
923 		if ((fid->fid_flags & FID_DELETED) == 0) {
924 			/* Check for name match */
925 			if (((namelen == id_len) &&
926 			    (strncmp(namep, (caddr_t)dname, namelen) == 0)) ||
927 			    ((fid->fid_flags & FID_PARENT) &&
928 			    (namep[0] == '.' &&
929 			    (namelen == 1 ||
930 			    (namelen == 2 && namep[1] == '.'))))) {
931 
932 				tdp->i_diroff = offset;
933 				if ((fid->fid_flags & FID_PARENT) &&
934 				    (namelen == 1) && (namep[0] == '.')) {
935 					struct vnode *vp = ITOV(tdp);
936 
937 					*ipp = tdp;
938 					VN_HOLD(vp);
939 				} else {
940 					uint16_t prn;
941 					uint32_t loc;
942 
943 					prn = SWAP_16(fid->fid_icb.lad_ext_prn);
944 					loc = SWAP_32(fid->fid_icb.lad_ext_loc);
945 					if ((error = ud_iget(tdp->i_vfs, prn,
946 					    loc, ipp, NULL, cr)) != 0) {
947 
948 						fbrelse(fbp, S_OTHER);
949 						goto end;
950 					}
951 				}
952 				slotp->status = EXIST;
953 				slotp->offset = offset;
954 				slotp->size = FID_LEN(fid);
955 				slotp->fbp = fbp;
956 				slotp->ep = fid;
957 				slotp->endoff = 0;
958 				goto end;
959 			}
960 		} else {
961 			/*
962 			 * see if we need to find an
963 			 * empty slot and the current slot
964 			 * matches
965 			 */
966 			if ((slotp->status != FOUND) || (matched == 0)) {
967 				sz = FID_LEN(fid);
968 				if (sz == sz_req) {
969 					slotp->status = FOUND;
970 					slotp->offset = offset;
971 					slotp->size = sz;
972 				}
973 				if (matched == 0) {
974 					if ((namelen == id_len) &&
975 					    (strncmp(namep, (caddr_t)dname,
976 					    namelen) == 0)) {
977 						matched = 1;
978 						slotp->status = FOUND;
979 						slotp->offset = offset;
980 						slotp->size = sz;
981 					}
982 				}
983 			}
984 		}
985 		offset += FID_LEN(fid);
986 	}
987 	if (fbp) {
988 		fbrelse(fbp, S_OTHER);
989 	}
990 	if (slotp->status == NONE) {
991 		/*
992 		 * We didn't find a slot; the new directory entry should be put
993 		 * at the end of the directory.  Return an indication of where
994 		 * this is, and set "endoff" to zero; since we're going to have
995 		 * to extend the directory, we're certainly not going to
996 		 * trucate it.
997 		 */
998 		slotp->offset = dirsize;
999 		if (tdp->i_desc_type == ICB_FLAG_ONE_AD) {
1000 			slotp->size = tdp->i_max_emb - tdp->i_size;
1001 		} else {
1002 			slotp->size = udf_vfsp->udf_lbsize -
1003 			    slotp->offset & udf_vfsp->udf_lbmask;
1004 		}
1005 		slotp->endoff = 0;
1006 	}
1007 
1008 	*ipp = NULL;
1009 end:
1010 	kmem_free((caddr_t)dname, 1024);
1011 	return (error);
1012 }
1013 
1014 /*
1015  * Return 1 if the dir has all files
1016  * deleted except the parent
1017  * else return 0
1018  */
1019 /* ARGSUSED */
1020 int
1021 ud_dirempty(struct ud_inode *ip, uint64_t ino, struct cred *cr)
1022 {
1023 	offset_t off;
1024 	int32_t empty = 1, error, count, entry_len, rcount;
1025 	struct file_id *fid;
1026 	caddr_t addr;
1027 	uint32_t tbno;
1028 	int32_t	desc_len;
1029 
1030 	ud_printf("ud_dirempty\n");
1031 
1032 	ASSERT(RW_LOCK_HELD(&ip->i_contents));
1033 
1034 	if (ip->i_size == 0) {
1035 		return (empty);
1036 	}
1037 
1038 	desc_len = 1024;
1039 	addr = kmem_zalloc(desc_len, KM_SLEEP);
1040 	fid = (struct file_id *)addr;
1041 
1042 	for (off = 0; off < ip->i_size; off += entry_len) {
1043 
1044 		/*
1045 		 * First read fid
1046 		 * and verify checksum
1047 		 */
1048 
1049 		rcount = sizeof (struct file_id);
1050 		error = ud_rdwri(UIO_READ, FREAD, ip, addr, rcount, off,
1051 		    UIO_SYSSPACE, &count, cr);
1052 		if ((error != 0) || (count != 0)) {
1053 			empty = 0;
1054 			break;
1055 		}
1056 
1057 		if ((error = ud_ip_off2bno(ip, off, &tbno)) != 0) {
1058 			empty = 0;
1059 			break;
1060 		}
1061 
1062 		/*
1063 		 * We verify the tag id and also the FID_LEN.
1064 		 * FID_LEN should be <= desc_len.
1065 		 */
1066 		if (ud_verify_tag_and_desc(&fid->fid_tag,
1067 		    UD_FILE_ID_DESC,
1068 		    tbno, 0, desc_len) != 0) {
1069 		/* Corrupted directory */
1070 			empty = 0;
1071 			break;
1072 		}
1073 
1074 		/*
1075 		 * Read the fid + iulen + len
1076 		 * Now verify both checksum andCRC
1077 		 */
1078 
1079 		rcount = FID_LEN(fid);
1080 		error = ud_rdwri(UIO_READ, FREAD, ip, addr, rcount, off,
1081 		    UIO_SYSSPACE, &count, cr);
1082 		if ((error != 0) || (count != 0)) {
1083 			empty = 0;
1084 			break;
1085 		}
1086 		/*
1087 		 * Now that the entire decsriptor is read we verify the
1088 		 * crc.
1089 		 */
1090 		if (ud_verify_tag_and_desc(&fid->fid_tag,
1091 		    UD_FILE_ID_DESC,
1092 		    tbno,
1093 		    1, rcount) != 0) {
1094 			/* Corrupted directory */
1095 			empty = 0;
1096 			break;
1097 		}
1098 
1099 		/*
1100 		 * Is the file deleted
1101 		 */
1102 
1103 		if ((fid->fid_flags & FID_DELETED) == 0) {
1104 			if ((fid->fid_flags & FID_PARENT) == 0) {
1105 				empty = 0;
1106 				break;
1107 			}
1108 		}
1109 		entry_len = FID_LEN(fid);
1110 	}
1111 
1112 	kmem_free(addr, 1024);
1113 
1114 	return (empty);
1115 }
1116 
1117 
1118 int
1119 ud_dircheckpath(int32_t blkno,
1120 	struct ud_inode *target, struct cred *cr)
1121 {
1122 	int32_t err = 0;
1123 	struct vfs *vfsp;
1124 	struct udf_vfs *udf_vfsp;
1125 	struct fbuf *fbp;
1126 	struct file_id *fid;
1127 	struct ud_inode *ip, *tip;
1128 	uint16_t prn;
1129 	uint32_t lbno, dummy, tbno;
1130 	daddr_t parent_icb_loc;
1131 
1132 	ud_printf("ud_dircheckpath\n");
1133 
1134 	udf_vfsp = target->i_udf;
1135 	ip = target;
1136 
1137 	ASSERT(udf_vfsp != NULL);
1138 	ASSERT(MUTEX_HELD(&target->i_udf->udf_rename_lck));
1139 	ASSERT(RW_WRITE_HELD(&ip->i_rwlock));
1140 
1141 	if (ip->i_icb_lbano == blkno) {
1142 		err = EINVAL;
1143 		goto out;
1144 	}
1145 	if (ip->i_icb_lbano == udf_vfsp->udf_root_blkno) {
1146 		goto out;
1147 	}
1148 
1149 	/*
1150 	 * Search back through the directory tree, using the PARENT entries
1151 	 * Fail any attempt to move a directory into an ancestor directory.
1152 	 */
1153 	for (;;) {
1154 		if ((err = fbread(ITOV(ip), 0,
1155 		    udf_vfsp->udf_lbsize, S_READ, &fbp)) != 0) {
1156 			break;
1157 		}
1158 
1159 		if ((err = ud_ip_off2bno(ip, 0, &tbno)) != 0) {
1160 			break;
1161 		}
1162 		fid = (struct file_id *)fbp->fb_addr;
1163 		/* IS this a valid file_identifier */
1164 		if (ud_verify_tag_and_desc(&fid->fid_tag,
1165 		    UD_FILE_ID_DESC,
1166 		    tbno,
1167 		    1, udf_vfsp->udf_lbsize) != 0) {
1168 			break;
1169 		}
1170 		if ((fid->fid_flags & FID_DELETED) != 0) {
1171 			break;
1172 		}
1173 		if ((fid->fid_flags & FID_PARENT) == 0) {
1174 			/*
1175 			 * This cannot happen unless
1176 			 * something is grossly wrong
1177 			 * First entry has to be parent
1178 			 */
1179 			break;
1180 		}
1181 		prn = SWAP_16(fid->fid_icb.lad_ext_prn);
1182 		lbno = SWAP_32(fid->fid_icb.lad_ext_loc);
1183 		parent_icb_loc =
1184 		    ud_xlate_to_daddr(udf_vfsp, prn, lbno, 1, &dummy);
1185 		ASSERT(dummy == 1);
1186 		if (parent_icb_loc == blkno) {
1187 			err = EINVAL;
1188 			break;
1189 		}
1190 		vfsp = ip->i_vfs;
1191 		udf_vfsp = ip->i_udf;
1192 		if (parent_icb_loc == udf_vfsp->udf_root_blkno) {
1193 			break;
1194 		}
1195 		if (fbp != NULL) {
1196 			fbrelse(fbp, S_OTHER);
1197 			fbp = NULL;
1198 		}
1199 		if (ip != target) {
1200 			rw_exit(&ip->i_rwlock);
1201 			VN_RELE(ITOV(ip));
1202 		}
1203 
1204 		/*
1205 		 * Race to get the inode.
1206 		 */
1207 		if (err = ud_iget(vfsp, prn, lbno, &tip, NULL, cr)) {
1208 			ip = NULL;
1209 			break;
1210 		}
1211 		ip = tip;
1212 		rw_enter(&ip->i_rwlock, RW_READER);
1213 	}
1214 	if (fbp) {
1215 		fbrelse(fbp, S_OTHER);
1216 	}
1217 out:
1218 	if (ip) {
1219 		if (ip != target) {
1220 			rw_exit(&ip->i_rwlock);
1221 			VN_RELE(ITOV(ip));
1222 		}
1223 	}
1224 	return (err);
1225 }
1226 
1227 int
1228 ud_dirmakeinode(struct ud_inode *tdp, struct ud_inode **ipp,
1229 	struct vattr *vap, enum de_op op, struct cred *cr)
1230 {
1231 	struct ud_inode *ip;
1232 	int32_t error;
1233 
1234 	ASSERT(vap != NULL);
1235 	ASSERT(op == DE_CREATE || op == DE_MKDIR);
1236 	ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE));
1237 	ASSERT(RW_WRITE_HELD(&tdp->i_rwlock));
1238 
1239 	/*
1240 	 * Allocate a new inode.
1241 	 */
1242 	if ((error = ud_ialloc(tdp, &ip, vap, cr)) != 0) {
1243 		return (error);
1244 	}
1245 
1246 	ASSERT(ip != NULL);
1247 
1248 	rw_enter(&ip->i_contents, RW_WRITER);
1249 
1250 	if (op == DE_MKDIR) {
1251 		error = ud_dirmakedirect(ip, tdp, cr);
1252 	}
1253 
1254 	ip->i_flag |= IACC|IUPD|ICHG;
1255 	/*
1256 	 * Clear IACC and/or IUPD if the caller specified the atime and/or
1257 	 * mtime fields.  They were set from the passed in attributes in
1258 	 * ud_ialloc().
1259 	 */
1260 	if (vap->va_mask & AT_ATIME)
1261 		ip->i_flag &= ~IACC;
1262 	if (vap->va_mask & AT_MTIME)
1263 		ip->i_flag &= ~IUPD;
1264 	/*
1265 	 * push inode before it's name appears in a directory
1266 	 */
1267 	ud_iupdat(ip, 1);
1268 	*ipp = ip;
1269 	rw_exit(&ip->i_contents);
1270 	return (error);
1271 }
1272 
1273 /*
1274  * Enter the file sip in the directory tdp with name namep.
1275  */
1276 int
1277 ud_diraddentry(struct ud_inode *tdp, char *namep,
1278 	enum de_op op, int32_t namelen, struct slot *slotp,
1279 	struct ud_inode *sip, struct ud_inode *sdp, struct cred *cr)
1280 {
1281 	struct udf_vfs *udf_vfsp;
1282 	int32_t error, temp;
1283 	struct file_id *fid;
1284 	uint8_t *buf = NULL;
1285 
1286 	ASSERT(RW_WRITE_HELD(&tdp->i_rwlock));
1287 
1288 	ud_printf("ud_diraddentry\n");
1289 
1290 	udf_vfsp = sip->i_udf;
1291 
1292 	/*
1293 	 * Check inode to be linked to see if it is in the
1294 	 * same filesystem.
1295 	 */
1296 	if (ITOV(tdp)->v_vfsp != ITOV(sip)->v_vfsp) {
1297 		error = EXDEV;
1298 		goto bad;
1299 	}
1300 
1301 	if ((op == DE_RENAME) && (sip->i_type == VDIR)) {
1302 		if ((error = ud_dirfixdotdot(sip, sdp, tdp)) != 0) {
1303 			goto bad;
1304 		}
1305 	}
1306 
1307 	buf = (uint8_t *)kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP);
1308 
1309 	/*
1310 	 * Fill in entry data.
1311 	 */
1312 	fid = (struct file_id *)buf;
1313 	fid->fid_ver = SWAP_16(1);
1314 	if (sip->i_type == VDIR) {
1315 		fid->fid_flags = FID_DIR;
1316 	} else {
1317 		fid->fid_flags = 0;
1318 	}
1319 	fid->fid_iulen = 0;
1320 
1321 	fid->fid_icb.lad_ext_len = SWAP_32(sip->i_udf->udf_lbsize);
1322 	fid->fid_icb.lad_ext_loc = SWAP_32(sip->i_icb_block);
1323 	fid->fid_icb.lad_ext_prn = SWAP_16(sip->i_icb_prn);
1324 	fid->fid_iulen = 0;
1325 
1326 	temp = MIN(udf_vfsp->udf_lbsize - F_LEN, MAXNAMELEN);
1327 	if ((error = ud_compress(namelen, &temp,
1328 	    (uint8_t *)namep, fid->fid_spec)) == 0) {
1329 		fid->fid_idlen = (uint8_t)temp;
1330 		error = ud_dirprepareentry(tdp, slotp, buf, cr);
1331 	}
1332 
1333 	kmem_free(buf, udf_vfsp->udf_lbsize);
1334 
1335 bad:
1336 	return (error);
1337 }
1338 
1339 /*
1340  * Write a prototype directory into the empty inode ip, whose parent is dp.
1341  */
1342 /* ARGSUSED2 */
1343 int
1344 ud_dirmakedirect(struct ud_inode *ip,
1345 	struct ud_inode *dp, struct cred *cr)
1346 {
1347 	int32_t err;
1348 	uint32_t blkno, size, parent_len, tbno;
1349 	struct fbuf *fbp;
1350 	struct file_id *fid;
1351 	struct icb_ext *iext;
1352 
1353 	ud_printf("ud_dirmakedirect\n");
1354 
1355 	ASSERT(RW_WRITE_HELD(&ip->i_contents));
1356 	ASSERT(RW_WRITE_HELD(&dp->i_rwlock));
1357 
1358 	parent_len = sizeof (struct file_id);
1359 
1360 	if ((ip->i_desc_type != ICB_FLAG_ONE_AD) ||
1361 	    (parent_len > ip->i_max_emb)) {
1362 		ASSERT(ip->i_ext);
1363 		/*
1364 		 * Allocate space for the directory we're creating.
1365 		 */
1366 		if ((err = ud_alloc_space(ip->i_vfs, ip->i_icb_prn,
1367 		    0, 1, &blkno, &size, 0, 0)) != 0) {
1368 			return (err);
1369 		}
1370 		/*
1371 		 * init with the size of
1372 		 * directory with just the
1373 		 * parent
1374 		 */
1375 		ip->i_size = sizeof (struct file_id);
1376 		ip->i_flag |= IUPD|ICHG|IATTCHG;
1377 		iext = ip->i_ext;
1378 		iext->ib_prn = ip->i_icb_prn;
1379 		iext->ib_block = blkno;
1380 		iext->ib_count = ip->i_size;
1381 		iext->ib_offset = 0;
1382 		ip->i_ext_used = 1;
1383 	} else {
1384 		ip->i_size = sizeof (struct file_id);
1385 		ip->i_flag |= IUPD|ICHG|IATTCHG;
1386 	}
1387 
1388 	ITIMES_NOLOCK(ip);
1389 
1390 	/*
1391 	 * Update the dp link count and write out the change.
1392 	 * This reflects the ".." entry we'll soon write.
1393 	 */
1394 	if (dp->i_nlink == MAXLINK) {
1395 		return (EMLINK);
1396 	}
1397 	dp->i_nlink++;
1398 	dp->i_flag |= ICHG;
1399 	ud_iupdat(dp, 1);
1400 
1401 	/*
1402 	 * Initialize directory with ".."
1403 	 * Since the parent directory is locked, we don't have to
1404 	 * worry about anything changing when we drop the write
1405 	 * lock on (ip).
1406 	 */
1407 	rw_exit(&ip->i_contents);
1408 	if ((err = fbread(ITOV(ip), (offset_t)0,
1409 	    ip->i_udf->udf_lbsize, S_WRITE, &fbp)) != 0) {
1410 		rw_enter(&ip->i_contents, RW_WRITER);
1411 		return (err);
1412 	}
1413 
1414 	bzero(fbp->fb_addr, ip->i_udf->udf_lbsize);
1415 
1416 	fid = (struct file_id *)fbp->fb_addr;
1417 	fid->fid_ver = SWAP_16(1);
1418 	fid->fid_flags = FID_DIR | FID_PARENT;
1419 	fid->fid_icb.lad_ext_len = SWAP_32(dp->i_udf->udf_lbsize);
1420 	fid->fid_icb.lad_ext_loc = SWAP_32(dp->i_icb_block);
1421 	fid->fid_icb.lad_ext_prn = SWAP_16(dp->i_icb_prn);
1422 
1423 	/*
1424 	 * fid_idlen, fid_iulen and fid_spec are zero
1425 	 * due to bzero above
1426 	 */
1427 
1428 	if ((err = ud_ip_off2bno(ip, 0, &tbno)) == 0) {
1429 		ud_make_tag(ip->i_udf, &fid->fid_tag,
1430 		    UD_FILE_ID_DESC, tbno, FID_LEN(fid));
1431 	}
1432 
1433 	err = ud_fbwrite(fbp, ip);
1434 	rw_enter(&ip->i_contents, RW_WRITER);
1435 
1436 	return (err);
1437 }
1438 
1439 int
1440 ud_dirrename(struct ud_inode *sdp, struct ud_inode *sip,
1441 	struct ud_inode *tdp, struct ud_inode *tip, char *namep,
1442 	uint8_t *buf, struct slot *slotp, struct cred *cr)
1443 {
1444 	int32_t error = 0, doingdirectory;
1445 	struct file_id *fid;
1446 
1447 	ud_printf("ud_dirrename\n");
1448 	ASSERT(sdp->i_udf != NULL);
1449 	ASSERT(MUTEX_HELD(&sdp->i_udf->udf_rename_lck));
1450 	ASSERT(RW_WRITE_HELD(&tdp->i_rwlock));
1451 	ASSERT(RW_WRITE_HELD(&tdp->i_contents));
1452 	ASSERT(buf);
1453 	ASSERT(slotp->ep);
1454 
1455 	fid = slotp->ep;
1456 
1457 	/*
1458 	 * Short circuit rename of something to itself.
1459 	 */
1460 	if (sip->i_icb_lbano == tip->i_icb_lbano) {
1461 		return (ESAME);		/* special KLUDGE error code */
1462 	}
1463 	/*
1464 	 * Everything is protected under the vfs_rename_lock so the ordering
1465 	 * of i_contents locks doesn't matter here.
1466 	 */
1467 	rw_enter(&sip->i_contents, RW_READER);
1468 	rw_enter(&tip->i_contents, RW_READER);
1469 
1470 	/*
1471 	 * Check that everything is on the same filesystem.
1472 	 */
1473 	if ((ITOV(tip)->v_vfsp != ITOV(tdp)->v_vfsp) ||
1474 	    (ITOV(tip)->v_vfsp != ITOV(sip)->v_vfsp)) {
1475 		error = EXDEV;		/* XXX archaic */
1476 		goto out;
1477 	}
1478 
1479 	/*
1480 	 * Must have write permission to rewrite target entry.
1481 	 */
1482 	if ((error = ud_iaccess(tdp, IWRITE, cr, 0)) != 0 ||
1483 	    (error = ud_sticky_remove_access(tdp, tip, cr)) != 0)
1484 		goto out;
1485 
1486 	/*
1487 	 * Ensure source and target are compatible (both directories
1488 	 * or both not directories).  If target is a directory it must
1489 	 * be empty and have no links to it; in addition it must not
1490 	 * be a mount point, and both the source and target must be
1491 	 * writable.
1492 	 */
1493 	doingdirectory = (sip->i_type == VDIR);
1494 	if (tip->i_type == VDIR) {
1495 		if (!doingdirectory) {
1496 			error = EISDIR;
1497 			goto out;
1498 		}
1499 		/*
1500 		 * vn_vfswlock will prevent mounts from using the directory
1501 		 * until we are done.
1502 		 */
1503 		if (vn_vfswlock(ITOV(tip))) {
1504 			error = EBUSY;
1505 			goto out;
1506 		}
1507 		if (vn_mountedvfs(ITOV(tip)) != NULL) {
1508 			vn_vfsunlock(ITOV(tip));
1509 			error = EBUSY;
1510 			goto out;
1511 		}
1512 		if (!ud_dirempty(tip, tdp->i_uniqid, cr) || tip->i_nlink > 2) {
1513 			vn_vfsunlock(ITOV(tip));
1514 			error = EEXIST;	/* SIGH should be ENOTEMPTY */
1515 			goto out;
1516 		}
1517 	} else if (doingdirectory) {
1518 		error = ENOTDIR;
1519 		goto out;
1520 	}
1521 
1522 	/*
1523 	 * Rewrite the inode pointer for target name entry
1524 	 * from the target inode (ip) to the source inode (sip).
1525 	 * This prevents the target entry from disappearing
1526 	 * during a crash. Mark the directory inode to reflect the changes.
1527 	 */
1528 	dnlc_remove(ITOV(tdp), namep);
1529 	fid->fid_icb.lad_ext_prn = SWAP_16(sip->i_icb_prn);
1530 	fid->fid_icb.lad_ext_loc = SWAP_32(sip->i_icb_block);
1531 	dnlc_enter(ITOV(tdp), namep, ITOV(sip));
1532 
1533 	ud_make_tag(tdp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC,
1534 	    SWAP_32(fid->fid_tag.tag_loc), FID_LEN(fid));
1535 
1536 	error = ud_write_fid(tdp, slotp, buf);
1537 
1538 	if (error) {
1539 		if (doingdirectory) {
1540 			vn_vfsunlock(ITOV(tip));
1541 		}
1542 		goto out;
1543 	}
1544 
1545 	/*
1546 	 * Upgrade to write lock on tip
1547 	 */
1548 	rw_exit(&tip->i_contents);
1549 	rw_enter(&tip->i_contents, RW_WRITER);
1550 
1551 	mutex_enter(&tdp->i_tlock);
1552 	tdp->i_flag |= IUPD|ICHG;
1553 	mutex_exit(&tdp->i_tlock);
1554 	/*
1555 	 * Decrement the link count of the target inode.
1556 	 * Fix the ".." entry in sip to point to dp.
1557 	 * This is done after the new entry is on the disk.
1558 	 */
1559 	tip->i_nlink--;
1560 	mutex_enter(&tip->i_tlock);
1561 	tip->i_flag |= ICHG;
1562 	mutex_exit(&tip->i_tlock);
1563 
1564 	if (doingdirectory) {
1565 		/*
1566 		 * The entry for tip no longer exists so I can unlock the
1567 		 * vfslock.
1568 		 */
1569 		vn_vfsunlock(ITOV(tip));
1570 		/*
1571 		 * Decrement target link count once more if it was a directory.
1572 		 */
1573 		if (tip->i_nlink != 0) {
1574 			cmn_err(CE_WARN,
1575 			"ud_direnter: target directory link count != 0");
1576 			rw_exit(&tip->i_contents);
1577 			rw_exit(&sip->i_contents);
1578 			return (EINVAL);
1579 		}
1580 		/*
1581 		 * Renaming a directory with the parent different
1582 		 * requires that ".." be rewritten.  The window is
1583 		 * still there for ".." to be inconsistent, but this
1584 		 * is unavoidable, and a lot shorter than when it was
1585 		 * done in a user process.  We decrement the link
1586 		 * count in the new parent as appropriate to reflect
1587 		 * the just-removed target.  If the parent is the
1588 		 * same, this is appropriate since the original
1589 		 * directory is going away.  If the new parent is
1590 		 * different, dirfixdotdot() will bump the link count
1591 		 * back.
1592 		 */
1593 		tdp->i_nlink--;
1594 		mutex_enter(&tdp->i_tlock);
1595 		tdp->i_flag |= ICHG;
1596 		mutex_exit(&tdp->i_tlock);
1597 		ITIMES_NOLOCK(tdp);
1598 		if (sdp != tdp) {
1599 			rw_exit(&tip->i_contents);
1600 			rw_exit(&sip->i_contents);
1601 			error = ud_dirfixdotdot(sip, sdp, tdp);
1602 			return (error);
1603 		}
1604 	}
1605 
1606 out:
1607 	rw_exit(&tip->i_contents);
1608 	rw_exit(&sip->i_contents);
1609 	return (error);
1610 }
1611 
1612 
1613 /*
1614  * 1. When we find a slot that belonged to a file which was deleted
1615  *      and is in the middle of the directory
1616  * 2. There is not empty slot available. The new entry
1617  *      will be at the end of the directory and fits in the same block.
1618  * 3. There is no empty slot available. The new
1619  *      entry will not fit the left over directory
1620  *      so we need to allocate a new block. If
1621  *      we cannot allocate a proximity block we need
1622  *      to allocate a new icb, and data block.
1623  */
1624 int
1625 ud_dirprepareentry(struct ud_inode *dp,
1626 	struct slot *slotp, uint8_t *buf, struct cred *cr)
1627 {
1628 	struct fbuf *fbp;
1629 	uint16_t old_dtype;
1630 	int32_t error = 0;
1631 	uint32_t entrysize, count, offset, tbno, old_size, off;
1632 	struct file_id *fid;
1633 	int32_t lbsize, lbmask, mask;
1634 
1635 	ASSERT(RW_WRITE_HELD(&dp->i_rwlock));
1636 
1637 	ASSERT((slotp->status == NONE) || (slotp->status == FOUND));
1638 
1639 	ud_printf("ud_dirprepareentry\n");
1640 	lbsize = dp->i_udf->udf_lbsize;
1641 	lbmask = dp->i_udf->udf_lbmask;
1642 	mask = ~lbmask;
1643 
1644 	fid = (struct file_id *)buf;
1645 	entrysize = FID_LEN(fid);
1646 
1647 	/*
1648 	 * If we didn't find a slot, then indicate that the
1649 	 * new slot belongs at the end of the directory.
1650 	 * If we found a slot, then the new entry can be
1651 	 * put at slotp->offset.
1652 	 */
1653 	if (slotp->status == NONE) {
1654 		/*
1655 		 * We did not find a slot, the next
1656 		 * entry will be in the end of the directory
1657 		 * see if we can fit the new entry inside
1658 		 * the old block. If not allocate a new block.
1659 		 */
1660 		if (entrysize > slotp->size) {
1661 			/*
1662 			 * extend the directory
1663 			 * size by one new block
1664 			 */
1665 			old_dtype = dp->i_desc_type;
1666 			old_size = (uint32_t)dp->i_size;
1667 			error = ud_bmap_write(dp, slotp->offset,
1668 			    blkoff(dp->i_udf, slotp->offset) + entrysize,
1669 			    0, cr);
1670 			if (error != 0) {
1671 				return (error);
1672 			}
1673 			if (old_dtype != dp->i_desc_type) {
1674 				/*
1675 				 * oops we changed the astrat
1676 				 * of the file, we have to
1677 				 * recaliculate tags
1678 				 * fortunately we donot have more
1679 				 * than one lbsize to handle here
1680 				 */
1681 				if ((error = ud_ip_off2bno(dp,
1682 				    0, &tbno)) != 0) {
1683 					return (error);
1684 				}
1685 				if ((error = fbread(ITOV(dp), 0,
1686 				    dp->i_udf->udf_lbsize,
1687 				    S_WRITE, &fbp)) != 0) {
1688 					return (error);
1689 				}
1690 				off = 0;
1691 				while (off < old_size) {
1692 					struct file_id *tfid;
1693 
1694 					tfid = (struct file_id *)
1695 					    (fbp->fb_addr + off);
1696 
1697 					ud_make_tag(dp->i_udf, &tfid->fid_tag,
1698 					    UD_FILE_ID_DESC, tbno,
1699 					    FID_LEN(tfid));
1700 
1701 					off += FID_LEN(tfid);
1702 				}
1703 				if (error = ud_fbwrite(fbp, dp)) {
1704 					return (error);
1705 				}
1706 			}
1707 		} else {
1708 			/* Extend the directory size */
1709 			if (dp->i_desc_type != ICB_FLAG_ONE_AD) {
1710 				ASSERT(dp->i_ext);
1711 				dp->i_ext[dp->i_ext_used - 1].ib_count +=
1712 				    entrysize;
1713 			}
1714 		}
1715 		dp->i_size += entrysize;
1716 		dp->i_flag |= IUPD|ICHG|IATTCHG;
1717 		ITIMES_NOLOCK(dp);
1718 	} else if (slotp->status != FOUND) {
1719 		cmn_err(CE_WARN, "status is not NONE/FOUND");
1720 		return (EINVAL);
1721 	}
1722 
1723 	if ((error = ud_ip_off2bno(dp, slotp->offset, &tbno)) != 0) {
1724 		return (error);
1725 	}
1726 	ud_make_tag(dp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC,
1727 	    tbno, FID_LEN(fid));
1728 
1729 	/*
1730 	 * fbread cannot cross a
1731 	 * MAXBSIZE boundary so handle it here
1732 	 */
1733 	offset = slotp->offset;
1734 	if ((error = fbread(ITOV(dp), offset & mask, lbsize,
1735 	    S_WRITE, &fbp)) != 0) {
1736 		return (error);
1737 	}
1738 	if ((offset & mask) != ((offset + entrysize) & mask)) {
1739 		count = entrysize - ((offset + entrysize) & lbmask);
1740 	} else {
1741 		count = entrysize;
1742 	}
1743 	bcopy((caddr_t)buf, fbp->fb_addr + (offset & lbmask), count);
1744 
1745 	if (error = ud_fbwrite(fbp, dp)) {
1746 		return (error);
1747 	}
1748 
1749 	if (entrysize > count) {
1750 		if ((error = fbread(ITOV(dp), (offset + entrysize) & mask,
1751 		    lbsize, S_WRITE, &fbp)) != 0) {
1752 			return (error);
1753 		}
1754 		bcopy((caddr_t)(buf + count), fbp->fb_addr, entrysize - count);
1755 		if (error = ud_fbwrite(fbp, dp)) {
1756 			return (error);
1757 		}
1758 	}
1759 
1760 	dp->i_flag |= IUPD|ICHG|IATTCHG;
1761 	ITIMES_NOLOCK(dp);
1762 	return (error);
1763 }
1764 
1765 
1766 /*
1767  * Fix the FID_PARENT entry of the child directory so that it points
1768  * to the new parent directory instead of the old one.  Routine
1769  * assumes that dp is a directory and that all the inodes are on
1770  * the same file system.
1771  */
1772 int
1773 ud_dirfixdotdot(struct ud_inode *dp,
1774 	struct ud_inode *opdp, struct ud_inode *npdp)
1775 {
1776 	int32_t err = 0;
1777 	struct fbuf *fbp;
1778 	struct file_id *fid;
1779 	uint32_t loc, dummy, tbno;
1780 
1781 	ud_printf("ud_dirfixdotdot\n");
1782 
1783 	ASSERT(opdp->i_type == VDIR);
1784 	ASSERT(npdp->i_type == VDIR);
1785 
1786 	ASSERT(RW_WRITE_HELD(&npdp->i_rwlock));
1787 
1788 	err = fbread(ITOV(dp), (offset_t)0,
1789 	    dp->i_udf->udf_lbsize, S_WRITE, &fbp);
1790 
1791 	if (err || dp->i_nlink == 0 ||
1792 	    dp->i_size < sizeof (struct file_id)) {
1793 		goto bad;
1794 	}
1795 
1796 	if ((err = ud_ip_off2bno(dp, 0, &tbno)) != 0) {
1797 		goto bad;
1798 	}
1799 
1800 	fid = (struct file_id *)fbp->fb_addr;
1801 	if ((ud_verify_tag_and_desc(&fid->fid_tag, UD_FILE_ID_DESC,
1802 	    tbno,
1803 	    1, dp->i_udf->udf_lbsize) != 0) ||
1804 	    ((fid->fid_flags & (FID_DIR | FID_PARENT)) !=
1805 	    (FID_DIR | FID_PARENT))) {
1806 		err = ENOTDIR;
1807 		goto bad;
1808 	}
1809 
1810 	loc = ud_xlate_to_daddr(dp->i_udf,
1811 	    SWAP_16(fid->fid_icb.lad_ext_prn),
1812 	    SWAP_32(fid->fid_icb.lad_ext_loc), 1, &dummy);
1813 	ASSERT(dummy == 1);
1814 	if (loc == npdp->i_icb_lbano) {
1815 		goto bad;
1816 	}
1817 
1818 	/*
1819 	 * Increment the link count in the new parent inode and force it out.
1820 	 */
1821 	if (npdp->i_nlink == MAXLINK) {
1822 		err = EMLINK;
1823 		goto bad;
1824 	}
1825 
1826 	npdp->i_nlink++;
1827 	mutex_enter(&npdp->i_tlock);
1828 	npdp->i_flag |= ICHG;
1829 	mutex_exit(&npdp->i_tlock);
1830 	ud_iupdat(npdp, 1);
1831 
1832 	/*
1833 	 * Rewrite the child FID_PARENT entry and force it out.
1834 	 */
1835 	dnlc_remove(ITOV(dp), "..");
1836 	fid->fid_icb.lad_ext_loc = SWAP_32(npdp->i_icb_block);
1837 	fid->fid_icb.lad_ext_prn = SWAP_16(npdp->i_icb_prn);
1838 	ud_make_tag(npdp->i_udf, &fid->fid_tag,
1839 	    UD_FILE_ID_DESC, tbno, FID_LEN(fid));
1840 	dnlc_enter(ITOV(dp), "..", ITOV(npdp));
1841 
1842 	err = ud_fbwrite(fbp, dp);
1843 	fbp = NULL;
1844 	if (err != 0) {
1845 		goto bad;
1846 	}
1847 
1848 	/*
1849 	 * Decrement the link count of the old parent inode and force
1850 	 * it out.  If opdp is NULL, then this is a new directory link;
1851 	 * it has no parent, so we need not do anything.
1852 	 */
1853 	if (opdp != NULL) {
1854 		rw_enter(&opdp->i_contents, RW_WRITER);
1855 		if (opdp->i_nlink != 0) {
1856 			opdp->i_nlink--;
1857 			mutex_enter(&opdp->i_tlock);
1858 			opdp->i_flag |= ICHG;
1859 			mutex_exit(&opdp->i_tlock);
1860 			ud_iupdat(opdp, 1);
1861 		}
1862 		rw_exit(&opdp->i_contents);
1863 	}
1864 	return (0);
1865 
1866 bad:
1867 	if (fbp) {
1868 		fbrelse(fbp, S_OTHER);
1869 	}
1870 	return (err);
1871 }
1872 
1873 int32_t
1874 ud_write_fid(struct ud_inode *dp, struct slot *slot, uint8_t *buf)
1875 {
1876 	struct udf_vfs *udf_vfsp;
1877 	struct fbuf *lfbp;
1878 	struct file_id *fid;
1879 	int32_t error = 0;
1880 	uint32_t lbsize, lbmask, count, old_count;
1881 
1882 
1883 	ASSERT(slot->fbp);
1884 	ASSERT(slot->ep);
1885 
1886 	udf_vfsp = dp->i_udf;
1887 	fid = slot->ep;
1888 	lbsize = dp->i_udf->udf_lbsize;
1889 	lbmask = dp->i_udf->udf_lbmask;
1890 
1891 	if (((uint8_t *)fid >= buf) &&
1892 	    ((uint8_t *)fid < &buf[udf_vfsp->udf_lbsize])) {
1893 
1894 		if ((error = fbread(ITOV(dp),
1895 		    (offset_t)(slot->offset & ~lbmask),
1896 		    lbsize, S_WRITE, &lfbp)) != 0) {
1897 			goto out;
1898 		}
1899 
1900 
1901 		/*
1902 		 * We do not need to write the
1903 		 * file name. So check if the entry
1904 		 * does not cross a block boundary
1905 		 * and write only required portions
1906 		 */
1907 		if (((slot->offset & lbmask) +
1908 			sizeof (struct file_id)) > lbsize) {
1909 
1910 			if ((slot->offset & lbmask) != 0) {
1911 				old_count = lbsize -
1912 					(slot->offset & lbmask);
1913 				count = (slot->offset +
1914 					sizeof (struct file_id)) &
1915 					lbmask;
1916 			} else {
1917 				old_count = 0;
1918 				count = sizeof (struct file_id);
1919 			}
1920 
1921 			bcopy(buf, lfbp->fb_addr +
1922 				(slot->offset & lbmask), old_count);
1923 			bcopy(buf + old_count,
1924 				slot->fbp->fb_addr, count);
1925 
1926 			error = ud_fbwrite(lfbp, dp);
1927 
1928 			error = ud_fbwrite(slot->fbp, dp);
1929 		} else {
1930 			bcopy(buf, lfbp->fb_addr +
1931 				(slot->offset & lbmask),
1932 				sizeof (struct file_id));
1933 
1934 			error = ud_fbwrite(lfbp, dp);
1935 
1936 			fbrelse(slot->fbp, S_OTHER);
1937 		}
1938 	} else {
1939 		if ((error = ud_fbwrite(slot->fbp, dp)) != 0) {
1940 			fid->fid_flags &= ~FID_DELETED;
1941 			ud_make_tag(dp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC,
1942 			    SWAP_32(fid->fid_tag.tag_loc), FID_LEN(fid));
1943 		}
1944 	}
1945 	slot->fbp = NULL;
1946 
1947 out:
1948 	return (error);
1949 }
1950