1/* 2 * arch/m68k/atari/stram.c: Functions for ST-RAM allocations 3 * 4 * Copyright 1994-97 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> 5 * 6 * This file is subject to the terms and conditions of the GNU General Public 7 * License. See the file COPYING in the main directory of this archive 8 * for more details. 9 */ 10 11#include <linux/config.h> 12#include <linux/types.h> 13#include <linux/kernel.h> 14#include <linux/mm.h> 15#include <linux/kdev_t.h> 16#include <linux/major.h> 17#include <linux/init.h> 18#include <linux/swap.h> 19#include <linux/slab.h> 20#include <linux/vmalloc.h> 21#include <linux/pagemap.h> 22#include <linux/shm.h> 23#include <linux/bootmem.h> 24 25#include <asm/setup.h> 26#include <asm/machdep.h> 27#include <asm/page.h> 28#include <asm/pgtable.h> 29#include <asm/atarihw.h> 30#include <asm/atari_stram.h> 31#include <asm/io.h> 32#include <asm/semaphore.h> 33 34 35#ifdef CONFIG_STRAM_SWAP 36#define MAJOR_NR Z2RAM_MAJOR 37#define do_z2_request do_stram_request 38#include <linux/blk.h> 39#undef DEVICE_NAME 40#define DEVICE_NAME "stram" 41#endif 42 43#undef DEBUG 44 45#ifdef DEBUG 46#define DPRINTK(fmt,args...) printk( fmt, ##args ) 47#else 48#define DPRINTK(fmt,args...) 49#endif 50 51#if defined(CONFIG_PROC_FS) && defined(CONFIG_STRAM_PROC) 52/* abbrev for the && above... */ 53#define DO_PROC 54#include <linux/proc_fs.h> 55#endif 56 57/* Pre-swapping comments: 58 * 59 * ++roman: 60 * 61 * New version of ST-Ram buffer allocation. Instead of using the 62 * 1 MB - 4 KB that remain when the ST-Ram chunk starts at $1000 63 * (1 MB granularity!), such buffers are reserved like this: 64 * 65 * - If the kernel resides in ST-Ram anyway, we can take the buffer 66 * from behind the current kernel data space the normal way 67 * (incrementing start_mem). 68 * 69 * - If the kernel is in TT-Ram, stram_init() initializes start and 70 * end of the available region. Buffers are allocated from there 71 * and mem_init() later marks the such used pages as reserved. 72 * Since each TT-Ram chunk is at least 4 MB in size, I hope there 73 * won't be an overrun of the ST-Ram region by normal kernel data 74 * space. 75 * 76 * For that, ST-Ram may only be allocated while kernel initialization 77 * is going on, or exactly: before mem_init() is called. There is also 78 * no provision now for freeing ST-Ram buffers. It seems that isn't 79 * really needed. 80 * 81 */ 82 83/* 84 * New Nov 1997: Use ST-RAM as swap space! 85 * 86 * In the past, there were often problems with modules that require ST-RAM 87 * buffers. Such drivers have to use __get_dma_pages(), which unfortunately 88 * often isn't very successful in allocating more than 1 page :-( [1] The net 89 * result was that most of the time you couldn't insmod such modules (ataflop, 90 * ACSI, SCSI on Falcon, Atari internal framebuffer, not to speak of acsi_slm, 91 * which needs a 1 MB buffer... :-). 92 * 93 * To overcome this limitation, ST-RAM can now be turned into a very 94 * high-speed swap space. If a request for an ST-RAM buffer comes, the kernel 95 * now tries to unswap some pages on that swap device to make some free (and 96 * contiguous) space. This works much better in comparison to 97 * __get_dma_pages(), since used swap pages can be selectively freed by either 98 * moving them to somewhere else in swap space, or by reading them back into 99 * system memory. Ok, there operation of unswapping isn't really cheap (for 100 * each page, one has to go through the page tables of all processes), but it 101 * doesn't happen that often (only when allocation ST-RAM, i.e. when loading a 102 * module that needs ST-RAM). But it at least makes it possible to load such 103 * modules! 104 * 105 * It could also be that overall system performance increases a bit due to 106 * ST-RAM swapping, since slow ST-RAM isn't used anymore for holding data or 107 * executing code in. It's then just a (very fast, compared to disk) back 108 * storage for not-so-often needed data. (But this effect must be compared 109 * with the loss of total memory...) Don't know if the effect is already 110 * visible on a TT, where the speed difference between ST- and TT-RAM isn't 111 * that dramatic, but it should on machines where TT-RAM is really much faster 112 * (e.g. Afterburner). 113 * 114 * [1]: __get_free_pages() does a fine job if you only want one page, but if 115 * you want more (contiguous) pages, it can give you such a block only if 116 * there's already a free one. The algorithm can't try to free buffers or swap 117 * out something in order to make more free space, since all that page-freeing 118 * mechanisms work "target-less", i.e. they just free something, but not in a 119 * specific place. I.e., __get_free_pages() can't do anything to free 120 * *adjacent* pages :-( This situation becomes even worse for DMA memory, 121 * since the freeing algorithms are also blind to DMA capability of pages. 122 */ 123 124/* 1998-10-20: ++andreas 125 unswap_by_move disabled because it does not handle swapped shm pages. 126*/ 127 128/* 2000-05-01: ++andreas 129 Integrated with bootmem. Remove all traces of unswap_by_move. 130*/ 131 132#ifdef CONFIG_STRAM_SWAP 133#define ALIGN_IF_SWAP(x) PAGE_ALIGN(x) 134#else 135#define ALIGN_IF_SWAP(x) (x) 136#endif 137 138/* get index of swap page at address 'addr' */ 139#define SWAP_NR(addr) (((addr) - swap_start) >> PAGE_SHIFT) 140 141/* get address of swap page #'nr' */ 142#define SWAP_ADDR(nr) (swap_start + ((nr) << PAGE_SHIFT)) 143 144/* get number of pages for 'n' bytes (already page-aligned) */ 145#define N_PAGES(n) ((n) >> PAGE_SHIFT) 146 147/* The following two numbers define the maximum fraction of ST-RAM in total 148 * memory, below that the kernel would automatically use ST-RAM as swap 149 * space. This decision can be overriden with stram_swap= */ 150#define MAX_STRAM_FRACTION_NOM 1 151#define MAX_STRAM_FRACTION_DENOM 3 152 153/* Start and end (virtual) of ST-RAM */ 154static void *stram_start, *stram_end; 155 156/* set after memory_init() executed and allocations via start_mem aren't 157 * possible anymore */ 158static int mem_init_done = 0; 159 160/* set if kernel is in ST-RAM */ 161static int kernel_in_stram; 162 163typedef struct stram_block { 164 struct stram_block *next; 165 void *start; 166 unsigned long size; 167 unsigned flags; 168 const char *owner; 169} BLOCK; 170 171/* values for flags field */ 172#define BLOCK_FREE 0x01 /* free structure in the BLOCKs pool */ 173#define BLOCK_KMALLOCED 0x02 /* structure allocated by kmalloc() */ 174#define BLOCK_GFP 0x08 /* block allocated with __get_dma_pages() */ 175#define BLOCK_INSWAP 0x10 /* block allocated in swap space */ 176 177/* list of allocated blocks */ 178static BLOCK *alloc_list = NULL; 179 180/* We can't always use kmalloc() to allocate BLOCK structures, since 181 * stram_alloc() can be called rather early. So we need some pool of 182 * statically allocated structures. 20 of them is more than enough, so in most 183 * cases we never should need to call kmalloc(). */ 184#define N_STATIC_BLOCKS 20 185static BLOCK static_blocks[N_STATIC_BLOCKS]; 186 187#ifdef CONFIG_STRAM_SWAP 188/* max. number of bytes to use for swapping 189 * 0 = no ST-RAM swapping 190 * -1 = do swapping (to whole ST-RAM) if it's less than MAX_STRAM_FRACTION of 191 * total memory 192 */ 193static int max_swap_size = -1; 194 195/* start and end of swapping area */ 196static void *swap_start, *swap_end; 197 198/* The ST-RAM's swap info structure */ 199static struct swap_info_struct *stram_swap_info; 200 201/* The ST-RAM's swap type */ 202static int stram_swap_type; 203 204/* Semaphore for get_stram_region. */ 205static DECLARE_MUTEX(stram_swap_sem); 206 207/* major and minor device number of the ST-RAM device; for the major, we use 208 * the same as Amiga z2ram, which is really similar and impossible on Atari, 209 * and for the minor a relatively odd number to avoid the user creating and 210 * using that device. */ 211#define STRAM_MAJOR Z2RAM_MAJOR 212#define STRAM_MINOR 13 213 214/* Some impossible pointer value */ 215#define MAGIC_FILE_P (struct file *)0xffffdead 216 217#ifdef DO_PROC 218static unsigned stat_swap_read = 0; 219static unsigned stat_swap_write = 0; 220static unsigned stat_swap_force = 0; 221#endif /* DO_PROC */ 222 223#endif /* CONFIG_STRAM_SWAP */ 224 225/***************************** Prototypes *****************************/ 226 227#ifdef CONFIG_STRAM_SWAP 228static int swap_init(void *start_mem, void *swap_data); 229static void *get_stram_region( unsigned long n_pages ); 230static void free_stram_region( unsigned long offset, unsigned long n_pages 231 ); 232static int in_some_region(void *addr); 233static unsigned long find_free_region( unsigned long n_pages, unsigned long 234 *total_free, unsigned long 235 *region_free ); 236static void do_stram_request(request_queue_t *); 237static int stram_open( struct inode *inode, struct file *filp ); 238static int stram_release( struct inode *inode, struct file *filp ); 239static void reserve_region(void *start, void *end); 240#endif 241static BLOCK *add_region( void *addr, unsigned long size ); 242static BLOCK *find_region( void *addr ); 243static int remove_region( BLOCK *block ); 244 245/************************* End of Prototypes **************************/ 246 247 248/* ------------------------------------------------------------------------ */ 249/* Public Interface */ 250/* ------------------------------------------------------------------------ */ 251 252/* 253 * This init function is called very early by atari/config.c 254 * It initializes some internal variables needed for stram_alloc() 255 */ 256void __init atari_stram_init(void) 257{ 258 int i; 259 260 /* initialize static blocks */ 261 for( i = 0; i < N_STATIC_BLOCKS; ++i ) 262 static_blocks[i].flags = BLOCK_FREE; 263 264 /* determine whether kernel code resides in ST-RAM (then ST-RAM is the 265 * first memory block at virtual 0x0) */ 266 stram_start = phys_to_virt(0); 267 kernel_in_stram = (stram_start == 0); 268 269 for( i = 0; i < m68k_num_memory; ++i ) { 270 if (m68k_memory[i].addr == 0) { 271 /* skip first 2kB or page (supervisor-only!) */ 272 stram_end = stram_start + m68k_memory[i].size; 273 return; 274 } 275 } 276 /* Should never come here! (There is always ST-Ram!) */ 277 panic( "atari_stram_init: no ST-RAM found!" ); 278} 279 280 281/* 282 * This function is called from setup_arch() to reserve the pages needed for 283 * ST-RAM management. 284 */ 285void __init atari_stram_reserve_pages(void *start_mem) 286{ 287#ifdef CONFIG_STRAM_SWAP 288 /* if max_swap_size is negative (i.e. no stram_swap= option given), 289 * determine at run time whether to use ST-RAM swapping */ 290 if (max_swap_size < 0) 291 /* Use swapping if ST-RAM doesn't make up more than MAX_STRAM_FRACTION 292 * of total memory. In that case, the max. size is set to 16 MB, 293 * because ST-RAM can never be bigger than that. 294 * Also, never use swapping on a Hades, there's no separate ST-RAM in 295 * that machine. */ 296 max_swap_size = 297 (!MACH_IS_HADES && 298 (N_PAGES(stram_end-stram_start)*MAX_STRAM_FRACTION_DENOM <= 299 ((unsigned long)high_memory>>PAGE_SHIFT)*MAX_STRAM_FRACTION_NOM)) ? 16*1024*1024 : 0; 300 DPRINTK( "atari_stram_reserve_pages: max_swap_size = %d\n", max_swap_size ); 301#endif 302 303 /* always reserve first page of ST-RAM, the first 2 kB are 304 * supervisor-only! */ 305 if (!kernel_in_stram) 306 reserve_bootmem (0, PAGE_SIZE); 307 308#ifdef CONFIG_STRAM_SWAP 309 { 310 void *swap_data; 311 312 start_mem = (void *) PAGE_ALIGN ((unsigned long) start_mem); 313 /* determine first page to use as swap: if the kernel is 314 in TT-RAM, this is the first page of (usable) ST-RAM; 315 otherwise just use the end of kernel data (= start_mem) */ 316 swap_start = !kernel_in_stram ? stram_start + PAGE_SIZE : start_mem; 317 /* decrement by one page, rest of kernel assumes that first swap page 318 * is always reserved and maybe doesn't handle SWP_ENTRY == 0 319 * correctly */ 320 swap_start -= PAGE_SIZE; 321 swap_end = stram_end; 322 if (swap_end-swap_start > max_swap_size) 323 swap_end = swap_start + max_swap_size; 324 DPRINTK( "atari_stram_reserve_pages: swapping enabled; " 325 "swap=%p-%p\n", swap_start, swap_end); 326 327 /* reserve some amount of memory for maintainance of 328 * swapping itself: one page for each 2048 (PAGE_SIZE/2) 329 * swap pages. (2 bytes for each page) */ 330 swap_data = start_mem; 331 start_mem += ((SWAP_NR(swap_end) + PAGE_SIZE/2 - 1) 332 >> (PAGE_SHIFT-1)) << PAGE_SHIFT; 333 /* correct swap_start if necessary */ 334 if (swap_start + PAGE_SIZE == swap_data) 335 swap_start = start_mem - PAGE_SIZE; 336 337 if (!swap_init( start_mem, swap_data )) { 338 printk( KERN_ERR "ST-RAM swap space initialization failed\n" ); 339 max_swap_size = 0; 340 return; 341 } 342 /* reserve region for swapping meta-data */ 343 reserve_region(swap_data, start_mem); 344 /* reserve swapping area itself */ 345 reserve_region(swap_start + PAGE_SIZE, swap_end); 346 347 /* 348 * If the whole ST-RAM is used for swapping, there are no allocatable 349 * dma pages left. But unfortunately, some shared parts of the kernel 350 * (particularily the SCSI mid-level) call __get_dma_pages() 351 * unconditionally :-( These calls then fail, and scsi.c even doesn't 352 * check for NULL return values and just crashes. The quick fix for 353 * this (instead of doing much clean up work in the SCSI code) is to 354 * pretend all pages are DMA-able by setting mach_max_dma_address to 355 * ULONG_MAX. This doesn't change any functionality so far, since 356 * get_dma_pages() shouldn't be used on Atari anyway anymore (better 357 * use atari_stram_alloc()), and the Atari SCSI drivers don't need DMA 358 * memory. But unfortunately there's now no kind of warning (even not 359 * a NULL return value) if you use get_dma_pages() nevertheless :-( 360 * You just will get non-DMA-able memory... 361 */ 362 mach_max_dma_address = 0xffffffff; 363 } 364#endif 365} 366 367void atari_stram_mem_init_hook (void) 368{ 369 mem_init_done = 1; 370} 371 372 373/* 374 * This is main public interface: somehow allocate a ST-RAM block 375 * There are three strategies: 376 * 377 * - If we're before mem_init(), we have to make a static allocation. The 378 * region is taken in the kernel data area (if the kernel is in ST-RAM) or 379 * from the start of ST-RAM (if the kernel is in TT-RAM) and added to the 380 * rsvd_stram_* region. The ST-RAM is somewhere in the middle of kernel 381 * address space in the latter case. 382 * 383 * - If mem_init() already has been called and ST-RAM swapping is enabled, 384 * try to get the memory from the (pseudo) swap-space, either free already 385 * or by moving some other pages out of the swap. 386 * 387 * - If mem_init() already has been called, and ST-RAM swapping is not 388 * enabled, the only possibility is to try with __get_dma_pages(). This has 389 * the disadvantage that it's very hard to get more than 1 page, and it is 390 * likely to fail :-( 391 * 392 */ 393void *atari_stram_alloc(long size, const char *owner) 394{ 395 void *addr = NULL; 396 BLOCK *block; 397 int flags; 398 399 DPRINTK("atari_stram_alloc(size=%08lx,owner=%s)\n", size, owner); 400 401 size = ALIGN_IF_SWAP(size); 402 DPRINTK( "atari_stram_alloc: rounded size = %08lx\n", size ); 403#ifdef CONFIG_STRAM_SWAP 404 if (max_swap_size) { 405 /* If swapping is active: make some free space in the swap 406 "device". */ 407 DPRINTK( "atari_stram_alloc: after mem_init, swapping ok, " 408 "calling get_region\n" ); 409 addr = get_stram_region( N_PAGES(size) ); 410 flags = BLOCK_INSWAP; 411 } 412 else 413#endif 414 if (!mem_init_done) 415 return alloc_bootmem_low(size); 416 else { 417 /* After mem_init() and no swapping: can only resort to 418 * __get_dma_pages() */ 419 addr = (void *)__get_dma_pages(GFP_KERNEL, get_order(size)); 420 flags = BLOCK_GFP; 421 DPRINTK( "atari_stram_alloc: after mem_init, swapping off, " 422 "get_pages=%p\n", addr ); 423 } 424 425 if (addr) { 426 if (!(block = add_region( addr, size ))) { 427 /* out of memory for BLOCK structure :-( */ 428 DPRINTK( "atari_stram_alloc: out of mem for BLOCK -- " 429 "freeing again\n" ); 430#ifdef CONFIG_STRAM_SWAP 431 if (flags == BLOCK_INSWAP) 432 free_stram_region( SWAP_NR(addr), N_PAGES(size) ); 433 else 434#endif 435 free_pages((unsigned long)addr, get_order(size)); 436 return( NULL ); 437 } 438 block->owner = owner; 439 block->flags |= flags; 440 } 441 return( addr ); 442} 443 444void atari_stram_free( void *addr ) 445 446{ 447 BLOCK *block; 448 449 DPRINTK( "atari_stram_free(addr=%p)\n", addr ); 450 451 if (!(block = find_region( addr ))) { 452 printk( KERN_ERR "Attempt to free non-allocated ST-RAM block at %p " 453 "from %p\n", addr, __builtin_return_address(0) ); 454 return; 455 } 456 DPRINTK( "atari_stram_free: found block (%p): size=%08lx, owner=%s, " 457 "flags=%02x\n", block, block->size, block->owner, block->flags ); 458 459#ifdef CONFIG_STRAM_SWAP 460 if (!max_swap_size) { 461#endif 462 if (block->flags & BLOCK_GFP) { 463 DPRINTK("atari_stram_free: is kmalloced, order_size=%d\n", 464 get_order(block->size)); 465 free_pages((unsigned long)addr, get_order(block->size)); 466 } 467 else 468 goto fail; 469#ifdef CONFIG_STRAM_SWAP 470 } 471 else if (block->flags & BLOCK_INSWAP) { 472 DPRINTK( "atari_stram_free: is swap-alloced\n" ); 473 free_stram_region( SWAP_NR(block->start), N_PAGES(block->size) ); 474 } 475 else 476 goto fail; 477#endif 478 remove_region( block ); 479 return; 480 481 fail: 482 printk( KERN_ERR "atari_stram_free: cannot free block at %p " 483 "(called from %p)\n", addr, __builtin_return_address(0) ); 484} 485 486 487#ifdef CONFIG_STRAM_SWAP 488 489 490/* ------------------------------------------------------------------------ */ 491/* Main Swapping Functions */ 492/* ------------------------------------------------------------------------ */ 493 494 495/* 496 * Initialize ST-RAM swap device 497 * (lots copied and modified from sys_swapon() in mm/swapfile.c) 498 */ 499static int __init swap_init(void *start_mem, void *swap_data) 500{ 501 static struct dentry fake_dentry; 502 static struct vfsmount fake_vfsmnt; 503 struct swap_info_struct *p; 504 struct inode swap_inode; 505 unsigned int type; 506 void *addr; 507 int i, j, k, prev; 508 509 DPRINTK("swap_init(start_mem=%p, swap_data=%p)\n", 510 start_mem, swap_data); 511 512 /* need at least one page for swapping to (and this also isn't very 513 * much... :-) */ 514 if (swap_end - swap_start < 2*PAGE_SIZE) { 515 printk( KERN_WARNING "stram_swap_init: swap space too small\n" ); 516 return( 0 ); 517 } 518 519 /* find free slot in swap_info */ 520 for( p = swap_info, type = 0; type < nr_swapfiles; type++, p++ ) 521 if (!(p->flags & SWP_USED)) 522 break; 523 if (type >= MAX_SWAPFILES) { 524 printk( KERN_WARNING "stram_swap_init: max. number of " 525 "swap devices exhausted\n" ); 526 return( 0 ); 527 } 528 if (type >= nr_swapfiles) 529 nr_swapfiles = type+1; 530 531 stram_swap_info = p; 532 stram_swap_type = type; 533 534 /* fake some dir cache entries to give us some name in /dev/swaps */ 535 fake_dentry.d_parent = &fake_dentry; 536 fake_dentry.d_name.name = "stram (internal)"; 537 fake_dentry.d_name.len = 16; 538 fake_vfsmnt.mnt_parent = &fake_vfsmnt; 539 540 p->flags = SWP_USED; 541 p->swap_file = &fake_dentry; 542 p->swap_vfsmnt = &fake_vfsmnt; 543 p->swap_device = 0; 544 p->swap_map = swap_data; 545 p->cluster_nr = 0; 546 p->next = -1; 547 p->prio = 0x7ff0; /* a rather high priority, but not the higest 548 * to give the user a chance to override */ 549 550 /* call stram_open() directly, avoids at least the overhead in 551 * constructing a dummy file structure... */ 552 p->swap_device = MKDEV( STRAM_MAJOR, STRAM_MINOR ); 553 swap_inode.i_rdev = p->swap_device; 554 stram_open( &swap_inode, MAGIC_FILE_P ); 555 p->max = SWAP_NR(swap_end); 556 557 /* initialize swap_map: set regions that are already allocated or belong 558 * to kernel data space to SWAP_MAP_BAD, otherwise to free */ 559 j = 0; /* # of free pages */ 560 k = 0; /* # of already allocated pages (from pre-mem_init stram_alloc()) */ 561 p->lowest_bit = 0; 562 p->highest_bit = 0; 563 for( i = 1, addr = SWAP_ADDR(1); i < p->max; 564 i++, addr += PAGE_SIZE ) { 565 if (in_some_region( addr )) { 566 p->swap_map[i] = SWAP_MAP_BAD; 567 ++k; 568 } 569 else if (kernel_in_stram && addr < start_mem ) { 570 p->swap_map[i] = SWAP_MAP_BAD; 571 } 572 else { 573 p->swap_map[i] = 0; 574 ++j; 575 if (!p->lowest_bit) p->lowest_bit = i; 576 p->highest_bit = i; 577 } 578 } 579 /* first page always reserved (and doesn't really belong to swap space) */ 580 p->swap_map[0] = SWAP_MAP_BAD; 581 582 /* now swapping to this device ok */ 583 p->pages = j + k; 584 swap_list_lock(); 585 nr_swap_pages += j; 586 p->flags = SWP_WRITEOK; 587 588 /* insert swap space into swap_list */ 589 prev = -1; 590 for (i = swap_list.head; i >= 0; i = swap_info[i].next) { 591 if (p->prio >= swap_info[i].prio) { 592 break; 593 } 594 prev = i; 595 } 596 p->next = i; 597 if (prev < 0) { 598 swap_list.head = swap_list.next = p - swap_info; 599 } else { 600 swap_info[prev].next = p - swap_info; 601 } 602 swap_list_unlock(); 603 604 printk( KERN_INFO "Using %dk (%d pages) of ST-RAM as swap space.\n", 605 p->pages << 2, p->pages ); 606 return( 1 ); 607} 608 609 610/* 611 * The swap entry has been read in advance, and we return 1 to indicate 612 * that the page has been used or is no longer needed. 613 * 614 * Always set the resulting pte to be nowrite (the same as COW pages 615 * after one process has exited). We don't know just how many PTEs will 616 * share this swap entry, so be cautious and let do_wp_page work out 617 * what to do if a write is requested later. 618 */ 619static inline void unswap_pte(struct vm_area_struct * vma, unsigned long 620 address, pte_t *dir, swp_entry_t entry, 621 struct page *page) 622{ 623 pte_t pte = *dir; 624 625 if (pte_none(pte)) 626 return; 627 if (pte_present(pte)) { 628 /* If this entry is swap-cached, then page must already 629 hold the right address for any copies in physical 630 memory */ 631 if (pte_page(pte) != page) 632 return; 633 /* We will be removing the swap cache in a moment, so... */ 634 set_pte(dir, pte_mkdirty(pte)); 635 return; 636 } 637 if (pte_val(pte) != entry.val) 638 return; 639 640 DPRINTK("unswap_pte: replacing entry %08lx by new page %p", 641 entry.val, page); 642 set_pte(dir, pte_mkdirty(mk_pte(page, vma->vm_page_prot))); 643 swap_free(entry); 644 get_page(page); 645 ++vma->vm_mm->rss; 646} 647 648static inline void unswap_pmd(struct vm_area_struct * vma, pmd_t *dir, 649 unsigned long address, unsigned long size, 650 unsigned long offset, swp_entry_t entry, 651 struct page *page) 652{ 653 pte_t * pte; 654 unsigned long end; 655 656 if (pmd_none(*dir)) 657 return; 658 if (pmd_bad(*dir)) { 659 pmd_ERROR(*dir); 660 pmd_clear(dir); 661 return; 662 } 663 pte = pte_offset(dir, address); 664 offset += address & PMD_MASK; 665 address &= ~PMD_MASK; 666 end = address + size; 667 if (end > PMD_SIZE) 668 end = PMD_SIZE; 669 do { 670 unswap_pte(vma, offset+address-vma->vm_start, pte, entry, page); 671 address += PAGE_SIZE; 672 pte++; 673 } while (address < end); 674} 675 676static inline void unswap_pgd(struct vm_area_struct * vma, pgd_t *dir, 677 unsigned long address, unsigned long size, 678 swp_entry_t entry, struct page *page) 679{ 680 pmd_t * pmd; 681 unsigned long offset, end; 682 683 if (pgd_none(*dir)) 684 return; 685 if (pgd_bad(*dir)) { 686 pgd_ERROR(*dir); 687 pgd_clear(dir); 688 return; 689 } 690 pmd = pmd_offset(dir, address); 691 offset = address & PGDIR_MASK; 692 address &= ~PGDIR_MASK; 693 end = address + size; 694 if (end > PGDIR_SIZE) 695 end = PGDIR_SIZE; 696 do { 697 unswap_pmd(vma, pmd, address, end - address, offset, entry, 698 page); 699 address = (address + PMD_SIZE) & PMD_MASK; 700 pmd++; 701 } while (address < end); 702} 703 704static void unswap_vma(struct vm_area_struct * vma, pgd_t *pgdir, 705 swp_entry_t entry, struct page *page) 706{ 707 unsigned long start = vma->vm_start, end = vma->vm_end; 708 709 do { 710 unswap_pgd(vma, pgdir, start, end - start, entry, page); 711 start = (start + PGDIR_SIZE) & PGDIR_MASK; 712 pgdir++; 713 } while (start < end); 714} 715 716static void unswap_process(struct mm_struct * mm, swp_entry_t entry, 717 struct page *page) 718{ 719 struct vm_area_struct* vma; 720 721 /* 722 * Go through process' page directory. 723 */ 724 if (!mm) 725 return; 726 for (vma = mm->mmap; vma; vma = vma->vm_next) { 727 pgd_t * pgd = pgd_offset(mm, vma->vm_start); 728 unswap_vma(vma, pgd, entry, page); 729 } 730} 731 732 733static int unswap_by_read(unsigned short *map, unsigned long max, 734 unsigned long start, unsigned long n_pages) 735{ 736 struct task_struct *p; 737 struct page *page; 738 swp_entry_t entry; 739 unsigned long i; 740 741 DPRINTK( "unswapping %lu..%lu by reading in\n", 742 start, start+n_pages-1 ); 743 744 for( i = start; i < start+n_pages; ++i ) { 745 if (map[i] == SWAP_MAP_BAD) { 746 printk( KERN_ERR "get_stram_region: page %lu already " 747 "reserved??\n", i ); 748 continue; 749 } 750 751 if (map[i]) { 752 entry = SWP_ENTRY(stram_swap_type, i); 753 DPRINTK("unswap: map[i=%lu]=%u nr_swap=%u\n", 754 i, map[i], nr_swap_pages); 755 756 swap_device_lock(stram_swap_info); 757 map[i]++; 758 swap_device_unlock(stram_swap_info); 759 /* Get a page for the entry, using the existing 760 swap cache page if there is one. Otherwise, 761 get a clean page and read the swap into it. */ 762 page = read_swap_cache_async(entry); 763 if (!page) { 764 swap_free(entry); 765 return -ENOMEM; 766 } 767 read_lock(&tasklist_lock); 768 for_each_task(p) 769 unswap_process(p->mm, entry, page); 770 read_unlock(&tasklist_lock); 771 shmem_unuse(entry, page); 772 /* Now get rid of the extra reference to the 773 temporary page we've been using. */ 774 if (PageSwapCache(page)) 775 delete_from_swap_cache(page); 776 __free_page(page); 777 #ifdef DO_PROC 778 stat_swap_force++; 779 #endif 780 } 781 782 DPRINTK( "unswap: map[i=%lu]=%u nr_swap=%u\n", 783 i, map[i], nr_swap_pages ); 784 swap_list_lock(); 785 swap_device_lock(stram_swap_info); 786 map[i] = SWAP_MAP_BAD; 787 if (stram_swap_info->lowest_bit == i) 788 stram_swap_info->lowest_bit++; 789 if (stram_swap_info->highest_bit == i) 790 stram_swap_info->highest_bit--; 791 --nr_swap_pages; 792 swap_device_unlock(stram_swap_info); 793 swap_list_unlock(); 794 } 795 796 return 0; 797} 798 799/* 800 * reserve a region in ST-RAM swap space for an allocation 801 */ 802static void *get_stram_region( unsigned long n_pages ) 803{ 804 unsigned short *map = stram_swap_info->swap_map; 805 unsigned long max = stram_swap_info->max; 806 unsigned long start, total_free, region_free; 807 int err; 808 void *ret = NULL; 809 810 DPRINTK( "get_stram_region(n_pages=%lu)\n", n_pages ); 811 812 down(&stram_swap_sem); 813 814 /* disallow writing to the swap device now */ 815 stram_swap_info->flags = SWP_USED; 816 817 /* find a region of n_pages pages in the swap space including as much free 818 * pages as possible (and excluding any already-reserved pages). */ 819 if (!(start = find_free_region( n_pages, &total_free, ®ion_free ))) 820 goto end; 821 DPRINTK( "get_stram_region: region starts at %lu, has %lu free pages\n", 822 start, region_free ); 823 824 err = unswap_by_read(map, max, start, n_pages); 825 if (err) 826 goto end; 827 828 ret = SWAP_ADDR(start); 829 end: 830 /* allow using swap device again */ 831 stram_swap_info->flags = SWP_WRITEOK; 832 up(&stram_swap_sem); 833 DPRINTK( "get_stram_region: returning %p\n", ret ); 834 return( ret ); 835} 836 837 838/* 839 * free a reserved region in ST-RAM swap space 840 */ 841static void free_stram_region( unsigned long offset, unsigned long n_pages ) 842{ 843 unsigned short *map = stram_swap_info->swap_map; 844 845 DPRINTK( "free_stram_region(offset=%lu,n_pages=%lu)\n", offset, n_pages ); 846 847 if (offset < 1 || offset + n_pages > stram_swap_info->max) { 848 printk( KERN_ERR "free_stram_region: Trying to free non-ST-RAM\n" ); 849 return; 850 } 851 852 swap_list_lock(); 853 swap_device_lock(stram_swap_info); 854 /* un-reserve the freed pages */ 855 for( ; n_pages > 0; ++offset, --n_pages ) { 856 if (map[offset] != SWAP_MAP_BAD) 857 printk( KERN_ERR "free_stram_region: Swap page %lu was not " 858 "reserved\n", offset ); 859 map[offset] = 0; 860 } 861 862 /* update swapping meta-data */ 863 if (offset < stram_swap_info->lowest_bit) 864 stram_swap_info->lowest_bit = offset; 865 if (offset+n_pages-1 > stram_swap_info->highest_bit) 866 stram_swap_info->highest_bit = offset+n_pages-1; 867 if (stram_swap_info->prio > swap_info[swap_list.next].prio) 868 swap_list.next = swap_list.head; 869 nr_swap_pages += n_pages; 870 swap_device_unlock(stram_swap_info); 871 swap_list_unlock(); 872} 873 874 875/* ------------------------------------------------------------------------ */ 876/* Utility Functions for Swapping */ 877/* ------------------------------------------------------------------------ */ 878 879 880/* is addr in some of the allocated regions? */ 881static int in_some_region(void *addr) 882{ 883 BLOCK *p; 884 885 for( p = alloc_list; p; p = p->next ) { 886 if (p->start <= addr && addr < p->start + p->size) 887 return( 1 ); 888 } 889 return( 0 ); 890} 891 892 893static unsigned long find_free_region(unsigned long n_pages, 894 unsigned long *total_free, 895 unsigned long *region_free) 896{ 897 unsigned short *map = stram_swap_info->swap_map; 898 unsigned long max = stram_swap_info->max; 899 unsigned long head, tail, max_start; 900 long nfree, max_free; 901 902 /* first scan the swap space for a suitable place for the allocation */ 903 head = 1; 904 max_start = 0; 905 max_free = -1; 906 *total_free = 0; 907 908 start_over: 909 /* increment tail until final window size reached, and count free pages */ 910 nfree = 0; 911 for( tail = head; tail-head < n_pages && tail < max; ++tail ) { 912 if (map[tail] == SWAP_MAP_BAD) { 913 head = tail+1; 914 goto start_over; 915 } 916 if (!map[tail]) { 917 ++nfree; 918 ++*total_free; 919 } 920 } 921 if (tail-head < n_pages) 922 goto out; 923 if (nfree > max_free) { 924 max_start = head; 925 max_free = nfree; 926 if (max_free >= n_pages) 927 /* don't need more free pages... :-) */ 928 goto out; 929 } 930 931 /* now shift the window and look for the area where as much pages as 932 * possible are free */ 933 while( tail < max ) { 934 nfree -= (map[head++] == 0); 935 if (map[tail] == SWAP_MAP_BAD) { 936 head = tail+1; 937 goto start_over; 938 } 939 if (!map[tail]) { 940 ++nfree; 941 ++*total_free; 942 } 943 ++tail; 944 if (nfree > max_free) { 945 max_start = head; 946 max_free = nfree; 947 if (max_free >= n_pages) 948 /* don't need more free pages... :-) */ 949 goto out; 950 } 951 } 952 953 out: 954 if (max_free < 0) { 955 printk( KERN_NOTICE "get_stram_region: ST-RAM too full or fragmented " 956 "-- can't allocate %lu pages\n", n_pages ); 957 return( 0 ); 958 } 959 960 *region_free = max_free; 961 return( max_start ); 962} 963 964 965/* setup parameters from command line */ 966void __init stram_swap_setup(char *str, int *ints) 967{ 968 if (ints[0] >= 1) 969 max_swap_size = ((ints[1] < 0 ? 0 : ints[1]) * 1024) & PAGE_MASK; 970} 971 972 973/* ------------------------------------------------------------------------ */ 974/* ST-RAM device */ 975/* ------------------------------------------------------------------------ */ 976 977static int stram_blocksizes[14] = { 978 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096 }; 979static int stram_sizes[14] = { 980 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 981static int refcnt = 0; 982 983static void do_stram_request(request_queue_t *q) 984{ 985 void *start; 986 unsigned long len; 987 988 while (1) { 989 INIT_REQUEST; 990 991 start = swap_start + (CURRENT->sector << 9); 992 len = CURRENT->current_nr_sectors << 9; 993 if ((start + len) > swap_end) { 994 printk( KERN_ERR "stram: bad access beyond end of device: " 995 "block=%ld, count=%ld\n", 996 CURRENT->sector, 997 CURRENT->current_nr_sectors ); 998 end_request( 0 ); 999 continue; 1000 } 1001 1002 if (CURRENT->cmd == READ) { 1003 memcpy(CURRENT->buffer, start, len); 1004#ifdef DO_PROC 1005 stat_swap_read += N_PAGES(len); 1006#endif 1007 } 1008 else { 1009 memcpy(start, CURRENT->buffer, len); 1010#ifdef DO_PROC 1011 stat_swap_write += N_PAGES(len); 1012#endif 1013 } 1014 end_request( 1 ); 1015 } 1016} 1017 1018 1019static int stram_open( struct inode *inode, struct file *filp ) 1020{ 1021 if (filp != MAGIC_FILE_P) { 1022 printk( KERN_NOTICE "Only kernel can open ST-RAM device\n" ); 1023 return( -EPERM ); 1024 } 1025 if (MINOR(inode->i_rdev) != STRAM_MINOR) 1026 return( -ENXIO ); 1027 if (refcnt) 1028 return( -EBUSY ); 1029 ++refcnt; 1030 return( 0 ); 1031} 1032 1033static int stram_release( struct inode *inode, struct file *filp ) 1034{ 1035 if (filp != MAGIC_FILE_P) { 1036 printk( KERN_NOTICE "Only kernel can close ST-RAM device\n" ); 1037 return( -EPERM ); 1038 } 1039 if (refcnt > 0) 1040 --refcnt; 1041 return( 0 ); 1042} 1043 1044 1045static struct block_device_operations stram_fops = { 1046 open: stram_open, 1047 release: stram_release, 1048}; 1049 1050int __init stram_device_init(void) 1051{ 1052 1053 if (!MACH_IS_ATARI) 1054 /* no point in initializing this, I hope */ 1055 return( -ENXIO ); 1056 1057 if (!max_swap_size) 1058 /* swapping not enabled */ 1059 return( -ENXIO ); 1060 1061 if (register_blkdev( STRAM_MAJOR, "stram", &stram_fops)) { 1062 printk( KERN_ERR "stram: Unable to get major %d\n", STRAM_MAJOR ); 1063 return( -ENXIO ); 1064 } 1065 1066 blk_init_queue(BLK_DEFAULT_QUEUE(STRAM_MAJOR), do_stram_request); 1067 blksize_size[STRAM_MAJOR] = stram_blocksizes; 1068 stram_sizes[STRAM_MINOR] = (swap_end - swap_start)/1024; 1069 blk_size[STRAM_MAJOR] = stram_sizes; 1070 register_disk(NULL, MKDEV(STRAM_MAJOR, STRAM_MINOR), 1, &stram_fops, 1071 (swap_end-swap_start)>>9); 1072 return( 0 ); 1073} 1074 1075 1076 1077/* ------------------------------------------------------------------------ */ 1078/* Misc Utility Functions */ 1079/* ------------------------------------------------------------------------ */ 1080 1081/* reserve a range of pages */ 1082static void reserve_region(void *start, void *end) 1083{ 1084 reserve_bootmem (virt_to_phys(start), end - start); 1085} 1086 1087#endif /* CONFIG_STRAM_SWAP */ 1088 1089 1090/* ------------------------------------------------------------------------ */ 1091/* Region Management */ 1092/* ------------------------------------------------------------------------ */ 1093 1094 1095/* insert a region into the alloced list (sorted) */ 1096static BLOCK *add_region( void *addr, unsigned long size ) 1097{ 1098 BLOCK **p, *n = NULL; 1099 int i; 1100 1101 for( i = 0; i < N_STATIC_BLOCKS; ++i ) { 1102 if (static_blocks[i].flags & BLOCK_FREE) { 1103 n = &static_blocks[i]; 1104 n->flags = 0; 1105 break; 1106 } 1107 } 1108 if (!n && mem_init_done) { 1109 /* if statics block pool exhausted and we can call kmalloc() already 1110 * (after mem_init()), try that */ 1111 n = kmalloc( sizeof(BLOCK), GFP_KERNEL ); 1112 if (n) 1113 n->flags = BLOCK_KMALLOCED; 1114 } 1115 if (!n) { 1116 printk( KERN_ERR "Out of memory for ST-RAM descriptor blocks\n" ); 1117 return( NULL ); 1118 } 1119 n->start = addr; 1120 n->size = size; 1121 1122 for( p = &alloc_list; *p; p = &((*p)->next) ) 1123 if ((*p)->start > addr) break; 1124 n->next = *p; 1125 *p = n; 1126 1127 return( n ); 1128} 1129 1130 1131/* find a region (by start addr) in the alloced list */ 1132static BLOCK *find_region( void *addr ) 1133{ 1134 BLOCK *p; 1135 1136 for( p = alloc_list; p; p = p->next ) { 1137 if (p->start == addr) 1138 return( p ); 1139 if (p->start > addr) 1140 break; 1141 } 1142 return( NULL ); 1143} 1144 1145 1146/* remove a block from the alloced list */ 1147static int remove_region( BLOCK *block ) 1148{ 1149 BLOCK **p; 1150 1151 for( p = &alloc_list; *p; p = &((*p)->next) ) 1152 if (*p == block) break; 1153 if (!*p) 1154 return( 0 ); 1155 1156 *p = block->next; 1157 if (block->flags & BLOCK_KMALLOCED) 1158 kfree( block ); 1159 else 1160 block->flags |= BLOCK_FREE; 1161 return( 1 ); 1162} 1163 1164 1165 1166/* ------------------------------------------------------------------------ */ 1167/* /proc statistics file stuff */ 1168/* ------------------------------------------------------------------------ */ 1169 1170#ifdef DO_PROC 1171 1172#define PRINT_PROC(fmt,args...) len += sprintf( buf+len, fmt, ##args ) 1173 1174int get_stram_list( char *buf ) 1175{ 1176 int len = 0; 1177 BLOCK *p; 1178#ifdef CONFIG_STRAM_SWAP 1179 int i; 1180 unsigned short *map = stram_swap_info->swap_map; 1181 unsigned long max = stram_swap_info->max; 1182 unsigned free = 0, used = 0, rsvd = 0; 1183#endif 1184 1185#ifdef CONFIG_STRAM_SWAP 1186 if (max_swap_size) { 1187 for( i = 1; i < max; ++i ) { 1188 if (!map[i]) 1189 ++free; 1190 else if (map[i] == SWAP_MAP_BAD) 1191 ++rsvd; 1192 else 1193 ++used; 1194 } 1195 PRINT_PROC( 1196 "Total ST-RAM: %8u kB\n" 1197 "Total ST-RAM swap: %8lu kB\n" 1198 "Free swap: %8u kB\n" 1199 "Used swap: %8u kB\n" 1200 "Allocated swap: %8u kB\n" 1201 "Swap Reads: %8u\n" 1202 "Swap Writes: %8u\n" 1203 "Swap Forced Reads: %8u\n", 1204 (stram_end - stram_start) >> 10, 1205 (max-1) << (PAGE_SHIFT-10), 1206 free << (PAGE_SHIFT-10), 1207 used << (PAGE_SHIFT-10), 1208 rsvd << (PAGE_SHIFT-10), 1209 stat_swap_read, 1210 stat_swap_write, 1211 stat_swap_force ); 1212 } 1213 else { 1214#endif 1215 PRINT_PROC( "ST-RAM swapping disabled\n" ); 1216 PRINT_PROC("Total ST-RAM: %8u kB\n", 1217 (stram_end - stram_start) >> 10); 1218#ifdef CONFIG_STRAM_SWAP 1219 } 1220#endif 1221 1222 PRINT_PROC( "Allocated regions:\n" ); 1223 for( p = alloc_list; p; p = p->next ) { 1224 if (len + 50 >= PAGE_SIZE) 1225 break; 1226 PRINT_PROC("0x%08lx-0x%08lx: %s (", 1227 virt_to_phys(p->start), 1228 virt_to_phys(p->start+p->size-1), 1229 p->owner); 1230 if (p->flags & BLOCK_GFP) 1231 PRINT_PROC( "page-alloced)\n" ); 1232 else if (p->flags & BLOCK_INSWAP) 1233 PRINT_PROC( "in swap)\n" ); 1234 else 1235 PRINT_PROC( "??)\n" ); 1236 } 1237 1238 return( len ); 1239} 1240 1241#endif 1242 1243 1244/* 1245 * Local variables: 1246 * c-indent-level: 4 1247 * tab-width: 4 1248 * End: 1249 */ 1250