efs_vnops.c revision 1.8.2.1 1 /* $NetBSD: efs_vnops.c,v 1.8.2.1 2007/10/06 15:29:44 yamt Exp $ */
2
3 /*
4 * Copyright (c) 2006 Stephen M. Rumble <rumble (at) ephemeral.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/cdefs.h>
20 __KERNEL_RCSID(0, "$NetBSD: efs_vnops.c,v 1.8.2.1 2007/10/06 15:29:44 yamt Exp $");
21
22 #include <sys/param.h>
23 #include <sys/systm.h>
24 #include <sys/proc.h>
25 #include <sys/kernel.h>
26 #include <sys/vnode.h>
27 #include <sys/mount.h>
28 #include <sys/malloc.h>
29 #include <sys/namei.h>
30 #include <sys/dirent.h>
31 #include <sys/lockf.h>
32 #include <sys/unistd.h>
33
34 #include <miscfs/genfs/genfs.h>
35 #include <miscfs/genfs/genfs_node.h>
36
37 #include <fs/efs/efs.h>
38 #include <fs/efs/efs_sb.h>
39 #include <fs/efs/efs_dir.h>
40 #include <fs/efs/efs_genfs.h>
41 #include <fs/efs/efs_mount.h>
42 #include <fs/efs/efs_extent.h>
43 #include <fs/efs/efs_dinode.h>
44 #include <fs/efs/efs_inode.h>
45 #include <fs/efs/efs_subr.h>
46 #include <fs/efs/efs_ihash.h>
47
48 MALLOC_DECLARE(M_EFSTMP);
49
50 /*
51 * Lookup a pathname component in the given directory.
52 *
53 * Returns 0 on success.
54 */
55 static int
56 efs_lookup(void *v)
57 {
58 struct vop_lookup_args /* {
59 struct vnode *a_dvp;
60 struct vnode **a_vpp;
61 struct componentname *a_cnp;
62 } */ *ap = v;
63 struct componentname *cnp = ap->a_cnp;
64 struct vnode *vp;
65 ino_t ino;
66 int err, nameiop = cnp->cn_nameiop;
67
68 /* ensure that the directory can be accessed first */
69 err = VOP_ACCESS(ap->a_dvp, VEXEC, cnp->cn_cred, cnp->cn_lwp);
70 if (err)
71 return (err);
72
73 err = cache_lookup(ap->a_dvp, ap->a_vpp, cnp);
74 if (err != -1)
75 return (err);
76
77 /*
78 * Handle the three lookup types: '.', '..', and everything else.
79 */
80 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
81 vref(ap->a_dvp);
82 *ap->a_vpp = ap->a_dvp;
83 } else if (cnp->cn_flags & ISDOTDOT) {
84 err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount),
85 EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino);
86 if (err)
87 return (err);
88
89 VOP_UNLOCK(ap->a_dvp, 0); /* preserve lock order */
90
91 err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp);
92 if (err) {
93 vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY);
94 return (err);
95 }
96 vn_lock(ap->a_dvp, LK_EXCLUSIVE | LK_RETRY);
97 *ap->a_vpp = vp;
98 } else {
99 err = efs_inode_lookup(VFSTOEFS(ap->a_dvp->v_mount),
100 EFS_VTOI(ap->a_dvp), ap->a_cnp, &ino);
101 if (err) {
102 if (err == ENOENT && (cnp->cn_flags & MAKEENTRY) &&
103 nameiop != CREATE)
104 cache_enter(ap->a_dvp, NULL, cnp);
105 if (err == ENOENT && (nameiop == CREATE ||
106 nameiop == RENAME)) {
107 err = VOP_ACCESS(ap->a_dvp, VWRITE,
108 cnp->cn_cred, cnp->cn_lwp);
109 if (err)
110 return (err);
111 cnp->cn_flags |= SAVENAME;
112 return (EJUSTRETURN);
113 }
114 return (err);
115 }
116 err = VFS_VGET(ap->a_dvp->v_mount, ino, &vp);
117 if (err)
118 return (err);
119 *ap->a_vpp = vp;
120 }
121
122 if (cnp->cn_flags & MAKEENTRY)
123 cache_enter(ap->a_dvp, *ap->a_vpp, cnp);
124
125 return (0);
126 }
127
128 /*
129 * Determine the accessiblity of a file based on the permissions allowed by the
130 * specified credentials.
131 *
132 * Returns 0 on success.
133 */
134 static int
135 efs_access(void *v)
136 {
137 struct vop_access_args /* {
138 const struct vnodeop_desc *a_desc;
139 struct vnode *a_vp;
140 int a_mode;
141 struct ucred *a_cred;
142 struct lwp *a_l;
143 } */ *ap = v;
144 struct vnode *vp = ap->a_vp;
145 struct efs_inode *eip = EFS_VTOI(vp);
146
147 if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
148 return (EROFS);
149
150 return (vaccess(vp->v_type, eip->ei_mode, eip->ei_uid, eip->ei_gid,
151 ap->a_mode, ap->a_cred));
152 }
153
154 /*
155 * Get specific vnode attributes on a file. See vattr(9).
156 *
157 * Returns 0 on success.
158 */
159 static int
160 efs_getattr(void *v)
161 {
162 struct vop_getattr_args /* {
163 const struct vnodeop_desc *a_desc;
164 struct vnode *a_vp;
165 struct vattr *a_vap;
166 struct ucred *a_cred;
167 struct lwp *a_l;
168 } */ *ap = v;
169
170 struct vattr *vap = ap->a_vap;
171 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
172
173 vattr_null(ap->a_vap);
174 vap->va_type = ap->a_vp->v_type;
175 vap->va_mode = eip->ei_mode;
176 vap->va_nlink = eip->ei_nlink;
177 vap->va_uid = eip->ei_uid;
178 vap->va_gid = eip->ei_gid;
179 vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid;
180 vap->va_fileid = eip->ei_number;
181 vap->va_size = eip->ei_size;
182
183 if (ap->a_vp->v_type == VBLK)
184 vap->va_blocksize = BLKDEV_IOSIZE;
185 else if (ap->a_vp->v_type == VCHR)
186 vap->va_blocksize = MAXBSIZE;
187 else
188 vap->va_blocksize = EFS_BB_SIZE;
189
190 vap->va_atime.tv_sec = eip->ei_atime;
191 vap->va_mtime.tv_sec = eip->ei_mtime;
192 vap->va_ctime.tv_sec = eip->ei_ctime;
193 /* vap->va_birthtime = */
194 vap->va_gen = eip->ei_gen;
195 vap->va_flags = ap->a_vp->v_flag;
196
197 if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR) {
198 uint32_t dmaj, dmin;
199
200 if (be16toh(eip->ei_di.di_odev) != EFS_DINODE_ODEV_INVALID) {
201 dmaj = EFS_DINODE_ODEV_MAJ(be16toh(eip->ei_di.di_odev));
202 dmin = EFS_DINODE_ODEV_MIN(be16toh(eip->ei_di.di_odev));
203 } else {
204 dmaj = EFS_DINODE_NDEV_MAJ(be32toh(eip->ei_di.di_ndev));
205 dmin = EFS_DINODE_NDEV_MIN(be32toh(eip->ei_di.di_ndev));
206 }
207
208 vap->va_rdev = makedev(dmaj, dmin);
209 }
210
211 vap->va_bytes = eip->ei_size;
212 /* vap->va_filerev = */
213 /* vap->va_vaflags = */
214
215 return (0);
216 }
217
218 /*
219 * Read a file.
220 *
221 * Returns 0 on success.
222 */
223 static int
224 efs_read(void *v)
225 {
226 struct vop_read_args /* {
227 const struct vnodeop_desc *a_desc;
228 struct vnode *a_vp;
229 struct uio *a_uio;
230 int a_ioflag;
231 struct ucred *a_cred;
232 } */ *ap = v;
233 struct efs_extent ex;
234 struct efs_extent_iterator exi;
235 void *win;
236 struct uio *uio = ap->a_uio;
237 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
238 off_t start;
239 vsize_t len;
240 int err, ret, flags;
241 const int advice = IO_ADV_DECODE(ap->a_ioflag);
242
243 if (ap->a_vp->v_type == VDIR)
244 return (EISDIR);
245
246 if (ap->a_vp->v_type != VREG)
247 return (EINVAL);
248
249 efs_extent_iterator_init(&exi, eip, uio->uio_offset);
250 ret = efs_extent_iterator_next(&exi, &ex);
251 while (ret == 0) {
252 if (uio->uio_offset < 0 || uio->uio_offset >= eip->ei_size ||
253 uio->uio_resid == 0)
254 break;
255
256 start = ex.ex_offset * EFS_BB_SIZE;
257 len = ex.ex_length * EFS_BB_SIZE;
258
259 if (!(uio->uio_offset >= start &&
260 uio->uio_offset < (start + len))) {
261 ret = efs_extent_iterator_next(&exi, &ex);
262 continue;
263 }
264
265 start = uio->uio_offset - start;
266
267 len = MIN(len - start, uio->uio_resid);
268 len = MIN(len, eip->ei_size - uio->uio_offset);
269
270 win = ubc_alloc(&ap->a_vp->v_uobj, uio->uio_offset,
271 &len, advice, UBC_READ);
272
273 flags = UBC_WANT_UNMAP(ap->a_vp) ? UBC_UNMAP : 0;
274
275 err = uiomove(win, len, uio);
276 ubc_release(win, flags);
277 if (err) {
278 EFS_DPRINTF(("efs_read: uiomove error %d\n",
279 err));
280 return (err);
281 }
282 }
283
284 return ((ret == -1) ? 0 : ret);
285 }
286
287 static int
288 efs_readdir(void *v)
289 {
290 struct vop_readdir_args /* {
291 const struct vnodeop_desc *a_desc;
292 struct vnode *a_vp;
293 struct uio *a_uio;
294 struct ucred *a_cred;
295 int *a_eofflag;
296 off_t **a_cookies;
297 int *a_ncookies;
298 } */ *ap = v;
299 struct dirent *dp;
300 struct efs_dinode edi;
301 struct efs_extent ex;
302 struct efs_extent_iterator exi;
303 struct buf *bp;
304 struct efs_dirent *de;
305 struct efs_dirblk *db;
306 struct uio *uio = ap->a_uio;
307 struct efs_inode *ei = EFS_VTOI(ap->a_vp);
308 off_t *cookies = NULL;
309 off_t offset;
310 int i, j, err, ret, s, slot, ncookies, maxcookies = 0;
311
312 if (ap->a_vp->v_type != VDIR)
313 return (ENOTDIR);
314
315 if (ap->a_eofflag != NULL)
316 *ap->a_eofflag = false;
317
318 if (ap->a_ncookies != NULL) {
319 ncookies = 0;
320 maxcookies =
321 uio->uio_resid / _DIRENT_MINSIZE((struct dirent *)0);
322 cookies = malloc(maxcookies * sizeof(off_t), M_TEMP, M_WAITOK);
323 }
324
325 dp = malloc(sizeof(struct dirent), M_EFSTMP, M_WAITOK | M_ZERO);
326
327 offset = 0;
328 efs_extent_iterator_init(&exi, ei, 0);
329 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
330 for (i = 0; i < ex.ex_length; i++) {
331 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
332 ex.ex_bn + i, NULL, &bp);
333 if (err) {
334 brelse(bp);
335 goto exit_err;
336 }
337
338 db = (struct efs_dirblk *)bp->b_data;
339
340 if (be16toh(db->db_magic) != EFS_DIRBLK_MAGIC) {
341 printf("efs_readdir: bad dirblk\n");
342 brelse(bp);
343 continue;
344 }
345
346 for (j = 0; j < db->db_slots; j++) {
347 slot = EFS_DIRENT_OFF_EXPND(db->db_space[j]);
348 if (slot == EFS_DIRBLK_SLOT_FREE)
349 continue;
350
351 if (!EFS_DIRENT_OFF_VALID(slot)) {
352 printf("efs_readdir: bad dirent\n");
353 continue;
354 }
355
356 de = EFS_DIRBLK_TO_DIRENT(db, slot);
357 s = _DIRENT_RECLEN(dp, de->de_namelen);
358
359 if (offset < uio->uio_offset) {
360 offset += s;
361 continue;
362 }
363
364 /* XXX - latter shouldn't happen, right? */
365 if (s > uio->uio_resid ||
366 offset > uio->uio_offset) {
367 brelse(bp);
368 goto exit_ok;
369 }
370
371 /* de_namelen is uint8_t, d.d_name is 512b */
372 KASSERT(sizeof(dp->d_name)-de->de_namelen > 0);
373 dp->d_fileno = be32toh(de->de_inumber);
374 dp->d_reclen = s;
375 dp->d_namlen = de->de_namelen;
376 memcpy(dp->d_name, de->de_name,
377 de->de_namelen);
378 dp->d_name[de->de_namelen] = '\0';
379
380 /* look up inode to get type */
381 err = efs_read_inode(
382 VFSTOEFS(ap->a_vp->v_mount),
383 dp->d_fileno, NULL, &edi);
384 if (err) {
385 brelse(bp);
386 goto exit_err;
387 }
388
389 switch (be16toh(edi.di_mode) & EFS_IFMT) {
390 case EFS_IFIFO:
391 dp->d_type = DT_FIFO;
392 break;
393 case EFS_IFCHR:
394 dp->d_type = DT_CHR;
395 break;
396 case EFS_IFDIR:
397 dp->d_type = DT_DIR;
398 break;
399 case EFS_IFBLK:
400 dp->d_type = DT_BLK;
401 break;
402 case EFS_IFREG:
403 dp->d_type = DT_REG;
404 break;
405 case EFS_IFLNK:
406 dp->d_type = DT_LNK;
407 break;
408 case EFS_IFSOCK:
409 dp->d_type = DT_SOCK;
410 break;
411 default:
412 dp->d_type = DT_UNKNOWN;
413 break;
414 }
415
416 err = uiomove(dp, s, uio);
417 if (err) {
418 brelse(bp);
419 goto exit_err;
420 }
421
422 offset += s;
423
424 if (cookies != NULL && maxcookies != 0) {
425 cookies[ncookies++] = offset;
426 if (ncookies == maxcookies) {
427 brelse(bp);
428 goto exit_ok;
429 }
430 }
431 }
432
433 brelse(bp);
434 }
435 }
436
437 if (ret != -1) {
438 err = ret;
439 goto exit_err;
440 }
441
442 if (ap->a_eofflag != NULL)
443 *ap->a_eofflag = true;
444
445 exit_ok:
446 if (cookies != NULL) {
447 *ap->a_cookies = cookies;
448 *ap->a_ncookies = ncookies;
449 }
450
451 uio->uio_offset = offset;
452
453 free(dp, M_EFSTMP);
454
455 return (0);
456
457 exit_err:
458 if (cookies != NULL)
459 free(cookies, M_TEMP);
460
461 free(dp, M_EFSTMP);
462
463 return (err);
464 }
465
466 static int
467 efs_readlink(void *v)
468 {
469 struct vop_readlink_args /* {
470 const struct vnodeop_desc *a_desc;
471 struct vnode *a_vp;
472 struct uio *a_uio;
473 struct ucred *a_cred;
474 } */ *ap = v;
475 struct uio *uio = ap->a_uio;
476 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
477 char *buf;
478 size_t len;
479 int err, i;
480
481 if ((eip->ei_mode & EFS_IFMT) != EFS_IFLNK)
482 return (EINVAL);
483
484 if (uio->uio_resid < 1)
485 return (EINVAL);
486
487 buf = malloc(eip->ei_size + 1, M_EFSTMP, M_ZERO | M_WAITOK);
488
489 /* symlinks are either inlined in the inode, or in extents */
490 if (eip->ei_numextents == 0) {
491 if (eip->ei_size > sizeof(eip->ei_di.di_symlink)) {
492 EFS_DPRINTF(("efs_readlink: too big for inline\n"));
493 free(buf, M_EFSTMP);
494 return (EBADF);
495 }
496
497 memcpy(buf, eip->ei_di.di_symlink, eip->ei_size);
498 len = MIN(uio->uio_resid, eip->ei_size + 1);
499 } else {
500 struct efs_extent_iterator exi;
501 struct efs_extent ex;
502 struct buf *bp;
503 int resid, off, ret;
504
505 off = 0;
506 resid = eip->ei_size;
507
508 efs_extent_iterator_init(&exi, eip, 0);
509 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
510 for (i = 0; i < ex.ex_length; i++) {
511 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
512 ex.ex_bn + i, NULL, &bp);
513 if (err) {
514 brelse(bp);
515 free(buf, M_EFSTMP);
516 return (err);
517 }
518
519 len = MIN(resid, bp->b_bcount);
520 memcpy(buf + off, bp->b_data, len);
521 brelse(bp);
522
523 off += len;
524 resid -= len;
525
526 if (resid == 0)
527 break;
528 }
529
530 if (resid == 0)
531 break;
532 }
533
534 if (ret != 0 && ret != -1) {
535 free(buf, M_EFSTMP);
536 return (ret);
537 }
538
539 len = off + 1;
540 }
541
542 KASSERT(len >= 1 && len <= (eip->ei_size + 1));
543 buf[len - 1] = '\0';
544 err = uiomove(buf, len, uio);
545 free(buf, M_EFSTMP);
546
547 return (err);
548 }
549
550 /*
551 * Release an inactive vnode. The vnode _must_ be unlocked on return.
552 * It is either nolonger being used by the kernel, or an unmount is being
553 * forced.
554 *
555 * Returns 0 on success.
556 */
557 static int
558 efs_inactive(void *v)
559 {
560 struct vop_inactive_args /* {
561 const struct vnodeop_desc *a_desc;
562 struct vnode *a_vp;
563 struct lwp *a_l;
564 } */ *ap = v;
565 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
566
567 VOP_UNLOCK(ap->a_vp, 0);
568
569 if (eip->ei_mode == 0)
570 vrecycle(ap->a_vp, NULL, ap->a_l);
571
572 return (0);
573 }
574
575 static int
576 efs_reclaim(void *v)
577 {
578 struct vop_reclaim_args /* {
579 const struct vnodeop_desc *a_desc;
580 struct vnode *a_vp;
581 struct lwp *a_l;
582 } */ *ap = v;
583 struct vnode *vp = ap->a_vp;
584
585 efs_ihashrem(EFS_VTOI(vp));
586 cache_purge(vp);
587 genfs_node_destroy(vp);
588 pool_put(&efs_inode_pool, vp->v_data);
589 vp->v_data = NULL;
590
591 return (0);
592 }
593
594 static int
595 efs_bmap(void *v)
596 {
597 struct vop_bmap_args /* {
598 const struct vnodeop_desc *a_desc;
599 struct vnode *a_vp;
600 daddr_t a_bn;
601 struct vnode **a_vpp;
602 daddr_t *a_bnp;
603 int *a_runp;
604 } */ *ap = v;
605 struct efs_extent ex;
606 struct efs_extent_iterator exi;
607 struct vnode *vp = ap->a_vp;
608 struct efs_inode *eip = EFS_VTOI(vp);
609 bool found;
610 int ret;
611
612 if (ap->a_vpp != NULL)
613 *ap->a_vpp = VFSTOEFS(vp->v_mount)->em_devvp;
614
615 found = false;
616 efs_extent_iterator_init(&exi, eip, ap->a_bn * EFS_BB_SIZE);
617 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
618 if (ap->a_bn >= ex.ex_offset &&
619 ap->a_bn < (ex.ex_offset + ex.ex_length)) {
620 found = true;
621 break;
622 }
623 }
624
625 KASSERT(!found || (found && ret == 0));
626
627 if (!found) {
628 EFS_DPRINTF(("efs_bmap: ap->a_bn not in extents\n"));
629 return ((ret == -1) ? EIO : ret);
630 }
631
632 if (ex.ex_magic != EFS_EXTENT_MAGIC) {
633 EFS_DPRINTF(("efs_bmap: exn.ex_magic != EFS_EXTENT_MAGIC\n"));
634 return (EIO);
635 }
636
637 if (ap->a_bn < ex.ex_offset) {
638 EFS_DPRINTF(("efs_bmap: ap->a_bn < exn.ex_offset\n"));
639 return (EIO);
640 }
641
642 KASSERT(ap->a_bn >= ex.ex_offset);
643 KASSERT(ex.ex_length > ap->a_bn - ex.ex_offset);
644
645 *ap->a_bnp = ex.ex_bn + (ap->a_bn - ex.ex_offset);
646 if (ap->a_runp != NULL)
647 *ap->a_runp = ex.ex_length - (ap->a_bn - ex.ex_offset) - 1;
648
649 return (0);
650 }
651
652 static int
653 efs_strategy(void *v)
654 {
655 struct vop_strategy_args /* {
656 const struct vnodeop_desc *a_desc;
657 struct vnode *a_vp;
658 struct buf *a_bp;
659 } */ *ap = v;
660 struct vnode *vp = ap->a_vp;
661 struct buf *bp = ap->a_bp;
662 int error;
663
664 if (vp == NULL) {
665 bp->b_error = EIO;
666 biodone(bp);
667 return (EIO);
668 }
669
670 if (bp->b_blkno == bp->b_lblkno) {
671 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
672 if (error) {
673 bp->b_error = error;
674 biodone(bp);
675 return (error);
676 }
677 if ((long)bp->b_blkno == -1)
678 clrbuf(bp);
679 }
680
681 if ((long)bp->b_blkno == -1) {
682 biodone(bp);
683 return (0);
684 }
685
686 return (VOP_STRATEGY(VFSTOEFS(vp->v_mount)->em_devvp, bp));
687 }
688
689 static int
690 efs_print(void *v)
691 {
692 struct vop_print_args /* {
693 const struct vnodeop_desc *a_desc;
694 struct vnode *a_vp;
695 } */ *ap = v;
696 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
697
698 printf( "efs_inode (ino %lu):\n"
699 " ei_mode: %07o\n"
700 " ei_nlink: %d\n"
701 " ei_uid: %d\n"
702 " ei_gid: %d\n"
703 " ei_size: %d\n"
704 " ei_atime: %d\n"
705 " ei_mtime: %d\n"
706 " ei_ctime: %d\n"
707 " ei_gen: %d\n"
708 " ei_numextents: %d\n"
709 " ei_version: %d\n",
710 (unsigned long)eip->ei_number,
711 (unsigned int)eip->ei_mode,
712 eip->ei_nlink,
713 eip->ei_uid,
714 eip->ei_gid,
715 eip->ei_size,
716 (int32_t)eip->ei_atime,
717 (int32_t)eip->ei_mtime,
718 (int32_t)eip->ei_ctime,
719 eip->ei_gen,
720 eip->ei_numextents,
721 eip->ei_version);
722
723 return (0);
724 }
725
726 static int
727 efs_pathconf(void *v)
728 {
729 struct vop_pathconf_args /* {
730 const struct vnodeop_desc *a_desc;
731 struct vnode *a_vp;
732 int a_name;
733 register_t *a_retval;
734 } */ *ap = v;
735
736 /* IRIX 4 values */
737 switch (ap->a_name) {
738 case _PC_LINK_MAX:
739 *ap->a_retval = 30000;
740 break;
741 case _PC_NAME_MAX:
742 *ap->a_retval = 255;
743 break;
744 case _PC_PATH_MAX:
745 *ap->a_retval = 1024;
746 break;
747 case _PC_NO_TRUNC:
748 *ap->a_retval = 1;
749 break;
750 case _PC_CHOWN_RESTRICTED:
751 *ap->a_retval = 1;
752 break;
753 case _PC_SYNC_IO:
754 *ap->a_retval = 1;
755 break;
756 case _PC_FILESIZEBITS:
757 *ap->a_retval = 32;
758 break;
759 default:
760 return (EINVAL);
761 }
762
763 return (0);
764 }
765
766 static int
767 efs_advlock(void *v)
768 {
769 struct vop_advlock_args /* {
770 const struct vnodeop_desc *a_desc;
771 struct vnode *a_vp;
772 void *a_id;
773 int a_op;
774 struct flock *a_fl;
775 int a_flags;
776 } */ *ap = v;
777 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
778
779 return (lf_advlock(ap, &eip->ei_lockf, eip->ei_size));
780 }
781
782 /* Global vfs data structures for efs */
783 int (**efs_vnodeop_p)(void *);
784 const struct vnodeopv_entry_desc efs_vnodeop_entries[] = {
785 { &vop_default_desc, vn_default_error}, /* error handler */
786 { &vop_lookup_desc, efs_lookup }, /* lookup */
787 { &vop_create_desc, genfs_eopnotsupp}, /* create */
788 { &vop_mknod_desc, genfs_eopnotsupp}, /* mknod */
789 { &vop_open_desc, genfs_nullop }, /* open */
790 { &vop_close_desc, genfs_nullop }, /* close */
791 { &vop_access_desc, efs_access }, /* access */
792 { &vop_getattr_desc, efs_getattr }, /* getattr */
793 { &vop_setattr_desc, genfs_eopnotsupp}, /* setattr */
794 { &vop_read_desc, efs_read }, /* read */
795 { &vop_write_desc, genfs_eopnotsupp}, /* write */
796 { &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */
797 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
798 { &vop_poll_desc, genfs_poll }, /* poll */
799 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
800 { &vop_revoke_desc, genfs_revoke }, /* revoke */
801 { &vop_mmap_desc, genfs_mmap }, /* mmap */
802 { &vop_fsync_desc, genfs_eopnotsupp}, /* fsync */
803 { &vop_seek_desc, genfs_seek }, /* seek */
804 { &vop_remove_desc, genfs_eopnotsupp}, /* remove */
805 { &vop_link_desc, genfs_eopnotsupp}, /* link */
806 { &vop_rename_desc, genfs_eopnotsupp}, /* rename */
807 { &vop_mkdir_desc, genfs_eopnotsupp}, /* mkdir */
808 { &vop_rmdir_desc, genfs_eopnotsupp}, /* rmdir */
809 { &vop_symlink_desc, genfs_eopnotsupp}, /* symlink */
810 { &vop_readdir_desc, efs_readdir }, /* readdir */
811 { &vop_readlink_desc, efs_readlink }, /* readlink */
812 { &vop_abortop_desc, genfs_abortop }, /* abortop */
813 { &vop_inactive_desc, efs_inactive }, /* inactive */
814 { &vop_reclaim_desc, efs_reclaim }, /* reclaim */
815 { &vop_lock_desc, genfs_lock, }, /* lock */
816 { &vop_unlock_desc, genfs_unlock, }, /* unlock */
817 { &vop_islocked_desc, genfs_islocked, }, /* islocked */
818 { &vop_bmap_desc, efs_bmap }, /* bmap */
819 { &vop_print_desc, efs_print }, /* print */
820 { &vop_pathconf_desc, efs_pathconf }, /* pathconf */
821 { &vop_advlock_desc, efs_advlock }, /* advlock */
822 /* blkatoff */
823 /* valloc */
824 /* balloc */
825 /* vfree */
826 /* truncate */
827 { &vop_lease_desc, genfs_lease_check }, /* lease */
828 /* whiteout */
829 { &vop_getpages_desc, genfs_getpages }, /* getpages */
830 { &vop_putpages_desc, genfs_putpages }, /* putpages */
831 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
832 { &vop_strategy_desc, efs_strategy }, /* strategy */
833 { NULL, NULL }
834 };
835 const struct vnodeopv_desc efs_vnodeop_opv_desc = {
836 &efs_vnodeop_p,
837 efs_vnodeop_entries
838 };
839