Rename printf -> kprintf in sys/ and add some defines where necessary
[dragonfly.git] / sys / vfs / nwfs / nwfs_io.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1999, Boris Popov
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Boris Popov.
16 * 4. Neither the name of the author nor the names of any co-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 AUTHOR 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 AUTHOR 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 * $FreeBSD: src/sys/nwfs/nwfs_io.c,v 1.6.2.1 2000/10/25 02:11:10 bp Exp $
086c1d7e 33 * $DragonFly: src/sys/vfs/nwfs/nwfs_io.c,v 1.23 2006/12/23 00:41:30 swildner Exp $
984263bc
MD
34 *
35 */
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/resourcevar.h> /* defines plimit structure in proc struct */
39#include <sys/kernel.h>
40#include <sys/buf.h>
41#include <sys/proc.h>
42#include <sys/mount.h>
43#include <sys/namei.h>
44#include <sys/vnode.h>
45#include <sys/dirent.h>
46#include <sys/signalvar.h>
47#include <sys/sysctl.h>
48
49#include <vm/vm.h>
50#include <vm/vm_page.h>
51#include <vm/vm_extern.h>
52#include <vm/vm_object.h>
53#include <vm/vm_pager.h>
54#include <vm/vnode_pager.h>
55
d2438d69
MD
56#include <netproto/ncp/ncp.h>
57#include <netproto/ncp/ncp_conn.h>
58#include <netproto/ncp/ncp_subr.h>
984263bc 59
165dba55
DR
60#include <sys/thread2.h>
61
b7d9f6b6
JS
62#include <machine/limits.h>
63
1f2de5d4
MD
64#include "nwfs.h"
65#include "nwfs_node.h"
66#include "nwfs_subr.h"
984263bc
MD
67
68static int nwfs_fastlookup = 1;
69
984263bc
MD
70SYSCTL_DECL(_vfs_nwfs);
71SYSCTL_INT(_vfs_nwfs, OID_AUTO, fastlookup, CTLFLAG_RW, &nwfs_fastlookup, 0, "");
72
73
74extern int nwfs_pbuf_freecnt;
75
984263bc
MD
76#define NWFS_RWCACHE
77
78static int
a9bb80e0
CP
79nwfs_readvdir(struct vnode *vp, struct uio *uio, struct ucred *cred)
80{
984263bc
MD
81 struct nwmount *nmp = VTONWFS(vp);
82 int error, count, i;
984263bc
MD
83 struct nwnode *np = VTONW(vp);
84 struct nw_entry_info fattr;
85 struct vnode *newvp;
984263bc 86 ncpfid fid;
b7d9f6b6
JS
87 ino_t d_ino;
88 size_t d_namlen;
89 const char *d_name;
90 uint8_t d_type;
984263bc
MD
91
92 np = VTONW(vp);
93 NCPVNDEBUG("dirname='%s'\n",np->n_name);
b7d9f6b6 94 if (uio->uio_resid < 0 || uio->uio_offset < 0 || uio->uio_offset > INT_MAX)
984263bc
MD
95 return (EINVAL);
96 error = 0;
97 count = 0;
b7d9f6b6 98 i = uio->uio_offset; /* offset in directory */
984263bc 99 if (i == 0) {
dadab5e9 100 error = ncp_initsearch(vp, uio->uio_td, cred);
984263bc
MD
101 if (error) {
102 NCPVNDEBUG("cannot initialize search, error=%d",error);
103 return( error );
104 }
105 }
106
b7d9f6b6 107 for (; !error && uio->uio_resid > 0; i++) {
984263bc
MD
108 switch (i) {
109 case 0: /* `.' */
b7d9f6b6
JS
110 d_ino = np->n_fid.f_id;
111 if (d_ino == 0)
112 d_ino = NWFS_ROOT_INO;
113 d_namlen = 1;
114 d_name = ".";
115 d_type = DT_DIR;
116 break;
984263bc 117 case 1: /* `..' */
b7d9f6b6
JS
118 d_ino = np->n_parent.f_id;
119 if (d_ino == 0)
120 d_ino = NWFS_ROOT_INO;
121 d_namlen = 2;
122 d_name = "..";
123 d_type = DT_DIR;
984263bc
MD
124 break;
125 default:
dadab5e9 126 error = ncp_search_for_file_or_subdir(nmp, &np->n_seq, &fattr, uio->uio_td, cred);
b7d9f6b6
JS
127 if (error && error < 0x80)
128 goto done;
129 d_ino = fattr.dirEntNum;
130 d_type = (fattr.attributes & aDIR) ? DT_DIR : DT_REG;
131 d_namlen = fattr.nameLen;
132 d_name = fattr.entryName;
984263bc
MD
133#if 0
134 if (error && eofflag) {
135 /* *eofflag = 1;*/
136 break;
137 }
138#endif
139 break;
140 }
141 if (nwfs_fastlookup && !error && i > 1) {
142 fid.f_id = fattr.dirEntNum;
143 fid.f_parent = np->n_fid.f_id;
144 error = nwfs_nget(vp->v_mount, fid, &fattr, vp, &newvp);
145 if (!error) {
146 VTONW(newvp)->n_ctime = VTONW(newvp)->n_vattr.va_ctime.tv_sec;
984263bc
MD
147 vput(newvp);
148 } else
149 error = 0;
150 }
151 if (error >= 0x80) {
152 error = 0;
153 break;
154 }
b7d9f6b6 155 if (vop_write_dirent(&error, uio, d_ino, d_type, d_namlen, d_name))
984263bc
MD
156 break;
157 }
b7d9f6b6
JS
158done:
159 uio->uio_offset = i;
984263bc
MD
160 return (error);
161}
162
163int
a9bb80e0
CP
164nwfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred)
165{
984263bc
MD
166 struct nwmount *nmp = VFSTONWFS(vp->v_mount);
167 struct nwnode *np = VTONW(vp);
dadab5e9 168 struct thread *td;
984263bc
MD
169 struct vattr vattr;
170 int error, biosize;
171
172 if (vp->v_type != VREG && vp->v_type != VDIR) {
086c1d7e 173 kprintf("%s: vn types other than VREG or VDIR are unsupported !\n",__func__);
984263bc
MD
174 return EIO;
175 }
176 if (uiop->uio_resid == 0) return 0;
177 if (uiop->uio_offset < 0) return EINVAL;
178/* if (uiop->uio_offset + uiop->uio_resid > nmp->nm_maxfilesize)
179 return (EFBIG);*/
dadab5e9 180 td = uiop->uio_td;
984263bc
MD
181 if (vp->v_type == VDIR) {
182 error = nwfs_readvdir(vp, uiop, cred);
183 return error;
184 }
185 biosize = NWFSTOCONN(nmp)->buffer_size;
186 if (np->n_flag & NMODIFIED) {
187 nwfs_attr_cacheremove(vp);
87de5057 188 error = VOP_GETATTR(vp, &vattr);
984263bc
MD
189 if (error) return (error);
190 np->n_mtime = vattr.va_mtime.tv_sec;
191 } else {
87de5057 192 error = VOP_GETATTR(vp, &vattr);
984263bc
MD
193 if (error) return (error);
194 if (np->n_mtime != vattr.va_mtime.tv_sec) {
87de5057 195 error = nwfs_vinvalbuf(vp, V_SAVE, 1);
984263bc
MD
196 if (error) return (error);
197 np->n_mtime = vattr.va_mtime.tv_sec;
198 }
199 }
200 error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop,cred);
201 return (error);
202}
203
204int
a9bb80e0
CP
205nwfs_writevnode(struct vnode *vp, struct uio *uiop, struct ucred *cred,
206 int ioflag)
984263bc
MD
207{
208 struct nwmount *nmp = VTONWFS(vp);
209 struct nwnode *np = VTONW(vp);
dadab5e9 210 struct thread *td;
984263bc
MD
211/* struct vattr vattr;*/
212 int error = 0;
213
214 if (vp->v_type != VREG) {
086c1d7e 215 kprintf("%s: vn types other than VREG unsupported !\n",__func__);
984263bc
MD
216 return EIO;
217 }
218 NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
219 if (uiop->uio_offset < 0) return EINVAL;
220/* if (uiop->uio_offset + uiop->uio_resid > nmp->nm_maxfilesize)
221 return (EFBIG);*/
dadab5e9 222 td = uiop->uio_td;
984263bc
MD
223 if (ioflag & (IO_APPEND | IO_SYNC)) {
224 if (np->n_flag & NMODIFIED) {
225 nwfs_attr_cacheremove(vp);
87de5057 226 error = nwfs_vinvalbuf(vp, V_SAVE, 1);
984263bc
MD
227 if (error) return (error);
228 }
229 if (ioflag & IO_APPEND) {
230 /* We can relay only on local information about file size,
231 * because until file is closed NetWare will not return
232 * the correct size. */
233#if notyet
234 nwfs_attr_cacheremove(vp);
87de5057 235 error = VOP_GETATTR(vp, &vattr);
984263bc
MD
236 if (error) return (error);
237#endif
238 uiop->uio_offset = np->n_size;
239 }
240 }
241 if (uiop->uio_resid == 0) return 0;
dadab5e9
MD
242 if (td->td_proc && uiop->uio_offset + uiop->uio_resid >
243 td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
84204577 244 ksignal(td->td_proc, SIGXFSZ);
984263bc
MD
245 return (EFBIG);
246 }
247 error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cred);
248 NCPVNDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
249 if (!error) {
250 if (uiop->uio_offset > np->n_size) {
251 np->n_vattr.va_size = np->n_size = uiop->uio_offset;
252 vnode_pager_setsize(vp, np->n_size);
253 }
254 }
255 return (error);
256}
257
258/*
259 * Do an I/O operation to/from a cache block.
260 */
261int
81b5c339 262nwfs_doio(struct vnode *vp, struct bio *bio, struct ucred *cr, struct thread *td)
984263bc 263{
81b5c339 264 struct buf *bp = bio->bio_buf;
984263bc 265 struct uio *uiop;
984263bc
MD
266 struct nwnode *np;
267 struct nwmount *nmp;
268 int error = 0;
269 struct uio uio;
270 struct iovec io;
271
984263bc
MD
272 np = VTONW(vp);
273 nmp = VFSTONWFS(vp->v_mount);
274 uiop = &uio;
275 uiop->uio_iov = &io;
276 uiop->uio_iovcnt = 1;
277 uiop->uio_segflg = UIO_SYSSPACE;
dadab5e9 278 uiop->uio_td = td;
10f3fee5
MD
279
280 if (bp->b_cmd == BUF_CMD_READ) {
984263bc
MD
281 io.iov_len = uiop->uio_resid = bp->b_bcount;
282 io.iov_base = bp->b_data;
283 uiop->uio_rw = UIO_READ;
284 switch (vp->v_type) {
285 case VREG:
54078292 286 uiop->uio_offset = bio->bio_offset;
984263bc
MD
287 error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);
288 if (error)
289 break;
290 if (uiop->uio_resid) {
291 int left = uiop->uio_resid;
292 int nread = bp->b_bcount - left;
293 if (left > 0)
294 bzero((char *)bp->b_data + nread, left);
295 }
296 break;
297/* case VDIR:
298 nfsstats.readdir_bios++;
54078292 299 uiop->uio_offset = bio->bio_offset;
984263bc
MD
300 if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
301 error = nfs_readdirplusrpc(vp, uiop, cr);
302 if (error == NFSERR_NOTSUPP)
303 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
304 }
305 if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
306 error = nfs_readdirrpc(vp, uiop, cr);
307 if (error == 0 && uiop->uio_resid == bp->b_bcount)
308 bp->b_flags |= B_INVAL;
309 break;
310*/
311 default:
086c1d7e 312 kprintf("nwfs_doio: type %x unexpected\n",vp->v_type);
984263bc
MD
313 break;
314 };
315 if (error) {
316 bp->b_flags |= B_ERROR;
317 bp->b_error = error;
318 }
319 } else { /* write */
10f3fee5 320 KKASSERT(bp->b_cmd == BUF_CMD_WRITE);
54078292
MD
321 if (bio->bio_offset + bp->b_dirtyend > np->n_size)
322 bp->b_dirtyend = np->n_size - bio->bio_offset;
984263bc
MD
323
324 if (bp->b_dirtyend > bp->b_dirtyoff) {
325 io.iov_len = uiop->uio_resid = bp->b_dirtyend - bp->b_dirtyoff;
54078292 326 uiop->uio_offset = bio->bio_offset + bp->b_dirtyoff;
984263bc
MD
327 io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
328 uiop->uio_rw = UIO_WRITE;
984263bc 329 error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);
984263bc
MD
330
331 /*
332 * For an interrupted write, the buffer is still valid
333 * and the write hasn't been pushed to the server yet,
334 * so we can't set B_ERROR and report the interruption
335 * by setting B_EINTR. For the B_ASYNC case, B_EINTR
336 * is not relevant, so the rpc attempt is essentially
337 * a noop. For the case of a V3 write rpc not being
338 * committed to stable storage, the block is still
339 * dirty and requires either a commit rpc or another
340 * write rpc with iomode == NFSV3WRITE_FILESYNC before
341 * the block is reused. This is indicated by setting
342 * the B_DELWRI and B_NEEDCOMMIT flags.
343 */
344 if (error == EINTR
345 || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
984263bc 346
165dba55 347 crit_enter();
984263bc
MD
348 bp->b_flags &= ~(B_INVAL|B_NOCACHE);
349 if ((bp->b_flags & B_ASYNC) == 0)
350 bp->b_flags |= B_EINTR;
10f3fee5 351 if ((bp->b_flags & B_PAGING) == 0)
984263bc 352 bdirty(bp);
984263bc
MD
353 if ((bp->b_flags & B_ASYNC) == 0)
354 bp->b_flags |= B_EINTR;
165dba55 355 crit_exit();
984263bc
MD
356 } else {
357 if (error) {
358 bp->b_flags |= B_ERROR;
359 bp->b_error /*= np->n_error */= error;
360/* np->n_flag |= NWRITEERR;*/
361 }
362 bp->b_dirtyoff = bp->b_dirtyend = 0;
363 }
364 } else {
365 bp->b_resid = 0;
81b5c339 366 biodone(bio);
984263bc
MD
367 return (0);
368 }
369 }
370 bp->b_resid = uiop->uio_resid;
81b5c339 371 biodone(bio);
984263bc
MD
372 return (error);
373}
374
375/*
376 * Vnode op for VM getpages.
377 * Wish wish .... get rid from multiple IO routines
a9bb80e0
CP
378 *
379 * nwfs_getpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
380 * int a_reqpage, vm_ooffset_t a_offset)
984263bc
MD
381 */
382int
a9bb80e0 383nwfs_getpages(struct vop_getpages_args *ap)
984263bc
MD
384{
385#ifndef NWFS_RWCACHE
386 return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
387 ap->a_reqpage);
388#else
389 int i, error, nextoff, size, toff, npages, count;
390 struct uio uio;
391 struct iovec iov;
392 vm_offset_t kva;
393 struct buf *bp;
394 struct vnode *vp;
dadab5e9 395 struct thread *td = curthread; /* XXX */
984263bc
MD
396 struct ucred *cred;
397 struct nwmount *nmp;
398 struct nwnode *np;
399 vm_page_t *pages;
400
dadab5e9
MD
401 KKASSERT(td->td_proc);
402 cred = td->td_proc->p_ucred;
403
984263bc 404 vp = ap->a_vp;
984263bc
MD
405 np = VTONW(vp);
406 nmp = VFSTONWFS(vp->v_mount);
407 pages = ap->a_m;
408 count = ap->a_count;
409
410 if (vp->v_object == NULL) {
086c1d7e 411 kprintf("nwfs_getpages: called with non-merged cache vnode??\n");
984263bc
MD
412 return VM_PAGER_ERROR;
413 }
414
415 bp = getpbuf(&nwfs_pbuf_freecnt);
416 npages = btoc(count);
417 kva = (vm_offset_t) bp->b_data;
418 pmap_qenter(kva, pages, npages);
419
420 iov.iov_base = (caddr_t) kva;
421 iov.iov_len = count;
422 uio.uio_iov = &iov;
423 uio.uio_iovcnt = 1;
424 uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
425 uio.uio_resid = count;
426 uio.uio_segflg = UIO_SYSSPACE;
427 uio.uio_rw = UIO_READ;
dadab5e9 428 uio.uio_td = td;
984263bc
MD
429
430 error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, &uio,cred);
431 pmap_qremove(kva, npages);
432
433 relpbuf(bp, &nwfs_pbuf_freecnt);
434
435 if (error && (uio.uio_resid == count)) {
086c1d7e 436 kprintf("nwfs_getpages: error %d\n",error);
984263bc
MD
437 for (i = 0; i < npages; i++) {
438 if (ap->a_reqpage != i)
439 vnode_pager_freepage(pages[i]);
440 }
441 return VM_PAGER_ERROR;
442 }
443
444 size = count - uio.uio_resid;
445
446 for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
447 vm_page_t m;
448 nextoff = toff + PAGE_SIZE;
449 m = pages[i];
450
451 m->flags &= ~PG_ZERO;
452
453 if (nextoff <= size) {
454 m->valid = VM_PAGE_BITS_ALL;
455 m->dirty = 0;
456 } else {
457 int nvalid = ((size + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
458 vm_page_set_validclean(m, 0, nvalid);
459 }
460
461 if (i != ap->a_reqpage) {
462 /*
463 * Whether or not to leave the page activated is up in
464 * the air, but we should put the page on a page queue
465 * somewhere (it already is in the object). Result:
466 * It appears that emperical results show that
467 * deactivating pages is best.
468 */
469
470 /*
471 * Just in case someone was asking for this page we
472 * now tell them that it is ok to use.
473 */
474 if (!error) {
475 if (m->flags & PG_WANTED)
476 vm_page_activate(m);
477 else
478 vm_page_deactivate(m);
479 vm_page_wakeup(m);
480 } else {
481 vnode_pager_freepage(m);
482 }
483 }
484 }
485 return 0;
486#endif /* NWFS_RWCACHE */
487}
488
489/*
490 * Vnode op for VM putpages.
491 * possible bug: all IO done in sync mode
492 * Note that vop_close always invalidate pages before close, so it's
493 * not necessary to open vnode.
a9bb80e0
CP
494 *
495 * nwfs_putpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
496 * int a_sync, int *a_rtvals, vm_ooffset_t a_offset)
984263bc
MD
497 */
498int
a9bb80e0 499nwfs_putpages(struct vop_putpages_args *ap)
984263bc
MD
500{
501 int error;
dadab5e9 502 struct thread *td = curthread; /* XXX */
984263bc 503 struct vnode *vp = ap->a_vp;
984263bc
MD
504 struct ucred *cred;
505
506#ifndef NWFS_RWCACHE
dadab5e9
MD
507 KKASSERT(td->td_proc);
508 cred = td->td_proc->p_ucred; /* XXX */
87de5057 509 VOP_OPEN(vp, FWRITE, cred, NULL);
984263bc
MD
510 error = vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
511 ap->a_sync, ap->a_rtvals);
87de5057 512 VOP_CLOSE(vp, FWRITE, cred);
984263bc
MD
513 return error;
514#else
515 struct uio uio;
516 struct iovec iov;
517 vm_offset_t kva;
518 struct buf *bp;
519 int i, npages, count;
520 int *rtvals;
521 struct nwmount *nmp;
522 struct nwnode *np;
523 vm_page_t *pages;
524
dadab5e9
MD
525 KKASSERT(td->td_proc);
526 cred = td->td_proc->p_ucred; /* XXX */
527
87de5057 528/* VOP_OPEN(vp, FWRITE, cred, NULL);*/
984263bc
MD
529 np = VTONW(vp);
530 nmp = VFSTONWFS(vp->v_mount);
531 pages = ap->a_m;
532 count = ap->a_count;
533 rtvals = ap->a_rtvals;
534 npages = btoc(count);
535
536 for (i = 0; i < npages; i++) {
537 rtvals[i] = VM_PAGER_AGAIN;
538 }
539
540 bp = getpbuf(&nwfs_pbuf_freecnt);
541 kva = (vm_offset_t) bp->b_data;
542 pmap_qenter(kva, pages, npages);
543
544 iov.iov_base = (caddr_t) kva;
545 iov.iov_len = count;
546 uio.uio_iov = &iov;
547 uio.uio_iovcnt = 1;
548 uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
549 uio.uio_resid = count;
550 uio.uio_segflg = UIO_SYSSPACE;
551 uio.uio_rw = UIO_WRITE;
dadab5e9 552 uio.uio_td = td;
984263bc
MD
553 NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uio.uio_offset, uio.uio_resid);
554
555 error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, &uio, cred);
87de5057 556/* VOP_CLOSE(vp, FWRITE, cred);*/
984263bc
MD
557 NCPVNDEBUG("paged write done: %d\n", error);
558
559 pmap_qremove(kva, npages);
560 relpbuf(bp, &nwfs_pbuf_freecnt);
561
562 if (!error) {
563 int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;
564 for (i = 0; i < nwritten; i++) {
565 rtvals[i] = VM_PAGER_OK;
566 pages[i]->dirty = 0;
567 }
568 }
569 return rtvals[0];
570#endif /* NWFS_RWCACHE */
571}
572/*
573 * Flush and invalidate all dirty buffers. If another process is already
574 * doing the flush, just wait for completion.
575 */
576int
87de5057 577nwfs_vinvalbuf(struct vnode *vp, int flags, int intrflg)
984263bc
MD
578{
579 struct nwnode *np = VTONW(vp);
580/* struct nwmount *nmp = VTONWFS(vp);*/
581 int error = 0, slpflag, slptimeo;
582
5fd012e0 583 if (vp->v_flag & VRECLAIMED) {
984263bc
MD
584 return (0);
585 }
586 if (intrflg) {
587 slpflag = PCATCH;
588 slptimeo = 2 * hz;
589 } else {
590 slpflag = 0;
591 slptimeo = 0;
592 }
593 while (np->n_flag & NFLUSHINPROG) {
594 np->n_flag |= NFLUSHWANT;
377d4740 595 error = tsleep((caddr_t)&np->n_flag, 0, "nwfsvinv", slptimeo);
87de5057 596 error = ncp_chkintr(NWFSTOCONN(VTONWFS(vp)), curthread);
984263bc
MD
597 if (error == EINTR && intrflg)
598 return EINTR;
599 }
600 np->n_flag |= NFLUSHINPROG;
87de5057 601 error = vinvalbuf(vp, flags, slpflag, 0);
984263bc
MD
602 while (error) {
603 if (intrflg && (error == ERESTART || error == EINTR)) {
604 np->n_flag &= ~NFLUSHINPROG;
605 if (np->n_flag & NFLUSHWANT) {
606 np->n_flag &= ~NFLUSHWANT;
607 wakeup((caddr_t)&np->n_flag);
608 }
609 return EINTR;
610 }
87de5057 611 error = vinvalbuf(vp, flags, slpflag, 0);
984263bc
MD
612 }
613 np->n_flag &= ~(NMODIFIED | NFLUSHINPROG);
614 if (np->n_flag & NFLUSHWANT) {
615 np->n_flag &= ~NFLUSHWANT;
616 wakeup((caddr_t)&np->n_flag);
617 }
618 return (error);
619}