xref: /freebsd/sys/fs/ext2fs/ext2_vnops.c (revision 86e2d48bf9e2c729b4b9425320af0e8abc0d9b4c)
1 /*-
2  *  modified for EXT2FS support in Lites 1.1
3  *
4  *  Aug 1995, Godmar Back (gback@cs.utah.edu)
5  *  University of Utah, Department of Computer Science
6  */
7 /*-
8  * SPDX-License-Identifier: BSD-3-Clause
9  *
10  * Copyright (c) 1982, 1986, 1989, 1993
11  *	The Regents of the University of California.  All rights reserved.
12  * (c) UNIX System Laboratories, Inc.
13  * All or some portions of this file are derived from material licensed
14  * to the University of California by American Telephone and Telegraph
15  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
16  * the permission of UNIX System Laboratories, Inc.
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  * 1. Redistributions of source code must retain the above copyright
22  *    notice, this list of conditions and the following disclaimer.
23  * 2. Redistributions in binary form must reproduce the above copyright
24  *    notice, this list of conditions and the following disclaimer in the
25  *    documentation and/or other materials provided with the distribution.
26  * 3. Neither the name of the University nor the names of its contributors
27  *    may be used to endorse or promote products derived from this software
28  *    without specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40  * SUCH DAMAGE.
41  *
42  *	@(#)ufs_vnops.c	8.7 (Berkeley) 2/3/94
43  *	@(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95
44  * $FreeBSD$
45  */
46 
47 #include "opt_suiddir.h"
48 
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/kernel.h>
52 #include <sys/fcntl.h>
53 #include <sys/filio.h>
54 #include <sys/limits.h>
55 #include <sys/sdt.h>
56 #include <sys/stat.h>
57 #include <sys/bio.h>
58 #include <sys/buf.h>
59 #include <sys/endian.h>
60 #include <sys/priv.h>
61 #include <sys/rwlock.h>
62 #include <sys/mount.h>
63 #include <sys/unistd.h>
64 #include <sys/time.h>
65 #include <sys/vnode.h>
66 #include <sys/namei.h>
67 #include <sys/lockf.h>
68 #include <sys/event.h>
69 #include <sys/conf.h>
70 #include <sys/file.h>
71 #include <sys/extattr.h>
72 #include <sys/vmmeter.h>
73 
74 #include <vm/vm.h>
75 #include <vm/vm_param.h>
76 #include <vm/vm_extern.h>
77 #include <vm/vm_object.h>
78 #include <vm/vm_page.h>
79 #include <vm/vm_pager.h>
80 #include <vm/vnode_pager.h>
81 
82 #include "opt_directio.h"
83 
84 #include <ufs/ufs/dir.h>
85 
86 #include <fs/ext2fs/fs.h>
87 #include <fs/ext2fs/inode.h>
88 #include <fs/ext2fs/ext2_acl.h>
89 #include <fs/ext2fs/ext2fs.h>
90 #include <fs/ext2fs/ext2_extern.h>
91 #include <fs/ext2fs/ext2_dinode.h>
92 #include <fs/ext2fs/ext2_dir.h>
93 #include <fs/ext2fs/ext2_mount.h>
94 #include <fs/ext2fs/ext2_extattr.h>
95 #include <fs/ext2fs/ext2_extents.h>
96 
97 SDT_PROVIDER_DECLARE(ext2fs);
98 /*
99  * ext2fs trace probe:
100  * arg0: verbosity. Higher numbers give more verbose messages
101  * arg1: Textual message
102  */
103 SDT_PROBE_DEFINE2(ext2fs, , vnops, trace, "int", "char*");
104 
105 static int ext2_makeinode(int mode, struct vnode *, struct vnode **, struct componentname *);
106 static void ext2_itimes_locked(struct vnode *);
107 
108 static vop_access_t	ext2_access;
109 static int ext2_chmod(struct vnode *, int, struct ucred *, struct thread *);
110 static int ext2_chown(struct vnode *, uid_t, gid_t, struct ucred *,
111     struct thread *);
112 static vop_close_t	ext2_close;
113 static vop_create_t	ext2_create;
114 static vop_fsync_t	ext2_fsync;
115 static vop_getattr_t	ext2_getattr;
116 static vop_ioctl_t	ext2_ioctl;
117 static vop_link_t	ext2_link;
118 static vop_mkdir_t	ext2_mkdir;
119 static vop_mknod_t	ext2_mknod;
120 static vop_open_t	ext2_open;
121 static vop_pathconf_t	ext2_pathconf;
122 static vop_print_t	ext2_print;
123 static vop_read_t	ext2_read;
124 static vop_readlink_t	ext2_readlink;
125 static vop_remove_t	ext2_remove;
126 static vop_rename_t	ext2_rename;
127 static vop_rmdir_t	ext2_rmdir;
128 static vop_setattr_t	ext2_setattr;
129 static vop_strategy_t	ext2_strategy;
130 static vop_symlink_t	ext2_symlink;
131 static vop_write_t	ext2_write;
132 static vop_deleteextattr_t	ext2_deleteextattr;
133 static vop_getextattr_t	ext2_getextattr;
134 static vop_listextattr_t	ext2_listextattr;
135 static vop_setextattr_t	ext2_setextattr;
136 static vop_vptofh_t	ext2_vptofh;
137 static vop_close_t	ext2fifo_close;
138 static vop_kqfilter_t	ext2fifo_kqfilter;
139 
140 /* Global vfs data structures for ext2. */
141 struct vop_vector ext2_vnodeops = {
142 	.vop_default =		&default_vnodeops,
143 	.vop_access =		ext2_access,
144 	.vop_bmap =		ext2_bmap,
145 	.vop_cachedlookup =	ext2_lookup,
146 	.vop_close =		ext2_close,
147 	.vop_create =		ext2_create,
148 	.vop_fsync =		ext2_fsync,
149 	.vop_getpages =		vnode_pager_local_getpages,
150 	.vop_getpages_async =	vnode_pager_local_getpages_async,
151 	.vop_getattr =		ext2_getattr,
152 	.vop_inactive =		ext2_inactive,
153 	.vop_ioctl =		ext2_ioctl,
154 	.vop_link =		ext2_link,
155 	.vop_lookup =		vfs_cache_lookup,
156 	.vop_mkdir =		ext2_mkdir,
157 	.vop_mknod =		ext2_mknod,
158 	.vop_open =		ext2_open,
159 	.vop_pathconf =		ext2_pathconf,
160 	.vop_poll =		vop_stdpoll,
161 	.vop_print =		ext2_print,
162 	.vop_read =		ext2_read,
163 	.vop_readdir =		ext2_readdir,
164 	.vop_readlink =		ext2_readlink,
165 	.vop_reallocblks =	ext2_reallocblks,
166 	.vop_reclaim =		ext2_reclaim,
167 	.vop_remove =		ext2_remove,
168 	.vop_rename =		ext2_rename,
169 	.vop_rmdir =		ext2_rmdir,
170 	.vop_setattr =		ext2_setattr,
171 	.vop_strategy =		ext2_strategy,
172 	.vop_symlink =		ext2_symlink,
173 	.vop_write =		ext2_write,
174 	.vop_deleteextattr =	ext2_deleteextattr,
175 	.vop_getextattr =	ext2_getextattr,
176 	.vop_listextattr =	ext2_listextattr,
177 	.vop_setextattr =	ext2_setextattr,
178 #ifdef UFS_ACL
179 	.vop_getacl =		ext2_getacl,
180 	.vop_setacl =		ext2_setacl,
181 	.vop_aclcheck =		ext2_aclcheck,
182 #endif /* UFS_ACL */
183 	.vop_vptofh =		ext2_vptofh,
184 };
185 VFS_VOP_VECTOR_REGISTER(ext2_vnodeops);
186 
187 struct vop_vector ext2_fifoops = {
188 	.vop_default =		&fifo_specops,
189 	.vop_access =		ext2_access,
190 	.vop_close =		ext2fifo_close,
191 	.vop_fsync =		ext2_fsync,
192 	.vop_getattr =		ext2_getattr,
193 	.vop_inactive =		ext2_inactive,
194 	.vop_kqfilter =		ext2fifo_kqfilter,
195 	.vop_pathconf =		ext2_pathconf,
196 	.vop_print =		ext2_print,
197 	.vop_read =		VOP_PANIC,
198 	.vop_reclaim =		ext2_reclaim,
199 	.vop_setattr =		ext2_setattr,
200 	.vop_write =		VOP_PANIC,
201 	.vop_vptofh =		ext2_vptofh,
202 };
203 VFS_VOP_VECTOR_REGISTER(ext2_fifoops);
204 
205 /*
206  * A virgin directory (no blushing please).
207  * Note that the type and namlen fields are reversed relative to ext2.
208  * Also, we don't use `struct odirtemplate', since it would just cause
209  * endianness problems.
210  */
211 static struct dirtemplate mastertemplate = {
212 	0, 12, 1, EXT2_FT_DIR, ".",
213 	0, DIRBLKSIZ - 12, 2, EXT2_FT_DIR, ".."
214 };
215 static struct dirtemplate omastertemplate = {
216 	0, 12, 1, EXT2_FT_UNKNOWN, ".",
217 	0, DIRBLKSIZ - 12, 2, EXT2_FT_UNKNOWN, ".."
218 };
219 
220 static void
221 ext2_itimes_locked(struct vnode *vp)
222 {
223 	struct inode *ip;
224 	struct timespec ts;
225 
226 	ASSERT_VI_LOCKED(vp, __func__);
227 
228 	ip = VTOI(vp);
229 	if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0)
230 		return;
231 	if ((vp->v_type == VBLK || vp->v_type == VCHR))
232 		ip->i_flag |= IN_LAZYMOD;
233 	else
234 		ip->i_flag |= IN_MODIFIED;
235 	if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
236 		vfs_timestamp(&ts);
237 		if (ip->i_flag & IN_ACCESS) {
238 			ip->i_atime = ts.tv_sec;
239 			ip->i_atimensec = ts.tv_nsec;
240 		}
241 		if (ip->i_flag & IN_UPDATE) {
242 			ip->i_mtime = ts.tv_sec;
243 			ip->i_mtimensec = ts.tv_nsec;
244 			ip->i_modrev++;
245 		}
246 		if (ip->i_flag & IN_CHANGE) {
247 			ip->i_ctime = ts.tv_sec;
248 			ip->i_ctimensec = ts.tv_nsec;
249 		}
250 	}
251 	ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
252 }
253 
254 void
255 ext2_itimes(struct vnode *vp)
256 {
257 
258 	VI_LOCK(vp);
259 	ext2_itimes_locked(vp);
260 	VI_UNLOCK(vp);
261 }
262 
263 /*
264  * Create a regular file
265  */
266 static int
267 ext2_create(struct vop_create_args *ap)
268 {
269 	int error;
270 
271 	error =
272 	    ext2_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode),
273 	    ap->a_dvp, ap->a_vpp, ap->a_cnp);
274 	if (error != 0)
275 		return (error);
276 	if ((ap->a_cnp->cn_flags & MAKEENTRY) != 0)
277 		cache_enter(ap->a_dvp, *ap->a_vpp, ap->a_cnp);
278 	return (0);
279 }
280 
281 static int
282 ext2_open(struct vop_open_args *ap)
283 {
284 
285 	if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR)
286 		return (EOPNOTSUPP);
287 
288 	/*
289 	 * Files marked append-only must be opened for appending.
290 	 */
291 	if ((VTOI(ap->a_vp)->i_flags & APPEND) &&
292 	    (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
293 		return (EPERM);
294 
295 	vnode_create_vobject(ap->a_vp, VTOI(ap->a_vp)->i_size, ap->a_td);
296 
297 	return (0);
298 }
299 
300 /*
301  * Close called.
302  *
303  * Update the times on the inode.
304  */
305 static int
306 ext2_close(struct vop_close_args *ap)
307 {
308 	struct vnode *vp = ap->a_vp;
309 
310 	VI_LOCK(vp);
311 	if (vp->v_usecount > 1)
312 		ext2_itimes_locked(vp);
313 	VI_UNLOCK(vp);
314 	return (0);
315 }
316 
317 static int
318 ext2_access(struct vop_access_args *ap)
319 {
320 	struct vnode *vp = ap->a_vp;
321 	struct inode *ip = VTOI(vp);
322 	accmode_t accmode = ap->a_accmode;
323 	int error;
324 
325 	if (vp->v_type == VBLK || vp->v_type == VCHR)
326 		return (EOPNOTSUPP);
327 
328 	/*
329 	 * Disallow write attempts on read-only file systems;
330 	 * unless the file is a socket, fifo, or a block or
331 	 * character device resident on the file system.
332 	 */
333 	if (accmode & VWRITE) {
334 		switch (vp->v_type) {
335 		case VDIR:
336 		case VLNK:
337 		case VREG:
338 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
339 				return (EROFS);
340 			break;
341 		default:
342 			break;
343 		}
344 	}
345 
346 	/* If immutable bit set, nobody gets to write it. */
347 	if ((accmode & VWRITE) && (ip->i_flags & (SF_IMMUTABLE | SF_SNAPSHOT)))
348 		return (EPERM);
349 
350 	error = vaccess(vp->v_type, ip->i_mode, ip->i_uid, ip->i_gid,
351 	    ap->a_accmode, ap->a_cred, NULL);
352 	return (error);
353 }
354 
355 static int
356 ext2_getattr(struct vop_getattr_args *ap)
357 {
358 	struct vnode *vp = ap->a_vp;
359 	struct inode *ip = VTOI(vp);
360 	struct vattr *vap = ap->a_vap;
361 
362 	ext2_itimes(vp);
363 	/*
364 	 * Copy from inode table
365 	 */
366 	vap->va_fsid = dev2udev(ip->i_devvp->v_rdev);
367 	vap->va_fileid = ip->i_number;
368 	vap->va_mode = ip->i_mode & ~IFMT;
369 	vap->va_nlink = ip->i_nlink;
370 	vap->va_uid = ip->i_uid;
371 	vap->va_gid = ip->i_gid;
372 	vap->va_rdev = ip->i_rdev;
373 	vap->va_size = ip->i_size;
374 	vap->va_atime.tv_sec = ip->i_atime;
375 	vap->va_atime.tv_nsec = E2DI_HAS_XTIME(ip) ? ip->i_atimensec : 0;
376 	vap->va_mtime.tv_sec = ip->i_mtime;
377 	vap->va_mtime.tv_nsec = E2DI_HAS_XTIME(ip) ? ip->i_mtimensec : 0;
378 	vap->va_ctime.tv_sec = ip->i_ctime;
379 	vap->va_ctime.tv_nsec = E2DI_HAS_XTIME(ip) ? ip->i_ctimensec : 0;
380 	if E2DI_HAS_XTIME(ip) {
381 		vap->va_birthtime.tv_sec = ip->i_birthtime;
382 		vap->va_birthtime.tv_nsec = ip->i_birthnsec;
383 	}
384 	vap->va_flags = ip->i_flags;
385 	vap->va_gen = ip->i_gen;
386 	vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
387 	vap->va_bytes = dbtob((u_quad_t)ip->i_blocks);
388 	vap->va_type = IFTOVT(ip->i_mode);
389 	vap->va_filerev = ip->i_modrev;
390 	return (0);
391 }
392 
393 /*
394  * Set attribute vnode op. called from several syscalls
395  */
396 static int
397 ext2_setattr(struct vop_setattr_args *ap)
398 {
399 	struct vattr *vap = ap->a_vap;
400 	struct vnode *vp = ap->a_vp;
401 	struct inode *ip = VTOI(vp);
402 	struct ucred *cred = ap->a_cred;
403 	struct thread *td = curthread;
404 	int error;
405 
406 	/*
407 	 * Check for unsettable attributes.
408 	 */
409 	if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
410 	    (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
411 	    (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
412 	    ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
413 		return (EINVAL);
414 	}
415 	if (vap->va_flags != VNOVAL) {
416 		/* Disallow flags not supported by ext2fs. */
417 		if (vap->va_flags & ~(SF_APPEND | SF_IMMUTABLE | UF_NODUMP))
418 			return (EOPNOTSUPP);
419 
420 		if (vp->v_mount->mnt_flag & MNT_RDONLY)
421 			return (EROFS);
422 		/*
423 		 * Callers may only modify the file flags on objects they
424 		 * have VADMIN rights for.
425 		 */
426 		if ((error = VOP_ACCESS(vp, VADMIN, cred, td)))
427 			return (error);
428 		/*
429 		 * Unprivileged processes and privileged processes in
430 		 * jail() are not permitted to unset system flags, or
431 		 * modify flags if any system flags are set.
432 		 * Privileged non-jail processes may not modify system flags
433 		 * if securelevel > 0 and any existing system flags are set.
434 		 */
435 		if (!priv_check_cred(cred, PRIV_VFS_SYSFLAGS)) {
436 			if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND)) {
437 				error = securelevel_gt(cred, 0);
438 				if (error)
439 					return (error);
440 			}
441 		} else {
442 			if (ip->i_flags & (SF_IMMUTABLE | SF_APPEND) ||
443 			    ((vap->va_flags ^ ip->i_flags) & SF_SETTABLE))
444 				return (EPERM);
445 		}
446 		ip->i_flags = vap->va_flags;
447 		ip->i_flag |= IN_CHANGE;
448 		if (ip->i_flags & (IMMUTABLE | APPEND))
449 			return (0);
450 	}
451 	if (ip->i_flags & (IMMUTABLE | APPEND))
452 		return (EPERM);
453 	/*
454 	 * Go through the fields and update iff not VNOVAL.
455 	 */
456 	if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
457 		if (vp->v_mount->mnt_flag & MNT_RDONLY)
458 			return (EROFS);
459 		if ((error = ext2_chown(vp, vap->va_uid, vap->va_gid, cred,
460 		    td)) != 0)
461 			return (error);
462 	}
463 	if (vap->va_size != VNOVAL) {
464 		/*
465 		 * Disallow write attempts on read-only file systems;
466 		 * unless the file is a socket, fifo, or a block or
467 		 * character device resident on the file system.
468 		 */
469 		switch (vp->v_type) {
470 		case VDIR:
471 			return (EISDIR);
472 		case VLNK:
473 		case VREG:
474 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
475 				return (EROFS);
476 			break;
477 		default:
478 			break;
479 		}
480 		if ((error = ext2_truncate(vp, vap->va_size, 0, cred, td)) != 0)
481 			return (error);
482 	}
483 	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
484 		if (vp->v_mount->mnt_flag & MNT_RDONLY)
485 			return (EROFS);
486 		/*
487 		 * From utimes(2):
488 		 * If times is NULL, ... The caller must be the owner of
489 		 * the file, have permission to write the file, or be the
490 		 * super-user.
491 		 * If times is non-NULL, ... The caller must be the owner of
492 		 * the file or be the super-user.
493 		 */
494 		if ((error = VOP_ACCESS(vp, VADMIN, cred, td)) &&
495 		    ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
496 		    (error = VOP_ACCESS(vp, VWRITE, cred, td))))
497 			return (error);
498 		ip->i_flag |= IN_CHANGE | IN_MODIFIED;
499 		if (vap->va_atime.tv_sec != VNOVAL) {
500 			ip->i_flag &= ~IN_ACCESS;
501 			ip->i_atime = vap->va_atime.tv_sec;
502 			ip->i_atimensec = vap->va_atime.tv_nsec;
503 		}
504 		if (vap->va_mtime.tv_sec != VNOVAL) {
505 			ip->i_flag &= ~IN_UPDATE;
506 			ip->i_mtime = vap->va_mtime.tv_sec;
507 			ip->i_mtimensec = vap->va_mtime.tv_nsec;
508 		}
509 		ip->i_birthtime = vap->va_birthtime.tv_sec;
510 		ip->i_birthnsec = vap->va_birthtime.tv_nsec;
511 		error = ext2_update(vp, 0);
512 		if (error)
513 			return (error);
514 	}
515 	error = 0;
516 	if (vap->va_mode != (mode_t)VNOVAL) {
517 		if (vp->v_mount->mnt_flag & MNT_RDONLY)
518 			return (EROFS);
519 		error = ext2_chmod(vp, (int)vap->va_mode, cred, td);
520 	}
521 	return (error);
522 }
523 
524 /*
525  * Change the mode on a file.
526  * Inode must be locked before calling.
527  */
528 static int
529 ext2_chmod(struct vnode *vp, int mode, struct ucred *cred, struct thread *td)
530 {
531 	struct inode *ip = VTOI(vp);
532 	int error;
533 
534 	/*
535 	 * To modify the permissions on a file, must possess VADMIN
536 	 * for that file.
537 	 */
538 	if ((error = VOP_ACCESS(vp, VADMIN, cred, td)))
539 		return (error);
540 	/*
541 	 * Privileged processes may set the sticky bit on non-directories,
542 	 * as well as set the setgid bit on a file with a group that the
543 	 * process is not a member of.
544 	 */
545 	if (vp->v_type != VDIR && (mode & S_ISTXT)) {
546 		error = priv_check_cred(cred, PRIV_VFS_STICKYFILE);
547 		if (error)
548 			return (EFTYPE);
549 	}
550 	if (!groupmember(ip->i_gid, cred) && (mode & ISGID)) {
551 		error = priv_check_cred(cred, PRIV_VFS_SETGID);
552 		if (error)
553 			return (error);
554 	}
555 	ip->i_mode &= ~ALLPERMS;
556 	ip->i_mode |= (mode & ALLPERMS);
557 	ip->i_flag |= IN_CHANGE;
558 	return (0);
559 }
560 
561 /*
562  * Perform chown operation on inode ip;
563  * inode must be locked prior to call.
564  */
565 static int
566 ext2_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred,
567     struct thread *td)
568 {
569 	struct inode *ip = VTOI(vp);
570 	uid_t ouid;
571 	gid_t ogid;
572 	int error = 0;
573 
574 	if (uid == (uid_t)VNOVAL)
575 		uid = ip->i_uid;
576 	if (gid == (gid_t)VNOVAL)
577 		gid = ip->i_gid;
578 	/*
579 	 * To modify the ownership of a file, must possess VADMIN
580 	 * for that file.
581 	 */
582 	if ((error = VOP_ACCESS(vp, VADMIN, cred, td)))
583 		return (error);
584 	/*
585 	 * To change the owner of a file, or change the group of a file
586 	 * to a group of which we are not a member, the caller must
587 	 * have privilege.
588 	 */
589 	if (uid != ip->i_uid || (gid != ip->i_gid &&
590 	    !groupmember(gid, cred))) {
591 		error = priv_check_cred(cred, PRIV_VFS_CHOWN);
592 		if (error)
593 			return (error);
594 	}
595 	ogid = ip->i_gid;
596 	ouid = ip->i_uid;
597 	ip->i_gid = gid;
598 	ip->i_uid = uid;
599 	ip->i_flag |= IN_CHANGE;
600 	if ((ip->i_mode & (ISUID | ISGID)) && (ouid != uid || ogid != gid)) {
601 		if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID) != 0)
602 			ip->i_mode &= ~(ISUID | ISGID);
603 	}
604 	return (0);
605 }
606 
607 /*
608  * Synch an open file.
609  */
610 /* ARGSUSED */
611 static int
612 ext2_fsync(struct vop_fsync_args *ap)
613 {
614 	/*
615 	 * Flush all dirty buffers associated with a vnode.
616 	 */
617 
618 	vop_stdfsync(ap);
619 
620 	return (ext2_update(ap->a_vp, ap->a_waitfor == MNT_WAIT));
621 }
622 
623 /*
624  * Mknod vnode call
625  */
626 /* ARGSUSED */
627 static int
628 ext2_mknod(struct vop_mknod_args *ap)
629 {
630 	struct vattr *vap = ap->a_vap;
631 	struct vnode **vpp = ap->a_vpp;
632 	struct inode *ip;
633 	ino_t ino;
634 	int error;
635 
636 	error = ext2_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
637 	    ap->a_dvp, vpp, ap->a_cnp);
638 	if (error)
639 		return (error);
640 	ip = VTOI(*vpp);
641 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
642 	if (vap->va_rdev != VNOVAL) {
643 		/*
644 		 * Want to be able to use this to make badblock
645 		 * inodes, so don't truncate the dev number.
646 		 */
647 		if (!(ip->i_flag & IN_E4EXTENTS))
648 			ip->i_rdev = vap->va_rdev;
649 	}
650 	/*
651 	 * Remove inode, then reload it through VFS_VGET so it is
652 	 * checked to see if it is an alias of an existing entry in
653 	 * the inode cache.	 XXX I don't believe this is necessary now.
654 	 */
655 	(*vpp)->v_type = VNON;
656 	ino = ip->i_number;	/* Save this before vgone() invalidates ip. */
657 	vgone(*vpp);
658 	vput(*vpp);
659 	error = VFS_VGET(ap->a_dvp->v_mount, ino, LK_EXCLUSIVE, vpp);
660 	if (error) {
661 		*vpp = NULL;
662 		return (error);
663 	}
664 	return (0);
665 }
666 
667 static int
668 ext2_remove(struct vop_remove_args *ap)
669 {
670 	struct inode *ip;
671 	struct vnode *vp = ap->a_vp;
672 	struct vnode *dvp = ap->a_dvp;
673 	int error;
674 
675 	ip = VTOI(vp);
676 	if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
677 	    (VTOI(dvp)->i_flags & APPEND)) {
678 		error = EPERM;
679 		goto out;
680 	}
681 	error = ext2_dirremove(dvp, ap->a_cnp);
682 	if (error == 0) {
683 		ip->i_nlink--;
684 		ip->i_flag |= IN_CHANGE;
685 	}
686 out:
687 	return (error);
688 }
689 
690 /*
691  * link vnode call
692  */
693 static int
694 ext2_link(struct vop_link_args *ap)
695 {
696 	struct vnode *vp = ap->a_vp;
697 	struct vnode *tdvp = ap->a_tdvp;
698 	struct componentname *cnp = ap->a_cnp;
699 	struct inode *ip;
700 	int error;
701 
702 #ifdef INVARIANTS
703 	if ((cnp->cn_flags & HASBUF) == 0)
704 		panic("ext2_link: no name");
705 #endif
706 	ip = VTOI(vp);
707 	if ((nlink_t)ip->i_nlink >= EXT4_LINK_MAX) {
708 		error = EMLINK;
709 		goto out;
710 	}
711 	if (ip->i_flags & (IMMUTABLE | APPEND)) {
712 		error = EPERM;
713 		goto out;
714 	}
715 	ip->i_nlink++;
716 	ip->i_flag |= IN_CHANGE;
717 	error = ext2_update(vp, !DOINGASYNC(vp));
718 	if (!error)
719 		error = ext2_direnter(ip, tdvp, cnp);
720 	if (error) {
721 		ip->i_nlink--;
722 		ip->i_flag |= IN_CHANGE;
723 	}
724 out:
725 	return (error);
726 }
727 
728 static int
729 ext2_inc_nlink(struct inode *ip)
730 {
731 
732 	ip->i_nlink++;
733 
734 	if (S_ISDIR(ip->i_mode) &&
735 	    EXT2_HAS_RO_COMPAT_FEATURE(ip->i_e2fs, EXT2F_ROCOMPAT_DIR_NLINK) &&
736 	    ip->i_nlink > 1) {
737 		if (ip->i_nlink >= EXT4_LINK_MAX || ip->i_nlink == 2)
738 			ip->i_nlink = 1;
739 	} else if (ip->i_nlink > EXT4_LINK_MAX) {
740 		ip->i_nlink--;
741 		return (EMLINK);
742 	}
743 
744 	return (0);
745 }
746 
747 static void
748 ext2_dec_nlink(struct inode *ip)
749 {
750 
751 	if (!S_ISDIR(ip->i_mode) || ip->i_nlink > 2)
752 		ip->i_nlink--;
753 }
754 
755 /*
756  * Rename system call.
757  * 	rename("foo", "bar");
758  * is essentially
759  *	unlink("bar");
760  *	link("foo", "bar");
761  *	unlink("foo");
762  * but ``atomically''.  Can't do full commit without saving state in the
763  * inode on disk which isn't feasible at this time.  Best we can do is
764  * always guarantee the target exists.
765  *
766  * Basic algorithm is:
767  *
768  * 1) Bump link count on source while we're linking it to the
769  *    target.  This also ensure the inode won't be deleted out
770  *    from underneath us while we work (it may be truncated by
771  *    a concurrent `trunc' or `open' for creation).
772  * 2) Link source to destination.  If destination already exists,
773  *    delete it first.
774  * 3) Unlink source reference to inode if still around. If a
775  *    directory was moved and the parent of the destination
776  *    is different from the source, patch the ".." entry in the
777  *    directory.
778  */
779 static int
780 ext2_rename(struct vop_rename_args *ap)
781 {
782 	struct vnode *tvp = ap->a_tvp;
783 	struct vnode *tdvp = ap->a_tdvp;
784 	struct vnode *fvp = ap->a_fvp;
785 	struct vnode *fdvp = ap->a_fdvp;
786 	struct componentname *tcnp = ap->a_tcnp;
787 	struct componentname *fcnp = ap->a_fcnp;
788 	struct inode *ip, *xp, *dp;
789 	struct dirtemplate *dirbuf;
790 	int doingdirectory = 0, oldparent = 0, newparent = 0;
791 	int error = 0;
792 	u_char namlen;
793 
794 #ifdef INVARIANTS
795 	if ((tcnp->cn_flags & HASBUF) == 0 ||
796 	    (fcnp->cn_flags & HASBUF) == 0)
797 		panic("ext2_rename: no name");
798 #endif
799 	/*
800 	 * Check for cross-device rename.
801 	 */
802 	if ((fvp->v_mount != tdvp->v_mount) ||
803 	    (tvp && (fvp->v_mount != tvp->v_mount))) {
804 		error = EXDEV;
805 abortit:
806 		if (tdvp == tvp)
807 			vrele(tdvp);
808 		else
809 			vput(tdvp);
810 		if (tvp)
811 			vput(tvp);
812 		vrele(fdvp);
813 		vrele(fvp);
814 		return (error);
815 	}
816 
817 	if (tvp && ((VTOI(tvp)->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
818 	    (VTOI(tdvp)->i_flags & APPEND))) {
819 		error = EPERM;
820 		goto abortit;
821 	}
822 
823 	/*
824 	 * Renaming a file to itself has no effect.  The upper layers should
825 	 * not call us in that case.  Temporarily just warn if they do.
826 	 */
827 	if (fvp == tvp) {
828 		SDT_PROBE2(ext2fs, , vnops, trace, 1,
829 		    "rename: fvp == tvp (can't happen)");
830 		error = 0;
831 		goto abortit;
832 	}
833 
834 	if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
835 		goto abortit;
836 	dp = VTOI(fdvp);
837 	ip = VTOI(fvp);
838 	if (ip->i_nlink >= EXT4_LINK_MAX &&
839 	    !EXT2_HAS_RO_COMPAT_FEATURE(ip->i_e2fs, EXT2F_ROCOMPAT_DIR_NLINK)) {
840 		VOP_UNLOCK(fvp);
841 		error = EMLINK;
842 		goto abortit;
843 	}
844 	if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))
845 	    || (dp->i_flags & APPEND)) {
846 		VOP_UNLOCK(fvp);
847 		error = EPERM;
848 		goto abortit;
849 	}
850 	if ((ip->i_mode & IFMT) == IFDIR) {
851 		/*
852 		 * Avoid ".", "..", and aliases of "." for obvious reasons.
853 		 */
854 		if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
855 		    dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT ||
856 		    (ip->i_flag & IN_RENAME)) {
857 			VOP_UNLOCK(fvp);
858 			error = EINVAL;
859 			goto abortit;
860 		}
861 		ip->i_flag |= IN_RENAME;
862 		oldparent = dp->i_number;
863 		doingdirectory++;
864 	}
865 	vrele(fdvp);
866 
867 	/*
868 	 * When the target exists, both the directory
869 	 * and target vnodes are returned locked.
870 	 */
871 	dp = VTOI(tdvp);
872 	xp = NULL;
873 	if (tvp)
874 		xp = VTOI(tvp);
875 
876 	/*
877 	 * 1) Bump link count while we're moving stuff
878 	 *    around.  If we crash somewhere before
879 	 *    completing our work, the link count
880 	 *    may be wrong, but correctable.
881 	 */
882 	ext2_inc_nlink(ip);
883 	ip->i_flag |= IN_CHANGE;
884 	if ((error = ext2_update(fvp, !DOINGASYNC(fvp))) != 0) {
885 		VOP_UNLOCK(fvp);
886 		goto bad;
887 	}
888 
889 	/*
890 	 * If ".." must be changed (ie the directory gets a new
891 	 * parent) then the source directory must not be in the
892 	 * directory hierarchy above the target, as this would
893 	 * orphan everything below the source directory. Also
894 	 * the user must have write permission in the source so
895 	 * as to be able to change "..". We must repeat the call
896 	 * to namei, as the parent directory is unlocked by the
897 	 * call to checkpath().
898 	 */
899 	error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread);
900 	VOP_UNLOCK(fvp);
901 	if (oldparent != dp->i_number)
902 		newparent = dp->i_number;
903 	if (doingdirectory && newparent) {
904 		if (error)	/* write access check above */
905 			goto bad;
906 		if (xp != NULL)
907 			vput(tvp);
908 		error = ext2_checkpath(ip, dp, tcnp->cn_cred);
909 		if (error)
910 			goto out;
911 		VREF(tdvp);
912 		error = relookup(tdvp, &tvp, tcnp);
913 		if (error)
914 			goto out;
915 		vrele(tdvp);
916 		dp = VTOI(tdvp);
917 		xp = NULL;
918 		if (tvp)
919 			xp = VTOI(tvp);
920 	}
921 	/*
922 	 * 2) If target doesn't exist, link the target
923 	 *    to the source and unlink the source.
924 	 *    Otherwise, rewrite the target directory
925 	 *    entry to reference the source inode and
926 	 *    expunge the original entry's existence.
927 	 */
928 	if (xp == NULL) {
929 		if (dp->i_devvp != ip->i_devvp)
930 			panic("ext2_rename: EXDEV");
931 		/*
932 		 * Account for ".." in new directory.
933 		 * When source and destination have the same
934 		 * parent we don't fool with the link count.
935 		 */
936 		if (doingdirectory && newparent) {
937 			error = ext2_inc_nlink(dp);
938 			if (error)
939 				goto bad;
940 
941 			dp->i_flag |= IN_CHANGE;
942 			error = ext2_update(tdvp, !DOINGASYNC(tdvp));
943 			if (error)
944 				goto bad;
945 		}
946 		error = ext2_direnter(ip, tdvp, tcnp);
947 		if (error) {
948 			if (doingdirectory && newparent) {
949 				ext2_dec_nlink(dp);
950 				dp->i_flag |= IN_CHANGE;
951 				(void)ext2_update(tdvp, 1);
952 			}
953 			goto bad;
954 		}
955 		vput(tdvp);
956 	} else {
957 		if (xp->i_devvp != dp->i_devvp || xp->i_devvp != ip->i_devvp)
958 			panic("ext2_rename: EXDEV");
959 		/*
960 		 * Short circuit rename(foo, foo).
961 		 */
962 		if (xp->i_number == ip->i_number)
963 			panic("ext2_rename: same file");
964 		/*
965 		 * If the parent directory is "sticky", then the user must
966 		 * own the parent directory, or the destination of the rename,
967 		 * otherwise the destination may not be changed (except by
968 		 * root). This implements append-only directories.
969 		 */
970 		if ((dp->i_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 &&
971 		    tcnp->cn_cred->cr_uid != dp->i_uid &&
972 		    xp->i_uid != tcnp->cn_cred->cr_uid) {
973 			error = EPERM;
974 			goto bad;
975 		}
976 		/*
977 		 * Target must be empty if a directory and have no links
978 		 * to it. Also, ensure source and target are compatible
979 		 * (both directories, or both not directories).
980 		 */
981 		if ((xp->i_mode & IFMT) == IFDIR) {
982 			if (!ext2_dirempty(xp, dp->i_number, tcnp->cn_cred)) {
983 				error = ENOTEMPTY;
984 				goto bad;
985 			}
986 			if (!doingdirectory) {
987 				error = ENOTDIR;
988 				goto bad;
989 			}
990 			cache_purge(tdvp);
991 		} else if (doingdirectory) {
992 			error = EISDIR;
993 			goto bad;
994 		}
995 		error = ext2_dirrewrite(dp, ip, tcnp);
996 		if (error)
997 			goto bad;
998 		/*
999 		 * If the target directory is in the same
1000 		 * directory as the source directory,
1001 		 * decrement the link count on the parent
1002 		 * of the target directory.
1003 		 */
1004 		if (doingdirectory && !newparent) {
1005 			ext2_dec_nlink(dp);
1006 			dp->i_flag |= IN_CHANGE;
1007 		}
1008 		vput(tdvp);
1009 		/*
1010 		 * Adjust the link count of the target to
1011 		 * reflect the dirrewrite above.  If this is
1012 		 * a directory it is empty and there are
1013 		 * no links to it, so we can squash the inode and
1014 		 * any space associated with it.  We disallowed
1015 		 * renaming over top of a directory with links to
1016 		 * it above, as the remaining link would point to
1017 		 * a directory without "." or ".." entries.
1018 		 */
1019 		ext2_dec_nlink(xp);
1020 		if (doingdirectory) {
1021 			if (xp->i_nlink > 2)
1022 				panic("ext2_rename: linked directory");
1023 			error = ext2_truncate(tvp, (off_t)0, IO_SYNC,
1024 			    tcnp->cn_cred, tcnp->cn_thread);
1025 			xp->i_nlink = 0;
1026 		}
1027 		xp->i_flag |= IN_CHANGE;
1028 		vput(tvp);
1029 		xp = NULL;
1030 	}
1031 
1032 	/*
1033 	 * 3) Unlink the source.
1034 	 */
1035 	fcnp->cn_flags &= ~MODMASK;
1036 	fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
1037 	VREF(fdvp);
1038 	error = relookup(fdvp, &fvp, fcnp);
1039 	if (error == 0)
1040 		vrele(fdvp);
1041 	if (fvp != NULL) {
1042 		xp = VTOI(fvp);
1043 		dp = VTOI(fdvp);
1044 	} else {
1045 		/*
1046 		 * From name has disappeared.  IN_RENAME is not sufficient
1047 		 * to protect against directory races due to timing windows,
1048 		 * so we can't panic here.
1049 		 */
1050 		vrele(ap->a_fvp);
1051 		return (0);
1052 	}
1053 	/*
1054 	 * Ensure that the directory entry still exists and has not
1055 	 * changed while the new name has been entered. If the source is
1056 	 * a file then the entry may have been unlinked or renamed. In
1057 	 * either case there is no further work to be done. If the source
1058 	 * is a directory then it cannot have been rmdir'ed; its link
1059 	 * count of three would cause a rmdir to fail with ENOTEMPTY.
1060 	 * The IN_RENAME flag ensures that it cannot be moved by another
1061 	 * rename.
1062 	 */
1063 	if (xp != ip) {
1064 		/*
1065 		 * From name resolves to a different inode.  IN_RENAME is
1066 		 * not sufficient protection against timing window races
1067 		 * so we can't panic here.
1068 		 */
1069 	} else {
1070 		/*
1071 		 * If the source is a directory with a
1072 		 * new parent, the link count of the old
1073 		 * parent directory must be decremented
1074 		 * and ".." set to point to the new parent.
1075 		 */
1076 		if (doingdirectory && newparent) {
1077 			ext2_dec_nlink(dp);
1078 			dp->i_flag |= IN_CHANGE;
1079 			dirbuf = malloc(dp->i_e2fs->e2fs_bsize, M_TEMP, M_WAITOK | M_ZERO);
1080 			if (!dirbuf) {
1081 				error = ENOMEM;
1082 				goto bad;
1083 			}
1084 			error = vn_rdwr(UIO_READ, fvp, (caddr_t)dirbuf,
1085 			    ip->i_e2fs->e2fs_bsize, (off_t)0,
1086 			    UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK,
1087 			    tcnp->cn_cred, NOCRED, NULL, NULL);
1088 			if (error == 0) {
1089 				/* Like ufs little-endian: */
1090 				namlen = dirbuf->dotdot_type;
1091 				if (namlen != 2 ||
1092 				    dirbuf->dotdot_name[0] != '.' ||
1093 				    dirbuf->dotdot_name[1] != '.') {
1094 					ext2_dirbad(xp, (doff_t)12,
1095 					    "rename: mangled dir");
1096 				} else {
1097 					dirbuf->dotdot_ino = newparent;
1098 					/*
1099 					 * dirblock 0 could be htree root,
1100 					 * try both csum update functions.
1101 					 */
1102 					ext2_dirent_csum_set(ip,
1103 					    (struct ext2fs_direct_2 *)dirbuf);
1104 					ext2_dx_csum_set(ip,
1105 					    (struct ext2fs_direct_2 *)dirbuf);
1106 					(void)vn_rdwr(UIO_WRITE, fvp,
1107 					    (caddr_t)dirbuf,
1108 					    ip->i_e2fs->e2fs_bsize,
1109 					    (off_t)0, UIO_SYSSPACE,
1110 					    IO_NODELOCKED | IO_SYNC |
1111 					    IO_NOMACCHECK, tcnp->cn_cred,
1112 					    NOCRED, NULL, NULL);
1113 					cache_purge(fdvp);
1114 				}
1115 			}
1116 			free(dirbuf, M_TEMP);
1117 		}
1118 		error = ext2_dirremove(fdvp, fcnp);
1119 		if (!error) {
1120 			ext2_dec_nlink(xp);
1121 			xp->i_flag |= IN_CHANGE;
1122 		}
1123 		xp->i_flag &= ~IN_RENAME;
1124 	}
1125 	if (dp)
1126 		vput(fdvp);
1127 	if (xp)
1128 		vput(fvp);
1129 	vrele(ap->a_fvp);
1130 	return (error);
1131 
1132 bad:
1133 	if (xp)
1134 		vput(ITOV(xp));
1135 	vput(ITOV(dp));
1136 out:
1137 	if (doingdirectory)
1138 		ip->i_flag &= ~IN_RENAME;
1139 	if (vn_lock(fvp, LK_EXCLUSIVE) == 0) {
1140 		ext2_dec_nlink(ip);
1141 		ip->i_flag |= IN_CHANGE;
1142 		ip->i_flag &= ~IN_RENAME;
1143 		vput(fvp);
1144 	} else
1145 		vrele(fvp);
1146 	return (error);
1147 }
1148 
1149 #ifdef UFS_ACL
1150 static int
1151 ext2_do_posix1e_acl_inheritance_dir(struct vnode *dvp, struct vnode *tvp,
1152     mode_t dmode, struct ucred *cred, struct thread *td)
1153 {
1154 	int error;
1155 	struct inode *ip = VTOI(tvp);
1156 	struct acl *dacl, *acl;
1157 
1158 	acl = acl_alloc(M_WAITOK);
1159 	dacl = acl_alloc(M_WAITOK);
1160 
1161 	/*
1162 	 * Retrieve default ACL from parent, if any.
1163 	 */
1164 	error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cred, td);
1165 	switch (error) {
1166 	case 0:
1167 		/*
1168 		 * Retrieved a default ACL, so merge mode and ACL if
1169 		 * necessary.  If the ACL is empty, fall through to
1170 		 * the "not defined or available" case.
1171 		 */
1172 		if (acl->acl_cnt != 0) {
1173 			dmode = acl_posix1e_newfilemode(dmode, acl);
1174 			ip->i_mode = dmode;
1175 			*dacl = *acl;
1176 			ext2_sync_acl_from_inode(ip, acl);
1177 			break;
1178 		}
1179 		/* FALLTHROUGH */
1180 
1181 	case EOPNOTSUPP:
1182 		/*
1183 		 * Just use the mode as-is.
1184 		 */
1185 		ip->i_mode = dmode;
1186 		error = 0;
1187 		goto out;
1188 
1189 	default:
1190 		goto out;
1191 	}
1192 
1193 	error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cred, td);
1194 	if (error == 0)
1195 		error = VOP_SETACL(tvp, ACL_TYPE_DEFAULT, dacl, cred, td);
1196 	switch (error) {
1197 	case 0:
1198 		break;
1199 
1200 	case EOPNOTSUPP:
1201 		/*
1202 		 * XXX: This should not happen, as EOPNOTSUPP above
1203 		 * was supposed to free acl.
1204 		 */
1205 #ifdef DEBUG
1206 		printf("ext2_mkdir: VOP_GETACL() but no VOP_SETACL()\n");
1207 #endif	/* DEBUG */
1208 		break;
1209 
1210 	default:
1211 		goto out;
1212 	}
1213 
1214 out:
1215 	acl_free(acl);
1216 	acl_free(dacl);
1217 
1218 	return (error);
1219 }
1220 
1221 static int
1222 ext2_do_posix1e_acl_inheritance_file(struct vnode *dvp, struct vnode *tvp,
1223     mode_t mode, struct ucred *cred, struct thread *td)
1224 {
1225 	int error;
1226 	struct inode *ip = VTOI(tvp);
1227 	struct acl *acl;
1228 
1229 	acl = acl_alloc(M_WAITOK);
1230 
1231 	/*
1232 	 * Retrieve default ACL for parent, if any.
1233 	 */
1234 	error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cred, td);
1235 	switch (error) {
1236 	case 0:
1237 		/*
1238 		 * Retrieved a default ACL, so merge mode and ACL if
1239 		 * necessary.
1240 		 */
1241 		if (acl->acl_cnt != 0) {
1242 			/*
1243 			 * Two possible ways for default ACL to not
1244 			 * be present.  First, the EA can be
1245 			 * undefined, or second, the default ACL can
1246 			 * be blank.  If it's blank, fall through to
1247 			 * the it's not defined case.
1248 			 */
1249 			mode = acl_posix1e_newfilemode(mode, acl);
1250 			ip->i_mode = mode;
1251 			ext2_sync_acl_from_inode(ip, acl);
1252 			break;
1253 		}
1254 		/* FALLTHROUGH */
1255 
1256 	case EOPNOTSUPP:
1257 		/*
1258 		 * Just use the mode as-is.
1259 		 */
1260 		ip->i_mode = mode;
1261 		error = 0;
1262 		goto out;
1263 
1264 	default:
1265 		goto out;
1266 	}
1267 
1268 	error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cred, td);
1269 	switch (error) {
1270 	case 0:
1271 		break;
1272 
1273 	case EOPNOTSUPP:
1274 		/*
1275 		 * XXX: This should not happen, as EOPNOTSUPP above was
1276 		 * supposed to free acl.
1277 		 */
1278 		printf("ufs_do_posix1e_acl_inheritance_file: VOP_GETACL() "
1279 		    "but no VOP_SETACL()\n");
1280 		/* panic("ufs_do_posix1e_acl_inheritance_file: VOP_GETACL() "
1281 		    "but no VOP_SETACL()"); */
1282 		break;
1283 
1284 	default:
1285 		goto out;
1286 	}
1287 
1288 out:
1289 	acl_free(acl);
1290 
1291 	return (error);
1292 }
1293 
1294 #endif /* UFS_ACL */
1295 
1296 /*
1297  * Mkdir system call
1298  */
1299 static int
1300 ext2_mkdir(struct vop_mkdir_args *ap)
1301 {
1302 	struct m_ext2fs *fs;
1303 	struct vnode *dvp = ap->a_dvp;
1304 	struct vattr *vap = ap->a_vap;
1305 	struct componentname *cnp = ap->a_cnp;
1306 	struct inode *ip, *dp;
1307 	struct vnode *tvp;
1308 	struct dirtemplate dirtemplate, *dtp;
1309 	char *buf = NULL;
1310 	int error, dmode;
1311 
1312 #ifdef INVARIANTS
1313 	if ((cnp->cn_flags & HASBUF) == 0)
1314 		panic("ext2_mkdir: no name");
1315 #endif
1316 	dp = VTOI(dvp);
1317 	if ((nlink_t)dp->i_nlink >= EXT4_LINK_MAX &&
1318 	    !EXT2_HAS_RO_COMPAT_FEATURE(dp->i_e2fs, EXT2F_ROCOMPAT_DIR_NLINK)) {
1319 		error = EMLINK;
1320 		goto out;
1321 	}
1322 	dmode = vap->va_mode & 0777;
1323 	dmode |= IFDIR;
1324 	/*
1325 	 * Must simulate part of ext2_makeinode here to acquire the inode,
1326 	 * but not have it entered in the parent directory. The entry is
1327 	 * made later after writing "." and ".." entries.
1328 	 */
1329 	error = ext2_valloc(dvp, dmode, cnp->cn_cred, &tvp);
1330 	if (error)
1331 		goto out;
1332 	ip = VTOI(tvp);
1333 	fs = ip->i_e2fs;
1334 	ip->i_gid = dp->i_gid;
1335 #ifdef SUIDDIR
1336 	{
1337 		/*
1338 		 * if we are hacking owners here, (only do this where told to)
1339 		 * and we are not giving it TOO root, (would subvert quotas)
1340 		 * then go ahead and give it to the other user.
1341 		 * The new directory also inherits the SUID bit.
1342 		 * If user's UID and dir UID are the same,
1343 		 * 'give it away' so that the SUID is still forced on.
1344 		 */
1345 		if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
1346 		    (dp->i_mode & ISUID) && dp->i_uid) {
1347 			dmode |= ISUID;
1348 			ip->i_uid = dp->i_uid;
1349 		} else {
1350 			ip->i_uid = cnp->cn_cred->cr_uid;
1351 		}
1352 	}
1353 #else
1354 	ip->i_uid = cnp->cn_cred->cr_uid;
1355 #endif
1356 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1357 	ip->i_mode = dmode;
1358 	tvp->v_type = VDIR;	/* Rest init'd in getnewvnode(). */
1359 	ip->i_nlink = 2;
1360 	if (cnp->cn_flags & ISWHITEOUT)
1361 		ip->i_flags |= UF_OPAQUE;
1362 	error = ext2_update(tvp, 1);
1363 
1364 	/*
1365 	 * Bump link count in parent directory
1366 	 * to reflect work done below.  Should
1367 	 * be done before reference is created
1368 	 * so reparation is possible if we crash.
1369 	 */
1370 	ext2_inc_nlink(dp);
1371 	dp->i_flag |= IN_CHANGE;
1372 	error = ext2_update(dvp, !DOINGASYNC(dvp));
1373 	if (error)
1374 		goto bad;
1375 
1376 	/* Initialize directory with "." and ".." from static template. */
1377 	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs,
1378 	    EXT2F_INCOMPAT_FTYPE))
1379 		dtp = &mastertemplate;
1380 	else
1381 		dtp = &omastertemplate;
1382 	dirtemplate = *dtp;
1383 	dirtemplate.dot_ino = ip->i_number;
1384 	dirtemplate.dotdot_ino = dp->i_number;
1385 	/*
1386 	 * note that in ext2 DIRBLKSIZ == blocksize, not DEV_BSIZE so let's
1387 	 * just redefine it - for this function only
1388 	 */
1389 #undef  DIRBLKSIZ
1390 #define DIRBLKSIZ  VTOI(dvp)->i_e2fs->e2fs_bsize
1391 	dirtemplate.dotdot_reclen = DIRBLKSIZ - 12;
1392 	buf = malloc(DIRBLKSIZ, M_TEMP, M_WAITOK | M_ZERO);
1393 	if (!buf) {
1394 		error = ENOMEM;
1395 		ext2_dec_nlink(dp);
1396 		dp->i_flag |= IN_CHANGE;
1397 		goto bad;
1398 	}
1399 	if (EXT2_HAS_RO_COMPAT_FEATURE(fs, EXT2F_ROCOMPAT_METADATA_CKSUM)) {
1400 		dirtemplate.dotdot_reclen -= sizeof(struct ext2fs_direct_tail);
1401 		ext2_init_dirent_tail(EXT2_DIRENT_TAIL(buf, DIRBLKSIZ));
1402 	}
1403 	memcpy(buf, &dirtemplate, sizeof(dirtemplate));
1404 	ext2_dirent_csum_set(ip, (struct ext2fs_direct_2 *)buf);
1405 	error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)buf,
1406 	    DIRBLKSIZ, (off_t)0, UIO_SYSSPACE,
1407 	    IO_NODELOCKED | IO_SYNC | IO_NOMACCHECK, cnp->cn_cred, NOCRED,
1408 	    NULL, NULL);
1409 	if (error) {
1410 		ext2_dec_nlink(dp);
1411 		dp->i_flag |= IN_CHANGE;
1412 		goto bad;
1413 	}
1414 	if (DIRBLKSIZ > VFSTOEXT2(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
1415 		/* XXX should grow with balloc() */
1416 		panic("ext2_mkdir: blksize");
1417 	else {
1418 		ip->i_size = DIRBLKSIZ;
1419 		ip->i_flag |= IN_CHANGE;
1420 	}
1421 
1422 #ifdef UFS_ACL
1423 	if (dvp->v_mount->mnt_flag & MNT_ACLS) {
1424 		error = ext2_do_posix1e_acl_inheritance_dir(dvp, tvp, dmode,
1425 		    cnp->cn_cred, cnp->cn_thread);
1426 		if (error)
1427 			goto bad;
1428 	}
1429 
1430 #endif /* UFS_ACL */
1431 
1432 	/* Directory set up, now install its entry in the parent directory. */
1433 	error = ext2_direnter(ip, dvp, cnp);
1434 	if (error) {
1435 		ext2_dec_nlink(dp);
1436 		dp->i_flag |= IN_CHANGE;
1437 	}
1438 bad:
1439 	/*
1440 	 * No need to do an explicit VOP_TRUNCATE here, vrele will do this
1441 	 * for us because we set the link count to 0.
1442 	 */
1443 	if (error) {
1444 		ip->i_nlink = 0;
1445 		ip->i_flag |= IN_CHANGE;
1446 		vput(tvp);
1447 	} else
1448 		*ap->a_vpp = tvp;
1449 out:
1450 	free(buf, M_TEMP);
1451 	return (error);
1452 #undef  DIRBLKSIZ
1453 #define DIRBLKSIZ  DEV_BSIZE
1454 }
1455 
1456 /*
1457  * Rmdir system call.
1458  */
1459 static int
1460 ext2_rmdir(struct vop_rmdir_args *ap)
1461 {
1462 	struct vnode *vp = ap->a_vp;
1463 	struct vnode *dvp = ap->a_dvp;
1464 	struct componentname *cnp = ap->a_cnp;
1465 	struct inode *ip, *dp;
1466 	int error;
1467 
1468 	ip = VTOI(vp);
1469 	dp = VTOI(dvp);
1470 
1471 	/*
1472 	 * Verify the directory is empty (and valid).
1473 	 * (Rmdir ".." won't be valid since
1474 	 *  ".." will contain a reference to
1475 	 *  the current directory and thus be
1476 	 *  non-empty.)
1477 	 */
1478 	if (!ext2_dirempty(ip, dp->i_number, cnp->cn_cred)) {
1479 		error = ENOTEMPTY;
1480 		goto out;
1481 	}
1482 	if ((dp->i_flags & APPEND)
1483 	    || (ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
1484 		error = EPERM;
1485 		goto out;
1486 	}
1487 	/*
1488 	 * Delete reference to directory before purging
1489 	 * inode.  If we crash in between, the directory
1490 	 * will be reattached to lost+found,
1491 	 */
1492 	error = ext2_dirremove(dvp, cnp);
1493 	if (error)
1494 		goto out;
1495 	ext2_dec_nlink(dp);
1496 	dp->i_flag |= IN_CHANGE;
1497 	cache_purge(dvp);
1498 	VOP_UNLOCK(dvp);
1499 	/*
1500 	 * Truncate inode.  The only stuff left
1501 	 * in the directory is "." and "..".
1502 	 */
1503 	ip->i_nlink = 0;
1504 	error = ext2_truncate(vp, (off_t)0, IO_SYNC, cnp->cn_cred,
1505 	    cnp->cn_thread);
1506 	cache_purge(ITOV(ip));
1507 	if (vn_lock(dvp, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
1508 		VOP_UNLOCK(vp);
1509 		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
1510 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1511 	}
1512 out:
1513 	return (error);
1514 }
1515 
1516 /*
1517  * symlink -- make a symbolic link
1518  */
1519 static int
1520 ext2_symlink(struct vop_symlink_args *ap)
1521 {
1522 	struct vnode *vp, **vpp = ap->a_vpp;
1523 	struct inode *ip;
1524 	int len, error;
1525 
1526 	error = ext2_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
1527 	    vpp, ap->a_cnp);
1528 	if (error)
1529 		return (error);
1530 	vp = *vpp;
1531 	len = strlen(ap->a_target);
1532 	if (len < vp->v_mount->mnt_maxsymlinklen) {
1533 		ip = VTOI(vp);
1534 		bcopy(ap->a_target, (char *)ip->i_shortlink, len);
1535 		ip->i_size = len;
1536 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
1537 	} else
1538 		error = vn_rdwr(UIO_WRITE, vp, __DECONST(void *, ap->a_target),
1539 		    len, (off_t)0, UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK,
1540 		    ap->a_cnp->cn_cred, NOCRED, NULL, NULL);
1541 	if (error)
1542 		vput(vp);
1543 	return (error);
1544 }
1545 
1546 /*
1547  * Return target name of a symbolic link
1548  */
1549 static int
1550 ext2_readlink(struct vop_readlink_args *ap)
1551 {
1552 	struct vnode *vp = ap->a_vp;
1553 	struct inode *ip = VTOI(vp);
1554 	int isize;
1555 
1556 	isize = ip->i_size;
1557 	if (isize < vp->v_mount->mnt_maxsymlinklen) {
1558 		uiomove((char *)ip->i_shortlink, isize, ap->a_uio);
1559 		return (0);
1560 	}
1561 	return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
1562 }
1563 
1564 /*
1565  * Calculate the logical to physical mapping if not done already,
1566  * then call the device strategy routine.
1567  *
1568  * In order to be able to swap to a file, the ext2_bmaparray() operation may not
1569  * deadlock on memory.  See ext2_bmap() for details.
1570  */
1571 static int
1572 ext2_strategy(struct vop_strategy_args *ap)
1573 {
1574 	struct buf *bp = ap->a_bp;
1575 	struct vnode *vp = ap->a_vp;
1576 	struct bufobj *bo;
1577 	daddr_t blkno;
1578 	int error;
1579 
1580 	if (vp->v_type == VBLK || vp->v_type == VCHR)
1581 		panic("ext2_strategy: spec");
1582 	if (bp->b_blkno == bp->b_lblkno) {
1583 
1584 		if (VTOI(ap->a_vp)->i_flag & IN_E4EXTENTS)
1585 			error = ext4_bmapext(vp, bp->b_lblkno, &blkno, NULL, NULL);
1586 		else
1587 			error = ext2_bmaparray(vp, bp->b_lblkno, &blkno, NULL, NULL);
1588 
1589 		bp->b_blkno = blkno;
1590 		if (error) {
1591 			bp->b_error = error;
1592 			bp->b_ioflags |= BIO_ERROR;
1593 			bufdone(bp);
1594 			return (0);
1595 		}
1596 		if ((long)bp->b_blkno == -1)
1597 			vfs_bio_clrbuf(bp);
1598 	}
1599 	if ((long)bp->b_blkno == -1) {
1600 		bufdone(bp);
1601 		return (0);
1602 	}
1603 	bp->b_iooffset = dbtob(bp->b_blkno);
1604 	bo = VFSTOEXT2(vp->v_mount)->um_bo;
1605 	BO_STRATEGY(bo, bp);
1606 	return (0);
1607 }
1608 
1609 /*
1610  * Print out the contents of an inode.
1611  */
1612 static int
1613 ext2_print(struct vop_print_args *ap)
1614 {
1615 	struct vnode *vp = ap->a_vp;
1616 	struct inode *ip = VTOI(vp);
1617 
1618 	vn_printf(ip->i_devvp, "\tino %ju", (uintmax_t)ip->i_number);
1619 	if (vp->v_type == VFIFO)
1620 		fifo_printinfo(vp);
1621 	printf("\n");
1622 	return (0);
1623 }
1624 
1625 /*
1626  * Close wrapper for fifos.
1627  *
1628  * Update the times on the inode then do device close.
1629  */
1630 static int
1631 ext2fifo_close(struct vop_close_args *ap)
1632 {
1633 	struct vnode *vp = ap->a_vp;
1634 
1635 	VI_LOCK(vp);
1636 	if (vp->v_usecount > 1)
1637 		ext2_itimes_locked(vp);
1638 	VI_UNLOCK(vp);
1639 	return (fifo_specops.vop_close(ap));
1640 }
1641 
1642 /*
1643  * Kqfilter wrapper for fifos.
1644  *
1645  * Fall through to ext2 kqfilter routines if needed
1646  */
1647 static int
1648 ext2fifo_kqfilter(struct vop_kqfilter_args *ap)
1649 {
1650 	int error;
1651 
1652 	error = fifo_specops.vop_kqfilter(ap);
1653 	if (error)
1654 		error = vfs_kqfilter(ap);
1655 	return (error);
1656 }
1657 
1658 /*
1659  * Return POSIX pathconf information applicable to ext2 filesystems.
1660  */
1661 static int
1662 ext2_pathconf(struct vop_pathconf_args *ap)
1663 {
1664 	int error = 0;
1665 
1666 	switch (ap->a_name) {
1667 	case _PC_LINK_MAX:
1668 		if (EXT2_HAS_RO_COMPAT_FEATURE(VTOI(ap->a_vp)->i_e2fs,
1669 		    EXT2F_ROCOMPAT_DIR_NLINK))
1670 			*ap->a_retval = INT_MAX;
1671 		else
1672 			*ap->a_retval = EXT4_LINK_MAX;
1673 		break;
1674 	case _PC_NAME_MAX:
1675 		*ap->a_retval = NAME_MAX;
1676 		break;
1677 	case _PC_PIPE_BUF:
1678 		if (ap->a_vp->v_type == VDIR || ap->a_vp->v_type == VFIFO)
1679 			*ap->a_retval = PIPE_BUF;
1680 		else
1681 			error = EINVAL;
1682 		break;
1683 	case _PC_CHOWN_RESTRICTED:
1684 		*ap->a_retval = 1;
1685 		break;
1686 	case _PC_NO_TRUNC:
1687 		*ap->a_retval = 1;
1688 		break;
1689 
1690 #ifdef UFS_ACL
1691 	case _PC_ACL_EXTENDED:
1692 		if (ap->a_vp->v_mount->mnt_flag & MNT_ACLS)
1693 			*ap->a_retval = 1;
1694 		else
1695 			*ap->a_retval = 0;
1696 		break;
1697 	case _PC_ACL_PATH_MAX:
1698 		if (ap->a_vp->v_mount->mnt_flag & MNT_ACLS)
1699 			*ap->a_retval = ACL_MAX_ENTRIES;
1700 		else
1701 			*ap->a_retval = 3;
1702 		break;
1703 #endif /* UFS_ACL */
1704 
1705 	case _PC_MIN_HOLE_SIZE:
1706 		*ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
1707 		break;
1708 	case _PC_PRIO_IO:
1709 		*ap->a_retval = 0;
1710 		break;
1711 	case _PC_SYNC_IO:
1712 		*ap->a_retval = 0;
1713 		break;
1714 	case _PC_ALLOC_SIZE_MIN:
1715 		*ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_bsize;
1716 		break;
1717 	case _PC_FILESIZEBITS:
1718 		*ap->a_retval = 64;
1719 		break;
1720 	case _PC_REC_INCR_XFER_SIZE:
1721 		*ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
1722 		break;
1723 	case _PC_REC_MAX_XFER_SIZE:
1724 		*ap->a_retval = -1;	/* means ``unlimited'' */
1725 		break;
1726 	case _PC_REC_MIN_XFER_SIZE:
1727 		*ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
1728 		break;
1729 	case _PC_REC_XFER_ALIGN:
1730 		*ap->a_retval = PAGE_SIZE;
1731 		break;
1732 	case _PC_SYMLINK_MAX:
1733 		*ap->a_retval = MAXPATHLEN;
1734 		break;
1735 
1736 	default:
1737 		error = vop_stdpathconf(ap);
1738 		break;
1739 	}
1740 	return (error);
1741 }
1742 
1743 /*
1744  * Vnode operation to remove a named attribute.
1745  */
1746 static int
1747 ext2_deleteextattr(struct vop_deleteextattr_args *ap)
1748 {
1749 	struct inode *ip;
1750 	struct m_ext2fs *fs;
1751 	int error;
1752 
1753 	ip = VTOI(ap->a_vp);
1754 	fs = ip->i_e2fs;
1755 
1756 	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
1757 		return (EOPNOTSUPP);
1758 
1759 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1760 		return (EOPNOTSUPP);
1761 
1762 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1763 	    ap->a_cred, ap->a_td, VWRITE);
1764 	if (error)
1765 		return (error);
1766 
1767 	error = ENOATTR;
1768 
1769 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
1770 		error = ext2_extattr_inode_delete(ip, ap->a_attrnamespace, ap->a_name);
1771 		if (error != ENOATTR)
1772 			return (error);
1773 	}
1774 
1775 	if (ip->i_facl)
1776 		error = ext2_extattr_block_delete(ip, ap->a_attrnamespace, ap->a_name);
1777 
1778 	return (error);
1779 }
1780 
1781 /*
1782  * Vnode operation to retrieve a named extended attribute.
1783  */
1784 static int
1785 ext2_getextattr(struct vop_getextattr_args *ap)
1786 {
1787 	struct inode *ip;
1788 	struct m_ext2fs *fs;
1789 	int error;
1790 
1791 	ip = VTOI(ap->a_vp);
1792 	fs = ip->i_e2fs;
1793 
1794 	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
1795 		return (EOPNOTSUPP);
1796 
1797 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1798 		return (EOPNOTSUPP);
1799 
1800 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1801 	    ap->a_cred, ap->a_td, VREAD);
1802 	if (error)
1803 		return (error);
1804 
1805 	if (ap->a_size != NULL)
1806 		*ap->a_size = 0;
1807 
1808 	error = ENOATTR;
1809 
1810 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
1811 		error = ext2_extattr_inode_get(ip, ap->a_attrnamespace,
1812 		    ap->a_name, ap->a_uio, ap->a_size);
1813 		if (error != ENOATTR)
1814 			return (error);
1815 	}
1816 
1817 	if (ip->i_facl)
1818 		error = ext2_extattr_block_get(ip, ap->a_attrnamespace,
1819 		    ap->a_name, ap->a_uio, ap->a_size);
1820 
1821 	return (error);
1822 }
1823 
1824 /*
1825  * Vnode operation to retrieve extended attributes on a vnode.
1826  */
1827 static int
1828 ext2_listextattr(struct vop_listextattr_args *ap)
1829 {
1830 	struct inode *ip;
1831 	struct m_ext2fs *fs;
1832 	int error;
1833 
1834 	ip = VTOI(ap->a_vp);
1835 	fs = ip->i_e2fs;
1836 
1837 	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
1838 		return (EOPNOTSUPP);
1839 
1840 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1841 		return (EOPNOTSUPP);
1842 
1843 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1844 	    ap->a_cred, ap->a_td, VREAD);
1845 	if (error)
1846 		return (error);
1847 
1848 	if (ap->a_size != NULL)
1849 		*ap->a_size = 0;
1850 
1851 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
1852 		error = ext2_extattr_inode_list(ip, ap->a_attrnamespace,
1853 		    ap->a_uio, ap->a_size);
1854 		if (error)
1855 			return (error);
1856 	}
1857 
1858 	if (ip->i_facl)
1859 		error = ext2_extattr_block_list(ip, ap->a_attrnamespace,
1860 		    ap->a_uio, ap->a_size);
1861 
1862 	return (error);
1863 }
1864 
1865 /*
1866  * Vnode operation to set a named attribute.
1867  */
1868 static int
1869 ext2_setextattr(struct vop_setextattr_args *ap)
1870 {
1871 	struct inode *ip;
1872 	struct m_ext2fs *fs;
1873 	int error;
1874 
1875 	ip = VTOI(ap->a_vp);
1876 	fs = ip->i_e2fs;
1877 
1878 	if (!EXT2_HAS_COMPAT_FEATURE(ip->i_e2fs, EXT2F_COMPAT_EXT_ATTR))
1879 		return (EOPNOTSUPP);
1880 
1881 	if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
1882 		return (EOPNOTSUPP);
1883 
1884 	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
1885 	    ap->a_cred, ap->a_td, VWRITE);
1886 	if (error)
1887 		return (error);
1888 
1889 	error = ext2_extattr_valid_attrname(ap->a_attrnamespace, ap->a_name);
1890 	if (error)
1891 		return (error);
1892 
1893 	if (EXT2_INODE_SIZE(fs) != E2FS_REV0_INODE_SIZE) {
1894 		error = ext2_extattr_inode_set(ip, ap->a_attrnamespace,
1895 		    ap->a_name, ap->a_uio);
1896 		if (error != ENOSPC)
1897 			return (error);
1898 	}
1899 
1900 	error = ext2_extattr_block_set(ip, ap->a_attrnamespace,
1901 	    ap->a_name, ap->a_uio);
1902 
1903 	return (error);
1904 }
1905 
1906 /*
1907  * Vnode pointer to File handle
1908  */
1909 /* ARGSUSED */
1910 static int
1911 ext2_vptofh(struct vop_vptofh_args *ap)
1912 {
1913 	struct inode *ip;
1914 	struct ufid *ufhp;
1915 
1916 	ip = VTOI(ap->a_vp);
1917 	ufhp = (struct ufid *)ap->a_fhp;
1918 	ufhp->ufid_len = sizeof(struct ufid);
1919 	ufhp->ufid_ino = ip->i_number;
1920 	ufhp->ufid_gen = ip->i_gen;
1921 	return (0);
1922 }
1923 
1924 /*
1925  * Initialize the vnode associated with a new inode, handle aliased
1926  * vnodes.
1927  */
1928 int
1929 ext2_vinit(struct mount *mntp, struct vop_vector *fifoops, struct vnode **vpp)
1930 {
1931 	struct inode *ip;
1932 	struct vnode *vp;
1933 
1934 	vp = *vpp;
1935 	ip = VTOI(vp);
1936 	vp->v_type = IFTOVT(ip->i_mode);
1937 	/*
1938 	 * Only unallocated inodes should be of type VNON.
1939 	 */
1940 	if (ip->i_mode != 0 && vp->v_type == VNON)
1941 		return (EINVAL);
1942 	if (vp->v_type == VFIFO)
1943 		vp->v_op = fifoops;
1944 
1945 	if (ip->i_number == EXT2_ROOTINO)
1946 		vp->v_vflag |= VV_ROOT;
1947 	ip->i_modrev = init_va_filerev();
1948 	*vpp = vp;
1949 	return (0);
1950 }
1951 
1952 /*
1953  * Allocate a new inode.
1954  */
1955 static int
1956 ext2_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
1957     struct componentname *cnp)
1958 {
1959 	struct inode *ip, *pdir;
1960 	struct vnode *tvp;
1961 	int error;
1962 
1963 	pdir = VTOI(dvp);
1964 #ifdef INVARIANTS
1965 	if ((cnp->cn_flags & HASBUF) == 0)
1966 		panic("ext2_makeinode: no name");
1967 #endif
1968 	*vpp = NULL;
1969 	if ((mode & IFMT) == 0)
1970 		mode |= IFREG;
1971 
1972 	error = ext2_valloc(dvp, mode, cnp->cn_cred, &tvp);
1973 	if (error) {
1974 		return (error);
1975 	}
1976 	ip = VTOI(tvp);
1977 	ip->i_gid = pdir->i_gid;
1978 #ifdef SUIDDIR
1979 	{
1980 		/*
1981 		 * if we are
1982 		 * not the owner of the directory,
1983 		 * and we are hacking owners here, (only do this where told to)
1984 		 * and we are not giving it TOO root, (would subvert quotas)
1985 		 * then go ahead and give it to the other user.
1986 		 * Note that this drops off the execute bits for security.
1987 		 */
1988 		if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
1989 		    (pdir->i_mode & ISUID) &&
1990 		    (pdir->i_uid != cnp->cn_cred->cr_uid) && pdir->i_uid) {
1991 			ip->i_uid = pdir->i_uid;
1992 			mode &= ~07111;
1993 		} else {
1994 			ip->i_uid = cnp->cn_cred->cr_uid;
1995 		}
1996 	}
1997 #else
1998 	ip->i_uid = cnp->cn_cred->cr_uid;
1999 #endif
2000 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
2001 	ip->i_mode = mode;
2002 	tvp->v_type = IFTOVT(mode);	/* Rest init'd in getnewvnode(). */
2003 	ip->i_nlink = 1;
2004 	if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred)) {
2005 		if (priv_check_cred(cnp->cn_cred, PRIV_VFS_RETAINSUGID))
2006 			ip->i_mode &= ~ISGID;
2007 	}
2008 
2009 	if (cnp->cn_flags & ISWHITEOUT)
2010 		ip->i_flags |= UF_OPAQUE;
2011 
2012 	/*
2013 	 * Make sure inode goes to disk before directory entry.
2014 	 */
2015 	error = ext2_update(tvp, !DOINGASYNC(tvp));
2016 	if (error)
2017 		goto bad;
2018 
2019 #ifdef UFS_ACL
2020 	if (dvp->v_mount->mnt_flag & MNT_ACLS) {
2021 		error = ext2_do_posix1e_acl_inheritance_file(dvp, tvp, mode,
2022 		    cnp->cn_cred, cnp->cn_thread);
2023 		if (error)
2024 			goto bad;
2025 	}
2026 #endif /* UFS_ACL */
2027 
2028 	error = ext2_direnter(ip, dvp, cnp);
2029 	if (error)
2030 		goto bad;
2031 
2032 	*vpp = tvp;
2033 	return (0);
2034 
2035 bad:
2036 	/*
2037 	 * Write error occurred trying to update the inode
2038 	 * or the directory so must deallocate the inode.
2039 	 */
2040 	ip->i_nlink = 0;
2041 	ip->i_flag |= IN_CHANGE;
2042 	vput(tvp);
2043 	return (error);
2044 }
2045 
2046 /*
2047  * Vnode op for reading.
2048  */
2049 static int
2050 ext2_read(struct vop_read_args *ap)
2051 {
2052 	struct vnode *vp;
2053 	struct inode *ip;
2054 	struct uio *uio;
2055 	struct m_ext2fs *fs;
2056 	struct buf *bp;
2057 	daddr_t lbn, nextlbn;
2058 	off_t bytesinfile;
2059 	long size, xfersize, blkoffset;
2060 	int error, orig_resid, seqcount;
2061 	int ioflag;
2062 
2063 	vp = ap->a_vp;
2064 	uio = ap->a_uio;
2065 	ioflag = ap->a_ioflag;
2066 
2067 	seqcount = ap->a_ioflag >> IO_SEQSHIFT;
2068 	ip = VTOI(vp);
2069 
2070 #ifdef INVARIANTS
2071 	if (uio->uio_rw != UIO_READ)
2072 		panic("%s: mode", "ext2_read");
2073 
2074 	if (vp->v_type == VLNK) {
2075 		if ((int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
2076 			panic("%s: short symlink", "ext2_read");
2077 	} else if (vp->v_type != VREG && vp->v_type != VDIR)
2078 		panic("%s: type %d", "ext2_read", vp->v_type);
2079 #endif
2080 	orig_resid = uio->uio_resid;
2081 	KASSERT(orig_resid >= 0, ("ext2_read: uio->uio_resid < 0"));
2082 	if (orig_resid == 0)
2083 		return (0);
2084 	KASSERT(uio->uio_offset >= 0, ("ext2_read: uio->uio_offset < 0"));
2085 	fs = ip->i_e2fs;
2086 	if (uio->uio_offset < ip->i_size &&
2087 	    uio->uio_offset >= fs->e2fs_maxfilesize)
2088 		return (EOVERFLOW);
2089 
2090 	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
2091 		if ((bytesinfile = ip->i_size - uio->uio_offset) <= 0)
2092 			break;
2093 		lbn = lblkno(fs, uio->uio_offset);
2094 		nextlbn = lbn + 1;
2095 		size = blksize(fs, ip, lbn);
2096 		blkoffset = blkoff(fs, uio->uio_offset);
2097 
2098 		xfersize = fs->e2fs_fsize - blkoffset;
2099 		if (uio->uio_resid < xfersize)
2100 			xfersize = uio->uio_resid;
2101 		if (bytesinfile < xfersize)
2102 			xfersize = bytesinfile;
2103 
2104 		if (lblktosize(fs, nextlbn) >= ip->i_size)
2105 			error = bread(vp, lbn, size, NOCRED, &bp);
2106 		else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
2107 			error = cluster_read(vp, ip->i_size, lbn, size,
2108 			    NOCRED, blkoffset + uio->uio_resid, seqcount,
2109 			    0, &bp);
2110 		} else if (seqcount > 1) {
2111 			u_int nextsize = blksize(fs, ip, nextlbn);
2112 
2113 			error = breadn(vp, lbn,
2114 			    size, &nextlbn, &nextsize, 1, NOCRED, &bp);
2115 		} else
2116 			error = bread(vp, lbn, size, NOCRED, &bp);
2117 		if (error) {
2118 			brelse(bp);
2119 			bp = NULL;
2120 			break;
2121 		}
2122 
2123 		/*
2124 		 * We should only get non-zero b_resid when an I/O error
2125 		 * has occurred, which should cause us to break above.
2126 		 * However, if the short read did not cause an error,
2127 		 * then we want to ensure that we do not uiomove bad
2128 		 * or uninitialized data.
2129 		 */
2130 		size -= bp->b_resid;
2131 		if (size < xfersize) {
2132 			if (size == 0)
2133 				break;
2134 			xfersize = size;
2135 		}
2136 		error = uiomove((char *)bp->b_data + blkoffset,
2137 		    (int)xfersize, uio);
2138 		if (error)
2139 			break;
2140 		vfs_bio_brelse(bp, ioflag);
2141 	}
2142 
2143 	/*
2144 	 * This can only happen in the case of an error because the loop
2145 	 * above resets bp to NULL on each iteration and on normal
2146 	 * completion has not set a new value into it. so it must have come
2147 	 * from a 'break' statement
2148 	 */
2149 	if (bp != NULL)
2150 		vfs_bio_brelse(bp, ioflag);
2151 
2152 	if ((error == 0 || uio->uio_resid != orig_resid) &&
2153 	    (vp->v_mount->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0)
2154 		ip->i_flag |= IN_ACCESS;
2155 	return (error);
2156 }
2157 
2158 static int
2159 ext2_ioctl(struct vop_ioctl_args *ap)
2160 {
2161 	struct vnode *vp;
2162 	int error;
2163 
2164 	vp = ap->a_vp;
2165 	switch (ap->a_command) {
2166 	case FIOSEEKDATA:
2167 		if (!(VTOI(vp)->i_flag & IN_E4EXTENTS)) {
2168 			error = vn_lock(vp, LK_SHARED);
2169 			if (error == 0) {
2170 				error = ext2_bmap_seekdata(vp,
2171 				    (off_t *)ap->a_data);
2172 				VOP_UNLOCK(vp);
2173 			} else
2174 				error = EBADF;
2175 			return (error);
2176 		}
2177 	case FIOSEEKHOLE:
2178 		return (vn_bmap_seekhole(vp, ap->a_command,
2179 		    (off_t *)ap->a_data, ap->a_cred));
2180 	default:
2181 		return (ENOTTY);
2182 	}
2183 }
2184 
2185 /*
2186  * Vnode op for writing.
2187  */
2188 static int
2189 ext2_write(struct vop_write_args *ap)
2190 {
2191 	struct vnode *vp;
2192 	struct uio *uio;
2193 	struct inode *ip;
2194 	struct m_ext2fs *fs;
2195 	struct buf *bp;
2196 	daddr_t lbn;
2197 	off_t osize;
2198 	int blkoffset, error, flags, ioflag, resid, size, seqcount, xfersize;
2199 
2200 	ioflag = ap->a_ioflag;
2201 	uio = ap->a_uio;
2202 	vp = ap->a_vp;
2203 
2204 	seqcount = ioflag >> IO_SEQSHIFT;
2205 	ip = VTOI(vp);
2206 
2207 #ifdef INVARIANTS
2208 	if (uio->uio_rw != UIO_WRITE)
2209 		panic("%s: mode", "ext2_write");
2210 #endif
2211 
2212 	switch (vp->v_type) {
2213 	case VREG:
2214 		if (ioflag & IO_APPEND)
2215 			uio->uio_offset = ip->i_size;
2216 		if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
2217 			return (EPERM);
2218 		/* FALLTHROUGH */
2219 	case VLNK:
2220 		break;
2221 	case VDIR:
2222 		/* XXX differs from ffs -- this is called from ext2_mkdir(). */
2223 		if ((ioflag & IO_SYNC) == 0)
2224 			panic("ext2_write: nonsync dir write");
2225 		break;
2226 	default:
2227 		panic("ext2_write: type %p %d (%jd,%jd)", (void *)vp,
2228 		    vp->v_type, (intmax_t)uio->uio_offset,
2229 		    (intmax_t)uio->uio_resid);
2230 	}
2231 
2232 	KASSERT(uio->uio_resid >= 0, ("ext2_write: uio->uio_resid < 0"));
2233 	KASSERT(uio->uio_offset >= 0, ("ext2_write: uio->uio_offset < 0"));
2234 	fs = ip->i_e2fs;
2235 	if ((uoff_t)uio->uio_offset + uio->uio_resid > fs->e2fs_maxfilesize)
2236 		return (EFBIG);
2237 	/*
2238 	 * Maybe this should be above the vnode op call, but so long as
2239 	 * file servers have no limits, I don't think it matters.
2240 	 */
2241 	if (vn_rlimit_fsize(vp, uio, uio->uio_td))
2242 		return (EFBIG);
2243 
2244 	resid = uio->uio_resid;
2245 	osize = ip->i_size;
2246 	if (seqcount > BA_SEQMAX)
2247 		flags = BA_SEQMAX << BA_SEQSHIFT;
2248 	else
2249 		flags = seqcount << BA_SEQSHIFT;
2250 	if ((ioflag & IO_SYNC) && !DOINGASYNC(vp))
2251 		flags |= IO_SYNC;
2252 
2253 	for (error = 0; uio->uio_resid > 0;) {
2254 		lbn = lblkno(fs, uio->uio_offset);
2255 		blkoffset = blkoff(fs, uio->uio_offset);
2256 		xfersize = fs->e2fs_fsize - blkoffset;
2257 		if (uio->uio_resid < xfersize)
2258 			xfersize = uio->uio_resid;
2259 		if (uio->uio_offset + xfersize > ip->i_size)
2260 			vnode_pager_setsize(vp, uio->uio_offset + xfersize);
2261 
2262 		/*
2263 		 * We must perform a read-before-write if the transfer size
2264 		 * does not cover the entire buffer.
2265 		 */
2266 		if (fs->e2fs_bsize > xfersize)
2267 			flags |= BA_CLRBUF;
2268 		else
2269 			flags &= ~BA_CLRBUF;
2270 		error = ext2_balloc(ip, lbn, blkoffset + xfersize,
2271 		    ap->a_cred, &bp, flags);
2272 		if (error != 0)
2273 			break;
2274 
2275 		if ((ioflag & (IO_SYNC | IO_INVAL)) == (IO_SYNC | IO_INVAL))
2276 			bp->b_flags |= B_NOCACHE;
2277 		if (uio->uio_offset + xfersize > ip->i_size)
2278 			ip->i_size = uio->uio_offset + xfersize;
2279 		size = blksize(fs, ip, lbn) - bp->b_resid;
2280 		if (size < xfersize)
2281 			xfersize = size;
2282 
2283 		error =
2284 		    uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
2285 		/*
2286 		 * If the buffer is not already filled and we encounter an
2287 		 * error while trying to fill it, we have to clear out any
2288 		 * garbage data from the pages instantiated for the buffer.
2289 		 * If we do not, a failed uiomove() during a write can leave
2290 		 * the prior contents of the pages exposed to a userland mmap.
2291 		 *
2292 		 * Note that we need only clear buffers with a transfer size
2293 		 * equal to the block size because buffers with a shorter
2294 		 * transfer size were cleared above by the call to ext2_balloc()
2295 		 * with the BA_CLRBUF flag set.
2296 		 *
2297 		 * If the source region for uiomove identically mmaps the
2298 		 * buffer, uiomove() performed the NOP copy, and the buffer
2299 		 * content remains valid because the page fault handler
2300 		 * validated the pages.
2301 		 */
2302 		if (error != 0 && (bp->b_flags & B_CACHE) == 0 &&
2303 		    fs->e2fs_bsize == xfersize)
2304 			vfs_bio_clrbuf(bp);
2305 
2306 		vfs_bio_set_flags(bp, ioflag);
2307 
2308 		/*
2309 		 * If IO_SYNC each buffer is written synchronously.  Otherwise
2310 		 * if we have a severe page deficiency write the buffer
2311 		 * asynchronously.  Otherwise try to cluster, and if that
2312 		 * doesn't do it then either do an async write (if O_DIRECT),
2313 		 * or a delayed write (if not).
2314 		 */
2315 		if (ioflag & IO_SYNC) {
2316 			(void)bwrite(bp);
2317 		} else if (vm_page_count_severe() ||
2318 			    buf_dirty_count_severe() ||
2319 		    (ioflag & IO_ASYNC)) {
2320 			bp->b_flags |= B_CLUSTEROK;
2321 			bawrite(bp);
2322 		} else if (xfersize + blkoffset == fs->e2fs_fsize) {
2323 			if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
2324 				bp->b_flags |= B_CLUSTEROK;
2325 				cluster_write(vp, bp, ip->i_size, seqcount, 0);
2326 			} else {
2327 				bawrite(bp);
2328 			}
2329 		} else if (ioflag & IO_DIRECT) {
2330 			bp->b_flags |= B_CLUSTEROK;
2331 			bawrite(bp);
2332 		} else {
2333 			bp->b_flags |= B_CLUSTEROK;
2334 			bdwrite(bp);
2335 		}
2336 		if (error || xfersize == 0)
2337 			break;
2338 	}
2339 	/*
2340 	 * If we successfully wrote any data, and we are not the superuser
2341 	 * we clear the setuid and setgid bits as a precaution against
2342 	 * tampering.
2343 	 */
2344 	if ((ip->i_mode & (ISUID | ISGID)) && resid > uio->uio_resid &&
2345 	    ap->a_cred) {
2346 		if (priv_check_cred(ap->a_cred, PRIV_VFS_RETAINSUGID))
2347 			ip->i_mode &= ~(ISUID | ISGID);
2348 	}
2349 	if (error) {
2350 		if (ioflag & IO_UNIT) {
2351 			(void)ext2_truncate(vp, osize,
2352 			    ioflag & IO_SYNC, ap->a_cred, uio->uio_td);
2353 			uio->uio_offset -= resid - uio->uio_resid;
2354 			uio->uio_resid = resid;
2355 		}
2356 	}
2357 	if (uio->uio_resid != resid) {
2358 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
2359 		if (ioflag & IO_SYNC)
2360 			error = ext2_update(vp, 1);
2361 	}
2362 	return (error);
2363 }
2364