litmus2008.git - [ARCHIVE] Old LITMUS^RT 2008 version (for reference).

about summary refs log tree commit diff stats

diff options

Diffstat (limited to 'fs/ext4/ioctl.c')

0 files changed, 0 insertions, 0 deletions

valds <torvalds@ppc970.osdl.org> 2005-04-16 18:20:36 -0400 committer Linus Torvalds <torvalds@ppc970.osdl.org> 2005-04-16 18:20:36 -0400 Linux-2.6.12-rc2' href='/cgit/cgit.cgi/litmus-rt-budgetable-locks.git/.git/commit/mm/page_alloc.c?h=update_litmus_2019&id=1da177e4c3f41524e886b7f1b8a0c1fc7321cac2'>1da177e4c3f4

641916881322

23
24

39
40

43
44

52
53

55
56
57

91
92
93

107
108

122
123

124
125

126
127

130
131

162
163

164
165

169
170

171
172

173
174

183
184

188
189
190

219
220
221

222
223

253
254

266
267
268

272
273

275
276

287
288
289

291
292
293

295
296

298
299
300

314
315
316

319
320

322
323

327
328

332
333

336
337

353
354

401
402

403
404
405

409
410

450
451

452
453

456
457

459
460

461
462

466
467

468
469

484
485

486
487
488

496
497
498

502
503

509
510
511

512
513
514

525
526

538
539
540

546
547

563
564

565
566

571
572

584
585

587
588

589
590

593
594
595

603
604

606
607

608
609
610

619
620

622
623
624

625
626

633
634
635

652
653

663
664
665

666
667

668
669
670

673
674

695
696

706
707

712
713

748
749

750
751

753
754

755
756
757

758
759
760

775
776
777

794
795

797
798

799
800

808
809

832
833

846
847
848

860
861
862

865
866

872
873

874
875
876

884
885
886

887
888
889

899
900

902
903
904

905
906

908
909

967
968

975
976

989
990

991
992
993

1011
1012
1013

1015
1016

1017
1018

1034
1035

1037
1038
1039

1040
1041

1055
1056

1059
1060

1063
1064

1068
1069

1071
1072

1073
1074

1083
1084

1085
1086

1088
1089

1092
1093

1095
1096

1098
1099

1127
1128

1129
1130

1138
1139
1140

1153
1154

1165
1166

1174
1175

1176
1177

1178
1179

1206
1207

1218
1219

1225
1226
1227

1228
1229

1232
1233

1244
1245

1255
1256
1257

1278
1279

1291
1292

1324
1325
1326

1327
1328

1329
1330

1331
1332
1333

1360
1361

1362
1363

1364
1365

1393
1394
1395

1508
1509
1510

1519
1520
1521

1527
1528

1529
1530

1531
1532
1533

1541
1542

1565
1566

1568
1569

1593
1594

1595
1596
1597

1599
1600
1601

1628
1629

1631
1632
1633

1634
1635

1642
1643

1655
1656

1713
1714

1715
1716
1717

1719
1720

1722
1723
1724

1725
1726

1734
1735

1746
1747

1749
1750
1751

1760
1761

1771
1772

1774
1775

1788
1789
1790

1791
1792
1793

1794
1795

1810
1811

1830
1831
1832

1838
1839

1840
1841

1871
1872

1875
1876

1878
1879

1880
1881

1882
1883

1884
1885

1886
1887

1895
1896

1899
1900

1901
1902

1905
1906

1921
1922

1939
1940

1965
1966

1993
1994

2005
2006

2009
2010

2025
2026

2087
2088

2090
2091

2093
2094

2100
2101

2123
2124

2136
2137

2152
2153

2172
2173

2175
2176

2179
2180

2183
2184
2185

2186
2187
2188

2189
2190

2197
2198

2206
2207

2210
2211

2227
2228

2235
2236

2247
2248
2249

2255
2256

2263
2264

2265
2266

2282
2283
2284

2285
2286
2287

2288
2289

2290
2291

2292
2293

2294
2295
2296

2297
2298

2299
2300
2301

2308
2309

2310
2311

2313
2314

2316
2317

2320
2321

2325
2326

2332
2333

2428
2429

2447
2448

2463
2464
2465

2466
2467
2468

2470
2471

2503
2504
2505

2506
2507

2508
2509
2510

2515
2516
2517

2518
2519

2520
2521

2522
2523
2524

2546
2547

2549
2550

2552
2553

2589
2590

2623
2624
2625

2626
2627

2630
2631

2637
2638

2640
2641
2642

2659
2660

2661
2662

2669
2670
2671

2673
2674

2675
2676

2680
2681

2684
2685
2686

2687
2688

2689
2690

2692
2693

2702
2703

2704
2705

2707
2708

2731
2732

2733
2734

2739
2740

2741
2742

2748
2749
2750

2757
2758
2759

2762
2763

2767
2768

2772
2773

2868
2869

2877
2878

2944
2945

2948
2949
2950

2964
2965

2968
2969

2975
2976
2977

2984
2985
2986

2995
2996
2997

3000
3001
3002

3010
3011

3024
3025

3031
3032
3033

3060
3061

3063
3064

3067
3068

3071
3072

3073
3074

3075
3076

3095
3096

3114
3115
3116

3117
3118

3120
3121

3122
3123
3124

3133
3134
3135

3142
3143

3144
3145

3159
3160
3161

3164
3165

3192
3193

3211
3212
3213

3224
3225
3226

3242
3243
3244

3248
3249

3250
3251

3292
3293
3294

3295
3296

3297
3298

3299
3300

3301
3302

3307
3308

3309
3310

3318
3319

3320
3321

3369
3370

3371
3372
3373

3374
3375

3383
3384

3404
3405

3433
3434
3435

3445
3446

3448
3449
3450

3465
3466
3467

3488
3489
3490

3548
3549
3550

3562
3563
3564

3595
3596

3597
3598

3620
3621

3623
3624

3643
3644
3645

3655
3656
3657

3679
3680

3702
3703
3704

3705
3706

3714
3715

3782
3783

3790
3791
3792

3794
3795
3796

3800
3801
3802

3809
3810

3811
3812

3822
3823

3827
3828

3841
3842
3843

3850
3851

3860
3861
3862

3865
3866

3870
3871
3872

3880
3881

3883
3884

3894
3895
3896

3900
3901
3902

3905
3906

3908
3909

3912
3913

3914
3915

3917
3918

3919
3920

3922
3923

3977
3978

4020
4021

4022
4023

4024
4025
4026

4028
4029

4031
4032

4034
4035
4036

4039
4040

4120
4121

4124
4125

4128
4129

4158
4159

4166
4167

4179
4180

4181
4182

4206
4207

4311
4312

4327
4328

4345
4346
4347

4356
4357

4370
4371

4372
4373
4374

4376
4377
4378

4398
4399

4407
4408

4446
4447

4449
4450

4455
4456
4457

4468
4469
4470

4472
4473

4499
4500
4501

4529
4530

4558
4559

4560
4561

4562
4563

4574
4575
4576

4577
4578

4583
4584

4600
4601

4603
4604

4605
4606

4612
4613

4624
4625

4626
4627

4629
4630

4631
4632

4636
4637
4638

4639
4640

4666
4667
4668

4670
4671

4673
4674

4682
4683

4722
4723

4737
4738
4739

4740
4741

4753
4754
4755

4756
4757

4772
4773

4781
4782
4783

4805
4806

4862
4863

4891
4892
4893

4894
4895

4896
4897

4901
4902

4910
4911

4939
4940

4992
4993

5014
5015

5021
5022

/*
 *  linux/mm/page_alloc.c
 *
 *  Manages the free list, the system allocates free pages here.
 *  Note that kmalloc() lives in slab.c
 *
 *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 *  Swap reorganised 29.12.95, Stephen Tweedie
 *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
 *  Reshaped it to be a zoned allocator, Ingo Molnar, Red Hat, 1999
 *  Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
 *  Zone balancing, Kanoj Sarcar, SGI, Jan 2000
 *  Per cpu hot/cold page lists, bulk allocation, Martin J. Bligh, Sept 2002
 *          (lots of bits borrowed from Ingo Molnar & Andrew Morton)
 */

#include <linux/stddef.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/interrupt.h>
#include <linux/pagemap.h>
#include <linux/jiffies.h>
#include <linux/bootmem.h>
#include <linux/compiler.h>
#include <linux/kernel.h>
#include <linux/kmemcheck.h>
#include <linux/module.h>
#include <linux/suspend.h>
#include <linux/pagevec.h>
#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/oom.h>
#include <linux/notifier.h>
#include <linux/topology.h>
#include <linux/sysctl.h>
#include <linux/cpu.h>
#include <linux/cpuset.h>
#include <linux/memory_hotplug.h>
#include <linux/nodemask.h>
#include <linux/vmalloc.h>
#include <linux/mempolicy.h>
#include <linux/stop_machine.h>
#include <linux/sort.h>
#include <linux/pfn.h>
#include <linux/backing-dev.h>
#include <linux/fault-inject.h>
#include <linux/page-isolation.h>
#include <linux/page_cgroup.h>
#include <linux/debugobjects.h>
#include <linux/kmemleak.h>
#include <trace/events/kmem.h>

#include <asm/tlbflush.h>
#include <asm/div64.h>
#include "internal.h"

/*
 * Array of node states.
 */
nodemask_t node_states[NR_NODE_STATES] __read_mostly = {
	[N_POSSIBLE] = NODE_MASK_ALL,
	[N_ONLINE] = { { [0] = 1UL } },
#ifndef CONFIG_NUMA
	[N_NORMAL_MEMORY] = { { [0] = 1UL } },
#ifdef CONFIG_HIGHMEM
	[N_HIGH_MEMORY] = { { [0] = 1UL } },
#endif
	[N_CPU] = { { [0] = 1UL } },
#endif	/* NUMA */
};
EXPORT_SYMBOL(node_states);

unsigned long totalram_pages __read_mostly;
unsigned long totalreserve_pages __read_mostly;
int percpu_pagelist_fraction;
gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;

#ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE
int pageblock_order __read_mostly;
#endif

static void __free_pages_ok(struct page *page, unsigned int order);

/*
 * results with 256, 32 in the lowmem_reserve sysctl:
 *	1G machine -> (16M dma, 800M-16M normal, 1G-800M high)
 *	1G machine -> (16M dma, 784M normal, 224M high)
 *	NORMAL allocation will leave 784M/256 of ram reserved in the ZONE_DMA
 *	HIGHMEM allocation will leave 224M/32 of ram reserved in ZONE_NORMAL
 *	HIGHMEM allocation will (224M+784M)/256 of ram reserved in ZONE_DMA
 *
 * TBD: should special case ZONE_DMA32 machines here - in those we normally
 * don't need any ZONE_NORMAL reservation
 */
int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1] = {
#ifdef CONFIG_ZONE_DMA
	 256,
#endif
#ifdef CONFIG_ZONE_DMA32
	 256,
#endif
#ifdef CONFIG_HIGHMEM
	 32,
#endif
	 32,
};

EXPORT_SYMBOL(totalram_pages);

static char * const zone_names[MAX_NR_ZONES] = {
#ifdef CONFIG_ZONE_DMA
	 "DMA",
#endif
#ifdef CONFIG_ZONE_DMA32
	 "DMA32",
#endif
	 "Normal",
#ifdef CONFIG_HIGHMEM
	 "HighMem",
#endif
	 "Movable",
};

int min_free_kbytes = 1024;

static unsigned long __meminitdata nr_kernel_pages;
static unsigned long __meminitdata nr_all_pages;
static unsigned long __meminitdata dma_reserve;

#ifdef CONFIG_ARCH_POPULATES_NODE_MAP
  /*
   * MAX_ACTIVE_REGIONS determines the maximum number of distinct
   * ranges of memory (RAM) that may be registered with add_active_range().
   * Ranges passed to add_active_range() will be merged if possible
   * so the number of times add_active_range() can be called is
   * related to the number of nodes and the number of holes
   */
  #ifdef CONFIG_MAX_ACTIVE_REGIONS
    /* Allow an architecture to set MAX_ACTIVE_REGIONS to save memory */
    #define MAX_ACTIVE_REGIONS CONFIG_MAX_ACTIVE_REGIONS
  #else
    #if MAX_NUMNODES >= 32
      /* If there can be many nodes, allow up to 50 holes per node */
      #define MAX_ACTIVE_REGIONS (MAX_NUMNODES*50)
    #else
      /* By default, allow up to 256 distinct regions */
      #define MAX_ACTIVE_REGIONS 256
    #endif
  #endif

  static struct node_active_region __meminitdata early_node_map[MAX_ACTIVE_REGIONS];
  static int __meminitdata nr_nodemap_entries;
  static unsigned long __meminitdata arch_zone_lowest_possible_pfn[MAX_NR_ZONES];
  static unsigned long __meminitdata arch_zone_highest_possible_pfn[MAX_NR_ZONES];
  static unsigned long __initdata required_kernelcore;
  static unsigned long __initdata required_movablecore;
  static unsigned long __meminitdata zone_movable_pfn[MAX_NUMNODES];

  /* movable_zone is the "real" zone pages in ZONE_MOVABLE are taken from */
  int movable_zone;
  EXPORT_SYMBOL(movable_zone);
#endif /* CONFIG_ARCH_POPULATES_NODE_MAP */

#if MAX_NUMNODES > 1
int nr_node_ids __read_mostly = MAX_NUMNODES;
int nr_online_nodes __read_mostly = 1;
EXPORT_SYMBOL(nr_node_ids);
EXPORT_SYMBOL(nr_online_nodes);
#endif

int page_group_by_mobility_disabled __read_mostly;

static void set_pageblock_migratetype(struct page *page, int migratetype)
{

	if (unlikely(page_group_by_mobility_disabled))
		migratetype = MIGRATE_UNMOVABLE;

	set_pageblock_flags_group(page, (unsigned long)migratetype,
					PB_migrate, PB_migrate_end);
}

bool oom_killer_disabled __read_mostly;

#ifdef CONFIG_DEBUG_VM
static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
{
	int ret = 0;
	unsigned seq;
	unsigned long pfn = page_to_pfn(page);

	do {
		seq = zone_span_seqbegin(zone);
		if (pfn >= zone->zone_start_pfn + zone->spanned_pages)
			ret = 1;
		else if (pfn < zone->zone_start_pfn)
			ret = 1;
	} while (zone_span_seqretry(zone, seq));

	return ret;
}

static int page_is_consistent(struct zone *zone, struct page *page)
{
	if (!pfn_valid_within(page_to_pfn(page)))
		return 0;
	if (zone != page_zone(page))
		return 0;

	return 1;
}
/*
 * Temporary debugging check for pages not lying within a given zone.
 */
static int bad_range(struct zone *zone, struct page *page)
{
	if (page_outside_zone_boundaries(zone, page))
		return 1;
	if (!page_is_consistent(zone, page))
		return 1;

	return 0;
}
#else
static inline int bad_range(struct zone *zone, struct page *page)
{
	return 0;
}
#endif

static void bad_page(struct page *page)
{
	static unsigned long resume;
	static unsigned long nr_shown;
	static unsigned long nr_unshown;

	/* Don't complain about poisoned pages */
	if (PageHWPoison(page)) {
		__ClearPageBuddy(page);
		return;
	}

	/*
	 * Allow a burst of 60 reports, then keep quiet for that minute;
	 * or allow a steady drip of one report per second.
	 */
	if (nr_shown == 60) {
		if (time_before(jiffies, resume)) {
			nr_unshown++;
			goto out;
		}
		if (nr_unshown) {
			printk(KERN_ALERT
			      "BUG: Bad page state: %lu messages suppressed\n",
				nr_unshown);
			nr_unshown = 0;
		}
		nr_shown = 0;
	}
	if (nr_shown++ == 0)
		resume = jiffies + 60 * HZ;

	printk(KERN_ALERT "BUG: Bad page state in process %s  pfn:%05lx\n",
		current->comm, page_to_pfn(page));
	printk(KERN_ALERT
		"page:%p flags:%p count:%d mapcount:%d mapping:%p index:%lx\n",
		page, (void *)page->flags, page_count(page),
		page_mapcount(page), page->mapping, page->index);

	dump_stack();
out:
	/* Leave bad fields for debug, except PageBuddy could make trouble */
	__ClearPageBuddy(page);
	add_taint(TAINT_BAD_PAGE);
}

/*
 * Higher-order pages are called "compound pages".  They are structured thusly:
 *
 * The first PAGE_SIZE page is called the "head page".
 *
 * The remaining PAGE_SIZE pages are called "tail pages".
 *
 * All pages have PG_compound set.  All pages have their ->private pointing at
 * the head page (even the head page has this).
 *
 * The first tail page's ->lru.next holds the address of the compound page's
 * put_page() function.  Its ->lru.prev holds the order of allocation.
 * This usage means that zero-order pages may not be compound.
 */

static void free_compound_page(struct page *page)
{
	__free_pages_ok(page, compound_order(page));
}

void prep_compound_page(struct page *page, unsigned long order)
{
	int i;
	int nr_pages = 1 << order;

	set_compound_page_dtor(page, free_compound_page);
	set_compound_order(page, order);
	__SetPageHead(page);
	for (i = 1; i < nr_pages; i++) {
		struct page *p = page + i;

		__SetPageTail(p);
		p->first_page = page;
	}
}

static int destroy_compound_page(struct page *page, unsigned long order)
{
	int i;
	int nr_pages = 1 << order;
	int bad = 0;

	if (unlikely(compound_order(page) != order) ||
	    unlikely(!PageHead(page))) {
		bad_page(page);
		bad++;
	}

	__ClearPageHead(page);

	for (i = 1; i < nr_pages; i++) {
		struct page *p = page + i;

		if (unlikely(!PageTail(p) || (p->first_page != page))) {


context:
space:
mode: