€•eMŒsphinx.addnodes”Œdocument”“”)”}”(Œ rawsource”Œ”Œchildren”]”(Œ translations”Œ LanguagesNode”“”)”}”(hhh]”(hŒ pending_xref”“”)”}”(hhh]”Œdocutils.nodes”ŒText”“”ŒChinese (Simplified)”…””}”(hhŒparent”hubaŒ attributes”}”(Œids”]”Œclasses”]”Œnames”]”Œdupnames”]”Œbackrefs”]”Œ refdomain”Œstd”Œreftype”Œdoc”Œ reftarget”Œ%/translations/zh_CN/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuŒtagname”hhh ubh)”}”(hhh]”hŒChinese (Traditional)”…””}”(hhhh2ubah}”(h]”h ]”h"]”h$]”h&]”Œ refdomain”h)Œreftype”h+Œ reftarget”Œ%/translations/zh_TW/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuh1hhh ubh)”}”(hhh]”hŒItalian”…””}”(hhhhFubah}”(h]”h ]”h"]”h$]”h&]”Œ refdomain”h)Œreftype”h+Œ reftarget”Œ%/translations/it_IT/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuh1hhh ubh)”}”(hhh]”hŒJapanese”…””}”(hhhhZubah}”(h]”h ]”h"]”h$]”h&]”Œ refdomain”h)Œreftype”h+Œ reftarget”Œ%/translations/ja_JP/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuh1hhh ubh)”}”(hhh]”hŒKorean”…””}”(hhhhnubah}”(h]”h ]”h"]”h$]”h&]”Œ refdomain”h)Œreftype”h+Œ reftarget”Œ%/translations/ko_KR/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuh1hhh ubh)”}”(hhh]”hŒSpanish”…””}”(hhhh‚ubah}”(h]”h ]”h"]”h$]”h&]”Œ refdomain”h)Œreftype”h+Œ reftarget”Œ%/translations/sp_SP/RCU/rculist_nulls”Œmodname”NŒ classname”NŒ refexplicit”ˆuh1hhh ubeh}”(h]”h ]”h"]”h$]”h&]”Œcurrent_language”ŒEnglish”uh1h hhŒ _document”hŒsource”NŒline”NubhŒcomment”“”)”}”(hŒ SPDX-License-Identifier: GPL-2.0”h]”hŒ SPDX-License-Identifier: GPL-2.0”…””}”(hhhh£ubah}”(h]”h ]”h"]”h$]”h&]”Œ xml:space”Œpreserve”uh1h¡hhhžhhŸŒ?/var/lib/git/docbuild/linux/Documentation/RCU/rculist_nulls.rst”h KubhŒsection”“”)”}”(hhh]”(hŒtitle”“”)”}”(hŒ1Using RCU hlist_nulls to protect list and objects”h]”hŒ1Using RCU hlist_nulls to protect list and objects”…””}”(hh½hh»hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hh¶hžhhŸh³h KubhŒ paragraph”“”)”}”(hŒ…This section describes how to use hlist_nulls to protect read-mostly linked lists and objects using SLAB_TYPESAFE_BY_RCU allocations.”h]”hŒ…This section describes how to use hlist_nulls to protect read-mostly linked lists and objects using SLAB_TYPESAFE_BY_RCU allocations.”…””}”(hhÍhhËhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h Khh¶hžhubhÊ)”}”(hŒ&Please read the basics in listRCU.rst.”h]”hŒ&Please read the basics in listRCU.rst.”…””}”(hhÛhhÙhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h K hh¶hžhubhµ)”}”(hhh]”(hº)”}”(hŒ Using 'nulls'”h]”hŒUsing ‘nulls’”…””}”(hhìhhêhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hhçhžhhŸh³h KubhÊ)”}”(hŒUUsing special makers (called 'nulls') is a convenient way to solve following problem.”h]”hŒYUsing special makers (called ‘nulls’) is a convenient way to solve following problem.”…””}”(hhúhhøhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h KhhçhžhubhÊ)”}”(hŒñWithout 'nulls', a typical RCU linked list managing objects which are allocated with SLAB_TYPESAFE_BY_RCU kmem_cache can use the following algorithms. Following examples assume 'obj' is a pointer to such objects, which is having below type.”h]”hŒùWithout ‘nulls’, a typical RCU linked list managing objects which are allocated with SLAB_TYPESAFE_BY_RCU kmem_cache can use the following algorithms. Following examples assume ‘obj’ is a pointer to such objects, which is having below type.”…””}”(hjhjhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h KhhçhžhubhŒ literal_block”“”)”}”(hŒWstruct object { struct hlist_node obj_node; atomic_t refcnt; unsigned int key; };”h]”hŒWstruct object { struct hlist_node obj_node; atomic_t refcnt; unsigned int key; };”…””}”(hhhjubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h Khhçhžhubhµ)”}”(hhh]”(hº)”}”(hŒ1) Lookup algorithm”h]”hŒ1) Lookup algorithm”…””}”(hj)hj'hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj$hžhhŸh³h K!ubj)”}”(hXãbegin: rcu_read_lock(); obj = lockless_lookup(key); if (obj) { if (!try_get_ref(obj)) { // might fail for free objects rcu_read_unlock(); goto begin; } /* * Because a writer could delete object, and a writer could * reuse these object before the RCU grace period, we * must check key after getting the reference on object */ if (obj->key != key) { // not the object we expected put_ref(obj); rcu_read_unlock(); goto begin; } } rcu_read_unlock();”h]”hXãbegin: rcu_read_lock(); obj = lockless_lookup(key); if (obj) { if (!try_get_ref(obj)) { // might fail for free objects rcu_read_unlock(); goto begin; } /* * Because a writer could delete object, and a writer could * reuse these object before the RCU grace period, we * must check key after getting the reference on object */ if (obj->key != key) { // not the object we expected put_ref(obj); rcu_read_unlock(); goto begin; } } rcu_read_unlock();”…””}”(hhhj5ubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h K%hj$hžhubhÊ)”}”(hŒŽBeware that lockless_lookup(key) cannot use traditional hlist_for_each_entry_rcu() but a version with an additional memory barrier (smp_rmb())”h]”hŒŽBeware that lockless_lookup(key) cannot use traditional hlist_for_each_entry_rcu() but a version with an additional memory barrier (smp_rmb())”…””}”(hjEhjChžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h K:hj$hžhubj)”}”(hXMlockless_lookup(key) { struct hlist_node *node, *next; for (pos = rcu_dereference((head)->first); pos && ({ next = pos->next; smp_rmb(); prefetch(next); 1; }) && ({ obj = hlist_entry(pos, typeof(*obj), obj_node); 1; }); pos = rcu_dereference(next)) if (obj->key == key) return obj; return NULL; }”h]”hXMlockless_lookup(key) { struct hlist_node *node, *next; for (pos = rcu_dereference((head)->first); pos && ({ next = pos->next; smp_rmb(); prefetch(next); 1; }) && ({ obj = hlist_entry(pos, typeof(*obj), obj_node); 1; }); pos = rcu_dereference(next)) if (obj->key == key) return obj; return NULL; }”…””}”(hhhjQubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h K?hj$hžhubhÊ)”}”(hŒKAnd note the traditional hlist_for_each_entry_rcu() misses this smp_rmb()::”h]”hŒJAnd note the traditional hlist_for_each_entry_rcu() misses this smp_rmb():”…””}”(hŒJAnd note the traditional hlist_for_each_entry_rcu() misses this smp_rmb():”hj_hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h KKhj$hžhubj)”}”(hX struct hlist_node *node; for (pos = rcu_dereference((head)->first); pos && ({ prefetch(pos->next); 1; }) && ({ obj = hlist_entry(pos, typeof(*obj), obj_node); 1; }); pos = rcu_dereference(pos->next)) if (obj->key == key) return obj; return NULL;”h]”hX struct hlist_node *node; for (pos = rcu_dereference((head)->first); pos && ({ prefetch(pos->next); 1; }) && ({ obj = hlist_entry(pos, typeof(*obj), obj_node); 1; }); pos = rcu_dereference(pos->next)) if (obj->key == key) return obj; return NULL;”…””}”(hhhjnubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h KMhj$hžhubhÊ)”}”(hŒQuoting Corey Minyard::”h]”hŒQuoting Corey Minyard:”…””}”(hŒQuoting Corey Minyard:”hj|hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h KVhj$hžhubj)”}”(hXï"If the object is moved from one list to another list in-between the time the hash is calculated and the next field is accessed, and the object has moved to the end of a new list, the traversal will not complete properly on the list it should have, since the object will be on the end of the new list and there's not a way to tell it's on a new list and restart the list traversal. I think that this can be solved by pre-fetching the "next" field (with proper barriers) before checking the key."”h]”hXï"If the object is moved from one list to another list in-between the time the hash is calculated and the next field is accessed, and the object has moved to the end of a new list, the traversal will not complete properly on the list it should have, since the object will be on the end of the new list and there's not a way to tell it's on a new list and restart the list traversal. I think that this can be solved by pre-fetching the "next" field (with proper barriers) before checking the key."”…””}”(hhhj‹ubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h KXhj$hžhubeh}”(h]”Œlookup-algorithm”ah ]”h"]”h$]”Œ1) lookup algorithm”ah&]”uh1h´hhçhžhhŸh³h K!Œ referenced”Kubhµ)”}”(hhh]”(hº)”}”(hŒ2) Insertion algorithm”h]”hŒ2) Insertion algorithm”…””}”(hj§hj¥hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj¢hžhhŸh³h KbubhÊ)”}”(hX_We need to make sure a reader cannot read the new 'obj->obj_node.next' value and previous value of 'obj->key'. Otherwise, an item could be deleted from a chain, and inserted into another chain. If new chain was empty before the move, 'next' pointer is NULL, and lockless reader can not detect the fact that it missed following items in original chain.”h]”hXkWe need to make sure a reader cannot read the new ‘obj->obj_node.next’ value and previous value of ‘obj->key’. Otherwise, an item could be deleted from a chain, and inserted into another chain. If new chain was empty before the move, ‘next’ pointer is NULL, and lockless reader can not detect the fact that it missed following items in original chain.”…””}”(hjµhj³hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h Kdhj¢hžhubj)”}”(hXH/* * Please note that new inserts are done at the head of list, * not in the middle or end. */ obj = kmem_cache_alloc(...); lock_chain(); // typically a spin_lock() obj->key = key; atomic_set_release(&obj->refcnt, 1); // key before refcnt hlist_add_head_rcu(&obj->obj_node, list); unlock_chain(); // typically a spin_unlock()”h]”hXH/* * Please note that new inserts are done at the head of list, * not in the middle or end. */ obj = kmem_cache_alloc(...); lock_chain(); // typically a spin_lock() obj->key = key; atomic_set_release(&obj->refcnt, 1); // key before refcnt hlist_add_head_rcu(&obj->obj_node, list); unlock_chain(); // typically a spin_unlock()”…””}”(hhhjÁubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h Klhj¢hžhubeh}”(h]”Œinsertion-algorithm”ah ]”h"]”Œ2) insertion algorithm”ah$]”h&]”uh1h´hhçhžhhŸh³h Kbubhµ)”}”(hhh]”(hº)”}”(hŒ3) Removal algorithm”h]”hŒ3) Removal algorithm”…””}”(hjÜhjÚhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj×hžhhŸh³h KyubhÊ)”}”(hŒ½Nothing special here, we can use a standard RCU hlist deletion. But thanks to SLAB_TYPESAFE_BY_RCU, beware a deleted object can be reused very very fast (before the end of RCU grace period)”h]”hŒ½Nothing special here, we can use a standard RCU hlist deletion. But thanks to SLAB_TYPESAFE_BY_RCU, beware a deleted object can be reused very very fast (before the end of RCU grace period)”…””}”(hjêhjèhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h K{hj×hžhubj)”}”(hŒÂif (put_last_reference_on(obj) { lock_chain(); // typically a spin_lock() hlist_del_init_rcu(&obj->obj_node); unlock_chain(); // typically a spin_unlock() kmem_cache_free(cachep, obj); }”h]”hŒÂif (put_last_reference_on(obj) { lock_chain(); // typically a spin_lock() hlist_del_init_rcu(&obj->obj_node); unlock_chain(); // typically a spin_unlock() kmem_cache_free(cachep, obj); }”…””}”(hhhjöubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h Khj×hžhubeh}”(h]”Œremoval-algorithm”ah ]”h"]”Œ3) removal algorithm”ah$]”h&]”uh1h´hhçhžhhŸh³h Kyubeh}”(h]”Œ using-nulls”ah ]”h"]”Œ using 'nulls'”ah$]”h&]”uh1h´hh¶hžhhŸh³h KubhŒ transition”“”)”}”(hŒJ--------------------------------------------------------------------------”h]”h}”(h]”h ]”h"]”h$]”h&]”uh1jhŸh³h KŠhh¶hžhubhµ)”}”(hhh]”(hº)”}”(hŒAvoiding extra smp_rmb()”h]”hŒAvoiding extra smp_rmb()”…””}”(hj%hj#hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj hžhhŸh³h KubhÊ)”}”(hŒCWith hlist_nulls we can avoid extra smp_rmb() in lockless_lookup().”h]”hŒCWith hlist_nulls we can avoid extra smp_rmb() in lockless_lookup().”…””}”(hj3hj1hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h Khj hžhubhÊ)”}”(hXøFor example, if we choose to store the slot number as the 'nulls' end-of-list marker for each slot of the hash table, we can detect a race (some writer did a delete and/or a move of an object to another chain) checking the final 'nulls' value if the lookup met the end of chain. If final 'nulls' value is not the slot number, then we must restart the lookup at the beginning. If the object was moved to the same chain, then the reader doesn't care: It might occasionally scan the list again without harm.”h]”hXFor example, if we choose to store the slot number as the ‘nulls’ end-of-list marker for each slot of the hash table, we can detect a race (some writer did a delete and/or a move of an object to another chain) checking the final ‘nulls’ value if the lookup met the end of chain. If final ‘nulls’ value is not the slot number, then we must restart the lookup at the beginning. If the object was moved to the same chain, then the reader doesn’t care: It might occasionally scan the list again without harm.”…””}”(hjAhj?hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h K‘hj hžhubhÊ)”}”(hŒtNote that using hlist_nulls means the type of 'obj_node' field of 'struct object' becomes 'struct hlist_nulls_node'.”h]”hŒ€Note that using hlist_nulls means the type of ‘obj_node’ field of ‘struct object’ becomes ‘struct hlist_nulls_node’.”…””}”(hjOhjMhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h K›hj hžhubhµ)”}”(hhh]”(hº)”}”(hŒ1) lookup algorithm”h]”hŒ1) lookup algorithm”…””}”(hj`hj^hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hj[hžhhŸh³h K ubj)”}”(hX§head = &table[slot]; begin: rcu_read_lock(); hlist_nulls_for_each_entry_rcu(obj, node, head, obj_node) { if (obj->key == key) { if (!try_get_ref(obj)) { // might fail for free objects rcu_read_unlock(); goto begin; } if (obj->key != key) { // not the object we expected put_ref(obj); rcu_read_unlock(); goto begin; } goto out; } } // If the nulls value we got at the end of this lookup is // not the expected one, we must restart lookup. // We probably met an item that was moved to another chain. if (get_nulls_value(node) != slot) { put_ref(obj); rcu_read_unlock(); goto begin; } obj = NULL; out: rcu_read_unlock();”h]”hX§head = &table[slot]; begin: rcu_read_lock(); hlist_nulls_for_each_entry_rcu(obj, node, head, obj_node) { if (obj->key == key) { if (!try_get_ref(obj)) { // might fail for free objects rcu_read_unlock(); goto begin; } if (obj->key != key) { // not the object we expected put_ref(obj); rcu_read_unlock(); goto begin; } goto out; } } // If the nulls value we got at the end of this lookup is // not the expected one, we must restart lookup. // We probably met an item that was moved to another chain. if (get_nulls_value(node) != slot) { put_ref(obj); rcu_read_unlock(); goto begin; } obj = NULL; out: rcu_read_unlock();”…””}”(hhhjlubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h K¤hj[hžhubeh}”(h]”Œid1”ah ]”h"]”h$]”jŸah&]”uh1h´hj hžhhŸh³h K j¡Kubhµ)”}”(hhh]”(hº)”}”(hŒ2) Insert algorithm”h]”hŒ2) Insert algorithm”…””}”(hj†hj„hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¹hjhžhhŸh³h KÄubhÊ)”}”(hŒ[Same to the above one, but uses hlist_nulls_add_head_rcu() instead of hlist_add_head_rcu().”h]”hŒ[Same to the above one, but uses hlist_nulls_add_head_rcu() instead of hlist_add_head_rcu().”…””}”(hj”hj’hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhŸh³h KÆhjhžhubj)”}”(hX•/* * Please note that new inserts are done at the head of list, * not in the middle or end. */ obj = kmem_cache_alloc(cachep); lock_chain(); // typically a spin_lock() obj->key = key; atomic_set_release(&obj->refcnt, 1); // key before refcnt /* * insert obj in RCU way (readers might be traversing chain) */ hlist_nulls_add_head_rcu(&obj->obj_node, list); unlock_chain(); // typically a spin_unlock()”h]”hX•/* * Please note that new inserts are done at the head of list, * not in the middle or end. */ obj = kmem_cache_alloc(cachep); lock_chain(); // typically a spin_lock() obj->key = key; atomic_set_release(&obj->refcnt, 1); // key before refcnt /* * insert obj in RCU way (readers might be traversing chain) */ hlist_nulls_add_head_rcu(&obj->obj_node, list); unlock_chain(); // typically a spin_unlock()”…””}”(hhhj ubah}”(h]”h ]”h"]”h$]”h&]”h±h²uh1jhŸh³h KËhjhžhubeh}”(h]”Œinsert-algorithm”ah ]”h"]”Œ2) insert algorithm”ah$]”h&]”uh1h´hj hžhhŸh³h KÄubeh}”(h]”Œavoiding-extra-smp-rmb”ah ]”h"]”Œavoiding extra smp_rmb()”ah$]”h&]”uh1h´hh¶hžhhŸh³h Kubeh}”(h]”Œ1using-rcu-hlist-nulls-to-protect-list-and-objects”ah ]”h"]”Œ1using rcu hlist_nulls to protect list and objects”ah$]”h&]”uh1h´hhhžhhŸh³h Kubeh}”(h]”h ]”h"]”h$]”h&]”Œsource”h³uh1hŒcurrent_source”NŒ current_line”NŒsettings”Œdocutils.frontend”ŒValues”“”)”}”(h¹NŒ generator”NŒ datestamp”NŒ source_link”NŒ source_url”NŒ toc_backlinks”Œentry”Œfootnote_backlinks”KŒ sectnum_xform”KŒstrip_comments”NŒstrip_elements_with_classes”NŒ strip_classes”NŒ report_level”KŒ halt_level”KŒexit_status_level”KŒdebug”NŒwarning_stream”NŒ traceback”ˆŒinput_encoding”Œ utf-8-sig”Œinput_encoding_error_handler”Œstrict”Œoutput_encoding”Œutf-8”Œoutput_encoding_error_handler”jéŒerror_encoding”ŒUTF-8”Œerror_encoding_error_handler”Œbackslashreplace”Œ language_code”Œen”Œrecord_dependencies”NŒconfig”NŒ id_prefix”hŒauto_id_prefix”Œid”Œ dump_settings”NŒdump_internals”NŒdump_transforms”NŒdump_pseudo_xml”NŒexpose_internals”NŒstrict_visitor”NŒ_disable_config”NŒ_source”h³Œ _destination”NŒ _config_files”]”Œ7/var/lib/git/docbuild/linux/Documentation/docutils.conf”aŒpep_references”NŒ pep_base_url”Œhttps://peps.python.org/”Œpep_file_url_template”Œpep-%04d”Œrfc_references”NŒ rfc_base_url”Œ&https://datatracker.ietf.org/doc/html/”Œ tab_width”KŒtrim_footnote_reference_space”‰Œfile_insertion_enabled”ˆŒ raw_enabled”KŒline_length_limit”M'Œsyntax_highlight”Œlong”Œ smart_quotes”ˆŒsmartquotes_locales”]”Œcharacter_level_inline_markup”‰Œdoctitle_xform”‰Œ docinfo_xform”KŒsectsubtitle_xform”‰Œ image_loading”Œlink”Œembed_stylesheet”‰Œcloak_email_addresses”ˆŒsection_self_link”‰Œ embed_images”‰Œenv”NubŒreporter”NŒindirect_targets”]”Œsubstitution_defs”}”Œsubstitution_names”}”Œrefnames”}”Œrefids”}”Œnameids”}”(jÃjÀjjŒ1) lookup algorithm”NjÔjÑj jj»j¸j³j°uŒ nametypes”}”(jÃNjNj.NjÔNj Nj»Nj³Nuh}”(jÀh¶jhçj›j$jÑj¢jj×j¸j j|j[j°juŒ footnote_refs”}”Œ citation_refs”}”Œ autofootnotes”]”Œautofootnote_refs”]”Œsymbol_footnotes”]”Œsymbol_footnote_refs”]”Œ footnotes”]”Œ citations”]”Œautofootnote_start”KŒsymbol_footnote_start”KŒ id_counter”Œ collections”ŒCounter”“”}”j÷Ks…”R”Œparse_messages”]”hŒsystem_message”“”)”}”(hhh]”hÊ)”}”(hŒ6Duplicate implicit target name: "1) lookup algorithm".”h]”hŒ:Duplicate implicit target name: “1) lookup algorithmâ€.”…””}”(hhhjRhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÉhjOubah}”(h]”h ]”h"]”h$]”h&]”j|aŒlevel”KŒtype”ŒINFO”Œsource”h³Œline”K uh1jMhj[hžhhŸh³h K ubaŒtransform_messages”]”Œ transformer”NŒ include_log”]”Œ decoration”Nhžhub.