![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lfs_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / ufs / lfs|
Return to lfs_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / ufs / lfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* $NetBSD: lfs_vnops.c,v 1.6 1994/12/14 13:03:50 mycroft Exp $ */
26:
27: /*
28: * Copyright (c) 1986, 1989, 1991, 1993
29: * The Regents of the University of California. All rights reserved.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Berkeley and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * @(#)lfs_vnops.c 8.8 (Berkeley) 8/10/94
60: */
61:
62: #include <sys/param.h>
63: #include <sys/systm.h>
64: #include <sys/namei.h>
65: #include <sys/resourcevar.h>
66: #include <sys/kernel.h>
67: #include <sys/file.h>
68: #include <sys/stat.h>
69: #include <sys/buf.h>
70: #include <sys/proc.h>
71: #include <sys/conf.h>
72: #include <sys/mount.h>
73: #include <sys/vnode.h>
74: #include <sys/malloc.h>
75:
76: #include <vm/vm.h>
77:
78: #include <miscfs/specfs/specdev.h>
79: #include <miscfs/fifofs/fifo.h>
80:
81: #include <ufs/ufs/quota.h>
82: #include <ufs/ufs/inode.h>
83: #include <ufs/ufs/dir.h>
84: #include <ufs/ufs/ufsmount.h>
85: #include <ufs/ufs/ufs_extern.h>
86:
87: #include <ufs/lfs/lfs.h>
88: #include <ufs/lfs/lfs_extern.h>
89:
90: /* Global vfs data structures for lfs. */
91: int (**lfs_vnodeop_p)();
92: struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
93: { &vop_default_desc, vn_default_error },
94: { &vop_lookup_desc, ufs_lookup }, /* lookup */
95: { &vop_create_desc, ufs_create }, /* create */
96: { &vop_whiteout_desc, ufs_whiteout }, /* whiteout */
97: { &vop_mknod_desc, ufs_mknod }, /* mknod */
98: { &vop_open_desc, ufs_open }, /* open */
99: { &vop_close_desc, lfs_close }, /* close */
100: { &vop_access_desc, ufs_access }, /* access */
101: { &vop_getattr_desc, lfs_getattr }, /* getattr */
102: { &vop_setattr_desc, ufs_setattr }, /* setattr */
103: { &vop_read_desc, lfs_read }, /* read */
104: { &vop_write_desc, lfs_write }, /* write */
105: { &vop_lease_desc, ufs_lease_check }, /* lease */
106: { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
107: { &vop_select_desc, ufs_select }, /* select */
108: { &vop_mmap_desc, ufs_mmap }, /* mmap */
109: { &vop_fsync_desc, lfs_fsync }, /* fsync */
110: { &vop_seek_desc, ufs_seek }, /* seek */
111: { &vop_remove_desc, ufs_remove }, /* remove */
112: { &vop_link_desc, ufs_link }, /* link */
113: { &vop_rename_desc, ufs_rename }, /* rename */
114: { &vop_mkdir_desc, ufs_mkdir }, /* mkdir */
115: { &vop_rmdir_desc, ufs_rmdir }, /* rmdir */
116: { &vop_symlink_desc, ufs_symlink }, /* symlink */
117: { &vop_readdir_desc, ufs_readdir }, /* readdir */
118: { &vop_readlink_desc, ufs_readlink }, /* readlink */
119: { &vop_abortop_desc, ufs_abortop }, /* abortop */
120: { &vop_inactive_desc, lfs_inactive }, /* inactive */
121: { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
122: { &vop_lock_desc, ufs_lock }, /* lock */
123: { &vop_unlock_desc, ufs_unlock }, /* unlock */
124: { &vop_bmap_desc, ufs_bmap }, /* bmap */
125: { &vop_strategy_desc, ufs_strategy }, /* strategy */
126: { &vop_print_desc, ufs_print }, /* print */
127: { &vop_islocked_desc, ufs_islocked }, /* islocked */
128: { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
129: { &vop_advlock_desc, ufs_advlock }, /* advlock */
130: { &vop_blkatoff_desc, lfs_blkatoff }, /* blkatoff */
131: { &vop_valloc_desc, lfs_valloc }, /* valloc */
132: { &vop_vfree_desc, lfs_vfree }, /* vfree */
133: { &vop_truncate_desc, lfs_truncate }, /* truncate */
134: { &vop_update_desc, lfs_update }, /* update */
135: { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
136: { &vop_pgrd_desc, lfs_pgrg }, /* pager read */
137: { &vop_pgwr_desc, lfs_pgwr }, /* pager write */
138: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
139: };
140: struct vnodeopv_desc lfs_vnodeop_opv_desc =
141: { &lfs_vnodeop_p, lfs_vnodeop_entries };
142:
143: int (**lfs_specop_p)();
144: struct vnodeopv_entry_desc lfs_specop_entries[] = {
145: { &vop_default_desc, vn_default_error },
146: { &vop_lookup_desc, spec_lookup }, /* lookup */
147: { &vop_create_desc, spec_create }, /* create */
148: { &vop_mknod_desc, spec_mknod }, /* mknod */
149: { &vop_open_desc, spec_open }, /* open */
150: { &vop_close_desc, ufsspec_close }, /* close */
151: { &vop_access_desc, ufs_access }, /* access */
152: { &vop_getattr_desc, lfs_getattr }, /* getattr */
153: { &vop_setattr_desc, ufs_setattr }, /* setattr */
154: { &vop_read_desc, ufsspec_read }, /* read */
155: { &vop_write_desc, ufsspec_write }, /* write */
156: { &vop_lease_desc, spec_lease_check }, /* lease */
157: { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
158: { &vop_select_desc, spec_select }, /* select */
159: { &vop_mmap_desc, spec_mmap }, /* mmap */
160: { &vop_fsync_desc, spec_fsync }, /* fsync */
161: { &vop_seek_desc, spec_seek }, /* seek */
162: { &vop_remove_desc, spec_remove }, /* remove */
163: { &vop_link_desc, spec_link }, /* link */
164: { &vop_rename_desc, spec_rename }, /* rename */
165: { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
166: { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
167: { &vop_symlink_desc, spec_symlink }, /* symlink */
168: { &vop_readdir_desc, spec_readdir }, /* readdir */
169: { &vop_readlink_desc, spec_readlink }, /* readlink */
170: { &vop_abortop_desc, spec_abortop }, /* abortop */
171: { &vop_inactive_desc, lfs_inactive }, /* inactive */
172: { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
173: { &vop_lock_desc, ufs_lock }, /* lock */
174: { &vop_unlock_desc, ufs_unlock }, /* unlock */
175: { &vop_bmap_desc, spec_bmap }, /* bmap */
176: { &vop_strategy_desc, spec_strategy }, /* strategy */
177: { &vop_print_desc, ufs_print }, /* print */
178: { &vop_islocked_desc, ufs_islocked }, /* islocked */
179: { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
180: { &vop_advlock_desc, spec_advlock }, /* advlock */
181: { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
182: { &vop_valloc_desc, spec_valloc }, /* valloc */
183: { &vop_vfree_desc, lfs_vfree }, /* vfree */
184: { &vop_truncate_desc, spec_truncate }, /* truncate */
185: { &vop_update_desc, lfs_update }, /* update */
186: { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
187: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
188: };
189: struct vnodeopv_desc lfs_specop_opv_desc =
190: { &lfs_specop_p, lfs_specop_entries };
191:
1.1.1.2 ! root 192: #if FIFO
1.1 root 193: int (**lfs_fifoop_p)();
194: struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
195: { &vop_default_desc, vn_default_error },
196: { &vop_lookup_desc, fifo_lookup }, /* lookup */
197: { &vop_create_desc, fifo_create }, /* create */
198: { &vop_mknod_desc, fifo_mknod }, /* mknod */
199: { &vop_open_desc, fifo_open }, /* open */
200: { &vop_close_desc, ufsfifo_close }, /* close */
201: { &vop_access_desc, ufs_access }, /* access */
202: { &vop_getattr_desc, lfs_getattr }, /* getattr */
203: { &vop_setattr_desc, ufs_setattr }, /* setattr */
204: { &vop_read_desc, ufsfifo_read }, /* read */
205: { &vop_write_desc, ufsfifo_write }, /* write */
206: { &vop_lease_desc, fifo_lease_check }, /* lease */
207: { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
208: { &vop_select_desc, fifo_select }, /* select */
209: { &vop_mmap_desc, fifo_mmap }, /* mmap */
210: { &vop_fsync_desc, fifo_fsync }, /* fsync */
211: { &vop_seek_desc, fifo_seek }, /* seek */
212: { &vop_remove_desc, fifo_remove }, /* remove */
213: { &vop_link_desc, fifo_link }, /* link */
214: { &vop_rename_desc, fifo_rename }, /* rename */
215: { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
216: { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
217: { &vop_symlink_desc, fifo_symlink }, /* symlink */
218: { &vop_readdir_desc, fifo_readdir }, /* readdir */
219: { &vop_readlink_desc, fifo_readlink }, /* readlink */
220: { &vop_abortop_desc, fifo_abortop }, /* abortop */
221: { &vop_inactive_desc, lfs_inactive }, /* inactive */
222: { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
223: { &vop_lock_desc, ufs_lock }, /* lock */
224: { &vop_unlock_desc, ufs_unlock }, /* unlock */
225: { &vop_bmap_desc, fifo_bmap }, /* bmap */
226: { &vop_strategy_desc, fifo_strategy }, /* strategy */
227: { &vop_print_desc, ufs_print }, /* print */
228: { &vop_islocked_desc, ufs_islocked }, /* islocked */
229: { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
230: { &vop_advlock_desc, fifo_advlock }, /* advlock */
231: { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
232: { &vop_valloc_desc, fifo_valloc }, /* valloc */
233: { &vop_vfree_desc, lfs_vfree }, /* vfree */
234: { &vop_truncate_desc, fifo_truncate }, /* truncate */
235: { &vop_update_desc, lfs_update }, /* update */
236: { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
237: { (struct vnodeop_desc*)NULL, (int(*)())NULL }
238: };
239: struct vnodeopv_desc lfs_fifoop_opv_desc =
240: { &lfs_fifoop_p, lfs_fifoop_entries };
241: #endif /* FIFO */
242:
243: #define LFS_READWRITE
244: #include <ufs/ufs/ufs_readwrite.c>
245: #undef LFS_READWRITE
246:
247: /*
248: * Synch an open file.
249: */
250: /* ARGSUSED */
251: lfs_fsync(ap)
252: struct vop_fsync_args /* {
253: struct vnode *a_vp;
254: struct ucred *a_cred;
255: int a_waitfor;
256: struct proc *a_p;
257: } */ *ap;
258: {
259: struct timeval tv;
260:
261: tv = time;
262: return (VOP_UPDATE(ap->a_vp, &tv, &tv,
263: ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0));
264: }
265:
266: /*
267: * These macros are used to bracket UFS directory ops, so that we can
268: * identify all the pages touched during directory ops which need to
269: * be ordered and flushed atomically, so that they may be recovered.
270: */
271: #define SET_DIROP(fs) { \
272: if ((fs)->lfs_writer) \
273: tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0); \
274: ++(fs)->lfs_dirops; \
275: (fs)->lfs_doifile = 1; \
276: }
277:
278: #define SET_ENDOP(fs) { \
279: --(fs)->lfs_dirops; \
280: if (!(fs)->lfs_dirops) \
281: wakeup(&(fs)->lfs_writer); \
282: }
283:
284: #define MARK_VNODE(dvp) (dvp)->v_flag |= VDIROP
285:
286: int
287: lfs_symlink(ap)
288: struct vop_symlink_args /* {
289: struct vnode *a_dvp;
290: struct vnode **a_vpp;
291: struct componentname *a_cnp;
292: struct vattr *a_vap;
293: char *a_target;
294: } */ *ap;
295: {
296: int ret;
297:
298: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
299: MARK_VNODE(ap->a_dvp);
300: ret = ufs_symlink(ap);
301: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
302: return (ret);
303: }
304:
305: int
306: lfs_mknod(ap)
307: struct vop_mknod_args /* {
308: struct vnode *a_dvp;
309: struct vnode **a_vpp;
310: struct componentname *a_cnp;
311: struct vattr *a_vap;
312: } */ *ap;
313: {
314: int ret;
315:
316: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
317: MARK_VNODE(ap->a_dvp);
318: ret = ufs_mknod(ap);
319: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
320: return (ret);
321: }
322:
323: int
324: lfs_create(ap)
325: struct vop_create_args /* {
326: struct vnode *a_dvp;
327: struct vnode **a_vpp;
328: struct componentname *a_cnp;
329: struct vattr *a_vap;
330: } */ *ap;
331: {
332: int ret;
333:
334: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
335: MARK_VNODE(ap->a_dvp);
336: ret = ufs_create(ap);
337: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
338: return (ret);
339: }
340:
341: int
342: lfs_mkdir(ap)
343: struct vop_mkdir_args /* {
344: struct vnode *a_dvp;
345: struct vnode **a_vpp;
346: struct componentname *a_cnp;
347: struct vattr *a_vap;
348: } */ *ap;
349: {
350: int ret;
351:
352: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
353: MARK_VNODE(ap->a_dvp);
354: ret = ufs_mkdir(ap);
355: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
356: return (ret);
357: }
358:
359: int
360: lfs_remove(ap)
361: struct vop_remove_args /* {
362: struct vnode *a_dvp;
363: struct vnode *a_vp;
364: struct componentname *a_cnp;
365: } */ *ap;
366: {
367: int ret;
368:
369: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
370: MARK_VNODE(ap->a_dvp);
371: MARK_VNODE(ap->a_vp);
372: ret = ufs_remove(ap);
373: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
374: return (ret);
375: }
376:
377: int
378: lfs_rmdir(ap)
379: struct vop_rmdir_args /* {
380: struct vnodeop_desc *a_desc;
381: struct vnode *a_dvp;
382: struct vnode *a_vp;
383: struct componentname *a_cnp;
384: } */ *ap;
385: {
386: int ret;
387:
388: SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
389: MARK_VNODE(ap->a_dvp);
390: MARK_VNODE(ap->a_vp);
391: ret = ufs_rmdir(ap);
392: SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
393: return (ret);
394: }
395:
396: int
397: lfs_link(ap)
398: struct vop_link_args /* {
399: struct vnode *a_vp;
400: struct vnode *a_tdvp;
401: struct componentname *a_cnp;
402: } */ *ap;
403: {
404: int ret;
405:
406: SET_DIROP(VTOI(ap->a_vp)->i_lfs);
407: MARK_VNODE(ap->a_vp);
408: ret = ufs_link(ap);
409: SET_ENDOP(VTOI(ap->a_vp)->i_lfs);
410: return (ret);
411: }
412:
413: int
414: lfs_rename(ap)
415: struct vop_rename_args /* {
416: struct vnode *a_fdvp;
417: struct vnode *a_fvp;
418: struct componentname *a_fcnp;
419: struct vnode *a_tdvp;
420: struct vnode *a_tvp;
421: struct componentname *a_tcnp;
422: } */ *ap;
423: {
424: int ret;
425:
426: SET_DIROP(VTOI(ap->a_fdvp)->i_lfs);
427: MARK_VNODE(ap->a_fdvp);
428: MARK_VNODE(ap->a_tdvp);
429: ret = ufs_rename(ap);
430: SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
431: return (ret);
432: }
433: /* XXX hack to avoid calling ITIMES in getattr */
434: int
435: lfs_getattr(ap)
436: struct vop_getattr_args /* {
437: struct vnode *a_vp;
438: struct vattr *a_vap;
439: struct ucred *a_cred;
440: struct proc *a_p;
441: } */ *ap;
442: {
443: register struct vnode *vp = ap->a_vp;
444: register struct inode *ip = VTOI(vp);
445: register struct vattr *vap = ap->a_vap;
446: /*
447: * Copy from inode table
448: */
449: vap->va_fsid = ip->i_dev;
450: vap->va_fileid = ip->i_number;
451: vap->va_mode = ip->i_mode & ~IFMT;
452: vap->va_nlink = ip->i_nlink;
453: vap->va_uid = ip->i_uid;
454: vap->va_gid = ip->i_gid;
455: vap->va_rdev = (dev_t)ip->i_rdev;
456: vap->va_size = ip->i_din.di_size;
457: vap->va_atime = ip->i_atime;
458: vap->va_mtime = ip->i_mtime;
459: vap->va_ctime = ip->i_ctime;
460: vap->va_flags = ip->i_flags;
461: vap->va_gen = ip->i_gen;
462: /* this doesn't belong here */
463: if (vp->v_type == VBLK)
464: vap->va_blocksize = BLKDEV_IOSIZE;
465: else if (vp->v_type == VCHR)
466: vap->va_blocksize = MAXPHYSIO;
467: else
468: vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
469: vap->va_bytes = dbtob(ip->i_blocks);
470: vap->va_type = vp->v_type;
471: vap->va_filerev = ip->i_modrev;
472: return (0);
473: }
474: /*
475: * Close called
476: *
477: * XXX -- we were using ufs_close, but since it updates the
478: * times on the inode, we might need to bump the uinodes
479: * count.
480: */
481: /* ARGSUSED */
482: int
483: lfs_close(ap)
484: struct vop_close_args /* {
485: struct vnode *a_vp;
486: int a_fflag;
487: struct ucred *a_cred;
488: struct proc *a_p;
489: } */ *ap;
490: {
491: register struct vnode *vp = ap->a_vp;
492: register struct inode *ip = VTOI(vp);
493: int mod;
494:
495: if (vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) {
496: mod = ip->i_flag & IN_MODIFIED;
497: ITIMES(ip, &time, &time);
498: if (!mod && ip->i_flag & IN_MODIFIED)
499: ip->i_lfs->lfs_uinodes++;
500: }
501: return (0);
502: }
503:
504: /*
505: * Stub inactive routine that avoid calling ufs_inactive in some cases.
506: */
507: int lfs_no_inactive = 0;
508:
509: int
510: lfs_inactive(ap)
511: struct vop_inactive_args /* {
512: struct vnode *a_vp;
513: } */ *ap;
514: {
515:
516: if (lfs_no_inactive)
517: return (0);
518: return (ufs_inactive(ap));
519: }
520:
521: /*
522: * Reclaim an inode so that it can be used for other purposes.
523: */
524: int
525: lfs_reclaim(ap)
526: struct vop_reclaim_args /* {
527: struct vnode *a_vp;
528: } */ *ap;
529: {
530: register struct vnode *vp = ap->a_vp;
531: int error;
532:
533: if (error = ufs_reclaim(vp))
534: return (error);
535: FREE(vp->v_data, M_LFSNODE);
536: vp->v_data = NULL;
537: return (0);
538: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.