Relocation/backref cache cleanups
cover Relocation/backref cache cleanups
Hi,
Relocation caches extent backrefs in an rbtree (the 'backref cache'). The following patches move the backref cache code out of relocation.c and into it's own file. We then do a straight-forward cleanup the main backref cache function, build_backref_tree(). No functionality is changed in these patches.
These patches are part of a larger series I have, which speeds up qgroup accounting by using the same backref cache facility. That series is not quite ready, however I wanted to see about getting these cleanup patches upstreamed as they are nicely self contained and benefit the readability of the code.
All feedback is appreciated.
--Mark
PATCH 1/3 btrfs: Move backref cache code out of relocation.c
From: Mark Fasheh <[email protected]>
No functional changes are made here, we simply move the backref cache out of relocation.c and into it's own file, backref-cache.c. We also add the headers relocation.h and backref-cache.h.
--- fs/btrfs/Makefile | 2 +- fs/btrfs/backref-cache.c | 883 ++++++++++++++++++++++++++++++++ fs/btrfs/backref-cache.h | 113 +++++ fs/btrfs/relocation.c | 1027 +------------------------------------- fs/btrfs/relocation.h | 85 ++++ 5 files changed, 1090 insertions(+), 1020 deletions(-) create mode 100644 fs/btrfs/backref-cache.c create mode 100644 fs/btrfs/backref-cache.h create mode 100644 fs/btrfs/relocation.h
fs/btrfs/Makefile +1 -1
@@ -11,7 +11,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \ reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \ uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \ - block-rsv.o delalloc-space.o + block-rsv.o delalloc-space.o backref-cache.o btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
fs/btrfs/backref-cache.c new file +883 -0
883 lines not on this page · raw message
fs/btrfs/backref-cache.h new file +113 -0
113 lines not on this page · raw message
fs/btrfs/relocation.c +8 -1019
1,095 lines not on this page · raw message
fs/btrfs/relocation.h new file +85 -0
85 lines not on this page · raw message
Signature · 1 line
2.22.1
Re: [PATCH 1/3] btrfs: Move backref cache code out of relocation.c
Quoted 7 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
No functional changes are made here, we simply move the backref cache out of
relocation.cand into it's own file,backref-cache.c. We also add the headersrelocation.handbackref-cache.h.Signed-off-by Mark Fasheh <[email protected]>
Thanks,
Josef
Re: [PATCH 1/3] btrfs: Move backref cache code out of relocation.c
In reply to Mark FashehQuoted 37 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
No functional changes are made here, we simply move the backref cache out of
relocation.cand into it's own file,backref-cache.c. We also add the headersrelocation.handbackref-cache.h.Signed-off-by Mark Fasheh <[email protected]>--- fs/btrfs/Makefile | 2 +- fs/btrfs/backref-cache.c | 883 ++++++++++++++++++++++++++++++++ fs/btrfs/backref-cache.h | 113 +++++ fs/btrfs/relocation.c | 1027 +------------------------------------- fs/btrfs/relocation.h | 85 ++++ 5 files changed, 1090 insertions(+), 1020 deletions(-) create mode 100644 fs/btrfs/backref-cache.c create mode 100644 fs/btrfs/backref-cache.h create mode 100644 fs/btrfs/relocation.hfs/btrfs/Makefile +1
-1@@ -11,7 +11,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \ reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \ uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o \ - block-rsv.o delalloc-space.o + block-rsv.o delalloc-space.o backref-cache.o btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.ofs/btrfs/backref-cache.c new file +0
-0
fs/btrfs/backref-cache.c line 4
Quoted 4 lines
fs/btrfs/backref-cache.c new file +4
-0@@ -0,0 +1,883 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2009 Oracle. All rights reserved. +*/
We don't need the (c) headers since the SPDX tags have been established, so I've removed it.
Otherwise, I fixed some whitespace damage and took the opportunity to update comments and other minor coding style in the +part of the code.
PATCH 2/3 btrfs: move ref finding machinery out of build_backref_tree()
In reply to Mark FashehFrom: Mark Fasheh <[email protected]>
build_backref_tree() is walking extent refs in what is an otherwise self contained chunk of code. We can shrink the total number of lines in build_backref_tree() *and* make it more readable by moving that walk into its own subroutine.
--- fs/btrfs/backref-cache.c | 110 +++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 45 deletions(-)
fs/btrfs/backref-cache.c +65 -45
@@ -336,6 +336,61 @@ int find_inline_backref(struct extent_buffer *leaf, int slot,return 0 ; } +#define SEARCH_COMPLETE 1 +#define SEARCH_NEXT 2 +static int find_next_ref (struct btrfs_root *extent_root,u64 cur_bytenr, +struct btrfs_path *path,unsigned long *ptr, +unsigned long *end,struct btrfs_key *key,bool exist) +{ +struct extent_buffer *eb = path->nodes[0 ]; +int ret; + +if (*ptr >= *end) { +if (path->slots[0 ] >=btrfs_header_nritems (eb)) { + ret =btrfs_next_leaf (extent_root, path); +if (ret <0 ) + goto out; +if (ret >0 ) +return SEARCH_COMPLETE ; + eb = path->nodes[0 ]; + } + +btrfs_item_key_to_cpu (eb, key, path->slots[0 ]); +if (key->objectid != cur_bytenr) { +WARN_ON (exist); +return SEARCH_COMPLETE ; + } + +if (key->type ==BTRFS_EXTENT_ITEM_KEY || + key->type ==BTRFS_METADATA_ITEM_KEY ) { + ret =find_inline_backref (eb, path->slots[0 ], + ptr, end); +if (ret) +return SEARCH_NEXT ; + } + } + +if (*ptr < *end) { +/* update key for inline back ref */ +struct btrfs_extent_inline_ref *iref; +int type; + iref = (struct btrfs_extent_inline_ref *)(*ptr); + type =btrfs_get_extent_inline_ref_type (eb, iref, +BTRFS_REF_TYPE_BLOCK ); +if (type ==BTRFS_REF_TYPE_INVALID ) { + ret = -EUCLEAN ; + goto out; + } + key->type = type; + key->offset =btrfs_extent_inline_ref_offset (eb, iref); + +WARN_ON (key->type !=BTRFS_TREE_BLOCK_REF_KEY && + key->type !=BTRFS_SHARED_BLOCK_REF_KEY ); + } + ret =0 ; +out: +return ret; +}/* * build backref tree for a given tree block. root of the backref tree
@@ -439,52 +494,17 @@ struct backref_node *build_backref_tree(struct reloc_control *rc,while (1 ) {cond_resched (); - eb = path1->nodes[0 ]; - -if (ptr >= end) { -if (path1->slots[0 ] >=btrfs_header_nritems (eb)) { - ret =btrfs_next_leaf (rc->extent_root, path1); -if (ret <0 ) { - err = ret; - goto out; - } -if (ret >0 ) -break ; - eb = path1->nodes[0 ]; - } - -btrfs_item_key_to_cpu (eb, &key, path1->slots[0 ]); -if (key.objectid != cur->bytenr) { -WARN_ON (exist); -break ; - } - -if (key.type ==BTRFS_EXTENT_ITEM_KEY || - key.type ==BTRFS_METADATA_ITEM_KEY ) { - ret =find_inline_backref (eb, path1->slots[0 ], - &ptr, &end); -if (ret) - goto next; - } - } - -if (ptr < end) { -/* update key for inline back ref */ -struct btrfs_extent_inline_ref *iref; -int type; - iref = (struct btrfs_extent_inline_ref *)ptr; - type =btrfs_get_extent_inline_ref_type (eb, iref, -BTRFS_REF_TYPE_BLOCK ); -if (type ==BTRFS_REF_TYPE_INVALID ) { - err = -EUCLEAN ; - goto out; - } - key.type = type; - key.offset =btrfs_extent_inline_ref_offset (eb, iref); - -WARN_ON (key.type !=BTRFS_TREE_BLOCK_REF_KEY && - key.type !=BTRFS_SHARED_BLOCK_REF_KEY ); + ret =find_next_ref (rc->extent_root, cur->bytenr, path1, &ptr, + &end, &key, exist !=NULL ); +if (ret <0 ) { + err = ret; + goto out; } + eb = path1->nodes[0 ]; +if (ret ==SEARCH_COMPLETE ) +break ; +else if (ret ==SEARCH_NEXT ) + goto next;/* * Parent node found and matches current inline ref, no need to
Signature · 1 line
2.22.1
Re: [PATCH 2/3] btrfs: move ref finding machinery out of build_backref_tree()
Quoted 17 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
build_backref_tree()is walking extent refs in what is an otherwise self contained chunk of code. We can shrink the total number of lines inbuild_backref_tree()*and* make it more readable by moving that walk into its own subroutine.Signed-off-by Mark Fasheh <[email protected]>--- fs/btrfs/backref-cache.c | 110 +++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 45 deletions(-)fs/btrfs/backref-cache.c +0
-0
fs/btrfs/backref-cache.c int find_inline_backref(struct extent_buffer *leaf, int slot, · line 343
Quoted 8 lines
fs/btrfs/backref-cache.c +5
-0@@ -336,6 +336,61 @@ int find_inline_backref(struct extent_buffer *leaf, int slot,return 0 ; } +#define SEARCH_COMPLETE 1 +#define SEARCH_NEXT 2 +static int find_next_ref (struct btrfs_root *extent_root,u64 cur_bytenr, +struct btrfs_path *path,unsigned long *ptr, +unsigned long *end,struct btrfs_key *key,bool exist)
I'd rather we do an enum here, so it's clear what we're expecting in the code context. Thanks,
Josef
Re: [PATCH 2/3] btrfs: move ref finding machinery out of build_backref_tree()
Quoted 21 lines · Josef Bacik
Quoted 20 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
build_backref_tree()is walking extent refs in what is an otherwise self contained chunk of code. We can shrink the total number of lines inbuild_backref_tree()*and* make it more readable by moving that walk into its own subroutine.Signed-off-by Mark Fasheh <[email protected]>--- fs/btrfs/backref-cache.c | 110 +++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 45 deletions(-)fs/btrfs/backref-cache.c +0
-0@@ -336,6 +336,61 @@ int find_inline_backref(struct extent_buffer *leaf, int slot,return 0 ; }
Quoted 8 lines
fs/btrfs/backref-cache.c int find_inline_backref(struct extent_buffer *leaf, int slot, · line 343
Quoted 5 lines
fs/btrfs/backref-cache.c +5
-0+#define SEARCH_COMPLETE 1 +#define SEARCH_NEXT 2 +static int find_next_ref (struct btrfs_root *extent_root,u64 cur_bytenr, +struct btrfs_path *path,unsigned long *ptr, +unsigned long *end,struct btrfs_key *key,bool exist)I'd rather we do an enum here, so it's clear what we're expecting in the code context. Thanks,
The function also returns errors (< 0), so do you mean enum for the SEARCH_* values only for for the function as well?
Josef Bacik
Reviewed-byRe: [PATCH 2/3] btrfs: move ref finding machinery out of build_backref_tree()
Quoted 31 lines · David Sterba
Quoted 21 lines · Josef Bacik
Quoted 20 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
build_backref_tree()is walking extent refs in what is an otherwise self contained chunk of code. We can shrink the total number of lines inbuild_backref_tree()*and* make it more readable by moving that walk into its own subroutine.Signed-off-by Mark Fasheh <[email protected]>--- fs/btrfs/backref-cache.c | 110 +++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 45 deletions(-)fs/btrfs/backref-cache.c +0
-0@@ -336,6 +336,61 @@ int find_inline_backref(struct extent_buffer *leaf, int slot,return 0 ; }Quoted 8 lines
fs/btrfs/backref-cache.c int find_inline_backref(struct extent_buffer *leaf, int slot, · line 343
Quoted 5 lines
fs/btrfs/backref-cache.c +5
-0+#define SEARCH_COMPLETE 1 +#define SEARCH_NEXT 2 +static int find_next_ref (struct btrfs_root *extent_root,u64 cur_bytenr, +struct btrfs_path *path,unsigned long *ptr, +unsigned long *end,struct btrfs_key *key,bool exist)I'd rather we do an enum here, so it's clear what we're expecting in the code context. Thanks,
Quoted 2 lines
The function also returns errors (< 0), so do you mean enum for the SEARCH_* values only for for the function as well?
Blah I didn't notice that, in that case you can add
Thanks,
Josef
PATCH 3/3 btrfs: move useless node processing out of build_backref_cache
In reply to Mark FashehFrom: Mark Fasheh <[email protected]>
The backref cache has to clean up nodes referring to tree leaves. It is trivial to pull that code into it's own function, which is what I do here.
--- fs/btrfs/backref-cache.c | 82 +++++++++++++++++++++++----------------- 1 file changed, 47 insertions(+), 35 deletions(-)
fs/btrfs/backref-cache.c +47 -35
@@ -336,6 +336,51 @@ int find_inline_backref(struct extent_buffer *leaf, int slot,return 0 ; } +/* +* process useless backref nodes. backref nodes for tree leaves are +* deleted from the cache. backref nodes for upper level tree blocks +* are left in the cache to avoid unnecessary backref lookup. +*/ +static void process_useless_backrefs (struct reloc_control *rc, +struct backref_node *node, +struct list_head *useless) +{ +struct backref_node *lower; +struct backref_node *upper; +struct backref_edge *edge; + +while (!list_empty (useless)) { + upper = list_entry(useless->next, struct backref_node, list); +list_del_init (&upper->list); +ASSERT (list_empty (&upper->upper)); +if (upper == node) + node =NULL ; +if (upper->lowest) { +list_del_init (&upper->lower); + upper->lowest =0 ; + } +while (!list_empty (&upper->lower)) { + edge =list_entry (upper->lower.next, + struct backref_edge, list[UPPER]); +list_del (&edge->list[UPPER ]); +list_del (&edge->list[LOWER ]); + lower = edge->node[LOWER ]; +free_backref_edge (&rc->backref_cache, edge); + +if (list_empty (&lower->upper)) +list_add (&lower->list, useless); + } +__mark_block_processed (rc, upper); +if (upper->level >0 ) { +list_add (&upper->list, &rc->backref_cache.detached); + upper->detached =1 ; + }else { +rb_erase (&upper->rb_node, &rc->backref_cache.rb_root); +free_backref_node (&rc->backref_cache, upper); + } + } +} +#define SEARCH_COMPLETE 1#define SEARCH_NEXT 2 static int find_next_ref(struct btrfs_root *extent_root, u64 cur_bytenr,
@@ -797,42 +842,9 @@ struct backref_node *build_backref_tree(struct reloc_control *rc,list_for_each_entry (edge, &upper->upper, list[LOWER ])list_add_tail (&edge->list[UPPER ], &list); } -/* -* process useless backref nodes. backref nodes for tree leaves -* are deleted from the cache. backref nodes for upper level -* tree blocks are left in the cache to avoid unnecessary backref -* lookup. -*/ -while (!list_empty (&useless)) { - upper = list_entry(useless.next, struct backref_node, list); -list_del_init (&upper->list); -ASSERT (list_empty (&upper->upper)); -if (upper == node) - node =NULL ; -if (upper->lowest) { -list_del_init (&upper->lower); - upper->lowest =0 ; - } -while (!list_empty (&upper->lower)) { - edge =list_entry (upper->lower.next, - struct backref_edge, list[UPPER]); -list_del (&edge->list[UPPER ]); -list_del (&edge->list[LOWER ]); - lower = edge->node[LOWER ]; -free_backref_edge (cache, edge); -if (list_empty (&lower->upper)) -list_add (&lower->list, &useless); - } -__mark_block_processed (rc, upper); -if (upper->level >0 ) { -list_add (&upper->list, &cache->detached); - upper->detached =1 ; - }else { -rb_erase (&upper->rb_node, &cache->rb_root); -free_backref_node (cache, upper); - } - } +process_useless_backrefs (rc, node, &useless); + out:btrfs_free_path (path1);btrfs_free_path (path2);
Signature · 1 line
2.22.1
Re: [PATCH 3/3] btrfs: move useless node processing out of build_backref_cache
Quoted 7 lines · Mark Fasheh
From: Mark Fasheh <[email protected]>
The backref cache has to clean up nodes referring to tree leaves. It is trivial to pull that code into it's own function, which is what I do here.
Signed-off-by Mark Fasheh <[email protected]>---
Thanks,
Josef
Quoted 8 lines · Mark Fasheh
Hi,
Relocation caches extent backrefs in an rbtree (the 'backref cache'). The following patches move the backref cache code out of
relocation.cand into it's own file. We then do a straight-forward cleanup the main backref cache function,build_backref_tree(). No functionality is changed in these patches.
Quoted 5 lines
These patches are part of a larger series I have, which speeds up qgroup accounting by using the same backref cache facility. That series is not quite ready, however I wanted to see about getting these cleanup patches upstreamed as they are nicely self contained and benefit the readability of the code.
Patches 1-3 moved to misc-next.
Quoted 9 lines · David Sterba
Quoted 8 lines · Mark Fasheh
Hi,
Relocation caches extent backrefs in an rbtree (the 'backref cache'). The following patches move the backref cache code out of
relocation.cand into it's own file. We then do a straight-forward cleanup the main backref cache function,build_backref_tree(). No functionality is changed in these patches.
Quoted 7 lines
Quoted 5 lines
These patches are part of a larger series I have, which speeds up qgroup accounting by using the same backref cache facility. That series is not quite ready, however I wanted to see about getting these cleanup patches upstreamed as they are nicely self contained and benefit the readability of the code.
Patches 1-3 moved to misc-next.
And removed again. There's an assertion hit in at least 2 fstests (btrfs/061, btrfs/063, btrfs/187). I tried the verbatim patches from the mailinglist and the version I applied with some minor edits, both reproduce that.
[ 6466.460371] assertion failed: !node || !node->detached, in fs/btrfs/backref-cache.c:890 [ 6466.462933] ------------[ cut here ]------------ [ 6466.464419] kernel BUG at fs/btrfs/ctree.h:3119! [ 6466.465950] invalid opcode: 0000 [#1] SMP [ 6466.467281] CPU: 3 PID: 23411 Comm: btrfs Tainted: G W 5.4.0-rc1-default+ #743 [ 6466.470089] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.12.1-0-ga5cab58-prebuilt.qemu.org 04/01/2014 [ 6466.473501] RIP: 0010:assfail.constprop.0+0x18/0x26 [btrfs] [ 6466.479151] RSP: 0000:ffffaca387a13950 EFLAGS: 00010246 [ 6466.479965] RAX: 000000000000004b RBX: ffff97d4777aacb8 RCX: 0000000000000001 [ 6466.481011] RDX: 0000000000000000 RSI: 0000000000000001 RDI: ffffffffbd1044c0 [ 6466.482059] RBP: dead000000000122 R08: 0000000000000000 R09: 0000000000000000 [ 6466.483114] R10: 0000000000000000 R11: 0000000000000000 R12: dead000000000100 [ 6466.484163] R13: ffff97d46d38f508 R14: ffff97d490a74b90 R15: ffff97d4777aace8 [ 6466.485236] FS: 00007f5ca43fb8c0(0000) GS:ffff97d4bdc00000(0000) knlGS:0000000000000000 [ 6466.486508] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 6466.487888] CR2: 000055c2028b0018 CR3: 000000003abfe000 CR4: 00000000000006e0 [ 6466.489924] Call Trace: [ 6466.490728] build_backref_tree.cold+0xcc/0xdd [btrfs] [ 6466.492400] relocate_tree_blocks+0x19c/0x6f0 [btrfs] [ 6466.493989] ? kmem_cache_alloc_trace+0x1d3/0x260 [ 6466.495405] relocate_block_group+0x218/0x5b0 [btrfs] [ 6466.496884] btrfs_relocate_block_group+0x154/0x300 [btrfs] [ 6466.498478] btrfs_relocate_chunk+0x32/0xd0 [btrfs] [ 6466.499768] __btrfs_balance+0x41c/0xc90 [btrfs] [ 6466.501306] btrfs_balance+0x57d/0xa60 [btrfs] [ 6466.502663] ? btrfs_ioctl_balance+0x21c/0x350 [btrfs] [ 6466.504183] ? kmem_cache_alloc_trace+0x1d3/0x260 [ 6466.505578] btrfs_ioctl_balance+0x298/0x350 [btrfs] [ 6466.506819] btrfs_ioctl+0x2d3/0x2550 [btrfs] [ 6466.507964] ? __handle_mm_fault+0x60b/0x6e0 [ 6466.508883] ? _raw_spin_unlock+0x24/0x30 [ 6466.509678] ? do_vfs_ioctl+0x405/0x730 [ 6466.510390] do_vfs_ioctl+0x405/0x730 [ 6466.511056] ksys_ioctl+0x3a/0x70 [ 6466.511834] ? trace_hardirqs_off_thunk+0x1a/0x20 [ 6466.512715] __x64_sys_ioctl+0x16/0x20 [ 6466.513351] do_syscall_64+0x50/0x1f0 [ 6466.513978] entry_SYSCALL_64_after_hwframe+0x49/0xbe [ 6466.514790] RIP: 0033:0x7f5ca4620387 [ 6466.518949] RSP: 002b:00007ffe004aeb78 EFLAGS: 00000206 ORIG_RAX: 0000000000000010 [ 6466.521066] RAX: ffffffffffffffda RBX: 00007ffe004aec20 RCX: 00007f5ca4620387 [ 6466.523018] RDX: 00007ffe004aec20 RSI: 00000000c4009420 RDI: 0000000000000003 [ 6466.524988] RBP: 0000000000000003 R08: 000055683637c2a0 R09: 0000000000000231 [ 6466.526966] R10: fffffffffffff206 R11: 0000000000000206 R12: 0000000000000001 [ 6466.528936] R13: 00007ffe004b0167 R14: 0000000000000001 R15: 0000000000000000 [ 6466.533252] Modules linked in: dm_flakey dm_mod dax btrfs libcrc32c xor zstd_decompress zstd_compress xxhash raid6_pq loop [ 6466.535241] ---[ end trace a30d87f8f65c9956 ]--- [ 6466.536313] RIP: 0010:assfail.constprop.0+0x18/0x26 [btrfs] [ 6466.540357] RSP: 0000:ffffaca387a13950 EFLAGS: 00010246 [ 6466.541358] RAX: 000000000000004b RBX: ffff97d4777aacb8 RCX: 0000000000000001 [ 6466.542609] RDX: 0000000000000000 RSI: 0000000000000001 RDI: ffffffffbd1044c0 [ 6466.545863] RBP: dead000000000122 R08: 0000000000000000 R09: 0000000000000000 [ 6466.548036] R10: 0000000000000000 R11: 0000000000000000 R12: dead000000000100 [ 6466.549618] R13: ffff97d46d38f508 R14: ffff97d490a74b90 R15: ffff97d4777aace8 [ 6466.551137] FS: 00007f5ca43fb8c0(0000) GS:ffff97d4bdc00000(0000) knlGS:0000000000000000 [ 6466.552858] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 6466.553844] CR2: 000055c2028b0018 CR3: 000000003abfe000 CR4: 00000000000006e0 [ 6467.928233] ------------[ cut here ]------------