diff for duplicates of <055101dc2d25$7e068a70$7a139f50$@samsung.com> diff --git a/a/1.txt b/N1/1.txt index cea18a7..786c7f7 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -41,125 +41,116 @@ > >> Thanks, > >> > > -> > Does “readahead more node pages” mean removing this condition? -> > " offset[i - 1] % MAX_RA_NODE == 0 " -> -> Actually, I meant a) remove "offset[i - 1] % MAX_RA_NODE == 0" or b) -> increase MAX_RA_NODE. -> -> Also, maybe we can try as below to trigger synchronous IO for such high -> determinacy read. -> -> void df2fs_ra_node_page() -> { -> ... -> err = read_node_folio(afolio, 0); -> ... -> } -> - -I’m not sure if I fully understood, but does this mean that in the case of precache, the readahead nodes are handled with sync reads? -With the current code, it seems difficult to implement this. - +> > Does “readahead more node pages” mean removing this condition?\r +> > " offset[i - 1] % MAX_RA_NODE == 0 "\r +> \r +> Actually, I meant a) remove "offset[i - 1] % MAX_RA_NODE == 0" or b)\r +> increase MAX_RA_NODE.\r +> \r +> Also, maybe we can try as below to trigger synchronous IO for such high\r +> determinacy read.\r +> \r +> void df2fs_ra_node_page()\r +> {\r +> ...\r +> err = read_node_folio(afolio, 0);\r +> ...\r +> }\r +> \r +\r +I’m not sure if I fully understood, but does this mean that in the case of precache, the readahead nodes are handled with sync reads?\r +With the current code, it seems difficult to implement this.\r +\r +> >\r +> > I originally added the condition to prevent unnecessary readahead\r +> > requests, but it seems this condition was actually blocking valid\r +> readahead as well.\r +> >\r +> > After removing the condition and running tests, I confirmed that more\r +> > readahead node pages are being issued.\r +> >\r +> > I’ll share the test results along with the improved patch.\r +> \r +> It makes sense, thanks for checking this and sharing the result.\r +> \r +> Thanks,\r +> \r +\r +I tested with the revised v3 code and confirmed that most node pages are now handled by readahead. \r +(In the v2 version, only about half of nodes were processed with readahead.)\r +\r +Thank you for your review.\r +\r +> >\r +> > Thanks,\r +> >\r +> >>> Tested on a 256GB mobile device with an SM8750 chipset.\r +> >>>\r +> >>> Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com>\r +> >>> Reviewed-by: Sunmin Jeong <s_min.jeong@samsung.com>\r +> >>> Signed-off-by: Yunji Kang <yunji0.kang@samsung.com>\r +> >>> ---\r +> >>> v2:\r +> >>> - Modify the readahead condition check routine for better code\r +> >>> readability.\r +> >>> - Update the title from 'node block' to 'node blocks'.\r +> >>>\r +> >>> fs/f2fs/data.c | 3 +++\r +> >>> fs/f2fs/f2fs.h | 1 +\r +> >>> fs/f2fs/node.c | 5 ++++-\r +> >>> 3 files changed, 8 insertions(+), 1 deletion(-)\r +> >>>\r +> >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index\r +> >>> 7961e0ddfca3..ab3117e3b24a 100644\r +> >>> --- a/fs/f2fs/data.c\r +> >>> +++ b/fs/f2fs/data.c\r +> >>> @@ -1572,6 +1572,9 @@ int f2fs_map_blocks(struct inode *inode,\r +> >>> struct\r +> >> f2fs_map_blocks *map, int flag)\r +> >>> pgofs = (pgoff_t)map->m_lblk;\r +> >>> end = pgofs + maxblocks;\r +> >>>\r +> >>> + if (flag == F2FS_GET_BLOCK_PRECACHE)\r +> >>> + mode = LOOKUP_NODE_PRECACHE;\r +> >>> +\r +> >>> next_dnode:\r +> >>> if (map->m_may_create) {\r +> >>> if (f2fs_lfs_mode(sbi))\r +> >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index\r +> >>> 9d3bc9633c1d..3ce41528d48e 100644\r +> >>> --- a/fs/f2fs/f2fs.h\r +> >>> +++ b/fs/f2fs/f2fs.h\r +> >>> @@ -651,6 +651,7 @@ enum {\r +> >>> * look up a node with readahead called\r +> >>> * by get_data_block.\r +> >>> */\r +> >>> + LOOKUP_NODE_PRECACHE, /* look up a node for\r +> >> F2FS_GET_BLOCK_PRECACHE */\r +> >>> };\r +> >>>\r +> >>> #define DEFAULT_RETRY_IO_COUNT 8 /* maximum retry read IO or\r +> flush\r +> >> count */\r +> >>> diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index\r +> >>> 4254db453b2d..d4bf3ce715c5 100644\r +> >>> --- a/fs/f2fs/node.c\r +> >>> +++ b/fs/f2fs/node.c\r +> >>> @@ -860,7 +860,10 @@ int f2fs_get_dnode_of_data(struct dnode_of_data\r +> >>> *dn,\r +> >> pgoff_t index, int mode)\r +> >>> set_nid(parent, offset[i - 1], nids[i], i == 1);\r +> >>> f2fs_alloc_nid_done(sbi, nids[i]);\r +> >>> done = true;\r +> >>> - } else if (mode == LOOKUP_NODE_RA && i == level && level > 1)\r +> >> {\r +> >>> + } else if ((i == level && level > 1) &&\r +> >>> + (mode == LOOKUP_NODE_RA ||\r +> >>> + (mode == LOOKUP_NODE_PRECACHE &&\r +> >>> + offset[i - 1] % MAX_RA_NODE == 0))) {\r +> >>> nfolio[i] = f2fs_get_node_folio_ra(parent, offset[i -\r +> >> 1]);\r +> >>> if (IS_ERR(nfolio[i])) {\r +> >>> err = PTR_ERR(nfolio[i]);\r +> >\r +> >\r > > -> > I originally added the condition to prevent unnecessary readahead -> > requests, but it seems this condition was actually blocking valid -> readahead as well. -> > -> > After removing the condition and running tests, I confirmed that more -> > readahead node pages are being issued. -> > -> > I’ll share the test results along with the improved patch. -> -> It makes sense, thanks for checking this and sharing the result. -> -> Thanks, -> - -I tested with the revised v3 code and confirmed that most node pages are now handled by readahead. -(In the v2 version, only about half of nodes were processed with readahead.) - -Thank you for your review. - -> > -> > Thanks, -> > -> >>> Tested on a 256GB mobile device with an SM8750 chipset. -> >>> -> >>> Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com> -> >>> Reviewed-by: Sunmin Jeong <s_min.jeong@samsung.com> -> >>> Signed-off-by: Yunji Kang <yunji0.kang@samsung.com> -> >>> --- -> >>> v2: -> >>> - Modify the readahead condition check routine for better code -> >>> readability. -> >>> - Update the title from 'node block' to 'node blocks'. -> >>> -> >>> fs/f2fs/data.c | 3 +++ -> >>> fs/f2fs/f2fs.h | 1 + -> >>> fs/f2fs/node.c | 5 ++++- -> >>> 3 files changed, 8 insertions(+), 1 deletion(-) -> >>> -> >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index -> >>> 7961e0ddfca3..ab3117e3b24a 100644 -> >>> --- a/fs/f2fs/data.c -> >>> +++ b/fs/f2fs/data.c -> >>> @@ -1572,6 +1572,9 @@ int f2fs_map_blocks(struct inode *inode, -> >>> struct -> >> f2fs_map_blocks *map, int flag) -> >>> pgofs = (pgoff_t)map->m_lblk; -> >>> end = pgofs + maxblocks; -> >>> -> >>> + if (flag == F2FS_GET_BLOCK_PRECACHE) -> >>> + mode = LOOKUP_NODE_PRECACHE; -> >>> + -> >>> next_dnode: -> >>> if (map->m_may_create) { -> >>> if (f2fs_lfs_mode(sbi)) -> >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index -> >>> 9d3bc9633c1d..3ce41528d48e 100644 -> >>> --- a/fs/f2fs/f2fs.h -> >>> +++ b/fs/f2fs/f2fs.h -> >>> @@ -651,6 +651,7 @@ enum { -> >>> * look up a node with readahead called -> >>> * by get_data_block. -> >>> */ -> >>> + LOOKUP_NODE_PRECACHE, /* look up a node for -> >> F2FS_GET_BLOCK_PRECACHE */ -> >>> }; -> >>> -> >>> #define DEFAULT_RETRY_IO_COUNT 8 /* maximum retry read IO or -> flush -> >> count */ -> >>> diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index -> >>> 4254db453b2d..d4bf3ce715c5 100644 -> >>> --- a/fs/f2fs/node.c -> >>> +++ b/fs/f2fs/node.c -> >>> @@ -860,7 +860,10 @@ int f2fs_get_dnode_of_data(struct dnode_of_data -> >>> *dn, -> >> pgoff_t index, int mode) -> >>> set_nid(parent, offset[i - 1], nids[i], i == 1); -> >>> f2fs_alloc_nid_done(sbi, nids[i]); -> >>> done = true; -> >>> - } else if (mode == LOOKUP_NODE_RA && i == level && level > 1) -> >> { -> >>> + } else if ((i == level && level > 1) && -> >>> + (mode == LOOKUP_NODE_RA || -> >>> + (mode == LOOKUP_NODE_PRECACHE && -> >>> + offset[i - 1] % MAX_RA_NODE == 0))) { -> >>> nfolio[i] = f2fs_get_node_folio_ra(parent, offset[i - -> >> 1]); -> >>> if (IS_ERR(nfolio[i])) { -> >>> err = PTR_ERR(nfolio[i]); -> > -> > -> > - - - - - -_______________________________________________ -Linux-f2fs-devel mailing list -Linux-f2fs-devel@lists.sourceforge.net -https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel diff --git a/a/content_digest b/N1/content_digest index d68656b..1fa8fab 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -4,13 +4,14 @@ "ref\000d401dc2d0a$18100c20$48302460$@samsung.com\0" "ref\084d65c75-7ab7-4c0c-9085-9423effb8632@kernel.org\0" "From\0Yunji Kang <yunji0.kang@samsung.com>\0" - "Subject\0Re: [f2fs-dev] [PATCH v2] f2fs: readahead node blocks in F2FS_GET_BLOCK_PRECACHE mode\0" + "Subject\0RE: [PATCH v2] f2fs: readahead node blocks in F2FS_GET_BLOCK_PRECACHE mode\0" "Date\0Wed, 24 Sep 2025 16:33:16 +0900\0" "To\0'Chao Yu' <chao@kernel.org>" " <jaegeuk@kernel.org>\0" - "Cc\0'Sungjong Seo' <sj1557.seo@samsung.com>" - linux-kernel@vger.kernel.org - " linux-f2fs-devel@lists.sourceforge.net\0" + "Cc\0<linux-f2fs-devel@lists.sourceforge.net>" + <linux-kernel@vger.kernel.org> + 'Sungjong Seo' <sj1557.seo@samsung.com> + " 'Sunmin Jeong' <s_min.jeong@samsung.com>\0" "\00:1\0" "b\0" "> On 9/24/25 12:17, Yunji Kang wrote:\n" @@ -56,127 +57,118 @@ "> >> Thanks,\n" "> >>\n" "> >\n" - "> > Does \342\200\234readahead more node pages\342\200\235 mean removing this condition?\n" - "> > \" offset[i - 1] % MAX_RA_NODE == 0 \"\n" - "> \n" - "> Actually, I meant a) remove \"offset[i - 1] % MAX_RA_NODE == 0\" or b)\n" - "> increase MAX_RA_NODE.\n" - "> \n" - "> Also, maybe we can try as below to trigger synchronous IO for such high\n" - "> determinacy read.\n" - "> \n" - "> void df2fs_ra_node_page()\n" - "> {\n" - "> ...\n" - "> \terr = read_node_folio(afolio, 0);\n" - "> ...\n" - "> }\n" - "> \n" - "\n" - "I\342\200\231m not sure if I fully understood, but does this mean that in the case of precache, the readahead nodes are handled with sync reads?\n" - "With the current code, it seems difficult to implement this.\n" - "\n" - "> >\n" - "> > I originally added the condition to prevent unnecessary readahead\n" - "> > requests, but it seems this condition was actually blocking valid\n" - "> readahead as well.\n" - "> >\n" - "> > After removing the condition and running tests, I confirmed that more\n" - "> > readahead node pages are being issued.\n" - "> >\n" - "> > I\342\200\231ll share the test results along with the improved patch.\n" - "> \n" - "> It makes sense, thanks for checking this and sharing the result.\n" - "> \n" - "> Thanks,\n" - "> \n" - "\n" - "I tested with the revised v3 code and confirmed that most node pages are now handled by readahead. \n" - "(In the v2 version, only about half of nodes were processed with readahead.)\n" - "\n" - "Thank you for your review.\n" - "\n" - "> >\n" - "> > Thanks,\n" - "> >\n" - "> >>> Tested on a 256GB mobile device with an SM8750 chipset.\n" - "> >>>\n" - "> >>> Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com>\n" - "> >>> Reviewed-by: Sunmin Jeong <s_min.jeong@samsung.com>\n" - "> >>> Signed-off-by: Yunji Kang <yunji0.kang@samsung.com>\n" - "> >>> ---\n" - "> >>> v2:\n" - "> >>> - Modify the readahead condition check routine for better code\n" - "> >>> readability.\n" - "> >>> - Update the title from 'node block' to 'node blocks'.\n" - "> >>>\n" - "> >>> fs/f2fs/data.c | 3 +++\n" - "> >>> fs/f2fs/f2fs.h | 1 +\n" - "> >>> fs/f2fs/node.c | 5 ++++-\n" - "> >>> 3 files changed, 8 insertions(+), 1 deletion(-)\n" - "> >>>\n" - "> >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index\n" - "> >>> 7961e0ddfca3..ab3117e3b24a 100644\n" - "> >>> --- a/fs/f2fs/data.c\n" - "> >>> +++ b/fs/f2fs/data.c\n" - "> >>> @@ -1572,6 +1572,9 @@ int f2fs_map_blocks(struct inode *inode,\n" - "> >>> struct\n" - "> >> f2fs_map_blocks *map, int flag)\n" - "> >>> \tpgofs =\t(pgoff_t)map->m_lblk;\n" - "> >>> \tend = pgofs + maxblocks;\n" - "> >>>\n" - "> >>> +\tif (flag == F2FS_GET_BLOCK_PRECACHE)\n" - "> >>> +\t\tmode = LOOKUP_NODE_PRECACHE;\n" - "> >>> +\n" - "> >>> next_dnode:\n" - "> >>> \tif (map->m_may_create) {\n" - "> >>> \t\tif (f2fs_lfs_mode(sbi))\n" - "> >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index\n" - "> >>> 9d3bc9633c1d..3ce41528d48e 100644\n" - "> >>> --- a/fs/f2fs/f2fs.h\n" - "> >>> +++ b/fs/f2fs/f2fs.h\n" - "> >>> @@ -651,6 +651,7 @@ enum {\n" - "> >>> \t\t\t\t\t * look up a node with readahead called\n" - "> >>> \t\t\t\t\t * by get_data_block.\n" - "> >>> \t\t\t\t\t */\n" - "> >>> +\tLOOKUP_NODE_PRECACHE,\t\t/* look up a node for\n" - "> >> F2FS_GET_BLOCK_PRECACHE */\n" - "> >>> };\n" - "> >>>\n" - "> >>> #define DEFAULT_RETRY_IO_COUNT\t8\t/* maximum retry read IO or\n" - "> flush\n" - "> >> count */\n" - "> >>> diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index\n" - "> >>> 4254db453b2d..d4bf3ce715c5 100644\n" - "> >>> --- a/fs/f2fs/node.c\n" - "> >>> +++ b/fs/f2fs/node.c\n" - "> >>> @@ -860,7 +860,10 @@ int f2fs_get_dnode_of_data(struct dnode_of_data\n" - "> >>> *dn,\n" - "> >> pgoff_t index, int mode)\n" - "> >>> \t\t\tset_nid(parent, offset[i - 1], nids[i], i == 1);\n" - "> >>> \t\t\tf2fs_alloc_nid_done(sbi, nids[i]);\n" - "> >>> \t\t\tdone = true;\n" - "> >>> -\t\t} else if (mode == LOOKUP_NODE_RA && i == level && level > 1)\n" - "> >> {\n" - "> >>> +\t\t} else if ((i == level && level > 1) &&\n" - "> >>> +\t\t\t\t(mode == LOOKUP_NODE_RA ||\n" - "> >>> +\t\t\t\t(mode == LOOKUP_NODE_PRECACHE &&\n" - "> >>> +\t\t\t\toffset[i - 1] % MAX_RA_NODE == 0))) {\n" - "> >>> \t\t\tnfolio[i] = f2fs_get_node_folio_ra(parent, offset[i -\n" - "> >> 1]);\n" - "> >>> \t\t\tif (IS_ERR(nfolio[i])) {\n" - "> >>> \t\t\t\terr = PTR_ERR(nfolio[i]);\n" - "> >\n" - "> >\n" - "> >\n" - "\n" - "\n" - "\n" - "\n" - "\n" - "_______________________________________________\n" - "Linux-f2fs-devel mailing list\n" - "Linux-f2fs-devel@lists.sourceforge.net\n" - https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel + "> > Does \342\200\234readahead more node pages\342\200\235 mean removing this condition?\r\n" + "> > \" offset[i - 1] % MAX_RA_NODE == 0 \"\r\n" + "> \r\n" + "> Actually, I meant a) remove \"offset[i - 1] % MAX_RA_NODE == 0\" or b)\r\n" + "> increase MAX_RA_NODE.\r\n" + "> \r\n" + "> Also, maybe we can try as below to trigger synchronous IO for such high\r\n" + "> determinacy read.\r\n" + "> \r\n" + "> void df2fs_ra_node_page()\r\n" + "> {\r\n" + "> ...\r\n" + "> \terr = read_node_folio(afolio, 0);\r\n" + "> ...\r\n" + "> }\r\n" + "> \r\n" + "\r\n" + "I\342\200\231m not sure if I fully understood, but does this mean that in the case of precache, the readahead nodes are handled with sync reads?\r\n" + "With the current code, it seems difficult to implement this.\r\n" + "\r\n" + "> >\r\n" + "> > I originally added the condition to prevent unnecessary readahead\r\n" + "> > requests, but it seems this condition was actually blocking valid\r\n" + "> readahead as well.\r\n" + "> >\r\n" + "> > After removing the condition and running tests, I confirmed that more\r\n" + "> > readahead node pages are being issued.\r\n" + "> >\r\n" + "> > I\342\200\231ll share the test results along with the improved patch.\r\n" + "> \r\n" + "> It makes sense, thanks for checking this and sharing the result.\r\n" + "> \r\n" + "> Thanks,\r\n" + "> \r\n" + "\r\n" + "I tested with the revised v3 code and confirmed that most node pages are now handled by readahead. \r\n" + "(In the v2 version, only about half of nodes were processed with readahead.)\r\n" + "\r\n" + "Thank you for your review.\r\n" + "\r\n" + "> >\r\n" + "> > Thanks,\r\n" + "> >\r\n" + "> >>> Tested on a 256GB mobile device with an SM8750 chipset.\r\n" + "> >>>\r\n" + "> >>> Reviewed-by: Sungjong Seo <sj1557.seo@samsung.com>\r\n" + "> >>> Reviewed-by: Sunmin Jeong <s_min.jeong@samsung.com>\r\n" + "> >>> Signed-off-by: Yunji Kang <yunji0.kang@samsung.com>\r\n" + "> >>> ---\r\n" + "> >>> v2:\r\n" + "> >>> - Modify the readahead condition check routine for better code\r\n" + "> >>> readability.\r\n" + "> >>> - Update the title from 'node block' to 'node blocks'.\r\n" + "> >>>\r\n" + "> >>> fs/f2fs/data.c | 3 +++\r\n" + "> >>> fs/f2fs/f2fs.h | 1 +\r\n" + "> >>> fs/f2fs/node.c | 5 ++++-\r\n" + "> >>> 3 files changed, 8 insertions(+), 1 deletion(-)\r\n" + "> >>>\r\n" + "> >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index\r\n" + "> >>> 7961e0ddfca3..ab3117e3b24a 100644\r\n" + "> >>> --- a/fs/f2fs/data.c\r\n" + "> >>> +++ b/fs/f2fs/data.c\r\n" + "> >>> @@ -1572,6 +1572,9 @@ int f2fs_map_blocks(struct inode *inode,\r\n" + "> >>> struct\r\n" + "> >> f2fs_map_blocks *map, int flag)\r\n" + "> >>> \tpgofs =\t(pgoff_t)map->m_lblk;\r\n" + "> >>> \tend = pgofs + maxblocks;\r\n" + "> >>>\r\n" + "> >>> +\tif (flag == F2FS_GET_BLOCK_PRECACHE)\r\n" + "> >>> +\t\tmode = LOOKUP_NODE_PRECACHE;\r\n" + "> >>> +\r\n" + "> >>> next_dnode:\r\n" + "> >>> \tif (map->m_may_create) {\r\n" + "> >>> \t\tif (f2fs_lfs_mode(sbi))\r\n" + "> >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index\r\n" + "> >>> 9d3bc9633c1d..3ce41528d48e 100644\r\n" + "> >>> --- a/fs/f2fs/f2fs.h\r\n" + "> >>> +++ b/fs/f2fs/f2fs.h\r\n" + "> >>> @@ -651,6 +651,7 @@ enum {\r\n" + "> >>> \t\t\t\t\t * look up a node with readahead called\r\n" + "> >>> \t\t\t\t\t * by get_data_block.\r\n" + "> >>> \t\t\t\t\t */\r\n" + "> >>> +\tLOOKUP_NODE_PRECACHE,\t\t/* look up a node for\r\n" + "> >> F2FS_GET_BLOCK_PRECACHE */\r\n" + "> >>> };\r\n" + "> >>>\r\n" + "> >>> #define DEFAULT_RETRY_IO_COUNT\t8\t/* maximum retry read IO or\r\n" + "> flush\r\n" + "> >> count */\r\n" + "> >>> diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c index\r\n" + "> >>> 4254db453b2d..d4bf3ce715c5 100644\r\n" + "> >>> --- a/fs/f2fs/node.c\r\n" + "> >>> +++ b/fs/f2fs/node.c\r\n" + "> >>> @@ -860,7 +860,10 @@ int f2fs_get_dnode_of_data(struct dnode_of_data\r\n" + "> >>> *dn,\r\n" + "> >> pgoff_t index, int mode)\r\n" + "> >>> \t\t\tset_nid(parent, offset[i - 1], nids[i], i == 1);\r\n" + "> >>> \t\t\tf2fs_alloc_nid_done(sbi, nids[i]);\r\n" + "> >>> \t\t\tdone = true;\r\n" + "> >>> -\t\t} else if (mode == LOOKUP_NODE_RA && i == level && level > 1)\r\n" + "> >> {\r\n" + "> >>> +\t\t} else if ((i == level && level > 1) &&\r\n" + "> >>> +\t\t\t\t(mode == LOOKUP_NODE_RA ||\r\n" + "> >>> +\t\t\t\t(mode == LOOKUP_NODE_PRECACHE &&\r\n" + "> >>> +\t\t\t\toffset[i - 1] % MAX_RA_NODE == 0))) {\r\n" + "> >>> \t\t\tnfolio[i] = f2fs_get_node_folio_ra(parent, offset[i -\r\n" + "> >> 1]);\r\n" + "> >>> \t\t\tif (IS_ERR(nfolio[i])) {\r\n" + "> >>> \t\t\t\terr = PTR_ERR(nfolio[i]);\r\n" + "> >\r\n" + "> >\r\n" + > > -e7201a2dbfb1c784404c3b3fedae87270ece0f41608f8f3d96a3e172a749a344 +7818cb9afc18c592162bf659a9b1b01f6923f04826082ddaca71a8188060a500
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.