1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5033f9833Sek * Common Development and Distribution License (the "License").
6033f9833Sek * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
211c17160aSKevin Crowe
22fa9e4066Sahrens /*
23f3e6fb2fSMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
2448bbca81SDaniel Hoffman * Copyright (c) 2013, 2016 by Delphix. All rights reserved.
251c17160aSKevin Crowe * Copyright 2017 Nexenta Systems, Inc.
26e2fc3408SPatrick Mooney * Copyright (c) 2015, Joyent, Inc.
27fa9e4066Sahrens */
28fa9e4066Sahrens
29fa9e4066Sahrens #include <sys/types.h>
30fa9e4066Sahrens #include <sys/param.h>
31fa9e4066Sahrens #include <sys/time.h>
32fa9e4066Sahrens #include <sys/systm.h>
33fa9e4066Sahrens #include <sys/sysmacros.h>
34fa9e4066Sahrens #include <sys/resource.h>
35fa9e4066Sahrens #include <sys/vfs.h>
36fa9e4066Sahrens #include <sys/vnode.h>
37fa9e4066Sahrens #include <sys/file.h>
38fa9e4066Sahrens #include <sys/mode.h>
39fa9e4066Sahrens #include <sys/kmem.h>
40fa9e4066Sahrens #include <sys/uio.h>
41fa9e4066Sahrens #include <sys/pathname.h>
42fa9e4066Sahrens #include <sys/cmn_err.h>
43fa9e4066Sahrens #include <sys/errno.h>
44fa9e4066Sahrens #include <sys/stat.h>
45fa9e4066Sahrens #include <sys/unistd.h>
46de8267e0Stimh #include <sys/sunddi.h>
47fa9e4066Sahrens #include <sys/random.h>
48fa9e4066Sahrens #include <sys/policy.h>
49fa9e4066Sahrens #include <sys/zfs_dir.h>
50fa9e4066Sahrens #include <sys/zfs_acl.h>
51fa9e4066Sahrens #include <sys/fs/zfs.h>
52fa9e4066Sahrens #include "fs/fs_subr.h"
53fa9e4066Sahrens #include <sys/zap.h>
54fa9e4066Sahrens #include <sys/dmu.h>
55fa9e4066Sahrens #include <sys/atomic.h>
56fa9e4066Sahrens #include <sys/zfs_ctldir.h>
57da6c28aaSamw #include <sys/zfs_fuid.h>
580a586ceaSMark Shellenbaum #include <sys/sa.h>
590a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
60033f9833Sek #include <sys/dnlc.h>
61da6c28aaSamw #include <sys/extdirent.h>
62da6c28aaSamw
63da6c28aaSamw /*
64da6c28aaSamw * zfs_match_find() is used by zfs_dirent_lock() to peform zap lookups
65da6c28aaSamw * of names after deciding which is the appropriate lookup interface.
66da6c28aaSamw */
67da6c28aaSamw static int
zfs_match_find(zfsvfs_t * zfsvfs,znode_t * dzp,char * name,matchtype_t mt,boolean_t update,int * deflags,pathname_t * rpnp,uint64_t * zoid)681c17160aSKevin Crowe zfs_match_find(zfsvfs_t *zfsvfs, znode_t *dzp, char *name, matchtype_t mt,
69da6c28aaSamw boolean_t update, int *deflags, pathname_t *rpnp, uint64_t *zoid)
70da6c28aaSamw {
71da6c28aaSamw int error;
72da6c28aaSamw
73da6c28aaSamw if (zfsvfs->z_norm) {
74da6c28aaSamw boolean_t conflict = B_FALSE;
75da6c28aaSamw size_t bufsz = 0;
76da6c28aaSamw char *buf = NULL;
77da6c28aaSamw
78da6c28aaSamw if (rpnp) {
79ab04eb8eStimh buf = rpnp->pn_buf;
80da6c28aaSamw bufsz = rpnp->pn_bufsize;
81da6c28aaSamw }
821c17160aSKevin Crowe
83da6c28aaSamw /*
84da6c28aaSamw * In the non-mixed case we only expect there would ever
85da6c28aaSamw * be one match, but we need to use the normalizing lookup.
86da6c28aaSamw */
87da6c28aaSamw error = zap_lookup_norm(zfsvfs->z_os, dzp->z_id, name, 8, 1,
88da6c28aaSamw zoid, mt, buf, bufsz, &conflict);
89ab04eb8eStimh if (!error && deflags)
90da6c28aaSamw *deflags = conflict ? ED_CASE_CONFLICT : 0;
91da6c28aaSamw } else {
92da6c28aaSamw error = zap_lookup(zfsvfs->z_os, dzp->z_id, name, 8, 1, zoid);
93da6c28aaSamw }
94da6c28aaSamw *zoid = ZFS_DIRENT_OBJ(*zoid);
95da6c28aaSamw
96da6c28aaSamw if (error == ENOENT && update)
97da6c28aaSamw dnlc_update(ZTOV(dzp), name, DNLC_NO_VNODE);
98da6c28aaSamw
99da6c28aaSamw return (error);
100da6c28aaSamw }
101fa9e4066Sahrens
102fa9e4066Sahrens /*
103fa9e4066Sahrens * Lock a directory entry. A dirlock on <dzp, name> protects that name
104fa9e4066Sahrens * in dzp's directory zap object. As long as you hold a dirlock, you can
105fa9e4066Sahrens * assume two things: (1) dzp cannot be reaped, and (2) no other thread
106fa9e4066Sahrens * can change the zap entry for (i.e. link or unlink) this name.
107fa9e4066Sahrens *
108fa9e4066Sahrens * Input arguments:
109fa9e4066Sahrens * dzp - znode for directory
110fa9e4066Sahrens * name - name of entry to lock
111fa9e4066Sahrens * flag - ZNEW: if the entry already exists, fail with EEXIST.
112fa9e4066Sahrens * ZEXISTS: if the entry does not exist, fail with ENOENT.
113fa9e4066Sahrens * ZSHARED: allow concurrent access with other ZSHARED callers.
114fa9e4066Sahrens * ZXATTR: we want dzp's xattr directory
115da6c28aaSamw * ZCILOOK: On a mixed sensitivity file system,
116da6c28aaSamw * this lookup should be case-insensitive.
117da6c28aaSamw * ZCIEXACT: On a purely case-insensitive file system,
118da6c28aaSamw * this lookup should be case-sensitive.
119da6c28aaSamw * ZRENAMING: we are locking for renaming, force narrow locks
120afefc7e4SSanjeev Bagewadi * ZHAVELOCK: Don't grab the z_name_lock for this call. The
121afefc7e4SSanjeev Bagewadi * current thread already holds it.
122fa9e4066Sahrens *
123fa9e4066Sahrens * Output arguments:
124fa9e4066Sahrens * zpp - pointer to the znode for the entry (NULL if there isn't one)
125fa9e4066Sahrens * dlpp - pointer to the dirlock for this entry (NULL on error)
126da6c28aaSamw * direntflags - (case-insensitive lookup only)
127da6c28aaSamw * flags if multiple case-sensitive matches exist in directory
128da6c28aaSamw * realpnp - (case-insensitive lookup only)
129da6c28aaSamw * actual name matched within the directory
130fa9e4066Sahrens *
131fa9e4066Sahrens * Return value: 0 on success or errno on failure.
132fa9e4066Sahrens *
133fa9e4066Sahrens * NOTE: Always checks for, and rejects, '.' and '..'.
134da6c28aaSamw * NOTE: For case-insensitive file systems we take wide locks (see below),
135da6c28aaSamw * but return znode pointers to a single match.
136fa9e4066Sahrens */
137fa9e4066Sahrens int
zfs_dirent_lock(zfs_dirlock_t ** dlpp,znode_t * dzp,char * name,znode_t ** zpp,int flag,int * direntflags,pathname_t * realpnp)138fa9e4066Sahrens zfs_dirent_lock(zfs_dirlock_t **dlpp, znode_t *dzp, char *name, znode_t **zpp,
139da6c28aaSamw int flag, int *direntflags, pathname_t *realpnp)
140fa9e4066Sahrens {
141fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
142fa9e4066Sahrens zfs_dirlock_t *dl;
143da6c28aaSamw boolean_t update;
1441c17160aSKevin Crowe matchtype_t mt = 0;
145fa9e4066Sahrens uint64_t zoid;
146da6c28aaSamw vnode_t *vp = NULL;
147da6c28aaSamw int error = 0;
148da6c28aaSamw int cmpflags;
149fa9e4066Sahrens
150fa9e4066Sahrens *zpp = NULL;
151fa9e4066Sahrens *dlpp = NULL;
152fa9e4066Sahrens
153fa9e4066Sahrens /*
154fa9e4066Sahrens * Verify that we are not trying to lock '.', '..', or '.zfs'
155fa9e4066Sahrens */
156fa9e4066Sahrens if (name[0] == '.' &&
157fa9e4066Sahrens (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')) ||
158fa9e4066Sahrens zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0)
159be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST));
160fa9e4066Sahrens
161da6c28aaSamw /*
162da6c28aaSamw * Case sensitivity and normalization preferences are set when
163da6c28aaSamw * the file system is created. These are stored in the
164da6c28aaSamw * zfsvfs->z_case and zfsvfs->z_norm fields. These choices
165da6c28aaSamw * affect what vnodes can be cached in the DNLC, how we
166da6c28aaSamw * perform zap lookups, and the "width" of our dirlocks.
167da6c28aaSamw *
168da6c28aaSamw * A normal dirlock locks a single name. Note that with
169da6c28aaSamw * normalization a name can be composed multiple ways, but
170da6c28aaSamw * when normalized, these names all compare equal. A wide
171da6c28aaSamw * dirlock locks multiple names. We need these when the file
172da6c28aaSamw * system is supporting mixed-mode access. It is sometimes
173da6c28aaSamw * necessary to lock all case permutations of file name at
174da6c28aaSamw * once so that simultaneous case-insensitive/case-sensitive
175da6c28aaSamw * behaves as rationally as possible.
176da6c28aaSamw */
177da6c28aaSamw
178da6c28aaSamw /*
1791c17160aSKevin Crowe * When matching we may need to normalize & change case according to
1801c17160aSKevin Crowe * FS settings.
1811c17160aSKevin Crowe *
1821c17160aSKevin Crowe * Note that a normalized match is necessary for a case insensitive
1831c17160aSKevin Crowe * filesystem when the lookup request is not exact because normalization
1841c17160aSKevin Crowe * can fold case independent of normalizing code point sequences.
1851c17160aSKevin Crowe *
1861c17160aSKevin Crowe * See the table above zfs_dropname().
187da6c28aaSamw */
1881c17160aSKevin Crowe if (zfsvfs->z_norm != 0) {
1891c17160aSKevin Crowe mt = MT_NORMALIZE;
1901c17160aSKevin Crowe
1911c17160aSKevin Crowe /*
1921c17160aSKevin Crowe * Determine if the match needs to honor the case specified in
1931c17160aSKevin Crowe * lookup, and if so keep track of that so that during
1941c17160aSKevin Crowe * normalization we don't fold case.
1951c17160aSKevin Crowe */
1961c17160aSKevin Crowe if ((zfsvfs->z_case == ZFS_CASE_INSENSITIVE &&
1971c17160aSKevin Crowe (flag & ZCIEXACT)) ||
1981c17160aSKevin Crowe (zfsvfs->z_case == ZFS_CASE_MIXED && !(flag & ZCILOOK))) {
1991c17160aSKevin Crowe mt |= MT_MATCH_CASE;
2001c17160aSKevin Crowe }
2011c17160aSKevin Crowe }
202da6c28aaSamw
203da6c28aaSamw /*
204da6c28aaSamw * Only look in or update the DNLC if we are looking for the
205da6c28aaSamw * name on a file system that does not require normalization
206da6c28aaSamw * or case folding. We can also look there if we happen to be
207da6c28aaSamw * on a non-normalizing, mixed sensitivity file system IF we
208da6c28aaSamw * are looking for the exact name.
209da6c28aaSamw *
210da6c28aaSamw * Maybe can add TO-UPPERed version of name to dnlc in ci-only
211da6c28aaSamw * case for performance improvement?
212da6c28aaSamw */
213da6c28aaSamw update = !zfsvfs->z_norm ||
2141c17160aSKevin Crowe (zfsvfs->z_case == ZFS_CASE_MIXED &&
215da6c28aaSamw !(zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER) && !(flag & ZCILOOK));
216da6c28aaSamw
217da6c28aaSamw /*
218da6c28aaSamw * ZRENAMING indicates we are in a situation where we should
219da6c28aaSamw * take narrow locks regardless of the file system's
220da6c28aaSamw * preferences for normalizing and case folding. This will
221da6c28aaSamw * prevent us deadlocking trying to grab the same wide lock
222da6c28aaSamw * twice if the two names happen to be case-insensitive
223da6c28aaSamw * matches.
224da6c28aaSamw */
225da6c28aaSamw if (flag & ZRENAMING)
226da6c28aaSamw cmpflags = 0;
227da6c28aaSamw else
228da6c28aaSamw cmpflags = zfsvfs->z_norm;
229da6c28aaSamw
230fa9e4066Sahrens /*
231fa9e4066Sahrens * Wait until there are no locks on this name.
232afefc7e4SSanjeev Bagewadi *
233afefc7e4SSanjeev Bagewadi * Don't grab the the lock if it is already held. However, cannot
234afefc7e4SSanjeev Bagewadi * have both ZSHARED and ZHAVELOCK together.
235fa9e4066Sahrens */
236afefc7e4SSanjeev Bagewadi ASSERT(!(flag & ZSHARED) || !(flag & ZHAVELOCK));
237afefc7e4SSanjeev Bagewadi if (!(flag & ZHAVELOCK))
238afefc7e4SSanjeev Bagewadi rw_enter(&dzp->z_name_lock, RW_READER);
239afefc7e4SSanjeev Bagewadi
240fa9e4066Sahrens mutex_enter(&dzp->z_lock);
241fa9e4066Sahrens for (;;) {
242893a6d32Sahrens if (dzp->z_unlinked) {
243fa9e4066Sahrens mutex_exit(&dzp->z_lock);
244afefc7e4SSanjeev Bagewadi if (!(flag & ZHAVELOCK))
245afefc7e4SSanjeev Bagewadi rw_exit(&dzp->z_name_lock);
246be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
247fa9e4066Sahrens }
248da6c28aaSamw for (dl = dzp->z_dirlocks; dl != NULL; dl = dl->dl_next) {
249da6c28aaSamw if ((u8_strcmp(name, dl->dl_name, 0, cmpflags,
250da6c28aaSamw U8_UNICODE_LATEST, &error) == 0) || error != 0)
251fa9e4066Sahrens break;
252da6c28aaSamw }
253da6c28aaSamw if (error != 0) {
254da6c28aaSamw mutex_exit(&dzp->z_lock);
255afefc7e4SSanjeev Bagewadi if (!(flag & ZHAVELOCK))
256afefc7e4SSanjeev Bagewadi rw_exit(&dzp->z_name_lock);
257be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
258da6c28aaSamw }
259fa9e4066Sahrens if (dl == NULL) {
260fa9e4066Sahrens /*
261fa9e4066Sahrens * Allocate a new dirlock and add it to the list.
262fa9e4066Sahrens */
263fa9e4066Sahrens dl = kmem_alloc(sizeof (zfs_dirlock_t), KM_SLEEP);
264fa9e4066Sahrens cv_init(&dl->dl_cv, NULL, CV_DEFAULT, NULL);
265fa9e4066Sahrens dl->dl_name = name;
266fa9e4066Sahrens dl->dl_sharecnt = 0;
267afefc7e4SSanjeev Bagewadi dl->dl_namelock = 0;
268fa9e4066Sahrens dl->dl_namesize = 0;
269fa9e4066Sahrens dl->dl_dzp = dzp;
270fa9e4066Sahrens dl->dl_next = dzp->z_dirlocks;
271fa9e4066Sahrens dzp->z_dirlocks = dl;
272fa9e4066Sahrens break;
273fa9e4066Sahrens }
274fa9e4066Sahrens if ((flag & ZSHARED) && dl->dl_sharecnt != 0)
275fa9e4066Sahrens break;
276fa9e4066Sahrens cv_wait(&dl->dl_cv, &dzp->z_lock);
277fa9e4066Sahrens }
278fa9e4066Sahrens
279afefc7e4SSanjeev Bagewadi /*
280afefc7e4SSanjeev Bagewadi * If the z_name_lock was NOT held for this dirlock record it.
281afefc7e4SSanjeev Bagewadi */
282afefc7e4SSanjeev Bagewadi if (flag & ZHAVELOCK)
283afefc7e4SSanjeev Bagewadi dl->dl_namelock = 1;
284afefc7e4SSanjeev Bagewadi
285fa9e4066Sahrens if ((flag & ZSHARED) && ++dl->dl_sharecnt > 1 && dl->dl_namesize == 0) {
286fa9e4066Sahrens /*
287fa9e4066Sahrens * We're the second shared reference to dl. Make a copy of
288fa9e4066Sahrens * dl_name in case the first thread goes away before we do.
289fa9e4066Sahrens * Note that we initialize the new name before storing its
290fa9e4066Sahrens * pointer into dl_name, because the first thread may load
29148bbca81SDaniel Hoffman * dl->dl_name at any time. It'll either see the old value,
29248bbca81SDaniel Hoffman * which belongs to it, or the new shared copy; either is OK.
293fa9e4066Sahrens */
294fa9e4066Sahrens dl->dl_namesize = strlen(dl->dl_name) + 1;
295fa9e4066Sahrens name = kmem_alloc(dl->dl_namesize, KM_SLEEP);
296fa9e4066Sahrens bcopy(dl->dl_name, name, dl->dl_namesize);
297fa9e4066Sahrens dl->dl_name = name;
298fa9e4066Sahrens }
299fa9e4066Sahrens
300fa9e4066Sahrens mutex_exit(&dzp->z_lock);
301fa9e4066Sahrens
302fa9e4066Sahrens /*
303fa9e4066Sahrens * We have a dirlock on the name. (Note that it is the dirlock,
304fa9e4066Sahrens * not the dzp's z_lock, that protects the name in the zap object.)
305fa9e4066Sahrens * See if there's an object by this name; if so, put a hold on it.
306fa9e4066Sahrens */
307fa9e4066Sahrens if (flag & ZXATTR) {
3080a586ceaSMark Shellenbaum error = sa_lookup(dzp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &zoid,
3090a586ceaSMark Shellenbaum sizeof (zoid));
3100a586ceaSMark Shellenbaum if (error == 0)
3110a586ceaSMark Shellenbaum error = (zoid == 0 ? ENOENT : 0);
312fa9e4066Sahrens } else {
313da6c28aaSamw if (update)
314da6c28aaSamw vp = dnlc_lookup(ZTOV(dzp), name);
315033f9833Sek if (vp == DNLC_NO_VNODE) {
316033f9833Sek VN_RELE(vp);
317be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT);
318033f9833Sek } else if (vp) {
319033f9833Sek if (flag & ZNEW) {
320033f9833Sek zfs_dirent_unlock(dl);
321033f9833Sek VN_RELE(vp);
322be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST));
323033f9833Sek }
324033f9833Sek *dlpp = dl;
325033f9833Sek *zpp = VTOZ(vp);
326033f9833Sek return (0);
327033f9833Sek } else {
3281c17160aSKevin Crowe error = zfs_match_find(zfsvfs, dzp, name, mt,
329da6c28aaSamw update, direntflags, realpnp, &zoid);
330033f9833Sek }
331fa9e4066Sahrens }
332fa9e4066Sahrens if (error) {
333fa9e4066Sahrens if (error != ENOENT || (flag & ZEXISTS)) {
334fa9e4066Sahrens zfs_dirent_unlock(dl);
335fa9e4066Sahrens return (error);
336fa9e4066Sahrens }
337fa9e4066Sahrens } else {
338fa9e4066Sahrens if (flag & ZNEW) {
339fa9e4066Sahrens zfs_dirent_unlock(dl);
340be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST));
341fa9e4066Sahrens }
342fa9e4066Sahrens error = zfs_zget(zfsvfs, zoid, zpp);
343fa9e4066Sahrens if (error) {
344fa9e4066Sahrens zfs_dirent_unlock(dl);
345fa9e4066Sahrens return (error);
346fa9e4066Sahrens }
347da6c28aaSamw if (!(flag & ZXATTR) && update)
348033f9833Sek dnlc_update(ZTOV(dzp), name, ZTOV(*zpp));
349fa9e4066Sahrens }
350fa9e4066Sahrens
351fa9e4066Sahrens *dlpp = dl;
352fa9e4066Sahrens
353fa9e4066Sahrens return (0);
354fa9e4066Sahrens }
355fa9e4066Sahrens
356fa9e4066Sahrens /*
357fa9e4066Sahrens * Unlock this directory entry and wake anyone who was waiting for it.
358fa9e4066Sahrens */
359fa9e4066Sahrens void
zfs_dirent_unlock(zfs_dirlock_t * dl)360fa9e4066Sahrens zfs_dirent_unlock(zfs_dirlock_t *dl)
361fa9e4066Sahrens {
362fa9e4066Sahrens znode_t *dzp = dl->dl_dzp;
363fa9e4066Sahrens zfs_dirlock_t **prev_dl, *cur_dl;
364fa9e4066Sahrens
365fa9e4066Sahrens mutex_enter(&dzp->z_lock);
366afefc7e4SSanjeev Bagewadi
367afefc7e4SSanjeev Bagewadi if (!dl->dl_namelock)
368afefc7e4SSanjeev Bagewadi rw_exit(&dzp->z_name_lock);
369afefc7e4SSanjeev Bagewadi
370fa9e4066Sahrens if (dl->dl_sharecnt > 1) {
371fa9e4066Sahrens dl->dl_sharecnt--;
372fa9e4066Sahrens mutex_exit(&dzp->z_lock);
373fa9e4066Sahrens return;
374fa9e4066Sahrens }
375fa9e4066Sahrens prev_dl = &dzp->z_dirlocks;
376fa9e4066Sahrens while ((cur_dl = *prev_dl) != dl)
377fa9e4066Sahrens prev_dl = &cur_dl->dl_next;
378fa9e4066Sahrens *prev_dl = dl->dl_next;
379fa9e4066Sahrens cv_broadcast(&dl->dl_cv);
380fa9e4066Sahrens mutex_exit(&dzp->z_lock);
381fa9e4066Sahrens
382fa9e4066Sahrens if (dl->dl_namesize != 0)
383fa9e4066Sahrens kmem_free(dl->dl_name, dl->dl_namesize);
384fa9e4066Sahrens cv_destroy(&dl->dl_cv);
385fa9e4066Sahrens kmem_free(dl, sizeof (*dl));
386fa9e4066Sahrens }
387fa9e4066Sahrens
388fa9e4066Sahrens /*
389fa9e4066Sahrens * Look up an entry in a directory.
390fa9e4066Sahrens *
391fa9e4066Sahrens * NOTE: '.' and '..' are handled as special cases because
392fa9e4066Sahrens * no directory entries are actually stored for them. If this is
393fa9e4066Sahrens * the root of a filesystem, then '.zfs' is also treated as a
394fa9e4066Sahrens * special pseudo-directory.
395fa9e4066Sahrens */
396fa9e4066Sahrens int
zfs_dirlook(znode_t * dzp,char * name,vnode_t ** vpp,int flags,int * deflg,pathname_t * rpnp)397da6c28aaSamw zfs_dirlook(znode_t *dzp, char *name, vnode_t **vpp, int flags,
398da6c28aaSamw int *deflg, pathname_t *rpnp)
399fa9e4066Sahrens {
400fa9e4066Sahrens zfs_dirlock_t *dl;
401fa9e4066Sahrens znode_t *zp;
402fa9e4066Sahrens int error = 0;
4030a586ceaSMark Shellenbaum uint64_t parent;
404fa9e4066Sahrens
405fa9e4066Sahrens if (name[0] == 0 || (name[0] == '.' && name[1] == 0)) {
406fa9e4066Sahrens *vpp = ZTOV(dzp);
407fa9e4066Sahrens VN_HOLD(*vpp);
408fa9e4066Sahrens } else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {
409fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
4100a586ceaSMark Shellenbaum
411fa9e4066Sahrens /*
412fa9e4066Sahrens * If we are a snapshot mounted under .zfs, return
413fa9e4066Sahrens * the vp for the snapshot directory.
414fa9e4066Sahrens */
4150a586ceaSMark Shellenbaum if ((error = sa_lookup(dzp->z_sa_hdl,
4160a586ceaSMark Shellenbaum SA_ZPL_PARENT(zfsvfs), &parent, sizeof (parent))) != 0)
4170a586ceaSMark Shellenbaum return (error);
4180a586ceaSMark Shellenbaum if (parent == dzp->z_id && zfsvfs->z_parent != zfsvfs) {
419fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_parent->z_ctldir,
420da6c28aaSamw "snapshot", vpp, NULL, 0, NULL, kcred,
421da6c28aaSamw NULL, NULL, NULL);
422fa9e4066Sahrens return (error);
423fa9e4066Sahrens }
424fa9e4066Sahrens rw_enter(&dzp->z_parent_lock, RW_READER);
4250a586ceaSMark Shellenbaum error = zfs_zget(zfsvfs, parent, &zp);
426fa9e4066Sahrens if (error == 0)
427fa9e4066Sahrens *vpp = ZTOV(zp);
428fa9e4066Sahrens rw_exit(&dzp->z_parent_lock);
429fa9e4066Sahrens } else if (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0) {
430fa9e4066Sahrens *vpp = zfsctl_root(dzp);
431fa9e4066Sahrens } else {
432da6c28aaSamw int zf;
433da6c28aaSamw
434da6c28aaSamw zf = ZEXISTS | ZSHARED;
435da6c28aaSamw if (flags & FIGNORECASE)
436da6c28aaSamw zf |= ZCILOOK;
437da6c28aaSamw
438da6c28aaSamw error = zfs_dirent_lock(&dl, dzp, name, &zp, zf, deflg, rpnp);
439fa9e4066Sahrens if (error == 0) {
440fa9e4066Sahrens *vpp = ZTOV(zp);
441fa9e4066Sahrens zfs_dirent_unlock(dl);
4427f6e3e7dSperrin dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */
443fa9e4066Sahrens }
444da6c28aaSamw rpnp = NULL;
445fa9e4066Sahrens }
446fa9e4066Sahrens
447ab04eb8eStimh if ((flags & FIGNORECASE) && rpnp && !error)
448ab04eb8eStimh (void) strlcpy(rpnp->pn_buf, name, rpnp->pn_bufsize);
449da6c28aaSamw
450fa9e4066Sahrens return (error);
451fa9e4066Sahrens }
452fa9e4066Sahrens
453ea8dc4b6Seschrock /*
454893a6d32Sahrens * unlinked Set (formerly known as the "delete queue") Error Handling
455ea8dc4b6Seschrock *
456893a6d32Sahrens * When dealing with the unlinked set, we dmu_tx_hold_zap(), but we
457ea8dc4b6Seschrock * don't specify the name of the entry that we will be manipulating. We
458ea8dc4b6Seschrock * also fib and say that we won't be adding any new entries to the
459893a6d32Sahrens * unlinked set, even though we might (this is to lower the minimum file
460ea8dc4b6Seschrock * size that can be deleted in a full filesystem). So on the small
461893a6d32Sahrens * chance that the nlink list is using a fat zap (ie. has more than
462ea8dc4b6Seschrock * 2000 entries), we *may* not pre-read a block that's needed.
463ea8dc4b6Seschrock * Therefore it is remotely possible for some of the assertions
464893a6d32Sahrens * regarding the unlinked set below to fail due to i/o error. On a
465ea8dc4b6Seschrock * nondebug system, this will result in the space being leaked.
466ea8dc4b6Seschrock */
467fa9e4066Sahrens void
zfs_unlinked_add(znode_t * zp,dmu_tx_t * tx)468893a6d32Sahrens zfs_unlinked_add(znode_t *zp, dmu_tx_t *tx)
469fa9e4066Sahrens {
470fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
471cdb0ab79Smaybee
472cdb0ab79Smaybee ASSERT(zp->z_unlinked);
4730a586ceaSMark Shellenbaum ASSERT(zp->z_links == 0);
474cdb0ab79Smaybee
475b420f3adSRichard Lowe VERIFY3U(0, ==,
476b420f3adSRichard Lowe zap_add_int(zfsvfs->z_os, zfsvfs->z_unlinkedobj, zp->z_id, tx));
477cdb0ab79Smaybee }
478cdb0ab79Smaybee
479893a6d32Sahrens /*
480893a6d32Sahrens * Clean up any znodes that had no links when we either crashed or
481893a6d32Sahrens * (force) umounted the file system.
482893a6d32Sahrens */
483c5832a53SAlek Pinchuk static void
zfs_unlinked_drain_task(void * arg)484c5832a53SAlek Pinchuk zfs_unlinked_drain_task(void *arg)
485893a6d32Sahrens {
486c5832a53SAlek Pinchuk zfsvfs_t *zfsvfs = arg;
487893a6d32Sahrens zap_cursor_t zc;
488893a6d32Sahrens zap_attribute_t zap;
489893a6d32Sahrens dmu_object_info_t doi;
490893a6d32Sahrens znode_t *zp;
491893a6d32Sahrens int error;
492893a6d32Sahrens
493c5832a53SAlek Pinchuk ASSERT3B(zfsvfs->z_draining, ==, B_TRUE);
494c5832a53SAlek Pinchuk
495893a6d32Sahrens /*
496893a6d32Sahrens * Interate over the contents of the unlinked set.
497893a6d32Sahrens */
498893a6d32Sahrens for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);
499c5832a53SAlek Pinchuk zap_cursor_retrieve(&zc, &zap) == 0 && !zfsvfs->z_drain_cancel;
500893a6d32Sahrens zap_cursor_advance(&zc)) {
501893a6d32Sahrens
502893a6d32Sahrens /*
503893a6d32Sahrens * See what kind of object we have in list
504893a6d32Sahrens */
505893a6d32Sahrens
506893a6d32Sahrens error = dmu_object_info(zfsvfs->z_os,
507893a6d32Sahrens zap.za_first_integer, &doi);
508893a6d32Sahrens if (error != 0)
509893a6d32Sahrens continue;
510893a6d32Sahrens
511893a6d32Sahrens ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||
512893a6d32Sahrens (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));
513893a6d32Sahrens /*
514893a6d32Sahrens * We need to re-mark these list entries for deletion,
515893a6d32Sahrens * so we pull them back into core and set zp->z_unlinked.
516893a6d32Sahrens */
517893a6d32Sahrens error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);
518893a6d32Sahrens
519893a6d32Sahrens /*
520893a6d32Sahrens * We may pick up znodes that are already marked for deletion.
521893a6d32Sahrens * This could happen during the purge of an extended attribute
522893a6d32Sahrens * directory. All we need to do is skip over them, since they
523893a6d32Sahrens * are already in the system marked z_unlinked.
524893a6d32Sahrens */
525893a6d32Sahrens if (error != 0)
526893a6d32Sahrens continue;
527893a6d32Sahrens
528893a6d32Sahrens zp->z_unlinked = B_TRUE;
529c5832a53SAlek Pinchuk
530893a6d32Sahrens VN_RELE(ZTOV(zp));
531c5832a53SAlek Pinchuk ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);
532893a6d32Sahrens }
533893a6d32Sahrens zap_cursor_fini(&zc);
534c5832a53SAlek Pinchuk
535c5832a53SAlek Pinchuk zfsvfs->z_draining = B_FALSE;
536c5832a53SAlek Pinchuk zfsvfs->z_drain_task = TASKQID_INVALID;
537c5832a53SAlek Pinchuk }
538c5832a53SAlek Pinchuk
539c5832a53SAlek Pinchuk /*
540c5832a53SAlek Pinchuk * Sets z_draining then tries to dispatch async unlinked drain.
541c5832a53SAlek Pinchuk * If that fails executes synchronous unlinked drain.
542c5832a53SAlek Pinchuk */
543c5832a53SAlek Pinchuk void
zfs_unlinked_drain(zfsvfs_t * zfsvfs)544c5832a53SAlek Pinchuk zfs_unlinked_drain(zfsvfs_t *zfsvfs)
545c5832a53SAlek Pinchuk {
546c5832a53SAlek Pinchuk ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);
547c5832a53SAlek Pinchuk ASSERT3B(zfsvfs->z_draining, ==, B_FALSE);
548c5832a53SAlek Pinchuk
549c5832a53SAlek Pinchuk zfsvfs->z_draining = B_TRUE;
550c5832a53SAlek Pinchuk zfsvfs->z_drain_cancel = B_FALSE;
551c5832a53SAlek Pinchuk
552c5832a53SAlek Pinchuk zfsvfs->z_drain_task = taskq_dispatch(
553c5832a53SAlek Pinchuk dsl_pool_unlinked_drain_taskq(dmu_objset_pool(zfsvfs->z_os)),
554c5832a53SAlek Pinchuk zfs_unlinked_drain_task, zfsvfs, TQ_SLEEP);
555c5832a53SAlek Pinchuk if (zfsvfs->z_drain_task == TASKQID_INVALID) {
556c5832a53SAlek Pinchuk zfs_dbgmsg("async zfs_unlinked_drain dispatch failed");
557c5832a53SAlek Pinchuk zfs_unlinked_drain_task(zfsvfs);
558c5832a53SAlek Pinchuk }
559c5832a53SAlek Pinchuk }
560c5832a53SAlek Pinchuk
561c5832a53SAlek Pinchuk /*
562c5832a53SAlek Pinchuk * Wait for the unlinked drain taskq task to stop. This will interrupt the
563c5832a53SAlek Pinchuk * unlinked set processing if it is in progress.
564c5832a53SAlek Pinchuk */
565c5832a53SAlek Pinchuk void
zfs_unlinked_drain_stop_wait(zfsvfs_t * zfsvfs)566c5832a53SAlek Pinchuk zfs_unlinked_drain_stop_wait(zfsvfs_t *zfsvfs)
567c5832a53SAlek Pinchuk {
568c5832a53SAlek Pinchuk ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);
569c5832a53SAlek Pinchuk
570c5832a53SAlek Pinchuk while (zfsvfs->z_draining) {
571c5832a53SAlek Pinchuk zfsvfs->z_drain_cancel = B_TRUE;
572c5832a53SAlek Pinchuk taskq_wait(dsl_pool_unlinked_drain_taskq(
573c5832a53SAlek Pinchuk dmu_objset_pool(zfsvfs->z_os)));
574c5832a53SAlek Pinchuk }
575893a6d32Sahrens }
576893a6d32Sahrens
577fa9e4066Sahrens /*
578fa9e4066Sahrens * Delete the entire contents of a directory. Return a count
57940ff3960Sck * of the number of entries that could not be deleted. If we encounter
58040ff3960Sck * an error, return a count of at least one so that the directory stays
58140ff3960Sck * in the unlinked set.
582fa9e4066Sahrens *
583fa9e4066Sahrens * NOTE: this function assumes that the directory is inactive,
584fa9e4066Sahrens * so there is no need to lock its entries before deletion.
585fa9e4066Sahrens * Also, it assumes the directory contents is *only* regular
586fa9e4066Sahrens * files.
587fa9e4066Sahrens */
588fa9e4066Sahrens static int
zfs_purgedir(znode_t * dzp)589fa9e4066Sahrens zfs_purgedir(znode_t *dzp)
590fa9e4066Sahrens {
591fa9e4066Sahrens zap_cursor_t zc;
592fa9e4066Sahrens zap_attribute_t zap;
593fa9e4066Sahrens znode_t *xzp;
594fa9e4066Sahrens dmu_tx_t *tx;
595fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
596fa9e4066Sahrens zfs_dirlock_t dl;
597fa9e4066Sahrens int skipped = 0;
598fa9e4066Sahrens int error;
599fa9e4066Sahrens
600fa9e4066Sahrens for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
601fa9e4066Sahrens (error = zap_cursor_retrieve(&zc, &zap)) == 0;
602fa9e4066Sahrens zap_cursor_advance(&zc)) {
603b1b8ab34Slling error = zfs_zget(zfsvfs,
604b1b8ab34Slling ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);
60540ff3960Sck if (error) {
60640ff3960Sck skipped += 1;
60740ff3960Sck continue;
60840ff3960Sck }
609fa9e4066Sahrens
610fa9e4066Sahrens ASSERT((ZTOV(xzp)->v_type == VREG) ||
611fa9e4066Sahrens (ZTOV(xzp)->v_type == VLNK));
612fa9e4066Sahrens
613fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
6140a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
615ea8dc4b6Seschrock dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);
6160a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
617893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
6180a586ceaSMark Shellenbaum /* Is this really needed ? */
6190a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, xzp);
6204bb73804SMatthew Ahrens dmu_tx_mark_netfree(tx);
621fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT);
622fa9e4066Sahrens if (error) {
623fa9e4066Sahrens dmu_tx_abort(tx);
624fa9e4066Sahrens VN_RELE(ZTOV(xzp));
625fa9e4066Sahrens skipped += 1;
626fa9e4066Sahrens continue;
627fa9e4066Sahrens }
628fa9e4066Sahrens bzero(&dl, sizeof (dl));
629fa9e4066Sahrens dl.dl_dzp = dzp;
630fa9e4066Sahrens dl.dl_name = zap.za_name;
631fa9e4066Sahrens
632fa9e4066Sahrens error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);
63340ff3960Sck if (error)
63440ff3960Sck skipped += 1;
635fa9e4066Sahrens dmu_tx_commit(tx);
636fa9e4066Sahrens
637fa9e4066Sahrens VN_RELE(ZTOV(xzp));
638fa9e4066Sahrens }
63987e5029aSahrens zap_cursor_fini(&zc);
64040ff3960Sck if (error != ENOENT)
64140ff3960Sck skipped += 1;
642fa9e4066Sahrens return (skipped);
643fa9e4066Sahrens }
644fa9e4066Sahrens
645fa9e4066Sahrens void
zfs_rmnode(znode_t * zp)646fa9e4066Sahrens zfs_rmnode(znode_t *zp)
647fa9e4066Sahrens {
648fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
649fa9e4066Sahrens objset_t *os = zfsvfs->z_os;
650fa9e4066Sahrens znode_t *xzp = NULL;
651fa9e4066Sahrens dmu_tx_t *tx;
652fa9e4066Sahrens uint64_t acl_obj;
6530a586ceaSMark Shellenbaum uint64_t xattr_obj;
654fa9e4066Sahrens int error;
655fa9e4066Sahrens
6560a586ceaSMark Shellenbaum ASSERT(zp->z_links == 0);
657fa9e4066Sahrens ASSERT(ZTOV(zp)->v_count == 0);
658fa9e4066Sahrens
659fa9e4066Sahrens /*
660fa9e4066Sahrens * If this is an attribute directory, purge its contents.
661fa9e4066Sahrens */
6620a586ceaSMark Shellenbaum if (ZTOV(zp)->v_type == VDIR && (zp->z_pflags & ZFS_XATTR)) {
663fa9e4066Sahrens if (zfs_purgedir(zp) != 0) {
664fa9e4066Sahrens /*
665893a6d32Sahrens * Not enough space to delete some xattrs.
666cdb0ab79Smaybee * Leave it in the unlinked set.
667fa9e4066Sahrens */
6680e276a64Smaybee zfs_znode_dmu_fini(zp);
6690e276a64Smaybee zfs_znode_free(zp);
670fa9e4066Sahrens return;
671fa9e4066Sahrens }
672399cc7d5SChunwei Chen } else {
673cdb0ab79Smaybee /*
674399cc7d5SChunwei Chen * Free up all the data in the file. We don't do this for
675399cc7d5SChunwei Chen * XATTR directories because we need truncate and remove to be
676399cc7d5SChunwei Chen * in the same tx, like in zfs_znode_delete(). Otherwise, if
677399cc7d5SChunwei Chen * we crash here we'll end up with an inconsistent truncated
678399cc7d5SChunwei Chen * zap object in the delete queue. Note a truncated file is
679399cc7d5SChunwei Chen * harmless since it only contains user data.
680cdb0ab79Smaybee */
681399cc7d5SChunwei Chen error = dmu_free_long_range(os, zp->z_id, 0, DMU_OBJECT_END);
682399cc7d5SChunwei Chen if (error) {
683399cc7d5SChunwei Chen /*
684eb721827SAlek Pinchuk * Not enough space or we were interrupted by unmount.
685eb721827SAlek Pinchuk * Leave the file in the unlinked set.
686399cc7d5SChunwei Chen */
687399cc7d5SChunwei Chen zfs_znode_dmu_fini(zp);
688399cc7d5SChunwei Chen zfs_znode_free(zp);
689399cc7d5SChunwei Chen return;
690399cc7d5SChunwei Chen }
691cdb0ab79Smaybee }
692cdb0ab79Smaybee
693fa9e4066Sahrens /*
694893a6d32Sahrens * If the file has extended attributes, we're going to unlink
695893a6d32Sahrens * the xattr dir.
696fa9e4066Sahrens */
6970a586ceaSMark Shellenbaum error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
6980a586ceaSMark Shellenbaum &xattr_obj, sizeof (xattr_obj));
6990a586ceaSMark Shellenbaum if (error == 0 && xattr_obj) {
7000a586ceaSMark Shellenbaum error = zfs_zget(zfsvfs, xattr_obj, &xzp);
701fa9e4066Sahrens ASSERT(error == 0);
702fa9e4066Sahrens }
703fa9e4066Sahrens
7041412a1a2SMark Shellenbaum acl_obj = zfs_external_acl(zp);
705fa9e4066Sahrens
706fa9e4066Sahrens /*
707cdb0ab79Smaybee * Set up the final transaction.
708fa9e4066Sahrens */
709fa9e4066Sahrens tx = dmu_tx_create(os);
710fa9e4066Sahrens dmu_tx_hold_free(tx, zp->z_id, 0, DMU_OBJECT_END);
711893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
712fa9e4066Sahrens if (xzp) {
713893a6d32Sahrens dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, TRUE, NULL);
7140a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
715fa9e4066Sahrens }
716fa9e4066Sahrens if (acl_obj)
717fa9e4066Sahrens dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
7180a586ceaSMark Shellenbaum
7190a586ceaSMark Shellenbaum zfs_sa_upgrade_txholds(tx, zp);
720*c2270953SArne Jansen dmu_tx_mark_netfree(tx);
721fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT);
722fa9e4066Sahrens if (error) {
723fa9e4066Sahrens /*
724893a6d32Sahrens * Not enough space to delete the file. Leave it in the
725893a6d32Sahrens * unlinked set, leaking it until the fs is remounted (at
726893a6d32Sahrens * which point we'll call zfs_unlinked_drain() to process it).
727fa9e4066Sahrens */
728893a6d32Sahrens dmu_tx_abort(tx);
7290e276a64Smaybee zfs_znode_dmu_fini(zp);
7300e276a64Smaybee zfs_znode_free(zp);
7310e276a64Smaybee goto out;
732fa9e4066Sahrens }
733fa9e4066Sahrens
734fa9e4066Sahrens if (xzp) {
7350a586ceaSMark Shellenbaum ASSERT(error == 0);
736fa9e4066Sahrens mutex_enter(&xzp->z_lock);
737893a6d32Sahrens xzp->z_unlinked = B_TRUE; /* mark xzp for deletion */
7380a586ceaSMark Shellenbaum xzp->z_links = 0; /* no more links to it */
7390a586ceaSMark Shellenbaum VERIFY(0 == sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs),
7400a586ceaSMark Shellenbaum &xzp->z_links, sizeof (xzp->z_links), tx));
741fa9e4066Sahrens mutex_exit(&xzp->z_lock);
742893a6d32Sahrens zfs_unlinked_add(xzp, tx);
743fa9e4066Sahrens }
744fa9e4066Sahrens
745893a6d32Sahrens /* Remove this znode from the unlinked set */
746b420f3adSRichard Lowe VERIFY3U(0, ==,
747b420f3adSRichard Lowe zap_remove_int(zfsvfs->z_os, zfsvfs->z_unlinkedobj, zp->z_id, tx));
748fa9e4066Sahrens
749fa9e4066Sahrens zfs_znode_delete(zp, tx);
750fa9e4066Sahrens
751fa9e4066Sahrens dmu_tx_commit(tx);
7520e276a64Smaybee out:
753fa9e4066Sahrens if (xzp)
754fa9e4066Sahrens VN_RELE(ZTOV(xzp));
755fa9e4066Sahrens }
756fa9e4066Sahrens
757e7437265Sahrens static uint64_t
zfs_dirent(znode_t * zp,uint64_t mode)7580a586ceaSMark Shellenbaum zfs_dirent(znode_t *zp, uint64_t mode)
759e7437265Sahrens {
760e7437265Sahrens uint64_t de = zp->z_id;
7610a586ceaSMark Shellenbaum
762e7437265Sahrens if (zp->z_zfsvfs->z_version >= ZPL_VERSION_DIRENT_TYPE)
7630a586ceaSMark Shellenbaum de |= IFTODT(mode) << 60;
764e7437265Sahrens return (de);
765e7437265Sahrens }
766e7437265Sahrens
767fa9e4066Sahrens /*
768893a6d32Sahrens * Link zp into dl. Can only fail if zp has been unlinked.
769fa9e4066Sahrens */
770fa9e4066Sahrens int
zfs_link_create(zfs_dirlock_t * dl,znode_t * zp,dmu_tx_t * tx,int flag)771fa9e4066Sahrens zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
772fa9e4066Sahrens {
773fa9e4066Sahrens znode_t *dzp = dl->dl_dzp;
7740a586ceaSMark Shellenbaum zfsvfs_t *zfsvfs = zp->z_zfsvfs;
775fa9e4066Sahrens vnode_t *vp = ZTOV(zp);
776b1b8ab34Slling uint64_t value;
777fa9e4066Sahrens int zp_is_dir = (vp->v_type == VDIR);
7780a586ceaSMark Shellenbaum sa_bulk_attr_t bulk[5];
7790a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
7800a586ceaSMark Shellenbaum int count = 0;
781fa9e4066Sahrens int error;
782fa9e4066Sahrens
783fa9e4066Sahrens mutex_enter(&zp->z_lock);
784fa9e4066Sahrens
785fa9e4066Sahrens if (!(flag & ZRENAMING)) {
786893a6d32Sahrens if (zp->z_unlinked) { /* no new links to unlinked zp */
787fa9e4066Sahrens ASSERT(!(flag & (ZNEW | ZEXISTS)));
788fa9e4066Sahrens mutex_exit(&zp->z_lock);
789be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
790fa9e4066Sahrens }
7910a586ceaSMark Shellenbaum zp->z_links++;
7920a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
7930a586ceaSMark Shellenbaum &zp->z_links, sizeof (zp->z_links));
7940a586ceaSMark Shellenbaum
795fa9e4066Sahrens }
7960a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
7970a586ceaSMark Shellenbaum &dzp->z_id, sizeof (dzp->z_id));
7980a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
7990a586ceaSMark Shellenbaum &zp->z_pflags, sizeof (zp->z_pflags));
8000a586ceaSMark Shellenbaum
8010a586ceaSMark Shellenbaum if (!(flag & ZNEW)) {
8020a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
8030a586ceaSMark Shellenbaum ctime, sizeof (ctime));
8040a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
8050a586ceaSMark Shellenbaum ctime, B_TRUE);
8060a586ceaSMark Shellenbaum }
8070a586ceaSMark Shellenbaum error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
8080a586ceaSMark Shellenbaum ASSERT(error == 0);
809fa9e4066Sahrens
810fa9e4066Sahrens mutex_exit(&zp->z_lock);
811fa9e4066Sahrens
812fa9e4066Sahrens mutex_enter(&dzp->z_lock);
8130a586ceaSMark Shellenbaum dzp->z_size++;
8140a586ceaSMark Shellenbaum dzp->z_links += zp_is_dir;
8150a586ceaSMark Shellenbaum count = 0;
8160a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
8170a586ceaSMark Shellenbaum &dzp->z_size, sizeof (dzp->z_size));
8180a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
8190a586ceaSMark Shellenbaum &dzp->z_links, sizeof (dzp->z_links));
8200a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
8210a586ceaSMark Shellenbaum mtime, sizeof (mtime));
8220a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
8230a586ceaSMark Shellenbaum ctime, sizeof (ctime));
8240a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
8250a586ceaSMark Shellenbaum &dzp->z_pflags, sizeof (dzp->z_pflags));
8260a586ceaSMark Shellenbaum zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
8270a586ceaSMark Shellenbaum error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
8280a586ceaSMark Shellenbaum ASSERT(error == 0);
829fa9e4066Sahrens mutex_exit(&dzp->z_lock);
830fa9e4066Sahrens
8310a586ceaSMark Shellenbaum value = zfs_dirent(zp, zp->z_mode);
832fa9e4066Sahrens error = zap_add(zp->z_zfsvfs->z_os, dzp->z_id, dl->dl_name,
833b1b8ab34Slling 8, 1, &value, tx);
834fa9e4066Sahrens ASSERT(error == 0);
835fa9e4066Sahrens
836033f9833Sek dnlc_update(ZTOV(dzp), dl->dl_name, vp);
837033f9833Sek
838fa9e4066Sahrens return (0);
839fa9e4066Sahrens }
840fa9e4066Sahrens
8411c17160aSKevin Crowe /*
8421c17160aSKevin Crowe * The match type in the code for this function should conform to:
8431c17160aSKevin Crowe *
8441c17160aSKevin Crowe * ------------------------------------------------------------------------
8451c17160aSKevin Crowe * fs type | z_norm | lookup type | match type
8461c17160aSKevin Crowe * ---------|-------------|-------------|----------------------------------
8471c17160aSKevin Crowe * CS !norm | 0 | 0 | 0 (exact)
8481c17160aSKevin Crowe * CS norm | formX | 0 | MT_NORMALIZE
8491c17160aSKevin Crowe * CI !norm | upper | !ZCIEXACT | MT_NORMALIZE
8501c17160aSKevin Crowe * CI !norm | upper | ZCIEXACT | MT_NORMALIZE | MT_MATCH_CASE
8511c17160aSKevin Crowe * CI norm | upper|formX | !ZCIEXACT | MT_NORMALIZE
8521c17160aSKevin Crowe * CI norm | upper|formX | ZCIEXACT | MT_NORMALIZE | MT_MATCH_CASE
8531c17160aSKevin Crowe * CM !norm | upper | !ZCILOOK | MT_NORMALIZE | MT_MATCH_CASE
8541c17160aSKevin Crowe * CM !norm | upper | ZCILOOK | MT_NORMALIZE
8551c17160aSKevin Crowe * CM norm | upper|formX | !ZCILOOK | MT_NORMALIZE | MT_MATCH_CASE
8561c17160aSKevin Crowe * CM norm | upper|formX | ZCILOOK | MT_NORMALIZE
8571c17160aSKevin Crowe *
8581c17160aSKevin Crowe * Abbreviations:
8591c17160aSKevin Crowe * CS = Case Sensitive, CI = Case Insensitive, CM = Case Mixed
8601c17160aSKevin Crowe * upper = case folding set by fs type on creation (U8_TEXTPREP_TOUPPER)
8611c17160aSKevin Crowe * formX = unicode normalization form set on fs creation
8621c17160aSKevin Crowe */
8636ed5e6abSSam Falkner static int
zfs_dropname(zfs_dirlock_t * dl,znode_t * zp,znode_t * dzp,dmu_tx_t * tx,int flag)8646ed5e6abSSam Falkner zfs_dropname(zfs_dirlock_t *dl, znode_t *zp, znode_t *dzp, dmu_tx_t *tx,
8656ed5e6abSSam Falkner int flag)
8666ed5e6abSSam Falkner {
8676ed5e6abSSam Falkner int error;
8686ed5e6abSSam Falkner
8696ed5e6abSSam Falkner if (zp->z_zfsvfs->z_norm) {
8701c17160aSKevin Crowe matchtype_t mt = MT_NORMALIZE;
8711c17160aSKevin Crowe
8721c17160aSKevin Crowe if ((zp->z_zfsvfs->z_case == ZFS_CASE_INSENSITIVE &&
8736ed5e6abSSam Falkner (flag & ZCIEXACT)) ||
8741c17160aSKevin Crowe (zp->z_zfsvfs->z_case == ZFS_CASE_MIXED &&
8751c17160aSKevin Crowe !(flag & ZCILOOK))) {
8761c17160aSKevin Crowe mt |= MT_MATCH_CASE;
8771c17160aSKevin Crowe }
8781c17160aSKevin Crowe
8791c17160aSKevin Crowe error = zap_remove_norm(zp->z_zfsvfs->z_os, dzp->z_id,
8801c17160aSKevin Crowe dl->dl_name, mt, tx);
8816ed5e6abSSam Falkner } else {
8821c17160aSKevin Crowe error = zap_remove(zp->z_zfsvfs->z_os, dzp->z_id, dl->dl_name,
8831c17160aSKevin Crowe tx);
8846ed5e6abSSam Falkner }
8856ed5e6abSSam Falkner
8866ed5e6abSSam Falkner return (error);
8876ed5e6abSSam Falkner }
8886ed5e6abSSam Falkner
889fa9e4066Sahrens /*
890893a6d32Sahrens * Unlink zp from dl, and mark zp for deletion if this was the last link.
891fa9e4066Sahrens * Can fail if zp is a mount point (EBUSY) or a non-empty directory (EEXIST).
892893a6d32Sahrens * If 'unlinkedp' is NULL, we put unlinked znodes on the unlinked list.
893893a6d32Sahrens * If it's non-NULL, we use it to indicate whether the znode needs deletion,
894fa9e4066Sahrens * and it's the caller's job to do it.
895fa9e4066Sahrens */
896fa9e4066Sahrens int
zfs_link_destroy(zfs_dirlock_t * dl,znode_t * zp,dmu_tx_t * tx,int flag,boolean_t * unlinkedp)897fa9e4066Sahrens zfs_link_destroy(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag,
8989a686fbcSPaul Dagnelie boolean_t *unlinkedp)
899fa9e4066Sahrens {
900fa9e4066Sahrens znode_t *dzp = dl->dl_dzp;
9010a586ceaSMark Shellenbaum zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
902fa9e4066Sahrens vnode_t *vp = ZTOV(zp);
903fa9e4066Sahrens int zp_is_dir = (vp->v_type == VDIR);
904893a6d32Sahrens boolean_t unlinked = B_FALSE;
9050a586ceaSMark Shellenbaum sa_bulk_attr_t bulk[5];
9060a586ceaSMark Shellenbaum uint64_t mtime[2], ctime[2];
9070a586ceaSMark Shellenbaum int count = 0;
908fa9e4066Sahrens int error;
909fa9e4066Sahrens
910033f9833Sek dnlc_remove(ZTOV(dzp), dl->dl_name);
911033f9833Sek
912fa9e4066Sahrens if (!(flag & ZRENAMING)) {
913fa9e4066Sahrens if (vn_vfswlock(vp)) /* prevent new mounts on zp */
914be6fd75aSMatthew Ahrens return (SET_ERROR(EBUSY));
915fa9e4066Sahrens
916fa9e4066Sahrens if (vn_ismntpt(vp)) { /* don't remove mount point */
917fa9e4066Sahrens vn_vfsunlock(vp);
918be6fd75aSMatthew Ahrens return (SET_ERROR(EBUSY));
919fa9e4066Sahrens }
920fa9e4066Sahrens
921fa9e4066Sahrens mutex_enter(&zp->z_lock);
9220a586ceaSMark Shellenbaum
9230a586ceaSMark Shellenbaum if (zp_is_dir && !zfs_dirempty(zp)) {
924fa9e4066Sahrens mutex_exit(&zp->z_lock);
925fa9e4066Sahrens vn_vfsunlock(vp);
926be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST));
927fa9e4066Sahrens }
9280a586ceaSMark Shellenbaum
9296ed5e6abSSam Falkner /*
9306ed5e6abSSam Falkner * If we get here, we are going to try to remove the object.
9316ed5e6abSSam Falkner * First try removing the name from the directory; if that
9326ed5e6abSSam Falkner * fails, return the error.
9336ed5e6abSSam Falkner */
9346ed5e6abSSam Falkner error = zfs_dropname(dl, zp, dzp, tx, flag);
9356ed5e6abSSam Falkner if (error != 0) {
9366ed5e6abSSam Falkner mutex_exit(&zp->z_lock);
9376ed5e6abSSam Falkner vn_vfsunlock(vp);
9386ed5e6abSSam Falkner return (error);
9396ed5e6abSSam Falkner }
9406ed5e6abSSam Falkner
9410a586ceaSMark Shellenbaum if (zp->z_links <= zp_is_dir) {
9420125049cSahrens zfs_panic_recover("zfs: link count on %s is %u, "
9430125049cSahrens "should be at least %u",
944e2fc3408SPatrick Mooney zp->z_vnode->v_path != vn_vpath_empty ?
945e2fc3408SPatrick Mooney zp->z_vnode->v_path : "<unknown>",
946e2fc3408SPatrick Mooney (int)zp->z_links, zp_is_dir + 1);
9470a586ceaSMark Shellenbaum zp->z_links = zp_is_dir + 1;
9480125049cSahrens }
9490a586ceaSMark Shellenbaum if (--zp->z_links == zp_is_dir) {
950893a6d32Sahrens zp->z_unlinked = B_TRUE;
9510a586ceaSMark Shellenbaum zp->z_links = 0;
952893a6d32Sahrens unlinked = B_TRUE;
953fa9e4066Sahrens } else {
9540a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
9550a586ceaSMark Shellenbaum NULL, &ctime, sizeof (ctime));
9560a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
9570a586ceaSMark Shellenbaum NULL, &zp->z_pflags, sizeof (zp->z_pflags));
9580a586ceaSMark Shellenbaum zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime,
9590a586ceaSMark Shellenbaum B_TRUE);
960fa9e4066Sahrens }
9610a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
9620a586ceaSMark Shellenbaum NULL, &zp->z_links, sizeof (zp->z_links));
9630a586ceaSMark Shellenbaum error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
9640a586ceaSMark Shellenbaum count = 0;
9650a586ceaSMark Shellenbaum ASSERT(error == 0);
966fa9e4066Sahrens mutex_exit(&zp->z_lock);
967fa9e4066Sahrens vn_vfsunlock(vp);
9686ed5e6abSSam Falkner } else {
9696ed5e6abSSam Falkner error = zfs_dropname(dl, zp, dzp, tx, flag);
9706ed5e6abSSam Falkner if (error != 0)
9716ed5e6abSSam Falkner return (error);
972fa9e4066Sahrens }
973fa9e4066Sahrens
974fa9e4066Sahrens mutex_enter(&dzp->z_lock);
9750a586ceaSMark Shellenbaum dzp->z_size--; /* one dirent removed */
9760a586ceaSMark Shellenbaum dzp->z_links -= zp_is_dir; /* ".." link from zp */
9770a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
9780a586ceaSMark Shellenbaum NULL, &dzp->z_links, sizeof (dzp->z_links));
9790a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs),
9800a586ceaSMark Shellenbaum NULL, &dzp->z_size, sizeof (dzp->z_size));
9810a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
9820a586ceaSMark Shellenbaum NULL, ctime, sizeof (ctime));
9830a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs),
9840a586ceaSMark Shellenbaum NULL, mtime, sizeof (mtime));
9850a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
9860a586ceaSMark Shellenbaum NULL, &dzp->z_pflags, sizeof (dzp->z_pflags));
9870a586ceaSMark Shellenbaum zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
9880a586ceaSMark Shellenbaum error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
9890a586ceaSMark Shellenbaum ASSERT(error == 0);
990fa9e4066Sahrens mutex_exit(&dzp->z_lock);
991fa9e4066Sahrens
992893a6d32Sahrens if (unlinkedp != NULL)
993893a6d32Sahrens *unlinkedp = unlinked;
994893a6d32Sahrens else if (unlinked)
995893a6d32Sahrens zfs_unlinked_add(zp, tx);
996fa9e4066Sahrens
997fa9e4066Sahrens return (0);
998fa9e4066Sahrens }
999fa9e4066Sahrens
1000fa9e4066Sahrens /*
1001fa9e4066Sahrens * Indicate whether the directory is empty. Works with or without z_lock
1002fa9e4066Sahrens * held, but can only be consider a hint in the latter case. Returns true
1003fa9e4066Sahrens * if only "." and ".." remain and there's no work in progress.
1004fa9e4066Sahrens */
1005fa9e4066Sahrens boolean_t
zfs_dirempty(znode_t * dzp)1006fa9e4066Sahrens zfs_dirempty(znode_t *dzp)
1007fa9e4066Sahrens {
10080a586ceaSMark Shellenbaum return (dzp->z_size == 2 && dzp->z_dirlocks == 0);
1009fa9e4066Sahrens }
1010fa9e4066Sahrens
1011fa9e4066Sahrens int
zfs_make_xattrdir(znode_t * zp,vattr_t * vap,vnode_t ** xvpp,cred_t * cr)1012fa9e4066Sahrens zfs_make_xattrdir(znode_t *zp, vattr_t *vap, vnode_t **xvpp, cred_t *cr)
1013fa9e4066Sahrens {
1014fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
1015fa9e4066Sahrens znode_t *xzp;
1016fa9e4066Sahrens dmu_tx_t *tx;
1017fa9e4066Sahrens int error;
101889459e17SMark Shellenbaum zfs_acl_ids_t acl_ids;
101989459e17SMark Shellenbaum boolean_t fuid_dirtied;
10200a586ceaSMark Shellenbaum uint64_t parent;
1021fa9e4066Sahrens
1022fa9e4066Sahrens *xvpp = NULL;
1023fa9e4066Sahrens
1024da6c28aaSamw if (error = zfs_zaccess(zp, ACE_WRITE_NAMED_ATTRS, 0, B_FALSE, cr))
1025fa9e4066Sahrens return (error);
1026fa9e4066Sahrens
102789459e17SMark Shellenbaum if ((error = zfs_acl_ids_create(zp, IS_XATTR, vap, cr, NULL,
102889459e17SMark Shellenbaum &acl_ids)) != 0)
102989459e17SMark Shellenbaum return (error);
1030f67950b2SNasf-Fan if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, zp->z_projid)) {
103114843421SMatthew Ahrens zfs_acl_ids_free(&acl_ids);
1032be6fd75aSMatthew Ahrens return (SET_ERROR(EDQUOT));
103314843421SMatthew Ahrens }
103489459e17SMark Shellenbaum
1035fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os);
10360a586ceaSMark Shellenbaum dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
10370a586ceaSMark Shellenbaum ZFS_SA_BASE_ATTR_SIZE);
10380a586ceaSMark Shellenbaum dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
1039ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
104089459e17SMark Shellenbaum fuid_dirtied = zfsvfs->z_fuid_dirty;
104114843421SMatthew Ahrens if (fuid_dirtied)
104214843421SMatthew Ahrens zfs_fuid_txhold(zfsvfs, tx);
1043e722410cSMatthew Ahrens error = dmu_tx_assign(tx, TXG_WAIT);
1044fa9e4066Sahrens if (error) {
1045c8c24165SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1046fa9e4066Sahrens dmu_tx_abort(tx);
1047fa9e4066Sahrens return (error);
1048fa9e4066Sahrens }
10490a586ceaSMark Shellenbaum zfs_mknode(zp, vap, tx, cr, IS_XATTR, &xzp, &acl_ids);
105089459e17SMark Shellenbaum
105189459e17SMark Shellenbaum if (fuid_dirtied)
105289459e17SMark Shellenbaum zfs_fuid_sync(zfsvfs, tx);
105389459e17SMark Shellenbaum
1054f3e6fb2fSMark Shellenbaum #ifdef DEBUG
1055f3e6fb2fSMark Shellenbaum error = sa_lookup(xzp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
1056f3e6fb2fSMark Shellenbaum &parent, sizeof (parent));
1057f3e6fb2fSMark Shellenbaum ASSERT(error == 0 && parent == zp->z_id);
1058f3e6fb2fSMark Shellenbaum #endif
10590a586ceaSMark Shellenbaum
10600a586ceaSMark Shellenbaum VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &xzp->z_id,
10610a586ceaSMark Shellenbaum sizeof (xzp->z_id), tx));
1062fa9e4066Sahrens
1063da6c28aaSamw (void) zfs_log_create(zfsvfs->z_log, tx, TX_MKXATTR, zp,
106489459e17SMark Shellenbaum xzp, "", NULL, acl_ids.z_fuidp, vap);
106589459e17SMark Shellenbaum
106689459e17SMark Shellenbaum zfs_acl_ids_free(&acl_ids);
1067fa9e4066Sahrens dmu_tx_commit(tx);
1068fa9e4066Sahrens
1069fa9e4066Sahrens *xvpp = ZTOV(xzp);
1070fa9e4066Sahrens
1071fa9e4066Sahrens return (0);
1072fa9e4066Sahrens }
1073fa9e4066Sahrens
1074fa9e4066Sahrens /*
1075fa9e4066Sahrens * Return a znode for the extended attribute directory for zp.
1076fa9e4066Sahrens * ** If the directory does not already exist, it is created **
1077fa9e4066Sahrens *
1078fa9e4066Sahrens * IN: zp - znode to obtain attribute directory from
1079fa9e4066Sahrens * cr - credentials of caller
10803f063a9dSck * flags - flags from the VOP_LOOKUP call
1081fa9e4066Sahrens *
1082fa9e4066Sahrens * OUT: xzpp - pointer to extended attribute znode
1083fa9e4066Sahrens *
1084fa9e4066Sahrens * RETURN: 0 on success
1085fa9e4066Sahrens * error number on failure
1086fa9e4066Sahrens */
1087fa9e4066Sahrens int
zfs_get_xattrdir(znode_t * zp,vnode_t ** xvpp,cred_t * cr,int flags)10883f063a9dSck zfs_get_xattrdir(znode_t *zp, vnode_t **xvpp, cred_t *cr, int flags)
1089fa9e4066Sahrens {
1090fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs;
1091fa9e4066Sahrens znode_t *xzp;
1092fa9e4066Sahrens zfs_dirlock_t *dl;
1093fa9e4066Sahrens vattr_t va;
1094fa9e4066Sahrens int error;
1095fa9e4066Sahrens top:
1096da6c28aaSamw error = zfs_dirent_lock(&dl, zp, "", &xzp, ZXATTR, NULL, NULL);
1097fa9e4066Sahrens if (error)
1098fa9e4066Sahrens return (error);
1099fa9e4066Sahrens
1100fa9e4066Sahrens if (xzp != NULL) {
1101fa9e4066Sahrens *xvpp = ZTOV(xzp);
1102fa9e4066Sahrens zfs_dirent_unlock(dl);
1103fa9e4066Sahrens return (0);
1104fa9e4066Sahrens }
1105fa9e4066Sahrens
1106fa9e4066Sahrens
11073f063a9dSck if (!(flags & CREATE_XATTR_DIR)) {
11083f063a9dSck zfs_dirent_unlock(dl);
1109be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT));
11103f063a9dSck }
11113f063a9dSck
1112fa9e4066Sahrens if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
1113fa9e4066Sahrens zfs_dirent_unlock(dl);
1114be6fd75aSMatthew Ahrens return (SET_ERROR(EROFS));
1115fa9e4066Sahrens }
1116fa9e4066Sahrens
1117fa9e4066Sahrens /*
1118fa9e4066Sahrens * The ability to 'create' files in an attribute
1119fa9e4066Sahrens * directory comes from the write_xattr permission on the base file.
1120fa9e4066Sahrens *
1121fa9e4066Sahrens * The ability to 'search' an attribute directory requires
1122fa9e4066Sahrens * read_xattr permission on the base file.
1123fa9e4066Sahrens *
1124fa9e4066Sahrens * Once in a directory the ability to read/write attributes
1125fa9e4066Sahrens * is controlled by the permissions on the attribute file.
1126fa9e4066Sahrens */
1127fa9e4066Sahrens va.va_mask = AT_TYPE | AT_MODE | AT_UID | AT_GID;
1128fa9e4066Sahrens va.va_type = VDIR;
1129d2443e76Smarks va.va_mode = S_IFDIR | S_ISVTX | 0777;
1130bda89588Sjp zfs_fuid_map_ids(zp, cr, &va.va_uid, &va.va_gid);
1131fa9e4066Sahrens
1132fa9e4066Sahrens error = zfs_make_xattrdir(zp, &va, xvpp, cr);
1133fa9e4066Sahrens zfs_dirent_unlock(dl);
1134fa9e4066Sahrens
11351209a471SNeil Perrin if (error == ERESTART) {
11368a2f1b91Sahrens /* NB: we already did dmu_tx_wait() if necessary */
1137fa9e4066Sahrens goto top;
1138fa9e4066Sahrens }
1139fa9e4066Sahrens
1140fa9e4066Sahrens return (error);
1141fa9e4066Sahrens }
1142fa9e4066Sahrens
1143fa9e4066Sahrens /*
1144fa9e4066Sahrens * Decide whether it is okay to remove within a sticky directory.
1145fa9e4066Sahrens *
1146fa9e4066Sahrens * In sticky directories, write access is not sufficient;
1147fa9e4066Sahrens * you can remove entries from a directory only if:
1148fa9e4066Sahrens *
1149fa9e4066Sahrens * you own the directory,
1150fa9e4066Sahrens * you own the entry,
1151fa9e4066Sahrens * the entry is a plain file and you have write access,
1152fa9e4066Sahrens * or you are privileged (checked in secpolicy...).
1153fa9e4066Sahrens *
1154fa9e4066Sahrens * The function returns 0 if remove access is granted.
1155fa9e4066Sahrens */
1156fa9e4066Sahrens int
zfs_sticky_remove_access(znode_t * zdp,znode_t * zp,cred_t * cr)1157fa9e4066Sahrens zfs_sticky_remove_access(znode_t *zdp, znode_t *zp, cred_t *cr)
1158fa9e4066Sahrens {
1159c5832a53SAlek Pinchuk uid_t uid;
1160f1696b23SMark Shellenbaum uid_t downer;
1161f1696b23SMark Shellenbaum uid_t fowner;
1162f1696b23SMark Shellenbaum zfsvfs_t *zfsvfs = zdp->z_zfsvfs;
1163fa9e4066Sahrens
11641209a471SNeil Perrin if (zdp->z_zfsvfs->z_replay)
1165fa9e4066Sahrens return (0);
1166fa9e4066Sahrens
11670a586ceaSMark Shellenbaum if ((zdp->z_mode & S_ISVTX) == 0)
1168da6c28aaSamw return (0);
1169da6c28aaSamw
1170f1696b23SMark Shellenbaum downer = zfs_fuid_map_id(zfsvfs, zdp->z_uid, cr, ZFS_OWNER);
1171f1696b23SMark Shellenbaum fowner = zfs_fuid_map_id(zfsvfs, zp->z_uid, cr, ZFS_OWNER);
1172f1696b23SMark Shellenbaum
1173f1696b23SMark Shellenbaum if ((uid = crgetuid(cr)) == downer || uid == fowner ||
1174fa9e4066Sahrens (ZTOV(zp)->v_type == VREG &&
1175da6c28aaSamw zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0))
1176fa9e4066Sahrens return (0);
1177fa9e4066Sahrens else
1178fa9e4066Sahrens return (secpolicy_vnode_remove(cr));
1179fa9e4066Sahrens }
1180