Per-CPU VFS Namecache Effectiveness Statistics:
[dragonfly.git] / sys / vfs / smbfs / smbfs_io.c
1 /*
2  * Copyright (c) 2000-2001, 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/fs/smbfs/smbfs_io.c,v 1.3.2.3 2003/01/17 08:20:26 tjr Exp $
33  * $DragonFly: src/sys/vfs/smbfs/smbfs_io.c,v 1.10 2004/03/01 06:33:22 dillon Exp $
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/proc.h>
41 #include <sys/fcntl.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 /*
56 #include <sys/ioccom.h>
57 */
58 #include <netproto/smb/smb.h>
59 #include <netproto/smb/smb_conn.h>
60 #include <netproto/smb/smb_subr.h>
61
62 #include "smbfs.h"
63 #include "smbfs_node.h"
64 #include "smbfs_subr.h"
65
66 #include <sys/buf.h>
67
68 /*#define SMBFS_RWGENERIC*/
69
70 extern int smbfs_pbuf_freecnt;
71
72 static int smbfs_fastlookup = 1;
73
74 SYSCTL_DECL(_vfs_smbfs);
75 SYSCTL_INT(_vfs_smbfs, OID_AUTO, fastlookup, CTLFLAG_RW, &smbfs_fastlookup, 0, "");
76
77
78 #define DE_SIZE (sizeof(struct dirent))
79
80 static int
81 smbfs_readvdir(struct vnode *vp, struct uio *uio, struct ucred *cred)
82 {
83         struct dirent de;
84         struct componentname cn;
85         struct smb_cred scred;
86         struct smbfs_fctx *ctx;
87         struct vnode *newvp;
88         struct smbnode *np = VTOSMB(vp);
89         int error/*, *eofflag = ap->a_eofflag*/;
90         long offset, limit;
91
92         np = VTOSMB(vp);
93         SMBVDEBUG("dirname='%s'\n", np->n_name);
94         smb_makescred(&scred, uio->uio_td, cred);
95         offset = uio->uio_offset / DE_SIZE;     /* offset in the directory */
96         limit = uio->uio_resid / DE_SIZE;
97         if (uio->uio_resid < DE_SIZE || uio->uio_offset < 0)
98                 return EINVAL;
99         while (limit && offset < 2) {
100                 limit--;
101                 bzero((caddr_t)&de, DE_SIZE);
102                 de.d_reclen = DE_SIZE;
103                 de.d_fileno = (offset == 0) ? np->n_ino :
104                     (np->n_parent ? VTOSMB(np->n_parent)->n_ino : 2);
105                 if (de.d_fileno == 0)
106                         de.d_fileno = 0x7ffffffd + offset;
107                 de.d_namlen = offset + 1;
108                 de.d_name[0] = '.';
109                 de.d_name[1] = '.';
110                 de.d_name[offset + 1] = '\0';
111                 de.d_type = DT_DIR;
112                 error = uiomove((caddr_t)&de, DE_SIZE, uio);
113                 if (error)
114                         return error;
115                 offset++;
116                 uio->uio_offset += DE_SIZE;
117         }
118         if (limit == 0)
119                 return 0;
120         if (offset != np->n_dirofs || np->n_dirseq == NULL) {
121                 SMBVDEBUG("Reopening search %ld:%ld\n", offset, np->n_dirofs);
122                 if (np->n_dirseq) {
123                         smbfs_findclose(np->n_dirseq, &scred);
124                         np->n_dirseq = NULL;
125                 }
126                 np->n_dirofs = 2;
127                 error = smbfs_findopen(np, "*", 1,
128                     SMB_FA_SYSTEM | SMB_FA_HIDDEN | SMB_FA_DIR,
129                     &scred, &ctx);
130                 if (error) {
131                         SMBVDEBUG("can not open search, error = %d", error);
132                         return error;
133                 }
134                 np->n_dirseq = ctx;
135         } else
136                 ctx = np->n_dirseq;
137         while (np->n_dirofs < offset) {
138                 error = smbfs_findnext(ctx, offset - np->n_dirofs++, &scred);
139                 if (error) {
140                         smbfs_findclose(np->n_dirseq, &scred);
141                         np->n_dirseq = NULL;
142                         return error == ENOENT ? 0 : error;
143                 }
144         }
145         error = 0;
146         for (; limit; limit--, offset++) {
147                 error = smbfs_findnext(ctx, limit, &scred);
148                 if (error)
149                         break;
150                 np->n_dirofs++;
151                 bzero((caddr_t)&de, DE_SIZE);
152                 de.d_reclen = DE_SIZE;
153                 de.d_fileno = ctx->f_attr.fa_ino;
154                 de.d_type = (ctx->f_attr.fa_attr & SMB_FA_DIR) ? DT_DIR : DT_REG;
155                 de.d_namlen = ctx->f_nmlen;
156                 bcopy(ctx->f_name, de.d_name, de.d_namlen);
157                 de.d_name[de.d_namlen] = '\0';
158                 if (smbfs_fastlookup) {
159                         error = smbfs_nget(vp->v_mount, vp, ctx->f_name,
160                             ctx->f_nmlen, &ctx->f_attr, &newvp);
161                         if (!error) {
162                                 cn.cn_nameptr = de.d_name;
163                                 cn.cn_namelen = de.d_namlen;
164                                 cache_enter(vp, NCPNULL, newvp, &cn);
165                                 vput(newvp);
166                         }
167                 }
168                 error = uiomove((caddr_t)&de, DE_SIZE, uio);
169                 if (error)
170                         break;
171         }
172         if (error == ENOENT)
173                 error = 0;
174         uio->uio_offset = offset * DE_SIZE;
175         return error;
176 }
177
178 int
179 smbfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred)
180 {
181         struct thread *td;
182         struct smbmount *smp = VFSTOSMBFS(vp->v_mount);
183         struct smbnode *np = VTOSMB(vp);
184         struct vattr vattr;
185         struct smb_cred scred;
186         int error, lks;
187
188         /*
189          * Protect against method which is not supported for now
190          */
191         if (uiop->uio_segflg == UIO_NOCOPY)
192                 return EOPNOTSUPP;
193
194         if (vp->v_type != VREG && vp->v_type != VDIR) {
195                 SMBFSERR("vn types other than VREG or VDIR are unsupported !\n");
196                 return EIO;
197         }
198         if (uiop->uio_resid == 0)
199                 return 0;
200         if (uiop->uio_offset < 0)
201                 return EINVAL;
202 /*      if (uiop->uio_offset + uiop->uio_resid > smp->nm_maxfilesize)
203                 return EFBIG;*/
204         td = uiop->uio_td;
205         if (vp->v_type == VDIR) {
206                 lks = LK_EXCLUSIVE;/*lockstatus(&vp->v_lock, td);*/
207                 if (lks == LK_SHARED)
208                         vn_lock(vp, NULL, LK_UPGRADE | LK_RETRY, td);
209                 error = smbfs_readvdir(vp, uiop, cred);
210                 if (lks == LK_SHARED)
211                         vn_lock(vp, NULL, LK_DOWNGRADE | LK_RETRY, td);
212                 return error;
213         }
214
215 /*      biosize = SSTOCN(smp->sm_share)->sc_txmax;*/
216         if (np->n_flag & NMODIFIED) {
217                 smbfs_attr_cacheremove(vp);
218                 error = VOP_GETATTR(vp, &vattr, td);
219                 if (error)
220                         return error;
221                 np->n_mtime.tv_sec = vattr.va_mtime.tv_sec;
222         } else {
223                 error = VOP_GETATTR(vp, &vattr, td);
224                 if (error)
225                         return error;
226                 if (np->n_mtime.tv_sec != vattr.va_mtime.tv_sec) {
227                         error = smbfs_vinvalbuf(vp, V_SAVE, td, 1);
228                         if (error)
229                                 return error;
230                         np->n_mtime.tv_sec = vattr.va_mtime.tv_sec;
231                 }
232         }
233         smb_makescred(&scred, td, cred);
234         return smb_read(smp->sm_share, np->n_fid, uiop, &scred);
235 }
236
237 int
238 smbfs_writevnode(struct vnode *vp, struct uio *uiop,
239         struct ucred *cred, int ioflag)
240 {
241         struct thread *td;
242         struct smbmount *smp = VTOSMBFS(vp);
243         struct smbnode *np = VTOSMB(vp);
244         struct smb_cred scred;
245         int error = 0;
246
247         if (vp->v_type != VREG) {
248                 SMBERROR("vn types other than VREG unsupported !\n");
249                 return EIO;
250         }
251         SMBVDEBUG("ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
252         if (uiop->uio_offset < 0)
253                 return EINVAL;
254 /*      if (uiop->uio_offset + uiop->uio_resid > smp->nm_maxfilesize)
255                 return (EFBIG);*/
256         td = uiop->uio_td;
257         if (ioflag & (IO_APPEND | IO_SYNC)) {
258                 if (np->n_flag & NMODIFIED) {
259                         smbfs_attr_cacheremove(vp);
260                         error = smbfs_vinvalbuf(vp, V_SAVE, td, 1);
261                         if (error)
262                                 return error;
263                 }
264                 if (ioflag & IO_APPEND) {
265 #if notyet
266                         /*
267                          * File size can be changed by another client
268                          */
269                         smbfs_attr_cacheremove(vp);
270                         error = VOP_GETATTR(vp, &vattr, td);
271                         if (error) return (error);
272 #endif
273                         uiop->uio_offset = np->n_size;
274                 }
275         }
276         if (uiop->uio_resid == 0)
277                 return 0;
278         if (td->td_proc &&
279             uiop->uio_offset + uiop->uio_resid >
280             td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
281                 psignal(td->td_proc, SIGXFSZ);
282                 return EFBIG;
283         }
284         smb_makescred(&scred, td, cred);
285         error = smb_write(smp->sm_share, np->n_fid, uiop, &scred);
286         SMBVDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
287         if (!error) {
288                 if (uiop->uio_offset > np->n_size) {
289                         np->n_size = uiop->uio_offset;
290                         vnode_pager_setsize(vp, np->n_size);
291                 }
292         }
293         return error;
294 }
295
296 /*
297  * Do an I/O operation to/from a cache block.
298  */
299 int
300 smbfs_doio(struct buf *bp, struct ucred *cr, struct thread *td)
301 {
302         struct vnode *vp = bp->b_vp;
303         struct smbmount *smp = VFSTOSMBFS(vp->v_mount);
304         struct smbnode *np = VTOSMB(vp);
305         struct uio uio, *uiop = &uio;
306         struct iovec io;
307         struct smb_cred scred;
308         int error = 0;
309
310         uiop->uio_iov = &io;
311         uiop->uio_iovcnt = 1;
312         uiop->uio_segflg = UIO_SYSSPACE;
313         uiop->uio_td = td;
314
315         smb_makescred(&scred, td, cr);
316
317         if (bp->b_flags & B_READ) {
318             io.iov_len = uiop->uio_resid = bp->b_bcount;
319             io.iov_base = bp->b_data;
320             uiop->uio_rw = UIO_READ;
321             switch (vp->v_type) {
322               case VREG:
323                 uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
324                 error = smb_read(smp->sm_share, np->n_fid, uiop, &scred);
325                 if (error)
326                         break;
327                 if (uiop->uio_resid) {
328                         int left = uiop->uio_resid;
329                         int nread = bp->b_bcount - left;
330                         if (left > 0)
331                             bzero((char *)bp->b_data + nread, left);
332                 }
333                 break;
334             default:
335                 printf("smbfs_doio:  type %x unexpected\n",vp->v_type);
336                 break;
337             };
338             if (error) {
339                 bp->b_error = error;
340                 bp->b_flags |= B_ERROR;
341             }
342         } else { /* write */
343             if (((bp->b_blkno * DEV_BSIZE) + bp->b_dirtyend) > np->n_size)
344                 bp->b_dirtyend = np->n_size - (bp->b_blkno * DEV_BSIZE);
345
346             if (bp->b_dirtyend > bp->b_dirtyoff) {
347                 io.iov_len = uiop->uio_resid = bp->b_dirtyend - bp->b_dirtyoff;
348                 uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
349                 io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
350                 uiop->uio_rw = UIO_WRITE;
351                 bp->b_flags |= B_WRITEINPROG;
352                 error = smb_write(smp->sm_share, np->n_fid, uiop, &scred);
353                 bp->b_flags &= ~B_WRITEINPROG;
354
355                 /*
356                  * For an interrupted write, the buffer is still valid
357                  * and the write hasn't been pushed to the server yet,
358                  * so we can't set BIO_ERROR and report the interruption
359                  * by setting B_EINTR. For the B_ASYNC case, B_EINTR
360                  * is not relevant, so the rpc attempt is essentially
361                  * a noop.  For the case of a V3 write rpc not being
362                  * committed to stable storage, the block is still
363                  * dirty and requires either a commit rpc or another
364                  * write rpc with iomode == NFSV3WRITE_FILESYNC before
365                  * the block is reused. This is indicated by setting
366                  * the B_DELWRI and B_NEEDCOMMIT flags.
367                  */
368                 if (error == EINTR
369                     || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
370                         int s;
371
372                         s = splbio();
373                         bp->b_flags &= ~(B_INVAL|B_NOCACHE);
374                         if ((bp->b_flags & B_ASYNC) == 0)
375                             bp->b_flags |= B_EINTR;
376                         if ((bp->b_flags & B_PAGING) == 0) {
377                             bdirty(bp);
378                             bp->b_flags &= ~B_DONE;
379                         }
380                         if ((bp->b_flags & B_ASYNC) == 0)
381                             bp->b_flags |= B_EINTR;
382                         splx(s);
383                 } else {
384                         if (error) {
385                                 bp->b_flags |= B_ERROR;
386                                 bp->b_error = error;
387                         }
388                         bp->b_dirtyoff = bp->b_dirtyend = 0;
389                 }
390             } else {
391                 bp->b_resid = 0;
392                 biodone(bp);
393                 return 0;
394             }
395         }
396         bp->b_resid = uiop->uio_resid;
397         biodone(bp);
398         return error;
399 }
400
401 /*
402  * Vnode op for VM getpages.
403  * Wish wish .... get rid from multiple IO routines
404  */
405 int
406 smbfs_getpages(ap)
407         struct vop_getpages_args /* {
408                 struct vnode *a_vp;
409                 vm_page_t *a_m;
410                 int a_count;
411                 int a_reqpage;
412                 vm_ooffset_t a_offset;
413         } */ *ap;
414 {
415 #ifdef SMBFS_RWGENERIC
416         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
417                 ap->a_reqpage);
418 #else
419         int i, error, nextoff, size, toff, npages, count;
420         struct uio uio;
421         struct iovec iov;
422         vm_offset_t kva;
423         struct buf *bp;
424         struct vnode *vp;
425         struct thread *td = curthread;  /* XXX */
426         struct ucred *cred;
427         struct smbmount *smp;
428         struct smbnode *np;
429         struct smb_cred scred;
430         vm_page_t *pages;
431
432         KKASSERT(td->td_proc);
433
434         vp = ap->a_vp;
435         cred = td->td_proc->p_ucred;
436         np = VTOSMB(vp);
437         smp = VFSTOSMBFS(vp->v_mount);
438         pages = ap->a_m;
439         count = ap->a_count;
440
441         if (vp->v_object == NULL) {
442                 printf("smbfs_getpages: called with non-merged cache vnode??\n");
443                 return VM_PAGER_ERROR;
444         }
445         smb_makescred(&scred, td, cred);
446
447         bp = getpbuf(&smbfs_pbuf_freecnt);
448         npages = btoc(count);
449         kva = (vm_offset_t) bp->b_data;
450         pmap_qenter(kva, pages, npages);
451
452         iov.iov_base = (caddr_t) kva;
453         iov.iov_len = count;
454         uio.uio_iov = &iov;
455         uio.uio_iovcnt = 1;
456         uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
457         uio.uio_resid = count;
458         uio.uio_segflg = UIO_SYSSPACE;
459         uio.uio_rw = UIO_READ;
460         uio.uio_td = td;
461
462         error = smb_read(smp->sm_share, np->n_fid, &uio, &scred);
463         pmap_qremove(kva, npages);
464
465         relpbuf(bp, &smbfs_pbuf_freecnt);
466
467         if (error && (uio.uio_resid == count)) {
468                 printf("smbfs_getpages: error %d\n",error);
469                 for (i = 0; i < npages; i++) {
470                         if (ap->a_reqpage != i)
471                                 vnode_pager_freepage(pages[i]);
472                 }
473                 return VM_PAGER_ERROR;
474         }
475
476         size = count - uio.uio_resid;
477
478         for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
479                 vm_page_t m;
480                 nextoff = toff + PAGE_SIZE;
481                 m = pages[i];
482
483                 m->flags &= ~PG_ZERO;
484
485                 if (nextoff <= size) {
486                         m->valid = VM_PAGE_BITS_ALL;
487                         m->dirty = 0;
488                 } else {
489                         int nvalid = ((size + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
490                         vm_page_set_validclean(m, 0, nvalid);
491                 }
492                 
493                 if (i != ap->a_reqpage) {
494                         /*
495                          * Whether or not to leave the page activated is up in
496                          * the air, but we should put the page on a page queue
497                          * somewhere (it already is in the object).  Result:
498                          * It appears that emperical results show that
499                          * deactivating pages is best.
500                          */
501
502                         /*
503                          * Just in case someone was asking for this page we
504                          * now tell them that it is ok to use.
505                          */
506                         if (!error) {
507                                 if (m->flags & PG_WANTED)
508                                         vm_page_activate(m);
509                                 else
510                                         vm_page_deactivate(m);
511                                 vm_page_wakeup(m);
512                         } else {
513                                 vnode_pager_freepage(m);
514                         }
515                 }
516         }
517         return 0;
518 #endif /* SMBFS_RWGENERIC */
519 }
520
521 /*
522  * Vnode op for VM putpages.
523  * possible bug: all IO done in sync mode
524  * Note that vop_close always invalidate pages before close, so it's
525  * not necessary to open vnode.
526  */
527 int
528 smbfs_putpages(ap)
529         struct vop_putpages_args /* {
530                 struct vnode *a_vp;
531                 vm_page_t *a_m;
532                 int a_count;
533                 int a_sync;
534                 int *a_rtvals;
535                 vm_ooffset_t a_offset;
536         } */ *ap;
537 {
538         int error;
539         struct vnode *vp = ap->a_vp;
540         struct thread *td = curthread;  /* XXX */
541         struct ucred *cred;
542
543 #ifdef SMBFS_RWGENERIC
544         KKASSERT(td->td_proc);
545         cred = td->td_proc->p_ucred;
546         VOP_OPEN(vp, FWRITE, cred, td);
547         error = vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
548                 ap->a_sync, ap->a_rtvals);
549         VOP_CLOSE(vp, FWRITE, cred, td);
550         return error;
551 #else
552         struct uio uio;
553         struct iovec iov;
554         vm_offset_t kva;
555         struct buf *bp;
556         int i, npages, count;
557         int *rtvals;
558         struct smbmount *smp;
559         struct smbnode *np;
560         struct smb_cred scred;
561         vm_page_t *pages;
562
563         KKASSERT(td->td_proc);
564         cred = td->td_proc->p_ucred;
565 /*      VOP_OPEN(vp, FWRITE, cred, td);*/
566         np = VTOSMB(vp);
567         smp = VFSTOSMBFS(vp->v_mount);
568         pages = ap->a_m;
569         count = ap->a_count;
570         rtvals = ap->a_rtvals;
571         npages = btoc(count);
572
573         for (i = 0; i < npages; i++) {
574                 rtvals[i] = VM_PAGER_AGAIN;
575         }
576
577         bp = getpbuf(&smbfs_pbuf_freecnt);
578         kva = (vm_offset_t) bp->b_data;
579         pmap_qenter(kva, pages, npages);
580
581         iov.iov_base = (caddr_t) kva;
582         iov.iov_len = count;
583         uio.uio_iov = &iov;
584         uio.uio_iovcnt = 1;
585         uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
586         uio.uio_resid = count;
587         uio.uio_segflg = UIO_SYSSPACE;
588         uio.uio_rw = UIO_WRITE;
589         uio.uio_td = td;
590         SMBVDEBUG("ofs=%d,resid=%d\n",(int)uio.uio_offset, uio.uio_resid);
591
592         smb_makescred(&scred, td, cred);
593         error = smb_write(smp->sm_share, np->n_fid, &uio, &scred);
594 /*      VOP_CLOSE(vp, FWRITE, cred, td);*/
595         SMBVDEBUG("paged write done: %d\n", error);
596
597         pmap_qremove(kva, npages);
598         relpbuf(bp, &smbfs_pbuf_freecnt);
599
600         if (!error) {
601                 int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;
602                 for (i = 0; i < nwritten; i++) {
603                         rtvals[i] = VM_PAGER_OK;
604                         pages[i]->dirty = 0;
605                 }
606         }
607         return rtvals[0];
608 #endif /* SMBFS_RWGENERIC */
609 }
610
611 /*
612  * Flush and invalidate all dirty buffers. If another process is already
613  * doing the flush, just wait for completion.
614  */
615 int
616 smbfs_vinvalbuf(vp, flags, td, intrflg)
617         struct vnode *vp;
618         int flags;
619         struct thread *td;
620         int intrflg;
621 {
622         struct smbnode *np = VTOSMB(vp);
623         int error = 0, slpflag, slptimeo;
624
625         if (vp->v_flag & VXLOCK)
626                 return 0;
627         if (intrflg) {
628                 slpflag = PCATCH;
629                 slptimeo = 2 * hz;
630         } else {
631                 slpflag = 0;
632                 slptimeo = 0;
633         }
634         while (np->n_flag & NFLUSHINPROG) {
635                 np->n_flag |= NFLUSHWANT;
636                 error = tsleep((caddr_t)&np->n_flag, 0, "smfsvinv", slptimeo);
637                 error = smb_proc_intr(td);
638                 if (error == EINTR && intrflg)
639                         return EINTR;
640         }
641         np->n_flag |= NFLUSHINPROG;
642         error = vinvalbuf(vp, flags, td, slpflag, 0);
643         while (error) {
644                 if (intrflg && (error == ERESTART || error == EINTR)) {
645                         np->n_flag &= ~NFLUSHINPROG;
646                         if (np->n_flag & NFLUSHWANT) {
647                                 np->n_flag &= ~NFLUSHWANT;
648                                 wakeup((caddr_t)&np->n_flag);
649                         }
650                         return EINTR;
651                 }
652                 error = vinvalbuf(vp, flags, td, slpflag, 0);
653         }
654         np->n_flag &= ~(NMODIFIED | NFLUSHINPROG);
655         if (np->n_flag & NFLUSHWANT) {
656                 np->n_flag &= ~NFLUSHWANT;
657                 wakeup((caddr_t)&np->n_flag);
658         }
659         return (error);
660 }