![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vnode_pager.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / vm|
Return to vnode_pager.c CVS log | Up to [Apple Darwin 0.x] / kernel / vm |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Mach Operating System
27: * Copyright (c) 1987 Carnegie-Mellon University
28: * All rights reserved. The CMU software License Agreement specifies
29: * the terms and conditions for use and redistribution.
30: */
31:
32: /*
33: * File: vnode_pager.c
34: *
35: * "Swap" pager that pages to/from vnodes. Also
36: * handles demand paging from files.
37: *
38: * 12-Mar-86 David Golub (dbg) at Carnegie-Mellon University
39: * Created.
40: */
41:
42: #import <mach_nbc.h>
43:
44: #import <mach/boolean.h>
45: #import <sys/param.h>
46: #import <sys/systm.h>
47: #import <kern/lock.h>
48: #import <sys/proc.h>
49: #import <sys/buf.h>
50: #import <sys/uio.h>
51: #import <sys/vnode.h>
52: #import <ufs/ufs/quota.h>
53: #import <ufs/ufs/inode.h>
54: #import <sys/namei.h>
55: #import <sys/mach_swapon.h>
56: #import <ufs/ffs/fs.h>
57: #import <sys/mount.h>
58: #import <net/if.h>
59: #import <netinet/in.h>
60: #import <nfs/rpcv2.h>
61: #import <nfs/nfsproto.h>
62: #import <nfs/nfs.h>
63: #undef fs_fsok
64: #undef fs_tsize
65: #undef fs_bsize
66: #undef fs_blocks
67: #undef fs_bfree
68: #undef fs_bavail
69:
70: #import <mach/mach_types.h>
71: #import <vm/vm_page.h>
72: #if defined(ppc)
73: #import <vm/pmap.h>
74: #endif /* ppc */
75: #import <vm/vm_map.h>
76: #import <vm/vm_kern.h>
77: #import <kern/parallel.h>
78: #import <kern/zalloc.h>
79: #import <kern/kalloc.h>
80:
81: #import <vm/vnode_pager.h>
82: #import <kern/mapfs.h>
83:
84: #import <kern/assert.h>
85:
86: extern struct vnodeops nfs_vnodeops;
87: extern struct vnodeops spec_vnodeops;
88:
89: #if NBBY == 8
90: #define BYTEMASK 0xff
91: #else NBBY
92: Define a byte mask for this machine.
93: #endif NBBY
94:
95:
96: #define PAGEMAP_THRESHOLD 64 /* Integral of sizeof(vm_offset_t) */
97: #define PAGEMAP_ENTRIES (PAGEMAP_THRESHOLD/sizeof(vm_offset_t))
98: #define PAGEMAP_SIZE(npgs) (npgs*sizeof(long))
99:
100: #define INDIR_PAGEMAP_ENTRIES(npgs) \
101: (((npgs-1)/PAGEMAP_ENTRIES) + 1)
102: #define INDIR_PAGEMAP_SIZE(npgs) \
103: (INDIR_PAGEMAP_ENTRIES(npgs) * sizeof(caddr_t))
104: #define INDIR_PAGEMAP(size) \
105: (PAGEMAP_SIZE(size) > PAGEMAP_THRESHOLD)
106:
107: #define RMAPSIZE(blocks) \
108: (howmany(blocks,NBBY))
109:
110: /*
111: * Sigh... with NFS/vnodes it is highly likely that we will need
112: * to allocate memory at page-out time, so use the XP hack to reserve
113: * pages and always use kalloc/zalloc instead of kget/zget.
114: * This must be fixed!!! FIXME - XXX.
115: */
116:
117: #define kget(size) kalloc_noblock(size)
118: #define zget(zone) zalloc_noblock(zone)
119:
120: /*
121: * Basic vnode pager data structures
122: */
123: zone_t vstruct_zone;
124: simple_lock_data_t vstruct_lock;
125:
126: static queue_head_t pager_files;
127: static int pager_file_count;
128: static pager_file_t pager_file_list[MAXPAGERFILES];
129:
130: static pf_entry seen_files[MAXPAGERFILES];
131: static int seen_files_max = 0;
132:
133:
134: /*
135: * Routine: vnode_pager_vput
136: * Function:
137: * Release one use of this vnode_pager_t
138: */
139: void
140: vnode_pager_vput(vs)
141: register vnode_pager_t vs;
142: {
143:
144: simple_lock(&vstruct_lock);
145: vs->vs_count--;
146: simple_unlock(&vstruct_lock);
147: }
148:
149: /*
150: * vnode_pager_vget:
151: *
152: * Return a vnode corresponding to the specified paging space
153: * and guarantee that it will remain in memory (until furthur action
154: * is taken).
155: *
156: * The vnode is returned unlocked.
157: */
158: struct vnode *
159: vnode_pager_vget(vs)
160: vnode_pager_t vs;
161: {
162: register struct vnode *vp;
163:
164: simple_lock(&vstruct_lock);
165: vs->vs_count++;
166: simple_unlock(&vstruct_lock);
167: vp = vs->vs_vp;
168: return(vp);
169: }
170:
171:
172: /*
173: * vnode_pager_allocpage - allocate a page in a paging file
174: */
175: daddr_t
176: vnode_pager_allocpage(pf)
177: register struct pager_file *pf;
178: {
179: int bp; /* byte counter */
180: int i; /* bit counter */
181: daddr_t page; /* page number */
182:
183: lock_write(&pf->pf_lock);
184:
185: if (pf->pf_pfree == 0) {
186: lock_done(&pf->pf_lock);
187: return(-1);
188: }
189:
190: /*
191: * Start at hint page and work up.
192: */
193: i = 0;
194: for (bp = pf->pf_hint / NBBY; bp < howmany(pf->pf_npgs, NBBY); bp++) {
195: if (*(pf->pf_bmap + bp) != BYTEMASK) {
196: for (i = 0; i < NBBY; i++) {
197: if (isclr((pf->pf_bmap + bp), i))
198: break;
199: }
200: break;
201: }
202: }
203: page = bp*NBBY+i;
204: if (page >= pf->pf_npgs) {
205: panic("vnode_pager_allocpage");
206: }
207: if (page > pf->pf_hipage) {
208: pf->pf_hipage = page;
209: }
210: setbit(pf->pf_bmap,page);
211: --pf->pf_pfree;
212: pf->pf_hint = page;
213:
214: lock_done(&pf->pf_lock);
215: return(page);
216: }
217:
218:
219: /*
220: * vnode_pager_findpage - find an available page in some paging file, using the
221: * argument as a preference. If the pager_file argument is NULL, any file will
222: * do. Return the designated page and file in entry.
223: */
224: kern_return_t
225: vnode_pager_findpage(struct pager_file *preferPf, pf_entry *entry)
226: {
227: daddr_t result;
228: pager_file_t pf;
229:
230: if (preferPf == PAGER_FILE_NULL) {
231: if (!queue_empty(&pager_files))
232: preferPf = (pager_file_t) queue_first(&pager_files);
233: else
234: return KERN_FAILURE;
235: }
236:
237: pf = preferPf;
238: do {
239: result = vnode_pager_allocpage(pf);
240: if (result != -1) {
241: entry->index = pf->pf_index;
242: entry->offset = result;
243: return KERN_SUCCESS;
244: }
245:
246: if (queue_end(&pager_files, &pf->pf_chain))
247: pf = (pager_file_t) queue_first(&pager_files);
248: else
249: pf = (pager_file_t) queue_next(&pf->pf_chain);
250:
251: } while (preferPf != pf);
252:
253: return KERN_FAILURE;
254: }
255:
256: static void
257: vnode_pager_deallocpage(pf_entry entry)
258: {
259: register struct pager_file *pf;
260: daddr_t page;
261:
262: if (entry.index == INDEX_NULL)
263: return;
264:
265: assert(entry.index <= pager_file_count);
266:
267: pf = pager_file_list[entry.index];
268: page = entry.offset;
269:
270: lock_write(&pf->pf_lock);
271:
272: if (page >= (daddr_t) pf->pf_npgs)
273: panic("vnode_pager_deallocpage");
274: if (page < pf->pf_hint)
275: pf->pf_hint = page;
276: clrbit(pf->pf_bmap, page);
277: ++pf->pf_pfree;
278:
279: lock_done(&pf->pf_lock);
280: }
281:
282:
283: /*
284: * pagerfile_pager_create
285: *
286: * Create an vstruct corresponding to the given pagerfile.
287: *
288: */
289: vnode_pager_t
290: pagerfile_pager_create(pf, size)
291: register pager_file_t pf;
292: vm_size_t size;
293: {
294: register vnode_pager_t vs;
295: register int i;
296:
297: /*
298: * XXX This can still livelock -- if the
299: * pageout daemon needs an vnode_pager record
300: * it won't get one until someone else
301: * refills the zone.
302: */
303:
304: vs = (struct vstruct *) zget(vstruct_zone);
305:
306: if (vs == VNODE_PAGER_NULL)
307: return(vs);
308:
309: vs->vs_size = atop(round_page(size));
310:
311: if (vs->vs_size == 0)
312: vs->vs_pmap = (pf_entry **) 0;
313: else {
314: if (INDIR_PAGEMAP(vs->vs_size)) {
315: vs->vs_pmap = (pf_entry **)
316: kget(INDIR_PAGEMAP_SIZE(vs->vs_size));
317: } else {
318: vs->vs_pmap = (pf_entry **)
319: kget(PAGEMAP_SIZE(vs->vs_size));
320: }
321: if (vs->vs_pmap == (pf_entry **) 0) {
322: /*
323: * We can't sleep here, so if there are no free pages, then
324: * just return nothing.
325: */
326: zfree(vstruct_zone, (vm_offset_t) vs);
327: return(VNODE_PAGER_NULL);
328: }
329:
330: if (INDIR_PAGEMAP(vs->vs_size)) {
331: bzero((caddr_t)vs->vs_pmap,
332: INDIR_PAGEMAP_SIZE(vs->vs_size));
333: } else {
334: for (i = 0; i < vs->vs_size; i++)
335: ((pf_entry *) &vs->vs_pmap[i])->index = INDEX_NULL;
336: }
337: }
338:
339: vs->is_device = FALSE;
340: vs->vs_count = 1;
341: vs->vs_vp = pf->pf_vp;
342: vs->vs_swapfile = TRUE;
343: vs->vs_pf = pf;
344: pf->pf_count++;
345:
346: vnode_pager_vput(vs);
347:
348: return(vs);
349: }
350:
351:
352: /*
353: * pagerfile_lookup
354: *
355: * Look for an entry at the specified offset in vstruct. If it's there,
356: * fill in the entry and return TRUE, otherwise return FALSE.
357: */
358: static boolean_t
359: pagerfile_lookup(struct vstruct *vs, vm_offset_t f_offset, pf_entry *entry)
360: {
361: vm_offset_t f_page = atop(f_offset);
362: int indirBlock;
363: int blockOffset;
364:
365: if (f_page >= vs->vs_size)
366: return FALSE;
367:
368: /*
369: * Now look for the entry in the map.
370: */
371: if (INDIR_PAGEMAP(vs->vs_size)) {
372: indirBlock = f_page / PAGEMAP_ENTRIES;
373: blockOffset = f_page % PAGEMAP_ENTRIES;
374:
375: if (vs->vs_pmap[indirBlock] == NULL ||
376: vs->vs_pmap[indirBlock][blockOffset].index == INDEX_NULL)
377: return FALSE;
378: else
379: *entry = vs->vs_pmap[indirBlock][blockOffset];
380:
381: } else { /* direct map */
382:
383: if (((pf_entry *) &vs->vs_pmap[f_page])->index == INDEX_NULL)
384: return FALSE;
385: else
386: *entry = *((pf_entry *) &vs->vs_pmap[f_page]);
387: }
388: return TRUE;
389: }
390:
391:
392: /*
393: * pagerfile_bmap
394: *
395: * Fill in the map entry (pager file, offset) for a given f_offset into an
396: * object backed this pager map.
397: *
398: * Returns: KERN_FAILURE if page not in map or no room left
399: */
400: static kern_return_t
401: pagerfile_bmap(vs, f_offset, flag, entry)
402: struct vstruct *vs;
403: vm_offset_t f_offset;
404: int flag;
405: pf_entry *entry;
406: {
407: vm_offset_t f_page = atop(f_offset);
408: boolean_t found;
409: int i;
410:
411: /*
412: * Check the map to see if we can find it. If we can't, then we'll
413: * make room below.
414: */
415: found = pagerfile_lookup(vs, f_offset, entry);
416:
417: if ((found) && (entry->index > pager_file_count))
418: panic("pagerfile_bmap: bad index %d", entry->index);
419:
420: if (flag == B_READ)
421: return found ? KERN_SUCCESS : KERN_FAILURE;
422: else if (found) {
423: /*
424: * Deallocate the page here, if the hint says that there's free
425: * space earlier in the file. We do this to keep the swapfile
426: * as small as possible, and to enable the swapfile compactor.
427: */
428: struct pager_file *pf;
429:
430: if (entry->index == 0)
431: panic("pagerfile_bmap: 0 index");
432:
433: pf = pager_file_list[entry->index];
434: if (pf->pf_hint < entry->offset)
435: vnode_pager_deallocpage(*entry);
436: else
437: return KERN_SUCCESS;
438: }
439:
440: /*
441: * If the object has grown, expand the page map.
442: */
443: if (f_page + 1 > vs->vs_size) {
444: pf_entry **new_pmap;
445: int new_size;
446:
447: new_size = f_page + 1;
448: assert(new_size > 0);
449:
450: if (INDIR_PAGEMAP(new_size)) { /* new map is indirect */
451:
452: if (vs->vs_size == 0) {
453: /*
454: * Nothing to copy, just get a new
455: * map and zero it.
456: */
457: new_pmap = (pf_entry **) kget(INDIR_PAGEMAP_SIZE(new_size));
458: if (new_pmap == NULL)
459: return (KERN_FAILURE);
460: bzero((caddr_t)new_pmap, INDIR_PAGEMAP_SIZE(new_size));
461: }
462: else if (INDIR_PAGEMAP(vs->vs_size)) {
463:
464: if (INDIR_PAGEMAP_SIZE(new_size) ==
465: INDIR_PAGEMAP_SIZE(vs->vs_size)) {
466: goto leavemapalone;
467: }
468:
469: /* Get a new indirect map */
470: new_pmap = (pf_entry **) kget(INDIR_PAGEMAP_SIZE(new_size));
471: if (new_pmap == NULL)
472: return KERN_FAILURE;
473:
474: bzero((caddr_t)new_pmap, INDIR_PAGEMAP_SIZE(new_size));
475:
476: /* Old map is indirect, copy the entries */
477: for (i = 0; i < INDIR_PAGEMAP_ENTRIES(vs->vs_size); i++)
478: new_pmap[i] = vs->vs_pmap[i];
479:
480: /* And free the old map */
481: kfree(vs->vs_pmap, INDIR_PAGEMAP_SIZE(vs->vs_size));
482:
483: } else { /* old map was direct, new map is indirect */
484:
485: /* Get a new indirect map */
486: new_pmap = (pf_entry **) kget(INDIR_PAGEMAP_SIZE(new_size));
487: if (new_pmap == NULL)
488: return KERN_FAILURE;
489:
490: bzero((caddr_t)new_pmap, INDIR_PAGEMAP_SIZE(new_size));
491:
492: /*
493: * Old map is direct, move it to the first indirect block.
494: */
495: new_pmap[0] = (pf_entry *) kget(PAGEMAP_THRESHOLD);
496: if (new_pmap[0] == NULL) {
497: kfree(new_pmap, INDIR_PAGEMAP_SIZE(new_size));
498: return KERN_FAILURE;
499: }
500: for (i = 0; i < vs->vs_size; i++)
501: new_pmap[0][i] = *((pf_entry *) &vs->vs_pmap[i]);
502:
503: /* Initialize the remainder of the block */
504: for (i = vs->vs_size; i < PAGEMAP_ENTRIES; i++)
505: new_pmap[0][i].index = INDEX_NULL;
506:
507: /* And free the old map */
508: kfree(vs->vs_pmap, PAGEMAP_SIZE(vs->vs_size));
509: }
510:
511: } else { /* The new map is a direct one */
512:
513: new_pmap = (pf_entry **) kget(PAGEMAP_SIZE(new_size));
514: if (new_pmap == NULL)
515: return KERN_FAILURE;
516:
517: /* Copy info from the old map */
518: for (i = 0; i < vs->vs_size; i++)
519: new_pmap[i] = vs->vs_pmap[i];
520:
521: /* Initialize the rest of the new map */
522: for (i = vs->vs_size; i < new_size; i++)
523: ((pf_entry *) &new_pmap[i])->index = INDEX_NULL;
524:
525: if (vs->vs_size > 0)
526: kfree(vs->vs_pmap, PAGEMAP_SIZE(vs->vs_size));
527: }
528:
529: vs->vs_pmap = new_pmap;
530: leavemapalone:
531: vs->vs_size = new_size;
532: }
533:
534: /*
535: * Now allocate the spot for the new page.
536: */
537: if (INDIR_PAGEMAP(vs->vs_size)) {
538:
539: int indirBlock = f_page / PAGEMAP_ENTRIES; /* the indirect block */
540: int blockOffset = f_page % PAGEMAP_ENTRIES; /* offset into block */
541:
542: /*
543: * In an indirect map, we may need to allocate space for the
544: * indirect block itself.
545: */
546: if (vs->vs_pmap[indirBlock] == NULL) {
547: vs->vs_pmap[indirBlock]=(pf_entry *) kget(PAGEMAP_THRESHOLD);
548:
549: if (vs->vs_pmap[indirBlock] == NULL)
550: return KERN_FAILURE;
551:
552: for (i = 0; i < PAGEMAP_ENTRIES; i++)
553: vs->vs_pmap[indirBlock][i].index = INDEX_NULL;
554: }
555:
556: if (vnode_pager_findpage(vs->vs_pf, entry) == KERN_FAILURE)
557: return KERN_FAILURE;
558: else
559: vs->vs_pmap[indirBlock][blockOffset] = *entry;
560:
561: } else { /* direct map */
562:
563: if (vnode_pager_findpage(vs->vs_pf, entry) == KERN_FAILURE)
564: return KERN_FAILURE;
565:
566: *(pf_entry *) &vs->vs_pmap[f_page] = *entry;
567: }
568:
569: return KERN_SUCCESS;
570: }
571:
572: /*
573: * vnode_pager_create
574: *
575: * Create an vstruct corresponding to the given vp.
576: *
577: */
578: vnode_pager_t
579: vnode_pager_create(vp)
580: register struct vnode *vp;
581: {
582: vnode_pager_t vs;
583: struct vattr vattr;
584: vm_size_t size;
585: struct proc *p = current_proc();
586: int error;
587:
588: /*
589: * XXX This can still livelock -- if the
590: * pageout daemon needs a vnode_pager record
591: * it won't get one until someone else
592: * refills the zone.
593: */
594:
595: vs = (struct vstruct *) zalloc(vstruct_zone);
596:
597: if (vs == VNODE_PAGER_NULL)
598: return(vs);
599:
600: bzero((caddr_t)vs, sizeof(struct vstruct));
601:
602: vs->is_device = FALSE;
603: vs->vs_count = 1;
604: vp->v_vm_info->pager = (vm_pager_t) vs;
605: vs->vs_vp = vp;
606: vs->vs_swapfile = FALSE;
607:
608: error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
609: if (!error) {
610: size = vattr.va_size;
611: vp->v_vm_info->vnode_size = size;
612: }
613: else
614: vp->v_vm_info->vnode_size = 0;
615:
616: VREF(vp);
617:
618: vnode_pager_vput(vs);
619:
620: return(vs);
621: }
622:
623: /*
624: * vnode_pager_setup
625: *
626: * Set up a vstruct for a given vnode. This is an exported routine.
627: */
628: vm_pager_t
629: vnode_pager_setup(vp, is_text, can_cache)
630: struct vnode *vp;
631: boolean_t is_text;
632: boolean_t can_cache;
633: {
634: register pager_file_t pf;
635:
636: unix_master();
637:
638: if (is_text)
639: vp->v_flag |= VTEXT;
640: #if !MACH_NBC
641: if(!vp->v_vm_info)
642: vm_info_init(vp);
643: #endif /* MACH_NBC */
644:
645: if (vp->v_vm_info->pager == vm_pager_null) {
646: /*
647: * Check to make sure this isn't in use as a pager file.
648: */
649: for (pf = (pager_file_t) queue_first(&pager_files);
650: !queue_end(&pager_files, &pf->pf_chain);
651: pf = (pager_file_t) queue_next(&pf->pf_chain)) {
652: if (pf->pf_vp == vp) {
653: return(vm_pager_null);
654: }
655: }
656: (void) vnode_pager_create(vp);
657: if (can_cache)
658: vm_object_cache_object(
659: vm_object_lookup(vp->v_vm_info->pager), TRUE);
660: }
661:
662: unix_release();
663: /*
664: * Try to keep something in the vstruct zone since we can sleep
665: * here if necessary.
666: */
667: zfree(vstruct_zone, zalloc(vstruct_zone));
668: return(vp->v_vm_info->pager);
669: }
670:
671: #ifdef i386
672:
673: static __inline__ vm_offset_t
674: vnode_pageio_setup(
675: vm_page_t m
676: )
677: {
678: return (VM_PAGE_TO_PHYS(m));
679: }
680:
681: static __inline__ void
682: vnode_pageio_complete(
683: vm_page_t m,
684: vm_offset_t addr
685: )
686: {
687: /* do nothing */
688: }
689:
690: #else /* notdef i386 */
691:
692: static vm_offset_t
693: vnode_pageio_setup(
694: vm_page_t m
695: )
696: {
697: kern_return_t result;
698: vm_offset_t addr = vm_map_min(kernel_map);
699:
700: result = vm_map_find(kernel_map, VM_OBJECT_NULL, 0,
701: &addr, PAGE_SIZE, TRUE);
702: if (result != KERN_SUCCESS)
703: return (0);
704:
705: pmap_enter_phys_page(VM_PAGE_TO_PHYS(m), addr);
706:
707: return (addr);
708: }
709:
710: static void
711: vnode_pageio_complete(
712: vm_page_t m,
713: vm_offset_t addr
714: )
715: {
716: vm_offset_t taddr = trunc_page(addr);
717:
718: (void) vm_map_remove(kernel_map, taddr, taddr + PAGE_SIZE);
719: }
720:
721: #endif /* notdef i386 */
722:
723: pager_return_t
724: vnode_pagein(
725: vm_page_t m,
726: int *errorp
727: )
728: {
729: struct vnode *vp;
730: vnode_pager_t vs;
731: pager_return_t result = PAGER_SUCCESS;
732: vm_offset_t f_offset;
733: pf_entry entry;
734: struct proc *p = current_proc();
735: int error = 0;
736:
737: unix_master();
738:
739: vs = (vnode_pager_t) m->object->pager;
740: vp = vnode_pager_vget(vs);
741: f_offset = m->offset + m->object->paging_offset;
742:
743: if (vs->vs_swapfile) {
744: if (pagerfile_bmap(vs, f_offset, B_READ, &entry) == KERN_FAILURE)
745: result = PAGER_ABSENT;
746: else {
747: f_offset = ptoa(entry.offset);
748: vp = pager_file_list[entry.index]->pf_vp;
749: }
750: }
751:
752: if (result != PAGER_ABSENT) {
753: vm_offset_t ioaddr = vnode_pageio_setup(m);
754: struct uio auio;
755: struct iovec aiov;
756:
757: if (ioaddr) {
758: auio.uio_iov = &aiov;
759: auio.uio_iovcnt = 1;
760: auio.uio_offset = f_offset;
761: auio.uio_segflg = UIO_SYSSPACE;
762: auio.uio_rw = UIO_READ;
763: auio.uio_resid = PAGE_SIZE;
764: auio.uio_procp = NULL;
765:
766: aiov.iov_len = PAGE_SIZE;
767: aiov.iov_base = (caddr_t)ioaddr;
768:
769: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_CANRECURSE, p);
770:
771: m->nfspagereq=TRUE;
772: error = VOP_PAGEIN(vp, &auio, 0, p->p_ucred);
773: m->nfspagereq=FALSE;
774: if (error)
775: result = PAGER_ERROR;
776: vp->v_vm_info->error = error;
777:
778: VOP_UNLOCK(vp, 0, p);
779:
780: if (!error && auio.uio_resid > 0)
781: (void) memset((void *)(ioaddr + PAGE_SIZE -
782: auio.uio_resid), 0, auio.uio_resid);
783:
784: vnode_pageio_complete(m, ioaddr);
785: #ifdef ppc
786: /*
787: * After a pagein, we must synchronize the processor caches.
788: * On PPC, the i-cache is not coherent in all models, thus
789: * it needs to be invalidated.
790: */
791: flush_cache(VM_PAGE_TO_PHYS(m), PAGE_SIZE);
792: #endif /* ppc */
793: }
794: else
795: result = PAGER_ERROR;
796: }
797:
798: vnode_pager_vput(vs);
799:
800: if (errorp)
801: *errorp = error;
802:
803: unix_release();
804:
805: return (result);
806: }
807:
808: pager_return_t
809: vnode_pageout(
810: vm_page_t m
811: )
812: {
813: struct vnode *vp;
814: vnode_pager_t vs;
815: pager_return_t result = PAGER_SUCCESS;
816: vm_offset_t f_offset;
817: vm_size_t size = PAGE_SIZE;
818: pf_entry entry;
819: struct proc *p = current_proc();
820: int error = 0;
821:
822: unix_master();
823:
824: vs = (vnode_pager_t) m->object->pager;
825: vp = vnode_pager_vget(vs);
826: f_offset = m->offset + m->object->paging_offset;
827:
828: #if MACH_NBC
829: if (!vs->vs_swapfile) {
830: /*
831: * Be sure that a paging operation doesn't
832: * accidently extend the size of "mapped" file.
833: *
834: * However, we do extend the size up to the current
835: * size kept in the vm_info structure.
836: */
837: if (f_offset + size > vp->v_vm_info->vnode_size) {
838: if (f_offset > vp->v_vm_info->vnode_size)
839: size = 0;
840: else
841: size = vp->v_vm_info->vnode_size - f_offset;
842: }
843: }
844: #endif MACH_NBC
845:
846: if (vs->vs_swapfile) {
847: if (pagerfile_bmap(vs, f_offset, B_WRITE, &entry) == KERN_FAILURE)
848: result = PAGER_ERROR;
849: else {
850: /*
851: * If the paging operation extends the size of the
852: * pagerfile, update the information in the vm_info
853: * structure
854: */
855: f_offset = ptoa(entry.offset);
856: vp = pager_file_list[entry.index]->pf_vp;
857: if (f_offset + size > vp->v_vm_info->vnode_size)
858: vp->v_vm_info->vnode_size = f_offset + size;
859: }
860: }
861:
862: if (result != PAGER_ERROR && size > 0) {
863: vm_offset_t ioaddr = vnode_pageio_setup(m);
864: struct uio auio;
865: struct iovec aiov;
866:
867: if (ioaddr) {
868: auio.uio_iov = &aiov;
869: auio.uio_iovcnt = 1;
870: auio.uio_offset = f_offset;
871: auio.uio_segflg = UIO_SYSSPACE;
872: auio.uio_rw = UIO_WRITE;
873: auio.uio_procp = NULL;
874: aiov.iov_base = (caddr_t)ioaddr;
875: #if MACH_NBC
876: auio.uio_resid = size;
877: aiov.iov_len = size;
878: #else
879: auio.uio_resid = PAGE_SIZE;
880: aiov.iov_len = PAGE_SIZE;
881: #endif /* MACH_NBC */
882:
883: #if MACH_NBC
884: {
885: #define VNODE_LOCK_RETRY_COUNT 1
886: #define VNODE_LOCK_RETRY_TICKS 2
887:
888: int retry = VNODE_LOCK_RETRY_COUNT;
889: vnode_lock_retry:
890: error = vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_CANRECURSE, p);
891: if (error) {
892: /*
893: * Retry the lock after yielding to other threads.
894: * Not doing this makes the pageout thread compute bound.
895: * Yielding lets I/O threads to run
896: * and make forward progress.
897: */
898: if (retry-- > 0) {
899: thread_will_wait(current_thread());
900: thread_set_timeout(VNODE_LOCK_RETRY_TICKS);
901: thread_block();
902: goto vnode_lock_retry;
903: }
904:
905: result = PAGER_ERROR;
906: vnode_pageio_complete(m, ioaddr);
907: goto out;
908: }
909: }
910: #else /* MACH_NBC */
911: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
912: #endif /* MACH_NBC */
913:
914: error = VOP_PAGEOUT(vp, &auio, 0, p->p_ucred);
915: if (error)
916: result = PAGER_ERROR;
917: vp->v_vm_info->error = error;
918:
919: VOP_UNLOCK(vp, 0, p);
920:
921: vnode_pageio_complete(m, ioaddr);
922: }
923: else
924: result = PAGER_ERROR;
925: }
926:
927: if (result == PAGER_SUCCESS) {
928: m->clean = TRUE; /* XXX - wrong place */
929: pmap_clear_modify(VM_PAGE_TO_PHYS(m)); /* XXX - wrong place */
930: }
931:
932: out:
933: vnode_pager_vput(vs);
934:
935: unix_release();
936:
937: return (result);
938: }
939:
940: /*
941: * vnode_has_page:
942: *
943: * Parameters:
944: * pager
945: * id paging object
946: * offset Offset in paging object to test
947: *
948: * Assumptions:
949: * This is only used on shadowing (copy) objects.
950: * Since copy objects are always backed by a swapfile, we just
951: * test the map for that swapfile to see if the page is present.
952: */
953: boolean_t
954: vnode_has_page(pager, offset)
955: vm_pager_t pager;
956: vm_offset_t offset;
957: {
958: vnode_pager_t vs = (vnode_pager_t) pager;
959: pf_entry entry;
960:
961: /*
962: * For now, we do all inode hacking on the master cpu.
963: */
964: unix_master();
965:
966: if (vs == VNODE_PAGER_NULL)
967: panic("vnode_has_page: failed lookup");
968:
969: if (vs->vs_swapfile) {
970: unix_release();
971: if (pagerfile_bmap(vs, offset, B_READ, &entry) == KERN_FAILURE)
972: return FALSE;
973: else
974: return TRUE;
975: }
976: else {
977: panic("vnode_has_page called on non-default pager");
978: }
979: /*NOTREACHED*/
980:
981: return FALSE;
982: }
983:
984:
985: /*
986: * Routine: vnode_pager_file_init
987: * Function:
988: * Create a pager_file structure for a new pager file.
989: * Arguments:
990: * The file in question is specified by vnode pointer.
991: * lowat and hiwat are the low water and high water marks
992: * that the size of pager file will float between. If
993: * the low water mark is zero, then the file will not
994: * shrink after paging space is freed. If the high water
995: * mark is zero, the file will grow without bounds.
996: *
997: * The vp is locked on entry to and exit from this function.
998: */
999: int
1000: vnode_pager_file_init(pfp, vp, lowat, hiwat)
1001: pager_file_t *pfp;
1002: struct vnode *vp;
1003: long lowat;
1004: long hiwat;
1005: {
1006: struct vattr vattr;
1007: register pager_file_t pf;
1008: int error;
1009: long i;
1010: struct proc *p = current_proc();
1011: struct ucred *cred;
1012: vm_size_t size;
1013:
1014: *pfp = PAGER_FILE_NULL;
1015:
1016: /*
1017: * Make sure no other object paging to this file?
1018: */
1019: #if MACH_NBC
1020: mapfs_uncache(vp);
1021: #endif /* MACH_NBC */
1022:
1023: if(!vp->v_vm_info) {
1024: vm_info_init(vp);
1025: }
1026:
1027: if (vp->v_vm_info->mapped) {
1028: return(EBUSY);
1029: }
1030:
1031: /*
1032: * Clean up the file blocks on a pager file by
1033: * truncating to length "lowat".
1034: */
1035: error = VOP_GETATTR(vp, &vattr, p->p_ucred, p);
1036: size = vattr.va_size;
1037: if (size > lowat) {
1038: vattr_null(&vattr);
1039: vattr.va_size = size = lowat;
1040: error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
1041: if (error) {
1042: return(error);
1043: }
1044: }
1045:
1046: /*
1047: * Initialize the vnode_size field
1048: */
1049: vp->v_vm_info->vnode_size = size;
1050:
1051: pf = (pager_file_t) kalloc(sizeof(struct pager_file));
1052: VREF(vp);
1053: pf->pf_vp = vp;
1054: cred = p->p_ucred;
1055: crhold(cred);
1056: vp->v_vm_info->cred = cred;
1057: pf->pf_count = 0;
1058: pf->pf_hint = 0;
1059: pf->pf_lowat = atop(round_page(lowat));
1060: /*
1061: * If no maximum space is specified, then we should make a map that
1062: * can cover the entire disk, otherwise the block map need only
1063: * cover the maximum space allowed.
1064: */
1065: if (!hiwat)
1066: hiwat = vp->v_mount->mnt_stat.f_blocks *
1067: vp->v_mount->mnt_stat.f_bsize;
1068: pf->pf_pfree = pf->pf_npgs = atop(hiwat);
1069: pf->pf_bmap = (u_char *) kalloc(RMAPSIZE(pf->pf_npgs));
1070: for (i = 0; i < pf->pf_npgs; i++) {
1071: clrbit(pf->pf_bmap, i);
1072: }
1073: pf->pf_hipage = -1;
1074: pf->pf_prefer = FALSE;
1075: lock_init(&pf->pf_lock, TRUE);
1076:
1077: /*
1078: * Put the new pager file in the list.
1079: */
1080: queue_enter(&pager_files, pf, pager_file_t, pf_chain);
1081: pager_file_count++;
1082: pf->pf_index = pager_file_count;
1083: pager_file_list[pager_file_count] = pf;
1084: *pfp = pf;
1085: return (0);
1086: }
1087:
1088: void
1089: vnode_pager_shutdown()
1090: {
1091: pager_file_t pf;
1092:
1093: while (!queue_empty(&pager_files)) {
1094: pf = (pager_file_t) queue_first(&pager_files);
1095: vrele(pf->pf_vp);
1096: queue_remove(&pager_files, pf, pager_file_t, pf_chain);
1097: pager_file_count--;
1098: }
1099: }
1100:
1101:
1102: /*
1103: * Routine: mach_swapon
1104: * Function:
1105: * Syscall interface to mach_swapon.
1106: */
1107: int
1108: mach_swapon(filename, flags, lowat, hiwat)
1109: char *filename;
1110: int flags;
1111: long lowat;
1112: long hiwat;
1113: {
1114: struct vnode *vp;
1115: struct nameidata nd, *ndp;
1116: struct proc *p = current_proc();
1117: pager_file_t pf;
1118: register int error;
1119:
1120: ndp = &nd;
1121:
1122: if ((error = suser(p->p_ucred, &p->p_acflag)))
1123: return (error);
1124:
1125: unix_master();
1126:
1127: /*
1128: * Get a vnode for the paging area.
1129: */
1130: NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1131: filename, p);
1132: if ((error = namei(ndp)))
1133: return (error);
1134: vp = ndp->ni_vp;
1135:
1136: if (vp->v_type != VREG) {
1137: error = EINVAL;
1138: goto bailout;
1139: }
1140:
1141: /*
1142: * Look to see if we are already paging to this file.
1143: */
1144: for (pf = (pager_file_t) queue_first(&pager_files);
1145: !queue_end(&pager_files, &pf->pf_chain);
1146: pf = (pager_file_t) queue_next(&pf->pf_chain)) {
1147: if (pf->pf_vp == vp)
1148: break;
1149: }
1150: if (!queue_end(&pager_files, &pf->pf_chain)) {
1151: error = EBUSY;
1152: goto bailout;
1153: }
1154:
1155: error = vnode_pager_file_init(&pf, vp, lowat, hiwat);
1156: if (error) {
1157: goto bailout;
1158: }
1159: pf->pf_prefer = ((flags & MS_PREFER) != 0);
1160:
1161: /*
1162: * Create dummy symbol file for current mach_kernel executable.
1163: * See bsd/kern/kern_symfile.c
1164: */
1165: output_kernel_symbols(p);
1166:
1167: error = 0;
1168: bailout:
1169: if (vp) {
1170: VOP_UNLOCK(vp, 0, p);
1171: vrele(vp);
1172: }
1173: unix_release();
1174: return(error);
1175: }
1176:
1177: /*
1178: * Routine: vswap_allocate
1179: * Function:
1180: * Allocate a place for paging out a kernel-created
1181: * memory object.
1182: *
1183: * Implementation:
1184: * Looks through the paging files for the one with the
1185: * most free space. First, only "preferred" paging files
1186: * are considered, then local paging files, and then
1187: * remote paging files. In each case, the pager file
1188: * the most free blocks will be chosen.
1189: *
1190: * In/out conditions:
1191: * If the paging area is on a local disk, the inode is
1192: * returned locked.
1193: */
1194: pager_file_t
1195: vswap_allocate()
1196: {
1197: int pass;
1198: int mostspace;
1199: pager_file_t pf, mostpf;
1200:
1201: extern int (**ffs_vnodeop_p)();
1202:
1203: mostpf = PAGER_FILE_NULL;
1204: mostspace = 0;
1205:
1206: if (pager_file_count > 1) {
1207: for (pass = 0; pass < 4; pass++) {
1208: for (pf = (pager_file_t)queue_first(&pager_files);
1209: !queue_end(&pager_files, &pf->pf_chain);
1210: pf = (pager_file_t)queue_next(&pf->pf_chain)) {
1211:
1212: if ((pass < 2) && !pf->pf_prefer)
1213: continue;
1214: if ((!(pass &1) &&
1215: (pf->pf_vp->v_op != ffs_vnodeop_p)))
1216: continue;
1217:
1218: if (pf->pf_pfree > mostspace) {
1219: mostspace = pf->pf_pfree;
1220: mostpf = pf;
1221: }
1222: }
1223: /*
1224: * If we found space, then break out of loop.
1225: */
1226: if (mostpf != PAGER_FILE_NULL)
1227: break;
1228: }
1229: } else if (pager_file_count == 1) {
1230: mostpf = (pager_file_t) queue_first(&pager_files);
1231: }
1232:
1233: return(mostpf);
1234: }
1235:
1236: vm_pager_t
1237: vnode_alloc(size)
1238: vm_size_t size;
1239: {
1240: pager_file_t pf;
1241: vnode_pager_t vs = (vnode_pager_t) vm_pager_null;
1242:
1243: #ifdef lint
1244: size++;
1245: #endif lint
1246:
1247: unix_master();
1248:
1249: /*
1250: * Get a pager_file, then turn it into a paging space.
1251: */
1252:
1253: if ((pf = vswap_allocate()) == PAGER_FILE_NULL) {
1254: goto out;
1255: }
1256: if ((vs = pagerfile_pager_create(pf, size)) ==
1257: VNODE_PAGER_NULL) {
1258: vs = (vnode_pager_t) vm_pager_null;
1259: goto out;
1260: }
1261: out:
1262: unix_release();
1263: return((vm_pager_t) vs);
1264: }
1265:
1266:
1267: /*
1268: * Try to truncate the paging files.
1269: */
1270: void
1271: vnode_pager_truncate(pf_entry entry)
1272: {
1273: struct pager_file *pf = pager_file_list[entry.index];
1274: struct vnode *vp = pf->pf_vp;
1275: struct vattr vattr;
1276: int error;
1277: struct proc *p = current_proc();
1278: long truncpage;
1279: int i;
1280:
1281: /*
1282: * If this is not the last page in the file, return now.
1283: * If the swaptimizer is enabled we cannot free blocks out from
1284: * underneath it.
1285: */
1286: assert(entry.offset <= pf->pf_hipage);
1287: if (entry.offset < pf->pf_hipage)
1288: return;
1289:
1290: lock_write(&pf->pf_lock);
1291:
1292: /*
1293: * Find a new high page
1294: */
1295: for (i = entry.offset - 1; i >= 0; i--) {
1296: if (isset(pf->pf_bmap, i)) {
1297: pf->pf_hipage = i;
1298: break;
1299: }
1300: }
1301:
1302: /*
1303: * If we are higher than the low water mark, truncate
1304: * the file.
1305: */
1306: truncpage = pf->pf_hipage + 1;
1307: if (pf->pf_lowat == 0 || truncpage <= pf->pf_lowat ||
1308: vp->v_vm_info->vnode_size < ptoa(truncpage)) {
1309: lock_done(&pf->pf_lock);
1310: return;
1311: }
1312:
1313: vattr_null(&vattr);
1314: vattr.va_size = ptoa(truncpage);
1315: ASSERT( (int) vattr.va_size >= 0 );
1316:
1317: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1318: if ((error = VOP_SETATTR(vp, &vattr, vp->v_vm_info->cred, p))) {
1319: printf("vnode_deallocpage: error truncating %s,"
1320: " error = %d\n", pf->pf_name, error);
1321: }
1322: VOP_UNLOCK(vp, 0, p);
1323:
1324:
1325: lock_done(&pf->pf_lock);
1326: }
1327:
1328:
1329: static void
1330: visit_file(pf_entry entry)
1331: {
1332: int i;
1333:
1334: if (entry.index == INDEX_NULL)
1335: return;
1336:
1337: for (i = 0; i < seen_files_max; i++)
1338: if (seen_files[i].index == entry.index) {
1339: seen_files[i].offset = max(seen_files[i].offset,entry.offset);
1340: return;
1341: }
1342:
1343: seen_files[seen_files_max++] = entry;
1344: }
1345:
1346:
1347: void
1348: vnode_dealloc(pager)
1349: vm_pager_t pager;
1350: {
1351: struct vnode *vp;
1352: vnode_pager_t vs = (vnode_pager_t) pager;
1353: int i;
1354:
1355: unix_master();
1356:
1357: vp = vnode_pager_vget(vs);
1358:
1359: ASSERT(vs->vs_count == 1);
1360:
1361: seen_files_max = 0;
1362: if (vs->vs_swapfile) {
1363: pager_file_t pf;
1364: int i,j;
1365:
1366: ASSERT(vs->vs_pf);
1367:
1368: pf = vs->vs_pf;
1369: if (INDIR_PAGEMAP(vs->vs_size)) {
1370: for (i = 0; i < INDIR_PAGEMAP_ENTRIES(vs->vs_size); i++) {
1371: if (vs->vs_pmap[i] != NULL) {
1372: for(j = 0; j < PAGEMAP_ENTRIES; j++) {
1373: vnode_pager_deallocpage(vs->vs_pmap[i][j]);
1374: visit_file(vs->vs_pmap[i][j]);
1375: }
1376: kfree(vs->vs_pmap[i], PAGEMAP_THRESHOLD);
1377: }
1378: }
1379: kfree(vs->vs_pmap, INDIR_PAGEMAP_SIZE(vs->vs_size));
1380: } else {
1381: for (i = 0; i < vs->vs_size; i++) {
1382: vnode_pager_deallocpage(*(pf_entry *)&vs->vs_pmap[i]);
1383: visit_file(*(pf_entry *)&vs->vs_pmap[i]);
1384: }
1385: if (vs->vs_size > 0)
1386: kfree(vs->vs_pmap, PAGEMAP_SIZE(vs->vs_size));
1387: }
1388: pf->pf_count--;
1389: } else {
1390: vp->v_flag &= ~VTEXT;
1391: vp->v_vm_info->pager = vm_pager_null; /* so vrele will free */
1392:
1393: vp->v_flag |= VAGE; /* put this vnode at the head of freelist */
1394: vrele(vp);
1395: }
1396:
1397: for (i=0; i < seen_files_max; i++)
1398: vnode_pager_truncate(seen_files[i]);
1399: zfree(vstruct_zone, (vm_offset_t) vs);
1400: unix_release();
1401: }
1402:
1403: /*
1404: * Remove vnode associated object from the object cache.
1405: *
1406: * XXX unlock the vnode if it is currently locked.
1407: * We must do this since uncaching the object may result in its
1408: * destruction which may initiate paging activity which may necessitate
1409: * re-locking the vnode.
1410: */
1411: int
1412: vnode_uncache(vp)
1413: register struct vnode *vp;
1414: {
1415: struct proc *p = current_proc();
1416:
1417: if (vp->v_type != VREG)
1418: return (1);
1419:
1420: if (vp->v_vm_info == 0 || vp->v_vm_info->pager == vm_pager_null)
1421: return (1);
1422:
1423: #ifdef DEBUG
1424: if (!VOP_ISLOCKED(vp)) {
1425: extern int (**nfsv2_vnodeop_p)();
1426:
1427: if (vp->v_op != nfsv2_vnodeop_p)
1428: panic("vnode_uncache: vnode not locked!");
1429: }
1430: #endif
1431:
1432: /*
1433: * The act of uncaching may cause an object to be deallocated
1434: * which may need to wait for the pageout daemon which in turn
1435: * may be waiting for this inode's lock, so be sure to unlock
1436: * and relock later if necessary. (This of course means that
1437: * code calling this routine must be able to handle the fact
1438: * that the inode has been unlocked temporarily). This code, of
1439: * course depends on the Unix master restriction for proper
1440: * synchronization.
1441: */
1442: #if MACH_NBC
1443: mapfs_uncache(vp);
1444: #endif /* MACH_NBC */
1445:
1446: VOP_UNLOCK(vp, 0, p);
1447: vm_object_uncache(vp->v_vm_info->pager);
1448: #if MACH_NBC
1449: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_CANRECURSE, p);
1450: #else
1451: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1452: #endif
1453: return (1);
1454: }
1455:
1456: void
1457: vnode_pager_init()
1458: {
1459: register vm_size_t size;
1460:
1461: /*
1462: * Initialize zone of paging structures.
1463: */
1464:
1465: size = (vm_size_t) sizeof(struct vstruct);
1466: vstruct_zone = zinit(size,
1467: (vm_size_t) 10000*size, /* XXX */
1468: PAGE_SIZE,
1469: FALSE, "vnode pager structures");
1470: simple_lock_init(&vstruct_lock);
1471: queue_init(&pager_files);
1472: }
1473:
1474: void
1475: vnode_pager_setsize(vp, nsize)
1476: struct vnode *vp;
1477: u_long nsize;
1478: {
1479: if (vp->v_vm_info) {
1480: if (vp->v_type != VREG)
1481: panic("vnode_pager_setsize not VREG");
1482: vp->v_vm_info->vnode_size = nsize;
1483: }
1484: }
1485:
1486: void
1487: vnode_pager_umount(mp)
1488: register struct mount *mp;
1489: {
1490: struct proc *p = current_proc();
1491: struct vnode *vp, *nvp;
1492:
1493: loop:
1494: for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
1495: if (vp->v_mount != mp)
1496: goto loop;
1497: nvp = vp->v_mntvnodes.le_next;
1498: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
1499: (void) vnode_uncache(vp);
1500: VOP_UNLOCK(vp, 0, p);
1501: }
1502: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.