diff options
author | Yinghai Lu <yinghai@kernel.org> | 2008-10-14 21:59:18 -0400 |
---|---|---|
committer | Ingo Molnar <mingo@elte.hu> | 2008-10-28 11:30:57 -0400 |
commit | 30604bb410b53efa9c93ee8f03d7aa7494094faa (patch) | |
tree | 8345cd64ca91b655e0e81bcc546bac2dfc83bc74 /arch/x86/kernel | |
parent | 49fdf6785fd660e18a1eb4588928f47e9fa29a9a (diff) |
x86: break up mtrr_cleanup() into several small functions.
Ingo said mtrr_cleanup() is big and ugly.
so break it up into more functions and make it more readable.
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Diffstat (limited to 'arch/x86/kernel')
-rw-r--r-- | arch/x86/kernel/cpu/mtrr/main.c | 346 |
1 files changed, 171 insertions, 175 deletions
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c index c78c04821ea1..1159e269e596 100644 --- a/arch/x86/kernel/cpu/mtrr/main.c +++ b/arch/x86/kernel/cpu/mtrr/main.c | |||
@@ -803,6 +803,7 @@ x86_get_mtrr_mem_range(struct res_range *range, int nr_range, | |||
803 | } | 803 | } |
804 | 804 | ||
805 | static struct res_range __initdata range[RANGE_NUM]; | 805 | static struct res_range __initdata range[RANGE_NUM]; |
806 | static int __initdata nr_range; | ||
806 | 807 | ||
807 | #ifdef CONFIG_MTRR_SANITIZER | 808 | #ifdef CONFIG_MTRR_SANITIZER |
808 | 809 | ||
@@ -1206,39 +1207,43 @@ struct mtrr_cleanup_result { | |||
1206 | #define PSHIFT (PAGE_SHIFT - 10) | 1207 | #define PSHIFT (PAGE_SHIFT - 10) |
1207 | 1208 | ||
1208 | static struct mtrr_cleanup_result __initdata result[NUM_RESULT]; | 1209 | static struct mtrr_cleanup_result __initdata result[NUM_RESULT]; |
1209 | static struct res_range __initdata range_new[RANGE_NUM]; | ||
1210 | static unsigned long __initdata min_loss_pfn[RANGE_NUM]; | 1210 | static unsigned long __initdata min_loss_pfn[RANGE_NUM]; |
1211 | 1211 | ||
1212 | static int __init mtrr_cleanup(unsigned address_bits) | 1212 | static void __init print_out_mtrr_range_state(void) |
1213 | { | 1213 | { |
1214 | unsigned long extra_remove_base, extra_remove_size; | ||
1215 | unsigned long base, size, def, dummy; | ||
1216 | mtrr_type type; | ||
1217 | int nr_range, nr_range_new; | ||
1218 | u64 chunk_size, gran_size; | ||
1219 | unsigned long range_sums, range_sums_new; | ||
1220 | int index_good; | ||
1221 | int num_reg_good; | ||
1222 | int i; | 1214 | int i; |
1215 | char start_factor = 'K', size_factor = 'K'; | ||
1216 | unsigned long start_base, size_base; | ||
1217 | mtrr_type type; | ||
1223 | 1218 | ||
1224 | /* extra one for all 0 */ | 1219 | for (i = 0; i < num_var_ranges; i++) { |
1225 | int num[MTRR_NUM_TYPES + 1]; | ||
1226 | 1220 | ||
1227 | if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1) | 1221 | size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10); |
1228 | return 0; | 1222 | if (!size_base) |
1229 | rdmsr(MTRRdefType_MSR, def, dummy); | 1223 | continue; |
1230 | def &= 0xff; | ||
1231 | if (def != MTRR_TYPE_UNCACHABLE) | ||
1232 | return 0; | ||
1233 | 1224 | ||
1234 | /* get it and store it aside */ | 1225 | size_base = to_size_factor(size_base, &size_factor), |
1235 | memset(range_state, 0, sizeof(range_state)); | 1226 | start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10); |
1236 | for (i = 0; i < num_var_ranges; i++) { | 1227 | start_base = to_size_factor(start_base, &start_factor), |
1237 | mtrr_if->get(i, &base, &size, &type); | 1228 | type = range_state[i].type; |
1238 | range_state[i].base_pfn = base; | 1229 | |
1239 | range_state[i].size_pfn = size; | 1230 | printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n", |
1240 | range_state[i].type = type; | 1231 | i, start_base, start_factor, |
1232 | size_base, size_factor, | ||
1233 | (type == MTRR_TYPE_UNCACHABLE) ? "UC" : | ||
1234 | ((type == MTRR_TYPE_WRPROT) ? "WP" : | ||
1235 | ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other")) | ||
1236 | ); | ||
1241 | } | 1237 | } |
1238 | } | ||
1239 | |||
1240 | static int __init mtrr_need_cleanup(void) | ||
1241 | { | ||
1242 | int i; | ||
1243 | mtrr_type type; | ||
1244 | unsigned long size; | ||
1245 | /* extra one for all 0 */ | ||
1246 | int num[MTRR_NUM_TYPES + 1]; | ||
1242 | 1247 | ||
1243 | /* check entries number */ | 1248 | /* check entries number */ |
1244 | memset(num, 0, sizeof(num)); | 1249 | memset(num, 0, sizeof(num)); |
@@ -1263,29 +1268,133 @@ static int __init mtrr_cleanup(unsigned address_bits) | |||
1263 | num_var_ranges - num[MTRR_NUM_TYPES]) | 1268 | num_var_ranges - num[MTRR_NUM_TYPES]) |
1264 | return 0; | 1269 | return 0; |
1265 | 1270 | ||
1266 | /* print original var MTRRs at first, for debugging: */ | 1271 | return 1; |
1267 | printk(KERN_DEBUG "original variable MTRRs\n"); | 1272 | } |
1268 | for (i = 0; i < num_var_ranges; i++) { | ||
1269 | char start_factor = 'K', size_factor = 'K'; | ||
1270 | unsigned long start_base, size_base; | ||
1271 | 1273 | ||
1272 | size_base = range_state[i].size_pfn << (PAGE_SHIFT - 10); | 1274 | static unsigned long __initdata range_sums; |
1273 | if (!size_base) | 1275 | static void __init mtrr_calc_range_state(u64 chunk_size, u64 gran_size, |
1274 | continue; | 1276 | unsigned long extra_remove_base, |
1277 | unsigned long extra_remove_size, | ||
1278 | int i) | ||
1279 | { | ||
1280 | int num_reg; | ||
1281 | static struct res_range range_new[RANGE_NUM]; | ||
1282 | static int nr_range_new; | ||
1283 | unsigned long range_sums_new; | ||
1284 | |||
1285 | /* convert ranges to var ranges state */ | ||
1286 | num_reg = x86_setup_var_mtrrs(range, nr_range, | ||
1287 | chunk_size, gran_size); | ||
1288 | |||
1289 | /* we got new setting in range_state, check it */ | ||
1290 | memset(range_new, 0, sizeof(range_new)); | ||
1291 | nr_range_new = x86_get_mtrr_mem_range(range_new, 0, | ||
1292 | extra_remove_base, extra_remove_size); | ||
1293 | range_sums_new = sum_ranges(range_new, nr_range_new); | ||
1294 | |||
1295 | result[i].chunk_sizek = chunk_size >> 10; | ||
1296 | result[i].gran_sizek = gran_size >> 10; | ||
1297 | result[i].num_reg = num_reg; | ||
1298 | if (range_sums < range_sums_new) { | ||
1299 | result[i].lose_cover_sizek = | ||
1300 | (range_sums_new - range_sums) << PSHIFT; | ||
1301 | result[i].bad = 1; | ||
1302 | } else | ||
1303 | result[i].lose_cover_sizek = | ||
1304 | (range_sums - range_sums_new) << PSHIFT; | ||
1275 | 1305 | ||
1276 | size_base = to_size_factor(size_base, &size_factor), | 1306 | /* double check it */ |
1277 | start_base = range_state[i].base_pfn << (PAGE_SHIFT - 10); | 1307 | if (!result[i].bad && !result[i].lose_cover_sizek) { |
1278 | start_base = to_size_factor(start_base, &start_factor), | 1308 | if (nr_range_new != nr_range || |
1279 | type = range_state[i].type; | 1309 | memcmp(range, range_new, sizeof(range))) |
1310 | result[i].bad = 1; | ||
1311 | } | ||
1280 | 1312 | ||
1281 | printk(KERN_DEBUG "reg %d, base: %ld%cB, range: %ld%cB, type %s\n", | 1313 | if (!result[i].bad && (range_sums - range_sums_new < |
1282 | i, start_base, start_factor, | 1314 | min_loss_pfn[num_reg])) { |
1283 | size_base, size_factor, | 1315 | min_loss_pfn[num_reg] = |
1284 | (type == MTRR_TYPE_UNCACHABLE) ? "UC" : | 1316 | range_sums - range_sums_new; |
1285 | ((type == MTRR_TYPE_WRPROT) ? "WP" : | ||
1286 | ((type == MTRR_TYPE_WRBACK) ? "WB" : "Other")) | ||
1287 | ); | ||
1288 | } | 1317 | } |
1318 | } | ||
1319 | |||
1320 | static void __init mtrr_print_out_one_result(int i) | ||
1321 | { | ||
1322 | char gran_factor, chunk_factor, lose_factor; | ||
1323 | unsigned long gran_base, chunk_base, lose_base; | ||
1324 | |||
1325 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | ||
1326 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | ||
1327 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
1328 | printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t", | ||
1329 | result[i].bad ? "*BAD*" : " ", | ||
1330 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
1331 | printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n", | ||
1332 | result[i].num_reg, result[i].bad ? "-" : "", | ||
1333 | lose_base, lose_factor); | ||
1334 | } | ||
1335 | |||
1336 | static int __init mtrr_search_optimal_index(void) | ||
1337 | { | ||
1338 | int i; | ||
1339 | int num_reg_good; | ||
1340 | int index_good; | ||
1341 | |||
1342 | if (nr_mtrr_spare_reg >= num_var_ranges) | ||
1343 | nr_mtrr_spare_reg = num_var_ranges - 1; | ||
1344 | num_reg_good = -1; | ||
1345 | for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) { | ||
1346 | if (!min_loss_pfn[i]) | ||
1347 | num_reg_good = i; | ||
1348 | } | ||
1349 | |||
1350 | index_good = -1; | ||
1351 | if (num_reg_good != -1) { | ||
1352 | for (i = 0; i < NUM_RESULT; i++) { | ||
1353 | if (!result[i].bad && | ||
1354 | result[i].num_reg == num_reg_good && | ||
1355 | !result[i].lose_cover_sizek) { | ||
1356 | index_good = i; | ||
1357 | break; | ||
1358 | } | ||
1359 | } | ||
1360 | } | ||
1361 | |||
1362 | return index_good; | ||
1363 | } | ||
1364 | |||
1365 | |||
1366 | static int __init mtrr_cleanup(unsigned address_bits) | ||
1367 | { | ||
1368 | unsigned long extra_remove_base, extra_remove_size; | ||
1369 | unsigned long base, size, def, dummy; | ||
1370 | mtrr_type type; | ||
1371 | u64 chunk_size, gran_size; | ||
1372 | int index_good; | ||
1373 | int i; | ||
1374 | |||
1375 | if (!is_cpu(INTEL) || enable_mtrr_cleanup < 1) | ||
1376 | return 0; | ||
1377 | rdmsr(MTRRdefType_MSR, def, dummy); | ||
1378 | def &= 0xff; | ||
1379 | if (def != MTRR_TYPE_UNCACHABLE) | ||
1380 | return 0; | ||
1381 | |||
1382 | /* get it and store it aside */ | ||
1383 | memset(range_state, 0, sizeof(range_state)); | ||
1384 | for (i = 0; i < num_var_ranges; i++) { | ||
1385 | mtrr_if->get(i, &base, &size, &type); | ||
1386 | range_state[i].base_pfn = base; | ||
1387 | range_state[i].size_pfn = size; | ||
1388 | range_state[i].type = type; | ||
1389 | } | ||
1390 | |||
1391 | /* check if we need handle it and can handle it */ | ||
1392 | if (!mtrr_need_cleanup()) | ||
1393 | return 0; | ||
1394 | |||
1395 | /* print original var MTRRs at first, for debugging: */ | ||
1396 | printk(KERN_DEBUG "original variable MTRRs\n"); | ||
1397 | print_out_mtrr_range_state(); | ||
1289 | 1398 | ||
1290 | memset(range, 0, sizeof(range)); | 1399 | memset(range, 0, sizeof(range)); |
1291 | extra_remove_size = 0; | 1400 | extra_remove_size = 0; |
@@ -1309,176 +1418,64 @@ static int __init mtrr_cleanup(unsigned address_bits) | |||
1309 | range_sums >> (20 - PAGE_SHIFT)); | 1418 | range_sums >> (20 - PAGE_SHIFT)); |
1310 | 1419 | ||
1311 | if (mtrr_chunk_size && mtrr_gran_size) { | 1420 | if (mtrr_chunk_size && mtrr_gran_size) { |
1312 | int num_reg; | 1421 | i = 0; |
1313 | char gran_factor, chunk_factor, lose_factor; | 1422 | mtrr_calc_range_state(mtrr_chunk_size, mtrr_gran_size, |
1314 | unsigned long gran_base, chunk_base, lose_base; | 1423 | extra_remove_base, extra_remove_size, i); |
1315 | |||
1316 | debug_print++; | ||
1317 | /* convert ranges to var ranges state */ | ||
1318 | num_reg = x86_setup_var_mtrrs(range, nr_range, mtrr_chunk_size, | ||
1319 | mtrr_gran_size); | ||
1320 | 1424 | ||
1321 | /* we got new setting in range_state, check it */ | 1425 | mtrr_print_out_one_result(i); |
1322 | memset(range_new, 0, sizeof(range_new)); | ||
1323 | nr_range_new = x86_get_mtrr_mem_range(range_new, 0, | ||
1324 | extra_remove_base, | ||
1325 | extra_remove_size); | ||
1326 | range_sums_new = sum_ranges(range_new, nr_range_new); | ||
1327 | 1426 | ||
1328 | i = 0; | ||
1329 | result[i].chunk_sizek = mtrr_chunk_size >> 10; | ||
1330 | result[i].gran_sizek = mtrr_gran_size >> 10; | ||
1331 | result[i].num_reg = num_reg; | ||
1332 | if (range_sums < range_sums_new) { | ||
1333 | result[i].lose_cover_sizek = | ||
1334 | (range_sums_new - range_sums) << PSHIFT; | ||
1335 | result[i].bad = 1; | ||
1336 | } else | ||
1337 | result[i].lose_cover_sizek = | ||
1338 | (range_sums - range_sums_new) << PSHIFT; | ||
1339 | |||
1340 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | ||
1341 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | ||
1342 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
1343 | printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t", | ||
1344 | result[i].bad?"*BAD*":" ", | ||
1345 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
1346 | printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n", | ||
1347 | result[i].num_reg, result[i].bad?"-":"", | ||
1348 | lose_base, lose_factor); | ||
1349 | if (!result[i].bad) { | 1427 | if (!result[i].bad) { |
1350 | set_var_mtrr_all(address_bits); | 1428 | set_var_mtrr_all(address_bits); |
1351 | return 1; | 1429 | return 1; |
1352 | } | 1430 | } |
1353 | printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, " | 1431 | printk(KERN_INFO "invalid mtrr_gran_size or mtrr_chunk_size, " |
1354 | "will find optimal one\n"); | 1432 | "will find optimal one\n"); |
1355 | debug_print--; | ||
1356 | memset(result, 0, sizeof(result[0])); | ||
1357 | } | 1433 | } |
1358 | 1434 | ||
1359 | i = 0; | 1435 | i = 0; |
1360 | memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn)); | 1436 | memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn)); |
1361 | memset(result, 0, sizeof(result)); | 1437 | memset(result, 0, sizeof(result)); |
1362 | for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) { | 1438 | for (gran_size = (1ULL<<16); gran_size < (1ULL<<32); gran_size <<= 1) { |
1363 | char gran_factor; | ||
1364 | unsigned long gran_base; | ||
1365 | |||
1366 | if (debug_print) | ||
1367 | gran_base = to_size_factor(gran_size >> 10, &gran_factor); | ||
1368 | 1439 | ||
1369 | for (chunk_size = gran_size; chunk_size < (1ULL<<32); | 1440 | for (chunk_size = gran_size; chunk_size < (1ULL<<32); |
1370 | chunk_size <<= 1) { | 1441 | chunk_size <<= 1) { |
1371 | int num_reg; | ||
1372 | 1442 | ||
1373 | if (debug_print) { | ||
1374 | char chunk_factor; | ||
1375 | unsigned long chunk_base; | ||
1376 | |||
1377 | chunk_base = to_size_factor(chunk_size>>10, &chunk_factor), | ||
1378 | printk(KERN_INFO "\n"); | ||
1379 | printk(KERN_INFO "gran_size: %ld%c chunk_size: %ld%c \n", | ||
1380 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
1381 | } | ||
1382 | if (i >= NUM_RESULT) | 1443 | if (i >= NUM_RESULT) |
1383 | continue; | 1444 | continue; |
1384 | 1445 | ||
1385 | /* convert ranges to var ranges state */ | 1446 | mtrr_calc_range_state(chunk_size, gran_size, |
1386 | num_reg = x86_setup_var_mtrrs(range, nr_range, | 1447 | extra_remove_base, extra_remove_size, i); |
1387 | chunk_size, gran_size); | 1448 | if (debug_print) { |
1388 | 1449 | mtrr_print_out_one_result(i); | |
1389 | /* we got new setting in range_state, check it */ | 1450 | printk(KERN_INFO "\n"); |
1390 | memset(range_new, 0, sizeof(range_new)); | ||
1391 | nr_range_new = x86_get_mtrr_mem_range(range_new, 0, | ||
1392 | extra_remove_base, extra_remove_size); | ||
1393 | range_sums_new = sum_ranges(range_new, nr_range_new); | ||
1394 | |||
1395 | result[i].chunk_sizek = chunk_size >> 10; | ||
1396 | result[i].gran_sizek = gran_size >> 10; | ||
1397 | result[i].num_reg = num_reg; | ||
1398 | if (range_sums < range_sums_new) { | ||
1399 | result[i].lose_cover_sizek = | ||
1400 | (range_sums_new - range_sums) << PSHIFT; | ||
1401 | result[i].bad = 1; | ||
1402 | } else | ||
1403 | result[i].lose_cover_sizek = | ||
1404 | (range_sums - range_sums_new) << PSHIFT; | ||
1405 | |||
1406 | /* double check it */ | ||
1407 | if (!result[i].bad && !result[i].lose_cover_sizek) { | ||
1408 | if (nr_range_new != nr_range || | ||
1409 | memcmp(range, range_new, sizeof(range))) | ||
1410 | result[i].bad = 1; | ||
1411 | } | 1451 | } |
1412 | 1452 | ||
1413 | if (!result[i].bad && (range_sums - range_sums_new < | ||
1414 | min_loss_pfn[num_reg])) { | ||
1415 | min_loss_pfn[num_reg] = | ||
1416 | range_sums - range_sums_new; | ||
1417 | } | ||
1418 | i++; | 1453 | i++; |
1419 | } | 1454 | } |
1420 | } | 1455 | } |
1421 | 1456 | ||
1422 | /* print out all */ | ||
1423 | for (i = 0; i < NUM_RESULT; i++) { | ||
1424 | char gran_factor, chunk_factor, lose_factor; | ||
1425 | unsigned long gran_base, chunk_base, lose_base; | ||
1426 | |||
1427 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | ||
1428 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | ||
1429 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
1430 | printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t", | ||
1431 | result[i].bad?"*BAD*":" ", | ||
1432 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
1433 | printk(KERN_CONT "num_reg: %d \tlose cover RAM: %s%ld%c\n", | ||
1434 | result[i].num_reg, result[i].bad?"-":"", | ||
1435 | lose_base, lose_factor); | ||
1436 | } | ||
1437 | |||
1438 | /* try to find the optimal index */ | 1457 | /* try to find the optimal index */ |
1439 | if (nr_mtrr_spare_reg >= num_var_ranges) | 1458 | index_good = mtrr_search_optimal_index(); |
1440 | nr_mtrr_spare_reg = num_var_ranges - 1; | ||
1441 | num_reg_good = -1; | ||
1442 | for (i = num_var_ranges - nr_mtrr_spare_reg; i > 0; i--) { | ||
1443 | if (!min_loss_pfn[i]) | ||
1444 | num_reg_good = i; | ||
1445 | } | ||
1446 | |||
1447 | index_good = -1; | ||
1448 | if (num_reg_good != -1) { | ||
1449 | for (i = 0; i < NUM_RESULT; i++) { | ||
1450 | if (!result[i].bad && | ||
1451 | result[i].num_reg == num_reg_good && | ||
1452 | !result[i].lose_cover_sizek) { | ||
1453 | index_good = i; | ||
1454 | break; | ||
1455 | } | ||
1456 | } | ||
1457 | } | ||
1458 | 1459 | ||
1459 | if (index_good != -1) { | 1460 | if (index_good != -1) { |
1460 | char gran_factor, chunk_factor, lose_factor; | ||
1461 | unsigned long gran_base, chunk_base, lose_base; | ||
1462 | |||
1463 | printk(KERN_INFO "Found optimal setting for mtrr clean up\n"); | 1461 | printk(KERN_INFO "Found optimal setting for mtrr clean up\n"); |
1464 | i = index_good; | 1462 | i = index_good; |
1465 | gran_base = to_size_factor(result[i].gran_sizek, &gran_factor), | 1463 | mtrr_print_out_one_result(i); |
1466 | chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor), | 1464 | |
1467 | lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor), | ||
1468 | printk(KERN_INFO "gran_size: %ld%c \tchunk_size: %ld%c \t", | ||
1469 | gran_base, gran_factor, chunk_base, chunk_factor); | ||
1470 | printk(KERN_CONT "num_reg: %d \tlose RAM: %ld%c\n", | ||
1471 | result[i].num_reg, lose_base, lose_factor); | ||
1472 | /* convert ranges to var ranges state */ | 1465 | /* convert ranges to var ranges state */ |
1473 | chunk_size = result[i].chunk_sizek; | 1466 | chunk_size = result[i].chunk_sizek; |
1474 | chunk_size <<= 10; | 1467 | chunk_size <<= 10; |
1475 | gran_size = result[i].gran_sizek; | 1468 | gran_size = result[i].gran_sizek; |
1476 | gran_size <<= 10; | 1469 | gran_size <<= 10; |
1477 | debug_print++; | ||
1478 | x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size); | 1470 | x86_setup_var_mtrrs(range, nr_range, chunk_size, gran_size); |
1479 | debug_print--; | ||
1480 | set_var_mtrr_all(address_bits); | 1471 | set_var_mtrr_all(address_bits); |
1472 | printk(KERN_DEBUG "New variable MTRRs\n"); | ||
1473 | print_out_mtrr_range_state(); | ||
1481 | return 1; | 1474 | return 1; |
1475 | } else { | ||
1476 | /* print out all */ | ||
1477 | for (i = 0; i < NUM_RESULT; i++) | ||
1478 | mtrr_print_out_one_result(i); | ||
1482 | } | 1479 | } |
1483 | 1480 | ||
1484 | printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n"); | 1481 | printk(KERN_INFO "mtrr_cleanup: can not find optimal value\n"); |
@@ -1562,7 +1559,6 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn) | |||
1562 | { | 1559 | { |
1563 | unsigned long i, base, size, highest_pfn = 0, def, dummy; | 1560 | unsigned long i, base, size, highest_pfn = 0, def, dummy; |
1564 | mtrr_type type; | 1561 | mtrr_type type; |
1565 | int nr_range; | ||
1566 | u64 total_trim_size; | 1562 | u64 total_trim_size; |
1567 | 1563 | ||
1568 | /* extra one for all 0 */ | 1564 | /* extra one for all 0 */ |