?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - Try to fix delayed mtime updates on SHARED+RW maps again
[dragonfly.git] / sys / vfs / ufs / ufs_vnops.c
blob73b02cff3ff391188b96cc94aca3f80cf494e77b
1 /*
2 * Copyright (c) 1982, 1986, 1989, 1993, 1995
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95
35 * $FreeBSD: src/sys/ufs/ufs/ufs_vnops.c,v 1.131.2.8 2003/01/02 17:26:19 bde Exp $
36 */
37
38 #include "opt_quota.h"
39 #include "opt_suiddir.h"
40 #include "opt_ufs.h"
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/fcntl.h>
46 #include <sys/stat.h>
47 #include <sys/buf.h>
48 #include <sys/proc.h>
49 #include <sys/priv.h>
50 #include <sys/namei.h>
51 #include <sys/mount.h>
52 #include <sys/unistd.h>
53 #include <sys/vnode.h>
54 #include <sys/malloc.h>
55 #include <sys/dirent.h>
56 #include <sys/lockf.h>
57 #include <sys/event.h>
58 #include <sys/conf.h>
59
60 #include <sys/file.h> /* XXX */
61 #include <sys/jail.h>
62
63 #include <vm/vm.h>
64 #include <vm/vm_extern.h>
65
66 #include <vfs/fifofs/fifo.h>
67
68 #include "quota.h"
69 #include "inode.h"
70 #include "dir.h"
71 #include "ufsmount.h"
72 #include "ufs_extern.h"
73 #include "ffs_extern.h"
74 #include "fs.h"
75 #ifdef UFS_DIRHASH
76 #include "dirhash.h"
77 #endif
78
79 static int ufs_access (struct vop_access_args *);
80 static int ufs_advlock (struct vop_advlock_args *);
81 static int ufs_chmod (struct vnode *, int, struct ucred *);
82 static int ufs_chown (struct vnode *, uid_t, gid_t, struct ucred *);
83 static int ufs_close (struct vop_close_args *);
84 static int ufs_create (struct vop_old_create_args *);
85 static int ufs_getattr (struct vop_getattr_args *);
86 static int ufs_link (struct vop_old_link_args *);
87 static int ufs_makeinode (int mode, struct vnode *, struct vnode **, struct componentname *);
88 static int ufs_markatime (struct vop_markatime_args *);
89 static int ufs_missingop (struct vop_generic_args *ap);
90 static int ufs_mkdir (struct vop_old_mkdir_args *);
91 static int ufs_mknod (struct vop_old_mknod_args *);
92 static int ufs_mmap (struct vop_mmap_args *);
93 static int ufs_print (struct vop_print_args *);
94 static int ufs_readdir (struct vop_readdir_args *);
95 static int ufs_readlink (struct vop_readlink_args *);
96 static int ufs_remove (struct vop_old_remove_args *);
97 static int ufs_rename (struct vop_old_rename_args *);
98 static int ufs_rmdir (struct vop_old_rmdir_args *);
99 static int ufs_setattr (struct vop_setattr_args *);
100 static int ufs_strategy (struct vop_strategy_args *);
101 static int ufs_symlink (struct vop_old_symlink_args *);
102 static int ufs_whiteout (struct vop_old_whiteout_args *);
103 static int ufsfifo_close (struct vop_close_args *);
104 static int ufsfifo_kqfilter (struct vop_kqfilter_args *);
105 static int ufsfifo_read (struct vop_read_args *);
106 static int ufsfifo_write (struct vop_write_args *);
107 static int filt_ufsread (struct knote *kn, long hint);
108 static int filt_ufswrite (struct knote *kn, long hint);
109 static int filt_ufsvnode (struct knote *kn, long hint);
110 static void filt_ufsdetach (struct knote *kn);
111 static int ufs_kqfilter (struct vop_kqfilter_args *ap);
112
113 union _qcvt {
114 int64_t qcvt;
115 int32_t val[2];
116 };
117 #define SETHIGH(q, h) { \
118 union _qcvt tmp; \
119 tmp.qcvt = (q); \
120 tmp.val[_QUAD_HIGHWORD] = (h); \
121 (q) = tmp.qcvt; \
122 }
123 #define SETLOW(q, l) { \
124 union _qcvt tmp; \
125 tmp.qcvt = (q); \
126 tmp.val[_QUAD_LOWWORD] = (l); \
127 (q) = tmp.qcvt; \
128 }
129 #define VN_KNOTE(vp, b) \
130 KNOTE(&vp->v_pollinfo.vpi_kqinfo.ki_note, (b))
131
132 #define OFSFMT(vp) ((vp)->v_mount->mnt_maxsymlinklen <= 0)
133
134 /*
135 * A virgin directory (no blushing please).
136 */
137 static struct dirtemplate mastertemplate = {
138 0, 12, DT_DIR, 1, ".",
139 0, DIRBLKSIZ - 12, DT_DIR, 2, ".."
140 };
141 static struct odirtemplate omastertemplate = {
142 0, 12, 1, ".",
143 0, DIRBLKSIZ - 12, 2, ".."
144 };
145
146 void
147 ufs_itimes(struct vnode *vp)
148 {
149 struct inode *ip;
150 struct timespec ts;
151
152 ip = VTOI(vp);
153 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0)
154 return;
155 if ((vp->v_type == VBLK || vp->v_type == VCHR) && !DOINGSOFTDEP(vp))
156 ip->i_flag |= IN_LAZYMOD;
157 else
158 ip->i_flag |= IN_MODIFIED;
159
160 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
161 vfs_timestamp(&ts);
162 if (ip->i_flag & IN_ACCESS) {
163 ip->i_atime = ts.tv_sec;
164 ip->i_atimensec = ts.tv_nsec;
165 }
166 if (ip->i_flag & IN_CHANGE) {
167 ip->i_ctime = ts.tv_sec;
168 ip->i_ctimensec = ts.tv_nsec;
169 }
170 if (ip->i_flag & IN_UPDATE) {
171 if (ip->i_flag & IN_NOCOPYWRITE) {
172 if (vp->v_flag & VLASTWRITETS) {
173 ip->i_mtime = vp->v_lastwrite_ts.tv_sec;
174 ip->i_mtimensec =
175 vp->v_lastwrite_ts.tv_nsec;
176 }
177 } else {
178 ip->i_mtime = ts.tv_sec;
179 ip->i_mtimensec = ts.tv_nsec;
180 }
181 ip->i_modrev++;
182 }
183 }
184 ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
185 }
186
187 /*
188 * Create a regular file
189 *
190 * ufs_create(struct vnode *a_dvp, struct vnode **a_vpp,
191 * struct componentname *a_cnp, struct vattr *a_vap)
192 */
193 static
194 int
195 ufs_create(struct vop_old_create_args *ap)
196 {
197 int error;
198
199 error =
200 ufs_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode),
201 ap->a_dvp, ap->a_vpp, ap->a_cnp);
202 if (error)
203 return (error);
204 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
205 return (0);
206 }
207
208 /*
209 * Mknod vnode call
210 *
211 * ufs_mknod(struct vnode *a_dvp, struct vnode **a_vpp,
212 * struct componentname *a_cnp, struct vattr *a_vap)
213 */
214 /* ARGSUSED */
215 static
216 int
217 ufs_mknod(struct vop_old_mknod_args *ap)
218 {
219 struct vattr *vap = ap->a_vap;
220 struct vnode **vpp = ap->a_vpp;
221 struct inode *ip;
222 ino_t ino;
223 int error;
224
225 /*
226 * UFS cannot represent the entire major/minor range supported by
227 * the kernel.
228 */
229 if (vap->va_rmajor != VNOVAL &&
230 makeudev(vap->va_rmajor, vap->va_rminor) == NOUDEV) {
231 return(EINVAL);
232 }
233
234 /* no special directory support */
235 if (vap->va_type == VDIR)
236 return(EINVAL);
237
238 error = ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
239 ap->a_dvp, vpp, ap->a_cnp);
240 if (error)
241 return (error);
242 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
243 ip = VTOI(*vpp);
244 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
245 if (vap->va_rmajor != VNOVAL) {
246 /*
247 * Want to be able to use this to make badblock
248 * inodes, so don't truncate the dev number.
249 */
250 ip->i_rdev = makeudev(vap->va_rmajor, vap->va_rminor);
251 }
252 /*
253 * Remove inode, then reload it through VFS_VGET so it is
254 * checked to see if it is an alias of an existing entry in
255 * the inode cache.
256 */
257 (*vpp)->v_type = VNON;
258 ino = ip->i_number; /* Save this before vgone() invalidates ip. */
259 vgone_vxlocked(*vpp);
260 vput(*vpp);
261 error = VFS_VGET(ap->a_dvp->v_mount, NULL, ino, vpp);
262 if (error) {
263 *vpp = NULL;
264 return (error);
265 }
266 return (0);
267 }
268
269 /*
270 * Close called.
271 *
272 * Update the times on the inode.
273 *
274 * ufs_close(struct vnode *a_vp, int a_fflag)
275 */
276 /* ARGSUSED */
277 static
278 int
279 ufs_close(struct vop_close_args *ap)
280 {
281 struct vnode *vp = ap->a_vp;
282
283 if (VREFCNT(vp) > 1)
284 ufs_itimes(vp);
285 return (vop_stdclose(ap));
286 }
287
288 /*
289 * ufs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
290 */
291 static
292 int
293 ufs_access(struct vop_access_args *ap)
294 {
295 struct vnode *vp = ap->a_vp;
296 struct inode *ip = VTOI(vp);
297 int error;
298
299 #ifdef QUOTA
300 if (ap->a_mode & VWRITE) {
301 switch (vp->v_type) {
302 case VDIR:
303 case VLNK:
304 case VREG:
305 if ((error = ufs_getinoquota(ip)) != 0)
306 return (error);
307 break;
308 default:
309 break;
310 }
311 }
312 #endif
313
314 error = vop_helper_access(ap, ip->i_uid, ip->i_gid, ip->i_mode, 0);
315 return (error);
316 }
317
318 /*
319 * ufs_getattr(struct vnode *a_vp, struct vattr *a_vap)
320 */
321 /* ARGSUSED */
322 static
323 int
324 ufs_getattr(struct vop_getattr_args *ap)
325 {
326 struct vnode *vp = ap->a_vp;
327 struct inode *ip = VTOI(vp);
328 struct vattr *vap = ap->a_vap;
329
330 ufs_itimes(vp);
331 /*
332 * Copy from inode table
333 */
334 vap->va_fsid = dev2udev(ip->i_dev);
335 vap->va_fileid = ip->i_number;
336 vap->va_mode = ip->i_mode & ~IFMT;
337 vap->va_nlink = VFSTOUFS(vp->v_mount)->um_i_effnlink_valid ?
338 ip->i_effnlink : ip->i_nlink;
339 vap->va_uid = ip->i_uid;
340 vap->va_gid = ip->i_gid;
341 vap->va_rmajor = umajor(ip->i_rdev);
342 vap->va_rminor = uminor(ip->i_rdev);
343 vap->va_size = ip->i_din.di_size;
344 vap->va_atime.tv_sec = ip->i_atime;
345 vap->va_atime.tv_nsec = ip->i_atimensec;
346 vap->va_mtime.tv_sec = ip->i_mtime;
347 vap->va_mtime.tv_nsec = ip->i_mtimensec;
348 vap->va_ctime.tv_sec = ip->i_ctime;
349 vap->va_ctime.tv_nsec = ip->i_ctimensec;
350 vap->va_flags = ip->i_flags;
351 vap->va_gen = ip->i_gen;
352 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
353 vap->va_bytes = dbtob((u_quad_t)ip->i_blocks);
354 vap->va_type = IFTOVT(ip->i_mode);
355 vap->va_filerev = ip->i_modrev;
356 return (0);
357 }
358
359 static
360 int
361 ufs_markatime(struct vop_markatime_args *ap)
362 {
363 struct vnode *vp = ap->a_vp;
364 struct inode *ip = VTOI(vp);
365
366 if (vp->v_mount->mnt_flag & MNT_RDONLY)
367 return (EROFS);
368 if (vp->v_mount->mnt_flag & MNT_NOATIME)
369 return (0);
370 ip->i_flag |= IN_ACCESS;
371 VN_KNOTE(vp, NOTE_ATTRIB);
372 return (0);
373 }
374
375 /*
376 * Set attribute vnode op. called from several syscalls
377 *
378 * ufs_setattr(struct vnode *a_vp, struct vattr *a_vap,
379 * struct ucred *a_cred)
380 */
381 static
382 int
383 ufs_setattr(struct vop_setattr_args *ap)
384 {
385 struct vattr *vap = ap->a_vap;
386 struct vnode *vp = ap->a_vp;
387 struct inode *ip = VTOI(vp);
388 struct ucred *cred = ap->a_cred;
389 int error;
390
391 /*
392 * Check for unsettable attributes.
393 */
394 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
395 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
396 (vap->va_blocksize != VNOVAL) || (vap->va_rmajor != VNOVAL) ||
397 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
398 return (EINVAL);
399 }
400 if (vap->va_flags != VNOVAL) {
401 if (vp->v_mount->mnt_flag & MNT_RDONLY)
402 return (EROFS);
403 if (cred->cr_uid != ip->i_uid &&
404 (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0)))
405 return (error);
406 /*
407 * Note that a root chflags becomes a user chflags when
408 * we are jailed, unless the jail.chflags_allowed sysctl
409 * is set.
410 */
411 if (cred->cr_uid == 0 &&
412 (!jailed(cred) || jail_chflags_allowed)) {
413 if ((ip->i_flags
414 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) &&
415 securelevel > 0)
416 return (EPERM);
417 ip->i_flags = vap->va_flags;
418 } else {
419 if (ip->i_flags
420 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) ||
421 (vap->va_flags & UF_SETTABLE) != vap->va_flags)
422 return (EPERM);
423 ip->i_flags &= SF_SETTABLE;
424 ip->i_flags |= (vap->va_flags & UF_SETTABLE);
425 }
426 ip->i_flag |= IN_CHANGE;
427 if (vap->va_flags & (IMMUTABLE | APPEND))
428 return (0);
429 }
430 if (ip->i_flags & (IMMUTABLE | APPEND))
431 return (EPERM);
432 /*
433 * Go through the fields and update iff not VNOVAL.
434 */
435 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
436 if (vp->v_mount->mnt_flag & MNT_RDONLY)
437 return (EROFS);
438 if ((error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred)) != 0)
439 return (error);
440 }
441 if (vap->va_size != VNOVAL) {
442 /*
443 * Disallow write attempts on read-only filesystems;
444 * unless the file is a socket, fifo, or a block or
445 * character device resident on the filesystem.
446 */
447 switch (vp->v_type) {
448 case VDIR:
449 return (EISDIR);
450 case VLNK:
451 case VREG:
452 if (vp->v_mount->mnt_flag & MNT_RDONLY)
453 return (EROFS);
454 break;
455 default:
456 break;
457 }
458 if ((error = ffs_truncate(vp, vap->va_size, 0, cred)) != 0)
459 return (error);
460 }
461 ip = VTOI(vp);
462 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
463 if (vp->v_mount->mnt_flag & MNT_RDONLY)
464 return (EROFS);
465 if (cred->cr_uid != ip->i_uid &&
466 (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0)) &&
467 ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
468 (error = VOP_EACCESS(vp, VWRITE, cred))))
469 return (error);
470 if (vap->va_atime.tv_sec != VNOVAL)
471 ip->i_flag |= IN_ACCESS;
472 if (vap->va_mtime.tv_sec != VNOVAL)
473 ip->i_flag |= IN_CHANGE | IN_UPDATE;
474 ufs_itimes(vp);
475 if (vap->va_atime.tv_sec != VNOVAL) {
476 ip->i_atime = vap->va_atime.tv_sec;
477 ip->i_atimensec = vap->va_atime.tv_nsec;
478 }
479 if (vap->va_mtime.tv_sec != VNOVAL) {
480 ip->i_mtime = vap->va_mtime.tv_sec;
481 ip->i_mtimensec = vap->va_mtime.tv_nsec;
482 vclrflags(vp, VLASTWRITETS);
483 }
484 error = ffs_update(vp, 0);
485 if (error)
486 return (error);
487 }
488 error = 0;
489 if (vap->va_mode != (mode_t)VNOVAL) {
490 if (vp->v_mount->mnt_flag & MNT_RDONLY)
491 return (EROFS);
492 error = ufs_chmod(vp, (int)vap->va_mode, cred);
493 }
494 VN_KNOTE(vp, NOTE_ATTRIB);
495 return (error);
496 }
497
498 /*
499 * Change the mode on a file.
500 * Inode must be locked before calling.
501 */
502 static int
503 ufs_chmod(struct vnode *vp, int mode, struct ucred *cred)
504 {
505 struct inode *ip = VTOI(vp);
506 int error;
507 mode_t cur_mode = ip->i_mode;
508
509 error = vop_helper_chmod(vp, mode, cred, ip->i_uid, ip->i_gid,
510 &cur_mode);
511 if (error)
512 return (error);
513 #if 0
514 if (cred->cr_uid != ip->i_uid) {
515 error = priv_check_cred(cred, PRIV_VFS_CHMOD, 0);
516 if (error)
517 return (error);
518 }
519 if (cred->cr_uid) {
520 if (vp->v_type != VDIR && (mode & S_ISTXT))
521 return (EFTYPE);
522 if (!groupmember(ip->i_gid, cred) && (mode & ISGID))
523 return (EPERM);
524 }
525 #endif
526 ip->i_mode = cur_mode;
527 ip->i_flag |= IN_CHANGE;
528 return (0);
529 }
530
531 /*
532 * Perform chown operation on inode ip;
533 * inode must be locked prior to call.
534 */
535 static int
536 ufs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred)
537 {
538 struct inode *ip = VTOI(vp);
539 uid_t ouid;
540 gid_t ogid;
541 int error = 0;
542 #ifdef QUOTA
543 int i;
544 long change;
545 #endif
546
547 if (uid == (uid_t)VNOVAL)
548 uid = ip->i_uid;
549 if (gid == (gid_t)VNOVAL)
550 gid = ip->i_gid;
551 /*
552 * If we don't own the file, are trying to change the owner
553 * of the file, or are not a member of the target group,
554 * the caller must be superuser or the call fails.
555 */
556 if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid ||
557 (gid != ip->i_gid && !(cred->cr_gid == gid ||
558 groupmember(gid, cred)))) &&
559 (error = priv_check_cred(cred, PRIV_VFS_CHOWN, 0)))
560 return (error);
561 ogid = ip->i_gid;
562 ouid = ip->i_uid;
563 #ifdef QUOTA
564 if ((error = ufs_getinoquota(ip)) != 0)
565 return (error);
566 if (ouid == uid) {
567 ufs_dqrele(vp, ip->i_dquot[USRQUOTA]);
568 ip->i_dquot[USRQUOTA] = NODQUOT;
569 }
570 if (ogid == gid) {
571 ufs_dqrele(vp, ip->i_dquot[GRPQUOTA]);
572 ip->i_dquot[GRPQUOTA] = NODQUOT;
573 }
574 change = ip->i_blocks;
575 (void) ufs_chkdq(ip, -change, cred, CHOWN);
576 (void) ufs_chkiq(ip, -1, cred, CHOWN);
577 for (i = 0; i < MAXQUOTAS; i++) {
578 ufs_dqrele(vp, ip->i_dquot[i]);
579 ip->i_dquot[i] = NODQUOT;
580 }
581 #endif
582 ip->i_gid = gid;
583 ip->i_uid = uid;
584 #ifdef QUOTA
585 if ((error = ufs_getinoquota(ip)) == 0) {
586 if (ouid == uid) {
587 ufs_dqrele(vp, ip->i_dquot[USRQUOTA]);
588 ip->i_dquot[USRQUOTA] = NODQUOT;
589 }
590 if (ogid == gid) {
591 ufs_dqrele(vp, ip->i_dquot[GRPQUOTA]);
592 ip->i_dquot[GRPQUOTA] = NODQUOT;
593 }
594 if ((error = ufs_chkdq(ip, change, cred, CHOWN)) == 0) {
595 if ((error = ufs_chkiq(ip, 1, cred, CHOWN)) == 0)
596 goto good;
597 else
598 (void)ufs_chkdq(ip, -change, cred, CHOWN|FORCE);
599 }
600 for (i = 0; i < MAXQUOTAS; i++) {
601 ufs_dqrele(vp, ip->i_dquot[i]);
602 ip->i_dquot[i] = NODQUOT;
603 }
604 }
605 ip->i_gid = ogid;
606 ip->i_uid = ouid;
607 if (ufs_getinoquota(ip) == 0) {
608 if (ouid == uid) {
609 ufs_dqrele(vp, ip->i_dquot[USRQUOTA]);
610 ip->i_dquot[USRQUOTA] = NODQUOT;
611 }
612 if (ogid == gid) {
613 ufs_dqrele(vp, ip->i_dquot[GRPQUOTA]);
614 ip->i_dquot[GRPQUOTA] = NODQUOT;
615 }
616 (void) ufs_chkdq(ip, change, cred, FORCE|CHOWN);
617 (void) ufs_chkiq(ip, 1, cred, FORCE|CHOWN);
618 (void) ufs_getinoquota(ip);
619 }
620 return (error);
621 good:
622 if (ufs_getinoquota(ip))
623 panic("ufs_chown: lost quota");
624 #endif /* QUOTA */
625 ip->i_flag |= IN_CHANGE;
626 if (cred->cr_uid != 0 && (ouid != uid || ogid != gid))
627 ip->i_mode &= ~(ISUID | ISGID);
628 return (0);
629 }
630
631 /*
632 * Mmap a file
633 *
634 * NB Currently unsupported.
635 *
636 * ufs_mmap(struct vnode *a_vp, int a_fflags, struct ucred *a_cred)
637 */
638 /* ARGSUSED */
639 static
640 int
641 ufs_mmap(struct vop_mmap_args *ap)
642 {
643 return (EINVAL);
644 }
645
646 /*
647 * ufs_remove(struct vnode *a_dvp, struct vnode *a_vp,
648 * struct componentname *a_cnp)
649 */
650 static
651 int
652 ufs_remove(struct vop_old_remove_args *ap)
653 {
654 struct inode *ip;
655 struct vnode *vp = ap->a_vp;
656 struct vnode *dvp = ap->a_dvp;
657 int error;
658
659 ip = VTOI(vp);
660 #if 0 /* handled by kernel now */
661 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
662 (VTOI(dvp)->i_flags & APPEND)) {
663 error = EPERM;
664 goto out;
665 }
666 #endif
667 error = ufs_dirremove(dvp, ip, ap->a_cnp->cn_flags, 0);
668 VN_KNOTE(vp, NOTE_DELETE);
669 VN_KNOTE(dvp, NOTE_WRITE);
670 #if 0
671 out:
672 #endif
673 return (error);
674 }
675
676 /*
677 * link vnode call
678 *
679 * ufs_link(struct vnode *a_tdvp, struct vnode *a_vp,
680 * struct componentname *a_cnp)
681 */
682 static
683 int
684 ufs_link(struct vop_old_link_args *ap)
685 {
686 struct vnode *vp = ap->a_vp;
687 struct vnode *tdvp = ap->a_tdvp;
688 struct componentname *cnp = ap->a_cnp;
689 struct inode *ip;
690 struct direct newdir;
691 int error;
692
693 if (tdvp->v_mount != vp->v_mount) {
694 error = EXDEV;
695 goto out2;
696 }
697 if (tdvp != vp) {
698 error = vn_lock(vp, LK_EXCLUSIVE | LK_FAILRECLAIM);
699 if (error)
700 goto out2;
701 }
702 ip = VTOI(vp);
703 if ((nlink_t)ip->i_nlink >= LINK_MAX) {
704 error = EMLINK;
705 goto out1;
706 }
707 #if 0 /* handled by kernel now, also DragonFly allows this */
708 if (ip->i_flags & (IMMUTABLE | APPEND)) {
709 error = EPERM;
710 goto out1;
711 }
712 #endif
713 ip->i_effnlink++;
714 ip->i_nlink++;
715 ip->i_flag |= IN_CHANGE;
716 if (DOINGSOFTDEP(vp))
717 softdep_change_linkcnt(ip);
718 error = ffs_update(vp, !(DOINGSOFTDEP(vp) | DOINGASYNC(vp)));
719 if (!error) {
720 ufs_makedirentry(ip, cnp, &newdir);
721 error = ufs_direnter(tdvp, vp, &newdir, cnp, NULL);
722 }
723
724 if (error) {
725 ip->i_effnlink--;
726 ip->i_nlink--;
727 ip->i_flag |= IN_CHANGE;
728 if (DOINGSOFTDEP(vp))
729 softdep_change_linkcnt(ip);
730 }
731 out1:
732 if (tdvp != vp)
733 vn_unlock(vp);
734 out2:
735 VN_KNOTE(vp, NOTE_LINK);
736 VN_KNOTE(tdvp, NOTE_WRITE);
737 return (error);
738 }
739
740 /*
741 * whiteout vnode call
742 *
743 * ufs_whiteout(struct vnode *a_dvp, struct componentname *a_cnp, int a_flags)
744 */
745 static
746 int
747 ufs_whiteout(struct vop_old_whiteout_args *ap)
748 {
749 struct vnode *dvp = ap->a_dvp;
750 struct componentname *cnp = ap->a_cnp;
751 struct direct newdir;
752 int error = 0;
753
754 switch (ap->a_flags) {
755 case NAMEI_LOOKUP:
756 /* 4.4 format directories support whiteout operations */
757 if (dvp->v_mount->mnt_maxsymlinklen > 0)
758 return (0);
759 return (EOPNOTSUPP);
760
761 case NAMEI_CREATE:
762 /* create a new directory whiteout */
763 #ifdef DIAGNOSTIC
764 if (dvp->v_mount->mnt_maxsymlinklen <= 0)
765 panic("ufs_whiteout: old format filesystem");
766 #endif
767
768 newdir.d_ino = WINO;
769 newdir.d_namlen = cnp->cn_namelen;
770 bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1);
771 newdir.d_type = DT_WHT;
772 error = ufs_direnter(dvp, NULL, &newdir, cnp, NULL);
773 break;
774
775 case NAMEI_DELETE:
776 /* remove an existing directory whiteout */
777 #ifdef DIAGNOSTIC
778 if (dvp->v_mount->mnt_maxsymlinklen <= 0)
779 panic("ufs_whiteout: old format filesystem");
780 #endif
781
782 cnp->cn_flags &= ~CNP_DOWHITEOUT;
783 error = ufs_dirremove(dvp, NULL, cnp->cn_flags, 0);
784 break;
785 default:
786 panic("ufs_whiteout: unknown op");
787 }
788 return (error);
789 }
790
791 /*
792 * Rename system call.
793 * rename("foo", "bar");
794 * is essentially
795 * unlink("bar");
796 * link("foo", "bar");
797 * unlink("foo");
798 * but ``atomically''. Can't do full commit without saving state in the
799 * inode on disk which isn't feasible at this time. Best we can do is
800 * always guarantee the target exists.
801 *
802 * Basic algorithm is:
803 *
804 * 1) Bump link count on source while we're linking it to the
805 * target. This also ensure the inode won't be deleted out
806 * from underneath us while we work (it may be truncated by
807 * a concurrent `trunc' or `open' for creation).
808 * 2) Link source to destination. If destination already exists,
809 * delete it first.
810 * 3) Unlink source reference to inode if still around. If a
811 * directory was moved and the parent of the destination
812 * is different from the source, patch the ".." entry in the
813 * directory.
814 *
815 * ufs_rename(struct vnode *a_fdvp, struct vnode *a_fvp,
816 * struct componentname *a_fcnp, struct vnode *a_tdvp,
817 * struct vnode *a_tvp, struct componentname *a_tcnp)
818 */
819 static
820 int
821 ufs_rename(struct vop_old_rename_args *ap)
822 {
823 struct vnode *tvp = ap->a_tvp;
824 struct vnode *tdvp = ap->a_tdvp;
825 struct vnode *fvp = ap->a_fvp;
826 struct vnode *fdvp = ap->a_fdvp;
827 struct componentname *tcnp = ap->a_tcnp;
828 struct componentname *fcnp = ap->a_fcnp;
829 struct inode *ip, *xp, *dp;
830 struct direct newdir;
831 ino_t oldparent = 0, newparent = 0;
832 int doingdirectory = 0;
833 int error = 0, ioflag;
834
835 /*
836 * Check for cross-device rename.
837 */
838 if ((fvp->v_mount != tdvp->v_mount) ||
839 (tvp && (fvp->v_mount != tvp->v_mount))) {
840 error = EXDEV;
841 abortit:
842 if (tdvp == tvp)
843 vrele(tdvp);
844 else
845 vput(tdvp);
846 if (tvp)
847 vput(tvp);
848 vrele(fdvp);
849 vrele(fvp);
850 return (error);
851 }
852
853 #if 0 /* handled by kernel now */
854 if (tvp && ((VTOI(tvp)->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
855 (VTOI(tdvp)->i_flags & APPEND))) {
856 error = EPERM;
857 goto abortit;
858 }
859 #endif
860
861 /*
862 * Renaming a file to itself has no effect. The upper layers should
863 * not call us in that case. Temporarily just warn if they do.
864 */
865 if (fvp == tvp) {
866 kprintf("ufs_rename: fvp == tvp (can't happen)\n");
867 error = 0;
868 goto abortit;
869 }
870
871 error = vn_lock(fvp, LK_EXCLUSIVE | LK_FAILRECLAIM);
872 if (error)
873 goto abortit;
874
875 /*
876 * Note: now that fvp is locked we have to be sure to unlock it before
877 * using the 'abortit' target.
878 */
879 dp = VTOI(fdvp);
880 ip = VTOI(fvp);
881 if (ip->i_nlink >= LINK_MAX) {
882 vn_unlock(fvp);
883 error = EMLINK;
884 goto abortit;
885 }
886 #if 0 /* handled by kernel now */
887 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))
888 || (dp->i_flags & APPEND)) {
889 vn_unlock(fvp);
890 error = EPERM;
891 goto abortit;
892 }
893 #endif
894 if ((ip->i_mode & IFMT) == IFDIR) {
895 /*
896 * Avoid ".", "..", and aliases of "." for obvious reasons.
897 */
898 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
899 dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & CNP_ISDOTDOT ||
900 (ip->i_flag & IN_RENAME)) {
901 vn_unlock(fvp);
902 error = EINVAL;
903 goto abortit;
904 }
905 ip->i_flag |= IN_RENAME;
906 oldparent = dp->i_number;
907 doingdirectory = 1;
908 }
909 VN_KNOTE(fdvp, NOTE_WRITE); /* XXX right place? */
910
911 /*
912 * fvp still locked. ip->i_flag has IN_RENAME set if doingdirectory.
913 * Cleanup fvp requirements so we can unlock it.
914 *
915 * tvp and tdvp are locked. tvp may be NULL. Now that dp and xp
916 * is setup we can use the 'bad' target if we unlock fvp. We cannot
917 * use the abortit target anymore because of IN_RENAME.
918 */
919 dp = VTOI(tdvp);
920 if (tvp)
921 xp = VTOI(tvp);
922 else
923 xp = NULL;
924
925 /*
926 * 1) Bump link count while we're moving stuff
927 * around. If we crash somewhere before
928 * completing our work, the link count
929 * may be wrong, but correctable.
930 */
931 ip->i_effnlink++;
932 ip->i_nlink++;
933 ip->i_flag |= IN_CHANGE;
934 if (DOINGSOFTDEP(fvp))
935 softdep_change_linkcnt(ip);
936 if ((error = ffs_update(fvp, !(DOINGSOFTDEP(fvp) |
937 DOINGASYNC(fvp)))) != 0) {
938 vn_unlock(fvp);
939 goto bad;
940 }
941
942 /*
943 * If ".." must be changed (ie the directory gets a new
944 * parent) then the source directory must not be in the
945 * directory heirarchy above the target, as this would
946 * orphan everything below the source directory. Also
947 * the user must have write permission in the source so
948 * as to be able to change "..". We must repeat the call
949 * to namei, as the parent directory is unlocked by the
950 * call to checkpath().
951 */
952 error = VOP_EACCESS(fvp, VWRITE, tcnp->cn_cred);
953 vn_unlock(fvp);
954
955 /*
956 * We are now back to where we were in that fvp, fdvp are unlocked
957 * and tvp, tdvp are locked. tvp may be NULL. IN_RENAME may be
958 * set. Only the bad target or, if we clean up tvp and tdvp, the
959 * out target, may be used.
960 */
961 if (oldparent != dp->i_number)
962 newparent = dp->i_number;
963 if (doingdirectory && newparent) {
964 if (error) /* write access check above */
965 goto bad;
966
967 /*
968 * Once we start messing with tvp and tdvp we cannot use the
969 * 'bad' target, only finish cleaning tdvp and tvp up and
970 * use the 'out' target.
971 *
972 * This cleans up tvp.
973 */
974 if (xp != NULL) {
975 vput(tvp);
976 xp = NULL;
977 }
978
979 /*
980 * This is a real mess. ufs_checkpath vput's the target
981 * directory so retain an extra ref and note that tdvp will
982 * lose its lock on return. This leaves us with one good
983 * ref after ufs_checkpath returns.
984 */
985 vref(tdvp);
986 error = ufs_checkpath(ip, dp, tcnp->cn_cred);
987 tcnp->cn_flags |= CNP_PDIRUNLOCK;
988 if (error) {
989 vrele(tdvp);
990 goto out;
991 }
992
993 /*
994 * relookup no longer messes with tdvp's refs. tdvp must be
995 * unlocked on entry and will be locked on a successful
996 * return.
997 */
998 error = relookup(tdvp, &tvp, tcnp);
999 if (error) {
1000 if (tcnp->cn_flags & CNP_PDIRUNLOCK)
1001 vrele(tdvp);
1002 else
1003 vput(tdvp);
1004 goto out;
1005 }
1006 KKASSERT((tcnp->cn_flags & CNP_PDIRUNLOCK) == 0);
1007 dp = VTOI(tdvp);
1008 if (tvp)
1009 xp = VTOI(tvp);
1010 }
1011
1012 /*
1013 * We are back to fvp, fdvp unlocked, tvp, tdvp locked. tvp may
1014 * be NULL (xp will also be NULL in that case), and IN_RENAME will
1015 * be set if doingdirectory. This means we can use the 'bad' target
1016 * again.
1017 */
1018
1019 /*
1020 * 2) If target doesn't exist, link the target
1021 * to the source and unlink the source.
1022 * Otherwise, rewrite the target directory
1023 * entry to reference the source inode and
1024 * expunge the original entry's existence.
1025 */
1026 if (xp == NULL) {
1027 if (dp->i_dev != ip->i_dev)
1028 panic("ufs_rename: EXDEV");
1029 /*
1030 * Account for ".." in new directory.
1031 * When source and destination have the same
1032 * parent we don't fool with the link count.
1033 */
1034 if (doingdirectory && newparent) {
1035 if ((nlink_t)dp->i_nlink >= LINK_MAX) {
1036 error = EMLINK;
1037 goto bad;
1038 }
1039 dp->i_effnlink++;
1040 dp->i_nlink++;
1041 dp->i_flag |= IN_CHANGE;
1042 if (DOINGSOFTDEP(tdvp))
1043 softdep_change_linkcnt(dp);
1044 error = ffs_update(tdvp, !(DOINGSOFTDEP(tdvp) |
1045 DOINGASYNC(tdvp)));
1046 if (error)
1047 goto bad;
1048 }
1049 ufs_makedirentry(ip, tcnp, &newdir);
1050 error = ufs_direnter(tdvp, NULL, &newdir, tcnp, NULL);
1051 if (error) {
1052 if (doingdirectory && newparent) {
1053 dp->i_effnlink--;
1054 dp->i_nlink--;
1055 dp->i_flag |= IN_CHANGE;
1056 if (DOINGSOFTDEP(tdvp))
1057 softdep_change_linkcnt(dp);
1058 (void)ffs_update(tdvp, 1);
1059 }
1060 goto bad;
1061 }
1062 VN_KNOTE(tdvp, NOTE_WRITE);
1063 vput(tdvp);
1064 } else {
1065 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
1066 panic("ufs_rename: EXDEV");
1067 /*
1068 * Short circuit rename(foo, foo).
1069 */
1070 if (xp->i_number == ip->i_number)
1071 panic("ufs_rename: same file");
1072 /*
1073 * If the parent directory is "sticky", then the user must
1074 * own the parent directory, or the destination of the rename,
1075 * otherwise the destination may not be changed (except by
1076 * root). This implements append-only directories.
1077 */
1078 if ((dp->i_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 &&
1079 tcnp->cn_cred->cr_uid != dp->i_uid &&
1080 xp->i_uid != tcnp->cn_cred->cr_uid) {
1081 error = EPERM;
1082 goto bad;
1083 }
1084 /*
1085 * Target must be empty if a directory and have no links
1086 * to it. Also, ensure source and target are compatible
1087 * (both directories, or both not directories).
1088 *
1089 * Purge the file or directory being replaced from the
1090 * nameccache.
1091 */
1092 if ((xp->i_mode&IFMT) == IFDIR) {
1093 if ((xp->i_effnlink > 2) ||
1094 !ufs_dirempty(xp, dp->i_number, tcnp->cn_cred)) {
1095 error = ENOTEMPTY;
1096 goto bad;
1097 }
1098 if (!doingdirectory) {
1099 error = ENOTDIR;
1100 goto bad;
1101 }
1102 /* cache_purge removed - handled by VFS compat layer */
1103 } else if (doingdirectory == 0) {
1104 /* cache_purge removed - handled by VFS compat layer */
1105 } else {
1106 error = EISDIR;
1107 goto bad;
1108 }
1109 /*
1110 * note: inode passed to ufs_dirrewrite() is 0 for a
1111 * non-directory file rename, 1 for a directory rename
1112 * in the same directory, and > 1 for an inode representing
1113 * the new directory.
1114 */
1115 error = ufs_dirrewrite(dp, xp, ip->i_number,
1116 IFTODT(ip->i_mode),
1117 (doingdirectory && newparent) ?
1118 newparent : (ino_t)doingdirectory);
1119 if (error)
1120 goto bad;
1121 if (doingdirectory) {
1122 if (!newparent) {
1123 dp->i_effnlink--;
1124 if (DOINGSOFTDEP(tdvp))
1125 softdep_change_linkcnt(dp);
1126 }
1127 xp->i_effnlink--;
1128 if (DOINGSOFTDEP(tvp))
1129 softdep_change_linkcnt(xp);
1130 }
1131 if (doingdirectory && !DOINGSOFTDEP(tvp)) {
1132 /*
1133 * Truncate inode. The only stuff left in the directory
1134 * is "." and "..". The "." reference is inconsequential
1135 * since we are quashing it. We have removed the "."
1136 * reference and the reference in the parent directory,
1137 * but there may be other hard links. The soft
1138 * dependency code will arrange to do these operations
1139 * after the parent directory entry has been deleted on
1140 * disk, so when running with that code we avoid doing
1141 * them now.
1142 */
1143 if (!newparent) {
1144 dp->i_nlink--;
1145 dp->i_flag |= IN_CHANGE;
1146 }
1147 xp->i_nlink--;
1148 xp->i_flag |= IN_CHANGE;
1149 ioflag = DOINGASYNC(tvp) ? 0 : IO_SYNC;
1150 error = ffs_truncate(tvp, (off_t)0, ioflag,
1151 tcnp->cn_cred);
1152 if (error)
1153 goto bad;
1154 }
1155 VN_KNOTE(tdvp, NOTE_WRITE);
1156 vput(tdvp);
1157 VN_KNOTE(tvp, NOTE_DELETE);
1158 vput(tvp);
1159 xp = NULL;
1160 }
1161
1162 /*
1163 * tvp and tdvp have been cleaned up. only fvp and fdvp (both
1164 * unlocked) remain. We are about to overwrite fvp but we have to
1165 * keep 'ip' intact so we cannot release the old fvp, which is still
1166 * refd and accessible via ap->a_fvp.
1167 *
1168 * This means we cannot use either 'bad' or 'out' to cleanup any
1169 * more.
1170 */
1171
1172 /*
1173 * 3) Unlink the source.
1174 */
1175 fcnp->cn_flags &= ~CNP_MODMASK;
1176 fcnp->cn_flags |= CNP_LOCKPARENT;
1177 error = relookup(fdvp, &fvp, fcnp);
1178 if (error || fvp == NULL) {
1179 /*
1180 * From name has disappeared. IN_RENAME will not be set if
1181 * we get past the panic so we don't have to clean it up.
1182 */
1183 if (doingdirectory)
1184 panic("ufs_rename: lost dir entry");
1185 vrele(ap->a_fvp);
1186 if (fcnp->cn_flags & CNP_PDIRUNLOCK)
1187 vrele(fdvp);
1188 else
1189 vput(fdvp);
1190 return(0);
1191 }
1192 KKASSERT((fcnp->cn_flags & CNP_PDIRUNLOCK) == 0);
1193
1194 /*
1195 * fdvp and fvp are locked.
1196 */
1197 xp = VTOI(fvp);
1198 dp = VTOI(fdvp);
1199
1200 /*
1201 * Ensure that the directory entry still exists and has not
1202 * changed while the new name has been entered. If the source is
1203 * a file then the entry may have been unlinked or renamed. In
1204 * either case there is no further work to be done. If the source
1205 * is a directory then it cannot have been rmdir'ed; the IN_RENAME
1206 * flag ensures that it cannot be moved by another rename or removed
1207 * by a rmdir. Cleanup IN_RENAME.
1208 */
1209 if (xp != ip) {
1210 if (doingdirectory)
1211 panic("ufs_rename: lost dir entry");
1212 } else {
1213 /*
1214 * If the source is a directory with a
1215 * new parent, the link count of the old
1216 * parent directory must be decremented
1217 * and ".." set to point to the new parent.
1218 */
1219 if (doingdirectory && newparent) {
1220 xp->i_offset = mastertemplate.dot_reclen;
1221 ufs_dirrewrite(xp, dp, newparent, DT_DIR, 0);
1222 /* cache_purge removed - handled by VFS compat layer */
1223 }
1224 error = ufs_dirremove(fdvp, xp, fcnp->cn_flags, 0);
1225 xp->i_flag &= ~IN_RENAME;
1226 }
1227
1228 VN_KNOTE(fvp, NOTE_RENAME);
1229 vput(fdvp);
1230 vput(fvp);
1231 vrele(ap->a_fvp);
1232 return (error);
1233
1234 bad:
1235 if (xp)
1236 vput(ITOV(xp));
1237 vput(ITOV(dp));
1238 out:
1239 if (doingdirectory)
1240 ip->i_flag &= ~IN_RENAME;
1241 if (vn_lock(fvp, LK_EXCLUSIVE | LK_FAILRECLAIM) == 0) {
1242 ip->i_effnlink--;
1243 ip->i_nlink--;
1244 ip->i_flag |= IN_CHANGE;
1245 ip->i_flag &= ~IN_RENAME;
1246 if (DOINGSOFTDEP(fvp))
1247 softdep_change_linkcnt(ip);
1248 vput(fvp);
1249 } else {
1250 vrele(fvp);
1251 }
1252 return (error);
1253 }
1254
1255 /*
1256 * Mkdir system call
1257 *
1258 * ufs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp,
1259 * struct componentname *a_cnp, struct vattr *a_vap)
1260 */
1261 static
1262 int
1263 ufs_mkdir(struct vop_old_mkdir_args *ap)
1264 {
1265 struct vnode *dvp = ap->a_dvp;
1266 struct vattr *vap = ap->a_vap;
1267 struct componentname *cnp = ap->a_cnp;
1268 struct inode *ip, *dp;
1269 struct vnode *tvp;
1270 struct buf *bp;
1271 struct dirtemplate dirtemplate, *dtp;
1272 struct direct newdir;
1273 int error, dmode;
1274 long blkoff;
1275
1276 dp = VTOI(dvp);
1277 if ((nlink_t)dp->i_nlink >= LINK_MAX) {
1278 error = EMLINK;
1279 goto out;
1280 }
1281 dmode = vap->va_mode & 0777;
1282 dmode |= IFDIR;
1283 /*
1284 * Must simulate part of ufs_makeinode here to acquire the inode,
1285 * but not have it entered in the parent directory. The entry is
1286 * made later after writing "." and ".." entries.
1287 */
1288 error = ffs_valloc(dvp, dmode, cnp->cn_cred, &tvp);
1289 if (error)
1290 goto out;
1291 ip = VTOI(tvp);
1292 ip->i_gid = dp->i_gid;
1293 #ifdef SUIDDIR
1294 {
1295 #ifdef QUOTA
1296 struct ucred ucred, *ucp;
1297 ucp = cnp->cn_cred;
1298 #endif
1299 /*
1300 * If we are hacking owners here, (only do this where told to)
1301 * and we are not giving it TO root, (would subvert quotas)
1302 * then go ahead and give it to the other user.
1303 * The new directory also inherits the SUID bit.
1304 * If user's UID and dir UID are the same,
1305 * 'give it away' so that the SUID is still forced on.
1306 */
1307 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
1308 (dp->i_mode & ISUID) && dp->i_uid) {
1309 dmode |= ISUID;
1310 ip->i_uid = dp->i_uid;
1311 #ifdef QUOTA
1312 if (dp->i_uid != cnp->cn_cred->cr_uid) {
1313 /*
1314 * Make sure the correct user gets charged
1315 * for the space.
1316 * Make a dummy credential for the victim.
1317 * XXX This seems to never be accessed out of
1318 * our context so a stack variable is ok.
1319 */
1320 ucred.cr_ref = 1;
1321 ucred.cr_uid = ip->i_uid;
1322 ucred.cr_ngroups = 1;
1323 ucred.cr_groups[0] = dp->i_gid;
1324 ucp = &ucred;
1325 }
1326 #endif
1327 } else
1328 ip->i_uid = cnp->cn_cred->cr_uid;
1329 #ifdef QUOTA
1330 if ((error = ufs_getinoquota(ip)) ||
1331 (error = ufs_chkiq(ip, 1, ucp, 0))) {
1332 ffs_vfree(tvp, ip->i_number, dmode);
1333 vput(tvp);
1334 return (error);
1335 }
1336 #endif
1337 }
1338 #else /* !SUIDDIR */
1339 ip->i_uid = cnp->cn_cred->cr_uid;
1340 #ifdef QUOTA
1341 if ((error = ufs_getinoquota(ip)) ||
1342 (error = ufs_chkiq(ip, 1, cnp->cn_cred, 0))) {
1343 ffs_vfree(tvp, ip->i_number, dmode);
1344 vput(tvp);
1345 return (error);
1346 }
1347 #endif
1348 #endif /* !SUIDDIR */
1349 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1350 ip->i_mode = dmode;
1351 tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */
1352 ip->i_effnlink = 2;
1353 ip->i_nlink = 2;
1354 if (DOINGSOFTDEP(tvp))
1355 softdep_change_linkcnt(ip);
1356 if (cnp->cn_flags & CNP_ISWHITEOUT)
1357 ip->i_flags |= UF_OPAQUE;
1358
1359 /*
1360 * Bump link count in parent directory to reflect work done below.
1361 * Should be done before reference is created so cleanup is
1362 * possible if we crash.
1363 */
1364 dp->i_effnlink++;
1365 dp->i_nlink++;
1366 dp->i_flag |= IN_CHANGE;
1367 if (DOINGSOFTDEP(dvp))
1368 softdep_change_linkcnt(dp);
1369 error = ffs_update(tvp, !(DOINGSOFTDEP(dvp) | DOINGASYNC(dvp)));
1370 if (error)
1371 goto bad;
1372
1373 /*
1374 * The vnode must have a VM object in order to issue buffer cache
1375 * ops on it.
1376 */
1377 vinitvmio(tvp, DIRBLKSIZ, DIRBLKSIZ, -1);
1378
1379 /*
1380 * Initialize directory with "." and ".." from static template.
1381 */
1382 if (dvp->v_mount->mnt_maxsymlinklen > 0)
1383 dtp = &mastertemplate;
1384 else
1385 dtp = (struct dirtemplate *)&omastertemplate;
1386 dirtemplate = *dtp;
1387 dirtemplate.dot_ino = ip->i_number;
1388 dirtemplate.dotdot_ino = dp->i_number;
1389 nvnode_pager_setsize(tvp, DIRBLKSIZ, DIRBLKSIZ, -1);
1390 error = VOP_BALLOC(tvp, 0LL, DIRBLKSIZ, cnp->cn_cred, B_CLRBUF, &bp);
1391 if (error)
1392 goto bad;
1393 ip->i_size = DIRBLKSIZ;
1394 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1395 bcopy((caddr_t)&dirtemplate, (caddr_t)bp->b_data, sizeof dirtemplate);
1396 if (DOINGSOFTDEP(tvp)) {
1397 /*
1398 * Ensure that the entire newly allocated block is a
1399 * valid directory so that future growth within the
1400 * block does not have to ensure that the block is
1401 * written before the inode.
1402 */
1403 blkoff = DIRBLKSIZ;
1404 while (blkoff < bp->b_bcount) {
1405 ((struct direct *)
1406 (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ;
1407 blkoff += DIRBLKSIZ;
1408 }
1409 }
1410 if ((error = ffs_update(tvp, !(DOINGSOFTDEP(tvp) |
1411 DOINGASYNC(tvp)))) != 0) {
1412 bwrite(bp);
1413 goto bad;
1414 }
1415 /*
1416 * Directory set up, now install its entry in the parent directory.
1417 *
1418 * If we are not doing soft dependencies, then we must write out the
1419 * buffer containing the new directory body before entering the new
1420 * name in the parent. If we are doing soft dependencies, then the
1421 * buffer containing the new directory body will be passed to and
1422 * released in the soft dependency code after the code has attached
1423 * an appropriate ordering dependency to the buffer which ensures that
1424 * the buffer is written before the new name is written in the parent.
1425 */
1426 if (DOINGASYNC(dvp))
1427 bdwrite(bp);
1428 else if (!DOINGSOFTDEP(dvp) && (error = bwrite(bp)) != 0)
1429 goto bad;
1430 ufs_makedirentry(ip, cnp, &newdir);
1431 error = ufs_direnter(dvp, tvp, &newdir, cnp, bp);
1432
1433 bad:
1434 if (error == 0) {
1435 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1436 *ap->a_vpp = tvp;
1437 } else {
1438 dp->i_effnlink--;
1439 dp->i_nlink--;
1440 dp->i_flag |= IN_CHANGE;
1441 if (DOINGSOFTDEP(dvp))
1442 softdep_change_linkcnt(dp);
1443 /*
1444 * No need to do an explicit VOP_TRUNCATE here, vrele will
1445 * do this for us because we set the link count to 0.
1446 */
1447 ip->i_effnlink = 0;
1448 ip->i_nlink = 0;
1449 ip->i_flag |= IN_CHANGE;
1450 if (DOINGSOFTDEP(tvp))
1451 softdep_change_linkcnt(ip);
1452 vput(tvp);
1453 }
1454 out:
1455 return (error);
1456 }
1457
1458 /*
1459 * Rmdir system call.
1460 *
1461 * ufs_rmdir(struct vnode *a_dvp, struct vnode *a_vp,
1462 * struct componentname *a_cnp)
1463 */
1464 static
1465 int
1466 ufs_rmdir(struct vop_old_rmdir_args *ap)
1467 {
1468 struct vnode *vp = ap->a_vp;
1469 struct vnode *dvp = ap->a_dvp;
1470 struct componentname *cnp = ap->a_cnp;
1471 struct inode *ip, *dp;
1472 int error, ioflag;
1473
1474 ip = VTOI(vp);
1475 dp = VTOI(dvp);
1476
1477 /*
1478 * Do not remove a directory that is in the process of being renamed.
1479 * Verify the directory is empty (and valid). Rmdir ".." will not be
1480 * valid since ".." will contain a reference to the current directory
1481 * and thus be non-empty. Do not allow the removal of mounted on
1482 * directories (this can happen when an NFS exported filesystem
1483 * tries to remove a locally mounted on directory).
1484 */
1485 error = 0;
1486 if (ip->i_flag & IN_RENAME) {
1487 error = EINVAL;
1488 goto out;
1489 }
1490 if (ip->i_effnlink != 2 ||
1491 !ufs_dirempty(ip, dp->i_number, cnp->cn_cred)) {
1492 error = ENOTEMPTY;
1493 goto out;
1494 }
1495 #if 0 /* handled by kernel now */
1496 if ((dp->i_flags & APPEND)
1497 || (ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
1498 error = EPERM;
1499 goto out;
1500 }
1501 #endif
1502 /*
1503 * Delete reference to directory before purging
1504 * inode. If we crash in between, the directory
1505 * will be reattached to lost+found,
1506 */
1507 dp->i_effnlink--;
1508 ip->i_effnlink--;
1509 if (DOINGSOFTDEP(vp)) {
1510 softdep_change_linkcnt(dp);
1511 softdep_change_linkcnt(ip);
1512 }
1513 error = ufs_dirremove(dvp, ip, cnp->cn_flags, 1);
1514 if (error) {
1515 dp->i_effnlink++;
1516 ip->i_effnlink++;
1517 if (DOINGSOFTDEP(vp)) {
1518 softdep_change_linkcnt(dp);
1519 softdep_change_linkcnt(ip);
1520 }
1521 goto out;
1522 }
1523 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1524 /*
1525 * Truncate inode. The only stuff left in the directory is "." and
1526 * "..". The "." reference is inconsequential since we are quashing
1527 * it. The soft dependency code will arrange to do these operations
1528 * after the parent directory entry has been deleted on disk, so
1529 * when running with that code we avoid doing them now.
1530 */
1531 if (!DOINGSOFTDEP(vp)) {
1532 dp->i_nlink--;
1533 dp->i_flag |= IN_CHANGE;
1534 ip->i_nlink--;
1535 ip->i_flag |= IN_CHANGE;
1536 ioflag = DOINGASYNC(vp) ? 0 : IO_SYNC;
1537 error = ffs_truncate(vp, (off_t)0, ioflag, cnp->cn_cred);
1538 }
1539 /* cache_purge removed - handled by VFS compat layer */
1540 #ifdef UFS_DIRHASH
1541 /* Kill any active hash; i_effnlink == 0, so it will not come back. */
1542 if (ip->i_dirhash != NULL)
1543 ufsdirhash_free(ip);
1544 #endif
1545 out:
1546 VN_KNOTE(vp, NOTE_DELETE);
1547 return (error);
1548 }
1549
1550 /*
1551 * symlink -- make a symbolic link
1552 *
1553 * ufs_symlink(struct vnode *a_dvp, struct vnode **a_vpp,
1554 * struct componentname *a_cnp, struct vattr *a_vap,
1555 * char *a_target)
1556 */
1557 static
1558 int
1559 ufs_symlink(struct vop_old_symlink_args *ap)
1560 {
1561 struct vnode *vp, **vpp = ap->a_vpp;
1562 struct inode *ip;
1563 int len, error;
1564
1565 error = ufs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
1566 vpp, ap->a_cnp);
1567 if (error)
1568 return (error);
1569 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
1570 vp = *vpp;
1571 len = strlen(ap->a_target);
1572 if (len < vp->v_mount->mnt_maxsymlinklen) {
1573 ip = VTOI(vp);
1574 bcopy(ap->a_target, (char *)ip->i_shortlink, len);
1575 ip->i_size = len;
1576 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1577 } else {
1578 /*
1579 * Make sure we have a VM object in order to use
1580 * the buffer cache.
1581 */
1582 if (vp->v_object == NULL)
1583 vinitvmio(vp, 0, PAGE_SIZE, -1);
1584 error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
1585 UIO_SYSSPACE, IO_NODELOCKED,
1586 ap->a_cnp->cn_cred, NULL);
1587 }
1588 if (error)
1589 vput(vp);
1590 return (error);
1591 }
1592
1593 /*
1594 * Vnode op for reading directories.
1595 *
1596 * ufs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred,
1597 * int *a_eofflag, int *ncookies, off_t **a_cookies)
1598 */
1599 static
1600 int
1601 ufs_readdir(struct vop_readdir_args *ap)
1602 {
1603 struct uio *uio = ap->a_uio;
1604 struct vnode *vp = ap->a_vp;
1605 struct direct *dp;
1606 struct buf *bp;
1607 int retval;
1608 int error;
1609 int offset; /* offset into buffer cache buffer */
1610 int eoffset; /* end of buffer clipped to file EOF */
1611 int pickup; /* pickup point */
1612 int ncookies;
1613 int cookie_index;
1614 off_t *cookies;
1615
1616 if (uio->uio_offset < 0)
1617 return (EINVAL);
1618 /*
1619 * Guess the number of cookies needed. Make sure we compute at
1620 * least 1, and no more then a reasonable limit.
1621 */
1622 if (ap->a_ncookies) {
1623 ncookies = uio->uio_resid / 16 + 1;
1624 if (ncookies > 1024)
1625 ncookies = 1024;
1626 cookies = kmalloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
1627 } else {
1628 ncookies = -1; /* force conditionals below */
1629 cookies = NULL;
1630 }
1631 cookie_index = 0;
1632
1633 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM);
1634 if (error)
1635 return (error);
1636
1637 /*
1638 * Past or at EOF
1639 */
1640 if (uio->uio_offset >= VTOI(vp)->i_size) {
1641 if (ap->a_eofflag)
1642 *ap->a_eofflag = 1;
1643 if (ap->a_ncookies) {
1644 *ap->a_ncookies = cookie_index;
1645 *ap->a_cookies = cookies;
1646 }
1647 goto done;
1648 }
1649
1650 /*
1651 * Loop until we run out of cookies, we run out of user buffer,
1652 * or we hit the directory EOF.
1653 *
1654 * Always start scans at the beginning of the buffer, don't trust
1655 * the offset supplied by userland.
1656 */
1657 while ((error = ffs_blkatoff_ra(vp, uio->uio_offset, NULL, &bp, 2)) == 0) {
1658 pickup = (int)(uio->uio_offset - bp->b_loffset);
1659 offset = 0;
1660 retval = 0;
1661 if (bp->b_loffset + bp->b_bcount > VTOI(vp)->i_size)
1662 eoffset = (int)(VTOI(vp)->i_size - bp->b_loffset);
1663 else
1664 eoffset = bp->b_bcount;
1665
1666 while (offset < eoffset) {
1667 dp = (struct direct *)(bp->b_data + offset);
1668 if (dp->d_reclen <= 0 || (dp->d_reclen & 3) ||
1669 offset + dp->d_reclen > bp->b_bcount) {
1670 error = EIO;
1671 break;
1672 }
1673 if (offsetof(struct direct, d_name[dp->d_namlen]) > dp->d_reclen) {
1674 error = EIO;
1675 break;
1676 }
1677 if (offset < pickup) {
1678 offset += dp->d_reclen;
1679 continue;
1680 }
1681 #if BYTE_ORDER == LITTLE_ENDIAN
1682 if (OFSFMT(vp)) {
1683 retval = vop_write_dirent(&error, uio,
1684 dp->d_ino, dp->d_namlen, dp->d_type,
1685 dp->d_name);
1686 } else
1687 #endif
1688 {
1689 retval = vop_write_dirent(&error, uio,
1690 dp->d_ino, dp->d_type, dp->d_namlen,
1691 dp->d_name);
1692 }
1693 if (retval)
1694 break;
1695 if (cookies)
1696 cookies[cookie_index] = bp->b_loffset + offset;
1697 ++cookie_index;
1698 offset += dp->d_reclen;
1699 if (cookie_index == ncookies)
1700 break;
1701 }
1702
1703 /*
1704 * This will align the next loop to the beginning of the
1705 * next block, and pickup will calculate to 0.
1706 */
1707 uio->uio_offset = bp->b_loffset + offset;
1708 brelse(bp);
1709
1710 if (retval || error || cookie_index == ncookies ||
1711 uio->uio_offset >= VTOI(vp)->i_size) {
1712 break;
1713 }
1714 }
1715 if (ap->a_eofflag)
1716 *ap->a_eofflag = VTOI(vp)->i_size <= uio->uio_offset;
1717
1718 /*
1719 * Report errors only if we didn't manage to read anything
1720 */
1721 if (error && cookie_index == 0) {
1722 if (cookies) {
1723 kfree(cookies, M_TEMP);
1724 *ap->a_ncookies = 0;
1725 *ap->a_cookies = NULL;
1726 }
1727 } else {
1728 error = 0;
1729 if (cookies) {
1730 *ap->a_ncookies = cookie_index;
1731 *ap->a_cookies = cookies;
1732 }
1733 }
1734 done:
1735 vn_unlock(vp);
1736 return (error);
1737 }
1738
1739 /*
1740 * Return target name of a symbolic link
1741 *
1742 * ufs_readlink(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred)
1743 */
1744 static
1745 int
1746 ufs_readlink(struct vop_readlink_args *ap)
1747 {
1748 struct vnode *vp = ap->a_vp;
1749 struct inode *ip = VTOI(vp);
1750 int isize;
1751
1752 isize = ip->i_size;
1753 if ((isize < vp->v_mount->mnt_maxsymlinklen) ||
1754 (ip->i_din.di_blocks == 0)) { /* XXX - for old fastlink support */
1755 uiomove((char *)ip->i_shortlink, isize, ap->a_uio);
1756 return (0);
1757 }
1758
1759 /*
1760 * Perform the equivalent of an OPEN on vp so we can issue a
1761 * VOP_READ.
1762 */
1763 return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
1764 }
1765
1766 /*
1767 * Calculate the logical to physical mapping if not done already,
1768 * then call the device strategy routine.
1769 *
1770 * In order to be able to swap to a file, the VOP_BMAP operation may not
1771 * deadlock on memory. See ufs_bmap() for details.
1772 *
1773 * ufs_strategy(struct vnode *a_vp, struct bio *a_bio)
1774 */
1775 static
1776 int
1777 ufs_strategy(struct vop_strategy_args *ap)
1778 {
1779 struct bio *bio = ap->a_bio;
1780 struct bio *nbio;
1781 struct buf *bp = bio->bio_buf;
1782 struct vnode *vp = ap->a_vp;
1783 struct inode *ip;
1784 int error;
1785
1786 ip = VTOI(vp);
1787 if (vp->v_type == VBLK || vp->v_type == VCHR)
1788 panic("ufs_strategy: spec");
1789 nbio = push_bio(bio);
1790 if (nbio->bio_offset == NOOFFSET) {
1791 error = VOP_BMAP(vp, bio->bio_offset, &nbio->bio_offset,
1792 NULL, NULL, bp->b_cmd);
1793 if (error) {
1794 bp->b_error = error;
1795 bp->b_flags |= B_ERROR;
1796 /* I/O was never started on nbio, must biodone(bio) */
1797 biodone(bio);
1798 return (error);
1799 }
1800 if (nbio->bio_offset == NOOFFSET)
1801 vfs_bio_clrbuf(bp);
1802 }
1803 if (nbio->bio_offset == NOOFFSET) {
1804 /*
1805 * We hit a hole in the file. The buffer has been zero-filled
1806 * so just biodone() it.
1807 */
1808 biodone(bio);
1809 } else {
1810 vn_strategy(ip->i_devvp, nbio);
1811 }
1812 return (0);
1813 }
1814
1815 /*
1816 * Print out the contents of an inode.
1817 *
1818 * ufs_print(struct vnode *a_vp)
1819 */
1820 static
1821 int
1822 ufs_print(struct vop_print_args *ap)
1823 {
1824 struct vnode *vp = ap->a_vp;
1825 struct inode *ip = VTOI(vp);
1826
1827 kprintf("tag VT_UFS, ino %lu, on dev %s (%d, %d)",
1828 (u_long)ip->i_number, devtoname(ip->i_dev), major(ip->i_dev),
1829 minor(ip->i_dev));
1830 if (vp->v_type == VFIFO)
1831 fifo_printinfo(vp);
1832 lockmgr_printinfo(&vp->v_lock);
1833 kprintf("\n");
1834 return (0);
1835 }
1836
1837 /*
1838 * Read wrapper for fifos.
1839 *
1840 * ufsfifo_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
1841 * struct ucred *a_cred)
1842 */
1843 static
1844 int
1845 ufsfifo_read(struct vop_read_args *ap)
1846 {
1847 int error, resid;
1848 struct inode *ip;
1849 struct uio *uio;
1850
1851 uio = ap->a_uio;
1852 resid = uio->uio_resid;
1853 error = VOCALL(&fifo_vnode_vops, &ap->a_head);
1854 ip = VTOI(ap->a_vp);
1855 if ((ap->a_vp->v_mount->mnt_flag & MNT_NOATIME) == 0 && ip != NULL &&
1856 (uio->uio_resid != resid || (error == 0 && resid != 0)))
1857 VTOI(ap->a_vp)->i_flag |= IN_ACCESS;
1858 return (error);
1859 }
1860
1861 /*
1862 * Write wrapper for fifos.
1863 *
1864 * ufsfifo_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
1865 * struct ucred *a_cred)
1866 */
1867 static
1868 int
1869 ufsfifo_write(struct vop_write_args *ap)
1870 {
1871 int error, resid;
1872 struct inode *ip;
1873 struct uio *uio;
1874
1875 uio = ap->a_uio;
1876 resid = uio->uio_resid;
1877 error = VOCALL(&fifo_vnode_vops, &ap->a_head);
1878 ip = VTOI(ap->a_vp);
1879 if (ip != NULL && (uio->uio_resid != resid || (error == 0 && resid != 0)))
1880 VTOI(ap->a_vp)->i_flag |= IN_CHANGE | IN_UPDATE;
1881 return (error);
1882 }
1883
1884 /*
1885 * Close wrapper for fifos.
1886 *
1887 * Update the times on the inode then do device close.
1888 *
1889 * ufsfifo_close(struct vnode *a_vp, int a_fflag)
1890 */
1891 static
1892 int
1893 ufsfifo_close(struct vop_close_args *ap)
1894 {
1895 struct vnode *vp = ap->a_vp;
1896
1897 if (VREFCNT(vp) > 1)
1898 ufs_itimes(vp);
1899 return (VOCALL(&fifo_vnode_vops, &ap->a_head));
1900 }
1901
1902 /*
1903 * Kqfilter wrapper for fifos.
1904 *
1905 * Fall through to ufs kqfilter routines if needed
1906 */
1907 static
1908 int
1909 ufsfifo_kqfilter(struct vop_kqfilter_args *ap)
1910 {
1911 int error;
1912
1913 error = VOCALL(&fifo_vnode_vops, &ap->a_head);
1914 if (error)
1915 error = ufs_kqfilter(ap);
1916 return (error);
1917 }
1918
1919 /*
1920 * Advisory record locking support
1921 *
1922 * ufs_advlock(struct vnode *a_vp, caddr_t a_id, int a_op, struct flock *a_fl,
1923 * int a_flags)
1924 */
1925 static
1926 int
1927 ufs_advlock(struct vop_advlock_args *ap)
1928 {
1929 struct inode *ip = VTOI(ap->a_vp);
1930
1931 return (lf_advlock(ap, &(ip->i_lockf), ip->i_size));
1932 }
1933
1934 /*
1935 * Initialize the vnode associated with a new inode, handle aliased
1936 * vnodes.
1937 *
1938 * Make sure directories have their VM object now rather then later,
1939 * saving us from having to check on all the myrid directory VOPs
1940 * that might be executed without a VOP_OPEN being performed.
1941 */
1942 int
1943 ufs_vinit(struct mount *mntp, struct vnode **vpp)
1944 {
1945 struct inode *ip;
1946 struct vnode *vp;
1947 struct timeval tv;
1948
1949 vp = *vpp;
1950 ip = VTOI(vp);
1951
1952 vp->v_type = IFTOVT(ip->i_mode);
1953
1954 switch(vp->v_type) {
1955 case VCHR:
1956 case VBLK:
1957 vp->v_ops = &mntp->mnt_vn_spec_ops;
1958 addaliasu(vp, umajor(ip->i_rdev), uminor(ip->i_rdev));
1959 break;
1960 case VFIFO:
1961 vp->v_ops = &mntp->mnt_vn_fifo_ops;
1962 break;
1963 case VDIR:
1964 case VREG:
1965 vinitvmio(vp, ip->i_size,
1966 blkoffsize(ip->i_fs, ip, ip->i_size),
1967 blkoff(ip->i_fs, ip->i_size));
1968 break;
1969 case VLNK:
1970 if (ip->i_size >= vp->v_mount->mnt_maxsymlinklen) {
1971 vinitvmio(vp, ip->i_size,
1972 blkoffsize(ip->i_fs, ip, ip->i_size),
1973 blkoff(ip->i_fs, ip->i_size));
1974 }
1975 break;
1976 default:
1977 break;
1978
1979 }
1980
1981 if (ip->i_number == ROOTINO)
1982 vsetflags(vp, VROOT);
1983 /*
1984 * Initialize modrev times
1985 */
1986 getmicrouptime(&tv);
1987 SETHIGH(ip->i_modrev, tv.tv_sec);
1988 SETLOW(ip->i_modrev, tv.tv_usec * 4294);
1989 *vpp = vp;
1990 return (0);
1991 }
1992
1993 /*
1994 * Allocate a new inode.
1995 */
1996 static
1997 int
1998 ufs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
1999 struct componentname *cnp)
2000 {
2001 struct inode *ip, *pdir;
2002 struct direct newdir;
2003 struct vnode *tvp;
2004 int error;
2005
2006 pdir = VTOI(dvp);
2007 *vpp = NULL;
2008 if ((mode & IFMT) == 0)
2009 mode |= IFREG;
2010
2011 error = ffs_valloc(dvp, mode, cnp->cn_cred, &tvp);
2012 if (error)
2013 return (error);
2014 ip = VTOI(tvp);
2015 ip->i_flags = pdir->i_flags & (SF_NOHISTORY|UF_NOHISTORY|UF_NODUMP);
2016 ip->i_gid = pdir->i_gid;
2017 #ifdef SUIDDIR
2018 {
2019 #ifdef QUOTA
2020 struct ucred ucred, *ucp;
2021 ucp = cnp->cn_cred;
2022 #endif
2023 /*
2024 * If we are not the owner of the directory,
2025 * and we are hacking owners here, (only do this where told to)
2026 * and we are not giving it TO root, (would subvert quotas)
2027 * then go ahead and give it to the other user.
2028 * Note that this drops off the execute bits for security.
2029 */
2030 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
2031 (pdir->i_mode & ISUID) &&
2032 (pdir->i_uid != cnp->cn_cred->cr_uid) && pdir->i_uid) {
2033 ip->i_uid = pdir->i_uid;
2034 mode &= ~07111;
2035 #ifdef QUOTA
2036 /*
2037 * Make sure the correct user gets charged
2038 * for the space.
2039 * Quickly knock up a dummy credential for the victim.
2040 * XXX This seems to never be accessed out of our
2041 * context so a stack variable is ok.
2042 */
2043 ucred.cr_ref = 1;
2044 ucred.cr_uid = ip->i_uid;
2045 ucred.cr_ngroups = 1;
2046 ucred.cr_groups[0] = pdir->i_gid;
2047 ucp = &ucred;
2048 #endif
2049 } else
2050 ip->i_uid = cnp->cn_cred->cr_uid;
2051
2052 #ifdef QUOTA
2053 if ((error = ufs_getinoquota(ip)) ||
2054 (error = ufs_chkiq(ip, 1, ucp, 0))) {
2055 ffs_vfree(tvp, ip->i_number, mode);
2056 vput(tvp);
2057 return (error);
2058 }
2059 #endif
2060 }
2061 #else /* !SUIDDIR */
2062 ip->i_uid = cnp->cn_cred->cr_uid;
2063 #ifdef QUOTA
2064 if ((error = ufs_getinoquota(ip)) ||
2065 (error = ufs_chkiq(ip, 1, cnp->cn_cred, 0))) {
2066 ffs_vfree(tvp, ip->i_number, mode);
2067 vput(tvp);
2068 return (error);
2069 }
2070 #endif
2071 #endif /* !SUIDDIR */
2072 ip->i_din.di_spare[0] = 0;
2073 ip->i_din.di_spare[1] = 0;
2074 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
2075 ip->i_mode = mode;
2076 tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */
2077 ip->i_effnlink = 1;
2078 ip->i_nlink = 1;
2079 if (DOINGSOFTDEP(tvp))
2080 softdep_change_linkcnt(ip);
2081 if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred) &&
2082 priv_check_cred(cnp->cn_cred, PRIV_VFS_SETGID, 0)) {
2083 ip->i_mode &= ~ISGID;
2084 }
2085
2086 if (cnp->cn_flags & CNP_ISWHITEOUT)
2087 ip->i_flags |= UF_OPAQUE;
2088
2089 /*
2090 * Regular files and directories need VM objects. Softlinks do
2091 * not (not immediately anyway).
2092 */
2093 if (tvp->v_type == VREG || tvp->v_type == VDIR)
2094 vinitvmio(tvp, 0, PAGE_SIZE, -1);
2095
2096 /*
2097 * Make sure inode goes to disk before directory entry.
2098 */
2099 error = ffs_update(tvp, !(DOINGSOFTDEP(tvp) | DOINGASYNC(tvp)));
2100 if (error)
2101 goto bad;
2102 ufs_makedirentry(ip, cnp, &newdir);
2103 error = ufs_direnter(dvp, tvp, &newdir, cnp, NULL);
2104 if (error)
2105 goto bad;
2106 *vpp = tvp;
2107 return (0);
2108
2109 bad:
2110 /*
2111 * Write error occurred trying to update the inode
2112 * or the directory so must deallocate the inode.
2113 */
2114 ip->i_effnlink = 0;
2115 ip->i_nlink = 0;
2116 ip->i_flag |= IN_CHANGE;
2117 if (DOINGSOFTDEP(tvp))
2118 softdep_change_linkcnt(ip);
2119 vput(tvp);
2120 return (error);
2121 }
2122
2123 static int
2124 ufs_missingop(struct vop_generic_args *ap)
2125 {
2126 panic("no vop function for %s in ufs child", ap->a_desc->sd_name);
2127 return (EOPNOTSUPP);
2128 }
2129
2130 static struct filterops ufsread_filtops =
2131 { FILTEROP_ISFD, NULL, filt_ufsdetach, filt_ufsread };
2132 static struct filterops ufswrite_filtops =
2133 { FILTEROP_ISFD, NULL, filt_ufsdetach, filt_ufswrite };
2134 static struct filterops ufsvnode_filtops =
2135 { FILTEROP_ISFD, NULL, filt_ufsdetach, filt_ufsvnode };
2136
2137 /*
2138 * ufs_kqfilter(struct vnode *a_vp, struct knote *a_kn)
2139 */
2140 static int
2141 ufs_kqfilter(struct vop_kqfilter_args *ap)
2142 {
2143 struct vnode *vp = ap->a_vp;
2144 struct knote *kn = ap->a_kn;
2145
2146 switch (kn->kn_filter) {
2147 case EVFILT_READ:
2148 kn->kn_fop = &ufsread_filtops;
2149 break;
2150 case EVFILT_WRITE:
2151 kn->kn_fop = &ufswrite_filtops;
2152 break;
2153 case EVFILT_VNODE:
2154 kn->kn_fop = &ufsvnode_filtops;
2155 break;
2156 default:
2157 return (EOPNOTSUPP);
2158 }
2159
2160 kn->kn_hook = (caddr_t)vp;
2161
2162 /* XXX: kq token actually protects the list */
2163 lwkt_gettoken(&vp->v_token);
2164 knote_insert(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
2165 lwkt_reltoken(&vp->v_token);
2166
2167 return (0);
2168 }
2169
2170 static void
2171 filt_ufsdetach(struct knote *kn)
2172 {
2173 struct vnode *vp = (struct vnode *)kn->kn_hook;
2174
2175 lwkt_gettoken(&vp->v_token);
2176 knote_remove(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
2177 lwkt_reltoken(&vp->v_token);
2178 }
2179
2180 /*ARGSUSED*/
2181 static int
2182 filt_ufsread(struct knote *kn, long hint)
2183 {
2184 struct vnode *vp = (struct vnode *)kn->kn_hook;
2185 struct inode *ip = VTOI(vp);
2186 off_t off;
2187
2188 /*
2189 * filesystem is gone, so set the EOF flag and schedule
2190 * the knote for deletion.
2191 */
2192 if (hint == NOTE_REVOKE) {
2193 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
2194 return (1);
2195 }
2196
2197 off = ip->i_size - kn->kn_fp->f_offset;
2198 kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
2199 if (kn->kn_sfflags & NOTE_OLDAPI)
2200 return(1);
2201 return (kn->kn_data != 0);
2202 }
2203
2204 /*ARGSUSED*/
2205 static int
2206 filt_ufswrite(struct knote *kn, long hint)
2207 {
2208 /*
2209 * filesystem is gone, so set the EOF flag and schedule
2210 * the knote for deletion.
2211 */
2212 if (hint == NOTE_REVOKE)
2213 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
2214
2215 kn->kn_data = 0;
2216 return (1);
2217 }
2218
2219 static int
2220 filt_ufsvnode(struct knote *kn, long hint)
2221 {
2222 if (kn->kn_sfflags & hint)
2223 kn->kn_fflags |= hint;
2224 if (hint == NOTE_REVOKE) {
2225 kn->kn_flags |= (EV_EOF | EV_NODATA);
2226 return (1);
2227 }
2228 return (kn->kn_fflags != 0);
2229 }
2230
2231 /* Global vfs data structures for ufs. */
2232 static struct vop_ops ufs_vnode_vops = {
2233 .vop_default = vop_defaultop,
2234 .vop_fsync = (void *)ufs_missingop,
2235 .vop_read = (void *)ufs_missingop,
2236 .vop_reallocblks = (void *)ufs_missingop,
2237 .vop_write = (void *)ufs_missingop,
2238 .vop_access = ufs_access,
2239 .vop_advlock = ufs_advlock,
2240 .vop_bmap = ufs_bmap,
2241 .vop_old_lookup = ufs_lookup,
2242 .vop_close = ufs_close,
2243 .vop_old_create = ufs_create,
2244 .vop_getattr = ufs_getattr,
2245 .vop_inactive = ufs_inactive,
2246 .vop_old_link = ufs_link,
2247 .vop_old_mkdir = ufs_mkdir,
2248 .vop_old_mknod = ufs_mknod,
2249 .vop_mmap = ufs_mmap,
2250 .vop_open = vop_stdopen,
2251 .vop_pathconf = vop_stdpathconf,
2252 .vop_kqfilter = ufs_kqfilter,
2253 .vop_print = ufs_print,
2254 .vop_readdir = ufs_readdir,
2255 .vop_readlink = ufs_readlink,
2256 .vop_reclaim = ufs_reclaim,
2257 .vop_old_remove = ufs_remove,
2258 .vop_old_rename = ufs_rename,
2259 .vop_old_rmdir = ufs_rmdir,
2260 .vop_setattr = ufs_setattr,
2261 .vop_markatime = ufs_markatime,
2262 .vop_strategy = ufs_strategy,
2263 .vop_old_symlink = ufs_symlink,
2264 .vop_old_whiteout = ufs_whiteout
2265 };
2266
2267 static struct vop_ops ufs_spec_vops = {
2268 .vop_default = vop_defaultop,
2269 .vop_fsync = (void *)ufs_missingop,
2270 .vop_access = ufs_access,
2271 .vop_close = ufs_close,
2272 .vop_getattr = ufs_getattr,
2273 .vop_inactive = ufs_inactive,
2274 .vop_print = ufs_print,
2275 .vop_read = vop_stdnoread,
2276 .vop_reclaim = ufs_reclaim,
2277 .vop_setattr = ufs_setattr,
2278 .vop_markatime = ufs_markatime,
2279 .vop_write = vop_stdnowrite
2280 };
2281
2282 static struct vop_ops ufs_fifo_vops = {
2283 .vop_default = fifo_vnoperate,
2284 .vop_fsync = (void *)ufs_missingop,
2285 .vop_access = ufs_access,
2286 .vop_close = ufsfifo_close,
2287 .vop_getattr = ufs_getattr,
2288 .vop_inactive = ufs_inactive,
2289 .vop_kqfilter = ufsfifo_kqfilter,
2290 .vop_print = ufs_print,
2291 .vop_read = ufsfifo_read,
2292 .vop_reclaim = ufs_reclaim,
2293 .vop_setattr = ufs_setattr,
2294 .vop_markatime = ufs_markatime,
2295 .vop_write = ufsfifo_write
2296 };
2297
2298 VNODEOP_SET(ufs_vnode_vops);
2299 VNODEOP_SET(ufs_spec_vops);
2300 VNODEOP_SET(ufs_fifo_vops);
2301
2302 /*
2303 * ufs_vnoperate()
2304 */
2305 int
2306 ufs_vnoperate(struct vop_generic_args *ap)
2307 {
2308 return (VOCALL(&ufs_vnode_vops, ap));
2309 }
2310
2311 /*
2312 * ufs_vnoperatefifo()
2313 */
2314 int
2315 ufs_vnoperatefifo(struct vop_generic_args *ap)
2316 {
2317 return (VOCALL(&ufs_fifo_vops, ap));
2318 }
2319
2320 /*
2321 * ufs_vnoperatespec()
2322 */
2323 int
2324 ufs_vnoperatespec(struct vop_generic_args *ap)
2325 {
2326 return (VOCALL(&ufs_spec_vops, ap));
2327 }
DragonFly BSD