v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / mm / vmscan.c
1 /*
2  *  linux/mm/vmscan.c
3  *
4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
5  *
6  *  Swap reorganised 29.12.95, Stephen Tweedie.
7  *  kswapd added: 7.1.96  sct
8  *  Removed kswapd_ctl limits, and swap out as many pages as needed
9  *  to bring the system back to freepages.high: 2.4.97, Rik van Riel.
10  *  Version: $Id: vmscan.c,v 1.5 1998/02/23 22:14:28 sct Exp $
11  *  Zone aware kswapd started 02/00, Kanoj Sarcar (kanoj@sgi.com).
12  *  Multiqueue VM started 5.8.00, Rik van Riel.
13  */
14
15 #include <linux/slab.h>
16 #include <linux/kernel_stat.h>
17 #include <linux/swap.h>
18 #include <linux/swapctl.h>
19 #include <linux/smp_lock.h>
20 #include <linux/pagemap.h>
21 #include <linux/init.h>
22 #include <linux/highmem.h>
23 #include <linux/file.h>
24
25 #include <asm/pgalloc.h>
26
27 /*
28  * The "priority" of VM scanning is how much of the queues we
29  * will scan in one go. A value of 6 for DEF_PRIORITY implies
30  * that we'll scan 1/64th of the queues ("queue_length >> 6")
31  * during a normal aging round.
32  */
33 #define DEF_PRIORITY (6)
34
35 static inline void age_page_up(struct page *page)
36 {
37         unsigned age = page->age + PAGE_AGE_ADV;
38         if (age > PAGE_AGE_MAX)
39                 age = PAGE_AGE_MAX;
40         page->age = age;
41 }
42
43 static inline void age_page_down(struct page * page)
44 {
45         page->age /= 2;
46 }
47
48 /*
49  * The swap-out function returns 1 if it successfully
50  * scanned all the pages it was asked to (`count').
51  * It returns zero if it couldn't do anything,
52  *
53  * rss may decrease because pages are shared, but this
54  * doesn't count as having freed a page.
55  */
56
57 /*
58  * Estimate whether a zone has enough inactive or free pages..
59  */
60 static unsigned int zone_inactive_plenty(zone_t *zone)
61 {
62         unsigned int inactive;
63
64         if (!zone->size)
65                 return 0;
66                 
67         inactive = zone->inactive_dirty_pages;
68         inactive += zone->inactive_clean_pages;
69         inactive += zone->free_pages;
70
71         return (inactive > (zone->size / 3));
72 }
73
74 static unsigned int zone_free_plenty(zone_t *zone)
75 {
76         unsigned int free;
77
78         free = zone->free_pages;
79         free += zone->inactive_clean_pages;
80
81         return free > zone->pages_high*2;
82 }
83
84 /* mm->page_table_lock is held. mmap_sem is not held */
85 static void try_to_swap_out(struct mm_struct * mm, struct vm_area_struct* vma, unsigned long address, pte_t * page_table, struct page *page)
86 {
87         pte_t pte;
88         swp_entry_t entry;
89
90         /* 
91          * If we are doing a zone-specific scan, do not
92          * touch pages from zones which don't have a 
93          * shortage.
94          */
95         if (zone_inactive_plenty(page->zone))
96                 return;
97
98         /* Don't look at this pte if it's been accessed recently. */
99         if (ptep_test_and_clear_young(page_table)) {
100                 mark_page_accessed(page);
101                 return;
102         }
103
104         if (TryLockPage(page))
105                 return;
106
107         /* From this point on, the odds are that we're going to
108          * nuke this pte, so read and clear the pte.  This hook
109          * is needed on CPUs which update the accessed and dirty
110          * bits in hardware.
111          */
112         flush_cache_page(vma, address);
113         pte = ptep_get_and_clear(page_table);
114         flush_tlb_page(vma, address);
115
116         /*
117          * Is the page already in the swap cache? If so, then
118          * we can just drop our reference to it without doing
119          * any IO - it's already up-to-date on disk.
120          */
121         if (PageSwapCache(page)) {
122                 entry.val = page->index;
123                 if (pte_dirty(pte))
124                         set_page_dirty(page);
125 set_swap_pte:
126                 swap_duplicate(entry);
127                 set_pte(page_table, swp_entry_to_pte(entry));
128 drop_pte:
129                 mm->rss--;
130                 if (!PageReferenced(page))
131                         deactivate_page(page);
132                 UnlockPage(page);
133                 page_cache_release(page);
134                 return;
135         }
136
137         /*
138          * Is it a clean page? Then it must be recoverable
139          * by just paging it in again, and we can just drop
140          * it..  or if it's dirty but has backing store,
141          * just mark the page dirty and drop it.
142          *
143          * However, this won't actually free any real
144          * memory, as the page will just be in the page cache
145          * somewhere, and as such we should just continue
146          * our scan.
147          *
148          * Basically, this just makes it possible for us to do
149          * some real work in the future in "refill_inactive()".
150          */
151         if (page->mapping) {
152                 if (pte_dirty(pte))
153                         set_page_dirty(page);
154                 goto drop_pte;
155         }
156         /*
157          * Check PageDirty as well as pte_dirty: page may
158          * have been brought back from swap by swapoff.
159          */
160         if (!pte_dirty(pte) && !PageDirty(page))
161                 goto drop_pte;
162
163         /*
164          * This is a dirty, swappable page.  First of all,
165          * get a suitable swap entry for it, and make sure
166          * we have the swap cache set up to associate the
167          * page with that swap entry.
168          */
169         entry = get_swap_page();
170         if (!entry.val)
171                 goto out_unlock_restore; /* No swap space left */
172
173         /* Add it to the swap cache and mark it dirty */
174         add_to_swap_cache(page, entry);
175         set_page_dirty(page);
176         goto set_swap_pte;
177
178 out_unlock_restore:
179         set_pte(page_table, pte);
180         UnlockPage(page);
181         return;
182 }
183
184 /* mm->page_table_lock is held. mmap_sem is not held */
185 static int swap_out_pmd(struct mm_struct * mm, struct vm_area_struct * vma, pmd_t *dir, unsigned long address, unsigned long end, int count)
186 {
187         pte_t * pte;
188         unsigned long pmd_end;
189
190         if (pmd_none(*dir))
191                 return count;
192         if (pmd_bad(*dir)) {
193                 pmd_ERROR(*dir);
194                 pmd_clear(dir);
195                 return count;
196         }
197         
198         pte = pte_offset(dir, address);
199         
200         pmd_end = (address + PMD_SIZE) & PMD_MASK;
201         if (end > pmd_end)
202                 end = pmd_end;
203
204         do {
205                 if (pte_present(*pte)) {
206                         struct page *page = pte_page(*pte);
207
208                         if (VALID_PAGE(page) && !PageReserved(page)) {
209                                 try_to_swap_out(mm, vma, address, pte, page);
210                                 if (!--count)
211                                         break;
212                         }
213                 }
214                 address += PAGE_SIZE;
215                 pte++;
216         } while (address && (address < end));
217         mm->swap_address = address + PAGE_SIZE;
218         return count;
219 }
220
221 /* mm->page_table_lock is held. mmap_sem is not held */
222 static inline int swap_out_pgd(struct mm_struct * mm, struct vm_area_struct * vma, pgd_t *dir, unsigned long address, unsigned long end, int count)
223 {
224         pmd_t * pmd;
225         unsigned long pgd_end;
226
227         if (pgd_none(*dir))
228                 return count;
229         if (pgd_bad(*dir)) {
230                 pgd_ERROR(*dir);
231                 pgd_clear(dir);
232                 return count;
233         }
234
235         pmd = pmd_offset(dir, address);
236
237         pgd_end = (address + PGDIR_SIZE) & PGDIR_MASK;  
238         if (pgd_end && (end > pgd_end))
239                 end = pgd_end;
240         
241         do {
242                 count = swap_out_pmd(mm, vma, pmd, address, end, count);
243                 if (!count)
244                         break;
245                 address = (address + PMD_SIZE) & PMD_MASK;
246                 pmd++;
247         } while (address && (address < end));
248         return count;
249 }
250
251 /* mm->page_table_lock is held. mmap_sem is not held */
252 static int swap_out_vma(struct mm_struct * mm, struct vm_area_struct * vma, unsigned long address, int count)
253 {
254         pgd_t *pgdir;
255         unsigned long end;
256
257         /* Don't swap out areas which are locked down */
258         if (vma->vm_flags & (VM_LOCKED|VM_RESERVED))
259                 return count;
260
261         pgdir = pgd_offset(mm, address);
262
263         end = vma->vm_end;
264         if (address >= end)
265                 BUG();
266         do {
267                 count = swap_out_pgd(mm, vma, pgdir, address, end, count);
268                 if (!count)
269                         break;
270                 address = (address + PGDIR_SIZE) & PGDIR_MASK;
271                 pgdir++;
272         } while (address && (address < end));
273         return count;
274 }
275
276 /*
277  * Returns non-zero if we scanned all `count' pages
278  */
279 static int swap_out_mm(struct mm_struct * mm, int count)
280 {
281         unsigned long address;
282         struct vm_area_struct* vma;
283
284         if (!count)
285                 return 1;
286         /*
287          * Go through process' page directory.
288          */
289
290         /*
291          * Find the proper vm-area after freezing the vma chain 
292          * and ptes.
293          */
294         spin_lock(&mm->page_table_lock);
295         address = mm->swap_address;
296         vma = find_vma(mm, address);
297         if (vma) {
298                 if (address < vma->vm_start)
299                         address = vma->vm_start;
300
301                 for (;;) {
302                         count = swap_out_vma(mm, vma, address, count);
303                         if (!count)
304                                 goto out_unlock;
305                         vma = vma->vm_next;
306                         if (!vma)
307                                 break;
308                         address = vma->vm_start;
309                 }
310         }
311         /* Reset to 0 when we reach the end of address space */
312         mm->swap_address = 0;
313
314 out_unlock:
315         spin_unlock(&mm->page_table_lock);
316         return !count;
317 }
318
319 #define SWAP_MM_SHIFT   4
320 #define SWAP_SHIFT      5
321 #define SWAP_MIN        8
322
323 static inline int swap_amount(struct mm_struct *mm)
324 {
325         int nr = mm->rss >> SWAP_SHIFT;
326         if (nr < SWAP_MIN) {
327                 nr = SWAP_MIN;
328                 if (nr > mm->rss)
329                         nr = mm->rss;
330         }
331         return nr;
332 }
333
334 /* Placeholder for swap_out(): may be updated by fork.c:mmput() */
335 struct mm_struct *swap_mm = &init_mm;
336
337 static void swap_out(unsigned int priority, int gfp_mask)
338 {
339         int counter;
340         int retval = 0;
341         struct mm_struct *mm = current->mm;
342
343         /* Always start by trying to penalize the process that is allocating memory */
344         if (mm)
345                 retval = swap_out_mm(mm, swap_amount(mm));
346
347         /* Then, look at the other mm's */
348         counter = (mmlist_nr << SWAP_MM_SHIFT) >> priority;
349         do {
350                 spin_lock(&mmlist_lock);
351                 mm = swap_mm;
352                 if (mm == &init_mm) {
353                         mm = list_entry(mm->mmlist.next, struct mm_struct, mmlist);
354                         if (mm == &init_mm)
355                                 goto empty;
356                 }
357                 /* Set pointer for next call to next in the list */
358                 swap_mm = list_entry(mm->mmlist.next, struct mm_struct, mmlist);
359
360                 /* Make sure the mm doesn't disappear when we drop the lock.. */
361                 atomic_inc(&mm->mm_users);
362                 spin_unlock(&mmlist_lock);
363
364                 /* Walk about 6% of the address space each time */
365                 retval |= swap_out_mm(mm, swap_amount(mm));
366                 mmput(mm);
367         } while (--counter >= 0);
368         return;
369
370 empty:
371         spin_unlock(&mmlist_lock);
372 }
373
374
375 /**
376  * reclaim_page -       reclaims one page from the inactive_clean list
377  * @zone: reclaim a page from this zone
378  *
379  * The pages on the inactive_clean can be instantly reclaimed.
380  * The tests look impressive, but most of the time we'll grab
381  * the first page of the list and exit successfully.
382  */
383 struct page * reclaim_page(zone_t * zone)
384 {
385         struct page * page = NULL;
386         struct list_head * page_lru;
387         int maxscan;
388
389         /*
390          * We only need the pagemap_lru_lock if we don't reclaim the page,
391          * but we have to grab the pagecache_lock before the pagemap_lru_lock
392          * to avoid deadlocks and most of the time we'll succeed anyway.
393          */
394         spin_lock(&pagecache_lock);
395         spin_lock(&pagemap_lru_lock);
396         maxscan = zone->inactive_clean_pages;
397         while ((page_lru = zone->inactive_clean_list.prev) !=
398                         &zone->inactive_clean_list && maxscan--) {
399                 page = list_entry(page_lru, struct page, lru);
400
401                 /* Wrong page on list?! (list corruption, should not happen) */
402                 if (!PageInactiveClean(page)) {
403                         printk("VM: reclaim_page, wrong page on list.\n");
404                         list_del(page_lru);
405                         page->zone->inactive_clean_pages--;
406                         continue;
407                 }
408
409                 /* Page is referenced? Clear and move to the head of the list.. */
410                 if (PageTestandClearReferenced(page)) {
411                         list_del(page_lru);
412                         list_add(page_lru, &zone->inactive_clean_list);
413                 }
414
415                 /* The page is dirty, or locked, move to inactive_dirty list. */
416                 if (page->buffers || PageDirty(page) || TryLockPage(page)) {
417                         del_page_from_inactive_clean_list(page);
418                         add_page_to_inactive_dirty_list(page);
419                         continue;
420                 }
421
422                 /* Page is in use?  Move it to the active list. */
423                 if (page_count(page) > 1) {
424                         UnlockPage(page);
425                         del_page_from_inactive_clean_list(page);
426                         add_page_to_active_list(page);
427                         continue;
428                 }
429
430                 /* OK, remove the page from the caches. */
431                 if (PageSwapCache(page)) {
432                         __delete_from_swap_cache(page);
433                         goto found_page;
434                 }
435
436                 if (page->mapping) {
437                         __remove_inode_page(page);
438                         goto found_page;
439                 }
440
441                 /* We should never ever get here. */
442                 printk(KERN_ERR "VM: reclaim_page, found unknown page\n");
443                 list_del(page_lru);
444                 zone->inactive_clean_pages--;
445                 UnlockPage(page);
446         }
447         /* Reset page pointer, maybe we encountered an unfreeable page. */
448         page = NULL;
449         goto out;
450
451 found_page:
452         memory_pressure++;
453         del_page_from_inactive_clean_list(page);
454         UnlockPage(page);
455         page->age = PAGE_AGE_START;
456         if (page_count(page) != 1)
457                 printk("VM: reclaim_page, found page with count %d!\n",
458                                 page_count(page));
459 out:
460         spin_unlock(&pagemap_lru_lock);
461         spin_unlock(&pagecache_lock);
462         return page;
463 }
464
465 /**
466  * page_launder - clean dirty inactive pages, move to inactive_clean list
467  * @gfp_mask: what operations we are allowed to do
468  * @sync: are we allowed to do synchronous IO in emergencies ?
469  *
470  * When this function is called, we are most likely low on free +
471  * inactive_clean pages. Since we want to refill those pages as
472  * soon as possible, we'll make two loops over the inactive list,
473  * one to move the already cleaned pages to the inactive_clean lists
474  * and one to (often asynchronously) clean the dirty inactive pages.
475  *
476  * In situations where kswapd cannot keep up, user processes will
477  * end up calling this function. Since the user process needs to
478  * have a page before it can continue with its allocation, we'll
479  * do synchronous page flushing in that case.
480  *
481  * This code used to be heavily inspired by the FreeBSD source code. 
482  * Thanks go out to Matthew Dillon.
483  */
484 #define CAN_DO_FS               (gfp_mask & __GFP_FS)
485 int page_launder(int gfp_mask, int sync)
486 {
487         int maxscan, cleaned_pages;
488         struct list_head * page_lru;
489         struct page * page;
490
491         cleaned_pages = 0;
492
493         /* Will we wait on IO? */
494         if (!sync)
495                 gfp_mask &= ~__GFP_WAIT;
496
497         spin_lock(&pagemap_lru_lock);
498         maxscan = nr_inactive_dirty_pages >> DEF_PRIORITY;
499         while ((page_lru = inactive_dirty_list.prev) != &inactive_dirty_list &&
500                                 maxscan-- > 0) {
501                 page = list_entry(page_lru, struct page, lru);
502
503                 /* Wrong page on list?! (list corruption, should not happen) */
504                 if (!PageInactiveDirty(page)) {
505                         printk("VM: page_launder, wrong page on list.\n");
506                         list_del(page_lru);
507                         nr_inactive_dirty_pages--;
508                         page->zone->inactive_dirty_pages--;
509                         continue;
510                 }
511
512                 /* Page is referenced? Clear and move to the head of the list.. */
513                 if (PageTestandClearReferenced(page)) {
514                         list_del(page_lru);
515                         list_add(page_lru, &inactive_dirty_list);
516                 }
517
518                 /* Page is in use?  Move it to the active list. */
519                 if ((!page->buffers && page_count(page) > 1) || page_ramdisk(page)) {
520                         del_page_from_inactive_dirty_list(page);
521                         add_page_to_active_list(page);
522                         continue;
523                 }
524
525                 /* 
526                  * If this zone has plenty of pages free,
527                  * don't spend time on cleaning it.
528                  */
529                 if (zone_free_plenty(page->zone)) {
530                         list_del(page_lru);
531                         list_add(page_lru, &inactive_dirty_list);
532                         continue;
533                 }
534
535                 /*
536                  * The page is locked. IO in progress?
537                  * Move it to the back of the list.
538                  */
539                 if (TryLockPage(page)) {
540                         list_del(page_lru);
541                         list_add(page_lru, &inactive_dirty_list);
542                         continue;
543                 }
544
545                 /*
546                  * Dirty swap-cache page? Write it out if
547                  * last copy..
548                  */
549                 if (PageDirty(page)) {
550                         int (*writepage)(struct page *);
551
552                         /* Can a page get here without page->mapping? */
553                         if (!page->mapping)
554                                 goto page_active;
555                         writepage = page->mapping->a_ops->writepage;
556                         if (!writepage)
557                                 goto page_active;
558
559                         /* Can't do it? Move it to the back of the list */
560                         if (!CAN_DO_FS) {
561                                 list_del(page_lru);
562                                 list_add(page_lru, &inactive_dirty_list);
563                                 UnlockPage(page);
564                                 continue;
565                         }
566
567                         /* OK, do a physical asynchronous write to swap.  */
568                         ClearPageDirty(page);
569                         page_cache_get(page);
570                         spin_unlock(&pagemap_lru_lock);
571
572                         writepage(page);
573                         page_cache_release(page);
574
575                         /* And re-start the thing.. */
576                         spin_lock(&pagemap_lru_lock);
577                         continue;
578                 }
579
580                 /*
581                  * If the page has buffers, try to free the buffer mappings
582                  * associated with this page. If we succeed we either free
583                  * the page (in case it was a buffercache only page) or we
584                  * move the page to the inactive_clean list.
585                  *
586                  * On the first round, we should free all previously cleaned
587                  * buffer pages
588                  */
589                 if (page->buffers) {
590                         int clearedbuf;
591                         int freed_page = 0;
592
593                         /*
594                          * Since we might be doing disk IO, we have to
595                          * drop the spinlock and take an extra reference
596                          * on the page so it doesn't go away from under us.
597                          */
598                         del_page_from_inactive_dirty_list(page);
599                         page_cache_get(page);
600                         spin_unlock(&pagemap_lru_lock);
601
602                         /* Try to free the page buffers. */
603                         clearedbuf = try_to_free_buffers(page, gfp_mask);
604
605                         /*
606                          * Re-take the spinlock. Note that we cannot
607                          * unlock the page yet since we're still
608                          * accessing the page_struct here...
609                          */
610                         spin_lock(&pagemap_lru_lock);
611
612                         /* The buffers were not freed. */
613                         if (!clearedbuf) {
614                                 add_page_to_inactive_dirty_list(page);
615
616                         /* The page was only in the buffer cache. */
617                         } else if (!page->mapping) {
618                                 atomic_dec(&buffermem_pages);
619                                 freed_page = 1;
620                                 cleaned_pages++;
621
622                         /* The page has more users besides the cache and us. */
623                         } else if (page_count(page) > 2) {
624                                 add_page_to_active_list(page);
625
626                         /* OK, we "created" a freeable page. */
627                         } else /* page->mapping && page_count(page) == 2 */ {
628                                 add_page_to_inactive_clean_list(page);
629                                 cleaned_pages++;
630                         }
631
632                         /*
633                          * Unlock the page and drop the extra reference.
634                          * We can only do it here because we are accessing
635                          * the page struct above.
636                          */
637                         UnlockPage(page);
638                         page_cache_release(page);
639
640                         continue;
641                 } else if (page->mapping && !PageDirty(page)) {
642                         /*
643                          * If a page had an extra reference in
644                          * deactivate_page(), we will find it here.
645                          * Now the page is really freeable, so we
646                          * move it to the inactive_clean list.
647                          */
648                         del_page_from_inactive_dirty_list(page);
649                         add_page_to_inactive_clean_list(page);
650                         UnlockPage(page);
651                         cleaned_pages++;
652                 } else {
653 page_active:
654                         /*
655                          * OK, we don't know what to do with the page.
656                          * It's no use keeping it here, so we move it to
657                          * the active list.
658                          */
659                         del_page_from_inactive_dirty_list(page);
660                         add_page_to_active_list(page);
661                         UnlockPage(page);
662                 }
663         }
664         spin_unlock(&pagemap_lru_lock);
665
666         /* Return the number of pages moved to the inactive_clean list. */
667         return cleaned_pages;
668 }
669
670 /**
671  * refill_inactive_scan - scan the active list and find pages to deactivate
672  * @priority: the priority at which to scan
673  *
674  * This function will scan a portion of the active list to find
675  * unused pages, those pages will then be moved to the inactive list.
676  */
677 static int refill_inactive_scan(unsigned int priority)
678 {
679         struct list_head * page_lru;
680         struct page * page;
681         int maxscan = nr_active_pages >> priority;
682         int page_active = 0;
683         int nr_deactivated = 0;
684
685         /* Take the lock while messing with the list... */
686         spin_lock(&pagemap_lru_lock);
687         while (maxscan-- > 0 && (page_lru = active_list.prev) != &active_list) {
688                 page = list_entry(page_lru, struct page, lru);
689
690                 /* Wrong page on list?! (list corruption, should not happen) */
691                 if (!PageActive(page)) {
692                         printk("VM: refill_inactive, wrong page on list.\n");
693                         list_del(page_lru);
694                         nr_active_pages--;
695                         continue;
696                 }
697
698                 /*
699                  * Do not deactivate pages from zones which 
700                  * have plenty inactive pages.
701                  */
702
703                 if (zone_inactive_plenty(page->zone)) {
704                         page_active = 1;
705                         goto skip_page;
706                 }
707
708                 /* Do aging on the pages. */
709                 if (PageTestandClearReferenced(page)) {
710                         age_page_up(page);
711                         page_active = 1;
712                 } else {
713                         age_page_down(page);
714                         /*
715                          * Since we don't hold a reference on the page
716                          * ourselves, we have to do our test a bit more
717                          * strict then deactivate_page(). This is needed
718                          * since otherwise the system could hang shuffling
719                          * unfreeable pages from the active list to the
720                          * inactive_dirty list and back again...
721                          *
722                          * SUBTLE: we can have buffer pages with count 1.
723                          */
724                         if (page_count(page) <= (page->buffers ? 2 : 1)) {
725                                 deactivate_page_nolock(page);
726                                 page_active = 0;
727                         } else {
728                                 page_active = 1;
729                         }
730                 }
731                 /*
732                  * If the page is still on the active list, move it
733                  * to the other end of the list. Otherwise we exit if
734                  * we have done enough work.
735                  */
736                 if (page_active || PageActive(page)) {
737 skip_page:
738                         list_del(page_lru);
739                         list_add(page_lru, &active_list);
740                 } else {
741                         nr_deactivated++;
742                 }
743         }
744         spin_unlock(&pagemap_lru_lock);
745
746         return nr_deactivated;
747 }
748
749 /*
750  * Check if there are zones with a severe shortage of free pages,
751  * or if all zones have a minor shortage.
752  */
753 int free_shortage(void)
754 {
755         pg_data_t *pgdat;
756         unsigned int global_free = 0;
757         unsigned int global_target = freepages.high;
758
759         /* Are we low on free pages anywhere? */
760         pgdat = pgdat_list;
761         do {
762                 int i;
763                 for(i = 0; i < MAX_NR_ZONES; i++) {
764                         zone_t *zone = pgdat->node_zones+ i;
765                         unsigned int free;
766
767                         if (!zone->size)
768                                 continue;
769
770                         free = zone->free_pages;
771                         free += zone->inactive_clean_pages;
772
773                         /* Local shortage? */
774                         if (free < zone->pages_low)
775                                 return 1;
776
777                         global_free += free;
778                 }
779                 pgdat = pgdat->node_next;
780         } while (pgdat);
781
782         /* Global shortage? */
783         return global_free < global_target;
784 }
785
786 /*
787  * Are we low on inactive pages globally or in any zone?
788  */
789 int inactive_shortage(void)
790 {
791         pg_data_t *pgdat;
792         unsigned int global_target = freepages.high + inactive_target;
793         unsigned int global_inactive = 0;
794
795         pgdat = pgdat_list;
796         do {
797                 int i;
798                 for(i = 0; i < MAX_NR_ZONES; i++) {
799                         zone_t *zone = pgdat->node_zones + i;
800                         unsigned int inactive;
801
802                         if (!zone->size)
803                                 continue;
804
805                         inactive  = zone->inactive_dirty_pages;
806                         inactive += zone->inactive_clean_pages;
807                         inactive += zone->free_pages;
808
809                         /* Local shortage? */
810                         if (inactive < zone->pages_high)
811                                 return 1;
812
813                         global_inactive += inactive;
814                 }
815                 pgdat = pgdat->node_next;
816         } while (pgdat);
817
818         /* Global shortage? */
819         return global_inactive < global_target;
820 }
821
822 /*
823  * Loop until we are no longer under an inactive or free
824  * shortage. Return 1 on success, 0 if we failed to get
825  * there even after "maxtry" loops.
826  */
827 #define INACTIVE_SHORTAGE 1
828 #define FREE_SHORTAGE 2
829 #define GENERAL_SHORTAGE 4
830 static int do_try_to_free_pages(unsigned int gfp_mask, int user)
831 {
832         int shortage = 0;
833         int maxtry;
834
835         /* Always walk at least the active queue when called */
836         refill_inactive_scan(DEF_PRIORITY);
837
838         maxtry = 1 << DEF_PRIORITY;
839         do {
840                 /*
841                  * If needed, we move pages from the active list
842                  * to the inactive list.
843                  */
844                 if (shortage & INACTIVE_SHORTAGE) {
845                         /* Walk the VM space for a bit.. */
846                         swap_out(DEF_PRIORITY, gfp_mask);
847
848                         /* ..and refill the inactive list */
849                         refill_inactive_scan(DEF_PRIORITY);
850                 }
851
852                 /*
853                  * If we're low on free pages, move pages from the
854                  * inactive_dirty list to the inactive_clean list.
855                  *
856                  * Usually bdflush will have pre-cleaned the pages
857                  * before we get around to moving them to the other
858                  * list, so this is a relatively cheap operation.
859                  */
860                 if (shortage & FREE_SHORTAGE)
861                         page_launder(gfp_mask, user);
862
863                 /*      
864                  * Reclaim unused slab cache if we were short on memory.
865                  */
866                 if (shortage & GENERAL_SHORTAGE) {
867                         shrink_dcache_memory(DEF_PRIORITY, gfp_mask);
868                         shrink_icache_memory(DEF_PRIORITY, gfp_mask);
869
870                         kmem_cache_reap(gfp_mask);
871                 }
872
873                 if (current->need_resched) {
874                          __set_current_state(TASK_RUNNING);
875                         schedule();
876                 }
877
878                 shortage = 0;
879                 if (inactive_shortage())
880                         shortage |= INACTIVE_SHORTAGE | GENERAL_SHORTAGE;
881                 if (free_shortage())
882                         shortage |= FREE_SHORTAGE | GENERAL_SHORTAGE;
883
884                 if (--maxtry <= 0)
885                         break;
886         } while (shortage);
887
888         /* Return success if we're not "totally short" */
889         return shortage != (FREE_SHORTAGE | INACTIVE_SHORTAGE | GENERAL_SHORTAGE);
890 }
891
892 DECLARE_WAIT_QUEUE_HEAD(kswapd_wait);
893 DECLARE_WAIT_QUEUE_HEAD(kswapd_done);
894
895 /*
896  * The background pageout daemon, started as a kernel thread
897  * from the init process. 
898  *
899  * This basically trickles out pages so that we have _some_
900  * free memory available even if there is no other activity
901  * that frees anything up. This is needed for things like routing
902  * etc, where we otherwise might have all activity going on in
903  * asynchronous contexts that cannot page things out.
904  *
905  * If there are applications that are active memory-allocators
906  * (most normal use), this basically shouldn't matter.
907  */
908 int kswapd(void *unused)
909 {
910         struct task_struct *tsk = current;
911
912         daemonize();
913         strcpy(tsk->comm, "kswapd");
914         sigfillset(&tsk->blocked);
915         
916         /*
917          * Tell the memory management that we're a "memory allocator",
918          * and that if we need more memory we should get access to it
919          * regardless (see "__alloc_pages()"). "kswapd" should
920          * never get caught in the normal page freeing logic.
921          *
922          * (Kswapd normally doesn't need memory anyway, but sometimes
923          * you need a small amount of memory in order to be able to
924          * page out something else, and this flag essentially protects
925          * us from recursively trying to free more memory as we're
926          * trying to free the first piece of memory in the first place).
927          */
928         tsk->flags |= PF_MEMALLOC;
929
930         /*
931          * Kswapd main loop.
932          */
933         for (;;) {
934                 static long recalc = 0;
935
936                 /* Once a second ... */
937                 if (time_after(jiffies, recalc + HZ)) {
938                         recalc = jiffies;
939
940                         /* Recalculate VM statistics. */
941                         recalculate_vm_stats();
942                 }
943
944                 if (!do_try_to_free_pages(GFP_KSWAPD, 1)) {
945                         if (out_of_memory())
946                                 oom_kill();
947                         continue;
948                 }
949
950                 run_task_queue(&tq_disk);
951                 interruptible_sleep_on_timeout(&kswapd_wait, HZ);
952         }
953 }
954
955 void wakeup_kswapd(void)
956 {
957         if (waitqueue_active(&kswapd_wait))
958                 wake_up_interruptible(&kswapd_wait);
959 }
960
961 /*
962  * Called by non-kswapd processes when they want more
963  * memory but are unable to sleep on kswapd because
964  * they might be holding some IO locks ...
965  */
966 int try_to_free_pages(unsigned int gfp_mask)
967 {
968         int ret = 1;
969
970         if (gfp_mask & __GFP_WAIT) {
971                 current->flags |= PF_MEMALLOC;
972                 ret = do_try_to_free_pages(gfp_mask, 1);
973                 current->flags &= ~PF_MEMALLOC;
974         }
975
976         return ret;
977 }
978
979 DECLARE_WAIT_QUEUE_HEAD(kreclaimd_wait);
980 /*
981  * Kreclaimd will move pages from the inactive_clean list to the
982  * free list, in order to keep atomic allocations possible under
983  * all circumstances.
984  */
985 int kreclaimd(void *unused)
986 {
987         struct task_struct *tsk = current;
988         pg_data_t *pgdat;
989
990         daemonize();
991         strcpy(tsk->comm, "kreclaimd");
992         sigfillset(&tsk->blocked);
993         current->flags |= PF_MEMALLOC;
994
995         while (1) {
996
997                 /*
998                  * We sleep until someone wakes us up from
999                  * page_alloc.c::__alloc_pages().
1000                  */
1001                 interruptible_sleep_on(&kreclaimd_wait);
1002
1003                 /*
1004                  * Move some pages from the inactive_clean lists to
1005                  * the free lists, if it is needed.
1006                  */
1007                 pgdat = pgdat_list;
1008                 do {
1009                         int i;
1010                         for(i = 0; i < MAX_NR_ZONES; i++) {
1011                                 zone_t *zone = pgdat->node_zones + i;
1012                                 if (!zone->size)
1013                                         continue;
1014
1015                                 while (zone->free_pages < zone->pages_low) {
1016                                         struct page * page;
1017                                         page = reclaim_page(zone);
1018                                         if (!page)
1019                                                 break;
1020                                         __free_page(page);
1021                                 }
1022                         }
1023                         pgdat = pgdat->node_next;
1024                 } while (pgdat);
1025         }
1026 }
1027
1028
1029 static int __init kswapd_init(void)
1030 {
1031         printk("Starting kswapd v1.8\n");
1032         swap_setup();
1033         kernel_thread(kswapd, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
1034         kernel_thread(kreclaimd, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
1035         return 0;
1036 }
1037
1038 module_init(kswapd_init)