]> git.proxmox.com Git - mirror_zfs-debian.git/blame - module/zfs/zfs_dir.c
Add "ashift" property to zpool create
[mirror_zfs-debian.git] / module / zfs / zfs_dir.c
CommitLineData
34dc7c2f
BB
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/*
428870ff 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
34dc7c2f
BB
23 */
24
60101509 25
34dc7c2f
BB
26#include <sys/types.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/vfs.h>
33#include <sys/vnode.h>
34#include <sys/file.h>
35#include <sys/mode.h>
36#include <sys/kmem.h>
37#include <sys/uio.h>
38#include <sys/pathname.h>
39#include <sys/cmn_err.h>
40#include <sys/errno.h>
41#include <sys/stat.h>
42#include <sys/unistd.h>
43#include <sys/sunddi.h>
44#include <sys/random.h>
45#include <sys/policy.h>
46#include <sys/zfs_dir.h>
47#include <sys/zfs_acl.h>
48#include <sys/fs/zfs.h>
49#include "fs/fs_subr.h"
50#include <sys/zap.h>
51#include <sys/dmu.h>
52#include <sys/atomic.h>
34dc7c2f 53#include <sys/zfs_fuid.h>
428870ff
BB
54#include <sys/sa.h>
55#include <sys/zfs_sa.h>
34dc7c2f
BB
56#include <sys/dnlc.h>
57#include <sys/extdirent.h>
58
59/*
60 * zfs_match_find() is used by zfs_dirent_lock() to peform zap lookups
61 * of names after deciding which is the appropriate lookup interface.
62 */
63static int
3558fd73 64zfs_match_find(zfs_sb_t *zsb, znode_t *dzp, char *name, boolean_t exact,
34dc7c2f
BB
65 boolean_t update, int *deflags, pathname_t *rpnp, uint64_t *zoid)
66{
67 int error;
68
3558fd73 69 if (zsb->z_norm) {
34dc7c2f
BB
70 matchtype_t mt = MT_FIRST;
71 boolean_t conflict = B_FALSE;
72 size_t bufsz = 0;
73 char *buf = NULL;
74
75 if (rpnp) {
76 buf = rpnp->pn_buf;
77 bufsz = rpnp->pn_bufsize;
78 }
79 if (exact)
80 mt = MT_EXACT;
81 /*
82 * In the non-mixed case we only expect there would ever
83 * be one match, but we need to use the normalizing lookup.
84 */
3558fd73 85 error = zap_lookup_norm(zsb->z_os, dzp->z_id, name, 8, 1,
34dc7c2f
BB
86 zoid, mt, buf, bufsz, &conflict);
87 if (!error && deflags)
88 *deflags = conflict ? ED_CASE_CONFLICT : 0;
89 } else {
3558fd73 90 error = zap_lookup(zsb->z_os, dzp->z_id, name, 8, 1, zoid);
34dc7c2f
BB
91 }
92 *zoid = ZFS_DIRENT_OBJ(*zoid);
93
3558fd73 94#ifdef HAVE_DNLC
34dc7c2f 95 if (error == ENOENT && update)
3558fd73
BB
96 dnlc_update(ZTOI(dzp), name, DNLC_NO_VNODE);
97#endif /* HAVE_DNLC */
34dc7c2f
BB
98
99 return (error);
100}
101
102/*
103 * Lock a directory entry. A dirlock on <dzp, name> protects that name
104 * in dzp's directory zap object. As long as you hold a dirlock, you can
105 * assume two things: (1) dzp cannot be reaped, and (2) no other thread
106 * can change the zap entry for (i.e. link or unlink) this name.
107 *
108 * Input arguments:
109 * dzp - znode for directory
110 * name - name of entry to lock
111 * flag - ZNEW: if the entry already exists, fail with EEXIST.
112 * ZEXISTS: if the entry does not exist, fail with ENOENT.
113 * ZSHARED: allow concurrent access with other ZSHARED callers.
114 * ZXATTR: we want dzp's xattr directory
115 * ZCILOOK: On a mixed sensitivity file system,
116 * this lookup should be case-insensitive.
117 * ZCIEXACT: On a purely case-insensitive file system,
118 * this lookup should be case-sensitive.
119 * ZRENAMING: we are locking for renaming, force narrow locks
428870ff
BB
120 * ZHAVELOCK: Don't grab the z_name_lock for this call. The
121 * current thread already holds it.
34dc7c2f
BB
122 *
123 * Output arguments:
124 * zpp - pointer to the znode for the entry (NULL if there isn't one)
125 * dlpp - pointer to the dirlock for this entry (NULL on error)
126 * direntflags - (case-insensitive lookup only)
127 * flags if multiple case-sensitive matches exist in directory
128 * realpnp - (case-insensitive lookup only)
129 * actual name matched within the directory
130 *
131 * Return value: 0 on success or errno on failure.
132 *
133 * NOTE: Always checks for, and rejects, '.' and '..'.
134 * NOTE: For case-insensitive file systems we take wide locks (see below),
135 * but return znode pointers to a single match.
136 */
137int
138zfs_dirent_lock(zfs_dirlock_t **dlpp, znode_t *dzp, char *name, znode_t **zpp,
139 int flag, int *direntflags, pathname_t *realpnp)
140{
3558fd73 141 zfs_sb_t *zsb = ZTOZSB(dzp);
34dc7c2f
BB
142 zfs_dirlock_t *dl;
143 boolean_t update;
144 boolean_t exact;
145 uint64_t zoid;
3558fd73 146#ifdef HAVE_DNLC
34dc7c2f 147 vnode_t *vp = NULL;
3558fd73 148#endif /* HAVE_DNLC */
34dc7c2f
BB
149 int error = 0;
150 int cmpflags;
151
152 *zpp = NULL;
153 *dlpp = NULL;
154
155 /*
156 * Verify that we are not trying to lock '.', '..', or '.zfs'
157 */
149e873a
BB
158 if ((name[0] == '.' &&
159 (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) ||
160 (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0))
34dc7c2f
BB
161 return (EEXIST);
162
163 /*
164 * Case sensitivity and normalization preferences are set when
165 * the file system is created. These are stored in the
3558fd73 166 * zsb->z_case and zsb->z_norm fields. These choices
34dc7c2f
BB
167 * affect what vnodes can be cached in the DNLC, how we
168 * perform zap lookups, and the "width" of our dirlocks.
169 *
170 * A normal dirlock locks a single name. Note that with
171 * normalization a name can be composed multiple ways, but
172 * when normalized, these names all compare equal. A wide
173 * dirlock locks multiple names. We need these when the file
174 * system is supporting mixed-mode access. It is sometimes
175 * necessary to lock all case permutations of file name at
176 * once so that simultaneous case-insensitive/case-sensitive
177 * behaves as rationally as possible.
178 */
179
180 /*
181 * Decide if exact matches should be requested when performing
182 * a zap lookup on file systems supporting case-insensitive
183 * access.
184 */
185 exact =
3558fd73
BB
186 ((zsb->z_case == ZFS_CASE_INSENSITIVE) && (flag & ZCIEXACT)) ||
187 ((zsb->z_case == ZFS_CASE_MIXED) && !(flag & ZCILOOK));
34dc7c2f
BB
188
189 /*
190 * Only look in or update the DNLC if we are looking for the
191 * name on a file system that does not require normalization
192 * or case folding. We can also look there if we happen to be
193 * on a non-normalizing, mixed sensitivity file system IF we
194 * are looking for the exact name.
195 *
196 * Maybe can add TO-UPPERed version of name to dnlc in ci-only
197 * case for performance improvement?
198 */
3558fd73
BB
199 update = !zsb->z_norm ||
200 ((zsb->z_case == ZFS_CASE_MIXED) &&
201 !(zsb->z_norm & ~U8_TEXTPREP_TOUPPER) && !(flag & ZCILOOK));
34dc7c2f
BB
202
203 /*
204 * ZRENAMING indicates we are in a situation where we should
205 * take narrow locks regardless of the file system's
206 * preferences for normalizing and case folding. This will
207 * prevent us deadlocking trying to grab the same wide lock
208 * twice if the two names happen to be case-insensitive
209 * matches.
210 */
211 if (flag & ZRENAMING)
212 cmpflags = 0;
213 else
3558fd73 214 cmpflags = zsb->z_norm;
34dc7c2f
BB
215
216 /*
217 * Wait until there are no locks on this name.
428870ff
BB
218 *
219 * Don't grab the the lock if it is already held. However, cannot
220 * have both ZSHARED and ZHAVELOCK together.
34dc7c2f 221 */
428870ff
BB
222 ASSERT(!(flag & ZSHARED) || !(flag & ZHAVELOCK));
223 if (!(flag & ZHAVELOCK))
224 rw_enter(&dzp->z_name_lock, RW_READER);
225
34dc7c2f
BB
226 mutex_enter(&dzp->z_lock);
227 for (;;) {
228 if (dzp->z_unlinked) {
229 mutex_exit(&dzp->z_lock);
428870ff
BB
230 if (!(flag & ZHAVELOCK))
231 rw_exit(&dzp->z_name_lock);
34dc7c2f
BB
232 return (ENOENT);
233 }
234 for (dl = dzp->z_dirlocks; dl != NULL; dl = dl->dl_next) {
235 if ((u8_strcmp(name, dl->dl_name, 0, cmpflags,
236 U8_UNICODE_LATEST, &error) == 0) || error != 0)
237 break;
238 }
239 if (error != 0) {
240 mutex_exit(&dzp->z_lock);
428870ff
BB
241 if (!(flag & ZHAVELOCK))
242 rw_exit(&dzp->z_name_lock);
34dc7c2f
BB
243 return (ENOENT);
244 }
245 if (dl == NULL) {
246 /*
247 * Allocate a new dirlock and add it to the list.
248 */
249 dl = kmem_alloc(sizeof (zfs_dirlock_t), KM_SLEEP);
250 cv_init(&dl->dl_cv, NULL, CV_DEFAULT, NULL);
251 dl->dl_name = name;
252 dl->dl_sharecnt = 0;
428870ff 253 dl->dl_namelock = 0;
34dc7c2f
BB
254 dl->dl_namesize = 0;
255 dl->dl_dzp = dzp;
256 dl->dl_next = dzp->z_dirlocks;
257 dzp->z_dirlocks = dl;
258 break;
259 }
260 if ((flag & ZSHARED) && dl->dl_sharecnt != 0)
261 break;
262 cv_wait(&dl->dl_cv, &dzp->z_lock);
263 }
264
428870ff
BB
265 /*
266 * If the z_name_lock was NOT held for this dirlock record it.
267 */
268 if (flag & ZHAVELOCK)
269 dl->dl_namelock = 1;
270
34dc7c2f
BB
271 if ((flag & ZSHARED) && ++dl->dl_sharecnt > 1 && dl->dl_namesize == 0) {
272 /*
273 * We're the second shared reference to dl. Make a copy of
274 * dl_name in case the first thread goes away before we do.
275 * Note that we initialize the new name before storing its
276 * pointer into dl_name, because the first thread may load
277 * dl->dl_name at any time. He'll either see the old value,
278 * which is his, or the new shared copy; either is OK.
279 */
280 dl->dl_namesize = strlen(dl->dl_name) + 1;
281 name = kmem_alloc(dl->dl_namesize, KM_SLEEP);
282 bcopy(dl->dl_name, name, dl->dl_namesize);
283 dl->dl_name = name;
284 }
285
286 mutex_exit(&dzp->z_lock);
287
288 /*
289 * We have a dirlock on the name. (Note that it is the dirlock,
290 * not the dzp's z_lock, that protects the name in the zap object.)
291 * See if there's an object by this name; if so, put a hold on it.
292 */
293 if (flag & ZXATTR) {
3558fd73 294 error = sa_lookup(dzp->z_sa_hdl, SA_ZPL_XATTR(zsb), &zoid,
428870ff
BB
295 sizeof (zoid));
296 if (error == 0)
297 error = (zoid == 0 ? ENOENT : 0);
34dc7c2f 298 } else {
3558fd73 299#ifdef HAVE_DNLC
34dc7c2f 300 if (update)
3558fd73 301 vp = dnlc_lookup(ZTOI(dzp), name);
34dc7c2f 302 if (vp == DNLC_NO_VNODE) {
3558fd73 303 iput(vp);
34dc7c2f
BB
304 error = ENOENT;
305 } else if (vp) {
306 if (flag & ZNEW) {
307 zfs_dirent_unlock(dl);
3558fd73 308 iput(vp);
34dc7c2f
BB
309 return (EEXIST);
310 }
311 *dlpp = dl;
312 *zpp = VTOZ(vp);
313 return (0);
314 } else {
3558fd73 315 error = zfs_match_find(zsb, dzp, name, exact,
34dc7c2f
BB
316 update, direntflags, realpnp, &zoid);
317 }
3558fd73
BB
318#else
319 error = zfs_match_find(zsb, dzp, name, exact,
320 update, direntflags, realpnp, &zoid);
321#endif /* HAVE_DNLC */
34dc7c2f
BB
322 }
323 if (error) {
324 if (error != ENOENT || (flag & ZEXISTS)) {
325 zfs_dirent_unlock(dl);
326 return (error);
327 }
328 } else {
329 if (flag & ZNEW) {
330 zfs_dirent_unlock(dl);
331 return (EEXIST);
332 }
3558fd73 333 error = zfs_zget(zsb, zoid, zpp);
34dc7c2f
BB
334 if (error) {
335 zfs_dirent_unlock(dl);
336 return (error);
337 }
3558fd73 338#ifdef HAVE_DNLC
34dc7c2f 339 if (!(flag & ZXATTR) && update)
3558fd73
BB
340 dnlc_update(ZTOI(dzp), name, ZTOI(*zpp));
341#endif /* HAVE_DNLC */
34dc7c2f
BB
342 }
343
344 *dlpp = dl;
345
346 return (0);
347}
348
349/*
350 * Unlock this directory entry and wake anyone who was waiting for it.
351 */
352void
353zfs_dirent_unlock(zfs_dirlock_t *dl)
354{
355 znode_t *dzp = dl->dl_dzp;
356 zfs_dirlock_t **prev_dl, *cur_dl;
357
358 mutex_enter(&dzp->z_lock);
428870ff
BB
359
360 if (!dl->dl_namelock)
361 rw_exit(&dzp->z_name_lock);
362
34dc7c2f
BB
363 if (dl->dl_sharecnt > 1) {
364 dl->dl_sharecnt--;
365 mutex_exit(&dzp->z_lock);
366 return;
367 }
368 prev_dl = &dzp->z_dirlocks;
369 while ((cur_dl = *prev_dl) != dl)
370 prev_dl = &cur_dl->dl_next;
371 *prev_dl = dl->dl_next;
372 cv_broadcast(&dl->dl_cv);
373 mutex_exit(&dzp->z_lock);
374
375 if (dl->dl_namesize != 0)
376 kmem_free(dl->dl_name, dl->dl_namesize);
377 cv_destroy(&dl->dl_cv);
378 kmem_free(dl, sizeof (*dl));
379}
380
381/*
382 * Look up an entry in a directory.
383 *
384 * NOTE: '.' and '..' are handled as special cases because
385 * no directory entries are actually stored for them. If this is
386 * the root of a filesystem, then '.zfs' is also treated as a
387 * special pseudo-directory.
388 */
389int
3558fd73 390zfs_dirlook(znode_t *dzp, char *name, struct inode **ipp, int flags,
34dc7c2f
BB
391 int *deflg, pathname_t *rpnp)
392{
393 zfs_dirlock_t *dl;
394 znode_t *zp;
395 int error = 0;
428870ff 396 uint64_t parent;
34dc7c2f
BB
397
398 if (name[0] == 0 || (name[0] == '.' && name[1] == 0)) {
3558fd73
BB
399 *ipp = ZTOI(dzp);
400 igrab(*ipp);
34dc7c2f 401 } else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {
3558fd73 402 zfs_sb_t *zsb = ZTOZSB(dzp);
428870ff 403
34dc7c2f
BB
404 /*
405 * If we are a snapshot mounted under .zfs, return
406 * the vp for the snapshot directory.
407 */
428870ff 408 if ((error = sa_lookup(dzp->z_sa_hdl,
3558fd73 409 SA_ZPL_PARENT(zsb), &parent, sizeof (parent))) != 0)
428870ff 410 return (error);
3558fd73
BB
411#ifdef HAVE_SNAPSHOT
412 if (parent == dzp->z_id && zsb->z_parent != zsb) {
413 error = zfsctl_root_lookup(zsb->z_parent->z_ctldir,
414 "snapshot", ipp, NULL, 0, NULL, kcred,
34dc7c2f
BB
415 NULL, NULL, NULL);
416 return (error);
417 }
3558fd73 418#endif /* HAVE_SNAPSHOT */
34dc7c2f 419 rw_enter(&dzp->z_parent_lock, RW_READER);
3558fd73 420 error = zfs_zget(zsb, parent, &zp);
34dc7c2f 421 if (error == 0)
3558fd73 422 *ipp = ZTOI(zp);
34dc7c2f 423 rw_exit(&dzp->z_parent_lock);
3558fd73 424#ifdef HAVE_SNAPSHOT
34dc7c2f 425 } else if (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0) {
3558fd73
BB
426 *ipp = zfsctl_root(dzp);
427#endif /* HAVE_SNAPSHOT */
34dc7c2f
BB
428 } else {
429 int zf;
430
431 zf = ZEXISTS | ZSHARED;
432 if (flags & FIGNORECASE)
433 zf |= ZCILOOK;
434
435 error = zfs_dirent_lock(&dl, dzp, name, &zp, zf, deflg, rpnp);
436 if (error == 0) {
3558fd73 437 *ipp = ZTOI(zp);
34dc7c2f
BB
438 zfs_dirent_unlock(dl);
439 dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */
440 }
441 rpnp = NULL;
442 }
443
444 if ((flags & FIGNORECASE) && rpnp && !error)
445 (void) strlcpy(rpnp->pn_buf, name, rpnp->pn_bufsize);
446
447 return (error);
448}
449
34dc7c2f
BB
450/*
451 * unlinked Set (formerly known as the "delete queue") Error Handling
452 *
453 * When dealing with the unlinked set, we dmu_tx_hold_zap(), but we
454 * don't specify the name of the entry that we will be manipulating. We
455 * also fib and say that we won't be adding any new entries to the
456 * unlinked set, even though we might (this is to lower the minimum file
457 * size that can be deleted in a full filesystem). So on the small
458 * chance that the nlink list is using a fat zap (ie. has more than
459 * 2000 entries), we *may* not pre-read a block that's needed.
460 * Therefore it is remotely possible for some of the assertions
461 * regarding the unlinked set below to fail due to i/o error. On a
462 * nondebug system, this will result in the space being leaked.
463 */
464void
465zfs_unlinked_add(znode_t *zp, dmu_tx_t *tx)
466{
3558fd73 467 zfs_sb_t *zsb = ZTOZSB(zp);
34dc7c2f
BB
468
469 ASSERT(zp->z_unlinked);
428870ff 470 ASSERT(zp->z_links == 0);
34dc7c2f 471
b128c09f 472 VERIFY3U(0, ==,
3558fd73 473 zap_add_int(zsb->z_os, zsb->z_unlinkedobj, zp->z_id, tx));
34dc7c2f
BB
474}
475
476/*
477 * Clean up any znodes that had no links when we either crashed or
478 * (force) umounted the file system.
479 */
480void
3558fd73 481zfs_unlinked_drain(zfs_sb_t *zsb)
34dc7c2f
BB
482{
483 zap_cursor_t zc;
484 zap_attribute_t zap;
485 dmu_object_info_t doi;
486 znode_t *zp;
487 int error;
488
489 /*
490 * Interate over the contents of the unlinked set.
491 */
3558fd73 492 for (zap_cursor_init(&zc, zsb->z_os, zsb->z_unlinkedobj);
34dc7c2f
BB
493 zap_cursor_retrieve(&zc, &zap) == 0;
494 zap_cursor_advance(&zc)) {
495
496 /*
497 * See what kind of object we have in list
498 */
499
3558fd73 500 error = dmu_object_info(zsb->z_os, zap.za_first_integer, &doi);
34dc7c2f
BB
501 if (error != 0)
502 continue;
503
504 ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||
505 (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));
506 /*
507 * We need to re-mark these list entries for deletion,
508 * so we pull them back into core and set zp->z_unlinked.
509 */
3558fd73 510 error = zfs_zget(zsb, zap.za_first_integer, &zp);
34dc7c2f
BB
511
512 /*
513 * We may pick up znodes that are already marked for deletion.
514 * This could happen during the purge of an extended attribute
515 * directory. All we need to do is skip over them, since they
516 * are already in the system marked z_unlinked.
517 */
518 if (error != 0)
519 continue;
520
521 zp->z_unlinked = B_TRUE;
3558fd73 522 iput(ZTOI(zp));
34dc7c2f
BB
523 }
524 zap_cursor_fini(&zc);
525}
526
527/*
528 * Delete the entire contents of a directory. Return a count
529 * of the number of entries that could not be deleted. If we encounter
530 * an error, return a count of at least one so that the directory stays
531 * in the unlinked set.
532 *
533 * NOTE: this function assumes that the directory is inactive,
534 * so there is no need to lock its entries before deletion.
535 * Also, it assumes the directory contents is *only* regular
536 * files.
537 */
538static int
539zfs_purgedir(znode_t *dzp)
540{
541 zap_cursor_t zc;
542 zap_attribute_t zap;
543 znode_t *xzp;
544 dmu_tx_t *tx;
3558fd73 545 zfs_sb_t *zsb = ZTOZSB(dzp);
34dc7c2f
BB
546 zfs_dirlock_t dl;
547 int skipped = 0;
548 int error;
549
3558fd73 550 for (zap_cursor_init(&zc, zsb->z_os, dzp->z_id);
34dc7c2f
BB
551 (error = zap_cursor_retrieve(&zc, &zap)) == 0;
552 zap_cursor_advance(&zc)) {
3558fd73 553 error = zfs_zget(zsb,
34dc7c2f
BB
554 ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);
555 if (error) {
556 skipped += 1;
557 continue;
558 }
559
3558fd73 560 ASSERT(S_ISREG(ZTOI(xzp)->i_mode)||S_ISLNK(ZTOI(xzp)->i_mode));
34dc7c2f 561
3558fd73 562 tx = dmu_tx_create(zsb->z_os);
428870ff 563 dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
34dc7c2f 564 dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);
428870ff 565 dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
3558fd73 566 dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
428870ff
BB
567 /* Is this really needed ? */
568 zfs_sa_upgrade_txholds(tx, xzp);
34dc7c2f
BB
569 error = dmu_tx_assign(tx, TXG_WAIT);
570 if (error) {
571 dmu_tx_abort(tx);
3558fd73 572 iput(ZTOI(xzp));
34dc7c2f
BB
573 skipped += 1;
574 continue;
575 }
576 bzero(&dl, sizeof (dl));
577 dl.dl_dzp = dzp;
578 dl.dl_name = zap.za_name;
579
580 error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);
581 if (error)
582 skipped += 1;
583 dmu_tx_commit(tx);
584
3558fd73 585 iput(ZTOI(xzp));
34dc7c2f
BB
586 }
587 zap_cursor_fini(&zc);
588 if (error != ENOENT)
589 skipped += 1;
590 return (skipped);
591}
592
593void
594zfs_rmnode(znode_t *zp)
595{
3558fd73
BB
596 zfs_sb_t *zsb = ZTOZSB(zp);
597 objset_t *os = zsb->z_os;
34dc7c2f 598 znode_t *xzp = NULL;
34dc7c2f
BB
599 dmu_tx_t *tx;
600 uint64_t acl_obj;
428870ff 601 uint64_t xattr_obj;
34dc7c2f
BB
602 int error;
603
428870ff 604 ASSERT(zp->z_links == 0);
3558fd73 605 ASSERT(atomic_read(&ZTOI(zp)->i_count) == 0);
34dc7c2f
BB
606
607 /*
608 * If this is an attribute directory, purge its contents.
609 */
3558fd73 610 if (S_ISDIR(ZTOI(zp)->i_mode) && (zp->z_pflags & ZFS_XATTR)) {
34dc7c2f
BB
611 if (zfs_purgedir(zp) != 0) {
612 /*
613 * Not enough space to delete some xattrs.
b128c09f 614 * Leave it in the unlinked set.
34dc7c2f
BB
615 */
616 zfs_znode_dmu_fini(zp);
3558fd73
BB
617 zfs_inode_destroy(ZTOI(zp));
618
34dc7c2f
BB
619 return;
620 }
621 }
622
b128c09f
BB
623 /*
624 * Free up all the data in the file.
625 */
626 error = dmu_free_long_range(os, zp->z_id, 0, DMU_OBJECT_END);
627 if (error) {
628 /*
629 * Not enough space. Leave the file in the unlinked set.
630 */
631 zfs_znode_dmu_fini(zp);
3558fd73 632 zfs_inode_destroy(ZTOI(zp));
b128c09f
BB
633 return;
634 }
635
34dc7c2f
BB
636 /*
637 * If the file has extended attributes, we're going to unlink
638 * the xattr dir.
639 */
3558fd73 640 error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zsb),
428870ff
BB
641 &xattr_obj, sizeof (xattr_obj));
642 if (error == 0 && xattr_obj) {
3558fd73 643 error = zfs_zget(zsb, xattr_obj, &xzp);
34dc7c2f
BB
644 ASSERT(error == 0);
645 }
646
572e2857 647 acl_obj = zfs_external_acl(zp);
34dc7c2f
BB
648
649 /*
b128c09f 650 * Set up the final transaction.
34dc7c2f
BB
651 */
652 tx = dmu_tx_create(os);
653 dmu_tx_hold_free(tx, zp->z_id, 0, DMU_OBJECT_END);
3558fd73 654 dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, FALSE, NULL);
34dc7c2f 655 if (xzp) {
3558fd73 656 dmu_tx_hold_zap(tx, zsb->z_unlinkedobj, TRUE, NULL);
428870ff 657 dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
34dc7c2f
BB
658 }
659 if (acl_obj)
660 dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
428870ff
BB
661
662 zfs_sa_upgrade_txholds(tx, zp);
34dc7c2f
BB
663 error = dmu_tx_assign(tx, TXG_WAIT);
664 if (error) {
665 /*
666 * Not enough space to delete the file. Leave it in the
667 * unlinked set, leaking it until the fs is remounted (at
668 * which point we'll call zfs_unlinked_drain() to process it).
669 */
670 dmu_tx_abort(tx);
671 zfs_znode_dmu_fini(zp);
3558fd73 672 zfs_inode_destroy(ZTOI(zp));
34dc7c2f
BB
673 goto out;
674 }
675
676 if (xzp) {
428870ff 677 ASSERT(error == 0);
34dc7c2f
BB
678 mutex_enter(&xzp->z_lock);
679 xzp->z_unlinked = B_TRUE; /* mark xzp for deletion */
428870ff 680 xzp->z_links = 0; /* no more links to it */
3558fd73 681 VERIFY(0 == sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zsb),
428870ff 682 &xzp->z_links, sizeof (xzp->z_links), tx));
34dc7c2f
BB
683 mutex_exit(&xzp->z_lock);
684 zfs_unlinked_add(xzp, tx);
685 }
686
687 /* Remove this znode from the unlinked set */
b128c09f 688 VERIFY3U(0, ==,
3558fd73 689 zap_remove_int(zsb->z_os, zsb->z_unlinkedobj, zp->z_id, tx));
34dc7c2f
BB
690
691 zfs_znode_delete(zp, tx);
692
693 dmu_tx_commit(tx);
694out:
695 if (xzp)
3558fd73 696 iput(ZTOI(xzp));
34dc7c2f
BB
697}
698
699static uint64_t
428870ff 700zfs_dirent(znode_t *zp, uint64_t mode)
34dc7c2f
BB
701{
702 uint64_t de = zp->z_id;
428870ff 703
3558fd73 704 if (ZTOZSB(zp)->z_version >= ZPL_VERSION_DIRENT_TYPE)
428870ff 705 de |= IFTODT(mode) << 60;
34dc7c2f
BB
706 return (de);
707}
708
709/*
710 * Link zp into dl. Can only fail if zp has been unlinked.
711 */
712int
713zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
714{
715 znode_t *dzp = dl->dl_dzp;
3558fd73 716 zfs_sb_t *zsb = ZTOZSB(zp);
34dc7c2f 717 uint64_t value;
3558fd73 718 int zp_is_dir = S_ISDIR(ZTOI(zp)->i_mode);
428870ff
BB
719 sa_bulk_attr_t bulk[5];
720 uint64_t mtime[2], ctime[2];
721 int count = 0;
34dc7c2f
BB
722 int error;
723
34dc7c2f
BB
724 mutex_enter(&zp->z_lock);
725
726 if (!(flag & ZRENAMING)) {
727 if (zp->z_unlinked) { /* no new links to unlinked zp */
728 ASSERT(!(flag & (ZNEW | ZEXISTS)));
729 mutex_exit(&zp->z_lock);
730 return (ENOENT);
731 }
428870ff 732 zp->z_links++;
3558fd73 733 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL,
428870ff
BB
734 &zp->z_links, sizeof (zp->z_links));
735
34dc7c2f 736 }
3558fd73 737 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zsb), NULL,
428870ff 738 &dzp->z_id, sizeof (dzp->z_id));
3558fd73 739 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
428870ff
BB
740 &zp->z_pflags, sizeof (zp->z_pflags));
741
742 if (!(flag & ZNEW)) {
3558fd73 743 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
428870ff
BB
744 ctime, sizeof (ctime));
745 zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
746 ctime, B_TRUE);
747 }
748 error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
749 ASSERT(error == 0);
34dc7c2f 750
34dc7c2f
BB
751 mutex_exit(&zp->z_lock);
752
34dc7c2f 753 mutex_enter(&dzp->z_lock);
428870ff
BB
754 dzp->z_size++;
755 dzp->z_links += zp_is_dir;
756 count = 0;
3558fd73 757 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb), NULL,
428870ff 758 &dzp->z_size, sizeof (dzp->z_size));
3558fd73 759 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL,
428870ff 760 &dzp->z_links, sizeof (dzp->z_links));
3558fd73 761 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL,
428870ff 762 mtime, sizeof (mtime));
3558fd73 763 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
428870ff 764 ctime, sizeof (ctime));
3558fd73 765 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
428870ff
BB
766 &dzp->z_pflags, sizeof (dzp->z_pflags));
767 zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
768 error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
769 ASSERT(error == 0);
34dc7c2f
BB
770 mutex_exit(&dzp->z_lock);
771
428870ff 772 value = zfs_dirent(zp, zp->z_mode);
3558fd73 773 error = zap_add(ZTOZSB(zp)->z_os, dzp->z_id, dl->dl_name,
34dc7c2f
BB
774 8, 1, &value, tx);
775 ASSERT(error == 0);
776
34dc7c2f
BB
777 return (0);
778}
779
428870ff
BB
780static int
781zfs_dropname(zfs_dirlock_t *dl, znode_t *zp, znode_t *dzp, dmu_tx_t *tx,
782 int flag)
783{
784 int error;
785
3558fd73
BB
786 if (ZTOZSB(zp)->z_norm) {
787 if (((ZTOZSB(zp)->z_case == ZFS_CASE_INSENSITIVE) &&
428870ff 788 (flag & ZCIEXACT)) ||
3558fd73 789 ((ZTOZSB(zp)->z_case == ZFS_CASE_MIXED) &&
428870ff 790 !(flag & ZCILOOK)))
3558fd73 791 error = zap_remove_norm(ZTOZSB(zp)->z_os,
428870ff
BB
792 dzp->z_id, dl->dl_name, MT_EXACT, tx);
793 else
3558fd73 794 error = zap_remove_norm(ZTOZSB(zp)->z_os,
428870ff
BB
795 dzp->z_id, dl->dl_name, MT_FIRST, tx);
796 } else {
3558fd73 797 error = zap_remove(ZTOZSB(zp)->z_os,
428870ff
BB
798 dzp->z_id, dl->dl_name, tx);
799 }
800
801 return (error);
802}
803
34dc7c2f
BB
804/*
805 * Unlink zp from dl, and mark zp for deletion if this was the last link.
806 * Can fail if zp is a mount point (EBUSY) or a non-empty directory (EEXIST).
807 * If 'unlinkedp' is NULL, we put unlinked znodes on the unlinked list.
808 * If it's non-NULL, we use it to indicate whether the znode needs deletion,
809 * and it's the caller's job to do it.
810 */
811int
812zfs_link_destroy(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag,
813 boolean_t *unlinkedp)
814{
815 znode_t *dzp = dl->dl_dzp;
3558fd73
BB
816 zfs_sb_t *zsb = ZTOZSB(dzp);
817 int zp_is_dir = S_ISDIR(ZTOI(zp)->i_mode);
34dc7c2f 818 boolean_t unlinked = B_FALSE;
428870ff
BB
819 sa_bulk_attr_t bulk[5];
820 uint64_t mtime[2], ctime[2];
821 int count = 0;
34dc7c2f
BB
822 int error;
823
3558fd73
BB
824#ifdef HAVE_DNLC
825 dnlc_remove(ZTOI(dzp), dl->dl_name);
826#endif /* HAVE_DNLC */
34dc7c2f
BB
827
828 if (!(flag & ZRENAMING)) {
34dc7c2f 829 mutex_enter(&zp->z_lock);
428870ff
BB
830
831 if (zp_is_dir && !zfs_dirempty(zp)) {
34dc7c2f 832 mutex_exit(&zp->z_lock);
34dc7c2f
BB
833 return (EEXIST);
834 }
428870ff
BB
835
836 /*
837 * If we get here, we are going to try to remove the object.
838 * First try removing the name from the directory; if that
839 * fails, return the error.
840 */
841 error = zfs_dropname(dl, zp, dzp, tx, flag);
842 if (error != 0) {
843 mutex_exit(&zp->z_lock);
428870ff
BB
844 return (error);
845 }
846
847 if (zp->z_links <= zp_is_dir) {
3558fd73
BB
848 zfs_panic_recover("zfs: link count on %lu is %u, "
849 "should be at least %u", zp->z_id,
850 (int)zp->z_links, zp_is_dir + 1);
428870ff 851 zp->z_links = zp_is_dir + 1;
34dc7c2f 852 }
428870ff 853 if (--zp->z_links == zp_is_dir) {
34dc7c2f 854 zp->z_unlinked = B_TRUE;
428870ff 855 zp->z_links = 0;
34dc7c2f
BB
856 unlinked = B_TRUE;
857 } else {
3558fd73 858 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb),
428870ff 859 NULL, &ctime, sizeof (ctime));
3558fd73 860 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb),
428870ff
BB
861 NULL, &zp->z_pflags, sizeof (zp->z_pflags));
862 zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime,
863 B_TRUE);
34dc7c2f 864 }
3558fd73 865 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb),
428870ff
BB
866 NULL, &zp->z_links, sizeof (zp->z_links));
867 error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
868 count = 0;
869 ASSERT(error == 0);
34dc7c2f 870 mutex_exit(&zp->z_lock);
428870ff
BB
871 } else {
872 error = zfs_dropname(dl, zp, dzp, tx, flag);
873 if (error != 0)
874 return (error);
34dc7c2f
BB
875 }
876
34dc7c2f 877 mutex_enter(&dzp->z_lock);
428870ff
BB
878 dzp->z_size--; /* one dirent removed */
879 dzp->z_links -= zp_is_dir; /* ".." link from zp */
3558fd73 880 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb),
428870ff 881 NULL, &dzp->z_links, sizeof (dzp->z_links));
3558fd73 882 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb),
428870ff 883 NULL, &dzp->z_size, sizeof (dzp->z_size));
3558fd73 884 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb),
428870ff 885 NULL, ctime, sizeof (ctime));
3558fd73 886 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb),
428870ff 887 NULL, mtime, sizeof (mtime));
3558fd73 888 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb),
428870ff
BB
889 NULL, &dzp->z_pflags, sizeof (dzp->z_pflags));
890 zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
891 error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
34dc7c2f 892 ASSERT(error == 0);
428870ff 893 mutex_exit(&dzp->z_lock);
34dc7c2f
BB
894
895 if (unlinkedp != NULL)
896 *unlinkedp = unlinked;
897 else if (unlinked)
898 zfs_unlinked_add(zp, tx);
899
900 return (0);
901}
902
903/*
904 * Indicate whether the directory is empty. Works with or without z_lock
905 * held, but can only be consider a hint in the latter case. Returns true
906 * if only "." and ".." remain and there's no work in progress.
907 */
908boolean_t
909zfs_dirempty(znode_t *dzp)
910{
428870ff 911 return (dzp->z_size == 2 && dzp->z_dirlocks == 0);
34dc7c2f
BB
912}
913
914int
3558fd73 915zfs_make_xattrdir(znode_t *zp, vattr_t *vap, struct inode **xipp, cred_t *cr)
34dc7c2f 916{
3558fd73 917 zfs_sb_t *zsb = ZTOZSB(zp);
34dc7c2f
BB
918 znode_t *xzp;
919 dmu_tx_t *tx;
920 int error;
9babb374
BB
921 zfs_acl_ids_t acl_ids;
922 boolean_t fuid_dirtied;
3558fd73 923#ifdef DEBUG
428870ff 924 uint64_t parent;
3558fd73 925#endif
34dc7c2f 926
3558fd73 927 *xipp = NULL;
34dc7c2f 928
3558fd73 929 if ((error = zfs_zaccess(zp, ACE_WRITE_NAMED_ATTRS, 0, B_FALSE, cr)))
34dc7c2f
BB
930 return (error);
931
9babb374
BB
932 if ((error = zfs_acl_ids_create(zp, IS_XATTR, vap, cr, NULL,
933 &acl_ids)) != 0)
934 return (error);
3558fd73 935 if (zfs_acl_ids_overquota(zsb, &acl_ids)) {
9babb374
BB
936 zfs_acl_ids_free(&acl_ids);
937 return (EDQUOT);
938 }
939
428870ff 940top:
3558fd73 941 tx = dmu_tx_create(zsb->z_os);
428870ff
BB
942 dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
943 ZFS_SA_BASE_ATTR_SIZE);
944 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
34dc7c2f 945 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
3558fd73 946 fuid_dirtied = zsb->z_fuid_dirty;
9babb374 947 if (fuid_dirtied)
3558fd73 948 zfs_fuid_txhold(zsb, tx);
fb5f0bc8 949 error = dmu_tx_assign(tx, TXG_NOWAIT);
34dc7c2f 950 if (error) {
428870ff 951 if (error == ERESTART) {
34dc7c2f 952 dmu_tx_wait(tx);
428870ff
BB
953 dmu_tx_abort(tx);
954 goto top;
955 }
956 zfs_acl_ids_free(&acl_ids);
34dc7c2f
BB
957 dmu_tx_abort(tx);
958 return (error);
959 }
428870ff 960 zfs_mknode(zp, vap, tx, cr, IS_XATTR, &xzp, &acl_ids);
9babb374
BB
961
962 if (fuid_dirtied)
3558fd73 963 zfs_fuid_sync(zsb, tx);
9babb374 964
428870ff 965#ifdef DEBUG
3558fd73 966 error = sa_lookup(xzp->z_sa_hdl, SA_ZPL_PARENT(zsb),
428870ff
BB
967 &parent, sizeof (parent));
968 ASSERT(error == 0 && parent == zp->z_id);
969#endif
970
3558fd73 971 VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_XATTR(zsb), &xzp->z_id,
428870ff 972 sizeof (xzp->z_id), tx));
34dc7c2f 973
3558fd73 974 (void) zfs_log_create(zsb->z_log, tx, TX_MKXATTR, zp,
9babb374
BB
975 xzp, "", NULL, acl_ids.z_fuidp, vap);
976
977 zfs_acl_ids_free(&acl_ids);
34dc7c2f
BB
978 dmu_tx_commit(tx);
979
3558fd73 980 *xipp = ZTOI(xzp);
34dc7c2f
BB
981
982 return (0);
983}
984
985/*
986 * Return a znode for the extended attribute directory for zp.
987 * ** If the directory does not already exist, it is created **
988 *
989 * IN: zp - znode to obtain attribute directory from
990 * cr - credentials of caller
991 * flags - flags from the VOP_LOOKUP call
992 *
3558fd73 993 * OUT: xipp - pointer to extended attribute znode
34dc7c2f
BB
994 *
995 * RETURN: 0 on success
996 * error number on failure
997 */
998int
3558fd73 999zfs_get_xattrdir(znode_t *zp, struct inode **xipp, cred_t *cr, int flags)
34dc7c2f 1000{
3558fd73 1001 zfs_sb_t *zsb = ZTOZSB(zp);
34dc7c2f
BB
1002 znode_t *xzp;
1003 zfs_dirlock_t *dl;
1004 vattr_t va;
1005 int error;
1006top:
1007 error = zfs_dirent_lock(&dl, zp, "", &xzp, ZXATTR, NULL, NULL);
1008 if (error)
1009 return (error);
1010
1011 if (xzp != NULL) {
3558fd73 1012 *xipp = ZTOI(xzp);
34dc7c2f
BB
1013 zfs_dirent_unlock(dl);
1014 return (0);
1015 }
1016
34dc7c2f
BB
1017 if (!(flags & CREATE_XATTR_DIR)) {
1018 zfs_dirent_unlock(dl);
1019 return (ENOENT);
1020 }
1021
3558fd73 1022 if (zsb->z_vfs->mnt_flags & MNT_READONLY) {
34dc7c2f
BB
1023 zfs_dirent_unlock(dl);
1024 return (EROFS);
1025 }
1026
1027 /*
1028 * The ability to 'create' files in an attribute
1029 * directory comes from the write_xattr permission on the base file.
1030 *
1031 * The ability to 'search' an attribute directory requires
1032 * read_xattr permission on the base file.
1033 *
1034 * Once in a directory the ability to read/write attributes
1035 * is controlled by the permissions on the attribute file.
1036 */
3558fd73 1037 va.va_mask = ATTR_MODE | ATTR_UID | ATTR_GID;
34dc7c2f
BB
1038 va.va_mode = S_IFDIR | S_ISVTX | 0777;
1039 zfs_fuid_map_ids(zp, cr, &va.va_uid, &va.va_gid);
1040
274b7e79 1041 va.va_dentry = NULL;
3558fd73 1042 error = zfs_make_xattrdir(zp, &va, xipp, cr);
34dc7c2f
BB
1043 zfs_dirent_unlock(dl);
1044
fb5f0bc8 1045 if (error == ERESTART) {
34dc7c2f
BB
1046 /* NB: we already did dmu_tx_wait() if necessary */
1047 goto top;
1048 }
1049
1050 return (error);
1051}
1052
1053/*
1054 * Decide whether it is okay to remove within a sticky directory.
1055 *
1056 * In sticky directories, write access is not sufficient;
1057 * you can remove entries from a directory only if:
1058 *
1059 * you own the directory,
1060 * you own the entry,
1061 * the entry is a plain file and you have write access,
1062 * or you are privileged (checked in secpolicy...).
1063 *
1064 * The function returns 0 if remove access is granted.
1065 */
1066int
1067zfs_sticky_remove_access(znode_t *zdp, znode_t *zp, cred_t *cr)
1068{
3558fd73 1069 uid_t uid;
572e2857
BB
1070 uid_t downer;
1071 uid_t fowner;
3558fd73 1072 zfs_sb_t *zsb = ZTOZSB(zdp);
34dc7c2f 1073
3558fd73 1074 if (zsb->z_replay)
34dc7c2f
BB
1075 return (0);
1076
428870ff 1077 if ((zdp->z_mode & S_ISVTX) == 0)
34dc7c2f
BB
1078 return (0);
1079
3558fd73
BB
1080 downer = zfs_fuid_map_id(zsb, zdp->z_uid, cr, ZFS_OWNER);
1081 fowner = zfs_fuid_map_id(zsb, zp->z_uid, cr, ZFS_OWNER);
572e2857
BB
1082
1083 if ((uid = crgetuid(cr)) == downer || uid == fowner ||
3558fd73 1084 (S_ISDIR(ZTOI(zp)->i_mode) &&
34dc7c2f
BB
1085 zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0))
1086 return (0);
1087 else
1088 return (secpolicy_vnode_remove(cr));
1089}