efs_vnops.c revision 1.11 1 /* $NetBSD: efs_vnops.c,v 1.11 2007/10/10 20:42:23 ad 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.11 2007/10/10 20:42:23 ad 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_vflag |
196 ap->a_vp->v_iflag | ap->a_vp->v_uflag;
197
198 if (ap->a_vp->v_type == VBLK || ap->a_vp->v_type == VCHR) {
199 uint32_t dmaj, dmin;
200
201 if (be16toh(eip->ei_di.di_odev) != EFS_DINODE_ODEV_INVALID) {
202 dmaj = EFS_DINODE_ODEV_MAJ(be16toh(eip->ei_di.di_odev));
203 dmin = EFS_DINODE_ODEV_MIN(be16toh(eip->ei_di.di_odev));
204 } else {
205 dmaj = EFS_DINODE_NDEV_MAJ(be32toh(eip->ei_di.di_ndev));
206 dmin = EFS_DINODE_NDEV_MIN(be32toh(eip->ei_di.di_ndev));
207 }
208
209 vap->va_rdev = makedev(dmaj, dmin);
210 }
211
212 vap->va_bytes = eip->ei_size;
213 /* vap->va_filerev = */
214 /* vap->va_vaflags = */
215
216 return (0);
217 }
218
219 /*
220 * Read a file.
221 *
222 * Returns 0 on success.
223 */
224 static int
225 efs_read(void *v)
226 {
227 struct vop_read_args /* {
228 const struct vnodeop_desc *a_desc;
229 struct vnode *a_vp;
230 struct uio *a_uio;
231 int a_ioflag;
232 struct ucred *a_cred;
233 } */ *ap = v;
234 struct efs_extent ex;
235 struct efs_extent_iterator exi;
236 void *win;
237 struct uio *uio = ap->a_uio;
238 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
239 off_t start;
240 vsize_t len;
241 int err, ret, flags;
242 const int advice = IO_ADV_DECODE(ap->a_ioflag);
243
244 if (ap->a_vp->v_type == VDIR)
245 return (EISDIR);
246
247 if (ap->a_vp->v_type != VREG)
248 return (EINVAL);
249
250 efs_extent_iterator_init(&exi, eip, uio->uio_offset);
251 ret = efs_extent_iterator_next(&exi, &ex);
252 while (ret == 0) {
253 if (uio->uio_offset < 0 || uio->uio_offset >= eip->ei_size ||
254 uio->uio_resid == 0)
255 break;
256
257 start = ex.ex_offset * EFS_BB_SIZE;
258 len = ex.ex_length * EFS_BB_SIZE;
259
260 if (!(uio->uio_offset >= start &&
261 uio->uio_offset < (start + len))) {
262 ret = efs_extent_iterator_next(&exi, &ex);
263 continue;
264 }
265
266 start = uio->uio_offset - start;
267
268 len = MIN(len - start, uio->uio_resid);
269 len = MIN(len, eip->ei_size - uio->uio_offset);
270
271 win = ubc_alloc(&ap->a_vp->v_uobj, uio->uio_offset,
272 &len, advice, UBC_READ);
273
274 flags = UBC_WANT_UNMAP(ap->a_vp) ? UBC_UNMAP : 0;
275
276 err = uiomove(win, len, uio);
277 ubc_release(win, flags);
278 if (err) {
279 EFS_DPRINTF(("efs_read: uiomove error %d\n",
280 err));
281 return (err);
282 }
283 }
284
285 return ((ret == -1) ? 0 : ret);
286 }
287
288 static int
289 efs_readdir(void *v)
290 {
291 struct vop_readdir_args /* {
292 const struct vnodeop_desc *a_desc;
293 struct vnode *a_vp;
294 struct uio *a_uio;
295 struct ucred *a_cred;
296 int *a_eofflag;
297 off_t **a_cookies;
298 int *a_ncookies;
299 } */ *ap = v;
300 struct dirent *dp;
301 struct efs_dinode edi;
302 struct efs_extent ex;
303 struct efs_extent_iterator exi;
304 struct buf *bp;
305 struct efs_dirent *de;
306 struct efs_dirblk *db;
307 struct uio *uio = ap->a_uio;
308 struct efs_inode *ei = EFS_VTOI(ap->a_vp);
309 off_t *cookies = NULL;
310 off_t offset;
311 int i, j, err, ret, s, slot, ncookies, maxcookies = 0;
312
313 if (ap->a_vp->v_type != VDIR)
314 return (ENOTDIR);
315
316 if (ap->a_eofflag != NULL)
317 *ap->a_eofflag = false;
318
319 if (ap->a_ncookies != NULL) {
320 ncookies = 0;
321 maxcookies =
322 uio->uio_resid / _DIRENT_MINSIZE((struct dirent *)0);
323 cookies = malloc(maxcookies * sizeof(off_t), M_TEMP, M_WAITOK);
324 }
325
326 dp = malloc(sizeof(struct dirent), M_EFSTMP, M_WAITOK | M_ZERO);
327
328 offset = 0;
329 efs_extent_iterator_init(&exi, ei, 0);
330 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
331 for (i = 0; i < ex.ex_length; i++) {
332 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
333 ex.ex_bn + i, NULL, &bp);
334 if (err) {
335 brelse(bp, 0);
336 goto exit_err;
337 }
338
339 db = (struct efs_dirblk *)bp->b_data;
340
341 if (be16toh(db->db_magic) != EFS_DIRBLK_MAGIC) {
342 printf("efs_readdir: bad dirblk\n");
343 brelse(bp, 0);
344 continue;
345 }
346
347 for (j = 0; j < db->db_slots; j++) {
348 slot = EFS_DIRENT_OFF_EXPND(db->db_space[j]);
349 if (slot == EFS_DIRBLK_SLOT_FREE)
350 continue;
351
352 if (!EFS_DIRENT_OFF_VALID(slot)) {
353 printf("efs_readdir: bad dirent\n");
354 continue;
355 }
356
357 de = EFS_DIRBLK_TO_DIRENT(db, slot);
358 s = _DIRENT_RECLEN(dp, de->de_namelen);
359
360 if (offset < uio->uio_offset) {
361 offset += s;
362 continue;
363 }
364
365 /* XXX - shouldn't happen, right? */
366 if (offset > uio->uio_offset ||
367 s > uio->uio_resid) {
368 brelse(bp, 0);
369 goto exit_ok;
370 }
371
372 /* de_namelen is uint8_t, d.d_name is 512b */
373 KASSERT(sizeof(dp->d_name)-de->de_namelen > 0);
374 dp->d_fileno = be32toh(de->de_inumber);
375 dp->d_reclen = s;
376 dp->d_namlen = de->de_namelen;
377 memcpy(dp->d_name, de->de_name,
378 de->de_namelen);
379 dp->d_name[de->de_namelen] = '\0';
380
381 /* look up inode to get type */
382 err = efs_read_inode(
383 VFSTOEFS(ap->a_vp->v_mount),
384 dp->d_fileno, NULL, &edi);
385 if (err) {
386 brelse(bp, 0);
387 goto exit_err;
388 }
389
390 switch (be16toh(edi.di_mode) & EFS_IFMT) {
391 case EFS_IFIFO:
392 dp->d_type = DT_FIFO;
393 break;
394 case EFS_IFCHR:
395 dp->d_type = DT_CHR;
396 break;
397 case EFS_IFDIR:
398 dp->d_type = DT_DIR;
399 break;
400 case EFS_IFBLK:
401 dp->d_type = DT_BLK;
402 break;
403 case EFS_IFREG:
404 dp->d_type = DT_REG;
405 break;
406 case EFS_IFLNK:
407 dp->d_type = DT_LNK;
408 break;
409 case EFS_IFSOCK:
410 dp->d_type = DT_SOCK;
411 break;
412 default:
413 dp->d_type = DT_UNKNOWN;
414 break;
415 }
416
417 err = uiomove(dp, s, uio);
418 if (err) {
419 brelse(bp, 0);
420 goto exit_err;
421 }
422
423 offset += s;
424
425 if (cookies != NULL && maxcookies != 0) {
426 cookies[ncookies++] = offset;
427 if (ncookies == maxcookies) {
428 brelse(bp, 0);
429 goto exit_ok;
430 }
431 }
432 }
433
434 brelse(bp, 0);
435 }
436 }
437
438 if (ret != -1) {
439 err = ret;
440 goto exit_err;
441 }
442
443 if (ap->a_eofflag != NULL)
444 *ap->a_eofflag = true;
445
446 exit_ok:
447 if (cookies != NULL) {
448 *ap->a_cookies = cookies;
449 *ap->a_ncookies = ncookies;
450 }
451
452 uio->uio_offset = offset;
453
454 free(dp, M_EFSTMP);
455
456 return (0);
457
458 exit_err:
459 if (cookies != NULL)
460 free(cookies, M_TEMP);
461
462 free(dp, M_EFSTMP);
463
464 return (err);
465 }
466
467 static int
468 efs_readlink(void *v)
469 {
470 struct vop_readlink_args /* {
471 const struct vnodeop_desc *a_desc;
472 struct vnode *a_vp;
473 struct uio *a_uio;
474 struct ucred *a_cred;
475 } */ *ap = v;
476 struct uio *uio = ap->a_uio;
477 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
478 char *buf;
479 size_t len;
480 int err, i;
481
482 if ((eip->ei_mode & EFS_IFMT) != EFS_IFLNK)
483 return (EINVAL);
484
485 if (uio->uio_resid < 1)
486 return (EINVAL);
487
488 buf = malloc(eip->ei_size + 1, M_EFSTMP, M_ZERO | M_WAITOK);
489
490 /* symlinks are either inlined in the inode, or in extents */
491 if (eip->ei_numextents == 0) {
492 if (eip->ei_size > sizeof(eip->ei_di.di_symlink)) {
493 EFS_DPRINTF(("efs_readlink: too big for inline\n"));
494 free(buf, M_EFSTMP);
495 return (EBADF);
496 }
497
498 memcpy(buf, eip->ei_di.di_symlink, eip->ei_size);
499 len = MIN(uio->uio_resid, eip->ei_size + 1);
500 } else {
501 struct efs_extent_iterator exi;
502 struct efs_extent ex;
503 struct buf *bp;
504 int resid, off, ret;
505
506 off = 0;
507 resid = eip->ei_size;
508
509 efs_extent_iterator_init(&exi, eip, 0);
510 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
511 for (i = 0; i < ex.ex_length; i++) {
512 err = efs_bread(VFSTOEFS(ap->a_vp->v_mount),
513 ex.ex_bn + i, NULL, &bp);
514 if (err) {
515 brelse(bp, 0);
516 free(buf, M_EFSTMP);
517 return (err);
518 }
519
520 len = MIN(resid, bp->b_bcount);
521 memcpy(buf + off, bp->b_data, len);
522 brelse(bp, 0);
523
524 off += len;
525 resid -= len;
526
527 if (resid == 0)
528 break;
529 }
530
531 if (resid == 0)
532 break;
533 }
534
535 if (ret != 0 && ret != -1) {
536 free(buf, M_EFSTMP);
537 return (ret);
538 }
539
540 len = off + 1;
541 }
542
543 KASSERT(len >= 1 && len <= (eip->ei_size + 1));
544 buf[len - 1] = '\0';
545 err = uiomove(buf, len, uio);
546 free(buf, M_EFSTMP);
547
548 return (err);
549 }
550
551 /*
552 * Release an inactive vnode. The vnode _must_ be unlocked on return.
553 * It is either nolonger being used by the kernel, or an unmount is being
554 * forced.
555 *
556 * Returns 0 on success.
557 */
558 static int
559 efs_inactive(void *v)
560 {
561 struct vop_inactive_args /* {
562 const struct vnodeop_desc *a_desc;
563 struct vnode *a_vp;
564 struct lwp *a_l;
565 } */ *ap = v;
566 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
567
568 VOP_UNLOCK(ap->a_vp, 0);
569
570 if (eip->ei_mode == 0)
571 vrecycle(ap->a_vp, NULL, ap->a_l);
572
573 return (0);
574 }
575
576 static int
577 efs_reclaim(void *v)
578 {
579 struct vop_reclaim_args /* {
580 const struct vnodeop_desc *a_desc;
581 struct vnode *a_vp;
582 struct lwp *a_l;
583 } */ *ap = v;
584 struct vnode *vp = ap->a_vp;
585
586 efs_ihashrem(EFS_VTOI(vp));
587 cache_purge(vp);
588 genfs_node_destroy(vp);
589 pool_put(&efs_inode_pool, vp->v_data);
590 vp->v_data = NULL;
591
592 return (0);
593 }
594
595 static int
596 efs_bmap(void *v)
597 {
598 struct vop_bmap_args /* {
599 const struct vnodeop_desc *a_desc;
600 struct vnode *a_vp;
601 daddr_t a_bn;
602 struct vnode **a_vpp;
603 daddr_t *a_bnp;
604 int *a_runp;
605 } */ *ap = v;
606 struct efs_extent ex;
607 struct efs_extent_iterator exi;
608 struct vnode *vp = ap->a_vp;
609 struct efs_inode *eip = EFS_VTOI(vp);
610 bool found;
611 int ret;
612
613 if (ap->a_vpp != NULL)
614 *ap->a_vpp = VFSTOEFS(vp->v_mount)->em_devvp;
615
616 found = false;
617 efs_extent_iterator_init(&exi, eip, ap->a_bn * EFS_BB_SIZE);
618 while ((ret = efs_extent_iterator_next(&exi, &ex)) == 0) {
619 if (ap->a_bn >= ex.ex_offset &&
620 ap->a_bn < (ex.ex_offset + ex.ex_length)) {
621 found = true;
622 break;
623 }
624 }
625
626 KASSERT(!found || (found && ret == 0));
627
628 if (!found) {
629 EFS_DPRINTF(("efs_bmap: ap->a_bn not in extents\n"));
630 return ((ret == -1) ? EIO : ret);
631 }
632
633 if (ex.ex_magic != EFS_EXTENT_MAGIC) {
634 EFS_DPRINTF(("efs_bmap: exn.ex_magic != EFS_EXTENT_MAGIC\n"));
635 return (EIO);
636 }
637
638 if (ap->a_bn < ex.ex_offset) {
639 EFS_DPRINTF(("efs_bmap: ap->a_bn < exn.ex_offset\n"));
640 return (EIO);
641 }
642
643 KASSERT(ap->a_bn >= ex.ex_offset);
644 KASSERT(ex.ex_length > ap->a_bn - ex.ex_offset);
645
646 *ap->a_bnp = ex.ex_bn + (ap->a_bn - ex.ex_offset);
647 if (ap->a_runp != NULL)
648 *ap->a_runp = ex.ex_length - (ap->a_bn - ex.ex_offset) - 1;
649
650 return (0);
651 }
652
653 static int
654 efs_strategy(void *v)
655 {
656 struct vop_strategy_args /* {
657 const struct vnodeop_desc *a_desc;
658 struct vnode *a_vp;
659 struct buf *a_bp;
660 } */ *ap = v;
661 struct vnode *vp = ap->a_vp;
662 struct buf *bp = ap->a_bp;
663 int error;
664
665 if (vp == NULL) {
666 bp->b_error = EIO;
667 biodone(bp);
668 return (EIO);
669 }
670
671 if (bp->b_blkno == bp->b_lblkno) {
672 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
673 if (error) {
674 bp->b_error = error;
675 biodone(bp);
676 return (error);
677 }
678 if ((long)bp->b_blkno == -1)
679 clrbuf(bp);
680 }
681
682 if ((long)bp->b_blkno == -1) {
683 biodone(bp);
684 return (0);
685 }
686
687 return (VOP_STRATEGY(VFSTOEFS(vp->v_mount)->em_devvp, bp));
688 }
689
690 static int
691 efs_print(void *v)
692 {
693 struct vop_print_args /* {
694 const struct vnodeop_desc *a_desc;
695 struct vnode *a_vp;
696 } */ *ap = v;
697 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
698
699 printf( "efs_inode (ino %lu):\n"
700 " ei_mode: %07o\n"
701 " ei_nlink: %d\n"
702 " ei_uid: %d\n"
703 " ei_gid: %d\n"
704 " ei_size: %d\n"
705 " ei_atime: %d\n"
706 " ei_mtime: %d\n"
707 " ei_ctime: %d\n"
708 " ei_gen: %d\n"
709 " ei_numextents: %d\n"
710 " ei_version: %d\n",
711 (unsigned long)eip->ei_number,
712 (unsigned int)eip->ei_mode,
713 eip->ei_nlink,
714 eip->ei_uid,
715 eip->ei_gid,
716 eip->ei_size,
717 (int32_t)eip->ei_atime,
718 (int32_t)eip->ei_mtime,
719 (int32_t)eip->ei_ctime,
720 eip->ei_gen,
721 eip->ei_numextents,
722 eip->ei_version);
723
724 return (0);
725 }
726
727 static int
728 efs_pathconf(void *v)
729 {
730 struct vop_pathconf_args /* {
731 const struct vnodeop_desc *a_desc;
732 struct vnode *a_vp;
733 int a_name;
734 register_t *a_retval;
735 } */ *ap = v;
736
737 /* IRIX 4 values */
738 switch (ap->a_name) {
739 case _PC_LINK_MAX:
740 *ap->a_retval = 30000;
741 break;
742 case _PC_NAME_MAX:
743 *ap->a_retval = 255;
744 break;
745 case _PC_PATH_MAX:
746 *ap->a_retval = 1024;
747 break;
748 case _PC_NO_TRUNC:
749 *ap->a_retval = 1;
750 break;
751 case _PC_CHOWN_RESTRICTED:
752 *ap->a_retval = 1;
753 break;
754 case _PC_SYNC_IO:
755 *ap->a_retval = 1;
756 break;
757 case _PC_FILESIZEBITS:
758 *ap->a_retval = 32;
759 break;
760 default:
761 return (EINVAL);
762 }
763
764 return (0);
765 }
766
767 static int
768 efs_advlock(void *v)
769 {
770 struct vop_advlock_args /* {
771 const struct vnodeop_desc *a_desc;
772 struct vnode *a_vp;
773 void *a_id;
774 int a_op;
775 struct flock *a_fl;
776 int a_flags;
777 } */ *ap = v;
778 struct efs_inode *eip = EFS_VTOI(ap->a_vp);
779
780 return (lf_advlock(ap, &eip->ei_lockf, eip->ei_size));
781 }
782
783 /* Global vfs data structures for efs */
784 int (**efs_vnodeop_p)(void *);
785 const struct vnodeopv_entry_desc efs_vnodeop_entries[] = {
786 { &vop_default_desc, vn_default_error}, /* error handler */
787 { &vop_lookup_desc, efs_lookup }, /* lookup */
788 { &vop_create_desc, genfs_eopnotsupp}, /* create */
789 { &vop_mknod_desc, genfs_eopnotsupp}, /* mknod */
790 { &vop_open_desc, genfs_nullop }, /* open */
791 { &vop_close_desc, genfs_nullop }, /* close */
792 { &vop_access_desc, efs_access }, /* access */
793 { &vop_getattr_desc, efs_getattr }, /* getattr */
794 { &vop_setattr_desc, genfs_eopnotsupp}, /* setattr */
795 { &vop_read_desc, efs_read }, /* read */
796 { &vop_write_desc, genfs_eopnotsupp}, /* write */
797 { &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */
798 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
799 { &vop_poll_desc, genfs_poll }, /* poll */
800 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */
801 { &vop_revoke_desc, genfs_revoke }, /* revoke */
802 { &vop_mmap_desc, genfs_mmap }, /* mmap */
803 { &vop_fsync_desc, genfs_eopnotsupp}, /* fsync */
804 { &vop_seek_desc, genfs_seek }, /* seek */
805 { &vop_remove_desc, genfs_eopnotsupp}, /* remove */
806 { &vop_link_desc, genfs_eopnotsupp}, /* link */
807 { &vop_rename_desc, genfs_eopnotsupp}, /* rename */
808 { &vop_mkdir_desc, genfs_eopnotsupp}, /* mkdir */
809 { &vop_rmdir_desc, genfs_eopnotsupp}, /* rmdir */
810 { &vop_symlink_desc, genfs_eopnotsupp}, /* symlink */
811 { &vop_readdir_desc, efs_readdir }, /* readdir */
812 { &vop_readlink_desc, efs_readlink }, /* readlink */
813 { &vop_abortop_desc, genfs_abortop }, /* abortop */
814 { &vop_inactive_desc, efs_inactive }, /* inactive */
815 { &vop_reclaim_desc, efs_reclaim }, /* reclaim */
816 { &vop_lock_desc, genfs_lock, }, /* lock */
817 { &vop_unlock_desc, genfs_unlock, }, /* unlock */
818 { &vop_islocked_desc, genfs_islocked, }, /* islocked */
819 { &vop_bmap_desc, efs_bmap }, /* bmap */
820 { &vop_print_desc, efs_print }, /* print */
821 { &vop_pathconf_desc, efs_pathconf }, /* pathconf */
822 { &vop_advlock_desc, efs_advlock }, /* advlock */
823 /* blkatoff */
824 /* valloc */
825 /* balloc */
826 /* vfree */
827 /* truncate */
828 { &vop_lease_desc, genfs_lease_check }, /* lease */
829 /* whiteout */
830 { &vop_getpages_desc, genfs_getpages }, /* getpages */
831 { &vop_putpages_desc, genfs_putpages }, /* putpages */
832 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
833 { &vop_strategy_desc, efs_strategy }, /* strategy */
834 { NULL, NULL }
835 };
836 const struct vnodeopv_desc efs_vnodeop_opv_desc = {
837 &efs_vnodeop_p,
838 efs_vnodeop_entries
839 };
840