?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / ufs / ext2fs / ext2fs_vnops.c
blob0553c2a24863edeb99498d952f0c5cb2dd9a3798
1 /* $NetBSD: ext2fs_vnops.c,v 1.90 2009/10/19 18:41:17 bouyer Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1986, 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)ufs_vnops.c 8.14 (Berkeley) 10/26/94
37 * Modified for ext2fs by Manuel Bouyer.
38 */
39
40 /*
41 * Copyright (c) 1997 Manuel Bouyer.
42 *
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
45 * are met:
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
53 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
54 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
55 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
56 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
57 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
61 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62 *
63 * @(#)ufs_vnops.c 8.14 (Berkeley) 10/26/94
64 * Modified for ext2fs by Manuel Bouyer.
65 */
66
67 #include <sys/cdefs.h>
68 __KERNEL_RCSID(0, "$NetBSD: ext2fs_vnops.c,v 1.90 2009/10/19 18:41:17 bouyer Exp $");
69
70 #include <sys/param.h>
71 #include <sys/systm.h>
72 #include <sys/resourcevar.h>
73 #include <sys/kernel.h>
74 #include <sys/file.h>
75 #include <sys/stat.h>
76 #include <sys/buf.h>
77 #include <sys/proc.h>
78 #include <sys/mount.h>
79 #include <sys/namei.h>
80 #include <sys/vnode.h>
81 #include <sys/lockf.h>
82 #include <sys/malloc.h>
83 #include <sys/pool.h>
84 #include <sys/signalvar.h>
85 #include <sys/kauth.h>
86
87 #include <miscfs/fifofs/fifo.h>
88 #include <miscfs/genfs/genfs.h>
89 #include <miscfs/specfs/specdev.h>
90
91 #include <ufs/ufs/inode.h>
92 #include <ufs/ufs/ufs_extern.h>
93 #include <ufs/ufs/ufsmount.h>
94
95 #include <ufs/ext2fs/ext2fs.h>
96 #include <ufs/ext2fs/ext2fs_extern.h>
97 #include <ufs/ext2fs/ext2fs_dir.h>
98
99 extern int prtactive;
100
101 static int ext2fs_chmod(struct vnode *, int, kauth_cred_t, struct lwp *);
102 static int ext2fs_chown(struct vnode *, uid_t, gid_t, kauth_cred_t,
103 struct lwp *);
104
105 union _qcvt {
106 int64_t qcvt;
107 int32_t val[2];
108 };
109
110 #define SETHIGH(q, h) { \
111 union _qcvt tmp; \
112 tmp.qcvt = (q); \
113 tmp.val[_QUAD_HIGHWORD] = (h); \
114 (q) = tmp.qcvt; \
115 }
116 #define SETLOW(q, l) { \
117 union _qcvt tmp; \
118 tmp.qcvt = (q); \
119 tmp.val[_QUAD_LOWWORD] = (l); \
120 (q) = tmp.qcvt; \
121 }
122
123 /*
124 * Create a regular file
125 */
126 int
127 ext2fs_create(void *v)
128 {
129 struct vop_create_args /* {
130 struct vnode *a_dvp;
131 struct vnode **a_vpp;
132 struct componentname *a_cnp;
133 struct vattr *a_vap;
134 } */ *ap = v;
135 int error;
136
137 error =
138 ext2fs_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode),
139 ap->a_dvp, ap->a_vpp, ap->a_cnp);
140
141 if (error)
142 return (error);
143 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
144 return (0);
145 }
146
147 /*
148 * Mknod vnode call
149 */
150 /* ARGSUSED */
151 int
152 ext2fs_mknod(void *v)
153 {
154 struct vop_mknod_args /* {
155 struct vnode *a_dvp;
156 struct vnode **a_vpp;
157 struct componentname *a_cnp;
158 struct vattr *a_vap;
159 } */ *ap = v;
160 struct vattr *vap = ap->a_vap;
161 struct vnode **vpp = ap->a_vpp;
162 struct inode *ip;
163 int error;
164 struct mount *mp;
165 ino_t ino;
166
167 if ((error = ext2fs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
168 ap->a_dvp, vpp, ap->a_cnp)) != 0)
169 return (error);
170 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
171 ip = VTOI(*vpp);
172 mp = (*vpp)->v_mount;
173 ino = ip->i_number;
174 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
175 if (vap->va_rdev != VNOVAL) {
176 /*
177 * Want to be able to use this to make badblock
178 * inodes, so don't truncate the dev number.
179 */
180 ip->i_din.e2fs_din->e2di_rdev = h2fs32(vap->va_rdev);
181 }
182 /*
183 * Remove inode so that it will be reloaded by VFS_VGET and
184 * checked to see if it is an alias of an existing entry in
185 * the inode cache.
186 */
187 VOP_UNLOCK(*vpp, 0);
188 (*vpp)->v_type = VNON;
189 vgone(*vpp);
190 error = VFS_VGET(mp, ino, vpp);
191 if (error != 0) {
192 *vpp = NULL;
193 return (error);
194 }
195 return (0);
196 }
197
198 /*
199 * Open called.
200 *
201 * Just check the APPEND flag.
202 */
203 /* ARGSUSED */
204 int
205 ext2fs_open(void *v)
206 {
207 struct vop_open_args /* {
208 struct vnode *a_vp;
209 int a_mode;
210 kauth_cred_t a_cred;
211 } */ *ap = v;
212
213 /*
214 * Files marked append-only must be opened for appending.
215 */
216 if ((VTOI(ap->a_vp)->i_e2fs_flags & EXT2_APPEND) &&
217 (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
218 return (EPERM);
219 return (0);
220 }
221
222 static int
223 ext2fs_check_possible(struct vnode *vp, struct inode *ip, mode_t mode)
224 {
225
226 /*
227 * Disallow write attempts on read-only file systems;
228 * unless the file is a socket, fifo, or a block or
229 * character device resident on the file system.
230 */
231 if (mode & VWRITE) {
232 switch (vp->v_type) {
233 case VDIR:
234 case VLNK:
235 case VREG:
236 if (vp->v_mount->mnt_flag & MNT_RDONLY)
237 return (EROFS);
238 break;
239 default:
240 break;
241 }
242 }
243
244 /* If immutable bit set, nobody gets to write it. */
245 if ((mode & VWRITE) && (ip->i_e2fs_flags & EXT2_IMMUTABLE))
246 return (EPERM);
247
248 return 0;
249 }
250
251 static int
252 ext2fs_check_permitted(struct vnode *vp, struct inode *ip, mode_t mode,
253 kauth_cred_t cred)
254 {
255
256 return genfs_can_access(vp->v_type, ip->i_e2fs_mode & ALLPERMS,
257 ip->i_uid, ip->i_gid, mode, cred);
258 }
259
260 int
261 ext2fs_access(void *v)
262 {
263 struct vop_access_args /* {
264 struct vnode *a_vp;
265 int a_mode;
266 kauth_cred_t a_cred;
267 } */ *ap = v;
268 struct vnode *vp = ap->a_vp;
269 struct inode *ip = VTOI(vp);
270 mode_t mode = ap->a_mode;
271 int error;
272
273 error = ext2fs_check_possible(vp, ip, mode);
274 if (error)
275 return error;
276
277 error = ext2fs_check_permitted(vp, ip, mode, ap->a_cred);
278
279 return error;
280 }
281
282 /* ARGSUSED */
283 int
284 ext2fs_getattr(void *v)
285 {
286 struct vop_getattr_args /* {
287 struct vnode *a_vp;
288 struct vattr *a_vap;
289 kauth_cred_t a_cred;
290 } */ *ap = v;
291 struct vnode *vp = ap->a_vp;
292 struct inode *ip = VTOI(vp);
293 struct vattr *vap = ap->a_vap;
294
295 EXT2FS_ITIMES(ip, NULL, NULL, NULL);
296 /*
297 * Copy from inode table
298 */
299 vap->va_fsid = ip->i_dev;
300 vap->va_fileid = ip->i_number;
301 vap->va_mode = ip->i_e2fs_mode & ALLPERMS;
302 vap->va_nlink = ip->i_e2fs_nlink;
303 vap->va_uid = ip->i_uid;
304 vap->va_gid = ip->i_gid;
305 vap->va_rdev = (dev_t)fs2h32(ip->i_din.e2fs_din->e2di_rdev);
306 vap->va_size = vp->v_size;
307 vap->va_atime.tv_sec = ip->i_e2fs_atime;
308 vap->va_atime.tv_nsec = 0;
309 vap->va_mtime.tv_sec = ip->i_e2fs_mtime;
310 vap->va_mtime.tv_nsec = 0;
311 vap->va_ctime.tv_sec = ip->i_e2fs_ctime;
312 vap->va_ctime.tv_nsec = 0;
313 #ifdef EXT2FS_SYSTEM_FLAGS
314 vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? SF_APPEND : 0;
315 vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? SF_IMMUTABLE : 0;
316 #else
317 vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? UF_APPEND : 0;
318 vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? UF_IMMUTABLE : 0;
319 #endif
320 vap->va_gen = ip->i_e2fs_gen;
321 /* this doesn't belong here */
322 if (vp->v_type == VBLK)
323 vap->va_blocksize = BLKDEV_IOSIZE;
324 else if (vp->v_type == VCHR)
325 vap->va_blocksize = MAXBSIZE;
326 else
327 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
328 vap->va_bytes = dbtob((u_quad_t)ip->i_e2fs_nblock);
329 vap->va_type = vp->v_type;
330 vap->va_filerev = ip->i_modrev;
331 return (0);
332 }
333
334 /*
335 * Set attribute vnode op. called from several syscalls
336 */
337 int
338 ext2fs_setattr(void *v)
339 {
340 struct vop_setattr_args /* {
341 struct vnode *a_vp;
342 struct vattr *a_vap;
343 kauth_cred_t a_cred;
344 } */ *ap = v;
345 struct vattr *vap = ap->a_vap;
346 struct vnode *vp = ap->a_vp;
347 struct inode *ip = VTOI(vp);
348 kauth_cred_t cred = ap->a_cred;
349 struct lwp *l = curlwp;
350 int error;
351
352 /*
353 * Check for unsettable attributes.
354 */
355 if ((vap->va_type != VNON) || (vap->va_nlink != (nlink_t)VNOVAL) ||
356 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
357 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
358 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
359 return (EINVAL);
360 }
361 if (vap->va_flags != VNOVAL) {
362 if (vp->v_mount->mnt_flag & MNT_RDONLY)
363 return (EROFS);
364 if (kauth_cred_geteuid(cred) != ip->i_uid &&
365 (error = kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER,
366 NULL)))
367 return (error);
368 #ifdef EXT2FS_SYSTEM_FLAGS
369 if (kauth_authorize_generic(cred, KAUTH_GENERIC_ISSUSER,
370 NULL) == 0) {
371 if ((ip->i_e2fs_flags &
372 (EXT2_APPEND | EXT2_IMMUTABLE)) &&
373 kauth_authorize_system(l->l_cred,
374 KAUTH_SYSTEM_CHSYSFLAGS, 0, NULL, NULL, NULL))
375 return (EPERM);
376 ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
377 ip->i_e2fs_flags |=
378 (vap->va_flags & SF_APPEND) ? EXT2_APPEND : 0 |
379 (vap->va_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE : 0;
380 } else
381 return (EPERM);
382 #else
383 ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
384 ip->i_e2fs_flags |=
385 (vap->va_flags & UF_APPEND) ? EXT2_APPEND : 0 |
386 (vap->va_flags & UF_IMMUTABLE) ? EXT2_IMMUTABLE : 0;
387 #endif
388 ip->i_flag |= IN_CHANGE;
389 if (vap->va_flags & (IMMUTABLE | APPEND))
390 return (0);
391 }
392 if (ip->i_e2fs_flags & (EXT2_APPEND | EXT2_IMMUTABLE))
393 return (EPERM);
394 /*
395 * Go through the fields and update iff not VNOVAL.
396 */
397 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
398 if (vp->v_mount->mnt_flag & MNT_RDONLY)
399 return (EROFS);
400 error = ext2fs_chown(vp, vap->va_uid, vap->va_gid, cred, l);
401 if (error)
402 return (error);
403 }
404 if (vap->va_size != VNOVAL) {
405 /*
406 * Disallow write attempts on read-only file systems;
407 * unless the file is a socket, fifo, or a block or
408 * character device resident on the file system.
409 */
410 switch (vp->v_type) {
411 case VDIR:
412 return (EISDIR);
413 case VLNK:
414 case VREG:
415 if (vp->v_mount->mnt_flag & MNT_RDONLY)
416 return (EROFS);
417 default:
418 break;
419 }
420 error = ext2fs_truncate(vp, vap->va_size, 0, cred);
421 if (error)
422 return (error);
423 }
424 ip = VTOI(vp);
425 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
426 if (vp->v_mount->mnt_flag & MNT_RDONLY)
427 return (EROFS);
428 error = genfs_can_chtimes(vp, vap->va_vaflags, ip->i_uid, cred);
429 if (error)
430 return (error);
431 if (vap->va_atime.tv_sec != VNOVAL)
432 if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
433 ip->i_flag |= IN_ACCESS;
434 if (vap->va_mtime.tv_sec != VNOVAL)
435 ip->i_flag |= IN_CHANGE | IN_UPDATE;
436 error = ext2fs_update(vp, &vap->va_atime, &vap->va_mtime,
437 UPDATE_WAIT);
438 if (error)
439 return (error);
440 }
441 error = 0;
442 if (vap->va_mode != (mode_t)VNOVAL) {
443 if (vp->v_mount->mnt_flag & MNT_RDONLY)
444 return (EROFS);
445 error = ext2fs_chmod(vp, (int)vap->va_mode, cred, l);
446 }
447 VN_KNOTE(vp, NOTE_ATTRIB);
448 return (error);
449 }
450
451 /*
452 * Change the mode on a file.
453 * Inode must be locked before calling.
454 */
455 static int
456 ext2fs_chmod(struct vnode *vp, int mode, kauth_cred_t cred, struct lwp *l)
457 {
458 struct inode *ip = VTOI(vp);
459 int error;
460
461 error = genfs_can_chmod(vp, cred, ip->i_uid, ip->i_gid, mode);
462 if (error)
463 return (error);
464
465 ip->i_e2fs_mode &= ~ALLPERMS;
466 ip->i_e2fs_mode |= (mode & ALLPERMS);
467 ip->i_flag |= IN_CHANGE;
468 return (0);
469 }
470
471 /*
472 * Perform chown operation on inode ip;
473 * inode must be locked prior to call.
474 */
475 static int
476 ext2fs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred,
477 struct lwp *l)
478 {
479 struct inode *ip = VTOI(vp);
480 uid_t ouid;
481 gid_t ogid;
482 int error;
483
484 if (uid == (uid_t)VNOVAL)
485 uid = ip->i_uid;
486 if (gid == (gid_t)VNOVAL)
487 gid = ip->i_gid;
488
489 error = genfs_can_chown(vp, cred, ip->i_uid, ip->i_gid, uid, gid);
490 if (error)
491 return (error);
492
493 ogid = ip->i_gid;
494 ouid = ip->i_uid;
495
496 ip->i_e2fs_gid = gid & 0xffff;
497 ip->i_e2fs_uid = uid & 0xffff;
498 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
499 ip->i_e2fs_gid_high = (gid >> 16) & 0xffff;
500 ip->i_e2fs_uid_high = (uid >> 16) & 0xffff;
501 } else {
502 ip->i_e2fs_gid_high = 0;
503 ip->i_e2fs_uid_high = 0;
504 }
505 if (ouid != uid || ogid != gid) {
506 ext2fs_set_inode_guid(ip);
507 ip->i_flag |= IN_CHANGE;
508 }
509 if (ouid != uid && kauth_authorize_generic(cred,
510 KAUTH_GENERIC_ISSUSER, NULL) != 0)
511 ip->i_e2fs_mode &= ~ISUID;
512 if (ogid != gid && kauth_authorize_generic(cred,
513 KAUTH_GENERIC_ISSUSER, NULL) != 0)
514 ip->i_e2fs_mode &= ~ISGID;
515 return (0);
516 }
517
518 int
519 ext2fs_remove(void *v)
520 {
521 struct vop_remove_args /* {
522 struct vnode *a_dvp;
523 struct vnode *a_vp;
524 struct componentname *a_cnp;
525 } */ *ap = v;
526 struct inode *ip;
527 struct vnode *vp = ap->a_vp;
528 struct vnode *dvp = ap->a_dvp;
529 int error;
530
531 ip = VTOI(vp);
532 if (vp->v_type == VDIR ||
533 (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
534 (VTOI(dvp)->i_e2fs_flags & EXT2_APPEND)) {
535 error = EPERM;
536 } else {
537 error = ext2fs_dirremove(dvp, ap->a_cnp);
538 if (error == 0) {
539 ip->i_e2fs_nlink--;
540 ip->i_flag |= IN_CHANGE;
541 }
542 }
543
544 VN_KNOTE(vp, NOTE_DELETE);
545 VN_KNOTE(dvp, NOTE_WRITE);
546 if (dvp == vp)
547 vrele(vp);
548 else
549 vput(vp);
550 vput(dvp);
551 return (error);
552 }
553
554 /*
555 * link vnode call
556 */
557 int
558 ext2fs_link(void *v)
559 {
560 struct vop_link_args /* {
561 struct vnode *a_dvp;
562 struct vnode *a_vp;
563 struct componentname *a_cnp;
564 } */ *ap = v;
565 struct vnode *dvp = ap->a_dvp;
566 struct vnode *vp = ap->a_vp;
567 struct componentname *cnp = ap->a_cnp;
568 struct inode *ip;
569 int error;
570
571 #ifdef DIAGNOSTIC
572 if ((cnp->cn_flags & HASBUF) == 0)
573 panic("ext2fs_link: no name");
574 #endif
575 if (vp->v_type == VDIR) {
576 VOP_ABORTOP(dvp, cnp);
577 error = EISDIR;
578 goto out2;
579 }
580 if (dvp->v_mount != vp->v_mount) {
581 VOP_ABORTOP(dvp, cnp);
582 error = EXDEV;
583 goto out2;
584 }
585 if (dvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE))) {
586 VOP_ABORTOP(dvp, cnp);
587 goto out2;
588 }
589 ip = VTOI(vp);
590 if ((nlink_t)ip->i_e2fs_nlink >= LINK_MAX) {
591 VOP_ABORTOP(dvp, cnp);
592 error = EMLINK;
593 goto out1;
594 }
595 if (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) {
596 VOP_ABORTOP(dvp, cnp);
597 error = EPERM;
598 goto out1;
599 }
600 ip->i_e2fs_nlink++;
601 ip->i_flag |= IN_CHANGE;
602 error = ext2fs_update(vp, NULL, NULL, UPDATE_WAIT);
603 if (!error)
604 error = ext2fs_direnter(ip, dvp, cnp);
605 if (error) {
606 ip->i_e2fs_nlink--;
607 ip->i_flag |= IN_CHANGE;
608 }
609 PNBUF_PUT(cnp->cn_pnbuf);
610 out1:
611 if (dvp != vp)
612 VOP_UNLOCK(vp, 0);
613 out2:
614 VN_KNOTE(vp, NOTE_LINK);
615 VN_KNOTE(dvp, NOTE_WRITE);
616 vput(dvp);
617 return (error);
618 }
619
620 /*
621 * Rename system call.
622 * rename("foo", "bar");
623 * is essentially
624 * unlink("bar");
625 * link("foo", "bar");
626 * unlink("foo");
627 * but ``atomically''. Can't do full commit without saving state in the
628 * inode on disk which isn't feasible at this time. Best we can do is
629 * always guarantee the target exists.
630 *
631 * Basic algorithm is:
632 *
633 * 1) Bump link count on source while we're linking it to the
634 * target. This also ensure the inode won't be deleted out
635 * from underneath us while we work (it may be truncated by
636 * a concurrent `trunc' or `open' for creation).
637 * 2) Link source to destination. If destination already exists,
638 * delete it first.
639 * 3) Unlink source reference to inode if still around. If a
640 * directory was moved and the parent of the destination
641 * is different from the source, patch the ".." entry in the
642 * directory.
643 */
644 int
645 ext2fs_rename(void *v)
646 {
647 struct vop_rename_args /* {
648 struct vnode *a_fdvp;
649 struct vnode *a_fvp;
650 struct componentname *a_fcnp;
651 struct vnode *a_tdvp;
652 struct vnode *a_tvp;
653 struct componentname *a_tcnp;
654 } */ *ap = v;
655 struct vnode *tvp = ap->a_tvp;
656 struct vnode *tdvp = ap->a_tdvp;
657 struct vnode *fvp = ap->a_fvp;
658 struct vnode *fdvp = ap->a_fdvp;
659 struct componentname *tcnp = ap->a_tcnp;
660 struct componentname *fcnp = ap->a_fcnp;
661 struct inode *ip, *xp, *dp;
662 struct ext2fs_dirtemplate dirbuf;
663 int doingdirectory = 0, oldparent = 0, newparent = 0;
664 int error = 0;
665 u_char namlen;
666
667 #ifdef DIAGNOSTIC
668 if ((tcnp->cn_flags & HASBUF) == 0 ||
669 (fcnp->cn_flags & HASBUF) == 0)
670 panic("ext2fs_rename: no name");
671 #endif
672 /*
673 * Check for cross-device rename.
674 */
675 if ((fvp->v_mount != tdvp->v_mount) ||
676 (tvp && (fvp->v_mount != tvp->v_mount))) {
677 error = EXDEV;
678 abortit:
679 VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */
680 if (tdvp == tvp)
681 vrele(tdvp);
682 else
683 vput(tdvp);
684 if (tvp)
685 vput(tvp);
686 VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
687 vrele(fdvp);
688 vrele(fvp);
689 return (error);
690 }
691
692 /*
693 * Check if just deleting a link name.
694 */
695 if (tvp && ((VTOI(tvp)->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
696 (VTOI(tdvp)->i_e2fs_flags & EXT2_APPEND))) {
697 error = EPERM;
698 goto abortit;
699 }
700 if (fvp == tvp) {
701 if (fvp->v_type == VDIR) {
702 error = EINVAL;
703 goto abortit;
704 }
705
706 /* Release destination completely. */
707 VOP_ABORTOP(tdvp, tcnp);
708 vput(tdvp);
709 vput(tvp);
710
711 /* Delete source. */
712 vrele(fvp);
713 fcnp->cn_flags &= ~(MODMASK | SAVESTART);
714 fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
715 fcnp->cn_nameiop = DELETE;
716 vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
717 if ((error = relookup(fdvp, &fvp, fcnp))) {
718 vput(fdvp);
719 return (error);
720 }
721 return (VOP_REMOVE(fdvp, fvp, fcnp));
722 }
723 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
724 goto abortit;
725 dp = VTOI(fdvp);
726 ip = VTOI(fvp);
727 if ((nlink_t) ip->i_e2fs_nlink >= LINK_MAX) {
728 VOP_UNLOCK(fvp, 0);
729 error = EMLINK;
730 goto abortit;
731 }
732 if ((ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
733 (dp->i_e2fs_flags & EXT2_APPEND)) {
734 VOP_UNLOCK(fvp, 0);
735 error = EPERM;
736 goto abortit;
737 }
738 if ((ip->i_e2fs_mode & IFMT) == IFDIR) {
739 error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred);
740 if (!error && tvp)
741 error = VOP_ACCESS(tvp, VWRITE, tcnp->cn_cred);
742 if (error) {
743 VOP_UNLOCK(fvp, 0);
744 error = EACCES;
745 goto abortit;
746 }
747 /*
748 * Avoid ".", "..", and aliases of "." for obvious reasons.
749 */
750 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
751 dp == ip ||
752 (fcnp->cn_flags & ISDOTDOT) ||
753 (tcnp->cn_flags & ISDOTDOT) ||
754 (ip->i_flag & IN_RENAME)) {
755 VOP_UNLOCK(fvp, 0);
756 error = EINVAL;
757 goto abortit;
758 }
759 ip->i_flag |= IN_RENAME;
760 oldparent = dp->i_number;
761 doingdirectory = 1;
762 }
763 VN_KNOTE(fdvp, NOTE_WRITE); /* XXXLUKEM/XXX: right place? */
764
765 /*
766 * When the target exists, both the directory
767 * and target vnodes are returned locked.
768 */
769 dp = VTOI(tdvp);
770 xp = NULL;
771 if (tvp)
772 xp = VTOI(tvp);
773
774 /*
775 * 1) Bump link count while we're moving stuff
776 * around. If we crash somewhere before
777 * completing our work, the link count
778 * may be wrong, but correctable.
779 */
780 ip->i_e2fs_nlink++;
781 ip->i_flag |= IN_CHANGE;
782 if ((error = ext2fs_update(fvp, NULL, NULL, UPDATE_WAIT)) != 0) {
783 VOP_UNLOCK(fvp, 0);
784 goto bad;
785 }
786
787 /*
788 * If ".." must be changed (ie the directory gets a new
789 * parent) then the source directory must not be in the
790 * directory hierarchy above the target, as this would
791 * orphan everything below the source directory. Also
792 * the user must have write permission in the source so
793 * as to be able to change "..". We must repeat the call
794 * to namei, as the parent directory is unlocked by the
795 * call to checkpath().
796 */
797 error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred);
798 VOP_UNLOCK(fvp, 0);
799 if (oldparent != dp->i_number)
800 newparent = dp->i_number;
801 if (doingdirectory && newparent) {
802 if (error) /* write access check above */
803 goto bad;
804 if (xp != NULL)
805 vput(tvp);
806 vref(tdvp); /* compensate for the ref checkpath loses */
807 error = ext2fs_checkpath(ip, dp, tcnp->cn_cred);
808 if (error != 0) {
809 vrele(tdvp);
810 goto out;
811 }
812 tcnp->cn_flags &= ~SAVESTART;
813 vn_lock(tdvp, LK_EXCLUSIVE | LK_RETRY);
814 if ((error = relookup(tdvp, &tvp, tcnp)) != 0) {
815 vput(tdvp);
816 goto out;
817 }
818 dp = VTOI(tdvp);
819 xp = NULL;
820 if (tvp)
821 xp = VTOI(tvp);
822 }
823 /*
824 * 2) If target doesn't exist, link the target
825 * to the source and unlink the source.
826 * Otherwise, rewrite the target directory
827 * entry to reference the source inode and
828 * expunge the original entry's existence.
829 */
830 if (xp == NULL) {
831 if (dp->i_dev != ip->i_dev)
832 panic("rename: EXDEV");
833 /*
834 * Account for ".." in new directory.
835 * When source and destination have the same
836 * parent we don't fool with the link count.
837 */
838 if (doingdirectory && newparent) {
839 if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
840 error = EMLINK;
841 goto bad;
842 }
843 dp->i_e2fs_nlink++;
844 dp->i_flag |= IN_CHANGE;
845 if ((error = ext2fs_update(tdvp, NULL, NULL,
846 UPDATE_WAIT)) != 0)
847 goto bad;
848 }
849 error = ext2fs_direnter(ip, tdvp, tcnp);
850 if (error != 0) {
851 if (doingdirectory && newparent) {
852 dp->i_e2fs_nlink--;
853 dp->i_flag |= IN_CHANGE;
854 (void)ext2fs_update(tdvp, NULL, NULL,
855 UPDATE_WAIT);
856 }
857 goto bad;
858 }
859 VN_KNOTE(tdvp, NOTE_WRITE);
860 vput(tdvp);
861 } else {
862 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
863 panic("rename: EXDEV");
864 /*
865 * Short circuit rename(foo, foo).
866 */
867 if (xp->i_number == ip->i_number)
868 panic("rename: same file");
869 /*
870 * If the parent directory is "sticky", then the user must
871 * own the parent directory, or the destination of the rename,
872 * otherwise the destination may not be changed (except by
873 * root). This implements append-only directories.
874 */
875 if ((dp->i_e2fs_mode & S_ISTXT) &&
876 kauth_authorize_generic(tcnp->cn_cred,
877 KAUTH_GENERIC_ISSUSER, NULL) != 0 &&
878 kauth_cred_geteuid(tcnp->cn_cred) != dp->i_uid &&
879 xp->i_uid != kauth_cred_geteuid(tcnp->cn_cred)) {
880 error = EPERM;
881 goto bad;
882 }
883 /*
884 * Target must be empty if a directory and have no links
885 * to it. Also, ensure source and target are compatible
886 * (both directories, or both not directories).
887 */
888 if ((xp->i_e2fs_mode & IFMT) == IFDIR) {
889 if (!ext2fs_dirempty(xp, dp->i_number, tcnp->cn_cred) ||
890 xp->i_e2fs_nlink > 2) {
891 error = ENOTEMPTY;
892 goto bad;
893 }
894 if (!doingdirectory) {
895 error = ENOTDIR;
896 goto bad;
897 }
898 cache_purge(tdvp);
899 } else if (doingdirectory) {
900 error = EISDIR;
901 goto bad;
902 }
903 error = ext2fs_dirrewrite(dp, ip, tcnp);
904 if (error != 0)
905 goto bad;
906 /*
907 * If the target directory is in the same
908 * directory as the source directory,
909 * decrement the link count on the parent
910 * of the target directory.
911 */
912 if (doingdirectory && !newparent) {
913 dp->i_e2fs_nlink--;
914 dp->i_flag |= IN_CHANGE;
915 }
916 /*
917 * Adjust the link count of the target to
918 * reflect the dirrewrite above. If this is
919 * a directory it is empty and there are
920 * no links to it, so we can squash the inode and
921 * any space associated with it. We disallowed
922 * renaming over top of a directory with links to
923 * it above, as the remaining link would point to
924 * a directory without "." or ".." entries.
925 */
926 xp->i_e2fs_nlink--;
927 if (doingdirectory) {
928 if (--xp->i_e2fs_nlink != 0)
929 panic("rename: linked directory");
930 error = ext2fs_truncate(tvp, (off_t)0, IO_SYNC,
931 tcnp->cn_cred);
932 }
933 xp->i_flag |= IN_CHANGE;
934 VN_KNOTE(tdvp, NOTE_WRITE);
935 vput(tdvp);
936 VN_KNOTE(tvp, NOTE_DELETE);
937 vput(tvp);
938 xp = NULL;
939 }
940
941 /*
942 * 3) Unlink the source.
943 */
944 fcnp->cn_flags &= ~(MODMASK | SAVESTART);
945 fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
946 vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
947 if ((error = relookup(fdvp, &fvp, fcnp))) {
948 vput(fdvp);
949 vrele(ap->a_fvp);
950 return (error);
951 }
952 if (fvp != NULL) {
953 xp = VTOI(fvp);
954 dp = VTOI(fdvp);
955 } else {
956 /*
957 * From name has disappeared.
958 */
959 if (doingdirectory)
960 panic("ext2fs_rename: lost dir entry");
961 vrele(ap->a_fvp);
962 return (0);
963 }
964 /*
965 * Ensure that the directory entry still exists and has not
966 * changed while the new name has been entered. If the source is
967 * a file then the entry may have been unlinked or renamed. In
968 * either case there is no further work to be done. If the source
969 * is a directory then it cannot have been rmdir'ed; its link
970 * count of three would cause a rmdir to fail with ENOTEMPTY.
971 * The IRENAME flag ensures that it cannot be moved by another
972 * rename.
973 */
974 if (xp != ip) {
975 if (doingdirectory)
976 panic("ext2fs_rename: lost dir entry");
977 } else {
978 /*
979 * If the source is a directory with a
980 * new parent, the link count of the old
981 * parent directory must be decremented
982 * and ".." set to point to the new parent.
983 */
984 if (doingdirectory && newparent) {
985 KASSERT(dp != NULL);
986 dp->i_e2fs_nlink--;
987 dp->i_flag |= IN_CHANGE;
988 error = vn_rdwr(UIO_READ, fvp, (void *)&dirbuf,
989 sizeof (struct ext2fs_dirtemplate), (off_t)0,
990 UIO_SYSSPACE, IO_NODELOCKED,
991 tcnp->cn_cred, (size_t *)0, NULL);
992 if (error == 0) {
993 namlen = dirbuf.dotdot_namlen;
994 if (namlen != 2 ||
995 dirbuf.dotdot_name[0] != '.' ||
996 dirbuf.dotdot_name[1] != '.') {
997 ufs_dirbad(xp, (doff_t)12,
998 "ext2fs_rename: mangled dir");
999 } else {
1000 dirbuf.dotdot_ino = h2fs32(newparent);
1001 (void) vn_rdwr(UIO_WRITE, fvp,
1002 (void *)&dirbuf,
1003 sizeof (struct dirtemplate),
1004 (off_t)0, UIO_SYSSPACE,
1005 IO_NODELOCKED|IO_SYNC,
1006 tcnp->cn_cred, (size_t *)0,
1007 NULL);
1008 cache_purge(fdvp);
1009 }
1010 }
1011 }
1012 error = ext2fs_dirremove(fdvp, fcnp);
1013 if (!error) {
1014 xp->i_e2fs_nlink--;
1015 xp->i_flag |= IN_CHANGE;
1016 }
1017 xp->i_flag &= ~IN_RENAME;
1018 }
1019 VN_KNOTE(fvp, NOTE_RENAME);
1020 if (dp)
1021 vput(fdvp);
1022 if (xp)
1023 vput(fvp);
1024 vrele(ap->a_fvp);
1025 return (error);
1026
1027 bad:
1028 if (xp)
1029 vput(ITOV(xp));
1030 vput(ITOV(dp));
1031 out:
1032 if (doingdirectory)
1033 ip->i_flag &= ~IN_RENAME;
1034 if (vn_lock(fvp, LK_EXCLUSIVE) == 0) {
1035 ip->i_e2fs_nlink--;
1036 ip->i_flag |= IN_CHANGE;
1037 vput(fvp);
1038 } else
1039 vrele(fvp);
1040 vrele(fdvp);
1041 return (error);
1042 }
1043
1044 /*
1045 * Mkdir system call
1046 */
1047 int
1048 ext2fs_mkdir(void *v)
1049 {
1050 struct vop_mkdir_args /* {
1051 struct vnode *a_dvp;
1052 struct vnode **a_vpp;
1053 struct componentname *a_cnp;
1054 struct vattr *a_vap;
1055 } */ *ap = v;
1056 struct vnode *dvp = ap->a_dvp;
1057 struct vattr *vap = ap->a_vap;
1058 struct componentname *cnp = ap->a_cnp;
1059 struct inode *ip, *dp = VTOI(dvp);
1060 struct vnode *tvp;
1061 struct ext2fs_dirtemplate dirtemplate;
1062 int error, dmode;
1063
1064 #ifdef DIAGNOSTIC
1065 if ((cnp->cn_flags & HASBUF) == 0)
1066 panic("ext2fs_mkdir: no name");
1067 #endif
1068 if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
1069 error = EMLINK;
1070 goto out;
1071 }
1072 dmode = vap->va_mode & ACCESSPERMS;
1073 dmode |= IFDIR;
1074 /*
1075 * Must simulate part of ext2fs_makeinode here to acquire the inode,
1076 * but not have it entered in the parent directory. The entry is
1077 * made later after writing "." and ".." entries.
1078 */
1079 if ((error = ext2fs_valloc(dvp, dmode, cnp->cn_cred, &tvp)) != 0)
1080 goto out;
1081 ip = VTOI(tvp);
1082 ip->i_uid = kauth_cred_geteuid(cnp->cn_cred);
1083 ip->i_e2fs_uid = ip->i_uid & 0xffff;
1084 ip->i_e2fs_gid = dp->i_e2fs_gid;
1085 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
1086 ip->i_e2fs_uid_high = (ip->i_uid >> 16) & 0xffff;
1087 ip->i_e2fs_gid_high = dp->i_e2fs_gid_high;
1088 } else {
1089 ip->i_e2fs_uid_high = 0;
1090 ip->i_e2fs_gid_high = 0;
1091 }
1092 ip->i_gid = ip->i_e2fs_gid | (ip->i_e2fs_gid_high << 16);
1093 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1094 ip->i_e2fs_mode = dmode;
1095 tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */
1096 ip->i_e2fs_nlink = 2;
1097
1098 /*
1099 * Bump link count in parent directory
1100 * to reflect work done below. Should
1101 * be done before reference is created
1102 * so reparation is possible if we crash.
1103 */
1104 dp->i_e2fs_nlink++;
1105 dp->i_flag |= IN_CHANGE;
1106 if ((error = ext2fs_update(dvp, NULL, NULL, UPDATE_DIROP)) != 0)
1107 goto bad;
1108
1109 /* Initialize directory with "." and ".." from static template. */
1110 memset(&dirtemplate, 0, sizeof(dirtemplate));
1111 dirtemplate.dot_ino = h2fs32(ip->i_number);
1112 dirtemplate.dot_reclen = h2fs16(12);
1113 dirtemplate.dot_namlen = 1;
1114 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
1115 (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
1116 dirtemplate.dot_type = EXT2_FT_DIR;
1117 }
1118 dirtemplate.dot_name[0] = '.';
1119 dirtemplate.dotdot_ino = h2fs32(dp->i_number);
1120 dirtemplate.dotdot_reclen = h2fs16(VTOI(dvp)->i_e2fs->e2fs_bsize - 12);
1121 dirtemplate.dotdot_namlen = 2;
1122 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
1123 (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
1124 dirtemplate.dotdot_type = EXT2_FT_DIR;
1125 }
1126 dirtemplate.dotdot_name[0] = dirtemplate.dotdot_name[1] = '.';
1127 error = vn_rdwr(UIO_WRITE, tvp, (void *)&dirtemplate,
1128 sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE,
1129 IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (size_t *)0, NULL);
1130 if (error) {
1131 dp->i_e2fs_nlink--;
1132 dp->i_flag |= IN_CHANGE;
1133 goto bad;
1134 }
1135 if (VTOI(dvp)->i_e2fs->e2fs_bsize > dvp->v_mount->mnt_stat.f_bsize)
1136 panic("ext2fs_mkdir: blksize"); /* XXX should grow with balloc() */
1137 else {
1138 error = ext2fs_setsize(ip, VTOI(dvp)->i_e2fs->e2fs_bsize);
1139 if (error) {
1140 dp->i_e2fs_nlink--;
1141 dp->i_flag |= IN_CHANGE;
1142 goto bad;
1143 }
1144 ip->i_flag |= IN_CHANGE;
1145 uvm_vnp_setsize(tvp, ext2fs_size(ip));
1146 }
1147
1148 /* Directory set up, now install it's entry in the parent directory. */
1149 error = ext2fs_direnter(ip, dvp, cnp);
1150 if (error != 0) {
1151 dp->i_e2fs_nlink--;
1152 dp->i_flag |= IN_CHANGE;
1153 }
1154 bad:
1155 /*
1156 * No need to do an explicit ext2fs_truncate here, vrele will do this
1157 * for us because we set the link count to 0.
1158 */
1159 if (error) {
1160 ip->i_e2fs_nlink = 0;
1161 ip->i_flag |= IN_CHANGE;
1162 vput(tvp);
1163 } else {
1164 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1165 *ap->a_vpp = tvp;
1166 }
1167 out:
1168 PNBUF_PUT(cnp->cn_pnbuf);
1169 vput(dvp);
1170 return (error);
1171 }
1172
1173 /*
1174 * Rmdir system call.
1175 */
1176 int
1177 ext2fs_rmdir(void *v)
1178 {
1179 struct vop_rmdir_args /* {
1180 struct vnode *a_dvp;
1181 struct vnode *a_vp;
1182 struct componentname *a_cnp;
1183 } */ *ap = v;
1184 struct vnode *vp = ap->a_vp;
1185 struct vnode *dvp = ap->a_dvp;
1186 struct componentname *cnp = ap->a_cnp;
1187 struct inode *ip, *dp;
1188 int error;
1189
1190 ip = VTOI(vp);
1191 dp = VTOI(dvp);
1192 /*
1193 * No rmdir "." please.
1194 */
1195 if (dp == ip) {
1196 vrele(dvp);
1197 vput(vp);
1198 return (EINVAL);
1199 }
1200 /*
1201 * Verify the directory is empty (and valid).
1202 * (Rmdir ".." won't be valid since
1203 * ".." will contain a reference to
1204 * the current directory and thus be
1205 * non-empty.)
1206 */
1207 error = 0;
1208 if (ip->i_e2fs_nlink != 2 ||
1209 !ext2fs_dirempty(ip, dp->i_number, cnp->cn_cred)) {
1210 error = ENOTEMPTY;
1211 goto out;
1212 }
1213 if ((dp->i_e2fs_flags & EXT2_APPEND) ||
1214 (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND))) {
1215 error = EPERM;
1216 goto out;
1217 }
1218 /*
1219 * Delete reference to directory before purging
1220 * inode. If we crash in between, the directory
1221 * will be reattached to lost+found,
1222 */
1223 error = ext2fs_dirremove(dvp, cnp);
1224 if (error != 0)
1225 goto out;
1226 dp->i_e2fs_nlink--;
1227 dp->i_flag |= IN_CHANGE;
1228 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
1229 cache_purge(dvp);
1230 vput(dvp);
1231 dvp = NULL;
1232 /*
1233 * Truncate inode. The only stuff left
1234 * in the directory is "." and "..". The
1235 * "." reference is inconsequential since
1236 * we're quashing it. The ".." reference
1237 * has already been adjusted above. We've
1238 * removed the "." reference and the reference
1239 * in the parent directory, but there may be
1240 * other hard links so decrement by 2 and
1241 * worry about them later.
1242 */
1243 ip->i_e2fs_nlink -= 2;
1244 error = ext2fs_truncate(vp, (off_t)0, IO_SYNC, cnp->cn_cred);
1245 cache_purge(ITOV(ip));
1246 out:
1247 VN_KNOTE(vp, NOTE_DELETE);
1248 if (dvp)
1249 vput(dvp);
1250 vput(vp);
1251 return (error);
1252 }
1253
1254 /*
1255 * symlink -- make a symbolic link
1256 */
1257 int
1258 ext2fs_symlink(void *v)
1259 {
1260 struct vop_symlink_args /* {
1261 struct vnode *a_dvp;
1262 struct vnode **a_vpp;
1263 struct componentname *a_cnp;
1264 struct vattr *a_vap;
1265 char *a_target;
1266 } */ *ap = v;
1267 struct vnode *vp, **vpp;
1268 struct inode *ip;
1269 int len, error;
1270
1271 vpp = ap->a_vpp;
1272 error = ext2fs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
1273 vpp, ap->a_cnp);
1274 if (error)
1275 return (error);
1276 VN_KNOTE(ap->a_dvp, NOTE_WRITE);
1277 vp = *vpp;
1278 len = strlen(ap->a_target);
1279 ip = VTOI(vp);
1280 if (len < ip->i_ump->um_maxsymlinklen) {
1281 memcpy((char *)ip->i_din.e2fs_din->e2di_shortlink, ap->a_target, len);
1282 error = ext2fs_setsize(ip, len);
1283 if (error)
1284 goto bad;
1285 ip->i_flag |= IN_CHANGE | IN_UPDATE;
1286 uvm_vnp_setsize(vp, len);
1287 } else
1288 error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
1289 UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred,
1290 (size_t *)0, NULL);
1291 bad:
1292 if (error)
1293 vput(vp);
1294 return (error);
1295 }
1296
1297 /*
1298 * Return target name of a symbolic link
1299 */
1300 int
1301 ext2fs_readlink(void *v)
1302 {
1303 struct vop_readlink_args /* {
1304 struct vnode *a_vp;
1305 struct uio *a_uio;
1306 kauth_cred_t a_cred;
1307 } */ *ap = v;
1308 struct vnode *vp = ap->a_vp;
1309 struct inode *ip = VTOI(vp);
1310 struct ufsmount *ump = ip->i_ump;
1311 int isize;
1312
1313 isize = ext2fs_size(ip);
1314 if (isize < ump->um_maxsymlinklen ||
1315 (ump->um_maxsymlinklen == 0 && ip->i_e2fs_nblock == 0)) {
1316 uiomove((char *)ip->i_din.e2fs_din->e2di_shortlink, isize, ap->a_uio);
1317 return (0);
1318 }
1319 return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
1320 }
1321
1322 /*
1323 * Advisory record locking support
1324 */
1325 int
1326 ext2fs_advlock(void *v)
1327 {
1328 struct vop_advlock_args /* {
1329 struct vnode *a_vp;
1330 void * a_id;
1331 int a_op;
1332 struct flock *a_fl;
1333 int a_flags;
1334 } */ *ap = v;
1335 struct inode *ip = VTOI(ap->a_vp);
1336
1337 return lf_advlock(ap, &ip->i_lockf, ext2fs_size(ip));
1338 }
1339
1340 int
1341 ext2fs_fsync(void *v)
1342 {
1343 struct vop_fsync_args /* {
1344 struct vnode *a_vp;
1345 kauth_cred_t a_cred;
1346 int a_flags;
1347 off_t offlo;
1348 off_t offhi;
1349 struct proc *a_p;
1350 } */ *ap = v;
1351 struct vnode *vp = ap->a_vp;
1352 int wait;
1353 int error;
1354
1355 wait = (ap->a_flags & FSYNC_WAIT) != 0;
1356
1357 if (vp->v_type == VBLK)
1358 spec_fsync(v);
1359 else
1360 vflushbuf(vp, wait);
1361 if ((ap->a_flags & FSYNC_DATAONLY) != 0)
1362 error = 0;
1363 else
1364 error = ext2fs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
1365
1366 if (error == 0 && ap->a_flags & FSYNC_CACHE) {
1367 int l = 0;
1368 error = VOP_IOCTL(VTOI(vp)->i_devvp, DIOCCACHESYNC, &l, FWRITE,
1369 curlwp->l_cred);
1370 }
1371
1372 return error;
1373 }
1374
1375 /*
1376 * Initialize the vnode associated with a new inode, handle aliased
1377 * vnodes.
1378 */
1379 int
1380 ext2fs_vinit(struct mount *mntp, int (**specops)(void *),
1381 int (**fifoops)(void *), struct vnode **vpp)
1382 {
1383 struct timeval tv;
1384 struct inode *ip;
1385 struct vnode *vp;
1386
1387 vp = *vpp;
1388 ip = VTOI(vp);
1389 switch(vp->v_type = IFTOVT(ip->i_e2fs_mode)) {
1390 case VCHR:
1391 case VBLK:
1392 vp->v_op = specops;
1393 spec_node_init(vp, fs2h32(ip->i_din.e2fs_din->e2di_rdev));
1394 break;
1395 case VFIFO:
1396 vp->v_op = fifoops;
1397 break;
1398 case VNON:
1399 case VBAD:
1400 case VSOCK:
1401 case VLNK:
1402 case VDIR:
1403 case VREG:
1404 break;
1405 }
1406 if (ip->i_number == ROOTINO)
1407 vp->v_vflag |= VV_ROOT;
1408 /*
1409 * Initialize modrev times
1410 */
1411 getmicrouptime(&tv);
1412 SETHIGH(ip->i_modrev, tv.tv_sec);
1413 SETLOW(ip->i_modrev, tv.tv_usec * 4294);
1414 *vpp = vp;
1415 return (0);
1416 }
1417
1418 /*
1419 * Allocate a new inode.
1420 */
1421 int
1422 ext2fs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
1423 struct componentname *cnp)
1424 {
1425 struct inode *ip, *pdir;
1426 struct vnode *tvp;
1427 int error, ismember = 0;
1428
1429 pdir = VTOI(dvp);
1430 #ifdef DIAGNOSTIC
1431 if ((cnp->cn_flags & HASBUF) == 0)
1432 panic("ext2fs_makeinode: no name");
1433 #endif
1434 *vpp = NULL;
1435 if ((mode & IFMT) == 0)
1436 mode |= IFREG;
1437
1438 if ((error = ext2fs_valloc(dvp, mode, cnp->cn_cred, &tvp)) != 0) {
1439 PNBUF_PUT(cnp->cn_pnbuf);
1440 vput(dvp);
1441 return (error);
1442 }
1443 ip = VTOI(tvp);
1444 ip->i_uid = kauth_cred_geteuid(cnp->cn_cred);
1445 ip->i_e2fs_uid = ip->i_uid & 0xffff;
1446 ip->i_e2fs_gid = pdir->i_e2fs_gid;
1447 if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
1448 ip->i_e2fs_uid_high = (ip->i_uid >> 16) & 0xffff;
1449 ip->i_e2fs_gid_high = pdir->i_e2fs_gid_high;
1450 } else {
1451 ip->i_e2fs_uid_high = 0;
1452 ip->i_e2fs_gid_high = 0;
1453 }
1454 ip->i_gid = ip->i_e2fs_gid | (ip->i_e2fs_gid_high << 16);
1455 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1456 ip->i_e2fs_mode = mode;
1457 tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */
1458 ip->i_e2fs_nlink = 1;
1459 if ((ip->i_e2fs_mode & ISGID) && (kauth_cred_ismember_gid(cnp->cn_cred,
1460 ip->i_gid, &ismember) != 0 || !ismember) &&
1461 kauth_authorize_generic(cnp->cn_cred, KAUTH_GENERIC_ISSUSER, NULL))
1462 ip->i_e2fs_mode &= ~ISGID;
1463
1464 /*
1465 * Make sure inode goes to disk before directory entry.
1466 */
1467 if ((error = ext2fs_update(tvp, NULL, NULL, UPDATE_WAIT)) != 0)
1468 goto bad;
1469 error = ext2fs_direnter(ip, dvp, cnp);
1470 if (error != 0)
1471 goto bad;
1472 if ((cnp->cn_flags & SAVESTART) == 0)
1473 PNBUF_PUT(cnp->cn_pnbuf);
1474 vput(dvp);
1475 *vpp = tvp;
1476 return (0);
1477
1478 bad:
1479 /*
1480 * Write error occurred trying to update the inode
1481 * or the directory so must deallocate the inode.
1482 */
1483 tvp->v_type = VNON; /* Stop explosion if VBLK */
1484 ip->i_e2fs_nlink = 0;
1485 ip->i_flag |= IN_CHANGE;
1486 vput(tvp);
1487 PNBUF_PUT(cnp->cn_pnbuf);
1488 vput(dvp);
1489 return (error);
1490 }
1491
1492 /*
1493 * Reclaim an inode so that it can be used for other purposes.
1494 */
1495 int
1496 ext2fs_reclaim(void *v)
1497 {
1498 struct vop_reclaim_args /* {
1499 struct vnode *a_vp;
1500 } */ *ap = v;
1501 struct vnode *vp = ap->a_vp;
1502 struct inode *ip = VTOI(vp);
1503 int error;
1504
1505 if ((error = ufs_reclaim(vp)) != 0)
1506 return (error);
1507 if (ip->i_din.e2fs_din != NULL)
1508 pool_put(&ext2fs_dinode_pool, ip->i_din.e2fs_din);
1509 genfs_node_destroy(vp);
1510 pool_put(&ext2fs_inode_pool, vp->v_data);
1511 vp->v_data = NULL;
1512 return (0);
1513 }
1514
1515 /* Global vfs data structures for ext2fs. */
1516 int (**ext2fs_vnodeop_p)(void *);
1517 const struct vnodeopv_entry_desc ext2fs_vnodeop_entries[] = {
1518 { &vop_default_desc, vn_default_error },
1519 { &vop_lookup_desc, ext2fs_lookup }, /* lookup */
1520 { &vop_create_desc, ext2fs_create }, /* create */
1521 { &vop_mknod_desc, ext2fs_mknod }, /* mknod */
1522 { &vop_open_desc, ext2fs_open }, /* open */
1523 { &vop_close_desc, ufs_close }, /* close */
1524 { &vop_access_desc, ext2fs_access }, /* access */
1525 { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
1526 { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
1527 { &vop_read_desc, ext2fs_read }, /* read */
1528 { &vop_write_desc, ext2fs_write }, /* write */
1529 { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
1530 { &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
1531 { &vop_poll_desc, ufs_poll }, /* poll */
1532 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
1533 { &vop_revoke_desc, ufs_revoke }, /* revoke */
1534 { &vop_mmap_desc, ufs_mmap }, /* mmap */
1535 { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
1536 { &vop_seek_desc, ufs_seek }, /* seek */
1537 { &vop_remove_desc, ext2fs_remove }, /* remove */
1538 { &vop_link_desc, ext2fs_link }, /* link */
1539 { &vop_rename_desc, ext2fs_rename }, /* rename */
1540 { &vop_mkdir_desc, ext2fs_mkdir }, /* mkdir */
1541 { &vop_rmdir_desc, ext2fs_rmdir }, /* rmdir */
1542 { &vop_symlink_desc, ext2fs_symlink }, /* symlink */
1543 { &vop_readdir_desc, ext2fs_readdir }, /* readdir */
1544 { &vop_readlink_desc, ext2fs_readlink }, /* readlink */
1545 { &vop_abortop_desc, ufs_abortop }, /* abortop */
1546 { &vop_inactive_desc, ext2fs_inactive }, /* inactive */
1547 { &vop_reclaim_desc, ext2fs_reclaim }, /* reclaim */
1548 { &vop_lock_desc, ufs_lock }, /* lock */
1549 { &vop_unlock_desc, ufs_unlock }, /* unlock */
1550 { &vop_bmap_desc, ext2fs_bmap }, /* bmap */
1551 { &vop_strategy_desc, ufs_strategy }, /* strategy */
1552 { &vop_print_desc, ufs_print }, /* print */
1553 { &vop_islocked_desc, ufs_islocked }, /* islocked */
1554 { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
1555 { &vop_advlock_desc, ext2fs_advlock }, /* advlock */
1556 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
1557 { &vop_getpages_desc, genfs_getpages }, /* getpages */
1558 { &vop_putpages_desc, genfs_putpages }, /* putpages */
1559 { NULL, NULL }
1560 };
1561 const struct vnodeopv_desc ext2fs_vnodeop_opv_desc =
1562 { &ext2fs_vnodeop_p, ext2fs_vnodeop_entries };
1563
1564 int (**ext2fs_specop_p)(void *);
1565 const struct vnodeopv_entry_desc ext2fs_specop_entries[] = {
1566 { &vop_default_desc, vn_default_error },
1567 { &vop_lookup_desc, spec_lookup }, /* lookup */
1568 { &vop_create_desc, spec_create }, /* create */
1569 { &vop_mknod_desc, spec_mknod }, /* mknod */
1570 { &vop_open_desc, spec_open }, /* open */
1571 { &vop_close_desc, ufsspec_close }, /* close */
1572 { &vop_access_desc, ext2fs_access }, /* access */
1573 { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
1574 { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
1575 { &vop_read_desc, ufsspec_read }, /* read */
1576 { &vop_write_desc, ufsspec_write }, /* write */
1577 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
1578 { &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
1579 { &vop_poll_desc, spec_poll }, /* poll */
1580 { &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */
1581 { &vop_revoke_desc, spec_revoke }, /* revoke */
1582 { &vop_mmap_desc, spec_mmap }, /* mmap */
1583 { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
1584 { &vop_seek_desc, spec_seek }, /* seek */
1585 { &vop_remove_desc, spec_remove }, /* remove */
1586 { &vop_link_desc, spec_link }, /* link */
1587 { &vop_rename_desc, spec_rename }, /* rename */
1588 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
1589 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
1590 { &vop_symlink_desc, spec_symlink }, /* symlink */
1591 { &vop_readdir_desc, spec_readdir }, /* readdir */
1592 { &vop_readlink_desc, spec_readlink }, /* readlink */
1593 { &vop_abortop_desc, spec_abortop }, /* abortop */
1594 { &vop_inactive_desc, ext2fs_inactive }, /* inactive */
1595 { &vop_reclaim_desc, ext2fs_reclaim }, /* reclaim */
1596 { &vop_lock_desc, ufs_lock }, /* lock */
1597 { &vop_unlock_desc, ufs_unlock }, /* unlock */
1598 { &vop_bmap_desc, spec_bmap }, /* bmap */
1599 { &vop_strategy_desc, spec_strategy }, /* strategy */
1600 { &vop_print_desc, ufs_print }, /* print */
1601 { &vop_islocked_desc, ufs_islocked }, /* islocked */
1602 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
1603 { &vop_advlock_desc, spec_advlock }, /* advlock */
1604 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
1605 { &vop_getpages_desc, spec_getpages }, /* getpages */
1606 { &vop_putpages_desc, spec_putpages }, /* putpages */
1607 { NULL, NULL }
1608 };
1609 const struct vnodeopv_desc ext2fs_specop_opv_desc =
1610 { &ext2fs_specop_p, ext2fs_specop_entries };
1611
1612 int (**ext2fs_fifoop_p)(void *);
1613 const struct vnodeopv_entry_desc ext2fs_fifoop_entries[] = {
1614 { &vop_default_desc, vn_default_error },
1615 { &vop_lookup_desc, fifo_lookup }, /* lookup */
1616 { &vop_create_desc, fifo_create }, /* create */
1617 { &vop_mknod_desc, fifo_mknod }, /* mknod */
1618 { &vop_open_desc, fifo_open }, /* open */
1619 { &vop_close_desc, ufsfifo_close }, /* close */
1620 { &vop_access_desc, ext2fs_access }, /* access */
1621 { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
1622 { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
1623 { &vop_read_desc, ufsfifo_read }, /* read */
1624 { &vop_write_desc, ufsfifo_write }, /* write */
1625 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
1626 { &vop_fcntl_desc, ufs_fcntl }, /* fcntl */
1627 { &vop_poll_desc, fifo_poll }, /* poll */
1628 { &vop_kqfilter_desc, fifo_kqfilter }, /* kqfilter */
1629 { &vop_revoke_desc, fifo_revoke }, /* revoke */
1630 { &vop_mmap_desc, fifo_mmap }, /* mmap */
1631 { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
1632 { &vop_seek_desc, fifo_seek }, /* seek */
1633 { &vop_remove_desc, fifo_remove }, /* remove */
1634 { &vop_link_desc, fifo_link }, /* link */
1635 { &vop_rename_desc, fifo_rename }, /* rename */
1636 { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
1637 { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
1638 { &vop_symlink_desc, fifo_symlink }, /* symlink */
1639 { &vop_readdir_desc, fifo_readdir }, /* readdir */
1640 { &vop_readlink_desc, fifo_readlink }, /* readlink */
1641 { &vop_abortop_desc, fifo_abortop }, /* abortop */
1642 { &vop_inactive_desc, ext2fs_inactive }, /* inactive */
1643 { &vop_reclaim_desc, ext2fs_reclaim }, /* reclaim */
1644 { &vop_lock_desc, ufs_lock }, /* lock */
1645 { &vop_unlock_desc, ufs_unlock }, /* unlock */
1646 { &vop_bmap_desc, fifo_bmap }, /* bmap */
1647 { &vop_strategy_desc, fifo_strategy }, /* strategy */
1648 { &vop_print_desc, ufs_print }, /* print */
1649 { &vop_islocked_desc, ufs_islocked }, /* islocked */
1650 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
1651 { &vop_advlock_desc, fifo_advlock }, /* advlock */
1652 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
1653 { &vop_putpages_desc, fifo_putpages }, /* putpages */
1654 { NULL, NULL }
1655 };
1656 const struct vnodeopv_desc ext2fs_fifoop_opv_desc =
1657 { &ext2fs_fifoop_p, ext2fs_fifoop_entries };
NetBSD on the FriendlyARM MINI2440