Fix can't parser zram on kernel 6.11

Author: quic-wya

binder/binder.cpp

@@ -460,6 +460,10 @@ void Binder::print_binder_ref_olocked(ulong ref_addr) {
         void *binder_proc_buf = read_struct((ulong)node.proc,"binder_proc");
         if(binder_proc_buf == nullptr) return;
         ulong tsk_addr = ULONG(binder_proc_buf + field_offset(binder_proc,tsk));
+        if (!is_kvaddr(tsk_addr)) {
+            FREEBUF(binder_proc_buf);
+            return;
+        }
         int pid = UINT(binder_proc_buf + field_offset(binder_proc,pid));
         std::string task_name = read_cstring(tsk_addr + field_offset(task_struct,comm),16, "task_struct_comm");
         fprintf(fp, "  binder_ref:%#lx id:%d desc:%d s:%d w:%d death:%#lx -> node_id:%d binder_proc:%#lx %s[%d]\n",ref_addr,

defs.h

@@ -7532,13 +7532,19 @@ struct zspage {
             unsigned int isolated : 3;
             unsigned int magic : 8;
         } v5_17;
-	struct {
+        struct {
             unsigned int huge : 1;
             unsigned int fullness : 4;
             unsigned int class_id : 9;
             unsigned int isolated : 5;
             unsigned int magic : 8;
         } v6_6;
+        struct {
+            unsigned int huge : 1;
+            unsigned int fullness : 4;
+            unsigned int class_id : 9;
+            unsigned int magic : 8;
+        } v6_12;
     };
     unsigned int inuse;
     unsigned int freeobj;

memory/zram.cpp

@@ -214,21 +214,42 @@ void Zram::print_mem_pool(std::string zram_addr){
         << std::left << std::setw(13) << "OBJ_ALLOCATED" << " "
         << "OBJ_USED";
     fprintf(fp, "%s \n",oss_hd.str().c_str());
-
+    std::vector<std::string> class_stat_type = get_enumerator_list("class_stat_type");
+    int CLASS_EMPTY = 0;
+    int CLASS_ALMOST_EMPTY = 0;
+    int CLASS_ALMOST_FULL = 0;
+    int CLASS_FULL = 0;
+    int OBJ_ALLOCATED = 0;
+    int OBJ_USED = 0;
+    if (class_stat_type.size() > 0){
+        CLASS_EMPTY = read_enum_val("ZS_INUSE_RATIO_0");
+        CLASS_ALMOST_EMPTY = read_enum_val("ZS_INUSE_RATIO_10");
+        CLASS_ALMOST_FULL = read_enum_val("ZS_INUSE_RATIO_99");
+        CLASS_FULL = read_enum_val("ZS_INUSE_RATIO_100");
+        OBJ_ALLOCATED = read_enum_val("ZS_OBJS_ALLOCATED");
+        OBJ_USED = read_enum_val("ZS_OBJS_INUSE");
+    }else{
+        CLASS_EMPTY = read_enum_val("CLASS_EMPTY");
+        CLASS_ALMOST_EMPTY = read_enum_val("CLASS_ALMOST_EMPTY");
+        CLASS_ALMOST_FULL = read_enum_val("CLASS_ALMOST_FULL");
+        CLASS_FULL = read_enum_val("CLASS_FULL");
+        OBJ_ALLOCATED = read_enum_val("OBJ_ALLOCATED");
+        OBJ_USED = read_enum_val("OBJ_USED");
+    }
     for (size_t i = 0; i < pool_ptr->class_list.size(); i++){
         std::shared_ptr<size_class> class_ptr = pool_ptr->class_list[i];
         std::ostringstream oss;
-        oss << std::dec << std::setw(5) << std::setfill('0') << i << " "
+        oss << "[" << std::dec << std::setw(5) << std::setfill('0') << i << "] "
             << std::left << std::hex << std::setw(VADDR_PRLEN) << std::setfill(' ') << class_ptr->addr << " "
-            << std::left << std::dec << std::setw(5) << class_ptr->stats.objs[zs_stat_type::CLASS_EMPTY] << " "
-            << std::left << std::dec << std::setw(12) << class_ptr->stats.objs[zs_stat_type::CLASS_ALMOST_EMPTY] << " "
-            << std::left << std::dec << std::setw(12) << class_ptr->stats.objs[zs_stat_type::CLASS_ALMOST_FULL] << " "
-            << std::left << std::dec << std::setw(5) << class_ptr->stats.objs[zs_stat_type::CLASS_FULL] << " "
+            << std::left << std::dec << std::setw(5) << class_ptr->stats[CLASS_EMPTY] << " "
+            << std::left << std::dec << std::setw(12) << class_ptr->stats[CLASS_ALMOST_EMPTY] << " "
+            << std::left << std::dec << std::setw(12) << class_ptr->stats[CLASS_ALMOST_FULL] << " "
+            << std::left << std::dec << std::setw(5) << class_ptr->stats[CLASS_FULL] << " "
             << std::left << std::dec << std::setw(12) << class_ptr->pages_per_zspage << " "
             << std::left << std::dec << std::setw(12) << class_ptr->objs_per_zspage << " "
             << std::left << std::dec << std::setw(9) << csize(class_ptr->size) << " "
-            << std::left << std::dec << std::setw(13) << class_ptr->stats.objs[zs_stat_type::OBJ_ALLOCATED] << " "
-            << std::left << std::dec << class_ptr->stats.objs[zs_stat_type::OBJ_USED];
+            << std::left << std::dec << std::setw(13) << class_ptr->stats[OBJ_ALLOCATED] << " "
+            << std::left << std::dec << class_ptr->stats[OBJ_USED];
         fprintf(fp, "%s \n",oss.str().c_str());
     }
 }
@@ -488,6 +509,10 @@ void Zram::print_zram_full_info(std::string zram_addr){
 }
 
 void Zram::print_zrams(){
+    if (zram_list.size() == 0){
+        fprintf(fp, "Maybe not enable zram \n");
+        return;
+    }
     fprintf(fp, "========================================================================\n");
     for (const auto& zram_ptr : zram_list) {
         double ratio = (double)zram_ptr->stats.compr_data_size / (double)(zram_ptr->stats.pages_stored * page_size);

memory/zraminfo.cpp

@@ -40,11 +40,13 @@ void Zraminfo::init_offset(){
     field_init(zram,table);
     field_init(zram,mem_pool);
     field_init(zram,comp);
+    field_init(zram,comps);
     field_init(zram,disk);
     field_init(zram,limit_pages);
     field_init(zram,stats);
     field_init(zram,disksize);
     field_init(zram,compressor);
+    field_init(zram,comp_algs);
     field_init(zram,claim);
     struct_init(zram);
 
@@ -71,6 +73,8 @@ void Zraminfo::init_offset(){
     field_init(zspage,huge);
     struct_init(zspage);
 
+    field_init(zs_size_stat,objs);
+
     field_init(zram_stats,compr_data_size);
     field_init(zram_stats,num_reads);
     field_init(zram_stats,num_writes);
@@ -165,7 +169,9 @@ bool Zraminfo::get_zspage(ulong page,struct zspage* zp){
         return false;
     }
     if (field_offset(zspage, huge) != -1){
-        if (THIS_KERNEL_VERSION >= LINUX(6, 6, 0)){
+        if (THIS_KERNEL_VERSION >= LINUX(6, 12, 0)){
+            zs_magic = zp->v6_12.magic;
+        }else if (THIS_KERNEL_VERSION >= LINUX(6, 6, 0)){
             zs_magic = zp->v6_6.magic;
         }else{
             zs_magic = zp->v5_17.magic;
@@ -476,35 +482,46 @@ std::shared_ptr<size_class> Zraminfo::parser_size_class(ulong addr){
     class_ptr->pages_per_zspage = INT(class_buf + field_offset(size_class,pages_per_zspage));
     class_ptr->index = UINT(class_buf + field_offset(size_class,index));
     class_ptr->zspage_parser = false;
-    // fprintf(fp, "\nsize_class(%lx) objs_per_zspage:%d size:%d\n", addr,class_ptr->objs_per_zspage,class_ptr->size);
-    read_struct(addr + field_offset(size_class,stats),&class_ptr->stats,sizeof(struct zs_size_stat),"size_class_stats");
     FREEBUF(class_buf);
+    // fprintf(fp, "\nsize_class(%lx) objs_per_zspage:%d size:%d\n", addr,class_ptr->objs_per_zspage,class_ptr->size);
+    int stats_cnt = field_size(zs_size_stat,objs)/sizeof(unsigned long);
+    ulong stats_addr = addr + field_offset(size_class,stats);
+    for (size_t i = 0; i < stats_cnt; i++){
+        class_ptr->stats.push_back(read_ulong(stats_addr + i * sizeof(unsigned long), "size_class_stats"));
+    }
     return class_ptr;
 }
 
 void Zraminfo::parser_zpage(std::shared_ptr<size_class> class_ptr){
     for (size_t i = 0; i < group_cnt; i++){
         ulong group_addr = class_ptr->addr + field_offset(size_class,fullness_list) + i * sizeof(struct kernel_list_head);
         int offset = field_offset(zspage,list);
-        std::vector<ulong> zspage_list = for_each_list(group_addr,offset);
-        for (const auto& zspage_addr : zspage_list) {
-            class_ptr->fullness_list[i].push_back(parser_zpage(zspage_addr,class_ptr));
+        std::vector<std::shared_ptr<zpage>> zspage_list;
+        for (const auto& zspage_addr : for_each_list(group_addr,offset)) {
+            zspage_list.push_back(parser_zpage(zspage_addr,class_ptr));
         }
+        class_ptr->fullness_list.push_back(zspage_list);
     }
     class_ptr->zspage_parser = true;
 }
 
 std::shared_ptr<zs_pool> Zraminfo::parser_mem_pool(ulong addr){
-    if (!is_kvaddr(addr))return nullptr;
+    if (!is_kvaddr(addr)){
+        return nullptr;
+    }
     void *pool_buf = read_struct(addr,"zs_pool");
     if(pool_buf == nullptr) return nullptr;
     std::shared_ptr<zs_pool> pool_ptr = std::make_shared<zs_pool>();
     pool_ptr->addr = addr;
     pool_ptr->name = read_cstring(ULONG(pool_buf + field_offset(zs_pool,name)),64,"pool_name");
     // fprintf(fp, "zs_pool(%lx) pool_name:%s\n", addr,pool_ptr->name.c_str());
     pool_ptr->pages_allocated = INT(pool_buf + field_offset(zs_pool,pages_allocated));
-    pool_ptr->isolated_pages = INT(pool_buf + field_offset(zs_pool,isolated_pages));
-    pool_ptr->destroying = BOOL(pool_buf + field_offset(zs_pool,destroying));
+    if (field_offset(zs_pool,isolated_pages) != -1){
+        pool_ptr->isolated_pages = INT(pool_buf + field_offset(zs_pool,isolated_pages));
+    }
+    if (field_offset(zs_pool,destroying) != -1){
+        pool_ptr->destroying = BOOL(pool_buf + field_offset(zs_pool,destroying));
+    }
     read_struct(addr + field_offset(zs_pool,stats),&pool_ptr->stats,sizeof(struct zs_pool_stats),"zs_pool_stats");
     int class_cnt = field_size(zs_pool,size_class)/sizeof(void *);
     for (size_t i = 0; i < class_cnt; i++){
@@ -517,34 +534,64 @@ std::shared_ptr<zs_pool> Zraminfo::parser_mem_pool(ulong addr){
 }
 
 std::shared_ptr<zram> Zraminfo::parser_zram(ulong addr){
+    if(debug)fprintf(fp, "zram:%lx \n",addr);
     void *zram_buf = read_struct(addr,"zram");
     if(zram_buf == nullptr) return nullptr;
+    ulong pool_addr = ULONG(zram_buf + field_offset(zram,mem_pool));
+    if (!is_kvaddr(pool_addr))return nullptr;
     std::shared_ptr<zram> zram_ptr = std::make_shared<zram>();
     zram_ptr->addr = addr;
     zram_ptr->table = ULONG(zram_buf + field_offset(zram,table));
     zram_ptr->mem_pool = parser_mem_pool(ULONG(zram_buf + field_offset(zram,mem_pool)));
-    ulong zcomp_addr = ULONG(zram_buf + field_offset(zram,comp));
-    ulong zcomp_name_addr = read_pointer(zcomp_addr + field_offset(zcomp,name),"zcomp_name_addr");
-    zram_ptr->zcomp_name = read_cstring(zcomp_name_addr,64,"zcomp_name");
+    if (field_offset(zram,comp) != -1){
+        ulong zcomp_addr = ULONG(zram_buf + field_offset(zram,comp));
+        if (is_kvaddr(zcomp_addr)){
+            ulong zcomp_name_addr = read_pointer(zcomp_addr + field_offset(zcomp,name),"zcomp_name_addr");
+            if (is_kvaddr(zcomp_name_addr)){
+                zram_ptr->zcomp_name = read_cstring(zcomp_name_addr,64,"zcomp_name");
+            }
+        }
+    }else if (field_offset(zram,comps) != -1){
+        ulong zcomp_addr = ULONG(zram_buf + field_offset(zram,comps));
+        if (is_kvaddr(zcomp_addr)){
+            ulong zcomp_name_addr = read_pointer(zcomp_addr + field_offset(zcomp,name),"zcomp_name_addr");
+            if (is_kvaddr(zcomp_name_addr)){
+                zram_ptr->zcomp_name = read_cstring(zcomp_name_addr,64,"zcomp_name");
+            }
+        }
+    }
     ulong disk_name_addr = ULONG(zram_buf + field_offset(zram,disk)) + field_offset(gendisk,disk_name);
     zram_ptr->disk_name = read_cstring(disk_name_addr,32,"disk_name");;
     // fprintf(fp, "disk_name:%s\n", zram_ptr->disk_name.c_str());
-    char compressor_name[128];
-    memcpy(&compressor_name,(void *)zram_buf + field_offset(zram,compressor),128);
-    zram_ptr->compressor = extract_string(compressor_name);
-    // std::cout << "compressor_name:" << zram_ptr->compressor << std::endl;
+    if (field_offset(zram,compressor) != -1){
+        char compressor_name[128];
+        memcpy(&compressor_name,(void *)zram_buf + field_offset(zram,compressor),128);
+        zram_ptr->compressor = extract_string(compressor_name);
+        // std::cout << "compressor_name:" << zram_ptr->compressor << std::endl;
+    }else if (field_offset(zram,comp_algs) != -1){
+        ulong name_addr = ULONG(zram_buf + field_offset(zram,comp_algs));
+        if (is_kvaddr(name_addr)){
+            zram_ptr->compressor = read_cstring(name_addr, 64, "compressor name");
+        }
+    }
     zram_ptr->limit_pages = ULONG(zram_buf + field_offset(zram,limit_pages));
     zram_ptr->disksize = ULONGLONG(zram_buf + field_offset(zram,disksize));
     zram_ptr->claim = BOOL(zram_buf + field_offset(zram,claim));
     FREEBUF(zram_buf);
     void *stats_buf = read_struct(addr + field_offset(zram,stats),"zram_stats");
     if(stats_buf == nullptr) return nullptr;
     zram_ptr->stats.compr_data_size = ULONGLONG(stats_buf + field_offset(zram_stats,compr_data_size));
-    zram_ptr->stats.num_reads = ULONGLONG(stats_buf + field_offset(zram_stats,num_reads));
-    zram_ptr->stats.num_writes = ULONGLONG(stats_buf + field_offset(zram_stats,num_writes));
+    if(field_offset(zram_stats,num_reads) != -1){
+        zram_ptr->stats.num_reads = ULONGLONG(stats_buf + field_offset(zram_stats,num_reads));
+    }
+    if(field_offset(zram_stats,num_writes) != -1){
+        zram_ptr->stats.num_writes = ULONGLONG(stats_buf + field_offset(zram_stats,num_writes));
+    }
     zram_ptr->stats.failed_reads = ULONGLONG(stats_buf + field_offset(zram_stats,failed_reads));
     zram_ptr->stats.failed_writes = ULONGLONG(stats_buf + field_offset(zram_stats,failed_writes));
-    zram_ptr->stats.invalid_io = ULONGLONG(stats_buf + field_offset(zram_stats,invalid_io));
+    if(field_offset(zram_stats,invalid_io) != -1){
+        zram_ptr->stats.invalid_io = ULONGLONG(stats_buf + field_offset(zram_stats,invalid_io));
+    }
     zram_ptr->stats.notify_free = ULONGLONG(stats_buf + field_offset(zram_stats,notify_free));
     zram_ptr->stats.same_pages = ULONGLONG(stats_buf + field_offset(zram_stats,same_pages));
     zram_ptr->stats.huge_pages = ULONGLONG(stats_buf + field_offset(zram_stats,huge_pages));

memory/zraminfo.h

@@ -56,10 +56,6 @@ struct zs_pool_stats {
     atomic_long_t pages_compacted;
 };
 
-struct zs_size_stat {
-    unsigned long objs[6];
-};
-
 struct zobj {
     int id;
     ulong start;
@@ -87,13 +83,13 @@ struct zpage {
 
 struct size_class {
     ulong addr;
-    std::vector<std::shared_ptr<zpage>> fullness_list[4];
+    std::vector<std::vector<std::shared_ptr<zpage>>> fullness_list;
     bool zspage_parser;
     int size;
     int objs_per_zspage;
     int pages_per_zspage;
     unsigned int index;
-    struct zs_size_stat stats;
+    std::vector<ulong> stats;
 };
 
 struct zs_pool {

pageowner/pageowner.cpp

@@ -337,7 +337,6 @@ void Pageowner::print_page_owner(std::string addr,int flags){
     if (flags == INPUT_PFN){
         pfn = number;
     }else if (flags == INPUT_PYHS){
-        fprintf(fp, "hello \n");
         pfn = phy_to_pfn(number);
     }else if (flags == INPUT_PAGE){
         pfn = page_to_pfn(number);
@@ -691,8 +690,8 @@ void Pageowner::parser_all_pageowners(){
         try_get_symbol_data(TO_CONST_STRING("min_low_pfn"), sizeof(ulong), &min_low_pfn);
     }
     /* PAGE_EXT_OWNER{,_ALLOCATED} */
-    enumerator_value(TO_CONST_STRING("PAGE_EXT_OWNER"), &PAGE_EXT_OWNER);
-    enumerator_value(TO_CONST_STRING("PAGE_EXT_OWNER_ALLOCATED"), &PAGE_EXT_OWNER_ALLOCATED); /* 5.4 and later */
+    PAGE_EXT_OWNER = read_enum_val("PAGE_EXT_OWNER");
+    PAGE_EXT_OWNER_ALLOCATED = read_enum_val("PAGE_EXT_OWNER_ALLOCATED");
     // fprintf(fp, "min_low_pfn:%ld\n", min_low_pfn);
     // fprintf(fp, "max_pfn:%ld\n", max_pfn);
     for (size_t pfn = min_low_pfn; pfn < max_pfn; pfn++){

plugin.cpp

@@ -699,6 +699,32 @@ int PaserPlugin::is_bigendian(void){
         return FALSE;
 }
 
+std::vector<std::string> PaserPlugin::get_enumerator_list(const std::string &enum_name){
+    std::vector<std::string> result;
+    char buf[BUFSIZE];
+    open_tmpfile();
+    if (dump_enumerator_list(TO_CONST_STRING(enum_name.c_str()))){
+        rewind(pc->tmpfile);
+        while (fgets(buf, BUFSIZE, pc->tmpfile)){
+            std::string line = buf;
+            size_t pos = line.find('=');
+            if (pos == std::string::npos) {
+                continue;
+            }else{
+                std::string name = line.substr(0, pos - 1);
+                size_t first = name.find_first_not_of(' ');
+                size_t last = name.find_last_not_of(' ');
+                if (first == std::string::npos || last == std::string::npos) {
+                    continue;
+                }
+                result.push_back(name.substr(first, (last - first + 1)));
+            }
+        }
+    }
+    close_tmpfile();
+    return result;
+}
+
 long PaserPlugin::read_enum_val(const std::string& enum_name){
      long enum_val = 0;
      enumerator_value(TO_CONST_STRING(enum_name.c_str()), &enum_val);

plugin.h

@@ -163,7 +163,8 @@ class PaserPlugin {
     bool isNumber(const std::string& str);
     std::string extract_string(const char *input);
     int is_bigendian(void);
-    long read_enum_val(const std::string& enum_name);
+    std::vector<std::string> get_enumerator_list(const std::string &enum_name);
+    long read_enum_val(const std::string &enum_name);
     std::map<std::string, ulong> read_enum_list(const std::string& enum_list_name);
     char get_printable(uint8_t d);
     std::string print_line(uint64_t addr, const std::vector<uint8_t>& data);