linux-next: manual merge of the vhost tree with Linus' tree

[Stephen Rothwell <sfr@canb.auug.org.au>]

[-- Attachment #1: Type: text/plain, Size: 6923 bytes --]

Hi all,

Today's linux-next merge of the vhost tree got a conflict in:

  scripts/lib/kdoc/kdoc_parser.py

between commit:

  77e3c875f0a8 ("docs: kdoc: split struct-member rewriting out of dump_struct()")

from Linus' tree (and maybe some others) and commit:

  67ae57499e77 ("virtio: clean up features qword/dword terms")

from the vhost tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc scripts/lib/kdoc/kdoc_parser.py
index f7dbb0868367,5d629aebc8f0..000000000000
--- a/scripts/lib/kdoc/kdoc_parser.py
+++ b/scripts/lib/kdoc/kdoc_parser.py
@@@ -72,133 -74,6 +72,134 @@@ doc_begin_func = KernRe(str(doc_com) 
                          r'(?:[-:].*)?$',		# description (not captured)
                          cache = False)
  
 +#
 +# Here begins a long set of transformations to turn structure member prefixes
 +# and macro invocations into something we can parse and generate kdoc for.
 +#
 +struct_args_pattern = r'([^,)]+)'
 +
 +struct_xforms = [
 +    # Strip attributes
 +    (KernRe(r"__attribute__\s*\(\([a-z0-9,_\*\s\(\)]*\)\)", flags=re.I | re.S, cache=False), ' '),
 +    (KernRe(r'\s*__aligned\s*\([^;]*\)', re.S), ' '),
 +    (KernRe(r'\s*__counted_by\s*\([^;]*\)', re.S), ' '),
 +    (KernRe(r'\s*__counted_by_(le|be)\s*\([^;]*\)', re.S), ' '),
 +    (KernRe(r'\s*__packed\s*', re.S), ' '),
 +    (KernRe(r'\s*CRYPTO_MINALIGN_ATTR', re.S), ' '),
 +    (KernRe(r'\s*____cacheline_aligned_in_smp', re.S), ' '),
 +    (KernRe(r'\s*____cacheline_aligned', re.S), ' '),
 +    (KernRe(r'\s*__cacheline_group_(begin|end)\([^\)]+\);'), ''),
 +    #
 +    # Unwrap struct_group macros based on this definition:
 +    # __struct_group(TAG, NAME, ATTRS, MEMBERS...)
 +    # which has variants like: struct_group(NAME, MEMBERS...)
 +    # Only MEMBERS arguments require documentation.
 +    #
 +    # Parsing them happens on two steps:
 +    #
 +    # 1. drop struct group arguments that aren't at MEMBERS,
 +    #    storing them as STRUCT_GROUP(MEMBERS)
 +    #
 +    # 2. remove STRUCT_GROUP() ancillary macro.
 +    #
 +    # The original logic used to remove STRUCT_GROUP() using an
 +    # advanced regex:
 +    #
 +    #   \bSTRUCT_GROUP(\(((?:(?>[^)(]+)|(?1))*)\))[^;]*;
 +    #
 +    # with two patterns that are incompatible with
 +    # Python re module, as it has:
 +    #
 +    #   - a recursive pattern: (?1)
 +    #   - an atomic grouping: (?>...)
 +    #
 +    # I tried a simpler version: but it didn't work either:
 +    #   \bSTRUCT_GROUP\(([^\)]+)\)[^;]*;
 +    #
 +    # As it doesn't properly match the end parenthesis on some cases.
 +    #
 +    # So, a better solution was crafted: there's now a NestedMatch
 +    # class that ensures that delimiters after a search are properly
 +    # matched. So, the implementation to drop STRUCT_GROUP() will be
 +    # handled in separate.
 +    #
 +    (KernRe(r'\bstruct_group\s*\(([^,]*,)', re.S), r'STRUCT_GROUP('),
 +    (KernRe(r'\bstruct_group_attr\s*\(([^,]*,){2}', re.S), r'STRUCT_GROUP('),
 +    (KernRe(r'\bstruct_group_tagged\s*\(([^,]*),([^,]*),', re.S), r'struct \1 \2; STRUCT_GROUP('),
 +    (KernRe(r'\b__struct_group\s*\(([^,]*,){3}', re.S), r'STRUCT_GROUP('),
 +    #
 +    # Replace macros
 +    #
 +    # TODO: use NestedMatch for FOO($1, $2, ...) matches
 +    #
 +    # it is better to also move those to the NestedMatch logic,
 +    # to ensure that parenthesis will be properly matched.
 +    #
 +    (KernRe(r'__ETHTOOL_DECLARE_LINK_MODE_MASK\s*\(([^\)]+)\)', re.S),
 +     r'DECLARE_BITMAP(\1, __ETHTOOL_LINK_MODE_MASK_NBITS)'),
 +    (KernRe(r'DECLARE_PHY_INTERFACE_MASK\s*\(([^\)]+)\)', re.S),
 +     r'DECLARE_BITMAP(\1, PHY_INTERFACE_MODE_MAX)'),
 +    (KernRe(r'DECLARE_BITMAP\s*\(' + struct_args_pattern + r',\s*' + struct_args_pattern + r'\)',
 +            re.S), r'unsigned long \1[BITS_TO_LONGS(\2)]'),
 +    (KernRe(r'DECLARE_HASHTABLE\s*\(' + struct_args_pattern + r',\s*' + struct_args_pattern + r'\)',
 +            re.S), r'unsigned long \1[1 << ((\2) - 1)]'),
 +    (KernRe(r'DECLARE_KFIFO\s*\(' + struct_args_pattern + r',\s*' + struct_args_pattern +
 +            r',\s*' + struct_args_pattern + r'\)', re.S), r'\2 *\1'),
 +    (KernRe(r'DECLARE_KFIFO_PTR\s*\(' + struct_args_pattern + r',\s*' +
 +            struct_args_pattern + r'\)', re.S), r'\2 *\1'),
 +    (KernRe(r'(?:__)?DECLARE_FLEX_ARRAY\s*\(' + struct_args_pattern + r',\s*' +
 +            struct_args_pattern + r'\)', re.S), r'\1 \2[]'),
 +    (KernRe(r'DEFINE_DMA_UNMAP_ADDR\s*\(' + struct_args_pattern + r'\)', re.S), r'dma_addr_t \1'),
 +    (KernRe(r'DEFINE_DMA_UNMAP_LEN\s*\(' + struct_args_pattern + r'\)', re.S), r'__u32 \1'),
++    (KernRe(r'VIRTIO_DECLARE_FEATURES\s*\(' + args_pattern + r'\)', re.S), r'u64 \1; u64 \1_array[VIRTIO_FEATURES_QWORDS]'),
 +]
 +#
 +# Regexes here are guaranteed to have the end limiter matching
 +# the start delimiter. Yet, right now, only one replace group
 +# is allowed.
 +#
 +struct_nested_prefixes = [
 +    (re.compile(r'\bSTRUCT_GROUP\('), r'\1'),
 +]
 +
 +#
 +# Transforms for function prototypes
 +#
 +function_xforms  = [
 +    (KernRe(r"^static +"), ""),
 +    (KernRe(r"^extern +"), ""),
 +    (KernRe(r"^asmlinkage +"), ""),
 +    (KernRe(r"^inline +"), ""),
 +    (KernRe(r"^__inline__ +"), ""),
 +    (KernRe(r"^__inline +"), ""),
 +    (KernRe(r"^__always_inline +"), ""),
 +    (KernRe(r"^noinline +"), ""),
 +    (KernRe(r"^__FORTIFY_INLINE +"), ""),
 +    (KernRe(r"__init +"), ""),
 +    (KernRe(r"__init_or_module +"), ""),
 +    (KernRe(r"__deprecated +"), ""),
 +    (KernRe(r"__flatten +"), ""),
 +    (KernRe(r"__meminit +"), ""),
 +    (KernRe(r"__must_check +"), ""),
 +    (KernRe(r"__weak +"), ""),
 +    (KernRe(r"__sched +"), ""),
 +    (KernRe(r"_noprof"), ""),
 +    (KernRe(r"__printf\s*\(\s*\d*\s*,\s*\d*\s*\) +"), ""),
 +    (KernRe(r"__(?:re)?alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\) +"), ""),
 +    (KernRe(r"__diagnose_as\s*\(\s*\S+\s*(?:,\s*\d+\s*)*\) +"), ""),
 +    (KernRe(r"DECL_BUCKET_PARAMS\s*\(\s*(\S+)\s*,\s*(\S+)\s*\)"), r"\1, \2"),
 +    (KernRe(r"__attribute_const__ +"), ""),
 +    (KernRe(r"__attribute__\s*\(\((?:[\w\s]+(?:\([^)]*\))?\s*,?)+\)\)\s+"), ""),
 +]
 +
 +#
 +# Apply a set of transforms to a block of text.
 +#
 +def apply_transforms(xforms, text):
 +    for search, subst in xforms:
 +        text = search.sub(subst, text)
 +    return text
 +
  #
  # A little helper to get rid of excess white space
  #

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]