A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-05 19:31:57 -04:00
Code Issues Projects Releases Packages Wiki Activity

mm: zram: fix swapcached issue on kernel 5.4

Browse source 
Afer Zram backing dev setuped, zram will be treated as a ASYNC IO
swap device, no longer SYNC IO device, because WB pages do have IO
operation on swap in, so the optimization on skiping swapcache
for fast swap device will no longer be applyed on such case.

Now we refactor this optimization, skip the swapcache by checking
SYNC IO state on each swap page via ioctl. Reuse ioctl because we
should not break the GKI.

Change-Id: Ia1dc351eafc7c0b62126a3864a6da9136c2bfe6d
Signed-off-by: huangzq2 <huangzq2@motorola.com>
Reviewed-on: https://gerrit.mot.com/1898090
SLTApproved: Slta Waiver
SME-Granted: SME Approvals Granted
Tested-by: Jira Key
Reviewed-by: Yonghui Jia <jiayh2@motorola.com>
Reviewed-by: Zhizhong Ge <gezz1@motorola.com>
Reviewed-by: Huosheng Liao <liaohs@motorola.com>
Submit-Approved: Jira Key
This commit is contained in:
huangzq2 2021-03-11 09:49:55 +08:00 • committed by Xiaojun Ji
commit 824502c8d1
4 changed files with 55 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

25
drivers/block/zram/zram_drv.c
View file

@ -25,6 +25,7 @@
#include <linux/genhd.h>
#include <linux/highmem.h>
#include <linux/slab.h>
#include <linux/swap.h>
#include <linux/backing-dev.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
@ -1630,6 +1631,27 @@ static void zram_slot_free_notify(struct block_device *bdev,
zram_slot_unlock(zram, index);
}
/* Moto huangzq2: check sync_io state on swap entry,
* return 0 on wb page, else return 1.
*/
#ifdef CONFIG_ZRAM_WRITEBACK
static int zram_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long index)
{
struct zram *zram;
int has_sync_io = 1;
if (cmd != SWP_SYNCHRONOUS_IO) return -EINVAL;
zram = bdev->bd_disk->private_data;
zram_slot_lock(zram, index);
has_sync_io = zram_test_flag(zram, index, ZRAM_WB) ? 0 : 1;
zram_slot_unlock(zram, index);
return has_sync_io;
}
#endif
static int zram_rw_page(struct block_device *bdev, sector_t sector,
struct page *page, unsigned int op)
{
@ -1822,6 +1844,9 @@ static int zram_open(struct block_device *bdev, fmode_t mode)
static const struct block_device_operations zram_devops = {
.open = zram_open,
.swap_slot_free_notify = zram_slot_free_notify,
#ifdef CONFIG_ZRAM_WRITEBACK
.ioctl = zram_ioctl,
#endif
.rw_page = zram_rw_page,
.owner = THIS_MODULE
};

1
include/linux/swap.h
View file

@ -397,6 +397,7 @@ extern void end_swap_bio_write(struct bio *bio);
extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
bio_end_io_t end_write_func);
extern int swap_set_page_dirty(struct page *page);
extern bool swap_slot_has_sync_io(swp_entry_t entry);
int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
unsigned long nr_pages, sector_t start_block);

17
mm/memory.c
View file

@ -3089,9 +3089,18 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
if (!page) {
struct swap_info_struct *si = swp_swap_info(entry);
bool skip_swapcache = false;
if (si->flags & SWP_SYNCHRONOUS_IO &&
__swap_count(entry) == 1) {
/* Moto huangzq2: check sync_io on each page if we enabled Zram wb.
* Zram writeback will remove SWP_SYNCHRONOUS_IO flag as it has disk
* IO operation on writeback page during swap in.
*/
if (si->flags & SWP_SYNCHRONOUS_IO && __swap_count(entry) == 1)
skip_swapcache = true;
else if (__swap_count(entry) == 1 && swap_slot_has_sync_io(entry))
skip_swapcache = true;
if (skip_swapcache) {
/* skip swapcache */
page = alloc_page_vma(GFP_HIGHUSER_MOVABLE | __GFP_CMA
| __GFP_OFFLINABLE, vma,
@ -3115,8 +3124,8 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
ret = VM_FAULT_RETRY;
goto out;
} else {
page = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE,
vmf);
page = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE | __GFP_CMA
| __GFP_OFFLINABLE, vmf);
swapcache = page;
}

16
mm/page_io.c
View file

@ -71,6 +71,22 @@ void end_swap_bio_write(struct bio *bio)
bio_put(bio);
}
/* Moto huangzq2: check sync_io state on swap entry */
bool swap_slot_has_sync_io(swp_entry_t entry)
{
struct swap_info_struct *sis;
struct gendisk *disk;
sis = swp_swap_info(entry);
disk = sis->bdev->bd_disk;
if (disk->fops->ioctl) {
return disk->fops->ioctl(sis->bdev, 0,
SWP_SYNCHRONOUS_IO, swp_offset(entry)) == 1;
}
return false;
}
static void swap_slot_free_notify(struct page *page)
{
struct swap_info_struct *sis;