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