darwin-vm-bugfix-for-running-apps-out-of-afs-20020710
[openafs.git] / src / afs / DARWIN / 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 RCSID("$Header$");
14
15 #include "../afs/sysincludes.h" /* Standard vendor system headers */
16 #include "../afs/afsincludes.h" /* Afs-based standard headers */
17 #include "../afs/afs_stats.h"  /* statistics */
18 #include <sys/ubc.h>
19
20 /* Try to discard pages, in order to recycle a vcache entry.
21  *
22  * We also make some sanity checks:  ref count, open count, held locks.
23  *
24  * We also do some non-VM-related chores, such as releasing the cred pointer
25  * (for AIX and Solaris) and releasing the gnode (for AIX).
26  *
27  * Locking:  afs_xvcache lock is held.  If it is dropped and re-acquired,
28  *   *slept should be set to warn the caller.
29  *
30  * Formerly, afs_xvcache was dropped and re-acquired for Solaris, but now it
31  * is not dropped and re-acquired for any platform.  It may be that *slept is
32  * therefore obsolescent.
33  *
34  * OSF/1 Locking:  VN_LOCK has been called.
35  */
36 int
37 osi_VM_FlushVCache(avc, slept)
38     struct vcache *avc;
39     int *slept;
40 {
41     struct vnode *vp=AFSTOV(avc);
42 #ifdef AFS_DARWIN14_ENV
43     if (UBCINFOEXISTS(vp))
44         return EBUSY;
45 #endif
46     if (avc->vrefCount)
47         return EBUSY;
48
49     if (avc->opens)
50         return EBUSY;
51
52     /* if a lock is held, give up */
53     if (CheckLock(&avc->lock) || afs_CheckBozonLock(&avc->pvnLock))
54         return EBUSY;
55
56     AFS_GUNLOCK();
57     cache_purge(vp);
58 #ifndef AFS_DARWIN14_ENV
59     if (UBCINFOEXISTS(vp))
60         {
61                 ubc_clean(vp, 1);
62                 ubc_uncache(vp);
63                 ubc_release(vp);
64                 ubc_info_free(vp);
65         }
66 #endif
67
68     AFS_GLOCK();
69
70     return 0;
71 }
72
73
74 /* Try to store pages to cache, in order to store a file back to the server.
75  *
76  * Locking:  the vcache entry's lock is held.  It will usually be dropped and
77  * re-obtained.
78  */
79 void
80 osi_VM_StoreAllSegments(avc)
81     struct vcache *avc;
82 {
83     struct vnode *vp=AFSTOV(avc);
84     ReleaseWriteLock(&avc->lock);
85     AFS_GUNLOCK();
86     if (UBCINFOEXISTS(vp)) {
87         ubc_pushdirty(vp);
88     }
89     AFS_GLOCK();
90     ObtainWriteLock(&avc->lock,94);
91 }
92
93 /* Try to invalidate pages, for "fs flush" or "fs flushv"; or
94  * try to free pages, when deleting a file.
95  *
96  * Locking:  the vcache entry's lock is held.  It may be dropped and 
97  * re-obtained.
98  *
99  * Since we drop and re-obtain the lock, we can't guarantee that there won't
100  * be some pages around when we return, newly created by concurrent activity.
101  */
102 void
103 osi_VM_TryToSmush(avc, acred, sync)
104     struct vcache *avc;
105     struct AFS_UCRED *acred;
106     int sync;
107 {
108     struct vnode *vp=AFSTOV(avc);
109     void *object;
110     kern_return_t kret;
111     off_t size, lastpg;
112     
113     ReleaseWriteLock(&avc->lock);
114     AFS_GUNLOCK();
115     if (UBCINFOEXISTS(vp))  {
116         size=ubc_getsize(vp);
117         kret=ubc_invalidate(vp,0,size); 
118         if (kret != 1) /* should be KERN_SUCCESS */
119             printf("TryToSmush: invalidate failed (error = %d)\n", kret);
120     }
121     AFS_GLOCK();
122     ObtainWriteLock(&avc->lock,59);
123 }
124
125 /* Purge VM for a file when its callback is revoked.
126  *
127  * Locking:  No lock is held, not even the global lock.
128  */
129 /* XXX this seems to not be referenced anywhere. *somebody* ought to be calling
130    this, and also making sure that ubc's idea of the filesize is right more
131    often */
132 void
133 osi_VM_FlushPages(avc, credp)
134     struct vcache *avc;
135     struct AFS_UCRED *credp;
136 {
137     struct vnode *vp=AFSTOV(avc);
138     void *object;
139     kern_return_t kret;
140     off_t size;
141     if (UBCINFOEXISTS(vp))  {
142         size=ubc_getsize(vp);
143         kret=ubc_invalidate(vp,0,size);
144         if (kret != 1) /* Should be KERN_SUCCESS */
145           printf("VMFlushPages: invalidate failed (error = %d)\n", kret);
146         /* XXX what about when not CStatd */
147         if (avc->states & CStatd && size != avc->m.Length) 
148             ubc_setsize(vp, avc->m.Length);
149     }
150 }
151
152 /* Purge pages beyond end-of-file, when truncating a file.
153  *
154  * Locking:  no lock is held, not even the global lock.
155  * activeV is raised.  This is supposed to block pageins, but at present
156  * it only works on Solaris.
157  */
158 void
159 osi_VM_Truncate(avc, alen, acred)
160     struct vcache *avc;
161     int alen;
162     struct AFS_UCRED *acred;
163 {
164     struct vnode *vp=AFSTOV(avc);
165     if (UBCINFOEXISTS(vp))  {
166         ubc_setsize(vp, alen);
167     }
168 }
169
170 extern struct  AFS_UCRED afs_osi_cred;
171 extern afs_rwlock_t afs_xvcache;
172 /* vnreclaim and vinactive are probably not aggressive enough to keep
173    enough afs vcaches free, so we try to do some of it ourselves */
174 /* XXX there's probably not nearly enough locking here */
175 void osi_VM_TryReclaim(avc, slept)
176      struct vcache *avc;
177      int *slept;
178 {
179     struct proc *p=current_proc();
180     struct vnode *vp=AFSTOV(avc);
181     void *obj;
182
183     if (slept)
184        *slept=0;
185     VN_HOLD(vp); /* remove from inactive list */
186     if (!simple_lock_try(&vp->v_interlock)) {
187         AFS_RELE(vp);
188         return;
189     }
190     if (!UBCINFOEXISTS(vp) || vp->v_count != 2) {
191         simple_unlock(&vp->v_interlock);
192         AFS_RELE(vp);
193         return;
194     }
195 #ifdef AFS_DARWIN14_ENV
196     if (vp->v_ubcinfo->ui_refcount > 1 || vp->v_ubcinfo->ui_mapped) {
197         simple_unlock(&vp->v_interlock);
198         AFS_RELE(vp);
199         return;
200     }
201 #else
202     if (vp->v_ubcinfo->ui_holdcnt) {
203         simple_unlock(&vp->v_interlock);
204         AFS_RELE(vp);
205         return;
206     }
207 #endif
208     if (slept && ubc_issetflags(vp, UI_WASMAPPED)) {
209        /* We can't possibly release this in time for this NewVCache to get it */
210         simple_unlock(&vp->v_interlock);
211         AFS_RELE(vp);
212         return;
213     }
214
215     vp->v_usecount--; /* we want the usecount to be 1 */
216
217     if (slept) {
218         ReleaseWriteLock(&afs_xvcache);
219         *slept=1;
220     } else
221         ReleaseReadLock(&afs_xvcache);
222     AFS_GUNLOCK();
223     obj=0;
224     if (ubc_issetflags(vp, UI_WASMAPPED)) {
225         simple_unlock(&vp->v_interlock);
226 #ifdef  AFS_DARWIN14_ENV
227         ubc_release_named(vp);
228 #else
229         ubc_release(vp);
230 #endif
231         if (ubc_issetflags(vp, UI_HASOBJREF))
232             printf("ubc_release didn't release the reference?!\n");
233     } else if (!vn_lock(vp, LK_EXCLUSIVE|LK_INTERLOCK,current_proc())) {
234 #ifdef AFS_DARWIN14_ENV
235         obj = ubc_getobject(vp,UBC_HOLDOBJECT);
236 #else
237 #ifdef AFS_DARWIN13_ENV
238         obj = ubc_getobject(vp,(UBC_NOREACTIVATE|UBC_HOLDOBJECT));
239 #else
240         obj = ubc_getobject(vp);
241 #endif
242 #endif
243         (void)ubc_clean(vp, 1);
244         vinvalbuf(vp, V_SAVE, &afs_osi_cred, p, 0, 0);
245         if (vp->v_usecount == 1)
246            VOP_INACTIVE(vp, p);
247         else
248            VOP_UNLOCK(vp, 0, p);
249         if (obj) {
250             if (ISSET(vp->v_flag, VTERMINATE))
251                 panic("afs_vnreclaim: already teminating");
252             SET(vp->v_flag, VTERMINATE);
253             memory_object_destroy(obj, 0);
254             while (ISSET(vp->v_flag, VTERMINATE)) {
255                   SET(vp->v_flag, VTERMWANT);
256                   tsleep((caddr_t)&vp->v_ubcinfo, PINOD, "afs_vnreclaim", 0);
257             }
258         }
259    } else {
260         if (simple_lock_try(&vp->v_interlock))
261             panic("afs_vnreclaim: slept, but did no work :(");
262         if (UBCINFOEXISTS(vp) && vp->v_count == 1) {
263            vp->v_usecount++;
264            simple_unlock(&vp->v_interlock);
265            VN_RELE(vp);
266         } else 
267            simple_unlock(&vp->v_interlock);
268    }
269    AFS_GLOCK();
270    if (slept)
271       ObtainWriteLock(&afs_xvcache,175);
272    else
273       ObtainReadLock(&afs_xvcache);
274 }
275
276 void osi_VM_NukePages(struct vnode *vp, off_t offset, off_t size) {
277
278     void *object;
279     struct vcache *avc = VTOAFS(vp);
280
281 #ifdef AFS_DARWIN14_ENV
282     offset=trunc_page(offset);
283     size=round_page(size+1);
284     while (size) {
285         ubc_page_op(vp, (vm_offset_t)offset, 
286                               UPL_POP_SET | UPL_POP_BUSY | UPL_POP_DUMP,
287                               0, 0);
288         size-=PAGE_SIZE;
289         offset+=PAGE_SIZE;
290     }
291 #else
292     object=NULL;
293 #ifdef AFS_DARWIN13_ENV
294     if (UBCINFOEXISTS(vp))
295         object = ubc_getobject(vp, UBC_NOREACTIVATE);
296 #else
297     if (UBCINFOEXISTS(vp))
298         object = ubc_getobject(vp);
299 #endif
300     if (!object)
301         return;
302
303     offset=trunc_page(offset);
304     size=round_page(size+1);
305
306 #ifdef AFS_DARWIN13_ENV
307     while (size) {
308         memory_object_page_op(object, (vm_offset_t)offset, 
309                               UPL_POP_SET | UPL_POP_BUSY | UPL_POP_DUMP,
310                               0, 0);
311         size-=PAGE_SIZE;
312         offset+=PAGE_SIZE;
313     }
314 #else 
315     /* This is all we can do, and it's not enough. sucks to be us */
316     ubc_setsize(vp, offset);
317     size=(offset + size > avc->m.Length) ? offset + size : avc->m.Length;
318     ubc_setsize(vp, size);
319 #endif
320 #endif
321
322 }
323 int osi_VM_Setup(struct vcache *avc) {
324    int error;
325    struct vnode *vp=AFSTOV(avc);
326
327    if (UBCISVALID(vp) && (avc->states & CStatd)) {
328       if (!UBCINFOEXISTS(vp) && !ISSET(vp->v_flag, VTERMINATE)) {
329          osi_vnhold(avc,0);  
330          AFS_GUNLOCK();
331          if ((error=ubc_info_init(&avc->v)))  {
332              AFS_GLOCK();
333              AFS_RELE(avc);
334              return error;
335          }
336 #ifndef AFS_DARWIN14_ENV
337          simple_lock(&avc->v.v_interlock);
338          if (!ubc_issetflags(&avc->v, UI_HASOBJREF))
339 #ifdef AFS_DARWIN13_ENV
340             if (ubc_getobject(&avc->v, (UBC_NOREACTIVATE|UBC_HOLDOBJECT)))
341                    panic("VM_Setup: null object");
342 #else
343             (void)_ubc_getobject(&avc->v, 1); /* return value not used */
344 #endif
345          simple_unlock(&avc->v.v_interlock);
346 #endif
347          AFS_GLOCK();
348          AFS_RELE(avc);
349       }
350       if (UBCINFOEXISTS(&avc->v))
351           ubc_setsize(&avc->v, avc->m.Length);
352    }
353    return 0;
354 }