Merge: CNB101: unroll: add generic loop unroll helpers

MR: https://gitlab.com/redhat/centos-stream/src/kernel/centos-stream-10/-/merge_requests/921

JIRA: https://issues.redhat.com/browse/RHEL-92674

```
commit c6594d6
Author: Alexander Lobakin <aleksander.lobakin@intel.com>
Date:   Thu Feb 6 19:26:26 2025 +0100

    unroll: add generic loop unroll helpers

    There are cases when we need to explicitly unroll loops. For example,
    cache operations, filling DMA descriptors on very high speeds etc.
    Add compiler-specific attribute macros to give the compiler a hint
    that we'd like to unroll a loop.
    Example usage:

     #define UNROLL_BATCH 8

            unrolled_count(UNROLL_BATCH)
            for (u32 i = 0; i < UNROLL_BATCH; i++)
                    op(priv, i);

    Note that sometimes the compilers won't unroll loops if they think this
    would have worse optimization and perf than without unrolling, and that
    unroll attributes are available only starting GCC 8. For older compiler
    versions, no hints/attributes will be applied.
    For better unrolling/parallelization, don't have any variables that
    interfere between iterations except for the iterator itself.

    Co-developed-by: Jose E. Marchesi <jose.marchesi@oracle.com> # pragmas
    Signed-off-by: Jose E. Marchesi <jose.marchesi@oracle.com>
    Reviewed-by: Przemek Kitszel <przemyslaw.kitszel@intel.com>
    Signed-off-by: Alexander Lobakin <aleksander.lobakin@intel.com>
    Link: https://patch.msgid.link/20250206182630.3914318-2-aleksander.lobakin@intel.com
    Signed-off-by: Jakub Kicinski <kuba@kernel.org>
```

Signed-off-by: CKI Backport Bot <cki-ci-bot+cki-gitlab-backport-bot@redhat.com>

---

<small>Created 2025-05-20 12:18 UTC by backporter - [KWF FAQ](https://red.ht/kernel_workflow_doc) - [Slack #team-kernel-workflow](https://redhat-internal.slack.com/archives/C04LRUPMJQ5) - [Source](https://gitlab.com/cki-project/kernel-workflow/-/blob/main/webhook/utils/backporter.py) - [Documentation](https://gitlab.com/cki-project/kernel-workflow/-/blob/main/docs/README.backporter.md) - [Report an issue](https://issues.redhat.com/secure/CreateIssueDetails!init.jspa?pid=12334433&issuetype=1&priority=4&summary=backporter+webhook+issue&components=kernel-workflow+/+backporter)</small>

Approved-by: Ivan Vecera <ivecera@redhat.com>
Approved-by: Michal Schmidt <mschmidt@redhat.com>

Merged-by: Julio Faracco <jfaracco@redhat.com>

Author: jcfaracco

include/linux/unroll.h

@@ -9,6 +9,50 @@
 
 #include <linux/args.h>
 
+#ifdef CONFIG_CC_IS_CLANG
+#define __pick_unrolled(x, y)		_Pragma(#x)
+#elif CONFIG_GCC_VERSION >= 80000
+#define __pick_unrolled(x, y)		_Pragma(#y)
+#else
+#define __pick_unrolled(x, y)		/* not supported */
+#endif
+
+/**
+ * unrolled - loop attributes to ask the compiler to unroll it
+ *
+ * Usage:
+ *
+ * #define BATCH 8
+ *
+ *	unrolled_count(BATCH)
+ *	for (u32 i = 0; i < BATCH; i++)
+ *		// loop body without cross-iteration dependencies
+ *
+ * This is only a hint and the compiler is free to disable unrolling if it
+ * thinks the count is suboptimal and may hurt performance and/or hugely
+ * increase object code size.
+ * Not having any cross-iteration dependencies (i.e. when iter x + 1 depends
+ * on what iter x will do with variables) is not a strict requirement, but
+ * provides best performance and object code size.
+ * Available only on Clang and GCC 8.x onwards.
+ */
+
+/* Ask the compiler to pick an optimal unroll count, Clang only */
+#define unrolled							\
+	__pick_unrolled(clang loop unroll(enable), /* nothing */)
+
+/* Unroll each @n iterations of the loop */
+#define unrolled_count(n)						\
+	__pick_unrolled(clang loop unroll_count(n), GCC unroll n)
+
+/* Unroll the whole loop */
+#define unrolled_full							\
+	__pick_unrolled(clang loop unroll(full), GCC unroll 65534)
+
+/* Never unroll the loop */
+#define unrolled_none							\
+	__pick_unrolled(clang loop unroll(disable), GCC unroll 1)
+
 #define UNROLL(N, MACRO, args...) CONCATENATE(__UNROLL_, N)(MACRO, args)
 
 #define __UNROLL_0(MACRO, args...)