zram memory tracking

PATCH Superseded Minchan Kim 3 participants 9 messages Apr 16, 2018

Subsystems (3)

Documentation Block layer zram

lore

Share & tools

lore

Minchan Kim

author maintainer

2018-04-16 03:31 UTC #0 lore raw

v4 cover zram memory tracking

zRam as swap is useful for small memory device. However, swap means those pages on zram are mostly cold pages due to VM's LRU algorithm. Especially, once init data for application are touched for launching, they tend to be not accessed any more and finally swapped out. zRAM can store such cold pages as compressed form but it's pointless to keep in memory. As well, it's pointless to store incompressible pages to zram so better idea is app developers manages them directly like free or mlock rather than remaining them on heap.

This patch provides a debugfs /sys/kernel/debug/zram/zram0/block_state to represent each block's state so admin can investigate what memory is cold|incompressible|same page with using pagemap once the pages are swapped out.

The output is as follows,

      300    75.033841 .wh
      301    63.806904 s..
      302    63.806919 ..h

First column is zram's block index and 3rh one represents symbol (s: same page w: written page to backing store h: huge page) of the block state. Second column represents usec time unit of the block was last accessed. So above example means the 300th block is accessed at 75.033851 second and it was huge so it was written to the backing store.

* from v3:
* use depends on selecting DEBUG_FS - Greg KH
* Add acked-by from Greg
* Fix null ptr access at module unload - Sergey
* warning fix from copy_to_user - Sergey

* From v2:
* debugfs and Kconfig cleanup - Greg KH
* Remove unnecesarry buffer - Sergey
* Change timestamp from sec to usec

* From v1:
* Do not propagate error number for debugfs fail - Greg KH
* Add writeback and hugepage information - Sergey

Minchan Kim (4):
zram: correct flag name of ZRAM_ACCESS
zram: mark incompressible page as ZRAM_HUGE
zram: record accessed second
zram: introduce zram memory tracking

 Documentation/blockdev/zram.txt |  25 +++++
 drivers/block/zram/Kconfig      |  10 ++
 drivers/block/zram/zram_drv.c   | 173 +++++++++++++++++++++++++++++---
 drivers/block/zram/zram_drv.h   |  14 ++-
 4 files changed, 205 insertions(+), 17 deletions(-)

Signature · 1 line

2.17.0.484.g0c8726318c-goog

Minchan Kim

author maintainer

2018-04-16 03:31 UTC #1 lore raw

PATCH v4 1/4 zram: correct flag name of ZRAM_ACCESS

ZRAM_ACCESS is used for locking a slot of zram so correct the name. It is also not a common flag to indicate status of the block so move the declare position on top of the flag.
Lastly, let's move the function to the top of source code to be able to use it easily without forward declaration.

Signed-off-by Minchan Kim <[email protected]>

---
 drivers/block/zram/zram_drv.c | 20 ++++++++++----------
 drivers/block/zram/zram_drv.h |  6 +++---
 2 files changed, 13 insertions(+), 13 deletions(-)

drivers/block/zram/zram_drv.c +10 ~~-10~~

index 0f3fadd71230..18dadeab775b 100644
@@ -52,6 +52,16 @@ static size_t huge_class_size;
 
 static void zram_free_page(struct zram *zram, size_t index);
 
+static void zram_slot_lock(struct zram *zram, u32 index)
+{
+	bit_spin_lock(ZRAM_LOCK, &zram->table[index].value);
+}
+
+static void zram_slot_unlock(struct zram *zram, u32 index)
+{
+	bit_spin_unlock(ZRAM_LOCK, &zram->table[index].value);
+}
+
 static inline bool init_done(struct zram *zram)
 {
 	return zram->disksize;

@@ -753,16 +763,6 @@ static DEVICE_ATTR_RO(io_stat);
 static DEVICE_ATTR_RO(mm_stat);
 static DEVICE_ATTR_RO(debug_stat);
 
-static void zram_slot_lock(struct zram *zram, u32 index)
-{
-	bit_spin_lock(ZRAM_ACCESS, &zram->table[index].value);
-}
-
-static void zram_slot_unlock(struct zram *zram, u32 index)
-{
-	bit_spin_unlock(ZRAM_ACCESS, &zram->table[index].value);
-}
-
 static void zram_meta_free(struct zram *zram, u64 disksize)
 {
 	size_t num_pages = disksize >> PAGE_SHIFT;

drivers/block/zram/zram_drv.h +3 -3

index 008861220723..8d8959ceabd1 100644
@@ -43,9 +43,9 @@
 
 /* Flags for zram pages (table[page_no].value) */
 enum zram_pageflags {
-	/* Page consists the same element */
-	ZRAM_SAME = ZRAM_FLAG_SHIFT,
-	ZRAM_ACCESS,	/* page is now accessed */
+	/* zram slot is locked */
+	ZRAM_LOCK = ZRAM_FLAG_SHIFT,
+	ZRAM_SAME,	/* Page consists the same element */
 	ZRAM_WB,	/* page is stored on backing_device */
 
 	__NR_ZRAM_PAGEFLAGS,

Signature · 1 line

2.17.0.484.g0c8726318c-goog

Minchan Kim

author maintainer

2018-04-16 03:31 UTC #2 lore raw

PATCH v4 2/4 zram: mark incompressible page as ZRAM_HUGE

In reply to Minchan Kim

Mark incompressible pages so that we could investigate who is the owner of the incompressible pages once the page is swapped out via using upcoming zram memory tracker feature.

With it, we could prevent such pages to be swapped out by using mlock. Otherwise we might remove them.

This patch exposes new stat for huge pages via mm_stat.

Signed-off-by Minchan Kim <[email protected]>

---
 Documentation/blockdev/zram.txt |  1 +
 drivers/block/zram/zram_drv.c   | 17 ++++++++++++++---
 drivers/block/zram/zram_drv.h   |  2 ++
 3 files changed, 17 insertions(+), 3 deletions(-)

Documentation/blockdev/zram.txt +1 -0

index 257e65714c6a..78db38d02bc9 100644
@@ -218,6 +218,7 @@ The stat file represents device's mm statistics. It consists of a single
  same_pages       the number of same element filled pages written to this disk.
                   No memory is allocated for such pages.
  pages_compacted  the number of pages freed during compaction
+ huge_pages	  the number of incompressible pages
 
 9) Deactivate:
 	swapoff /dev/zram0

drivers/block/zram/zram_drv.c +14 -3

index 18dadeab775b..777fb3339f59 100644
@@ -729,14 +729,15 @@ static ssize_t mm_stat_show(struct device *dev,
 	max_used = atomic_long_read(&zram->stats.max_used_pages);
 
 	ret = scnprintf(buf, PAGE_SIZE,
-			"%8llu %8llu %8llu %8lu %8ld %8llu %8lu\n",
+			"%8llu %8llu %8llu %8lu %8ld %8llu %8lu %8llu\n",
 			orig_size << PAGE_SHIFT,
 			(u64)atomic64_read(&zram->stats.compr_data_size),
 			mem_used << PAGE_SHIFT,
 			zram->limit_pages << PAGE_SHIFT,
 			max_used << PAGE_SHIFT,
 			(u64)atomic64_read(&zram->stats.same_pages),
-			pool_stats.pages_compacted);
+			pool_stats.pages_compacted,
+			(u64)atomic64_read(&zram->stats.huge_pages));
 	up_read(&zram->init_lock);
 
 	return ret;

@@ -805,6 +806,11 @@ static void zram_free_page(struct zram *zram, size_t index)
 {
 	unsigned long handle;
 
+	if (zram_test_flag(zram, index, ZRAM_HUGE)) {
+		zram_clear_flag(zram, index, ZRAM_HUGE);
+		atomic64_dec(&zram->stats.huge_pages);
+	}
+
 	if (zram_wb_enabled(zram) && zram_test_flag(zram, index, ZRAM_WB)) {
 		zram_wb_clear(zram, index);
 		atomic64_dec(&zram->stats.pages_stored);

@@ -973,6 +979,7 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
 	}
 
 	if (unlikely(comp_len >= huge_class_size)) {
+		comp_len = PAGE_SIZE;
 		if (zram_wb_enabled(zram) && allow_wb) {
 			zcomp_stream_put(zram->comp);
 			ret = write_to_bdev(zram, bvec, index, bio, &element);

@@ -984,7 +991,6 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
 			allow_wb = false;
 			goto compress_again;
 		}
-		comp_len = PAGE_SIZE;
 	}
 
 	/*

@@ -1046,6 +1052,11 @@ static int __zram_bvec_write(struct zram *zram, struct bio_vec *bvec,
 	zram_slot_lock(zram, index);
 	zram_free_page(zram, index);
 
+	if (comp_len == PAGE_SIZE) {
+		zram_set_flag(zram, index, ZRAM_HUGE);
+		atomic64_inc(&zram->stats.huge_pages);
+	}
+
 	if (flags) {
 		zram_set_flag(zram, index, flags);
 		zram_set_element(zram, index, element);

drivers/block/zram/zram_drv.h +2 -0

index 8d8959ceabd1..ff0547bdb586 100644
@@ -47,6 +47,7 @@ enum zram_pageflags {
 	ZRAM_LOCK = ZRAM_FLAG_SHIFT,
 	ZRAM_SAME,	/* Page consists the same element */
 	ZRAM_WB,	/* page is stored on backing_device */
+	ZRAM_HUGE,	/* Incompressible page */
 
 	__NR_ZRAM_PAGEFLAGS,
 };

@@ -71,6 +72,7 @@ struct zram_stats {
 	atomic64_t invalid_io;	/* non-page-aligned I/O requests */
 	atomic64_t notify_free;	/* no. of swap slot free notifications */
 	atomic64_t same_pages;		/* no. of same element filled pages */
+	atomic64_t huge_pages;		/* no. of huge pages */
 	atomic64_t pages_stored;	/* no. of pages currently stored */
 	atomic_long_t max_used_pages;	/* no. of maximum pages stored */
 	atomic64_t writestall;		/* no. of write slow paths */

Signature · 1 line

2.17.0.484.g0c8726318c-goog

Minchan Kim

author maintainer

2018-04-16 03:31 UTC #3 lore raw

PATCH v4 3/4 zram: record accessed second

In reply to Minchan Kim

zRam as swap is useful for small memory device. However, swap means those pages on zram are mostly cold pages due to VM's LRU algorithm. Especially, once init data for application are touched for launching, they tend to be not accessed any more and finally swapped out. zRAM can store such cold pages as compressed form but it's pointless to keep in memory. Better idea is app developers free them directly rather than remaining them on heap.

This patch records last access time of each block of zram so that With upcoming zram memory tracking, it could help userspace developers to reduce memory footprint.

Signed-off-by Minchan Kim <[email protected]>

---
 drivers/block/zram/zram_drv.c | 16 ++++++++++++++++
 drivers/block/zram/zram_drv.h |  1 +
 2 files changed, 17 insertions(+)

drivers/block/zram/zram_drv.c +16 -0

index 777fb3339f59..7fc10e2ad734 100644
@@ -107,6 +107,16 @@ static inline void zram_set_element(struct zram *zram, u32 index,
 	zram->table[index].element = element;
 }
 
+static void zram_accessed(struct zram *zram, u32 index)
+{
+	zram->table[index].ac_time = sched_clock();
+}
+
+static void zram_reset_access(struct zram *zram, u32 index)
+{
+	zram->table[index].ac_time = 0;
+}
+
 static unsigned long zram_get_element(struct zram *zram, u32 index)
 {
 	return zram->table[index].element;

@@ -806,6 +816,8 @@ static void zram_free_page(struct zram *zram, size_t index)
 {
 	unsigned long handle;
 
+	zram_reset_access(zram, index);
+
 	if (zram_test_flag(zram, index, ZRAM_HUGE)) {
 		zram_clear_flag(zram, index, ZRAM_HUGE);
 		atomic64_dec(&zram->stats.huge_pages);

@@ -1177,6 +1189,10 @@ static int zram_bvec_rw(struct zram *zram, struct bio_vec *bvec, u32 index,
 
 	generic_end_io_acct(q, rw_acct, &zram->disk->part0, start_time);
 
+	zram_slot_lock(zram, index);
+	zram_accessed(zram, index);
+	zram_slot_unlock(zram, index);
+
 	if (unlikely(ret < 0)) {
 		if (!is_write)
 			atomic64_inc(&zram->stats.failed_reads);

drivers/block/zram/zram_drv.h +1 -0

index ff0547bdb586..1075218e88b2 100644
@@ -61,6 +61,7 @@ struct zram_table_entry {
 		unsigned long element;
 	};
 	unsigned long value;
+	u64 ac_time;
 };
 
 struct zram_stats {

Signature · 1 line

2.17.0.484.g0c8726318c-goog

Minchan Kim

author maintainer

2018-04-16 03:31 UTC #4 lore raw

PATCH v4 4/4 zram: introduce zram memory tracking

In reply to Minchan Kim

zRam as swap is useful for small memory device. However, swap means those pages on zram are mostly cold pages due to VM's LRU algorithm. Especially, once init data for application are touched for launching, they tend to be not accessed any more and finally swapped out. zRAM can store such cold pages as compressed form but it's pointless to keep in memory. Better idea is app developers free them directly rather than remaining them on heap.

This patch tell us last access time of each block of zram via "cat /sys/kernel/debug/zram/zram0/block_state".

The output is as follows,

      300    75.033841 .wh
      301    63.806904 s..
      302    63.806919 ..h

Admin can leverage this information to catch cold|incompressible pages of process with *pagemap* once part of heaps are swapped out.

Acked-by Greg Kroah-Hartman <[email protected]>

Signed-off-by Minchan Kim <[email protected]>

---
 Documentation/blockdev/zram.txt |  24 ++++++
 drivers/block/zram/Kconfig      |  10 +++
 drivers/block/zram/zram_drv.c   | 140 +++++++++++++++++++++++++++++---
 drivers/block/zram/zram_drv.h   |   5 ++
 4 files changed, 168 insertions(+), 11 deletions(-)

Documentation/blockdev/zram.txt +24 -0

index 78db38d02bc9..45509c7d5716 100644
@@ -243,5 +243,29 @@ to backing storage rather than keeping it in memory.
 User should set up backing device via /sys/block/zramX/backing_dev
 before disksize setting.
 
+= memory tracking
+
+With CONFIG_ZRAM_MEMORY_TRACKING, user can know information of the
+zram block. It could be useful to catch cold or incompressible
+pages of the proess with*pagemap.
+If you enable the feature, you could see block state via
+/sys/kernel/debug/zram/zram0/block_state". The output is as follows,
+
+	  300    75.033841 .wh
+	  301    63.806904 s..
+	  302    63.806919 ..h
+
+First column is zram's block index.
+Second column is access time.
+Third column is state of the block.
+(s: same page
+w: written page to backing store
+h: huge page)
+
+First line of above example says 300th block is accessed at 75.033841sec
+and the block's state is huge so it is written back to the backing
+storage. It's a debugging feature so anyone shouldn't rely on it to work
+properly.
+
 Nitin Gupta
 [email protected]

drivers/block/zram/Kconfig +10 -0

index ac3a31d433b2..01090338fb47 100644
@@ -26,3 +26,13 @@ config ZRAM_WRITEBACK
 	 /sys/block/zramX/backing_dev.
 
 	 See zram.txt for more infomration.
+
+config ZRAM_MEMORY_TRACKING
+	bool "Tracking zram block status"
+	depends on ZRAM && DEBUG_FS
+	help
+	  With this feature, admin can track the state of allocated block
+	  of zRAM. Admin could see the information via
+	  /sys/kernel/debug/zram/zramX/block_state.
+
+	  See zram.txt for more information.

drivers/block/zram/zram_drv.c +129 ~~-11~~

194 lines not on this page · raw message

drivers/block/zram/zram_drv.h +5 -0

index 1075218e88b2..dbe459b300c0 100644
@@ -61,7 +61,9 @@ struct zram_table_entry {
 		unsigned long element;
 	};
 	unsigned long value;
+#ifdef CONFIG_ZRAM_MEMORY_TRACKING
 	u64 ac_time;
+#endif
 };
 
 struct zram_stats {

@@ -110,5 +112,8 @@ struct zram {
 	unsigned long nr_pages;
 	spinlock_t bitmap_lock;
 #endif
+#ifdef CONFIG_ZRAM_MEMORY_TRACKING
+	struct dentry *debugfs_dir;
+#endif
 };
 #endif

Signature · 1 line

2.17.0.484.g0c8726318c-goog

Randy Dunlap

reviewer

2018-04-16 04:17 UTC #5 lore raw

Re: [PATCH v4 4/4] zram: introduce zram memory tracking

Quoted 40 lines · Minchan Kim

zRam as swap is useful for small memory device. However, swap means those pages on zram are mostly cold pages due to VM's LRU algorithm. Especially, once init data for application are touched for launching, they tend to be not accessed any more and finally swapped out. zRAM can store such cold pages as compressed form but it's pointless to keep in memory. Better idea is app developers free them directly rather than remaining them on heap.
This patch tell us last access time of each block of zram via "cat /sys/kernel/debug/zram/zram0/block_state".
The output is as follows,
      300    75.033841 .wh
      301    63.806904 s..
      302    63.806919 ..h
First column is zram's block index and 3rh one represents symbol (s: same page w: written page to backing store h: huge page) of the block state. Second column represents usec time unit of the block was last accessed. So above example means the 300th block is accessed at 75.033851 second and it was huge so it was written to the backing store.
Admin can leverage this information to catch cold|incompressible pages of process with *pagemap* once part of heaps are swapped out.
Acked-by Greg Kroah-Hartman <[email protected]>
Signed-off-by Minchan Kim <[email protected]>
---
 Documentation/blockdev/zram.txt |  24 ++++++
 drivers/block/zram/Kconfig      |  10 +++
 drivers/block/zram/zram_drv.c   | 140 +++++++++++++++++++++++++++++---
 drivers/block/zram/zram_drv.h   |   5 ++
 4 files changed, 168 insertions(+), 11 deletions(-)
Documentation/blockdev/zram.txt +0 -0
index 78db38d02bc9..45509c7d5716 100644

Documentation/blockdev/zram.txt to backing storage rather than keeping it in memory. · line 250

Quoted 8 lines

Documentation/blockdev/zram.txt +5 -0

@@ -243,5 +243,29 @@ to backing storage rather than keeping it in memory.
 User should set up backing device via /sys/block/zramX/backing_dev
 before disksize setting.
 
+= memory tracking
+
+With CONFIG_ZRAM_MEMORY_TRACKING, user can know information of the
+zram block. It could be useful to catch cold or incompressible
+pages of the proess with*pagemap.

? process

Quoted 26 lines

Documentation/blockdev/zram.txt +19 -0

+If you enable the feature, you could see block state via
+/sys/kernel/debug/zram/zram0/block_state". The output is as follows,
+
+	  300    75.033841 .wh
+	  301    63.806904 s..
+	  302    63.806919 ..h
+
+First column is zram's block index.
+Second column is access time.
+Third column is state of the block.
+(s: same page
+w: written page to backing store
+h: huge page)
+
+First line of above example says 300th block is accessed at 75.033841sec
+and the block's state is huge so it is written back to the backing
+storage. It's a debugging feature so anyone shouldn't rely on it to work
+properly.
+
 Nitin Gupta
 [email protected]

drivers/block/zram/Kconfig +0 -0

index ac3a31d433b2..01090338fb47 100644

drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 31

Quoted 6 lines

drivers/block/zram/Kconfig +3 -0

@@ -26,3 +26,13 @@ config ZRAM_WRITEBACK
 	 /sys/block/zramX/backing_dev.
 
 	 See zram.txt for more infomration.
+
+config ZRAM_MEMORY_TRACKING
+	bool "Tracking zram block status"

bool "Track zram block status"

although sometimes it is zRam or zRAM.

drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 34

Quoted 3 lines

drivers/block/zram/Kconfig +3 -0

+	depends on ZRAM && DEBUG_FS
+	help
+	  With this feature, admin can track the state of allocated block

blocks

drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 38

Quoted 4 lines

drivers/block/zram/Kconfig +4 -0

+	  of zRAM. Admin could see the information via
+	  /sys/kernel/debug/zram/zramX/block_state.
+
+	  See zram.txt for more information.

See Documentation/blockdev/zram.txt for more information.

Signature · 1 line

~Randy

Minchan Kim

author maintainer

2018-04-16 04:26 UTC #6 lore raw

Re: [PATCH v4 4/4] zram: introduce zram memory tracking

Quoted 96 lines · Randy Dunlap

Quoted 40 lines · Minchan Kim
zRam as swap is useful for small memory device. However, swap means those pages on zram are mostly cold pages due to VM's LRU algorithm. Especially, once init data for application are touched for launching, they tend to be not accessed any more and finally swapped out. zRAM can store such cold pages as compressed form but it's pointless to keep in memory. Better idea is app developers free them directly rather than remaining them on heap.
This patch tell us last access time of each block of zram via "cat /sys/kernel/debug/zram/zram0/block_state".
The output is as follows,
      300    75.033841 .wh
      301    63.806904 s..
      302    63.806919 ..h
First column is zram's block index and 3rh one represents symbol (s: same page w: written page to backing store h: huge page) of the block state. Second column represents usec time unit of the block was last accessed. So above example means the 300th block is accessed at 75.033851 second and it was huge so it was written to the backing store.
Admin can leverage this information to catch cold|incompressible pages of process with *pagemap* once part of heaps are swapped out.
Acked-by Greg Kroah-Hartman <[email protected]>
Signed-off-by Minchan Kim <[email protected]>
---
 Documentation/blockdev/zram.txt |  24 ++++++
 drivers/block/zram/Kconfig      |  10 +++
 drivers/block/zram/zram_drv.c   | 140 +++++++++++++++++++++++++++++---
 drivers/block/zram/zram_drv.h   |   5 ++
 4 files changed, 168 insertions(+), 11 deletions(-)
Documentation/blockdev/zram.txt +0 -0
index 78db38d02bc9..45509c7d5716 100644
Documentation/blockdev/zram.txt to backing storage rather than keeping it in memory. · line 250
Quoted 8 lines
Documentation/blockdev/zram.txt +5 -0
@@ -243,5 +243,29 @@ to backing storage rather than keeping it in memory.
 User should set up backing device via /sys/block/zramX/backing_dev
 before disksize setting.
 
+= memory tracking
+
+With CONFIG_ZRAM_MEMORY_TRACKING, user can know information of the
+zram block. It could be useful to catch cold or incompressible
+pages of the proess with*pagemap.
? process
Quoted 26 lines
Documentation/blockdev/zram.txt +19 -0
+If you enable the feature, you could see block state via
+/sys/kernel/debug/zram/zram0/block_state". The output is as follows,
+
+	  300    75.033841 .wh
+	  301    63.806904 s..
+	  302    63.806919 ..h
+
+First column is zram's block index.
+Second column is access time.
+Third column is state of the block.
+(s: same page
+w: written page to backing store
+h: huge page)
+
+First line of above example says 300th block is accessed at 75.033841sec
+and the block's state is huge so it is written back to the backing
+storage. It's a debugging feature so anyone shouldn't rely on it to work
+properly.
+
 Nitin Gupta
 [email protected]
drivers/block/zram/Kconfig +0 -0
index ac3a31d433b2..01090338fb47 100644
drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 31
Quoted 6 lines
drivers/block/zram/Kconfig +3 -0
@@ -26,3 +26,13 @@ config ZRAM_WRITEBACK
 	 /sys/block/zramX/backing_dev.
 
 	 See zram.txt for more infomration.
+
+config ZRAM_MEMORY_TRACKING
+	bool "Tracking zram block status"
bool "Track zram block status"
although sometimes it is zRam or zRAM.
drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 34
Quoted 3 lines
drivers/block/zram/Kconfig +3 -0
+	depends on ZRAM && DEBUG_FS
+	help
+	  With this feature, admin can track the state of allocated block
blocks

Quoted 6 lines

drivers/block/zram/Kconfig config ZRAM_WRITEBACK · line 38
Quoted 4 lines
drivers/block/zram/Kconfig +4 -0
+	  of zRAM. Admin could see the information via
+	  /sys/kernel/debug/zram/zramX/block_state.
+
+	  See zram.txt for more information.
See Documentation/blockdev/zram.txt for more information.

I just fix things. I will wait more feedback and then resend. Thanks for the review!

Sergey Senozhatsky

Reviewed-by on the v4 series

2018-04-16 07:42 UTC #7 lore raw

In reply to Minchan Kim

Quoted 5 lines · Minchan Kim

Minchan Kim (4):
zram: correct flag name of ZRAM_ACCESS
zram: mark incompressible page as ZRAM_HUGE
zram: record accessed second
zram: introduce zram memory tracking

Looks OK to me. After Randy's comments addressed:

Reviewed-by Sergey Senozhatsky <[email protected]>

-ss

Minchan Kim

author maintainer

2018-04-16 09:12 UTC #8 lore raw

Quoted 10 lines · Sergey Senozhatsky

Quoted 5 lines · Minchan Kim
Minchan Kim (4):
zram: correct flag name of ZRAM_ACCESS
zram: mark incompressible page as ZRAM_HUGE
zram: record accessed second
zram: introduce zram memory tracking
Looks OK to me. After Randy's comments addressed:
Reviewed-by Sergey Senozhatsky <[email protected]>

Thanks for the review, Sergey!