afs: Remove 'slept' from osi_VM_FlushVCache
[openafs.git] / src / afs / IRIX / osi_vm.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"      /* statistics */
17 #include "sys/flock.h"          /* for IGN_PID */
18
19 extern struct vnodeops Afs_vnodeops;
20
21 /* Try to discard pages, in order to recycle a vcache entry.
22  *
23  * We also make some sanity checks:  ref count, open count, held locks.
24  *
25  * We also do some non-VM-related chores, such as releasing the cred pointer
26  * (for AIX and Solaris) and releasing the gnode (for AIX).
27  *
28  * Locking:  afs_xvcache lock is held. It must not be dropped.
29  */
30 int
31 osi_VM_FlushVCache(struct vcache *avc)
32 {
33     int s, code;
34     vnode_t *vp = &avc->v;
35
36     if (avc->vrefCount != 0)
37         return EBUSY;
38
39     if (avc->opens != 0)
40         return EBUSY;
41
42     /*
43      * Just in case someone is still referring to the vnode we give up
44      * trying to get rid of this guy.
45      */
46     if (CheckLock(&avc->lock) || LockWaiters(&avc->lock))
47         return EBUSY;
48
49     s = VN_LOCK(vp);
50
51     /*
52      * we just need to avoid the race
53      * in vn_rele between the ref count going to 0 and VOP_INACTIVE
54      * finishing up.
55      * Note that although we checked vcount above, we didn't have the lock
56      */
57     if (vp->v_count > 0 || (vp->v_flag & VINACT)) {
58         VN_UNLOCK(vp, s);
59         return EBUSY;
60     }
61     VN_UNLOCK(vp, s);
62
63     /*
64      * Since we store on last close and on VOP_INACTIVE
65      * there should be NO dirty pages
66      * Note that we hold the xvcache lock the entire time.
67      */
68     AFS_GUNLOCK();
69     PTOSSVP(vp, (off_t) 0, (off_t) MAXLONG);
70     AFS_GLOCK();
71
72     /* afs_chkpgoob will drop and re-acquire the global lock. */
73     afs_chkpgoob(vp, 0);
74     osi_Assert(!VN_GET_PGCNT(vp));
75     osi_Assert(!AFS_VN_MAPPED(vp));
76     osi_Assert(!AFS_VN_DIRTY(&avc->v));
77
78 #if defined(AFS_SGI65_ENV)
79     if (vp->v_filocks)
80         cleanlocks(vp, IGN_PID, 0);
81     mutex_destroy(&vp->v_filocksem);
82 #else /* AFS_SGI65_ENV */
83     if (vp->v_filocksem) {
84         if (vp->v_filocks)
85 #ifdef AFS_SGI64_ENV
86             cleanlocks(vp, &curprocp->p_flid);
87 #else
88             cleanlocks(vp, IGN_PID, 0);
89 #endif
90         osi_Assert(vp->v_filocks == NULL);
91         mutex_destroy(vp->v_filocksem);
92         kmem_free(vp->v_filocksem, sizeof *vp->v_filocksem);
93         vp->v_filocksem = NULL;
94     }
95 #endif /* AFS_SGI65_ENV */
96
97     if (avc->vrefCount)
98         osi_Panic("flushVcache: vm race");
99 #ifdef AFS_SGI64_ENV
100     AFS_GUNLOCK();
101     vnode_pcache_reclaim(vp);   /* this can sleep */
102     vnode_pcache_free(vp);
103     if (vp->v_op != &Afs_vnodeops) {
104         VOP_RECLAIM(vp, FSYNC_WAIT, code);
105     }
106     AFS_GLOCK();
107 #ifdef AFS_SGI65_ENV
108 #ifdef VNODE_TRACING
109     ktrace_free(vp->v_trace);
110 #endif /* VNODE_TRACING */
111     vn_bhv_remove(VN_BHV_HEAD(vp), &(avc->vc_bhv_desc));
112     vn_bhv_head_destroy(&(vp->v_bh));
113     destroy_bitlock(&vp->v_pcacheflag);
114     mutex_destroy(&vp->v_buf_lock);
115 #else
116     bhv_remove(VN_BHV_HEAD(vp), &(avc->vc_bhv_desc));
117     bhv_head_destroy(&(vp->v_bh));
118 #endif
119     vp->v_flag = 0;             /* debug */
120 #if defined(DEBUG) && defined(VNODE_INIT_BITLOCK)
121     destroy_bitlock(&vp->v_flag);
122 #endif
123 #ifdef INTR_KTHREADS
124     AFS_VN_DESTROY_BUF_LOCK(vp);
125 #endif
126 #endif /* AFS_SGI64_ENV */
127
128     return 0;
129 }
130
131 /* Try to invalidate pages, for "fs flush" or "fs flushv"; or
132  * try to free pages, when deleting a file.
133  *
134  * Locking:  the vcache entry's lock is held.  It may be dropped and 
135  * re-obtained.
136  *
137  * Since we drop and re-obtain the lock, we can't guarantee that there won't
138  * be some pages around when we return, newly created by concurrent activity.
139  */
140 void
141 osi_VM_TryToSmush(struct vcache *avc, afs_ucred_t *acred, int sync)
142 {
143     ReleaseWriteLock(&avc->lock);
144     AFS_GUNLOCK();
145     /* current remapf restriction - cannot have VOP_RWLOCK */
146     osi_Assert(OSI_GET_LOCKID() != avc->vc_rwlockid);
147     if (((vnode_t *) avc)->v_type == VREG && AFS_VN_MAPPED(((vnode_t *) avc)))
148         remapf(((vnode_t *) avc), 0, 0);
149     PTOSSVP(AFSTOV(avc), (off_t) 0, (off_t) MAXLONG);
150     AFS_GLOCK();
151     ObtainWriteLock(&avc->lock, 62);
152 }
153
154 /* Flush and invalidate pages, for fsync() with INVAL flag
155  *
156  * Locking:  only the global lock is held.
157  */
158 void
159 osi_VM_FSyncInval(struct vcache *avc)
160 {
161     AFS_GUNLOCK();
162     PFLUSHINVALVP((vnode_t *) avc, (off_t) 0, (off_t) avc->f.m.Length);
163     AFS_GLOCK();
164 }
165
166 /* Try to store pages to cache, in order to store a file back to the server.
167  *
168  * Locking:  the vcache entry's lock is held.  It will usually be dropped and
169  * re-obtained.
170  */
171 void
172 osi_VM_StoreAllSegments(struct vcache *avc)
173 {
174     int error;
175     osi_Assert(valusema(&avc->vc_rwlock) <= 0);
176     osi_Assert(OSI_GET_LOCKID() == avc->vc_rwlockid);
177     osi_Assert(avc->vrefCount > 0);
178     ReleaseWriteLock(&avc->lock);
179     /* We may call back into AFS via:
180      * pflushvp->chunkpush->do_pdflush->mp_afs_bmap
181      */
182     AFS_GUNLOCK();
183
184     /* Write out dirty pages list to avoid B_DELWRI buffers. */
185     while (VN_GET_DPAGES((vnode_t *) avc)) {
186         pdflush(AFSTOV(avc), 0);
187     }
188
189     PFLUSHVP(AFSTOV(avc), (off_t) avc->f.m.Length, (off_t) 0, error);
190     AFS_GLOCK();
191     if (error) {
192         /*
193          * If this fails (due to quota overage, etc.)
194          * what can we do?? we need to sure that
195          * that the VM cache is cleared of dirty pages
196          * We note that pinvalfree ignores write errors & otherwise
197          * does what we want (we don't use this normally since
198          * it also unhashes pages ..)
199          */
200         PINVALFREE((vnode_t *) avc, avc->f.m.Length);
201     }
202     ObtainWriteLock(&avc->lock, 121);
203     if (error && avc->f.m.LinkCount)
204         cmn_err(CE_WARN,
205                 "AFS:Failed to push back pages for vnode 0x%x error %d (from afs_StoreOnLastReference)",
206                 avc, error);
207 }
208
209 /* Purge VM for a file when its callback is revoked.
210  *
211  * Locking:  No lock is held, not even the global lock.
212  */
213 void
214 osi_VM_FlushPages(struct vcache *avc, afs_ucred_t *credp)
215 {
216     vnode_t *vp = (vnode_t *) avc;
217
218     remapf(vp, /*avc->f.m.Length */ 0, 0);
219
220     /* Used to grab locks and recheck avc->f.m.DataVersion and
221      * avc->execsOrWriters here, but we have to drop locks before calling
222      * ptossvp() anyway, so why bother.
223      */
224
225     /*
226      * ptossvp tosses all pages associated with this vnode
227      * All in-use pages are marked BAD
228      */
229     PTOSSVP(vp, (off_t) 0, (off_t) MAXLONG);
230 }
231
232 /* Purge pages beyond end-of-file, when truncating a file.
233  *
234  * Locking:  no lock is held, not even the global lock.
235  * activeV is raised.  This is supposed to block pageins, but at present
236  * it only works on Solaris.
237  */
238 void
239 osi_VM_Truncate(struct vcache *avc, int alen, afs_ucred_t *acred)
240 {
241     PTOSSVP(&avc->v, (off_t) alen, (off_t) MAXLONG);
242 }