Merge branch 'akpm' (fixes from Andrew)

+22 -8

drivers/mfd/sec-core.c

··· 81 81 82 82 int sec_reg_read(struct sec_pmic_dev *sec_pmic, u8 reg, void *dest) 83 83 { 84 - return regmap_read(sec_pmic->regmap, reg, dest); 84 + return regmap_read(sec_pmic->regmap_pmic, reg, dest); 85 85 } 86 86 EXPORT_SYMBOL_GPL(sec_reg_read); 87 87 88 88 int sec_bulk_read(struct sec_pmic_dev *sec_pmic, u8 reg, int count, u8 *buf) 89 89 { 90 - return regmap_bulk_read(sec_pmic->regmap, reg, buf, count); 90 + return regmap_bulk_read(sec_pmic->regmap_pmic, reg, buf, count); 91 91 } 92 92 EXPORT_SYMBOL_GPL(sec_bulk_read); 93 93 94 94 int sec_reg_write(struct sec_pmic_dev *sec_pmic, u8 reg, u8 value) 95 95 { 96 - return regmap_write(sec_pmic->regmap, reg, value); 96 + return regmap_write(sec_pmic->regmap_pmic, reg, value); 97 97 } 98 98 EXPORT_SYMBOL_GPL(sec_reg_write); 99 99 100 100 int sec_bulk_write(struct sec_pmic_dev *sec_pmic, u8 reg, int count, u8 *buf) 101 101 { 102 - return regmap_raw_write(sec_pmic->regmap, reg, buf, count); 102 + return regmap_raw_write(sec_pmic->regmap_pmic, reg, buf, count); 103 103 } 104 104 EXPORT_SYMBOL_GPL(sec_bulk_write); 105 105 106 106 int sec_reg_update(struct sec_pmic_dev *sec_pmic, u8 reg, u8 val, u8 mask) 107 107 { 108 - return regmap_update_bits(sec_pmic->regmap, reg, mask, val); 108 + return regmap_update_bits(sec_pmic->regmap_pmic, reg, mask, val); 109 109 } 110 110 EXPORT_SYMBOL_GPL(sec_reg_update); 111 111 ··· 164 164 .max_register = S5M8767_REG_LDO28CTRL, 165 165 .volatile_reg = s2mps11_volatile, 166 166 .cache_type = REGCACHE_FLAT, 167 + }; 168 + 169 + static const struct regmap_config sec_rtc_regmap_config = { 170 + .reg_bits = 8, 171 + .val_bits = 8, 167 172 }; 168 173 169 174 #ifdef CONFIG_OF ··· 271 266 break; 272 267 } 273 268 274 - sec_pmic->regmap = devm_regmap_init_i2c(i2c, regmap); 275 - if (IS_ERR(sec_pmic->regmap)) { 276 - ret = PTR_ERR(sec_pmic->regmap); 269 + sec_pmic->regmap_pmic = devm_regmap_init_i2c(i2c, regmap); 270 + if (IS_ERR(sec_pmic->regmap_pmic)) { 271 + ret = PTR_ERR(sec_pmic->regmap_pmic); 277 272 dev_err(&i2c->dev, "Failed to allocate register map: %d\n", 278 273 ret); 279 274 return ret; ··· 281 276 282 277 sec_pmic->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); 283 278 i2c_set_clientdata(sec_pmic->rtc, sec_pmic); 279 + 280 + sec_pmic->regmap_rtc = devm_regmap_init_i2c(sec_pmic->rtc, 281 + &sec_rtc_regmap_config); 282 + if (IS_ERR(sec_pmic->regmap_rtc)) { 283 + ret = PTR_ERR(sec_pmic->regmap_rtc); 284 + dev_err(&i2c->dev, "Failed to allocate RTC register map: %d\n", 285 + ret); 286 + return ret; 287 + } 284 288 285 289 if (pdata && pdata->cfg_pmic_irq) 286 290 pdata->cfg_pmic_irq();

+3 -3

drivers/mfd/sec-irq.c

··· 280 280 281 281 switch (type) { 282 282 case S5M8763X: 283 - ret = regmap_add_irq_chip(sec_pmic->regmap, sec_pmic->irq, 283 + ret = regmap_add_irq_chip(sec_pmic->regmap_pmic, sec_pmic->irq, 284 284 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 285 285 sec_pmic->irq_base, &s5m8763_irq_chip, 286 286 &sec_pmic->irq_data); 287 287 break; 288 288 case S5M8767X: 289 - ret = regmap_add_irq_chip(sec_pmic->regmap, sec_pmic->irq, 289 + ret = regmap_add_irq_chip(sec_pmic->regmap_pmic, sec_pmic->irq, 290 290 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 291 291 sec_pmic->irq_base, &s5m8767_irq_chip, 292 292 &sec_pmic->irq_data); 293 293 break; 294 294 case S2MPS11X: 295 - ret = regmap_add_irq_chip(sec_pmic->regmap, sec_pmic->irq, 295 + ret = regmap_add_irq_chip(sec_pmic->regmap_pmic, sec_pmic->irq, 296 296 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 297 297 sec_pmic->irq_base, &s2mps11_irq_chip, 298 298 &sec_pmic->irq_data);

+1 -1

drivers/regulator/s5m8767.c

··· 925 925 config.dev = s5m8767->dev; 926 926 config.init_data = pdata->regulators[i].initdata; 927 927 config.driver_data = s5m8767; 928 - config.regmap = iodev->regmap; 928 + config.regmap = iodev->regmap_pmic; 929 929 config.of_node = pdata->regulators[i].reg_node; 930 930 931 931 rdev[i] = devm_regulator_register(&pdev->dev, &regulators[id],

+2

drivers/rtc/rtc-at91rm9200.c

··· 220 220 221 221 at91_alarm_year = tm.tm_year; 222 222 223 + tm.tm_mon = alrm->time.tm_mon; 224 + tm.tm_mday = alrm->time.tm_mday; 223 225 tm.tm_hour = alrm->time.tm_hour; 224 226 tm.tm_min = alrm->time.tm_min; 225 227 tm.tm_sec = alrm->time.tm_sec;

+85 -33

drivers/rtc/rtc-s5m.c

··· 28 28 #include <linux/mfd/samsung/irq.h> 29 29 #include <linux/mfd/samsung/rtc.h> 30 30 31 + /* 32 + * Maximum number of retries for checking changes in UDR field 33 + * of SEC_RTC_UDR_CON register (to limit possible endless loop). 34 + * 35 + * After writing to RTC registers (setting time or alarm) read the UDR field 36 + * in SEC_RTC_UDR_CON register. UDR is auto-cleared when data have 37 + * been transferred. 38 + */ 39 + #define UDR_READ_RETRY_CNT 5 40 + 31 41 struct s5m_rtc_info { 32 42 struct device *dev; 33 43 struct sec_pmic_dev *s5m87xx; 34 - struct regmap *rtc; 44 + struct regmap *regmap; 35 45 struct rtc_device *rtc_dev; 36 46 int irq; 37 47 int device_type; ··· 94 84 } 95 85 } 96 86 87 + /* 88 + * Read RTC_UDR_CON register and wait till UDR field is cleared. 89 + * This indicates that time/alarm update ended. 90 + */ 91 + static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info) 92 + { 93 + int ret, retry = UDR_READ_RETRY_CNT; 94 + unsigned int data; 95 + 96 + do { 97 + ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data); 98 + } while (--retry && (data & RTC_UDR_MASK) && !ret); 99 + 100 + if (!retry) 101 + dev_err(info->dev, "waiting for UDR update, reached max number of retries\n"); 102 + 103 + return ret; 104 + } 105 + 97 106 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info) 98 107 { 99 108 int ret; 100 109 unsigned int data; 101 110 102 - ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data); 111 + ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data); 103 112 if (ret < 0) { 104 113 dev_err(info->dev, "failed to read update reg(%d)\n", ret); 105 114 return ret; ··· 127 98 data |= RTC_TIME_EN_MASK; 128 99 data |= RTC_UDR_MASK; 129 100 130 - ret = regmap_write(info->rtc, SEC_RTC_UDR_CON, data); 101 + ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data); 131 102 if (ret < 0) { 132 103 dev_err(info->dev, "failed to write update reg(%d)\n", ret); 133 104 return ret; 134 105 } 135 106 136 - do { 137 - ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data); 138 - } while ((data & RTC_UDR_MASK) && !ret); 107 + ret = s5m8767_wait_for_udr_update(info); 139 108 140 109 return ret; 141 110 } ··· 143 116 int ret; 144 117 unsigned int data; 145 118 146 - ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data); 119 + ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &data); 147 120 if (ret < 0) { 148 121 dev_err(info->dev, "%s: fail to read update reg(%d)\n", 149 122 __func__, ret); ··· 153 126 data &= ~RTC_TIME_EN_MASK; 154 127 data |= RTC_UDR_MASK; 155 128 156 - ret = regmap_write(info->rtc, SEC_RTC_UDR_CON, data); 129 + ret = regmap_write(info->regmap, SEC_RTC_UDR_CON, data); 157 130 if (ret < 0) { 158 131 dev_err(info->dev, "%s: fail to write update reg(%d)\n", 159 132 __func__, ret); 160 133 return ret; 161 134 } 162 135 163 - do { 164 - ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &data); 165 - } while ((data & RTC_UDR_MASK) && !ret); 136 + ret = s5m8767_wait_for_udr_update(info); 166 137 167 138 return ret; 168 139 } ··· 203 178 u8 data[8]; 204 179 int ret; 205 180 206 - ret = regmap_bulk_read(info->rtc, SEC_RTC_SEC, data, 8); 181 + ret = regmap_bulk_read(info->regmap, SEC_RTC_SEC, data, 8); 207 182 if (ret < 0) 208 183 return ret; 209 184 ··· 251 226 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, 252 227 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday); 253 228 254 - ret = regmap_raw_write(info->rtc, SEC_RTC_SEC, data, 8); 229 + ret = regmap_raw_write(info->regmap, SEC_RTC_SEC, data, 8); 255 230 if (ret < 0) 256 231 return ret; 257 232 ··· 267 242 unsigned int val; 268 243 int ret, i; 269 244 270 - ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8); 245 + ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8); 271 246 if (ret < 0) 272 247 return ret; 273 248 274 249 switch (info->device_type) { 275 250 case S5M8763X: 276 251 s5m8763_data_to_tm(data, &alrm->time); 277 - ret = regmap_read(info->rtc, SEC_ALARM0_CONF, &val); 252 + ret = regmap_read(info->regmap, SEC_ALARM0_CONF, &val); 278 253 if (ret < 0) 279 254 return ret; 280 255 281 256 alrm->enabled = !!val; 282 257 283 - ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val); 258 + ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val); 284 259 if (ret < 0) 285 260 return ret; 286 261 ··· 303 278 } 304 279 305 280 alrm->pending = 0; 306 - ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val); 281 + ret = regmap_read(info->regmap, SEC_RTC_STATUS, &val); 307 282 if (ret < 0) 308 283 return ret; 309 284 break; ··· 326 301 int ret, i; 327 302 struct rtc_time tm; 328 303 329 - ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8); 304 + ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8); 330 305 if (ret < 0) 331 306 return ret; 332 307 ··· 337 312 338 313 switch (info->device_type) { 339 314 case S5M8763X: 340 - ret = regmap_write(info->rtc, SEC_ALARM0_CONF, 0); 315 + ret = regmap_write(info->regmap, SEC_ALARM0_CONF, 0); 341 316 break; 342 317 343 318 case S5M8767X: 344 319 for (i = 0; i < 7; i++) 345 320 data[i] &= ~ALARM_ENABLE_MASK; 346 321 347 - ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8); 322 + ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8); 348 323 if (ret < 0) 349 324 return ret; 350 325 ··· 366 341 u8 alarm0_conf; 367 342 struct rtc_time tm; 368 343 369 - ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8); 344 + ret = regmap_bulk_read(info->regmap, SEC_ALARM0_SEC, data, 8); 370 345 if (ret < 0) 371 346 return ret; 372 347 ··· 378 353 switch (info->device_type) { 379 354 case S5M8763X: 380 355 alarm0_conf = 0x77; 381 - ret = regmap_write(info->rtc, SEC_ALARM0_CONF, alarm0_conf); 356 + ret = regmap_write(info->regmap, SEC_ALARM0_CONF, alarm0_conf); 382 357 break; 383 358 384 359 case S5M8767X: ··· 393 368 if (data[RTC_YEAR1] & 0x7f) 394 369 data[RTC_YEAR1] |= ALARM_ENABLE_MASK; 395 370 396 - ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8); 371 + ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8); 397 372 if (ret < 0) 398 373 return ret; 399 374 ret = s5m8767_rtc_set_alarm_reg(info); ··· 435 410 if (ret < 0) 436 411 return ret; 437 412 438 - ret = regmap_raw_write(info->rtc, SEC_ALARM0_SEC, data, 8); 413 + ret = regmap_raw_write(info->regmap, SEC_ALARM0_SEC, data, 8); 439 414 if (ret < 0) 440 415 return ret; 441 416 ··· 480 455 static void s5m_rtc_enable_wtsr(struct s5m_rtc_info *info, bool enable) 481 456 { 482 457 int ret; 483 - ret = regmap_update_bits(info->rtc, SEC_WTSR_SMPL_CNTL, 458 + ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL, 484 459 WTSR_ENABLE_MASK, 485 460 enable ? WTSR_ENABLE_MASK : 0); 486 461 if (ret < 0) ··· 491 466 static void s5m_rtc_enable_smpl(struct s5m_rtc_info *info, bool enable) 492 467 { 493 468 int ret; 494 - ret = regmap_update_bits(info->rtc, SEC_WTSR_SMPL_CNTL, 469 + ret = regmap_update_bits(info->regmap, SEC_WTSR_SMPL_CNTL, 495 470 SMPL_ENABLE_MASK, 496 471 enable ? SMPL_ENABLE_MASK : 0); 497 472 if (ret < 0) ··· 506 481 int ret; 507 482 struct rtc_time tm; 508 483 509 - ret = regmap_read(info->rtc, SEC_RTC_UDR_CON, &tp_read); 484 + ret = regmap_read(info->regmap, SEC_RTC_UDR_CON, &tp_read); 510 485 if (ret < 0) { 511 486 dev_err(info->dev, "%s: fail to read control reg(%d)\n", 512 487 __func__, ret); ··· 518 493 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 519 494 520 495 info->rtc_24hr_mode = 1; 521 - ret = regmap_raw_write(info->rtc, SEC_ALARM0_CONF, data, 2); 496 + ret = regmap_raw_write(info->regmap, SEC_ALARM0_CONF, data, 2); 522 497 if (ret < 0) { 523 498 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", 524 499 __func__, ret); ··· 540 515 ret = s5m_rtc_set_time(info->dev, &tm); 541 516 } 542 517 543 - ret = regmap_update_bits(info->rtc, SEC_RTC_UDR_CON, 518 + ret = regmap_update_bits(info->regmap, SEC_RTC_UDR_CON, 544 519 RTC_TCON_MASK, tp_read | RTC_TCON_MASK); 545 520 if (ret < 0) 546 521 dev_err(info->dev, "%s: fail to update TCON reg(%d)\n", ··· 567 542 568 543 info->dev = &pdev->dev; 569 544 info->s5m87xx = s5m87xx; 570 - info->rtc = s5m87xx->rtc; 545 + info->regmap = s5m87xx->regmap_rtc; 571 546 info->device_type = s5m87xx->device_type; 572 547 info->wtsr_smpl = s5m87xx->wtsr_smpl; 573 548 574 549 switch (pdata->device_type) { 575 550 case S5M8763X: 576 - info->irq = s5m87xx->irq_base + S5M8763_IRQ_ALARM0; 551 + info->irq = regmap_irq_get_virq(s5m87xx->irq_data, 552 + S5M8763_IRQ_ALARM0); 577 553 break; 578 554 579 555 case S5M8767X: 580 - info->irq = s5m87xx->irq_base + S5M8767_IRQ_RTCA1; 556 + info->irq = regmap_irq_get_virq(s5m87xx->irq_data, 557 + S5M8767_IRQ_RTCA1); 581 558 break; 582 559 583 560 default: ··· 623 596 if (info->wtsr_smpl) { 624 597 for (i = 0; i < 3; i++) { 625 598 s5m_rtc_enable_wtsr(info, false); 626 - regmap_read(info->rtc, SEC_WTSR_SMPL_CNTL, &val); 599 + regmap_read(info->regmap, SEC_WTSR_SMPL_CNTL, &val); 627 600 pr_debug("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val); 628 601 if (val & WTSR_ENABLE_MASK) 629 602 pr_emerg("%s: fail to disable WTSR\n", ··· 639 612 s5m_rtc_enable_smpl(info, false); 640 613 } 641 614 615 + static int s5m_rtc_resume(struct device *dev) 616 + { 617 + struct s5m_rtc_info *info = dev_get_drvdata(dev); 618 + int ret = 0; 619 + 620 + if (device_may_wakeup(dev)) 621 + ret = disable_irq_wake(info->irq); 622 + 623 + return ret; 624 + } 625 + 626 + static int s5m_rtc_suspend(struct device *dev) 627 + { 628 + struct s5m_rtc_info *info = dev_get_drvdata(dev); 629 + int ret = 0; 630 + 631 + if (device_may_wakeup(dev)) 632 + ret = enable_irq_wake(info->irq); 633 + 634 + return ret; 635 + } 636 + 637 + static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume); 638 + 642 639 static const struct platform_device_id s5m_rtc_id[] = { 643 640 { "s5m-rtc", 0 }, 644 641 }; ··· 671 620 .driver = { 672 621 .name = "s5m-rtc", 673 622 .owner = THIS_MODULE, 623 + .pm = &s5m_rtc_pm_ops, 674 624 }, 675 625 .probe = s5m_rtc_probe, 676 626 .shutdown = s5m_rtc_shutdown,

+9 -5

fs/proc/inode.c

··· 292 292 { 293 293 struct proc_dir_entry *pde = PDE(file_inode(file)); 294 294 unsigned long rv = -EIO; 295 - unsigned long (*get_area)(struct file *, unsigned long, unsigned long, 296 - unsigned long, unsigned long) = NULL; 295 + 297 296 if (use_pde(pde)) { 297 + typeof(proc_reg_get_unmapped_area) *get_area; 298 + 299 + get_area = pde->proc_fops->get_unmapped_area; 298 300 #ifdef CONFIG_MMU 299 - get_area = current->mm->get_unmapped_area; 301 + if (!get_area) 302 + get_area = current->mm->get_unmapped_area; 300 303 #endif 301 - if (pde->proc_fops->get_unmapped_area) 302 - get_area = pde->proc_fops->get_unmapped_area; 304 + 303 305 if (get_area) 304 306 rv = get_area(file, orig_addr, len, pgoff, flags); 307 + else 308 + rv = orig_addr; 305 309 unuse_pde(pde); 306 310 } 307 311 return rv;

+4 -1

include/linux/hugetlb.h

··· 142 142 return 0; 143 143 } 144 144 145 - #define isolate_huge_page(p, l) false 145 + static inline bool isolate_huge_page(struct page *page, struct list_head *list) 146 + { 147 + return false; 148 + } 146 149 #define putback_active_hugepage(p) do {} while (0) 147 150 #define is_hugepage_active(x) false 148 151

+2 -1

include/linux/kernel.h

··· 193 193 (__x < 0) ? -__x : __x; \ 194 194 }) 195 195 196 - #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP) 196 + #if defined(CONFIG_MMU) && \ 197 + (defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP)) 197 198 void might_fault(void); 198 199 #else 199 200 static inline void might_fault(void) { }

+2 -1

include/linux/mfd/samsung/core.h

··· 39 39 struct sec_pmic_dev { 40 40 struct device *dev; 41 41 struct sec_platform_data *pdata; 42 - struct regmap *regmap; 42 + struct regmap *regmap_pmic; 43 + struct regmap *regmap_rtc; 43 44 struct i2c_client *i2c; 44 45 struct i2c_client *rtc; 45 46

+11 -1

mm/huge_memory.c

··· 1481 1481 pmd = pmdp_get_and_clear(mm, old_addr, old_pmd); 1482 1482 VM_BUG_ON(!pmd_none(*new_pmd)); 1483 1483 set_pmd_at(mm, new_addr, new_pmd, pmd_mksoft_dirty(pmd)); 1484 - if (new_ptl != old_ptl) 1484 + if (new_ptl != old_ptl) { 1485 + pgtable_t pgtable; 1486 + 1487 + /* 1488 + * Move preallocated PTE page table if new_pmd is on 1489 + * different PMD page table. 1490 + */ 1491 + pgtable = pgtable_trans_huge_withdraw(mm, old_pmd); 1492 + pgtable_trans_huge_deposit(mm, new_pmd, pgtable); 1493 + 1485 1494 spin_unlock(new_ptl); 1495 + } 1486 1496 spin_unlock(old_ptl); 1487 1497 } 1488 1498 out:

+40 -1

mm/memcontrol.c

··· 2694 2694 goto bypass; 2695 2695 2696 2696 if (unlikely(task_in_memcg_oom(current))) 2697 - goto bypass; 2697 + goto nomem; 2698 + 2699 + if (gfp_mask & __GFP_NOFAIL) 2700 + oom = false; 2698 2701 2699 2702 /* 2700 2703 * We always charge the cgroup the mm_struct belongs to. ··· 6355 6352 static void mem_cgroup_css_free(struct cgroup_subsys_state *css) 6356 6353 { 6357 6354 struct mem_cgroup *memcg = mem_cgroup_from_css(css); 6355 + /* 6356 + * XXX: css_offline() would be where we should reparent all 6357 + * memory to prepare the cgroup for destruction. However, 6358 + * memcg does not do css_tryget() and res_counter charging 6359 + * under the same RCU lock region, which means that charging 6360 + * could race with offlining. Offlining only happens to 6361 + * cgroups with no tasks in them but charges can show up 6362 + * without any tasks from the swapin path when the target 6363 + * memcg is looked up from the swapout record and not from the 6364 + * current task as it usually is. A race like this can leak 6365 + * charges and put pages with stale cgroup pointers into 6366 + * circulation: 6367 + * 6368 + * #0 #1 6369 + * lookup_swap_cgroup_id() 6370 + * rcu_read_lock() 6371 + * mem_cgroup_lookup() 6372 + * css_tryget() 6373 + * rcu_read_unlock() 6374 + * disable css_tryget() 6375 + * call_rcu() 6376 + * offline_css() 6377 + * reparent_charges() 6378 + * res_counter_charge() 6379 + * css_put() 6380 + * css_free() 6381 + * pc->mem_cgroup = dead memcg 6382 + * add page to lru 6383 + * 6384 + * The bulk of the charges are still moved in offline_css() to 6385 + * avoid pinning a lot of pages in case a long-term reference 6386 + * like a swapout record is deferring the css_free() to long 6387 + * after offlining. But this makes sure we catch any charges 6388 + * made after offlining: 6389 + */ 6390 + mem_cgroup_reparent_charges(memcg); 6358 6391 6359 6392 memcg_destroy_kmem(memcg); 6360 6393 __mem_cgroup_free(memcg);

Configure Feed

Configure Feed