xref: /linux/fs/xfs/libxfs/xfs_dir2.c (revision daa2be74b1b2302004945b2a5e32424e177cc7da)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_bmap.h"
16 #include "xfs_dir2.h"
17 #include "xfs_dir2_priv.h"
18 #include "xfs_errortag.h"
19 #include "xfs_error.h"
20 #include "xfs_trace.h"
21 #include "xfs_health.h"
22 #include "xfs_bmap_btree.h"
23 #include "xfs_trans_space.h"
24 #include "xfs_parent.h"
25 #include "xfs_ag.h"
26 #include "xfs_ialloc.h"
27 
28 const struct xfs_name xfs_name_dotdot = {
29 	.name	= (const unsigned char *)"..",
30 	.len	= 2,
31 	.type	= XFS_DIR3_FT_DIR,
32 };
33 
34 const struct xfs_name xfs_name_dot = {
35 	.name	= (const unsigned char *)".",
36 	.len	= 1,
37 	.type	= XFS_DIR3_FT_DIR,
38 };
39 
40 /*
41  * Convert inode mode to directory entry filetype
42  */
43 unsigned char
44 xfs_mode_to_ftype(
45 	int		mode)
46 {
47 	switch (mode & S_IFMT) {
48 	case S_IFREG:
49 		return XFS_DIR3_FT_REG_FILE;
50 	case S_IFDIR:
51 		return XFS_DIR3_FT_DIR;
52 	case S_IFCHR:
53 		return XFS_DIR3_FT_CHRDEV;
54 	case S_IFBLK:
55 		return XFS_DIR3_FT_BLKDEV;
56 	case S_IFIFO:
57 		return XFS_DIR3_FT_FIFO;
58 	case S_IFSOCK:
59 		return XFS_DIR3_FT_SOCK;
60 	case S_IFLNK:
61 		return XFS_DIR3_FT_SYMLINK;
62 	default:
63 		return XFS_DIR3_FT_UNKNOWN;
64 	}
65 }
66 
67 /*
68  * ASCII case-insensitive (ie. A-Z) support for directories that was
69  * used in IRIX.
70  */
71 xfs_dahash_t
72 xfs_ascii_ci_hashname(
73 	const struct xfs_name	*name)
74 {
75 	xfs_dahash_t		hash;
76 	int			i;
77 
78 	for (i = 0, hash = 0; i < name->len; i++)
79 		hash = xfs_ascii_ci_xfrm(name->name[i]) ^ rol32(hash, 7);
80 
81 	return hash;
82 }
83 
84 enum xfs_dacmp
85 xfs_ascii_ci_compname(
86 	struct xfs_da_args	*args,
87 	const unsigned char	*name,
88 	int			len)
89 {
90 	enum xfs_dacmp		result;
91 	int			i;
92 
93 	if (args->namelen != len)
94 		return XFS_CMP_DIFFERENT;
95 
96 	result = XFS_CMP_EXACT;
97 	for (i = 0; i < len; i++) {
98 		if (args->name[i] == name[i])
99 			continue;
100 		if (xfs_ascii_ci_xfrm(args->name[i]) !=
101 		    xfs_ascii_ci_xfrm(name[i]))
102 			return XFS_CMP_DIFFERENT;
103 		result = XFS_CMP_CASE;
104 	}
105 
106 	return result;
107 }
108 
109 int
110 xfs_da_mount(
111 	struct xfs_mount	*mp)
112 {
113 	struct xfs_da_geometry	*dageo;
114 
115 
116 	ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
117 	ASSERT(xfs_dir2_dirblock_bytes(&mp->m_sb) <= XFS_MAX_BLOCKSIZE);
118 
119 	mp->m_dir_geo = kzalloc(sizeof(struct xfs_da_geometry),
120 				GFP_KERNEL | __GFP_RETRY_MAYFAIL);
121 	mp->m_attr_geo = kzalloc(sizeof(struct xfs_da_geometry),
122 				GFP_KERNEL | __GFP_RETRY_MAYFAIL);
123 	if (!mp->m_dir_geo || !mp->m_attr_geo) {
124 		kfree(mp->m_dir_geo);
125 		kfree(mp->m_attr_geo);
126 		return -ENOMEM;
127 	}
128 
129 	/* set up directory geometry */
130 	dageo = mp->m_dir_geo;
131 	dageo->blklog = mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog;
132 	dageo->fsblog = mp->m_sb.sb_blocklog;
133 	dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb);
134 	dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog;
135 	if (xfs_has_crc(mp)) {
136 		dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr);
137 		dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr);
138 		dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr);
139 		dageo->data_entry_offset =
140 				sizeof(struct xfs_dir3_data_hdr);
141 	} else {
142 		dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr);
143 		dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr);
144 		dageo->free_hdr_size = sizeof(struct xfs_dir2_free_hdr);
145 		dageo->data_entry_offset =
146 				sizeof(struct xfs_dir2_data_hdr);
147 	}
148 	dageo->leaf_max_ents = (dageo->blksize - dageo->leaf_hdr_size) /
149 			sizeof(struct xfs_dir2_leaf_entry);
150 	dageo->free_max_bests = (dageo->blksize - dageo->free_hdr_size) /
151 			sizeof(xfs_dir2_data_off_t);
152 
153 	dageo->data_first_offset = dageo->data_entry_offset +
154 			xfs_dir2_data_entsize(mp, 1) +
155 			xfs_dir2_data_entsize(mp, 2);
156 
157 	/*
158 	 * Now we've set up the block conversion variables, we can calculate the
159 	 * segment block constants using the geometry structure.
160 	 */
161 	dageo->datablk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_DATA_OFFSET);
162 	dageo->leafblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_LEAF_OFFSET);
163 	dageo->freeblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_FREE_OFFSET);
164 	dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) /
165 				(uint)sizeof(xfs_da_node_entry_t);
166 	dageo->max_extents = (XFS_DIR2_MAX_SPACES * XFS_DIR2_SPACE_SIZE) >>
167 					mp->m_sb.sb_blocklog;
168 	dageo->magicpct = (dageo->blksize * 37) / 100;
169 
170 	/* set up attribute geometry - single fsb only */
171 	dageo = mp->m_attr_geo;
172 	dageo->blklog = mp->m_sb.sb_blocklog;
173 	dageo->fsblog = mp->m_sb.sb_blocklog;
174 	dageo->blksize = 1 << dageo->blklog;
175 	dageo->fsbcount = 1;
176 	dageo->node_hdr_size = mp->m_dir_geo->node_hdr_size;
177 	dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) /
178 				(uint)sizeof(xfs_da_node_entry_t);
179 
180 	if (xfs_has_large_extent_counts(mp))
181 		dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_LARGE;
182 	else
183 		dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_SMALL;
184 
185 	dageo->magicpct = (dageo->blksize * 37) / 100;
186 	return 0;
187 }
188 
189 void
190 xfs_da_unmount(
191 	struct xfs_mount	*mp)
192 {
193 	kfree(mp->m_dir_geo);
194 	kfree(mp->m_attr_geo);
195 }
196 
197 /*
198  * Return 1 if directory contains only "." and "..".
199  */
200 int
201 xfs_dir_isempty(
202 	xfs_inode_t	*dp)
203 {
204 	xfs_dir2_sf_hdr_t	*sfp;
205 
206 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
207 	if (dp->i_disk_size == 0)	/* might happen during shutdown. */
208 		return 1;
209 	if (dp->i_disk_size > xfs_inode_data_fork_size(dp))
210 		return 0;
211 	sfp = dp->i_df.if_data;
212 	return !sfp->count;
213 }
214 
215 /*
216  * Validate a given inode number.
217  */
218 int
219 xfs_dir_ino_validate(
220 	xfs_mount_t	*mp,
221 	xfs_ino_t	ino)
222 {
223 	bool		ino_ok = xfs_verify_dir_ino(mp, ino);
224 
225 	if (XFS_IS_CORRUPT(mp, !ino_ok) ||
226 	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) {
227 		xfs_warn(mp, "Invalid inode number 0x%Lx",
228 				(unsigned long long) ino);
229 		return -EFSCORRUPTED;
230 	}
231 	return 0;
232 }
233 
234 /*
235  * Initialize a directory with its "." and ".." entries.
236  */
237 int
238 xfs_dir_init(
239 	xfs_trans_t	*tp,
240 	xfs_inode_t	*dp,
241 	xfs_inode_t	*pdp)
242 {
243 	struct xfs_da_args *args;
244 	int		error;
245 
246 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
247 	error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino);
248 	if (error)
249 		return error;
250 
251 	args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL);
252 	if (!args)
253 		return -ENOMEM;
254 
255 	args->geo = dp->i_mount->m_dir_geo;
256 	args->dp = dp;
257 	args->trans = tp;
258 	args->owner = dp->i_ino;
259 	error = xfs_dir2_sf_create(args, pdp->i_ino);
260 	kfree(args);
261 	return error;
262 }
263 
264 enum xfs_dir2_fmt
265 xfs_dir2_format(
266 	struct xfs_da_args	*args,
267 	int			*error)
268 {
269 	struct xfs_inode	*dp = args->dp;
270 	struct xfs_mount	*mp = dp->i_mount;
271 	struct xfs_da_geometry	*geo = mp->m_dir_geo;
272 	xfs_fileoff_t		eof;
273 
274 	xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
275 
276 	*error = 0;
277 	if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL)
278 		return XFS_DIR2_FMT_SF;
279 
280 	*error = xfs_bmap_last_offset(dp, &eof, XFS_DATA_FORK);
281 	if (*error)
282 		return XFS_DIR2_FMT_ERROR;
283 
284 	if (eof == XFS_B_TO_FSB(mp, geo->blksize)) {
285 		if (XFS_IS_CORRUPT(mp, dp->i_disk_size != geo->blksize)) {
286 			xfs_da_mark_sick(args);
287 			*error = -EFSCORRUPTED;
288 			return XFS_DIR2_FMT_ERROR;
289 		}
290 		return XFS_DIR2_FMT_BLOCK;
291 	}
292 	if (eof == geo->leafblk + geo->fsbcount)
293 		return XFS_DIR2_FMT_LEAF;
294 	return XFS_DIR2_FMT_NODE;
295 }
296 
297 int
298 xfs_dir_createname_args(
299 	struct xfs_da_args	*args)
300 {
301 	int			error;
302 
303 	if (!args->inumber)
304 		args->op_flags |= XFS_DA_OP_JUSTCHECK;
305 
306 	switch (xfs_dir2_format(args, &error)) {
307 	case XFS_DIR2_FMT_SF:
308 		return xfs_dir2_sf_addname(args);
309 	case XFS_DIR2_FMT_BLOCK:
310 		return xfs_dir2_block_addname(args);
311 	case XFS_DIR2_FMT_LEAF:
312 		return xfs_dir2_leaf_addname(args);
313 	case XFS_DIR2_FMT_NODE:
314 		return xfs_dir2_node_addname(args);
315 	default:
316 		return error;
317 	}
318 }
319 
320 /*
321  * Enter a name in a directory, or check for available space.
322  * If inum is 0, only the available space test is performed.
323  */
324 int
325 xfs_dir_createname(
326 	struct xfs_trans	*tp,
327 	struct xfs_inode	*dp,
328 	const struct xfs_name	*name,
329 	xfs_ino_t		inum,		/* new entry inode number */
330 	xfs_extlen_t		total)		/* bmap's total block count */
331 {
332 	struct xfs_da_args	*args;
333 	int			rval;
334 
335 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
336 
337 	if (inum) {
338 		rval = xfs_dir_ino_validate(tp->t_mountp, inum);
339 		if (rval)
340 			return rval;
341 		XFS_STATS_INC(dp->i_mount, xs_dir_create);
342 	}
343 
344 	args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL);
345 	if (!args)
346 		return -ENOMEM;
347 
348 	args->geo = dp->i_mount->m_dir_geo;
349 	args->name = name->name;
350 	args->namelen = name->len;
351 	args->filetype = name->type;
352 	args->hashval = xfs_dir2_hashname(dp->i_mount, name);
353 	args->inumber = inum;
354 	args->dp = dp;
355 	args->total = total;
356 	args->whichfork = XFS_DATA_FORK;
357 	args->trans = tp;
358 	args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
359 	args->owner = dp->i_ino;
360 
361 	rval = xfs_dir_createname_args(args);
362 	kfree(args);
363 	return rval;
364 }
365 
366 /*
367  * If doing a CI lookup and case-insensitive match, dup actual name into
368  * args.value. Return EEXIST for success (ie. name found) or an error.
369  */
370 int
371 xfs_dir_cilookup_result(
372 	struct xfs_da_args *args,
373 	const unsigned char *name,
374 	int		len)
375 {
376 	if (args->cmpresult == XFS_CMP_DIFFERENT)
377 		return -ENOENT;
378 	if (args->cmpresult != XFS_CMP_CASE ||
379 					!(args->op_flags & XFS_DA_OP_CILOOKUP))
380 		return -EEXIST;
381 
382 	args->value = kmalloc(len,
383 			GFP_KERNEL | __GFP_NOLOCKDEP | __GFP_RETRY_MAYFAIL);
384 	if (!args->value)
385 		return -ENOMEM;
386 
387 	memcpy(args->value, name, len);
388 	args->valuelen = len;
389 	return -EEXIST;
390 }
391 
392 int
393 xfs_dir_lookup_args(
394 	struct xfs_da_args	*args)
395 {
396 	int			error;
397 
398 	switch (xfs_dir2_format(args, &error)) {
399 	case XFS_DIR2_FMT_SF:
400 		error = xfs_dir2_sf_lookup(args);
401 		break;
402 	case XFS_DIR2_FMT_BLOCK:
403 		error = xfs_dir2_block_lookup(args);
404 		break;
405 	case XFS_DIR2_FMT_LEAF:
406 		error = xfs_dir2_leaf_lookup(args);
407 		break;
408 	case XFS_DIR2_FMT_NODE:
409 		error = xfs_dir2_node_lookup(args);
410 		break;
411 	default:
412 		break;
413 	}
414 
415 	if (error != -EEXIST)
416 		return error;
417 	return 0;
418 }
419 
420 /*
421  * Lookup a name in a directory, give back the inode number.
422  * If ci_name is not NULL, returns the actual name in ci_name if it differs
423  * to name, or ci_name->name is set to NULL for an exact match.
424  */
425 
426 int
427 xfs_dir_lookup(
428 	struct xfs_trans	*tp,
429 	struct xfs_inode	*dp,
430 	const struct xfs_name	*name,
431 	xfs_ino_t		*inum,	  /* out: inode number */
432 	struct xfs_name		*ci_name) /* out: actual name if CI match */
433 {
434 	struct xfs_da_args	*args;
435 	int			rval;
436 	int			lock_mode;
437 
438 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
439 	XFS_STATS_INC(dp->i_mount, xs_dir_lookup);
440 
441 	args = kzalloc(sizeof(*args),
442 			GFP_KERNEL | __GFP_NOLOCKDEP | __GFP_NOFAIL);
443 	args->geo = dp->i_mount->m_dir_geo;
444 	args->name = name->name;
445 	args->namelen = name->len;
446 	args->filetype = name->type;
447 	args->hashval = xfs_dir2_hashname(dp->i_mount, name);
448 	args->dp = dp;
449 	args->whichfork = XFS_DATA_FORK;
450 	args->trans = tp;
451 	args->op_flags = XFS_DA_OP_OKNOENT;
452 	args->owner = dp->i_ino;
453 	if (ci_name)
454 		args->op_flags |= XFS_DA_OP_CILOOKUP;
455 
456 	lock_mode = xfs_ilock_data_map_shared(dp);
457 	rval = xfs_dir_lookup_args(args);
458 	if (!rval) {
459 		*inum = args->inumber;
460 		if (ci_name) {
461 			ci_name->name = args->value;
462 			ci_name->len = args->valuelen;
463 		}
464 	}
465 	xfs_iunlock(dp, lock_mode);
466 	kfree(args);
467 	return rval;
468 }
469 
470 int
471 xfs_dir_removename_args(
472 	struct xfs_da_args	*args)
473 {
474 	int			error;
475 
476 	switch (xfs_dir2_format(args, &error)) {
477 	case XFS_DIR2_FMT_SF:
478 		return xfs_dir2_sf_removename(args);
479 	case XFS_DIR2_FMT_BLOCK:
480 		return xfs_dir2_block_removename(args);
481 	case XFS_DIR2_FMT_LEAF:
482 		return xfs_dir2_leaf_removename(args);
483 	case XFS_DIR2_FMT_NODE:
484 		return xfs_dir2_node_removename(args);
485 	default:
486 		return error;
487 	}
488 }
489 
490 /*
491  * Remove an entry from a directory.
492  */
493 int
494 xfs_dir_removename(
495 	struct xfs_trans	*tp,
496 	struct xfs_inode	*dp,
497 	const struct xfs_name	*name,
498 	xfs_ino_t		ino,
499 	xfs_extlen_t		total)		/* bmap's total block count */
500 {
501 	struct xfs_da_args	*args;
502 	int			rval;
503 
504 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
505 	XFS_STATS_INC(dp->i_mount, xs_dir_remove);
506 
507 	args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL);
508 	if (!args)
509 		return -ENOMEM;
510 
511 	args->geo = dp->i_mount->m_dir_geo;
512 	args->name = name->name;
513 	args->namelen = name->len;
514 	args->filetype = name->type;
515 	args->hashval = xfs_dir2_hashname(dp->i_mount, name);
516 	args->inumber = ino;
517 	args->dp = dp;
518 	args->total = total;
519 	args->whichfork = XFS_DATA_FORK;
520 	args->trans = tp;
521 	args->owner = dp->i_ino;
522 	rval = xfs_dir_removename_args(args);
523 	kfree(args);
524 	return rval;
525 }
526 
527 int
528 xfs_dir_replace_args(
529 	struct xfs_da_args	*args)
530 {
531 	int			error;
532 
533 	switch (xfs_dir2_format(args, &error)) {
534 	case XFS_DIR2_FMT_SF:
535 		return xfs_dir2_sf_replace(args);
536 	case XFS_DIR2_FMT_BLOCK:
537 		return xfs_dir2_block_replace(args);
538 	case XFS_DIR2_FMT_LEAF:
539 		return xfs_dir2_leaf_replace(args);
540 	case XFS_DIR2_FMT_NODE:
541 		return xfs_dir2_node_replace(args);
542 	default:
543 		return error;
544 	}
545 }
546 
547 /*
548  * Replace the inode number of a directory entry.
549  */
550 int
551 xfs_dir_replace(
552 	struct xfs_trans	*tp,
553 	struct xfs_inode	*dp,
554 	const struct xfs_name	*name,		/* name of entry to replace */
555 	xfs_ino_t		inum,		/* new inode number */
556 	xfs_extlen_t		total)		/* bmap's total block count */
557 {
558 	struct xfs_da_args	*args;
559 	int			rval;
560 
561 	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
562 
563 	rval = xfs_dir_ino_validate(tp->t_mountp, inum);
564 	if (rval)
565 		return rval;
566 
567 	args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL);
568 	if (!args)
569 		return -ENOMEM;
570 
571 	args->geo = dp->i_mount->m_dir_geo;
572 	args->name = name->name;
573 	args->namelen = name->len;
574 	args->filetype = name->type;
575 	args->hashval = xfs_dir2_hashname(dp->i_mount, name);
576 	args->inumber = inum;
577 	args->dp = dp;
578 	args->total = total;
579 	args->whichfork = XFS_DATA_FORK;
580 	args->trans = tp;
581 	args->owner = dp->i_ino;
582 	rval = xfs_dir_replace_args(args);
583 	kfree(args);
584 	return rval;
585 }
586 
587 /*
588  * See if this entry can be added to the directory without allocating space.
589  */
590 int
591 xfs_dir_canenter(
592 	struct xfs_trans	*tp,
593 	struct xfs_inode	*dp,
594 	const struct xfs_name	*name)		/* name of entry to add */
595 {
596 	return xfs_dir_createname(tp, dp, name, 0, 0);
597 }
598 
599 /*
600  * Utility routines.
601  */
602 
603 /*
604  * Add a block to the directory.
605  *
606  * This routine is for data and free blocks, not leaf/node blocks which are
607  * handled by xfs_da_grow_inode.
608  */
609 int
610 xfs_dir2_grow_inode(
611 	struct xfs_da_args	*args,
612 	int			space,	/* v2 dir's space XFS_DIR2_xxx_SPACE */
613 	xfs_dir2_db_t		*dbp)	/* out: block number added */
614 {
615 	struct xfs_inode	*dp = args->dp;
616 	struct xfs_mount	*mp = dp->i_mount;
617 	xfs_fileoff_t		bno;	/* directory offset of new block */
618 	int			count;	/* count of filesystem blocks */
619 	int			error;
620 
621 	trace_xfs_dir2_grow_inode(args, space);
622 
623 	/*
624 	 * Set lowest possible block in the space requested.
625 	 */
626 	bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE);
627 	count = args->geo->fsbcount;
628 
629 	error = xfs_da_grow_inode_int(args, &bno, count);
630 	if (error)
631 		return error;
632 
633 	*dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno);
634 
635 	/*
636 	 * Update file's size if this is the data space and it grew.
637 	 */
638 	if (space == XFS_DIR2_DATA_SPACE) {
639 		xfs_fsize_t	size;		/* directory file (data) size */
640 
641 		size = XFS_FSB_TO_B(mp, bno + count);
642 		if (size > dp->i_disk_size) {
643 			dp->i_disk_size = size;
644 			xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
645 		}
646 	}
647 	return 0;
648 }
649 
650 /*
651  * Remove the given block from the directory.
652  * This routine is used for data and free blocks, leaf/node are done
653  * by xfs_da_shrink_inode.
654  */
655 int
656 xfs_dir2_shrink_inode(
657 	struct xfs_da_args	*args,
658 	xfs_dir2_db_t		db,
659 	struct xfs_buf		*bp)
660 {
661 	xfs_fileoff_t		bno;		/* directory file offset */
662 	xfs_dablk_t		da;		/* directory file offset */
663 	int			done;		/* bunmap is finished */
664 	struct xfs_inode	*dp;
665 	int			error;
666 	struct xfs_mount	*mp;
667 	struct xfs_trans	*tp;
668 
669 	trace_xfs_dir2_shrink_inode(args, db);
670 
671 	dp = args->dp;
672 	mp = dp->i_mount;
673 	tp = args->trans;
674 	da = xfs_dir2_db_to_da(args->geo, db);
675 
676 	/* Unmap the fsblock(s). */
677 	error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, &done);
678 	if (error) {
679 		/*
680 		 * ENOSPC actually can happen if we're in a removename with no
681 		 * space reservation, and the resulting block removal would
682 		 * cause a bmap btree split or conversion from extents to btree.
683 		 * This can only happen for un-fragmented directory blocks,
684 		 * since you need to be punching out the middle of an extent.
685 		 * In this case we need to leave the block in the file, and not
686 		 * binval it.  So the block has to be in a consistent empty
687 		 * state and appropriately logged.  We don't free up the buffer,
688 		 * the caller can tell it hasn't happened since it got an error
689 		 * back.
690 		 */
691 		return error;
692 	}
693 	ASSERT(done);
694 	/*
695 	 * Invalidate the buffer from the transaction.
696 	 */
697 	xfs_trans_binval(tp, bp);
698 	/*
699 	 * If it's not a data block, we're done.
700 	 */
701 	if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET))
702 		return 0;
703 	/*
704 	 * If the block isn't the last one in the directory, we're done.
705 	 */
706 	if (dp->i_disk_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0))
707 		return 0;
708 	bno = da;
709 	if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
710 		/*
711 		 * This can't really happen unless there's kernel corruption.
712 		 */
713 		return error;
714 	}
715 	if (db == args->geo->datablk)
716 		ASSERT(bno == 0);
717 	else
718 		ASSERT(bno > 0);
719 	/*
720 	 * Set the size to the new last block.
721 	 */
722 	dp->i_disk_size = XFS_FSB_TO_B(mp, bno);
723 	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
724 	return 0;
725 }
726 
727 /* Returns true if the directory entry name is valid. */
728 bool
729 xfs_dir2_namecheck(
730 	const void	*name,
731 	size_t		length)
732 {
733 	/*
734 	 * MAXNAMELEN includes the trailing null, but (name/length) leave it
735 	 * out, so use >= for the length check.
736 	 */
737 	if (length >= MAXNAMELEN)
738 		return false;
739 
740 	/* There shouldn't be any slashes or nulls here */
741 	return !memchr(name, '/', length) && !memchr(name, 0, length);
742 }
743 
744 xfs_dahash_t
745 xfs_dir2_hashname(
746 	struct xfs_mount	*mp,
747 	const struct xfs_name	*name)
748 {
749 	if (unlikely(xfs_has_asciici(mp)))
750 		return xfs_ascii_ci_hashname(name);
751 	return xfs_da_hashname(name->name, name->len);
752 }
753 
754 enum xfs_dacmp
755 xfs_dir2_compname(
756 	struct xfs_da_args	*args,
757 	const unsigned char	*name,
758 	int			len)
759 {
760 	if (unlikely(xfs_has_asciici(args->dp->i_mount)))
761 		return xfs_ascii_ci_compname(args, name, len);
762 	return xfs_da_compname(args, name, len);
763 }
764 
765 #ifdef CONFIG_XFS_LIVE_HOOKS
766 /*
767  * Use a static key here to reduce the overhead of directory live update hooks.
768  * If the compiler supports jump labels, the static branch will be replaced by
769  * a nop sled when there are no hook users.  Online fsck is currently the only
770  * caller, so this is a reasonable tradeoff.
771  *
772  * Note: Patching the kernel code requires taking the cpu hotplug lock.  Other
773  * parts of the kernel allocate memory with that lock held, which means that
774  * XFS callers cannot hold any locks that might be used by memory reclaim or
775  * writeback when calling the static_branch_{inc,dec} functions.
776  */
777 DEFINE_STATIC_XFS_HOOK_SWITCH(xfs_dir_hooks_switch);
778 
779 void
780 xfs_dir_hook_disable(void)
781 {
782 	xfs_hooks_switch_off(&xfs_dir_hooks_switch);
783 }
784 
785 void
786 xfs_dir_hook_enable(void)
787 {
788 	xfs_hooks_switch_on(&xfs_dir_hooks_switch);
789 }
790 
791 /* Call hooks for a directory update relating to a child dirent update. */
792 inline void
793 xfs_dir_update_hook(
794 	struct xfs_inode		*dp,
795 	struct xfs_inode		*ip,
796 	int				delta,
797 	const struct xfs_name		*name)
798 {
799 	if (xfs_hooks_switched_on(&xfs_dir_hooks_switch)) {
800 		struct xfs_dir_update_params	p = {
801 			.dp		= dp,
802 			.ip		= ip,
803 			.delta		= delta,
804 			.name		= name,
805 		};
806 		struct xfs_mount	*mp = ip->i_mount;
807 
808 		xfs_hooks_call(&mp->m_dir_update_hooks, 0, &p);
809 	}
810 }
811 
812 /* Call the specified function during a directory update. */
813 int
814 xfs_dir_hook_add(
815 	struct xfs_mount	*mp,
816 	struct xfs_dir_hook	*hook)
817 {
818 	return xfs_hooks_add(&mp->m_dir_update_hooks, &hook->dirent_hook);
819 }
820 
821 /* Stop calling the specified function during a directory update. */
822 void
823 xfs_dir_hook_del(
824 	struct xfs_mount	*mp,
825 	struct xfs_dir_hook	*hook)
826 {
827 	xfs_hooks_del(&mp->m_dir_update_hooks, &hook->dirent_hook);
828 }
829 
830 /* Configure directory update hook functions. */
831 void
832 xfs_dir_hook_setup(
833 	struct xfs_dir_hook	*hook,
834 	notifier_fn_t		mod_fn)
835 {
836 	xfs_hook_setup(&hook->dirent_hook, mod_fn);
837 }
838 #endif /* CONFIG_XFS_LIVE_HOOKS */
839 
840 /*
841  * Given a directory @dp, a newly allocated inode @ip, and a @name, link @ip
842  * into @dp under the given @name.  If @ip is a directory, it will be
843  * initialized.  Both inodes must have the ILOCK held and the transaction must
844  * have sufficient blocks reserved.
845  */
846 int
847 xfs_dir_create_child(
848 	struct xfs_trans	*tp,
849 	unsigned int		resblks,
850 	struct xfs_dir_update	*du)
851 {
852 	struct xfs_inode	*dp = du->dp;
853 	const struct xfs_name	*name = du->name;
854 	struct xfs_inode	*ip = du->ip;
855 	int			error;
856 
857 	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
858 	xfs_assert_ilocked(dp, XFS_ILOCK_EXCL);
859 
860 	error = xfs_dir_createname(tp, dp, name, ip->i_ino, resblks);
861 	if (error) {
862 		ASSERT(error != -ENOSPC);
863 		return error;
864 	}
865 
866 	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
867 	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
868 
869 	if (S_ISDIR(VFS_I(ip)->i_mode)) {
870 		error = xfs_dir_init(tp, ip, dp);
871 		if (error)
872 			return error;
873 
874 		xfs_bumplink(tp, dp);
875 	}
876 
877 	/*
878 	 * If we have parent pointers, we need to add the attribute containing
879 	 * the parent information now.
880 	 */
881 	if (du->ppargs) {
882 		error = xfs_parent_addname(tp, du->ppargs, dp, name, ip);
883 		if (error)
884 			return error;
885 	}
886 
887 	xfs_dir_update_hook(dp, ip, 1, name);
888 	return 0;
889 }
890 
891 /*
892  * Given a directory @dp, an existing non-directory inode @ip, and a @name,
893  * link @ip into @dp under the given @name.  Both inodes must have the ILOCK
894  * held.
895  */
896 int
897 xfs_dir_add_child(
898 	struct xfs_trans	*tp,
899 	unsigned int		resblks,
900 	struct xfs_dir_update	*du)
901 {
902 	struct xfs_inode	*dp = du->dp;
903 	const struct xfs_name	*name = du->name;
904 	struct xfs_inode	*ip = du->ip;
905 	struct xfs_mount	*mp = tp->t_mountp;
906 	int			error;
907 
908 	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
909 	xfs_assert_ilocked(dp, XFS_ILOCK_EXCL);
910 	ASSERT(!S_ISDIR(VFS_I(ip)->i_mode));
911 
912 	if (!resblks) {
913 		error = xfs_dir_canenter(tp, dp, name);
914 		if (error)
915 			return error;
916 	}
917 
918 	/*
919 	 * Handle initial link state of O_TMPFILE inode
920 	 */
921 	if (VFS_I(ip)->i_nlink == 0) {
922 		struct xfs_perag	*pag;
923 
924 		pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
925 		error = xfs_iunlink_remove(tp, pag, ip);
926 		xfs_perag_put(pag);
927 		if (error)
928 			return error;
929 	}
930 
931 	error = xfs_dir_createname(tp, dp, name, ip->i_ino, resblks);
932 	if (error)
933 		return error;
934 
935 	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
936 	xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
937 
938 	xfs_bumplink(tp, ip);
939 
940 	/*
941 	 * If we have parent pointers, we now need to add the parent record to
942 	 * the attribute fork of the inode. If this is the initial parent
943 	 * attribute, we need to create it correctly, otherwise we can just add
944 	 * the parent to the inode.
945 	 */
946 	if (du->ppargs) {
947 		error = xfs_parent_addname(tp, du->ppargs, dp, name, ip);
948 		if (error)
949 			return error;
950 	}
951 
952 	xfs_dir_update_hook(dp, ip, 1, name);
953 	return 0;
954 }
955 
956 /*
957  * Given a directory @dp, a child @ip, and a @name, remove the (@name, @ip)
958  * entry from the directory.  Both inodes must have the ILOCK held.
959  */
960 int
961 xfs_dir_remove_child(
962 	struct xfs_trans	*tp,
963 	unsigned int		resblks,
964 	struct xfs_dir_update	*du)
965 {
966 	struct xfs_inode	*dp = du->dp;
967 	const struct xfs_name	*name = du->name;
968 	struct xfs_inode	*ip = du->ip;
969 	int			error;
970 
971 	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
972 	xfs_assert_ilocked(dp, XFS_ILOCK_EXCL);
973 
974 	/*
975 	 * If we're removing a directory perform some additional validation.
976 	 */
977 	if (S_ISDIR(VFS_I(ip)->i_mode)) {
978 		ASSERT(VFS_I(ip)->i_nlink >= 2);
979 		if (VFS_I(ip)->i_nlink != 2)
980 			return -ENOTEMPTY;
981 		if (!xfs_dir_isempty(ip))
982 			return -ENOTEMPTY;
983 
984 		/* Drop the link from ip's "..".  */
985 		error = xfs_droplink(tp, dp);
986 		if (error)
987 			return error;
988 
989 		/* Drop the "." link from ip to self.  */
990 		error = xfs_droplink(tp, ip);
991 		if (error)
992 			return error;
993 
994 		/*
995 		 * Point the unlinked child directory's ".." entry to the root
996 		 * directory to eliminate back-references to inodes that may
997 		 * get freed before the child directory is closed.  If the fs
998 		 * gets shrunk, this can lead to dirent inode validation errors.
999 		 */
1000 		if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) {
1001 			error = xfs_dir_replace(tp, ip, &xfs_name_dotdot,
1002 					tp->t_mountp->m_sb.sb_rootino, 0);
1003 			if (error)
1004 				return error;
1005 		}
1006 	} else {
1007 		/*
1008 		 * When removing a non-directory we need to log the parent
1009 		 * inode here.  For a directory this is done implicitly
1010 		 * by the xfs_droplink call for the ".." entry.
1011 		 */
1012 		xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1013 	}
1014 	xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1015 
1016 	/* Drop the link from dp to ip. */
1017 	error = xfs_droplink(tp, ip);
1018 	if (error)
1019 		return error;
1020 
1021 	error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks);
1022 	if (error) {
1023 		ASSERT(error != -ENOENT);
1024 		return error;
1025 	}
1026 
1027 	/* Remove parent pointer. */
1028 	if (du->ppargs) {
1029 		error = xfs_parent_removename(tp, du->ppargs, dp, name, ip);
1030 		if (error)
1031 			return error;
1032 	}
1033 
1034 	xfs_dir_update_hook(dp, ip, -1, name);
1035 	return 0;
1036 }
1037 
1038 /*
1039  * Exchange the entry (@name1, @ip1) in directory @dp1 with the entry (@name2,
1040  * @ip2) in directory @dp2, and update '..' @ip1 and @ip2's entries as needed.
1041  * @ip1 and @ip2 need not be of the same type.
1042  *
1043  * All inodes must have the ILOCK held, and both entries must already exist.
1044  */
1045 int
1046 xfs_dir_exchange_children(
1047 	struct xfs_trans	*tp,
1048 	struct xfs_dir_update	*du1,
1049 	struct xfs_dir_update	*du2,
1050 	unsigned int		spaceres)
1051 {
1052 	struct xfs_inode	*dp1 = du1->dp;
1053 	const struct xfs_name	*name1 = du1->name;
1054 	struct xfs_inode	*ip1 = du1->ip;
1055 	struct xfs_inode	*dp2 = du2->dp;
1056 	const struct xfs_name	*name2 = du2->name;
1057 	struct xfs_inode	*ip2 = du2->ip;
1058 	int			ip1_flags = 0;
1059 	int			ip2_flags = 0;
1060 	int			dp2_flags = 0;
1061 	int			error;
1062 
1063 	/* Swap inode number for dirent in first parent */
1064 	error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, spaceres);
1065 	if (error)
1066 		return error;
1067 
1068 	/* Swap inode number for dirent in second parent */
1069 	error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres);
1070 	if (error)
1071 		return error;
1072 
1073 	/*
1074 	 * If we're renaming one or more directories across different parents,
1075 	 * update the respective ".." entries (and link counts) to match the new
1076 	 * parents.
1077 	 */
1078 	if (dp1 != dp2) {
1079 		dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
1080 
1081 		if (S_ISDIR(VFS_I(ip2)->i_mode)) {
1082 			error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
1083 						dp1->i_ino, spaceres);
1084 			if (error)
1085 				return error;
1086 
1087 			/* transfer ip2 ".." reference to dp1 */
1088 			if (!S_ISDIR(VFS_I(ip1)->i_mode)) {
1089 				error = xfs_droplink(tp, dp2);
1090 				if (error)
1091 					return error;
1092 				xfs_bumplink(tp, dp1);
1093 			}
1094 
1095 			/*
1096 			 * Although ip1 isn't changed here, userspace needs
1097 			 * to be warned about the change, so that applications
1098 			 * relying on it (like backup ones), will properly
1099 			 * notify the change
1100 			 */
1101 			ip1_flags |= XFS_ICHGTIME_CHG;
1102 			ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
1103 		}
1104 
1105 		if (S_ISDIR(VFS_I(ip1)->i_mode)) {
1106 			error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
1107 						dp2->i_ino, spaceres);
1108 			if (error)
1109 				return error;
1110 
1111 			/* transfer ip1 ".." reference to dp2 */
1112 			if (!S_ISDIR(VFS_I(ip2)->i_mode)) {
1113 				error = xfs_droplink(tp, dp1);
1114 				if (error)
1115 					return error;
1116 				xfs_bumplink(tp, dp2);
1117 			}
1118 
1119 			/*
1120 			 * Although ip2 isn't changed here, userspace needs
1121 			 * to be warned about the change, so that applications
1122 			 * relying on it (like backup ones), will properly
1123 			 * notify the change
1124 			 */
1125 			ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
1126 			ip2_flags |= XFS_ICHGTIME_CHG;
1127 		}
1128 	}
1129 
1130 	if (ip1_flags) {
1131 		xfs_trans_ichgtime(tp, ip1, ip1_flags);
1132 		xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE);
1133 	}
1134 	if (ip2_flags) {
1135 		xfs_trans_ichgtime(tp, ip2, ip2_flags);
1136 		xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE);
1137 	}
1138 	if (dp2_flags) {
1139 		xfs_trans_ichgtime(tp, dp2, dp2_flags);
1140 		xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE);
1141 	}
1142 	xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1143 	xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
1144 
1145 	/* Schedule parent pointer replacements */
1146 	if (du1->ppargs) {
1147 		error = xfs_parent_replacename(tp, du1->ppargs, dp1, name1,
1148 				dp2, name2, ip1);
1149 		if (error)
1150 			return error;
1151 	}
1152 
1153 	if (du2->ppargs) {
1154 		error = xfs_parent_replacename(tp, du2->ppargs, dp2, name2,
1155 				dp1, name1, ip2);
1156 		if (error)
1157 			return error;
1158 	}
1159 
1160 	/*
1161 	 * Inform our hook clients that we've finished an exchange operation as
1162 	 * follows: removed the source and target files from their directories;
1163 	 * added the target to the source directory; and added the source to
1164 	 * the target directory.  All inodes are locked, so it's ok to model a
1165 	 * rename this way so long as we say we deleted entries before we add
1166 	 * new ones.
1167 	 */
1168 	xfs_dir_update_hook(dp1, ip1, -1, name1);
1169 	xfs_dir_update_hook(dp2, ip2, -1, name2);
1170 	xfs_dir_update_hook(dp1, ip2, 1, name1);
1171 	xfs_dir_update_hook(dp2, ip1, 1, name2);
1172 	return 0;
1173 }
1174 
1175 /*
1176  * Given an entry (@src_name, @src_ip) in directory @src_dp, make the entry
1177  * @target_name in directory @target_dp point to @src_ip and remove the
1178  * original entry, cleaning up everything left behind.
1179  *
1180  * Cleanup involves dropping a link count on @target_ip, and either removing
1181  * the (@src_name, @src_ip) entry from @src_dp or simply replacing the entry
1182  * with (@src_name, @wip) if a whiteout inode @wip is supplied.
1183  *
1184  * All inodes must have the ILOCK held.  We assume that if @src_ip is a
1185  * directory then its '..' doesn't already point to @target_dp, and that @wip
1186  * is a freshly allocated whiteout.
1187  */
1188 int
1189 xfs_dir_rename_children(
1190 	struct xfs_trans	*tp,
1191 	struct xfs_dir_update	*du_src,
1192 	struct xfs_dir_update	*du_tgt,
1193 	unsigned int		spaceres,
1194 	struct xfs_dir_update	*du_wip)
1195 {
1196 	struct xfs_mount	*mp = tp->t_mountp;
1197 	struct xfs_inode	*src_dp = du_src->dp;
1198 	const struct xfs_name	*src_name = du_src->name;
1199 	struct xfs_inode	*src_ip = du_src->ip;
1200 	struct xfs_inode	*target_dp = du_tgt->dp;
1201 	const struct xfs_name	*target_name = du_tgt->name;
1202 	struct xfs_inode	*target_ip = du_tgt->ip;
1203 	bool			new_parent = (src_dp != target_dp);
1204 	bool			src_is_directory;
1205 	int			error;
1206 
1207 	src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode);
1208 
1209 	/*
1210 	 * Check for expected errors before we dirty the transaction
1211 	 * so we can return an error without a transaction abort.
1212 	 */
1213 	if (target_ip == NULL) {
1214 		/*
1215 		 * If there's no space reservation, check the entry will
1216 		 * fit before actually inserting it.
1217 		 */
1218 		if (!spaceres) {
1219 			error = xfs_dir_canenter(tp, target_dp, target_name);
1220 			if (error)
1221 				return error;
1222 		}
1223 	} else {
1224 		/*
1225 		 * If target exists and it's a directory, check that whether
1226 		 * it can be destroyed.
1227 		 */
1228 		if (S_ISDIR(VFS_I(target_ip)->i_mode) &&
1229 		    (!xfs_dir_isempty(target_ip) ||
1230 		     (VFS_I(target_ip)->i_nlink > 2)))
1231 			return -EEXIST;
1232 	}
1233 
1234 	/*
1235 	 * Directory entry creation below may acquire the AGF. Remove
1236 	 * the whiteout from the unlinked list first to preserve correct
1237 	 * AGI/AGF locking order. This dirties the transaction so failures
1238 	 * after this point will abort and log recovery will clean up the
1239 	 * mess.
1240 	 *
1241 	 * For whiteouts, we need to bump the link count on the whiteout
1242 	 * inode. After this point, we have a real link, clear the tmpfile
1243 	 * state flag from the inode so it doesn't accidentally get misused
1244 	 * in future.
1245 	 */
1246 	if (du_wip->ip) {
1247 		struct xfs_perag	*pag;
1248 
1249 		ASSERT(VFS_I(du_wip->ip)->i_nlink == 0);
1250 
1251 		pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, du_wip->ip->i_ino));
1252 		error = xfs_iunlink_remove(tp, pag, du_wip->ip);
1253 		xfs_perag_put(pag);
1254 		if (error)
1255 			return error;
1256 
1257 		xfs_bumplink(tp, du_wip->ip);
1258 	}
1259 
1260 	/*
1261 	 * Set up the target.
1262 	 */
1263 	if (target_ip == NULL) {
1264 		/*
1265 		 * If target does not exist and the rename crosses
1266 		 * directories, adjust the target directory link count
1267 		 * to account for the ".." reference from the new entry.
1268 		 */
1269 		error = xfs_dir_createname(tp, target_dp, target_name,
1270 					   src_ip->i_ino, spaceres);
1271 		if (error)
1272 			return error;
1273 
1274 		xfs_trans_ichgtime(tp, target_dp,
1275 					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1276 
1277 		if (new_parent && src_is_directory) {
1278 			xfs_bumplink(tp, target_dp);
1279 		}
1280 	} else { /* target_ip != NULL */
1281 		/*
1282 		 * Link the source inode under the target name.
1283 		 * If the source inode is a directory and we are moving
1284 		 * it across directories, its ".." entry will be
1285 		 * inconsistent until we replace that down below.
1286 		 *
1287 		 * In case there is already an entry with the same
1288 		 * name at the destination directory, remove it first.
1289 		 */
1290 		error = xfs_dir_replace(tp, target_dp, target_name,
1291 					src_ip->i_ino, spaceres);
1292 		if (error)
1293 			return error;
1294 
1295 		xfs_trans_ichgtime(tp, target_dp,
1296 					XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1297 
1298 		/*
1299 		 * Decrement the link count on the target since the target
1300 		 * dir no longer points to it.
1301 		 */
1302 		error = xfs_droplink(tp, target_ip);
1303 		if (error)
1304 			return error;
1305 
1306 		if (src_is_directory) {
1307 			/*
1308 			 * Drop the link from the old "." entry.
1309 			 */
1310 			error = xfs_droplink(tp, target_ip);
1311 			if (error)
1312 				return error;
1313 		}
1314 	} /* target_ip != NULL */
1315 
1316 	/*
1317 	 * Remove the source.
1318 	 */
1319 	if (new_parent && src_is_directory) {
1320 		/*
1321 		 * Rewrite the ".." entry to point to the new
1322 		 * directory.
1323 		 */
1324 		error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
1325 					target_dp->i_ino, spaceres);
1326 		ASSERT(error != -EEXIST);
1327 		if (error)
1328 			return error;
1329 	}
1330 
1331 	/*
1332 	 * We always want to hit the ctime on the source inode.
1333 	 *
1334 	 * This isn't strictly required by the standards since the source
1335 	 * inode isn't really being changed, but old unix file systems did
1336 	 * it and some incremental backup programs won't work without it.
1337 	 */
1338 	xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG);
1339 	xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE);
1340 
1341 	/*
1342 	 * Adjust the link count on src_dp.  This is necessary when
1343 	 * renaming a directory, either within one parent when
1344 	 * the target existed, or across two parent directories.
1345 	 */
1346 	if (src_is_directory && (new_parent || target_ip != NULL)) {
1347 
1348 		/*
1349 		 * Decrement link count on src_directory since the
1350 		 * entry that's moved no longer points to it.
1351 		 */
1352 		error = xfs_droplink(tp, src_dp);
1353 		if (error)
1354 			return error;
1355 	}
1356 
1357 	/*
1358 	 * For whiteouts, we only need to update the source dirent with the
1359 	 * inode number of the whiteout inode rather than removing it
1360 	 * altogether.
1361 	 */
1362 	if (du_wip->ip)
1363 		error = xfs_dir_replace(tp, src_dp, src_name, du_wip->ip->i_ino,
1364 					spaceres);
1365 	else
1366 		error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
1367 					   spaceres);
1368 	if (error)
1369 		return error;
1370 
1371 	xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1372 	xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
1373 	if (new_parent)
1374 		xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
1375 
1376 	/* Schedule parent pointer updates. */
1377 	if (du_wip->ppargs) {
1378 		error = xfs_parent_addname(tp, du_wip->ppargs, src_dp,
1379 				src_name, du_wip->ip);
1380 		if (error)
1381 			return error;
1382 	}
1383 
1384 	if (du_src->ppargs) {
1385 		error = xfs_parent_replacename(tp, du_src->ppargs, src_dp,
1386 				src_name, target_dp, target_name, src_ip);
1387 		if (error)
1388 			return error;
1389 	}
1390 
1391 	if (du_tgt->ppargs) {
1392 		error = xfs_parent_removename(tp, du_tgt->ppargs, target_dp,
1393 				target_name, target_ip);
1394 		if (error)
1395 			return error;
1396 	}
1397 
1398 	/*
1399 	 * Inform our hook clients that we've finished a rename operation as
1400 	 * follows: removed the source and target files from their directories;
1401 	 * that we've added the source to the target directory; and finally
1402 	 * that we've added the whiteout, if there was one.  All inodes are
1403 	 * locked, so it's ok to model a rename this way so long as we say we
1404 	 * deleted entries before we add new ones.
1405 	 */
1406 	if (target_ip)
1407 		xfs_dir_update_hook(target_dp, target_ip, -1, target_name);
1408 	xfs_dir_update_hook(src_dp, src_ip, -1, src_name);
1409 	xfs_dir_update_hook(target_dp, src_ip, 1, target_name);
1410 	if (du_wip->ip)
1411 		xfs_dir_update_hook(src_dp, du_wip->ip, 1, src_name);
1412 	return 0;
1413 }
1414