1*0a6a1f1dSLionel Sambuc /* $NetBSD: ufs_vnops.c,v 1.231 2015/09/01 06:09:23 dholland Exp $ */
2d65f6f70SBen Gras
3d65f6f70SBen Gras /*-
4d65f6f70SBen Gras * Copyright (c) 2008 The NetBSD Foundation, Inc.
5d65f6f70SBen Gras * All rights reserved.
6d65f6f70SBen Gras *
7d65f6f70SBen Gras * This code is derived from software contributed to The NetBSD Foundation
8d65f6f70SBen Gras * by Wasabi Systems, Inc.
9d65f6f70SBen Gras *
10d65f6f70SBen Gras * Redistribution and use in source and binary forms, with or without
11d65f6f70SBen Gras * modification, are permitted provided that the following conditions
12d65f6f70SBen Gras * are met:
13d65f6f70SBen Gras * 1. Redistributions of source code must retain the above copyright
14d65f6f70SBen Gras * notice, this list of conditions and the following disclaimer.
15d65f6f70SBen Gras * 2. Redistributions in binary form must reproduce the above copyright
16d65f6f70SBen Gras * notice, this list of conditions and the following disclaimer in the
17d65f6f70SBen Gras * documentation and/or other materials provided with the distribution.
18d65f6f70SBen Gras *
19d65f6f70SBen Gras * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20d65f6f70SBen Gras * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21d65f6f70SBen Gras * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22d65f6f70SBen Gras * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23d65f6f70SBen Gras * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24d65f6f70SBen Gras * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25d65f6f70SBen Gras * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26d65f6f70SBen Gras * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27d65f6f70SBen Gras * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28d65f6f70SBen Gras * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29d65f6f70SBen Gras * POSSIBILITY OF SUCH DAMAGE.
30d65f6f70SBen Gras */
31d65f6f70SBen Gras
32d65f6f70SBen Gras /*
33d65f6f70SBen Gras * Copyright (c) 1982, 1986, 1989, 1993, 1995
34d65f6f70SBen Gras * The Regents of the University of California. All rights reserved.
35d65f6f70SBen Gras * (c) UNIX System Laboratories, Inc.
36d65f6f70SBen Gras * All or some portions of this file are derived from material licensed
37d65f6f70SBen Gras * to the University of California by American Telephone and Telegraph
38d65f6f70SBen Gras * Co. or Unix System Laboratories, Inc. and are reproduced herein with
39d65f6f70SBen Gras * the permission of UNIX System Laboratories, Inc.
40d65f6f70SBen Gras *
41d65f6f70SBen Gras * Redistribution and use in source and binary forms, with or without
42d65f6f70SBen Gras * modification, are permitted provided that the following conditions
43d65f6f70SBen Gras * are met:
44d65f6f70SBen Gras * 1. Redistributions of source code must retain the above copyright
45d65f6f70SBen Gras * notice, this list of conditions and the following disclaimer.
46d65f6f70SBen Gras * 2. Redistributions in binary form must reproduce the above copyright
47d65f6f70SBen Gras * notice, this list of conditions and the following disclaimer in the
48d65f6f70SBen Gras * documentation and/or other materials provided with the distribution.
49d65f6f70SBen Gras * 3. Neither the name of the University nor the names of its contributors
50d65f6f70SBen Gras * may be used to endorse or promote products derived from this software
51d65f6f70SBen Gras * without specific prior written permission.
52d65f6f70SBen Gras *
53d65f6f70SBen Gras * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54d65f6f70SBen Gras * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55d65f6f70SBen Gras * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56d65f6f70SBen Gras * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57d65f6f70SBen Gras * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58d65f6f70SBen Gras * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59d65f6f70SBen Gras * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60d65f6f70SBen Gras * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61d65f6f70SBen Gras * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62d65f6f70SBen Gras * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63d65f6f70SBen Gras * SUCH DAMAGE.
64d65f6f70SBen Gras *
65d65f6f70SBen Gras * @(#)ufs_vnops.c 8.28 (Berkeley) 7/31/95
66d65f6f70SBen Gras */
67d65f6f70SBen Gras
68d65f6f70SBen Gras #include <sys/cdefs.h>
69*0a6a1f1dSLionel Sambuc __KERNEL_RCSID(0, "$NetBSD: ufs_vnops.c,v 1.231 2015/09/01 06:09:23 dholland Exp $");
70d65f6f70SBen Gras
71d65f6f70SBen Gras #if defined(_KERNEL_OPT)
72d65f6f70SBen Gras #include "opt_ffs.h"
73d65f6f70SBen Gras #include "opt_quota.h"
74d65f6f70SBen Gras #endif
75d65f6f70SBen Gras
76d65f6f70SBen Gras #include <sys/param.h>
77d65f6f70SBen Gras #include <sys/systm.h>
78d65f6f70SBen Gras #include <sys/namei.h>
79d65f6f70SBen Gras #include <sys/resourcevar.h>
80d65f6f70SBen Gras #include <sys/kernel.h>
81d65f6f70SBen Gras #include <sys/file.h>
82d65f6f70SBen Gras #include <sys/stat.h>
83d65f6f70SBen Gras #include <sys/buf.h>
84d65f6f70SBen Gras #include <sys/proc.h>
85d65f6f70SBen Gras #include <sys/mount.h>
86d65f6f70SBen Gras #include <sys/vnode.h>
8784d9c625SLionel Sambuc #include <sys/kmem.h>
88d65f6f70SBen Gras #include <sys/malloc.h>
89d65f6f70SBen Gras #include <sys/dirent.h>
90d65f6f70SBen Gras #include <sys/lockf.h>
91d65f6f70SBen Gras #include <sys/kauth.h>
92d65f6f70SBen Gras #include <sys/wapbl.h>
93d65f6f70SBen Gras #include <sys/fstrans.h>
94d65f6f70SBen Gras
95d65f6f70SBen Gras #include <miscfs/specfs/specdev.h>
96d65f6f70SBen Gras #include <miscfs/fifofs/fifo.h>
97d65f6f70SBen Gras #include <miscfs/genfs/genfs.h>
98d65f6f70SBen Gras
99d65f6f70SBen Gras #include <ufs/ufs/inode.h>
100d65f6f70SBen Gras #include <ufs/ufs/dir.h>
101d65f6f70SBen Gras #include <ufs/ufs/ufsmount.h>
102d65f6f70SBen Gras #include <ufs/ufs/ufs_bswap.h>
103d65f6f70SBen Gras #include <ufs/ufs/ufs_extern.h>
104d65f6f70SBen Gras #include <ufs/ufs/ufs_wapbl.h>
105d65f6f70SBen Gras #ifdef UFS_DIRHASH
106d65f6f70SBen Gras #include <ufs/ufs/dirhash.h>
107d65f6f70SBen Gras #endif
108d65f6f70SBen Gras #include <ufs/ext2fs/ext2fs_extern.h>
109d65f6f70SBen Gras #include <ufs/ext2fs/ext2fs_dir.h>
110d65f6f70SBen Gras #include <ufs/ffs/ffs_extern.h>
111d65f6f70SBen Gras #include <ufs/lfs/lfs_extern.h>
112d65f6f70SBen Gras #include <ufs/lfs/lfs.h>
113d65f6f70SBen Gras
114d65f6f70SBen Gras #include <uvm/uvm.h>
115d65f6f70SBen Gras
116d65f6f70SBen Gras __CTASSERT(EXT2FS_MAXNAMLEN == FFS_MAXNAMLEN);
117d65f6f70SBen Gras __CTASSERT(LFS_MAXNAMLEN == FFS_MAXNAMLEN);
118d65f6f70SBen Gras
119d65f6f70SBen Gras static int ufs_chmod(struct vnode *, int, kauth_cred_t, struct lwp *);
120d65f6f70SBen Gras static int ufs_chown(struct vnode *, uid_t, gid_t, kauth_cred_t,
121d65f6f70SBen Gras struct lwp *);
122*0a6a1f1dSLionel Sambuc static int ufs_makeinode(struct vattr *, struct vnode *,
123*0a6a1f1dSLionel Sambuc const struct ufs_lookup_results *, struct vnode **, struct componentname *);
124d65f6f70SBen Gras
125d65f6f70SBen Gras /*
126d65f6f70SBen Gras * A virgin directory (no blushing please).
127d65f6f70SBen Gras */
128d65f6f70SBen Gras static const struct dirtemplate mastertemplate = {
129d65f6f70SBen Gras 0, 12, DT_DIR, 1, ".",
13084d9c625SLionel Sambuc 0, UFS_DIRBLKSIZ - 12, DT_DIR, 2, ".."
131d65f6f70SBen Gras };
132d65f6f70SBen Gras
133d65f6f70SBen Gras /*
134d65f6f70SBen Gras * Create a regular file
135d65f6f70SBen Gras */
136d65f6f70SBen Gras int
ufs_create(void * v)137d65f6f70SBen Gras ufs_create(void *v)
138d65f6f70SBen Gras {
139*0a6a1f1dSLionel Sambuc struct vop_create_v3_args /* {
140d65f6f70SBen Gras struct vnode *a_dvp;
141d65f6f70SBen Gras struct vnode **a_vpp;
142d65f6f70SBen Gras struct componentname *a_cnp;
143d65f6f70SBen Gras struct vattr *a_vap;
144d65f6f70SBen Gras } */ *ap = v;
145d65f6f70SBen Gras int error;
146d65f6f70SBen Gras struct vnode *dvp = ap->a_dvp;
147d65f6f70SBen Gras struct ufs_lookup_results *ulr;
148d65f6f70SBen Gras
149d65f6f70SBen Gras /* XXX should handle this material another way */
150d65f6f70SBen Gras ulr = &VTOI(dvp)->i_crap;
151d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(dvp));
152d65f6f70SBen Gras
153d65f6f70SBen Gras /*
154d65f6f70SBen Gras * UFS_WAPBL_BEGIN1(dvp->v_mount, dvp) performed by successful
155d65f6f70SBen Gras * ufs_makeinode
156d65f6f70SBen Gras */
157d65f6f70SBen Gras fstrans_start(dvp->v_mount, FSTRANS_SHARED);
158*0a6a1f1dSLionel Sambuc error = ufs_makeinode(ap->a_vap, dvp, ulr, ap->a_vpp, ap->a_cnp);
159d65f6f70SBen Gras if (error) {
160d65f6f70SBen Gras fstrans_done(dvp->v_mount);
161d65f6f70SBen Gras return (error);
162d65f6f70SBen Gras }
163d65f6f70SBen Gras UFS_WAPBL_END1(dvp->v_mount, dvp);
164d65f6f70SBen Gras fstrans_done(dvp->v_mount);
165d65f6f70SBen Gras VN_KNOTE(dvp, NOTE_WRITE);
166*0a6a1f1dSLionel Sambuc VOP_UNLOCK(*ap->a_vpp);
167d65f6f70SBen Gras return (0);
168d65f6f70SBen Gras }
169d65f6f70SBen Gras
170d65f6f70SBen Gras /*
171d65f6f70SBen Gras * Mknod vnode call
172d65f6f70SBen Gras */
173d65f6f70SBen Gras /* ARGSUSED */
174d65f6f70SBen Gras int
ufs_mknod(void * v)175d65f6f70SBen Gras ufs_mknod(void *v)
176d65f6f70SBen Gras {
177*0a6a1f1dSLionel Sambuc struct vop_mknod_v3_args /* {
178d65f6f70SBen Gras struct vnode *a_dvp;
179d65f6f70SBen Gras struct vnode **a_vpp;
180d65f6f70SBen Gras struct componentname *a_cnp;
181d65f6f70SBen Gras struct vattr *a_vap;
182d65f6f70SBen Gras } */ *ap = v;
183d65f6f70SBen Gras struct vattr *vap;
184d65f6f70SBen Gras struct vnode **vpp;
185d65f6f70SBen Gras struct inode *ip;
186d65f6f70SBen Gras int error;
187d65f6f70SBen Gras struct ufs_lookup_results *ulr;
188d65f6f70SBen Gras
189d65f6f70SBen Gras vap = ap->a_vap;
190d65f6f70SBen Gras vpp = ap->a_vpp;
191d65f6f70SBen Gras
192d65f6f70SBen Gras /* XXX should handle this material another way */
193d65f6f70SBen Gras ulr = &VTOI(ap->a_dvp)->i_crap;
194d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(ap->a_dvp));
195d65f6f70SBen Gras
196d65f6f70SBen Gras /*
197d65f6f70SBen Gras * UFS_WAPBL_BEGIN1(dvp->v_mount, dvp) performed by successful
198d65f6f70SBen Gras * ufs_makeinode
199d65f6f70SBen Gras */
200d65f6f70SBen Gras fstrans_start(ap->a_dvp->v_mount, FSTRANS_SHARED);
201*0a6a1f1dSLionel Sambuc if ((error = ufs_makeinode(vap, ap->a_dvp, ulr, vpp, ap->a_cnp)) != 0)
202d65f6f70SBen Gras goto out;
203d65f6f70SBen Gras VN_KNOTE(ap->a_dvp, NOTE_WRITE);
204d65f6f70SBen Gras ip = VTOI(*vpp);
205d65f6f70SBen Gras ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
206d65f6f70SBen Gras UFS_WAPBL_UPDATE(*vpp, NULL, NULL, 0);
207d65f6f70SBen Gras UFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
208d65f6f70SBen Gras VOP_UNLOCK(*vpp);
209d65f6f70SBen Gras out:
210d65f6f70SBen Gras fstrans_done(ap->a_dvp->v_mount);
211d65f6f70SBen Gras if (error != 0) {
212d65f6f70SBen Gras *vpp = NULL;
213d65f6f70SBen Gras return (error);
214d65f6f70SBen Gras }
215d65f6f70SBen Gras return (0);
216d65f6f70SBen Gras }
217d65f6f70SBen Gras
218d65f6f70SBen Gras /*
219d65f6f70SBen Gras * Open called.
220d65f6f70SBen Gras *
221d65f6f70SBen Gras * Nothing to do.
222d65f6f70SBen Gras */
223d65f6f70SBen Gras /* ARGSUSED */
224d65f6f70SBen Gras int
ufs_open(void * v)225d65f6f70SBen Gras ufs_open(void *v)
226d65f6f70SBen Gras {
227d65f6f70SBen Gras struct vop_open_args /* {
228d65f6f70SBen Gras struct vnode *a_vp;
229d65f6f70SBen Gras int a_mode;
230d65f6f70SBen Gras kauth_cred_t a_cred;
231d65f6f70SBen Gras } */ *ap = v;
232d65f6f70SBen Gras
233d65f6f70SBen Gras /*
234d65f6f70SBen Gras * Files marked append-only must be opened for appending.
235d65f6f70SBen Gras */
236d65f6f70SBen Gras if ((VTOI(ap->a_vp)->i_flags & APPEND) &&
237d65f6f70SBen Gras (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
238d65f6f70SBen Gras return (EPERM);
239d65f6f70SBen Gras return (0);
240d65f6f70SBen Gras }
241d65f6f70SBen Gras
242d65f6f70SBen Gras /*
243d65f6f70SBen Gras * Close called.
244d65f6f70SBen Gras *
245d65f6f70SBen Gras * Update the times on the inode.
246d65f6f70SBen Gras */
247d65f6f70SBen Gras /* ARGSUSED */
248d65f6f70SBen Gras int
ufs_close(void * v)249d65f6f70SBen Gras ufs_close(void *v)
250d65f6f70SBen Gras {
251d65f6f70SBen Gras struct vop_close_args /* {
252d65f6f70SBen Gras struct vnode *a_vp;
253d65f6f70SBen Gras int a_fflag;
254d65f6f70SBen Gras kauth_cred_t a_cred;
255d65f6f70SBen Gras } */ *ap = v;
256d65f6f70SBen Gras struct vnode *vp;
257d65f6f70SBen Gras
258d65f6f70SBen Gras vp = ap->a_vp;
259d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
260d65f6f70SBen Gras if (vp->v_usecount > 1)
261d65f6f70SBen Gras UFS_ITIMES(vp, NULL, NULL, NULL);
262d65f6f70SBen Gras fstrans_done(vp->v_mount);
263d65f6f70SBen Gras return (0);
264d65f6f70SBen Gras }
265d65f6f70SBen Gras
266d65f6f70SBen Gras static int
ufs_check_possible(struct vnode * vp,struct inode * ip,mode_t mode,kauth_cred_t cred)267d65f6f70SBen Gras ufs_check_possible(struct vnode *vp, struct inode *ip, mode_t mode,
268d65f6f70SBen Gras kauth_cred_t cred)
269d65f6f70SBen Gras {
270d65f6f70SBen Gras #if defined(QUOTA) || defined(QUOTA2)
271d65f6f70SBen Gras int error;
272d65f6f70SBen Gras #endif
273d65f6f70SBen Gras
274d65f6f70SBen Gras /*
275d65f6f70SBen Gras * Disallow write attempts on read-only file systems;
276d65f6f70SBen Gras * unless the file is a socket, fifo, or a block or
277d65f6f70SBen Gras * character device resident on the file system.
278d65f6f70SBen Gras */
279d65f6f70SBen Gras if (mode & VWRITE) {
280d65f6f70SBen Gras switch (vp->v_type) {
281d65f6f70SBen Gras case VDIR:
282d65f6f70SBen Gras case VLNK:
283d65f6f70SBen Gras case VREG:
284d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY)
285d65f6f70SBen Gras return (EROFS);
286d65f6f70SBen Gras #if defined(QUOTA) || defined(QUOTA2)
287d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
288d65f6f70SBen Gras error = chkdq(ip, 0, cred, 0);
289d65f6f70SBen Gras fstrans_done(vp->v_mount);
290d65f6f70SBen Gras if (error != 0)
291d65f6f70SBen Gras return error;
292d65f6f70SBen Gras #endif
293d65f6f70SBen Gras break;
294d65f6f70SBen Gras case VBAD:
295d65f6f70SBen Gras case VBLK:
296d65f6f70SBen Gras case VCHR:
297d65f6f70SBen Gras case VSOCK:
298d65f6f70SBen Gras case VFIFO:
299d65f6f70SBen Gras case VNON:
300d65f6f70SBen Gras default:
301d65f6f70SBen Gras break;
302d65f6f70SBen Gras }
303d65f6f70SBen Gras }
304d65f6f70SBen Gras
305d65f6f70SBen Gras /* If it is a snapshot, nobody gets access to it. */
306d65f6f70SBen Gras if ((ip->i_flags & SF_SNAPSHOT))
307d65f6f70SBen Gras return (EPERM);
308d65f6f70SBen Gras /* If immutable bit set, nobody gets to write it. */
309d65f6f70SBen Gras if ((mode & VWRITE) && (ip->i_flags & IMMUTABLE))
310d65f6f70SBen Gras return (EPERM);
311d65f6f70SBen Gras
312d65f6f70SBen Gras return 0;
313d65f6f70SBen Gras }
314d65f6f70SBen Gras
315d65f6f70SBen Gras static int
ufs_check_permitted(struct vnode * vp,struct inode * ip,mode_t mode,kauth_cred_t cred)316d65f6f70SBen Gras ufs_check_permitted(struct vnode *vp, struct inode *ip, mode_t mode,
317d65f6f70SBen Gras kauth_cred_t cred)
318d65f6f70SBen Gras {
319d65f6f70SBen Gras
32084d9c625SLionel Sambuc return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(mode, vp->v_type,
32184d9c625SLionel Sambuc ip->i_mode & ALLPERMS), vp, NULL, genfs_can_access(vp->v_type,
32284d9c625SLionel Sambuc ip->i_mode & ALLPERMS, ip->i_uid, ip->i_gid, mode, cred));
323d65f6f70SBen Gras }
324d65f6f70SBen Gras
325d65f6f70SBen Gras int
ufs_access(void * v)326d65f6f70SBen Gras ufs_access(void *v)
327d65f6f70SBen Gras {
328d65f6f70SBen Gras struct vop_access_args /* {
329d65f6f70SBen Gras struct vnode *a_vp;
330d65f6f70SBen Gras int a_mode;
331d65f6f70SBen Gras kauth_cred_t a_cred;
332d65f6f70SBen Gras } */ *ap = v;
333d65f6f70SBen Gras struct vnode *vp;
334d65f6f70SBen Gras struct inode *ip;
335d65f6f70SBen Gras mode_t mode;
336d65f6f70SBen Gras int error;
337d65f6f70SBen Gras
338d65f6f70SBen Gras vp = ap->a_vp;
339d65f6f70SBen Gras ip = VTOI(vp);
340d65f6f70SBen Gras mode = ap->a_mode;
341d65f6f70SBen Gras
342d65f6f70SBen Gras error = ufs_check_possible(vp, ip, mode, ap->a_cred);
343d65f6f70SBen Gras if (error)
344d65f6f70SBen Gras return error;
345d65f6f70SBen Gras
346d65f6f70SBen Gras error = ufs_check_permitted(vp, ip, mode, ap->a_cred);
347d65f6f70SBen Gras
348d65f6f70SBen Gras return error;
349d65f6f70SBen Gras }
350d65f6f70SBen Gras
351d65f6f70SBen Gras /* ARGSUSED */
352d65f6f70SBen Gras int
ufs_getattr(void * v)353d65f6f70SBen Gras ufs_getattr(void *v)
354d65f6f70SBen Gras {
355d65f6f70SBen Gras struct vop_getattr_args /* {
356d65f6f70SBen Gras struct vnode *a_vp;
357d65f6f70SBen Gras struct vattr *a_vap;
358d65f6f70SBen Gras kauth_cred_t a_cred;
359d65f6f70SBen Gras } */ *ap = v;
360d65f6f70SBen Gras struct vnode *vp;
361d65f6f70SBen Gras struct inode *ip;
362d65f6f70SBen Gras struct vattr *vap;
363d65f6f70SBen Gras
364d65f6f70SBen Gras vp = ap->a_vp;
365d65f6f70SBen Gras ip = VTOI(vp);
366d65f6f70SBen Gras vap = ap->a_vap;
367d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
368d65f6f70SBen Gras UFS_ITIMES(vp, NULL, NULL, NULL);
369d65f6f70SBen Gras
370d65f6f70SBen Gras /*
371d65f6f70SBen Gras * Copy from inode table
372d65f6f70SBen Gras */
373d65f6f70SBen Gras vap->va_fsid = ip->i_dev;
374d65f6f70SBen Gras vap->va_fileid = ip->i_number;
375d65f6f70SBen Gras vap->va_mode = ip->i_mode & ALLPERMS;
376d65f6f70SBen Gras vap->va_nlink = ip->i_nlink;
377d65f6f70SBen Gras vap->va_uid = ip->i_uid;
378d65f6f70SBen Gras vap->va_gid = ip->i_gid;
379d65f6f70SBen Gras vap->va_size = vp->v_size;
380d65f6f70SBen Gras if (ip->i_ump->um_fstype == UFS1) {
381*0a6a1f1dSLionel Sambuc switch (vp->v_type) {
382*0a6a1f1dSLionel Sambuc case VBLK:
383*0a6a1f1dSLionel Sambuc case VCHR:
384d65f6f70SBen Gras vap->va_rdev = (dev_t)ufs_rw32(ip->i_ffs1_rdev,
385d65f6f70SBen Gras UFS_MPNEEDSWAP(ip->i_ump));
386*0a6a1f1dSLionel Sambuc break;
387*0a6a1f1dSLionel Sambuc default:
388*0a6a1f1dSLionel Sambuc vap->va_rdev = NODEV;
389*0a6a1f1dSLionel Sambuc break;
390*0a6a1f1dSLionel Sambuc }
391d65f6f70SBen Gras vap->va_atime.tv_sec = ip->i_ffs1_atime;
392d65f6f70SBen Gras vap->va_atime.tv_nsec = ip->i_ffs1_atimensec;
393d65f6f70SBen Gras vap->va_mtime.tv_sec = ip->i_ffs1_mtime;
394d65f6f70SBen Gras vap->va_mtime.tv_nsec = ip->i_ffs1_mtimensec;
395d65f6f70SBen Gras vap->va_ctime.tv_sec = ip->i_ffs1_ctime;
396d65f6f70SBen Gras vap->va_ctime.tv_nsec = ip->i_ffs1_ctimensec;
397d65f6f70SBen Gras vap->va_birthtime.tv_sec = 0;
398d65f6f70SBen Gras vap->va_birthtime.tv_nsec = 0;
399d65f6f70SBen Gras vap->va_bytes = dbtob((u_quad_t)ip->i_ffs1_blocks);
400d65f6f70SBen Gras } else {
401*0a6a1f1dSLionel Sambuc switch (vp->v_type) {
402*0a6a1f1dSLionel Sambuc case VBLK:
403*0a6a1f1dSLionel Sambuc case VCHR:
404d65f6f70SBen Gras vap->va_rdev = (dev_t)ufs_rw64(ip->i_ffs2_rdev,
405d65f6f70SBen Gras UFS_MPNEEDSWAP(ip->i_ump));
406*0a6a1f1dSLionel Sambuc break;
407*0a6a1f1dSLionel Sambuc default:
408*0a6a1f1dSLionel Sambuc vap->va_rdev = NODEV;
409*0a6a1f1dSLionel Sambuc break;
410*0a6a1f1dSLionel Sambuc }
411d65f6f70SBen Gras vap->va_atime.tv_sec = ip->i_ffs2_atime;
412d65f6f70SBen Gras vap->va_atime.tv_nsec = ip->i_ffs2_atimensec;
413d65f6f70SBen Gras vap->va_mtime.tv_sec = ip->i_ffs2_mtime;
414d65f6f70SBen Gras vap->va_mtime.tv_nsec = ip->i_ffs2_mtimensec;
415d65f6f70SBen Gras vap->va_ctime.tv_sec = ip->i_ffs2_ctime;
416d65f6f70SBen Gras vap->va_ctime.tv_nsec = ip->i_ffs2_ctimensec;
417d65f6f70SBen Gras vap->va_birthtime.tv_sec = ip->i_ffs2_birthtime;
418d65f6f70SBen Gras vap->va_birthtime.tv_nsec = ip->i_ffs2_birthnsec;
419d65f6f70SBen Gras vap->va_bytes = dbtob(ip->i_ffs2_blocks);
420d65f6f70SBen Gras }
421d65f6f70SBen Gras vap->va_gen = ip->i_gen;
422d65f6f70SBen Gras vap->va_flags = ip->i_flags;
423d65f6f70SBen Gras
424d65f6f70SBen Gras /* this doesn't belong here */
425d65f6f70SBen Gras if (vp->v_type == VBLK)
426d65f6f70SBen Gras vap->va_blocksize = BLKDEV_IOSIZE;
427d65f6f70SBen Gras else if (vp->v_type == VCHR)
428d65f6f70SBen Gras vap->va_blocksize = MAXBSIZE;
429d65f6f70SBen Gras else
430d65f6f70SBen Gras vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
431d65f6f70SBen Gras vap->va_type = vp->v_type;
432d65f6f70SBen Gras vap->va_filerev = ip->i_modrev;
433d65f6f70SBen Gras fstrans_done(vp->v_mount);
434d65f6f70SBen Gras return (0);
435d65f6f70SBen Gras }
436d65f6f70SBen Gras
437d65f6f70SBen Gras /*
438d65f6f70SBen Gras * Set attribute vnode op. called from several syscalls
439d65f6f70SBen Gras */
440d65f6f70SBen Gras int
ufs_setattr(void * v)441d65f6f70SBen Gras ufs_setattr(void *v)
442d65f6f70SBen Gras {
443d65f6f70SBen Gras struct vop_setattr_args /* {
444d65f6f70SBen Gras struct vnode *a_vp;
445d65f6f70SBen Gras struct vattr *a_vap;
446d65f6f70SBen Gras kauth_cred_t a_cred;
447d65f6f70SBen Gras } */ *ap = v;
448d65f6f70SBen Gras struct vattr *vap;
449d65f6f70SBen Gras struct vnode *vp;
450d65f6f70SBen Gras struct inode *ip;
451d65f6f70SBen Gras kauth_cred_t cred;
452d65f6f70SBen Gras struct lwp *l;
453d65f6f70SBen Gras int error;
45484d9c625SLionel Sambuc kauth_action_t action;
45584d9c625SLionel Sambuc bool changing_sysflags;
456d65f6f70SBen Gras
457d65f6f70SBen Gras vap = ap->a_vap;
458d65f6f70SBen Gras vp = ap->a_vp;
459d65f6f70SBen Gras ip = VTOI(vp);
460d65f6f70SBen Gras cred = ap->a_cred;
461d65f6f70SBen Gras l = curlwp;
46284d9c625SLionel Sambuc action = KAUTH_VNODE_WRITE_FLAGS;
46384d9c625SLionel Sambuc changing_sysflags = false;
464d65f6f70SBen Gras
465d65f6f70SBen Gras /*
466d65f6f70SBen Gras * Check for unsettable attributes.
467d65f6f70SBen Gras */
468d65f6f70SBen Gras if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
469d65f6f70SBen Gras (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
470d65f6f70SBen Gras (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
471d65f6f70SBen Gras ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
472d65f6f70SBen Gras return (EINVAL);
473d65f6f70SBen Gras }
474d65f6f70SBen Gras
475d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
476d65f6f70SBen Gras
477d65f6f70SBen Gras if (vap->va_flags != VNOVAL) {
478d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY) {
479d65f6f70SBen Gras error = EROFS;
480d65f6f70SBen Gras goto out;
481d65f6f70SBen Gras }
48284d9c625SLionel Sambuc
483d65f6f70SBen Gras /* Snapshot flag cannot be set or cleared */
484d65f6f70SBen Gras if ((vap->va_flags & (SF_SNAPSHOT | SF_SNAPINVAL)) !=
485d65f6f70SBen Gras (ip->i_flags & (SF_SNAPSHOT | SF_SNAPINVAL))) {
486d65f6f70SBen Gras error = EPERM;
487d65f6f70SBen Gras goto out;
488d65f6f70SBen Gras }
48984d9c625SLionel Sambuc
49084d9c625SLionel Sambuc if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND)) {
49184d9c625SLionel Sambuc action |= KAUTH_VNODE_HAS_SYSFLAGS;
49284d9c625SLionel Sambuc }
49384d9c625SLionel Sambuc
49484d9c625SLionel Sambuc if ((vap->va_flags & SF_SETTABLE) !=
49584d9c625SLionel Sambuc (ip->i_flags & SF_SETTABLE)) {
49684d9c625SLionel Sambuc action |= KAUTH_VNODE_WRITE_SYSFLAGS;
49784d9c625SLionel Sambuc changing_sysflags = true;
49884d9c625SLionel Sambuc }
49984d9c625SLionel Sambuc
50084d9c625SLionel Sambuc error = kauth_authorize_vnode(cred, action, vp, NULL,
50184d9c625SLionel Sambuc genfs_can_chflags(cred, vp->v_type, ip->i_uid,
50284d9c625SLionel Sambuc changing_sysflags));
50384d9c625SLionel Sambuc if (error)
50484d9c625SLionel Sambuc goto out;
50584d9c625SLionel Sambuc
50684d9c625SLionel Sambuc if (changing_sysflags) {
507d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(vp->v_mount);
508d65f6f70SBen Gras if (error)
509d65f6f70SBen Gras goto out;
510d65f6f70SBen Gras ip->i_flags = vap->va_flags;
511d65f6f70SBen Gras DIP_ASSIGN(ip, flags, ip->i_flags);
512d65f6f70SBen Gras } else {
513d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(vp->v_mount);
514d65f6f70SBen Gras if (error)
515d65f6f70SBen Gras goto out;
516d65f6f70SBen Gras ip->i_flags &= SF_SETTABLE;
517d65f6f70SBen Gras ip->i_flags |= (vap->va_flags & UF_SETTABLE);
518d65f6f70SBen Gras DIP_ASSIGN(ip, flags, ip->i_flags);
519d65f6f70SBen Gras }
520d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
521d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, 0);
522d65f6f70SBen Gras UFS_WAPBL_END(vp->v_mount);
523d65f6f70SBen Gras if (vap->va_flags & (IMMUTABLE | APPEND)) {
524d65f6f70SBen Gras error = 0;
525d65f6f70SBen Gras goto out;
526d65f6f70SBen Gras }
527d65f6f70SBen Gras }
528d65f6f70SBen Gras if (ip->i_flags & (IMMUTABLE | APPEND)) {
529d65f6f70SBen Gras error = EPERM;
530d65f6f70SBen Gras goto out;
531d65f6f70SBen Gras }
532d65f6f70SBen Gras /*
533d65f6f70SBen Gras * Go through the fields and update iff not VNOVAL.
534d65f6f70SBen Gras */
535d65f6f70SBen Gras if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
536d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY) {
537d65f6f70SBen Gras error = EROFS;
538d65f6f70SBen Gras goto out;
539d65f6f70SBen Gras }
540d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(vp->v_mount);
541d65f6f70SBen Gras if (error)
542d65f6f70SBen Gras goto out;
543d65f6f70SBen Gras error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, l);
544d65f6f70SBen Gras UFS_WAPBL_END(vp->v_mount);
545d65f6f70SBen Gras if (error)
546d65f6f70SBen Gras goto out;
547d65f6f70SBen Gras }
548d65f6f70SBen Gras if (vap->va_size != VNOVAL) {
549d65f6f70SBen Gras /*
550d65f6f70SBen Gras * Disallow write attempts on read-only file systems;
551d65f6f70SBen Gras * unless the file is a socket, fifo, or a block or
552d65f6f70SBen Gras * character device resident on the file system.
553d65f6f70SBen Gras */
554d65f6f70SBen Gras switch (vp->v_type) {
555d65f6f70SBen Gras case VDIR:
556d65f6f70SBen Gras error = EISDIR;
557d65f6f70SBen Gras goto out;
558d65f6f70SBen Gras case VCHR:
559d65f6f70SBen Gras case VBLK:
560d65f6f70SBen Gras case VFIFO:
561d65f6f70SBen Gras break;
562d65f6f70SBen Gras case VREG:
563d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY) {
564d65f6f70SBen Gras error = EROFS;
565d65f6f70SBen Gras goto out;
566d65f6f70SBen Gras }
567d65f6f70SBen Gras if ((ip->i_flags & SF_SNAPSHOT) != 0) {
568d65f6f70SBen Gras error = EPERM;
569d65f6f70SBen Gras goto out;
570d65f6f70SBen Gras }
571*0a6a1f1dSLionel Sambuc error = ufs_truncate(vp, vap->va_size, cred);
572d65f6f70SBen Gras if (error)
573d65f6f70SBen Gras goto out;
574d65f6f70SBen Gras break;
575d65f6f70SBen Gras default:
576d65f6f70SBen Gras error = EOPNOTSUPP;
577d65f6f70SBen Gras goto out;
578d65f6f70SBen Gras }
579d65f6f70SBen Gras }
580d65f6f70SBen Gras ip = VTOI(vp);
581d65f6f70SBen Gras if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL ||
582d65f6f70SBen Gras vap->va_birthtime.tv_sec != VNOVAL) {
583d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY) {
584d65f6f70SBen Gras error = EROFS;
585d65f6f70SBen Gras goto out;
586d65f6f70SBen Gras }
587d65f6f70SBen Gras if ((ip->i_flags & SF_SNAPSHOT) != 0) {
588d65f6f70SBen Gras error = EPERM;
589d65f6f70SBen Gras goto out;
590d65f6f70SBen Gras }
59184d9c625SLionel Sambuc error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
59284d9c625SLionel Sambuc NULL, genfs_can_chtimes(vp, vap->va_vaflags, ip->i_uid, cred));
593d65f6f70SBen Gras if (error)
594d65f6f70SBen Gras goto out;
595d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(vp->v_mount);
596d65f6f70SBen Gras if (error)
597d65f6f70SBen Gras goto out;
598d65f6f70SBen Gras if (vap->va_atime.tv_sec != VNOVAL)
599d65f6f70SBen Gras if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
600d65f6f70SBen Gras ip->i_flag |= IN_ACCESS;
601d65f6f70SBen Gras if (vap->va_mtime.tv_sec != VNOVAL) {
602d65f6f70SBen Gras ip->i_flag |= IN_CHANGE | IN_UPDATE;
603d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RELATIME)
604d65f6f70SBen Gras ip->i_flag |= IN_ACCESS;
605d65f6f70SBen Gras }
606d65f6f70SBen Gras if (vap->va_birthtime.tv_sec != VNOVAL &&
607d65f6f70SBen Gras ip->i_ump->um_fstype == UFS2) {
608d65f6f70SBen Gras ip->i_ffs2_birthtime = vap->va_birthtime.tv_sec;
609d65f6f70SBen Gras ip->i_ffs2_birthnsec = vap->va_birthtime.tv_nsec;
610d65f6f70SBen Gras }
611d65f6f70SBen Gras error = UFS_UPDATE(vp, &vap->va_atime, &vap->va_mtime, 0);
612d65f6f70SBen Gras UFS_WAPBL_END(vp->v_mount);
613d65f6f70SBen Gras if (error)
614d65f6f70SBen Gras goto out;
615d65f6f70SBen Gras }
616d65f6f70SBen Gras error = 0;
617d65f6f70SBen Gras if (vap->va_mode != (mode_t)VNOVAL) {
618d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RDONLY) {
619d65f6f70SBen Gras error = EROFS;
620d65f6f70SBen Gras goto out;
621d65f6f70SBen Gras }
622d65f6f70SBen Gras if ((ip->i_flags & SF_SNAPSHOT) != 0 &&
623d65f6f70SBen Gras (vap->va_mode & (S_IXUSR | S_IWUSR | S_IXGRP | S_IWGRP |
624d65f6f70SBen Gras S_IXOTH | S_IWOTH))) {
625d65f6f70SBen Gras error = EPERM;
626d65f6f70SBen Gras goto out;
627d65f6f70SBen Gras }
628d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(vp->v_mount);
629d65f6f70SBen Gras if (error)
630d65f6f70SBen Gras goto out;
631d65f6f70SBen Gras error = ufs_chmod(vp, (int)vap->va_mode, cred, l);
632d65f6f70SBen Gras UFS_WAPBL_END(vp->v_mount);
633d65f6f70SBen Gras }
634d65f6f70SBen Gras VN_KNOTE(vp, NOTE_ATTRIB);
635d65f6f70SBen Gras out:
636d65f6f70SBen Gras fstrans_done(vp->v_mount);
637d65f6f70SBen Gras return (error);
638d65f6f70SBen Gras }
639d65f6f70SBen Gras
640d65f6f70SBen Gras /*
641d65f6f70SBen Gras * Change the mode on a file.
642d65f6f70SBen Gras * Inode must be locked before calling.
643d65f6f70SBen Gras */
644d65f6f70SBen Gras static int
ufs_chmod(struct vnode * vp,int mode,kauth_cred_t cred,struct lwp * l)645d65f6f70SBen Gras ufs_chmod(struct vnode *vp, int mode, kauth_cred_t cred, struct lwp *l)
646d65f6f70SBen Gras {
647d65f6f70SBen Gras struct inode *ip;
648d65f6f70SBen Gras int error;
649d65f6f70SBen Gras
650d65f6f70SBen Gras UFS_WAPBL_JLOCK_ASSERT(vp->v_mount);
651d65f6f70SBen Gras
652d65f6f70SBen Gras ip = VTOI(vp);
653d65f6f70SBen Gras
65484d9c625SLionel Sambuc error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY, vp,
65584d9c625SLionel Sambuc NULL, genfs_can_chmod(vp->v_type, cred, ip->i_uid, ip->i_gid, mode));
656d65f6f70SBen Gras if (error)
657d65f6f70SBen Gras return (error);
658d65f6f70SBen Gras
659d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
660d65f6f70SBen Gras ip->i_mode &= ~ALLPERMS;
661d65f6f70SBen Gras ip->i_mode |= (mode & ALLPERMS);
662d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
663d65f6f70SBen Gras DIP_ASSIGN(ip, mode, ip->i_mode);
664d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, 0);
665d65f6f70SBen Gras fstrans_done(vp->v_mount);
666d65f6f70SBen Gras return (0);
667d65f6f70SBen Gras }
668d65f6f70SBen Gras
669d65f6f70SBen Gras /*
670d65f6f70SBen Gras * Perform chown operation on inode ip;
671d65f6f70SBen Gras * inode must be locked prior to call.
672d65f6f70SBen Gras */
673d65f6f70SBen Gras static int
ufs_chown(struct vnode * vp,uid_t uid,gid_t gid,kauth_cred_t cred,struct lwp * l)674d65f6f70SBen Gras ufs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred,
675d65f6f70SBen Gras struct lwp *l)
676d65f6f70SBen Gras {
677d65f6f70SBen Gras struct inode *ip;
678d65f6f70SBen Gras int error = 0;
679d65f6f70SBen Gras #if defined(QUOTA) || defined(QUOTA2)
680d65f6f70SBen Gras uid_t ouid;
681d65f6f70SBen Gras gid_t ogid;
682d65f6f70SBen Gras int64_t change;
683d65f6f70SBen Gras #endif
684d65f6f70SBen Gras ip = VTOI(vp);
685d65f6f70SBen Gras error = 0;
686d65f6f70SBen Gras
687d65f6f70SBen Gras if (uid == (uid_t)VNOVAL)
688d65f6f70SBen Gras uid = ip->i_uid;
689d65f6f70SBen Gras if (gid == (gid_t)VNOVAL)
690d65f6f70SBen Gras gid = ip->i_gid;
691d65f6f70SBen Gras
69284d9c625SLionel Sambuc error = kauth_authorize_vnode(cred, KAUTH_VNODE_CHANGE_OWNERSHIP, vp,
69384d9c625SLionel Sambuc NULL, genfs_can_chown(cred, ip->i_uid, ip->i_gid, uid, gid));
694d65f6f70SBen Gras if (error)
695d65f6f70SBen Gras return (error);
696d65f6f70SBen Gras
697d65f6f70SBen Gras fstrans_start(vp->v_mount, FSTRANS_SHARED);
698d65f6f70SBen Gras #if defined(QUOTA) || defined(QUOTA2)
699d65f6f70SBen Gras ogid = ip->i_gid;
700d65f6f70SBen Gras ouid = ip->i_uid;
701d65f6f70SBen Gras change = DIP(ip, blocks);
702d65f6f70SBen Gras (void) chkdq(ip, -change, cred, 0);
703d65f6f70SBen Gras (void) chkiq(ip, -1, cred, 0);
704d65f6f70SBen Gras #endif
705d65f6f70SBen Gras ip->i_gid = gid;
706d65f6f70SBen Gras DIP_ASSIGN(ip, gid, gid);
707d65f6f70SBen Gras ip->i_uid = uid;
708d65f6f70SBen Gras DIP_ASSIGN(ip, uid, uid);
709d65f6f70SBen Gras #if defined(QUOTA) || defined(QUOTA2)
710d65f6f70SBen Gras if ((error = chkdq(ip, change, cred, 0)) == 0) {
711d65f6f70SBen Gras if ((error = chkiq(ip, 1, cred, 0)) == 0)
712d65f6f70SBen Gras goto good;
713d65f6f70SBen Gras else
714d65f6f70SBen Gras (void) chkdq(ip, -change, cred, FORCE);
715d65f6f70SBen Gras }
716d65f6f70SBen Gras ip->i_gid = ogid;
717d65f6f70SBen Gras DIP_ASSIGN(ip, gid, ogid);
718d65f6f70SBen Gras ip->i_uid = ouid;
719d65f6f70SBen Gras DIP_ASSIGN(ip, uid, ouid);
720d65f6f70SBen Gras (void) chkdq(ip, change, cred, FORCE);
721d65f6f70SBen Gras (void) chkiq(ip, 1, cred, FORCE);
722d65f6f70SBen Gras fstrans_done(vp->v_mount);
723d65f6f70SBen Gras return (error);
724d65f6f70SBen Gras good:
725d65f6f70SBen Gras #endif /* QUOTA || QUOTA2 */
726d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
727d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, 0);
728d65f6f70SBen Gras fstrans_done(vp->v_mount);
729d65f6f70SBen Gras return (0);
730d65f6f70SBen Gras }
731d65f6f70SBen Gras
732d65f6f70SBen Gras int
ufs_remove(void * v)733d65f6f70SBen Gras ufs_remove(void *v)
734d65f6f70SBen Gras {
735d65f6f70SBen Gras struct vop_remove_args /* {
736d65f6f70SBen Gras struct vnode *a_dvp;
737d65f6f70SBen Gras struct vnode *a_vp;
738d65f6f70SBen Gras struct componentname *a_cnp;
739d65f6f70SBen Gras } */ *ap = v;
740d65f6f70SBen Gras struct vnode *vp, *dvp;
741d65f6f70SBen Gras struct inode *ip;
742*0a6a1f1dSLionel Sambuc struct mount *mp;
743d65f6f70SBen Gras int error;
744d65f6f70SBen Gras struct ufs_lookup_results *ulr;
745d65f6f70SBen Gras
746d65f6f70SBen Gras vp = ap->a_vp;
747d65f6f70SBen Gras dvp = ap->a_dvp;
748d65f6f70SBen Gras ip = VTOI(vp);
749*0a6a1f1dSLionel Sambuc mp = dvp->v_mount;
750*0a6a1f1dSLionel Sambuc KASSERT(mp == vp->v_mount); /* XXX Not stable without lock. */
751d65f6f70SBen Gras
752d65f6f70SBen Gras /* XXX should handle this material another way */
753d65f6f70SBen Gras ulr = &VTOI(dvp)->i_crap;
754d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(dvp));
755d65f6f70SBen Gras
756*0a6a1f1dSLionel Sambuc fstrans_start(mp, FSTRANS_SHARED);
757d65f6f70SBen Gras if (vp->v_type == VDIR || (ip->i_flags & (IMMUTABLE | APPEND)) ||
758d65f6f70SBen Gras (VTOI(dvp)->i_flags & APPEND))
759d65f6f70SBen Gras error = EPERM;
760d65f6f70SBen Gras else {
761*0a6a1f1dSLionel Sambuc error = UFS_WAPBL_BEGIN(mp);
762d65f6f70SBen Gras if (error == 0) {
763d65f6f70SBen Gras error = ufs_dirremove(dvp, ulr,
764d65f6f70SBen Gras ip, ap->a_cnp->cn_flags, 0);
765*0a6a1f1dSLionel Sambuc UFS_WAPBL_END(mp);
766d65f6f70SBen Gras }
767d65f6f70SBen Gras }
768d65f6f70SBen Gras VN_KNOTE(vp, NOTE_DELETE);
769d65f6f70SBen Gras VN_KNOTE(dvp, NOTE_WRITE);
770d65f6f70SBen Gras if (dvp == vp)
771d65f6f70SBen Gras vrele(vp);
772d65f6f70SBen Gras else
773d65f6f70SBen Gras vput(vp);
774d65f6f70SBen Gras vput(dvp);
775*0a6a1f1dSLionel Sambuc fstrans_done(mp);
776d65f6f70SBen Gras return (error);
777d65f6f70SBen Gras }
778d65f6f70SBen Gras
779d65f6f70SBen Gras /*
780d65f6f70SBen Gras * ufs_link: create hard link.
781d65f6f70SBen Gras */
782d65f6f70SBen Gras int
ufs_link(void * v)783d65f6f70SBen Gras ufs_link(void *v)
784d65f6f70SBen Gras {
785*0a6a1f1dSLionel Sambuc struct vop_link_v2_args /* {
786d65f6f70SBen Gras struct vnode *a_dvp;
787d65f6f70SBen Gras struct vnode *a_vp;
788d65f6f70SBen Gras struct componentname *a_cnp;
789d65f6f70SBen Gras } */ *ap = v;
790d65f6f70SBen Gras struct vnode *dvp = ap->a_dvp;
791d65f6f70SBen Gras struct vnode *vp = ap->a_vp;
792d65f6f70SBen Gras struct componentname *cnp = ap->a_cnp;
793*0a6a1f1dSLionel Sambuc struct mount *mp = dvp->v_mount;
794d65f6f70SBen Gras struct inode *ip;
795d65f6f70SBen Gras struct direct *newdir;
796d65f6f70SBen Gras int error;
797d65f6f70SBen Gras struct ufs_lookup_results *ulr;
798d65f6f70SBen Gras
799d65f6f70SBen Gras KASSERT(dvp != vp);
800d65f6f70SBen Gras KASSERT(vp->v_type != VDIR);
801*0a6a1f1dSLionel Sambuc KASSERT(mp == vp->v_mount); /* XXX Not stable without lock. */
802d65f6f70SBen Gras
803d65f6f70SBen Gras /* XXX should handle this material another way */
804d65f6f70SBen Gras ulr = &VTOI(dvp)->i_crap;
805d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(dvp));
806d65f6f70SBen Gras
807*0a6a1f1dSLionel Sambuc fstrans_start(mp, FSTRANS_SHARED);
808d65f6f70SBen Gras error = vn_lock(vp, LK_EXCLUSIVE);
809d65f6f70SBen Gras if (error) {
810d65f6f70SBen Gras VOP_ABORTOP(dvp, cnp);
811d65f6f70SBen Gras goto out2;
812d65f6f70SBen Gras }
813d65f6f70SBen Gras ip = VTOI(vp);
814d65f6f70SBen Gras if ((nlink_t)ip->i_nlink >= LINK_MAX) {
815d65f6f70SBen Gras VOP_ABORTOP(dvp, cnp);
816d65f6f70SBen Gras error = EMLINK;
817d65f6f70SBen Gras goto out1;
818d65f6f70SBen Gras }
819d65f6f70SBen Gras if (ip->i_flags & (IMMUTABLE | APPEND)) {
820d65f6f70SBen Gras VOP_ABORTOP(dvp, cnp);
821d65f6f70SBen Gras error = EPERM;
822d65f6f70SBen Gras goto out1;
823d65f6f70SBen Gras }
824*0a6a1f1dSLionel Sambuc error = UFS_WAPBL_BEGIN(mp);
825d65f6f70SBen Gras if (error) {
826d65f6f70SBen Gras VOP_ABORTOP(dvp, cnp);
827d65f6f70SBen Gras goto out1;
828d65f6f70SBen Gras }
829d65f6f70SBen Gras ip->i_nlink++;
830d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, ip->i_nlink);
831d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
832d65f6f70SBen Gras error = UFS_UPDATE(vp, NULL, NULL, UPDATE_DIROP);
833d65f6f70SBen Gras if (!error) {
834d65f6f70SBen Gras newdir = pool_cache_get(ufs_direct_cache, PR_WAITOK);
835d65f6f70SBen Gras ufs_makedirentry(ip, cnp, newdir);
836d65f6f70SBen Gras error = ufs_direnter(dvp, ulr, vp, newdir, cnp, NULL);
837d65f6f70SBen Gras pool_cache_put(ufs_direct_cache, newdir);
838d65f6f70SBen Gras }
839d65f6f70SBen Gras if (error) {
840d65f6f70SBen Gras ip->i_nlink--;
841d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, ip->i_nlink);
842d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
843d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, UPDATE_DIROP);
844d65f6f70SBen Gras }
845*0a6a1f1dSLionel Sambuc UFS_WAPBL_END(mp);
846d65f6f70SBen Gras out1:
847d65f6f70SBen Gras VOP_UNLOCK(vp);
848d65f6f70SBen Gras out2:
849d65f6f70SBen Gras VN_KNOTE(vp, NOTE_LINK);
850d65f6f70SBen Gras VN_KNOTE(dvp, NOTE_WRITE);
851*0a6a1f1dSLionel Sambuc fstrans_done(mp);
852d65f6f70SBen Gras return (error);
853d65f6f70SBen Gras }
854d65f6f70SBen Gras
855d65f6f70SBen Gras /*
856d65f6f70SBen Gras * whiteout vnode call
857d65f6f70SBen Gras */
858d65f6f70SBen Gras int
ufs_whiteout(void * v)859d65f6f70SBen Gras ufs_whiteout(void *v)
860d65f6f70SBen Gras {
861d65f6f70SBen Gras struct vop_whiteout_args /* {
862d65f6f70SBen Gras struct vnode *a_dvp;
863d65f6f70SBen Gras struct componentname *a_cnp;
864d65f6f70SBen Gras int a_flags;
865d65f6f70SBen Gras } */ *ap = v;
866d65f6f70SBen Gras struct vnode *dvp = ap->a_dvp;
867d65f6f70SBen Gras struct componentname *cnp = ap->a_cnp;
868d65f6f70SBen Gras struct direct *newdir;
869d65f6f70SBen Gras int error;
870d65f6f70SBen Gras struct ufsmount *ump = VFSTOUFS(dvp->v_mount);
871d65f6f70SBen Gras struct ufs_lookup_results *ulr;
872d65f6f70SBen Gras
873d65f6f70SBen Gras /* XXX should handle this material another way */
874d65f6f70SBen Gras ulr = &VTOI(dvp)->i_crap;
875d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(dvp));
876d65f6f70SBen Gras
877d65f6f70SBen Gras error = 0;
878d65f6f70SBen Gras switch (ap->a_flags) {
879d65f6f70SBen Gras case LOOKUP:
880d65f6f70SBen Gras /* 4.4 format directories support whiteout operations */
881d65f6f70SBen Gras if (ump->um_maxsymlinklen > 0)
882d65f6f70SBen Gras return (0);
883d65f6f70SBen Gras return (EOPNOTSUPP);
884d65f6f70SBen Gras
885d65f6f70SBen Gras case CREATE:
886d65f6f70SBen Gras /* create a new directory whiteout */
887d65f6f70SBen Gras fstrans_start(dvp->v_mount, FSTRANS_SHARED);
888d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(dvp->v_mount);
889d65f6f70SBen Gras if (error)
890d65f6f70SBen Gras break;
891d65f6f70SBen Gras #ifdef DIAGNOSTIC
892d65f6f70SBen Gras if (ump->um_maxsymlinklen <= 0)
893d65f6f70SBen Gras panic("ufs_whiteout: old format filesystem");
894d65f6f70SBen Gras #endif
895d65f6f70SBen Gras
896d65f6f70SBen Gras newdir = pool_cache_get(ufs_direct_cache, PR_WAITOK);
89784d9c625SLionel Sambuc newdir->d_ino = UFS_WINO;
898d65f6f70SBen Gras newdir->d_namlen = cnp->cn_namelen;
899d65f6f70SBen Gras memcpy(newdir->d_name, cnp->cn_nameptr,
900d65f6f70SBen Gras (size_t)cnp->cn_namelen);
901d65f6f70SBen Gras newdir->d_name[cnp->cn_namelen] = '\0';
902d65f6f70SBen Gras newdir->d_type = DT_WHT;
903d65f6f70SBen Gras error = ufs_direnter(dvp, ulr, NULL, newdir, cnp, NULL);
904d65f6f70SBen Gras pool_cache_put(ufs_direct_cache, newdir);
905d65f6f70SBen Gras break;
906d65f6f70SBen Gras
907d65f6f70SBen Gras case DELETE:
908d65f6f70SBen Gras /* remove an existing directory whiteout */
909d65f6f70SBen Gras fstrans_start(dvp->v_mount, FSTRANS_SHARED);
910d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(dvp->v_mount);
911d65f6f70SBen Gras if (error)
912d65f6f70SBen Gras break;
913d65f6f70SBen Gras #ifdef DIAGNOSTIC
914d65f6f70SBen Gras if (ump->um_maxsymlinklen <= 0)
915d65f6f70SBen Gras panic("ufs_whiteout: old format filesystem");
916d65f6f70SBen Gras #endif
917d65f6f70SBen Gras
918d65f6f70SBen Gras cnp->cn_flags &= ~DOWHITEOUT;
919d65f6f70SBen Gras error = ufs_dirremove(dvp, ulr, NULL, cnp->cn_flags, 0);
920d65f6f70SBen Gras break;
921d65f6f70SBen Gras default:
922d65f6f70SBen Gras panic("ufs_whiteout: unknown op");
923d65f6f70SBen Gras /* NOTREACHED */
924d65f6f70SBen Gras }
925d65f6f70SBen Gras UFS_WAPBL_END(dvp->v_mount);
926d65f6f70SBen Gras fstrans_done(dvp->v_mount);
927d65f6f70SBen Gras return (error);
928d65f6f70SBen Gras }
929d65f6f70SBen Gras
930d65f6f70SBen Gras int
ufs_mkdir(void * v)931d65f6f70SBen Gras ufs_mkdir(void *v)
932d65f6f70SBen Gras {
933*0a6a1f1dSLionel Sambuc struct vop_mkdir_v3_args /* {
934d65f6f70SBen Gras struct vnode *a_dvp;
935d65f6f70SBen Gras struct vnode **a_vpp;
936d65f6f70SBen Gras struct componentname *a_cnp;
937d65f6f70SBen Gras struct vattr *a_vap;
938d65f6f70SBen Gras } */ *ap = v;
939d65f6f70SBen Gras struct vnode *dvp = ap->a_dvp, *tvp;
940d65f6f70SBen Gras struct vattr *vap = ap->a_vap;
941d65f6f70SBen Gras struct componentname *cnp = ap->a_cnp;
942d65f6f70SBen Gras struct inode *ip, *dp = VTOI(dvp);
943d65f6f70SBen Gras struct buf *bp;
944d65f6f70SBen Gras struct dirtemplate dirtemplate;
945d65f6f70SBen Gras struct direct *newdir;
946*0a6a1f1dSLionel Sambuc int error;
947d65f6f70SBen Gras struct ufsmount *ump = dp->i_ump;
948d65f6f70SBen Gras int dirblksiz = ump->um_dirblksiz;
949d65f6f70SBen Gras struct ufs_lookup_results *ulr;
950d65f6f70SBen Gras
951d65f6f70SBen Gras fstrans_start(dvp->v_mount, FSTRANS_SHARED);
952d65f6f70SBen Gras
953d65f6f70SBen Gras /* XXX should handle this material another way */
954d65f6f70SBen Gras ulr = &dp->i_crap;
955d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(dp);
956d65f6f70SBen Gras
957*0a6a1f1dSLionel Sambuc KASSERT(vap->va_type == VDIR);
958*0a6a1f1dSLionel Sambuc
959d65f6f70SBen Gras if ((nlink_t)dp->i_nlink >= LINK_MAX) {
960d65f6f70SBen Gras error = EMLINK;
961d65f6f70SBen Gras goto out;
962d65f6f70SBen Gras }
963d65f6f70SBen Gras /*
964d65f6f70SBen Gras * Must simulate part of ufs_makeinode here to acquire the inode,
965d65f6f70SBen Gras * but not have it entered in the parent directory. The entry is
966d65f6f70SBen Gras * made later after writing "." and ".." entries.
967d65f6f70SBen Gras */
968*0a6a1f1dSLionel Sambuc error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, ap->a_vpp);
969*0a6a1f1dSLionel Sambuc if (error)
970d65f6f70SBen Gras goto out;
971*0a6a1f1dSLionel Sambuc error = vn_lock(*ap->a_vpp, LK_EXCLUSIVE);
972*0a6a1f1dSLionel Sambuc if (error) {
973*0a6a1f1dSLionel Sambuc vrele(*ap->a_vpp);
974*0a6a1f1dSLionel Sambuc *ap->a_vpp = NULL;
975*0a6a1f1dSLionel Sambuc goto out;
976*0a6a1f1dSLionel Sambuc }
977*0a6a1f1dSLionel Sambuc error = UFS_WAPBL_BEGIN(ap->a_dvp->v_mount);
978*0a6a1f1dSLionel Sambuc if (error) {
979*0a6a1f1dSLionel Sambuc vput(*ap->a_vpp);
980*0a6a1f1dSLionel Sambuc goto out;
981*0a6a1f1dSLionel Sambuc }
982d65f6f70SBen Gras
983d65f6f70SBen Gras tvp = *ap->a_vpp;
984d65f6f70SBen Gras ip = VTOI(tvp);
985d65f6f70SBen Gras ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
986d65f6f70SBen Gras ip->i_nlink = 2;
987d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, 2);
988d65f6f70SBen Gras if (cnp->cn_flags & ISWHITEOUT) {
989d65f6f70SBen Gras ip->i_flags |= UF_OPAQUE;
990d65f6f70SBen Gras DIP_ASSIGN(ip, flags, ip->i_flags);
991d65f6f70SBen Gras }
992d65f6f70SBen Gras
993d65f6f70SBen Gras /*
994d65f6f70SBen Gras * Bump link count in parent directory to reflect work done below.
995d65f6f70SBen Gras * Should be done before reference is created so cleanup is
996d65f6f70SBen Gras * possible if we crash.
997d65f6f70SBen Gras */
998d65f6f70SBen Gras dp->i_nlink++;
999d65f6f70SBen Gras DIP_ASSIGN(dp, nlink, dp->i_nlink);
1000d65f6f70SBen Gras dp->i_flag |= IN_CHANGE;
1001d65f6f70SBen Gras if ((error = UFS_UPDATE(dvp, NULL, NULL, UPDATE_DIROP)) != 0)
1002d65f6f70SBen Gras goto bad;
1003d65f6f70SBen Gras
1004d65f6f70SBen Gras /*
1005d65f6f70SBen Gras * Initialize directory with "." and ".." from static template.
1006d65f6f70SBen Gras */
1007d65f6f70SBen Gras dirtemplate = mastertemplate;
1008d65f6f70SBen Gras dirtemplate.dotdot_reclen = dirblksiz - dirtemplate.dot_reclen;
1009d65f6f70SBen Gras dirtemplate.dot_ino = ufs_rw32(ip->i_number, UFS_MPNEEDSWAP(ump));
1010d65f6f70SBen Gras dirtemplate.dotdot_ino = ufs_rw32(dp->i_number, UFS_MPNEEDSWAP(ump));
1011d65f6f70SBen Gras dirtemplate.dot_reclen = ufs_rw16(dirtemplate.dot_reclen,
1012d65f6f70SBen Gras UFS_MPNEEDSWAP(ump));
1013d65f6f70SBen Gras dirtemplate.dotdot_reclen = ufs_rw16(dirtemplate.dotdot_reclen,
1014d65f6f70SBen Gras UFS_MPNEEDSWAP(ump));
1015d65f6f70SBen Gras if (ump->um_maxsymlinklen <= 0) {
1016d65f6f70SBen Gras #if BYTE_ORDER == LITTLE_ENDIAN
1017d65f6f70SBen Gras if (UFS_MPNEEDSWAP(ump) == 0)
1018d65f6f70SBen Gras #else
1019d65f6f70SBen Gras if (UFS_MPNEEDSWAP(ump) != 0)
1020d65f6f70SBen Gras #endif
1021d65f6f70SBen Gras {
1022d65f6f70SBen Gras dirtemplate.dot_type = dirtemplate.dot_namlen;
1023d65f6f70SBen Gras dirtemplate.dotdot_type = dirtemplate.dotdot_namlen;
1024d65f6f70SBen Gras dirtemplate.dot_namlen = dirtemplate.dotdot_namlen = 0;
1025d65f6f70SBen Gras } else
1026d65f6f70SBen Gras dirtemplate.dot_type = dirtemplate.dotdot_type = 0;
1027d65f6f70SBen Gras }
1028d65f6f70SBen Gras if ((error = UFS_BALLOC(tvp, (off_t)0, dirblksiz, cnp->cn_cred,
1029d65f6f70SBen Gras B_CLRBUF, &bp)) != 0)
1030d65f6f70SBen Gras goto bad;
1031d65f6f70SBen Gras ip->i_size = dirblksiz;
1032d65f6f70SBen Gras DIP_ASSIGN(ip, size, dirblksiz);
1033d65f6f70SBen Gras ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1034d65f6f70SBen Gras uvm_vnp_setsize(tvp, ip->i_size);
1035d65f6f70SBen Gras memcpy((void *)bp->b_data, (void *)&dirtemplate, sizeof dirtemplate);
1036d65f6f70SBen Gras
1037d65f6f70SBen Gras /*
1038*0a6a1f1dSLionel Sambuc * Directory set up, now install its entry in the parent directory.
1039d65f6f70SBen Gras * We must write out the buffer containing the new directory body
1040d65f6f70SBen Gras * before entering the new name in the parent.
1041d65f6f70SBen Gras */
1042d65f6f70SBen Gras if ((error = VOP_BWRITE(bp->b_vp, bp)) != 0)
1043d65f6f70SBen Gras goto bad;
1044d65f6f70SBen Gras if ((error = UFS_UPDATE(tvp, NULL, NULL, UPDATE_DIROP)) != 0) {
1045d65f6f70SBen Gras goto bad;
1046d65f6f70SBen Gras }
1047d65f6f70SBen Gras newdir = pool_cache_get(ufs_direct_cache, PR_WAITOK);
1048d65f6f70SBen Gras ufs_makedirentry(ip, cnp, newdir);
1049d65f6f70SBen Gras error = ufs_direnter(dvp, ulr, tvp, newdir, cnp, bp);
1050d65f6f70SBen Gras pool_cache_put(ufs_direct_cache, newdir);
1051d65f6f70SBen Gras bad:
1052d65f6f70SBen Gras if (error == 0) {
1053d65f6f70SBen Gras VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1054*0a6a1f1dSLionel Sambuc VOP_UNLOCK(tvp);
1055d65f6f70SBen Gras UFS_WAPBL_END(dvp->v_mount);
1056d65f6f70SBen Gras } else {
1057d65f6f70SBen Gras dp->i_nlink--;
1058d65f6f70SBen Gras DIP_ASSIGN(dp, nlink, dp->i_nlink);
1059d65f6f70SBen Gras dp->i_flag |= IN_CHANGE;
1060d65f6f70SBen Gras UFS_WAPBL_UPDATE(dvp, NULL, NULL, UPDATE_DIROP);
1061d65f6f70SBen Gras /*
1062d65f6f70SBen Gras * No need to do an explicit UFS_TRUNCATE here, vrele will
1063d65f6f70SBen Gras * do this for us because we set the link count to 0.
1064d65f6f70SBen Gras */
1065d65f6f70SBen Gras ip->i_nlink = 0;
1066d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, 0);
1067d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
1068d65f6f70SBen Gras UFS_WAPBL_UPDATE(tvp, NULL, NULL, UPDATE_DIROP);
1069d65f6f70SBen Gras UFS_WAPBL_END(dvp->v_mount);
1070d65f6f70SBen Gras vput(tvp);
1071d65f6f70SBen Gras }
1072d65f6f70SBen Gras out:
1073d65f6f70SBen Gras fstrans_done(dvp->v_mount);
1074d65f6f70SBen Gras return (error);
1075d65f6f70SBen Gras }
1076d65f6f70SBen Gras
1077d65f6f70SBen Gras int
ufs_rmdir(void * v)1078d65f6f70SBen Gras ufs_rmdir(void *v)
1079d65f6f70SBen Gras {
1080d65f6f70SBen Gras struct vop_rmdir_args /* {
1081d65f6f70SBen Gras struct vnode *a_dvp;
1082d65f6f70SBen Gras struct vnode *a_vp;
1083d65f6f70SBen Gras struct componentname *a_cnp;
1084d65f6f70SBen Gras } */ *ap = v;
1085d65f6f70SBen Gras struct vnode *vp, *dvp;
1086d65f6f70SBen Gras struct componentname *cnp;
1087d65f6f70SBen Gras struct inode *ip, *dp;
1088d65f6f70SBen Gras int error;
1089d65f6f70SBen Gras struct ufs_lookup_results *ulr;
1090d65f6f70SBen Gras
1091d65f6f70SBen Gras vp = ap->a_vp;
1092d65f6f70SBen Gras dvp = ap->a_dvp;
1093d65f6f70SBen Gras cnp = ap->a_cnp;
1094d65f6f70SBen Gras ip = VTOI(vp);
1095d65f6f70SBen Gras dp = VTOI(dvp);
1096d65f6f70SBen Gras
1097d65f6f70SBen Gras /* XXX should handle this material another way */
1098d65f6f70SBen Gras ulr = &dp->i_crap;
1099d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(dp);
1100d65f6f70SBen Gras
1101d65f6f70SBen Gras /*
1102d65f6f70SBen Gras * No rmdir "." or of mounted directories please.
1103d65f6f70SBen Gras */
1104d65f6f70SBen Gras if (dp == ip || vp->v_mountedhere != NULL) {
1105d65f6f70SBen Gras if (dp == ip)
1106d65f6f70SBen Gras vrele(dvp);
1107d65f6f70SBen Gras else
1108d65f6f70SBen Gras vput(dvp);
1109d65f6f70SBen Gras vput(vp);
1110d65f6f70SBen Gras return (EINVAL);
1111d65f6f70SBen Gras }
1112d65f6f70SBen Gras
1113d65f6f70SBen Gras fstrans_start(dvp->v_mount, FSTRANS_SHARED);
1114d65f6f70SBen Gras
1115d65f6f70SBen Gras /*
1116d65f6f70SBen Gras * Do not remove a directory that is in the process of being renamed.
1117d65f6f70SBen Gras * Verify that the directory is empty (and valid). (Rmdir ".." won't
1118d65f6f70SBen Gras * be valid since ".." will contain a reference to the current
1119d65f6f70SBen Gras * directory and thus be non-empty.)
1120d65f6f70SBen Gras */
1121d65f6f70SBen Gras error = 0;
1122d65f6f70SBen Gras if (ip->i_nlink != 2 ||
1123d65f6f70SBen Gras !ufs_dirempty(ip, dp->i_number, cnp->cn_cred)) {
1124d65f6f70SBen Gras error = ENOTEMPTY;
1125d65f6f70SBen Gras goto out;
1126d65f6f70SBen Gras }
1127d65f6f70SBen Gras if ((dp->i_flags & APPEND) ||
1128d65f6f70SBen Gras (ip->i_flags & (IMMUTABLE | APPEND))) {
1129d65f6f70SBen Gras error = EPERM;
1130d65f6f70SBen Gras goto out;
1131d65f6f70SBen Gras }
1132d65f6f70SBen Gras error = UFS_WAPBL_BEGIN(dvp->v_mount);
1133d65f6f70SBen Gras if (error)
1134d65f6f70SBen Gras goto out;
1135d65f6f70SBen Gras /*
1136d65f6f70SBen Gras * Delete reference to directory before purging
1137d65f6f70SBen Gras * inode. If we crash in between, the directory
1138d65f6f70SBen Gras * will be reattached to lost+found,
1139d65f6f70SBen Gras */
1140d65f6f70SBen Gras error = ufs_dirremove(dvp, ulr, ip, cnp->cn_flags, 1);
1141d65f6f70SBen Gras if (error) {
1142d65f6f70SBen Gras UFS_WAPBL_END(dvp->v_mount);
1143d65f6f70SBen Gras goto out;
1144d65f6f70SBen Gras }
1145d65f6f70SBen Gras VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1146d65f6f70SBen Gras cache_purge(dvp);
1147d65f6f70SBen Gras /*
1148d65f6f70SBen Gras * Truncate inode. The only stuff left in the directory is "." and
1149d65f6f70SBen Gras * "..". The "." reference is inconsequential since we're quashing
1150d65f6f70SBen Gras * it.
1151d65f6f70SBen Gras */
1152d65f6f70SBen Gras dp->i_nlink--;
1153d65f6f70SBen Gras DIP_ASSIGN(dp, nlink, dp->i_nlink);
1154d65f6f70SBen Gras dp->i_flag |= IN_CHANGE;
1155d65f6f70SBen Gras UFS_WAPBL_UPDATE(dvp, NULL, NULL, UPDATE_DIROP);
1156d65f6f70SBen Gras ip->i_nlink--;
1157d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, ip->i_nlink);
1158d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
1159d65f6f70SBen Gras error = UFS_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred);
1160d65f6f70SBen Gras cache_purge(vp);
1161d65f6f70SBen Gras /*
1162d65f6f70SBen Gras * Unlock the log while we still have reference to unlinked
1163d65f6f70SBen Gras * directory vp so that it will not get locked for recycling
1164d65f6f70SBen Gras */
1165d65f6f70SBen Gras UFS_WAPBL_END(dvp->v_mount);
1166d65f6f70SBen Gras #ifdef UFS_DIRHASH
1167d65f6f70SBen Gras if (ip->i_dirhash != NULL)
1168d65f6f70SBen Gras ufsdirhash_free(ip);
1169d65f6f70SBen Gras #endif
1170d65f6f70SBen Gras out:
1171d65f6f70SBen Gras VN_KNOTE(vp, NOTE_DELETE);
1172d65f6f70SBen Gras vput(vp);
1173d65f6f70SBen Gras fstrans_done(dvp->v_mount);
1174d65f6f70SBen Gras vput(dvp);
1175d65f6f70SBen Gras return (error);
1176d65f6f70SBen Gras }
1177d65f6f70SBen Gras
1178d65f6f70SBen Gras /*
1179d65f6f70SBen Gras * symlink -- make a symbolic link
1180d65f6f70SBen Gras */
1181d65f6f70SBen Gras int
ufs_symlink(void * v)1182d65f6f70SBen Gras ufs_symlink(void *v)
1183d65f6f70SBen Gras {
1184*0a6a1f1dSLionel Sambuc struct vop_symlink_v3_args /* {
1185d65f6f70SBen Gras struct vnode *a_dvp;
1186d65f6f70SBen Gras struct vnode **a_vpp;
1187d65f6f70SBen Gras struct componentname *a_cnp;
1188d65f6f70SBen Gras struct vattr *a_vap;
1189d65f6f70SBen Gras char *a_target;
1190d65f6f70SBen Gras } */ *ap = v;
1191d65f6f70SBen Gras struct vnode *vp, **vpp;
1192d65f6f70SBen Gras struct inode *ip;
1193d65f6f70SBen Gras int len, error;
1194d65f6f70SBen Gras struct ufs_lookup_results *ulr;
1195d65f6f70SBen Gras
1196d65f6f70SBen Gras vpp = ap->a_vpp;
1197d65f6f70SBen Gras
1198d65f6f70SBen Gras /* XXX should handle this material another way */
1199d65f6f70SBen Gras ulr = &VTOI(ap->a_dvp)->i_crap;
1200d65f6f70SBen Gras UFS_CHECK_CRAPCOUNTER(VTOI(ap->a_dvp));
1201d65f6f70SBen Gras
1202d65f6f70SBen Gras /*
1203d65f6f70SBen Gras * UFS_WAPBL_BEGIN1(dvp->v_mount, dvp) performed by successful
1204d65f6f70SBen Gras * ufs_makeinode
1205d65f6f70SBen Gras */
1206d65f6f70SBen Gras fstrans_start(ap->a_dvp->v_mount, FSTRANS_SHARED);
1207*0a6a1f1dSLionel Sambuc KASSERT(ap->a_vap->va_type == VLNK);
1208*0a6a1f1dSLionel Sambuc error = ufs_makeinode(ap->a_vap, ap->a_dvp, ulr, vpp, ap->a_cnp);
1209d65f6f70SBen Gras if (error)
1210d65f6f70SBen Gras goto out;
1211d65f6f70SBen Gras VN_KNOTE(ap->a_dvp, NOTE_WRITE);
1212d65f6f70SBen Gras vp = *vpp;
1213d65f6f70SBen Gras len = strlen(ap->a_target);
1214d65f6f70SBen Gras ip = VTOI(vp);
121584d9c625SLionel Sambuc /*
121684d9c625SLionel Sambuc * This test is off by one. um_maxsymlinklen contains the
121784d9c625SLionel Sambuc * number of bytes available, and we aren't storing a \0, so
121884d9c625SLionel Sambuc * the test should properly be <=. However, it cannot be
121984d9c625SLionel Sambuc * changed as this would break compatibility with existing fs
122084d9c625SLionel Sambuc * images -- see the way ufs_readlink() works.
122184d9c625SLionel Sambuc */
1222d65f6f70SBen Gras if (len < ip->i_ump->um_maxsymlinklen) {
1223d65f6f70SBen Gras memcpy((char *)SHORTLINK(ip), ap->a_target, len);
1224d65f6f70SBen Gras ip->i_size = len;
1225d65f6f70SBen Gras DIP_ASSIGN(ip, size, len);
1226d65f6f70SBen Gras uvm_vnp_setsize(vp, ip->i_size);
1227d65f6f70SBen Gras ip->i_flag |= IN_CHANGE | IN_UPDATE;
1228d65f6f70SBen Gras if (vp->v_mount->mnt_flag & MNT_RELATIME)
1229d65f6f70SBen Gras ip->i_flag |= IN_ACCESS;
1230d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, 0);
1231d65f6f70SBen Gras } else
1232*0a6a1f1dSLionel Sambuc error = ufs_bufio(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
1233*0a6a1f1dSLionel Sambuc IO_NODELOCKED | IO_JOURNALLOCKED, ap->a_cnp->cn_cred, NULL,
1234*0a6a1f1dSLionel Sambuc NULL);
1235d65f6f70SBen Gras UFS_WAPBL_END1(ap->a_dvp->v_mount, ap->a_dvp);
1236*0a6a1f1dSLionel Sambuc VOP_UNLOCK(vp);
1237d65f6f70SBen Gras if (error)
1238*0a6a1f1dSLionel Sambuc vrele(vp);
1239d65f6f70SBen Gras out:
1240d65f6f70SBen Gras fstrans_done(ap->a_dvp->v_mount);
1241d65f6f70SBen Gras return (error);
1242d65f6f70SBen Gras }
1243d65f6f70SBen Gras
1244d65f6f70SBen Gras /*
1245d65f6f70SBen Gras * Vnode op for reading directories.
1246d65f6f70SBen Gras *
1247d65f6f70SBen Gras * This routine handles converting from the on-disk directory format
1248d65f6f70SBen Gras * "struct direct" to the in-memory format "struct dirent" as well as
1249d65f6f70SBen Gras * byte swapping the entries if necessary.
1250d65f6f70SBen Gras */
1251d65f6f70SBen Gras int
ufs_readdir(void * v)1252d65f6f70SBen Gras ufs_readdir(void *v)
1253d65f6f70SBen Gras {
1254d65f6f70SBen Gras struct vop_readdir_args /* {
1255d65f6f70SBen Gras struct vnode *a_vp;
1256d65f6f70SBen Gras struct uio *a_uio;
1257d65f6f70SBen Gras kauth_cred_t a_cred;
1258d65f6f70SBen Gras int *a_eofflag;
1259d65f6f70SBen Gras off_t **a_cookies;
1260d65f6f70SBen Gras int *ncookies;
1261d65f6f70SBen Gras } */ *ap = v;
1262d65f6f70SBen Gras struct vnode *vp = ap->a_vp;
1263d65f6f70SBen Gras struct direct *cdp, *ecdp;
1264d65f6f70SBen Gras struct dirent *ndp;
1265d65f6f70SBen Gras char *cdbuf, *ndbuf, *endp;
1266d65f6f70SBen Gras struct uio auio, *uio;
1267d65f6f70SBen Gras struct iovec aiov;
1268d65f6f70SBen Gras int error;
126984d9c625SLionel Sambuc size_t count, ccount, rcount, cdbufsz, ndbufsz;
1270d65f6f70SBen Gras off_t off, *ccp;
1271d65f6f70SBen Gras off_t startoff;
1272d65f6f70SBen Gras size_t skipbytes;
1273d65f6f70SBen Gras struct ufsmount *ump = VFSTOUFS(vp->v_mount);
1274d65f6f70SBen Gras int nswap = UFS_MPNEEDSWAP(ump);
1275d65f6f70SBen Gras #if BYTE_ORDER == LITTLE_ENDIAN
1276d65f6f70SBen Gras int needswap = ump->um_maxsymlinklen <= 0 && nswap == 0;
1277d65f6f70SBen Gras #else
1278d65f6f70SBen Gras int needswap = ump->um_maxsymlinklen <= 0 && nswap != 0;
1279d65f6f70SBen Gras #endif
1280d65f6f70SBen Gras uio = ap->a_uio;
1281d65f6f70SBen Gras count = uio->uio_resid;
1282d65f6f70SBen Gras rcount = count - ((uio->uio_offset + count) & (ump->um_dirblksiz - 1));
1283d65f6f70SBen Gras
1284d65f6f70SBen Gras if (rcount < _DIRENT_MINSIZE(cdp) || count < _DIRENT_MINSIZE(ndp))
1285d65f6f70SBen Gras return EINVAL;
1286d65f6f70SBen Gras
1287d65f6f70SBen Gras startoff = uio->uio_offset & ~(ump->um_dirblksiz - 1);
1288d65f6f70SBen Gras skipbytes = uio->uio_offset - startoff;
1289d65f6f70SBen Gras rcount += skipbytes;
1290d65f6f70SBen Gras
1291d65f6f70SBen Gras auio.uio_iov = &aiov;
1292d65f6f70SBen Gras auio.uio_iovcnt = 1;
1293d65f6f70SBen Gras auio.uio_offset = startoff;
1294d65f6f70SBen Gras auio.uio_resid = rcount;
1295d65f6f70SBen Gras UIO_SETUP_SYSSPACE(&auio);
1296d65f6f70SBen Gras auio.uio_rw = UIO_READ;
129784d9c625SLionel Sambuc cdbufsz = rcount;
129884d9c625SLionel Sambuc cdbuf = kmem_alloc(cdbufsz, KM_SLEEP);
1299d65f6f70SBen Gras aiov.iov_base = cdbuf;
1300d65f6f70SBen Gras aiov.iov_len = rcount;
1301*0a6a1f1dSLionel Sambuc error = UFS_BUFRD(vp, &auio, 0, ap->a_cred);
1302d65f6f70SBen Gras if (error != 0) {
130384d9c625SLionel Sambuc kmem_free(cdbuf, cdbufsz);
1304d65f6f70SBen Gras return error;
1305d65f6f70SBen Gras }
1306d65f6f70SBen Gras
1307d65f6f70SBen Gras rcount -= auio.uio_resid;
1308d65f6f70SBen Gras
1309d65f6f70SBen Gras cdp = (struct direct *)(void *)cdbuf;
1310d65f6f70SBen Gras ecdp = (struct direct *)(void *)&cdbuf[rcount];
1311d65f6f70SBen Gras
131284d9c625SLionel Sambuc ndbufsz = count;
131384d9c625SLionel Sambuc ndbuf = kmem_alloc(ndbufsz, KM_SLEEP);
1314d65f6f70SBen Gras ndp = (struct dirent *)(void *)ndbuf;
1315d65f6f70SBen Gras endp = &ndbuf[count];
1316d65f6f70SBen Gras
1317d65f6f70SBen Gras off = uio->uio_offset;
1318d65f6f70SBen Gras if (ap->a_cookies) {
1319d65f6f70SBen Gras ccount = rcount / _DIRENT_RECLEN(cdp, 1);
1320d65f6f70SBen Gras ccp = *(ap->a_cookies) = malloc(ccount * sizeof(*ccp),
1321d65f6f70SBen Gras M_TEMP, M_WAITOK);
1322d65f6f70SBen Gras } else {
1323d65f6f70SBen Gras /* XXX: GCC */
1324d65f6f70SBen Gras ccount = 0;
1325d65f6f70SBen Gras ccp = NULL;
1326d65f6f70SBen Gras }
1327d65f6f70SBen Gras
1328d65f6f70SBen Gras while (cdp < ecdp) {
1329d65f6f70SBen Gras cdp->d_reclen = ufs_rw16(cdp->d_reclen, nswap);
1330d65f6f70SBen Gras if (skipbytes > 0) {
1331d65f6f70SBen Gras if (cdp->d_reclen <= skipbytes) {
1332d65f6f70SBen Gras skipbytes -= cdp->d_reclen;
1333d65f6f70SBen Gras cdp = _DIRENT_NEXT(cdp);
1334d65f6f70SBen Gras continue;
1335d65f6f70SBen Gras }
1336d65f6f70SBen Gras /*
1337d65f6f70SBen Gras * invalid cookie.
1338d65f6f70SBen Gras */
1339d65f6f70SBen Gras error = EINVAL;
1340d65f6f70SBen Gras goto out;
1341d65f6f70SBen Gras }
1342d65f6f70SBen Gras if (cdp->d_reclen == 0) {
1343d65f6f70SBen Gras struct dirent *ondp = ndp;
1344d65f6f70SBen Gras ndp->d_reclen = _DIRENT_MINSIZE(ndp);
1345d65f6f70SBen Gras ndp = _DIRENT_NEXT(ndp);
1346d65f6f70SBen Gras ondp->d_reclen = 0;
1347d65f6f70SBen Gras cdp = ecdp;
1348d65f6f70SBen Gras break;
1349d65f6f70SBen Gras }
1350d65f6f70SBen Gras if (needswap) {
1351d65f6f70SBen Gras ndp->d_type = cdp->d_namlen;
1352d65f6f70SBen Gras ndp->d_namlen = cdp->d_type;
1353d65f6f70SBen Gras } else {
1354d65f6f70SBen Gras ndp->d_type = cdp->d_type;
1355d65f6f70SBen Gras ndp->d_namlen = cdp->d_namlen;
1356d65f6f70SBen Gras }
1357d65f6f70SBen Gras ndp->d_reclen = _DIRENT_RECLEN(ndp, ndp->d_namlen);
1358d65f6f70SBen Gras if ((char *)(void *)ndp + ndp->d_reclen +
1359d65f6f70SBen Gras _DIRENT_MINSIZE(ndp) > endp)
1360d65f6f70SBen Gras break;
1361d65f6f70SBen Gras ndp->d_fileno = ufs_rw32(cdp->d_ino, nswap);
1362d65f6f70SBen Gras (void)memcpy(ndp->d_name, cdp->d_name, ndp->d_namlen);
1363d65f6f70SBen Gras memset(&ndp->d_name[ndp->d_namlen], 0,
1364d65f6f70SBen Gras ndp->d_reclen - _DIRENT_NAMEOFF(ndp) - ndp->d_namlen);
1365d65f6f70SBen Gras off += cdp->d_reclen;
1366d65f6f70SBen Gras if (ap->a_cookies) {
1367d65f6f70SBen Gras KASSERT(ccp - *(ap->a_cookies) < ccount);
1368d65f6f70SBen Gras *(ccp++) = off;
1369d65f6f70SBen Gras }
1370d65f6f70SBen Gras ndp = _DIRENT_NEXT(ndp);
1371d65f6f70SBen Gras cdp = _DIRENT_NEXT(cdp);
1372d65f6f70SBen Gras }
1373d65f6f70SBen Gras
1374d65f6f70SBen Gras count = ((char *)(void *)ndp - ndbuf);
1375d65f6f70SBen Gras error = uiomove(ndbuf, count, uio);
1376d65f6f70SBen Gras out:
1377d65f6f70SBen Gras if (ap->a_cookies) {
1378d65f6f70SBen Gras if (error) {
1379d65f6f70SBen Gras free(*(ap->a_cookies), M_TEMP);
1380d65f6f70SBen Gras *(ap->a_cookies) = NULL;
1381d65f6f70SBen Gras *(ap->a_ncookies) = 0;
1382d65f6f70SBen Gras } else {
1383d65f6f70SBen Gras *ap->a_ncookies = ccp - *(ap->a_cookies);
1384d65f6f70SBen Gras }
1385d65f6f70SBen Gras }
1386d65f6f70SBen Gras uio->uio_offset = off;
138784d9c625SLionel Sambuc kmem_free(ndbuf, ndbufsz);
138884d9c625SLionel Sambuc kmem_free(cdbuf, cdbufsz);
1389d65f6f70SBen Gras *ap->a_eofflag = VTOI(vp)->i_size <= uio->uio_offset;
1390d65f6f70SBen Gras return error;
1391d65f6f70SBen Gras }
1392d65f6f70SBen Gras
1393d65f6f70SBen Gras /*
1394d65f6f70SBen Gras * Return target name of a symbolic link
1395d65f6f70SBen Gras */
1396d65f6f70SBen Gras int
ufs_readlink(void * v)1397d65f6f70SBen Gras ufs_readlink(void *v)
1398d65f6f70SBen Gras {
1399d65f6f70SBen Gras struct vop_readlink_args /* {
1400d65f6f70SBen Gras struct vnode *a_vp;
1401d65f6f70SBen Gras struct uio *a_uio;
1402d65f6f70SBen Gras kauth_cred_t a_cred;
1403d65f6f70SBen Gras } */ *ap = v;
1404d65f6f70SBen Gras struct vnode *vp = ap->a_vp;
1405d65f6f70SBen Gras struct inode *ip = VTOI(vp);
1406d65f6f70SBen Gras struct ufsmount *ump = VFSTOUFS(vp->v_mount);
1407d65f6f70SBen Gras int isize;
1408d65f6f70SBen Gras
140984d9c625SLionel Sambuc /*
141084d9c625SLionel Sambuc * The test against um_maxsymlinklen is off by one; it should
141184d9c625SLionel Sambuc * theoretically be <=, not <. However, it cannot be changed
141284d9c625SLionel Sambuc * as that would break compatibility with existing fs images.
141384d9c625SLionel Sambuc */
141484d9c625SLionel Sambuc
1415d65f6f70SBen Gras isize = ip->i_size;
1416d65f6f70SBen Gras if (isize < ump->um_maxsymlinklen ||
1417d65f6f70SBen Gras (ump->um_maxsymlinklen == 0 && DIP(ip, blocks) == 0)) {
1418d65f6f70SBen Gras uiomove((char *)SHORTLINK(ip), isize, ap->a_uio);
1419d65f6f70SBen Gras return (0);
1420d65f6f70SBen Gras }
1421*0a6a1f1dSLionel Sambuc return (UFS_BUFRD(vp, ap->a_uio, 0, ap->a_cred));
1422d65f6f70SBen Gras }
1423d65f6f70SBen Gras
1424d65f6f70SBen Gras /*
1425d65f6f70SBen Gras * Calculate the logical to physical mapping if not done already,
1426d65f6f70SBen Gras * then call the device strategy routine.
1427d65f6f70SBen Gras */
1428d65f6f70SBen Gras int
ufs_strategy(void * v)1429d65f6f70SBen Gras ufs_strategy(void *v)
1430d65f6f70SBen Gras {
1431d65f6f70SBen Gras struct vop_strategy_args /* {
1432d65f6f70SBen Gras struct vnode *a_vp;
1433d65f6f70SBen Gras struct buf *a_bp;
1434d65f6f70SBen Gras } */ *ap = v;
1435d65f6f70SBen Gras struct buf *bp;
1436d65f6f70SBen Gras struct vnode *vp;
1437d65f6f70SBen Gras struct inode *ip;
1438d65f6f70SBen Gras struct mount *mp;
1439d65f6f70SBen Gras int error;
1440d65f6f70SBen Gras
1441d65f6f70SBen Gras bp = ap->a_bp;
1442d65f6f70SBen Gras vp = ap->a_vp;
1443d65f6f70SBen Gras ip = VTOI(vp);
1444d65f6f70SBen Gras if (vp->v_type == VBLK || vp->v_type == VCHR)
1445d65f6f70SBen Gras panic("ufs_strategy: spec");
1446d65f6f70SBen Gras KASSERT(bp->b_bcount != 0);
1447d65f6f70SBen Gras if (bp->b_blkno == bp->b_lblkno) {
1448d65f6f70SBen Gras error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno,
1449d65f6f70SBen Gras NULL);
1450d65f6f70SBen Gras if (error) {
1451d65f6f70SBen Gras bp->b_error = error;
1452d65f6f70SBen Gras biodone(bp);
1453d65f6f70SBen Gras return (error);
1454d65f6f70SBen Gras }
1455d65f6f70SBen Gras if (bp->b_blkno == -1) /* no valid data */
1456d65f6f70SBen Gras clrbuf(bp);
1457d65f6f70SBen Gras }
1458d65f6f70SBen Gras if (bp->b_blkno < 0) { /* block is not on disk */
1459d65f6f70SBen Gras biodone(bp);
1460d65f6f70SBen Gras return (0);
1461d65f6f70SBen Gras }
1462d65f6f70SBen Gras vp = ip->i_devvp;
1463d65f6f70SBen Gras
1464d65f6f70SBen Gras error = VOP_STRATEGY(vp, bp);
1465d65f6f70SBen Gras if (error)
1466d65f6f70SBen Gras return error;
1467d65f6f70SBen Gras
1468d65f6f70SBen Gras if (!BUF_ISREAD(bp))
1469d65f6f70SBen Gras return 0;
1470d65f6f70SBen Gras
1471d65f6f70SBen Gras mp = wapbl_vptomp(vp);
1472d65f6f70SBen Gras if (mp == NULL || mp->mnt_wapbl_replay == NULL ||
1473d65f6f70SBen Gras !WAPBL_REPLAY_ISOPEN(mp) ||
1474d65f6f70SBen Gras !WAPBL_REPLAY_CAN_READ(mp, bp->b_blkno, bp->b_bcount))
1475d65f6f70SBen Gras return 0;
1476d65f6f70SBen Gras
1477d65f6f70SBen Gras error = biowait(bp);
1478d65f6f70SBen Gras if (error)
1479d65f6f70SBen Gras return error;
1480d65f6f70SBen Gras
1481d65f6f70SBen Gras error = WAPBL_REPLAY_READ(mp, bp->b_data, bp->b_blkno, bp->b_bcount);
1482d65f6f70SBen Gras if (error) {
1483d65f6f70SBen Gras mutex_enter(&bufcache_lock);
1484d65f6f70SBen Gras SET(bp->b_cflags, BC_INVAL);
1485d65f6f70SBen Gras mutex_exit(&bufcache_lock);
1486d65f6f70SBen Gras }
1487d65f6f70SBen Gras return error;
1488d65f6f70SBen Gras }
1489d65f6f70SBen Gras
1490d65f6f70SBen Gras /*
1491d65f6f70SBen Gras * Print out the contents of an inode.
1492d65f6f70SBen Gras */
1493d65f6f70SBen Gras int
ufs_print(void * v)1494d65f6f70SBen Gras ufs_print(void *v)
1495d65f6f70SBen Gras {
1496d65f6f70SBen Gras struct vop_print_args /* {
1497d65f6f70SBen Gras struct vnode *a_vp;
1498d65f6f70SBen Gras } */ *ap = v;
1499d65f6f70SBen Gras struct vnode *vp;
1500d65f6f70SBen Gras struct inode *ip;
1501d65f6f70SBen Gras
1502d65f6f70SBen Gras vp = ap->a_vp;
1503d65f6f70SBen Gras ip = VTOI(vp);
1504d65f6f70SBen Gras printf("tag VT_UFS, ino %llu, on dev %llu, %llu",
1505d65f6f70SBen Gras (unsigned long long)ip->i_number,
1506d65f6f70SBen Gras (unsigned long long)major(ip->i_dev),
1507d65f6f70SBen Gras (unsigned long long)minor(ip->i_dev));
1508d65f6f70SBen Gras printf(" flags 0x%x, nlink %d\n",
1509d65f6f70SBen Gras ip->i_flag, ip->i_nlink);
1510d65f6f70SBen Gras printf("\tmode 0%o, owner %d, group %d, size %qd",
1511d65f6f70SBen Gras ip->i_mode, ip->i_uid, ip->i_gid,
1512d65f6f70SBen Gras (long long)ip->i_size);
1513d65f6f70SBen Gras if (vp->v_type == VFIFO)
1514d65f6f70SBen Gras VOCALL(fifo_vnodeop_p, VOFFSET(vop_print), v);
1515d65f6f70SBen Gras printf("\n");
1516d65f6f70SBen Gras return (0);
1517d65f6f70SBen Gras }
1518d65f6f70SBen Gras
1519d65f6f70SBen Gras /*
1520d65f6f70SBen Gras * Read wrapper for special devices.
1521d65f6f70SBen Gras */
1522d65f6f70SBen Gras int
ufsspec_read(void * v)1523d65f6f70SBen Gras ufsspec_read(void *v)
1524d65f6f70SBen Gras {
1525d65f6f70SBen Gras struct vop_read_args /* {
1526d65f6f70SBen Gras struct vnode *a_vp;
1527d65f6f70SBen Gras struct uio *a_uio;
1528d65f6f70SBen Gras int a_ioflag;
1529d65f6f70SBen Gras kauth_cred_t a_cred;
1530d65f6f70SBen Gras } */ *ap = v;
1531d65f6f70SBen Gras
1532d65f6f70SBen Gras /*
1533d65f6f70SBen Gras * Set access flag.
1534d65f6f70SBen Gras */
1535d65f6f70SBen Gras if ((ap->a_vp->v_mount->mnt_flag & MNT_NODEVMTIME) == 0)
1536d65f6f70SBen Gras VTOI(ap->a_vp)->i_flag |= IN_ACCESS;
1537d65f6f70SBen Gras return (VOCALL (spec_vnodeop_p, VOFFSET(vop_read), ap));
1538d65f6f70SBen Gras }
1539d65f6f70SBen Gras
1540d65f6f70SBen Gras /*
1541d65f6f70SBen Gras * Write wrapper for special devices.
1542d65f6f70SBen Gras */
1543d65f6f70SBen Gras int
ufsspec_write(void * v)1544d65f6f70SBen Gras ufsspec_write(void *v)
1545d65f6f70SBen Gras {
1546d65f6f70SBen Gras struct vop_write_args /* {
1547d65f6f70SBen Gras struct vnode *a_vp;
1548d65f6f70SBen Gras struct uio *a_uio;
1549d65f6f70SBen Gras int a_ioflag;
1550d65f6f70SBen Gras kauth_cred_t a_cred;
1551d65f6f70SBen Gras } */ *ap = v;
1552d65f6f70SBen Gras
1553d65f6f70SBen Gras /*
1554d65f6f70SBen Gras * Set update and change flags.
1555d65f6f70SBen Gras */
1556d65f6f70SBen Gras if ((ap->a_vp->v_mount->mnt_flag & MNT_NODEVMTIME) == 0)
1557d65f6f70SBen Gras VTOI(ap->a_vp)->i_flag |= IN_MODIFY;
1558d65f6f70SBen Gras return (VOCALL (spec_vnodeop_p, VOFFSET(vop_write), ap));
1559d65f6f70SBen Gras }
1560d65f6f70SBen Gras
1561d65f6f70SBen Gras /*
1562d65f6f70SBen Gras * Close wrapper for special devices.
1563d65f6f70SBen Gras *
1564d65f6f70SBen Gras * Update the times on the inode then do device close.
1565d65f6f70SBen Gras */
1566d65f6f70SBen Gras int
ufsspec_close(void * v)1567d65f6f70SBen Gras ufsspec_close(void *v)
1568d65f6f70SBen Gras {
1569d65f6f70SBen Gras struct vop_close_args /* {
1570d65f6f70SBen Gras struct vnode *a_vp;
1571d65f6f70SBen Gras int a_fflag;
1572d65f6f70SBen Gras kauth_cred_t a_cred;
1573d65f6f70SBen Gras } */ *ap = v;
1574d65f6f70SBen Gras struct vnode *vp;
1575d65f6f70SBen Gras
1576d65f6f70SBen Gras vp = ap->a_vp;
1577d65f6f70SBen Gras if (vp->v_usecount > 1)
1578d65f6f70SBen Gras UFS_ITIMES(vp, NULL, NULL, NULL);
1579d65f6f70SBen Gras return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
1580d65f6f70SBen Gras }
1581d65f6f70SBen Gras
1582d65f6f70SBen Gras /*
1583d65f6f70SBen Gras * Read wrapper for fifo's
1584d65f6f70SBen Gras */
1585d65f6f70SBen Gras int
ufsfifo_read(void * v)1586d65f6f70SBen Gras ufsfifo_read(void *v)
1587d65f6f70SBen Gras {
1588d65f6f70SBen Gras struct vop_read_args /* {
1589d65f6f70SBen Gras struct vnode *a_vp;
1590d65f6f70SBen Gras struct uio *a_uio;
1591d65f6f70SBen Gras int a_ioflag;
1592d65f6f70SBen Gras kauth_cred_t a_cred;
1593d65f6f70SBen Gras } */ *ap = v;
1594d65f6f70SBen Gras
1595d65f6f70SBen Gras /*
1596d65f6f70SBen Gras * Set access flag.
1597d65f6f70SBen Gras */
1598d65f6f70SBen Gras VTOI(ap->a_vp)->i_flag |= IN_ACCESS;
1599d65f6f70SBen Gras return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_read), ap));
1600d65f6f70SBen Gras }
1601d65f6f70SBen Gras
1602d65f6f70SBen Gras /*
1603d65f6f70SBen Gras * Write wrapper for fifo's.
1604d65f6f70SBen Gras */
1605d65f6f70SBen Gras int
ufsfifo_write(void * v)1606d65f6f70SBen Gras ufsfifo_write(void *v)
1607d65f6f70SBen Gras {
1608d65f6f70SBen Gras struct vop_write_args /* {
1609d65f6f70SBen Gras struct vnode *a_vp;
1610d65f6f70SBen Gras struct uio *a_uio;
1611d65f6f70SBen Gras int a_ioflag;
1612d65f6f70SBen Gras kauth_cred_t a_cred;
1613d65f6f70SBen Gras } */ *ap = v;
1614d65f6f70SBen Gras
1615d65f6f70SBen Gras /*
1616d65f6f70SBen Gras * Set update and change flags.
1617d65f6f70SBen Gras */
1618d65f6f70SBen Gras VTOI(ap->a_vp)->i_flag |= IN_MODIFY;
1619d65f6f70SBen Gras return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_write), ap));
1620d65f6f70SBen Gras }
1621d65f6f70SBen Gras
1622d65f6f70SBen Gras /*
1623d65f6f70SBen Gras * Close wrapper for fifo's.
1624d65f6f70SBen Gras *
1625d65f6f70SBen Gras * Update the times on the inode then do device close.
1626d65f6f70SBen Gras */
1627d65f6f70SBen Gras int
ufsfifo_close(void * v)1628d65f6f70SBen Gras ufsfifo_close(void *v)
1629d65f6f70SBen Gras {
1630d65f6f70SBen Gras struct vop_close_args /* {
1631d65f6f70SBen Gras struct vnode *a_vp;
1632d65f6f70SBen Gras int a_fflag;
1633d65f6f70SBen Gras kauth_cred_t a_cred;
1634d65f6f70SBen Gras } */ *ap = v;
1635d65f6f70SBen Gras struct vnode *vp;
1636d65f6f70SBen Gras
1637d65f6f70SBen Gras vp = ap->a_vp;
1638d65f6f70SBen Gras if (ap->a_vp->v_usecount > 1)
1639d65f6f70SBen Gras UFS_ITIMES(vp, NULL, NULL, NULL);
1640d65f6f70SBen Gras return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
1641d65f6f70SBen Gras }
1642d65f6f70SBen Gras
1643d65f6f70SBen Gras /*
1644d65f6f70SBen Gras * Return POSIX pathconf information applicable to ufs filesystems.
1645d65f6f70SBen Gras */
1646d65f6f70SBen Gras int
ufs_pathconf(void * v)1647d65f6f70SBen Gras ufs_pathconf(void *v)
1648d65f6f70SBen Gras {
1649d65f6f70SBen Gras struct vop_pathconf_args /* {
1650d65f6f70SBen Gras struct vnode *a_vp;
1651d65f6f70SBen Gras int a_name;
1652d65f6f70SBen Gras register_t *a_retval;
1653d65f6f70SBen Gras } */ *ap = v;
1654d65f6f70SBen Gras
1655d65f6f70SBen Gras switch (ap->a_name) {
1656d65f6f70SBen Gras case _PC_LINK_MAX:
1657d65f6f70SBen Gras *ap->a_retval = LINK_MAX;
1658d65f6f70SBen Gras return (0);
1659d65f6f70SBen Gras case _PC_NAME_MAX:
1660d65f6f70SBen Gras *ap->a_retval = FFS_MAXNAMLEN;
1661d65f6f70SBen Gras return (0);
1662d65f6f70SBen Gras case _PC_PATH_MAX:
1663d65f6f70SBen Gras *ap->a_retval = PATH_MAX;
1664d65f6f70SBen Gras return (0);
1665d65f6f70SBen Gras case _PC_PIPE_BUF:
1666d65f6f70SBen Gras *ap->a_retval = PIPE_BUF;
1667d65f6f70SBen Gras return (0);
1668d65f6f70SBen Gras case _PC_CHOWN_RESTRICTED:
1669d65f6f70SBen Gras *ap->a_retval = 1;
1670d65f6f70SBen Gras return (0);
1671d65f6f70SBen Gras case _PC_NO_TRUNC:
1672d65f6f70SBen Gras *ap->a_retval = 1;
1673d65f6f70SBen Gras return (0);
1674d65f6f70SBen Gras case _PC_SYNC_IO:
1675d65f6f70SBen Gras *ap->a_retval = 1;
1676d65f6f70SBen Gras return (0);
1677d65f6f70SBen Gras case _PC_FILESIZEBITS:
1678d65f6f70SBen Gras *ap->a_retval = 42;
1679d65f6f70SBen Gras return (0);
1680d65f6f70SBen Gras case _PC_SYMLINK_MAX:
1681d65f6f70SBen Gras *ap->a_retval = MAXPATHLEN;
1682d65f6f70SBen Gras return (0);
1683d65f6f70SBen Gras case _PC_2_SYMLINKS:
1684d65f6f70SBen Gras *ap->a_retval = 1;
1685d65f6f70SBen Gras return (0);
1686d65f6f70SBen Gras default:
1687d65f6f70SBen Gras return (EINVAL);
1688d65f6f70SBen Gras }
1689d65f6f70SBen Gras /* NOTREACHED */
1690d65f6f70SBen Gras }
1691d65f6f70SBen Gras
1692d65f6f70SBen Gras /*
1693d65f6f70SBen Gras * Advisory record locking support
1694d65f6f70SBen Gras */
1695d65f6f70SBen Gras int
ufs_advlock(void * v)1696d65f6f70SBen Gras ufs_advlock(void *v)
1697d65f6f70SBen Gras {
1698d65f6f70SBen Gras struct vop_advlock_args /* {
1699d65f6f70SBen Gras struct vnode *a_vp;
1700d65f6f70SBen Gras void * a_id;
1701d65f6f70SBen Gras int a_op;
1702d65f6f70SBen Gras struct flock *a_fl;
1703d65f6f70SBen Gras int a_flags;
1704d65f6f70SBen Gras } */ *ap = v;
1705d65f6f70SBen Gras struct inode *ip;
1706d65f6f70SBen Gras
1707d65f6f70SBen Gras ip = VTOI(ap->a_vp);
1708d65f6f70SBen Gras return lf_advlock(ap, &ip->i_lockf, ip->i_size);
1709d65f6f70SBen Gras }
1710d65f6f70SBen Gras
1711d65f6f70SBen Gras /*
1712d65f6f70SBen Gras * Initialize the vnode associated with a new inode, handle aliased
1713d65f6f70SBen Gras * vnodes.
1714d65f6f70SBen Gras */
1715d65f6f70SBen Gras void
ufs_vinit(struct mount * mntp,int (** specops)(void *),int (** fifoops)(void *),struct vnode ** vpp)1716d65f6f70SBen Gras ufs_vinit(struct mount *mntp, int (**specops)(void *), int (**fifoops)(void *),
1717d65f6f70SBen Gras struct vnode **vpp)
1718d65f6f70SBen Gras {
1719d65f6f70SBen Gras struct timeval tv;
1720d65f6f70SBen Gras struct inode *ip;
1721d65f6f70SBen Gras struct vnode *vp;
1722d65f6f70SBen Gras dev_t rdev;
1723d65f6f70SBen Gras struct ufsmount *ump;
1724d65f6f70SBen Gras
1725d65f6f70SBen Gras vp = *vpp;
1726d65f6f70SBen Gras ip = VTOI(vp);
1727d65f6f70SBen Gras switch(vp->v_type = IFTOVT(ip->i_mode)) {
1728d65f6f70SBen Gras case VCHR:
1729d65f6f70SBen Gras case VBLK:
1730d65f6f70SBen Gras vp->v_op = specops;
1731d65f6f70SBen Gras ump = ip->i_ump;
1732d65f6f70SBen Gras if (ump->um_fstype == UFS1)
1733d65f6f70SBen Gras rdev = (dev_t)ufs_rw32(ip->i_ffs1_rdev,
1734d65f6f70SBen Gras UFS_MPNEEDSWAP(ump));
1735d65f6f70SBen Gras else
1736d65f6f70SBen Gras rdev = (dev_t)ufs_rw64(ip->i_ffs2_rdev,
1737d65f6f70SBen Gras UFS_MPNEEDSWAP(ump));
1738d65f6f70SBen Gras spec_node_init(vp, rdev);
1739d65f6f70SBen Gras break;
1740d65f6f70SBen Gras case VFIFO:
1741d65f6f70SBen Gras vp->v_op = fifoops;
1742d65f6f70SBen Gras break;
1743d65f6f70SBen Gras case VNON:
1744d65f6f70SBen Gras case VBAD:
1745d65f6f70SBen Gras case VSOCK:
1746d65f6f70SBen Gras case VLNK:
1747d65f6f70SBen Gras case VDIR:
1748d65f6f70SBen Gras case VREG:
1749d65f6f70SBen Gras break;
1750d65f6f70SBen Gras }
175184d9c625SLionel Sambuc if (ip->i_number == UFS_ROOTINO)
1752d65f6f70SBen Gras vp->v_vflag |= VV_ROOT;
1753d65f6f70SBen Gras /*
1754d65f6f70SBen Gras * Initialize modrev times
1755d65f6f70SBen Gras */
1756d65f6f70SBen Gras getmicrouptime(&tv);
1757d65f6f70SBen Gras ip->i_modrev = (uint64_t)(uint)tv.tv_sec << 32
1758d65f6f70SBen Gras | tv.tv_usec * 4294u;
1759d65f6f70SBen Gras *vpp = vp;
1760d65f6f70SBen Gras }
1761d65f6f70SBen Gras
1762d65f6f70SBen Gras /*
1763d65f6f70SBen Gras * Allocate a new inode.
1764d65f6f70SBen Gras */
1765d65f6f70SBen Gras int
ufs_makeinode(struct vattr * vap,struct vnode * dvp,const struct ufs_lookup_results * ulr,struct vnode ** vpp,struct componentname * cnp)1766*0a6a1f1dSLionel Sambuc ufs_makeinode(struct vattr *vap, struct vnode *dvp,
1767*0a6a1f1dSLionel Sambuc const struct ufs_lookup_results *ulr,
1768d65f6f70SBen Gras struct vnode **vpp, struct componentname *cnp)
1769d65f6f70SBen Gras {
1770*0a6a1f1dSLionel Sambuc struct inode *ip;
1771d65f6f70SBen Gras struct direct *newdir;
1772d65f6f70SBen Gras struct vnode *tvp;
177384d9c625SLionel Sambuc int error;
1774d65f6f70SBen Gras
1775d65f6f70SBen Gras UFS_WAPBL_JUNLOCK_ASSERT(dvp->v_mount);
1776d65f6f70SBen Gras
1777*0a6a1f1dSLionel Sambuc error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, &tvp);
1778*0a6a1f1dSLionel Sambuc if (error)
1779*0a6a1f1dSLionel Sambuc return error;
1780*0a6a1f1dSLionel Sambuc error = vn_lock(tvp, LK_EXCLUSIVE);
1781*0a6a1f1dSLionel Sambuc if (error) {
1782*0a6a1f1dSLionel Sambuc vrele(tvp);
1783*0a6a1f1dSLionel Sambuc return error;
1784d65f6f70SBen Gras }
1785*0a6a1f1dSLionel Sambuc *vpp = tvp;
1786d65f6f70SBen Gras ip = VTOI(tvp);
1787d65f6f70SBen Gras error = UFS_WAPBL_BEGIN1(dvp->v_mount, dvp);
1788d65f6f70SBen Gras if (error) {
1789d65f6f70SBen Gras vput(tvp);
1790d65f6f70SBen Gras return (error);
1791d65f6f70SBen Gras }
1792d65f6f70SBen Gras ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1793d65f6f70SBen Gras ip->i_nlink = 1;
1794d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, 1);
179584d9c625SLionel Sambuc
179684d9c625SLionel Sambuc /* Authorize setting SGID if needed. */
179784d9c625SLionel Sambuc if (ip->i_mode & ISGID) {
179884d9c625SLionel Sambuc error = kauth_authorize_vnode(cnp->cn_cred, KAUTH_VNODE_WRITE_SECURITY,
179984d9c625SLionel Sambuc tvp, NULL, genfs_can_chmod(tvp->v_type, cnp->cn_cred, ip->i_uid,
1800*0a6a1f1dSLionel Sambuc ip->i_gid, MAKEIMODE(vap->va_type, vap->va_mode)));
180184d9c625SLionel Sambuc if (error) {
1802d65f6f70SBen Gras ip->i_mode &= ~ISGID;
1803d65f6f70SBen Gras DIP_ASSIGN(ip, mode, ip->i_mode);
1804d65f6f70SBen Gras }
180584d9c625SLionel Sambuc }
1806d65f6f70SBen Gras
1807d65f6f70SBen Gras if (cnp->cn_flags & ISWHITEOUT) {
1808d65f6f70SBen Gras ip->i_flags |= UF_OPAQUE;
1809d65f6f70SBen Gras DIP_ASSIGN(ip, flags, ip->i_flags);
1810d65f6f70SBen Gras }
1811d65f6f70SBen Gras
1812d65f6f70SBen Gras /*
1813d65f6f70SBen Gras * Make sure inode goes to disk before directory entry.
1814d65f6f70SBen Gras */
1815d65f6f70SBen Gras if ((error = UFS_UPDATE(tvp, NULL, NULL, UPDATE_DIROP)) != 0)
1816d65f6f70SBen Gras goto bad;
1817d65f6f70SBen Gras newdir = pool_cache_get(ufs_direct_cache, PR_WAITOK);
1818d65f6f70SBen Gras ufs_makedirentry(ip, cnp, newdir);
1819d65f6f70SBen Gras error = ufs_direnter(dvp, ulr, tvp, newdir, cnp, NULL);
1820d65f6f70SBen Gras pool_cache_put(ufs_direct_cache, newdir);
1821d65f6f70SBen Gras if (error)
1822d65f6f70SBen Gras goto bad;
1823d65f6f70SBen Gras *vpp = tvp;
1824d65f6f70SBen Gras return (0);
1825d65f6f70SBen Gras
1826d65f6f70SBen Gras bad:
1827d65f6f70SBen Gras /*
1828d65f6f70SBen Gras * Write error occurred trying to update the inode
1829d65f6f70SBen Gras * or the directory so must deallocate the inode.
1830d65f6f70SBen Gras */
1831d65f6f70SBen Gras ip->i_nlink = 0;
1832d65f6f70SBen Gras DIP_ASSIGN(ip, nlink, 0);
1833d65f6f70SBen Gras ip->i_flag |= IN_CHANGE;
1834d65f6f70SBen Gras UFS_WAPBL_UPDATE(tvp, NULL, NULL, 0);
1835d65f6f70SBen Gras UFS_WAPBL_END1(dvp->v_mount, dvp);
1836d65f6f70SBen Gras vput(tvp);
1837d65f6f70SBen Gras return (error);
1838d65f6f70SBen Gras }
1839d65f6f70SBen Gras
1840d65f6f70SBen Gras /*
1841d65f6f70SBen Gras * Allocate len bytes at offset off.
1842d65f6f70SBen Gras */
1843d65f6f70SBen Gras int
ufs_gop_alloc(struct vnode * vp,off_t off,off_t len,int flags,kauth_cred_t cred)1844d65f6f70SBen Gras ufs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
1845d65f6f70SBen Gras kauth_cred_t cred)
1846d65f6f70SBen Gras {
1847d65f6f70SBen Gras struct inode *ip = VTOI(vp);
1848d65f6f70SBen Gras int error, delta, bshift, bsize;
1849d65f6f70SBen Gras UVMHIST_FUNC("ufs_gop_alloc"); UVMHIST_CALLED(ubchist);
1850d65f6f70SBen Gras
1851d65f6f70SBen Gras error = 0;
1852d65f6f70SBen Gras bshift = vp->v_mount->mnt_fs_bshift;
1853d65f6f70SBen Gras bsize = 1 << bshift;
1854d65f6f70SBen Gras
1855d65f6f70SBen Gras delta = off & (bsize - 1);
1856d65f6f70SBen Gras off -= delta;
1857d65f6f70SBen Gras len += delta;
1858d65f6f70SBen Gras
1859d65f6f70SBen Gras while (len > 0) {
1860d65f6f70SBen Gras bsize = MIN(bsize, len);
1861d65f6f70SBen Gras
1862d65f6f70SBen Gras error = UFS_BALLOC(vp, off, bsize, cred, flags, NULL);
1863d65f6f70SBen Gras if (error) {
1864d65f6f70SBen Gras goto out;
1865d65f6f70SBen Gras }
1866d65f6f70SBen Gras
1867d65f6f70SBen Gras /*
1868d65f6f70SBen Gras * increase file size now, UFS_BALLOC() requires that
1869d65f6f70SBen Gras * EOF be up-to-date before each call.
1870d65f6f70SBen Gras */
1871d65f6f70SBen Gras
1872d65f6f70SBen Gras if (ip->i_size < off + bsize) {
1873d65f6f70SBen Gras UVMHIST_LOG(ubchist, "vp %p old 0x%x new 0x%x",
1874d65f6f70SBen Gras vp, ip->i_size, off + bsize, 0);
1875d65f6f70SBen Gras ip->i_size = off + bsize;
1876d65f6f70SBen Gras DIP_ASSIGN(ip, size, ip->i_size);
1877d65f6f70SBen Gras }
1878d65f6f70SBen Gras
1879d65f6f70SBen Gras off += bsize;
1880d65f6f70SBen Gras len -= bsize;
1881d65f6f70SBen Gras }
1882d65f6f70SBen Gras
1883d65f6f70SBen Gras out:
1884d65f6f70SBen Gras UFS_WAPBL_UPDATE(vp, NULL, NULL, 0);
1885d65f6f70SBen Gras return error;
1886d65f6f70SBen Gras }
1887d65f6f70SBen Gras
1888d65f6f70SBen Gras void
ufs_gop_markupdate(struct vnode * vp,int flags)1889d65f6f70SBen Gras ufs_gop_markupdate(struct vnode *vp, int flags)
1890d65f6f70SBen Gras {
1891d65f6f70SBen Gras u_int32_t mask = 0;
1892d65f6f70SBen Gras
1893d65f6f70SBen Gras if ((flags & GOP_UPDATE_ACCESSED) != 0) {
1894d65f6f70SBen Gras mask = IN_ACCESS;
1895d65f6f70SBen Gras }
1896d65f6f70SBen Gras if ((flags & GOP_UPDATE_MODIFIED) != 0) {
1897d65f6f70SBen Gras if (vp->v_type == VREG) {
1898d65f6f70SBen Gras mask |= IN_CHANGE | IN_UPDATE;
1899d65f6f70SBen Gras } else {
1900d65f6f70SBen Gras mask |= IN_MODIFY;
1901d65f6f70SBen Gras }
1902d65f6f70SBen Gras }
1903d65f6f70SBen Gras if (mask) {
1904d65f6f70SBen Gras struct inode *ip = VTOI(vp);
1905d65f6f70SBen Gras
1906d65f6f70SBen Gras ip->i_flag |= mask;
1907d65f6f70SBen Gras }
1908d65f6f70SBen Gras }
1909*0a6a1f1dSLionel Sambuc
1910*0a6a1f1dSLionel Sambuc int
ufs_bufio(enum uio_rw rw,struct vnode * vp,void * buf,size_t len,off_t off,int ioflg,kauth_cred_t cred,size_t * aresid,struct lwp * l)1911*0a6a1f1dSLionel Sambuc ufs_bufio(enum uio_rw rw, struct vnode *vp, void *buf, size_t len, off_t off,
1912*0a6a1f1dSLionel Sambuc int ioflg, kauth_cred_t cred, size_t *aresid, struct lwp *l)
1913*0a6a1f1dSLionel Sambuc {
1914*0a6a1f1dSLionel Sambuc struct iovec iov;
1915*0a6a1f1dSLionel Sambuc struct uio uio;
1916*0a6a1f1dSLionel Sambuc int error;
1917*0a6a1f1dSLionel Sambuc
1918*0a6a1f1dSLionel Sambuc KASSERT(ISSET(ioflg, IO_NODELOCKED));
1919*0a6a1f1dSLionel Sambuc KASSERT(VOP_ISLOCKED(vp));
1920*0a6a1f1dSLionel Sambuc KASSERT(rw != UIO_WRITE || VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
1921*0a6a1f1dSLionel Sambuc KASSERT(rw != UIO_WRITE || vp->v_mount->mnt_wapbl == NULL ||
1922*0a6a1f1dSLionel Sambuc ISSET(ioflg, IO_JOURNALLOCKED));
1923*0a6a1f1dSLionel Sambuc
1924*0a6a1f1dSLionel Sambuc iov.iov_base = buf;
1925*0a6a1f1dSLionel Sambuc iov.iov_len = len;
1926*0a6a1f1dSLionel Sambuc uio.uio_iov = &iov;
1927*0a6a1f1dSLionel Sambuc uio.uio_iovcnt = 1;
1928*0a6a1f1dSLionel Sambuc uio.uio_resid = len;
1929*0a6a1f1dSLionel Sambuc uio.uio_offset = off;
1930*0a6a1f1dSLionel Sambuc uio.uio_rw = rw;
1931*0a6a1f1dSLionel Sambuc UIO_SETUP_SYSSPACE(&uio);
1932*0a6a1f1dSLionel Sambuc
1933*0a6a1f1dSLionel Sambuc switch (rw) {
1934*0a6a1f1dSLionel Sambuc case UIO_READ:
1935*0a6a1f1dSLionel Sambuc error = UFS_BUFRD(vp, &uio, ioflg, cred);
1936*0a6a1f1dSLionel Sambuc break;
1937*0a6a1f1dSLionel Sambuc case UIO_WRITE:
1938*0a6a1f1dSLionel Sambuc error = UFS_BUFWR(vp, &uio, ioflg, cred);
1939*0a6a1f1dSLionel Sambuc break;
1940*0a6a1f1dSLionel Sambuc default:
1941*0a6a1f1dSLionel Sambuc panic("invalid uio rw: %d", (int)rw);
1942*0a6a1f1dSLionel Sambuc }
1943*0a6a1f1dSLionel Sambuc
1944*0a6a1f1dSLionel Sambuc if (aresid)
1945*0a6a1f1dSLionel Sambuc *aresid = uio.uio_resid;
1946*0a6a1f1dSLionel Sambuc else if (uio.uio_resid && error == 0)
1947*0a6a1f1dSLionel Sambuc error = EIO;
1948*0a6a1f1dSLionel Sambuc
1949*0a6a1f1dSLionel Sambuc KASSERT(VOP_ISLOCKED(vp));
1950*0a6a1f1dSLionel Sambuc KASSERT(rw != UIO_WRITE || VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
1951*0a6a1f1dSLionel Sambuc return error;
1952*0a6a1f1dSLionel Sambuc }
1953