1 /* $OpenBSD: ffs_vnops.c,v 1.33 2005/05/28 02:02:50 pedro Exp $ */
2 /* $NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $ */
3
4 /*
5 * Copyright (c) 1982, 1986, 1989, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * @(#)ffs_vnops.c 8.10 (Berkeley) 8/10/94
33 */
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/resourcevar.h>
38 #include <sys/kernel.h>
39 #include <sys/file.h>
40 #include <sys/stat.h>
41 #include <sys/buf.h>
42 #include <sys/proc.h>
43 #include <sys/conf.h>
44 #include <sys/mount.h>
45 #include <sys/vnode.h>
46 #include <sys/malloc.h>
47 #include <sys/signalvar.h>
48 #include <sys/pool.h>
49
50 #include <uvm/uvm_extern.h>
51
52 #include <miscfs/specfs/specdev.h>
53 #include <miscfs/fifofs/fifo.h>
54
55 #include <ufs/ufs/extattr.h>
56 #include <ufs/ufs/quota.h>
57 #include <ufs/ufs/inode.h>
58 #include <ufs/ufs/dir.h>
59 #include <ufs/ufs/ufs_extern.h>
60 #include <ufs/ufs/ufsmount.h>
61
62 #include <ufs/ffs/fs.h>
63 #include <ufs/ffs/ffs_extern.h>
64
65 /* Global vfs data structures for ufs. */
66 int (**ffs_vnodeop_p)(void *);
67 struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
68 { &vop_default_desc, vn_default_error },
69 { &vop_lookup_desc, ufs_lookup }, /* lookup */
70 { &vop_create_desc, ufs_create }, /* create */
71 { &vop_mknod_desc, ufs_mknod }, /* mknod */
72 { &vop_open_desc, ufs_open }, /* open */
73 { &vop_close_desc, ufs_close }, /* close */
74 { &vop_access_desc, ufs_access }, /* access */
75 { &vop_getattr_desc, ufs_getattr }, /* getattr */
76 { &vop_setattr_desc, ufs_setattr }, /* setattr */
77 { &vop_read_desc, ffs_read }, /* read */
78 { &vop_write_desc, ffs_write }, /* write */
79 { &vop_lease_desc, ufs_lease_check }, /* lease */
80 { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
81 { &vop_poll_desc, ufs_poll }, /* poll */
82 { &vop_kqfilter_desc, ufs_kqfilter }, /* kqfilter */
83 { &vop_revoke_desc, ufs_revoke }, /* revoke */
84 { &vop_fsync_desc, ffs_fsync }, /* fsync */
85 { &vop_remove_desc, ufs_remove }, /* remove */
86 { &vop_link_desc, ufs_link }, /* link */
87 { &vop_rename_desc, ufs_rename }, /* rename */
88 { &vop_mkdir_desc, ufs_mkdir }, /* mkdir */
89 { &vop_rmdir_desc, ufs_rmdir }, /* rmdir */
90 { &vop_symlink_desc, ufs_symlink }, /* symlink */
91 { &vop_readdir_desc, ufs_readdir }, /* readdir */
92 { &vop_readlink_desc, ufs_readlink }, /* readlink */
93 { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
94 { &vop_inactive_desc, ufs_inactive }, /* inactive */
95 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */
96 { &vop_lock_desc, ufs_lock }, /* lock */
97 { &vop_unlock_desc, ufs_unlock }, /* unlock */
98 { &vop_bmap_desc, ufs_bmap }, /* bmap */
99 { &vop_strategy_desc, ufs_strategy }, /* strategy */
100 { &vop_print_desc, ufs_print }, /* print */
101 { &vop_islocked_desc, ufs_islocked }, /* islocked */
102 { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
103 { &vop_advlock_desc, ufs_advlock }, /* advlock */
104 { &vop_reallocblks_desc, ffs_reallocblks }, /* reallocblks */
105 { &vop_bwrite_desc, vop_generic_bwrite },
106 #ifdef UFS_EXTATTR
107 { &vop_getextattr_desc, ufs_vop_getextattr },
108 { &vop_setextattr_desc, ufs_vop_setextattr },
109 #endif
110 { NULL, NULL }
111 };
112 struct vnodeopv_desc ffs_vnodeop_opv_desc =
113 { &ffs_vnodeop_p, ffs_vnodeop_entries };
114
115 int (**ffs_specop_p)(void *);
116 struct vnodeopv_entry_desc ffs_specop_entries[] = {
117 { &vop_default_desc, spec_vnoperate },
118 { &vop_close_desc, ufsspec_close }, /* close */
119 { &vop_access_desc, ufs_access }, /* access */
120 { &vop_getattr_desc, ufs_getattr }, /* getattr */
121 { &vop_setattr_desc, ufs_setattr }, /* setattr */
122 { &vop_read_desc, ufsspec_read }, /* read */
123 { &vop_write_desc, ufsspec_write }, /* write */
124 { &vop_fsync_desc, ffs_fsync }, /* fsync */
125 { &vop_inactive_desc, ufs_inactive }, /* inactive */
126 { &vop_reclaim_desc, ffs_reclaim }, /* reclaim */
127 { &vop_lock_desc, ufs_lock }, /* lock */
128 { &vop_unlock_desc, ufs_unlock }, /* unlock */
129 { &vop_print_desc, ufs_print }, /* print */
130 { &vop_islocked_desc, ufs_islocked }, /* islocked */
131 #ifdef UFS_EXTATTR
132 { &vop_getextattr_desc, ufs_vop_getextattr },
133 { &vop_setextattr_desc, ufs_vop_setextattr },
134 #endif
135 { NULL, NULL }
136 };
137 struct vnodeopv_desc ffs_specop_opv_desc =
138 { &ffs_specop_p, ffs_specop_entries };
139
140 #ifdef FIFO
141 int (**ffs_fifoop_p)(void *);
142 struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
143 { &vop_default_desc, fifo_vnoperate },
144 { &vop_close_desc, ufsfifo_close }, /* close */
145 { &vop_access_desc, ufs_access }, /* access */
146 { &vop_getattr_desc, ufs_getattr }, /* getattr */
147 { &vop_setattr_desc, ufs_setattr }, /* setattr */
148 { &vop_read_desc, ufsfifo_read }, /* read */
149 { &vop_write_desc, ufsfifo_write }, /* write */
150 { &vop_fsync_desc, ffs_fsync }, /* fsync */
151 { &vop_inactive_desc, ufs_inactive }, /* inactive */
152 { &vop_reclaim_desc, ffsfifo_reclaim }, /* reclaim */
153 { &vop_lock_desc, ufs_lock }, /* lock */
154 { &vop_unlock_desc, ufs_unlock }, /* unlock */
155 { &vop_print_desc, ufs_print }, /* print */
156 { &vop_islocked_desc, ufs_islocked }, /* islocked */
157 { &vop_bwrite_desc, vop_generic_bwrite },
158 #ifdef UFS_EXTATTR
159 { &vop_getextattr_desc, ufs_vop_getextattr },
160 { &vop_setextattr_desc, ufs_vop_setextattr },
161 #endif
162 { NULL, NULL }
163 };
164 struct vnodeopv_desc ffs_fifoop_opv_desc =
165 { &ffs_fifoop_p, ffs_fifoop_entries };
166 #endif /* FIFO */
167
168 /*
169 * Enabling cluster read/write operations.
170 */
171 int doclusterread = 1;
172 int doclusterwrite = 1;
173
174 #include <ufs/ufs/ufs_readwrite.c>
175
176 /*
177 * Synch an open file.
178 */
179 /* ARGSUSED */
180 int
ffs_fsync(v)181 ffs_fsync(v)
182 void *v;
183 {
184 struct vop_fsync_args /* {
185 struct vnode *a_vp;
186 struct ucred *a_cred;
187 int a_waitfor;
188 struct proc *a_p;
189 } */ *ap = v;
190 struct vnode *vp = ap->a_vp;
191 struct buf *bp, *nbp;
192 int s, error, passes, skipmeta;
193
194 if (vp->v_type == VBLK &&
195 vp->v_specmountpoint != NULL &&
196 (vp->v_specmountpoint->mnt_flag & MNT_SOFTDEP))
197 softdep_fsync_mountdev(vp);
198
199 /*
200 * Flush all dirty buffers associated with a vnode.
201 */
202 passes = NIADDR + 1;
203 skipmeta = 0;
204 if (ap->a_waitfor == MNT_WAIT)
205 skipmeta = 1;
206 s = splbio();
207 loop:
208 for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp;
209 bp = LIST_NEXT(bp, b_vnbufs))
210 bp->b_flags &= ~B_SCANNED;
211 for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
212 nbp = LIST_NEXT(bp, b_vnbufs);
213 /*
214 * Reasons to skip this buffer: it has already been considered
215 * on this pass, this pass is the first time through on a
216 * synchronous flush request and the buffer being considered
217 * is metadata, the buffer has dependencies that will cause
218 * it to be redirtied and it has not already been deferred,
219 * or it is already being written.
220 */
221 if (bp->b_flags & (B_BUSY | B_SCANNED))
222 continue;
223 if ((bp->b_flags & B_DELWRI) == 0)
224 panic("ffs_fsync: not dirty");
225 if (skipmeta && bp->b_lblkno < 0)
226 continue;
227 if (ap->a_waitfor != MNT_WAIT &&
228 LIST_FIRST(&bp->b_dep) != NULL &&
229 (bp->b_flags & B_DEFERRED) == 0 &&
230 buf_countdeps(bp, 0, 1)) {
231 bp->b_flags |= B_DEFERRED;
232 continue;
233 }
234
235 bremfree(bp);
236 bp->b_flags |= B_BUSY | B_SCANNED;
237 splx(s);
238 /*
239 * On our final pass through, do all I/O synchronously
240 * so that we can find out if our flush is failing
241 * because of write errors.
242 */
243 if (passes > 0 || ap->a_waitfor != MNT_WAIT)
244 (void) bawrite(bp);
245 else if ((error = bwrite(bp)) != 0)
246 return (error);
247 s = splbio();
248 /*
249 * Since we may have slept during the I/O, we need
250 * to start from a known point.
251 */
252 nbp = LIST_FIRST(&vp->v_dirtyblkhd);
253 }
254 if (skipmeta) {
255 skipmeta = 0;
256 goto loop;
257 }
258 if (ap->a_waitfor == MNT_WAIT) {
259 vwaitforio(vp, 0, "ffs_fsync", 0);
260
261 /*
262 * Ensure that any filesystem metadata associated
263 * with the vnode has been written.
264 */
265 splx(s);
266 if ((error = softdep_sync_metadata(ap)) != 0)
267 return (error);
268 s = splbio();
269 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
270 /*
271 * Block devices associated with filesystems may
272 * have new I/O requests posted for them even if
273 * the vnode is locked, so no amount of trying will
274 * get them clean. Thus we give block devices a
275 * good effort, then just give up. For all other file
276 * types, go around and try again until it is clean.
277 */
278 if (passes > 0) {
279 passes -= 1;
280 goto loop;
281 }
282 #ifdef DIAGNOSTIC
283 if (vp->v_type != VBLK)
284 vprint("ffs_fsync: dirty", vp);
285 #endif
286 }
287 }
288 splx(s);
289 return (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
290 }
291
292 /*
293 * Reclaim an inode so that it can be used for other purposes.
294 */
295 int
ffs_reclaim(v)296 ffs_reclaim(v)
297 void *v;
298 {
299 struct vop_reclaim_args /* {
300 struct vnode *a_vp;
301 struct proc *a_p;
302 } */ *ap = v;
303 register struct vnode *vp = ap->a_vp;
304 int error;
305
306 if ((error = ufs_reclaim(vp, ap->a_p)) != 0)
307 return (error);
308 /* XXX - same for for both mfs and ffs */
309 pool_put(&ffs_ino_pool, vp->v_data);
310 vp->v_data = NULL;
311 return (0);
312 }
313
314 #ifdef FIFO
315 int
ffsfifo_reclaim(void * v)316 ffsfifo_reclaim(void *v)
317 {
318 fifo_reclaim(v);
319 return (ffs_reclaim(v));
320 }
321 #endif
322