IB/core: extended command: an improved infrastructure for uverbs commands

Commit 400dbc96583f ("IB/core: Infrastructure for extensible uverbs
commands") added an infrastructure for extensible uverbs commands
while later commit 436f2ad05a0b ("IB/core: Export ib_create/destroy_flow
through uverbs") exported ib_create_flow()/ib_destroy_flow() functions
using this new infrastructure.

According to the commit 400dbc96583f, the purpose of this
infrastructure is to support passing around provider (eg. hardware)
specific buffers when userspace issue commands to the kernel, so that
it would be possible to extend uverbs (eg. core) buffers independently
from the provider buffers.

But the new kernel command function prototypes were not modified to
take advantage of this extension. This issue was exposed by Roland
Dreier in a previous review[1].

So the following patch is an attempt to a revised extensible command
infrastructure.

This improved extensible command infrastructure distinguish between
core (eg. legacy)'s command/response buffers from provider
(eg. hardware)'s command/response buffers: each extended command
implementing function is given a struct ib_udata to hold core
(eg. uverbs) input and output buffers, and another struct ib_udata to
hold the hw (eg. provider) input and output buffers.

Having those buffers identified separately make it easier to increase
one buffer to support extension without having to add some code to
guess the exact size of each command/response parts: This should make
the extended functions more reliable.

Additionally, instead of relying on command identifier being greater
than IB_USER_VERBS_CMD_THRESHOLD, the proposed infrastructure rely on
unused bits in command field: on the 32 bits provided by command
field, only 6 bits are really needed to encode the identifier of
commands currently supported by the kernel. (Even using only 6 bits
leaves room for about 23 new commands).

So this patch makes use of some high order bits in command field to
store flags, leaving enough room for more command identifiers than one
will ever need (eg. 256).

The new flags are used to specify if the command should be processed
as an extended one or a legacy one. While designing the new command
format, care was taken to make usage of flags itself extensible.

Using high order bits of the commands field ensure that newer
libibverbs on older kernel will properly fail when trying to call
extended commands. On the other hand, older libibverbs on newer kernel
will never be able to issue calls to extended commands.

The extended command header includes the optional response pointer so
that output buffer length and output buffer pointer are located
together in the command, allowing proper parameters checking. This
should make implementing functions easier and safer.

Additionally the extended header ensure 64bits alignment, while making
all sizes multiple of 8 bytes, extending the maximum buffer size:

                             legacy      extended

   Maximum command buffer:  256KBytes   1024KBytes (512KBytes + 512KBytes)
  Maximum response buffer:  256KBytes   1024KBytes (512KBytes + 512KBytes)

For the purpose of doing proper buffer size accounting, the headers
size are no more taken in account in "in_words".

One of the odds of the current extensible infrastructure, reading
twice the "legacy" command header, is fixed by removing the "legacy"
command header from the extended command header: they are processed as
two different parts of the command: memory is read once and
information are not duplicated: it's making clear that's an extended
command scheme and not a different command scheme.

The proposed scheme will format input (command) and output (response)
buffers this way:

- command:

  legacy header +
  extended header +
  command data (core + hw):

    +----------------------------------------+
    | flags     |   00      00    |  command |
    |        in_words    |   out_words       |
    +----------------------------------------+
    |                 response               |
    |                 response               |
    | provider_in_words | provider_out_words |
    |                 padding                |
    +----------------------------------------+
    |                                        |
    .              <uverbs input>            .
    .              (in_words * 8)            .
    |                                        |
    +----------------------------------------+
    |                                        |
    .             <provider input>           .
    .          (provider_in_words * 8)       .
    |                                        |
    +----------------------------------------+

- response, if present:

    +----------------------------------------+
    |                                        |
    .          <uverbs output space>         .
    .             (out_words * 8)            .
    |                                        |
    +----------------------------------------+
    |                                        |
    .         <provider output space>        .
    .         (provider_out_words * 8)       .
    |                                        |
    +----------------------------------------+

The overall design is to ensure that the extensible infrastructure is
itself extensible while begin more reliable with more input and bound
checking.

Note:

The unused field in the extended header would be perfect candidate to
hold the command "comp_mask" (eg. bit field used to handle
compatibility).  This was suggested by Roland Dreier in a previous
review[2].  But "comp_mask" field is likely to be present in the uverb
input and/or provider input, likewise for the response, as noted by
Matan Barak[3], so it doesn't make sense to put "comp_mask" in the
header.

[1]:
http://marc.info/?i=CAL1RGDWxmM17W2o_era24A-TTDeKyoL6u3NRu_=t_dhV_ZA9MA@mail.gmail.com

[2]:
http://marc.info/?i=CAL1RGDXJtrc849M6_XNZT5xO1+ybKtLWGq6yg6LhoSsKpsmkYA@mail.gmail.com

[3]:
http://marc.info/?i=525C1149.6000701@mellanox.com

Signed-off-by: Yann Droneaud <ydroneaud@opteya.com>
Link: http://marc.info/?i=cover.1383773832.git.ydroneaud@opteya.com

[ Convert "ret ? ret : 0" to the equivalent "ret".  - Roland ]

Signed-off-by: Roland Dreier <roland@purestorage.com>

1 files changed, 98 insertions, 29 deletions

diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 2df31f68ea09..189d99e76d9f 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -115,11 +115,16 @@ static ssize_t (*uverbs_cmd_table[])(struct ib_uverbs_file *file,
         [IB_USER_VERBS_CMD_CLOSE_XRCD]          = ib_uverbs_close_xrcd,
         [IB_USER_VERBS_CMD_CREATE_XSRQ]         = ib_uverbs_create_xsrq,
         [IB_USER_VERBS_CMD_OPEN_QP]             = ib_uverbs_open_qp,
+};
+
 #ifdef CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING
-        [IB_USER_VERBS_CMD_CREATE_FLOW]         = ib_uverbs_create_flow,
-        [IB_USER_VERBS_CMD_DESTROY_FLOW]        = ib_uverbs_destroy_flow
-#endif /* CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING */
+static int (*uverbs_ex_cmd_table[])(struct ib_uverbs_file *file,
+                                    struct ib_udata *ucore,
+                                    struct ib_udata *uhw) = {
+        [IB_USER_VERBS_EX_CMD_CREATE_FLOW]      = ib_uverbs_ex_create_flow,
+        [IB_USER_VERBS_EX_CMD_DESTROY_FLOW]     = ib_uverbs_ex_destroy_flow
 };
+#endif /* CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING */
 
 static void ib_uverbs_add_one(struct ib_device *device);
 static void ib_uverbs_remove_one(struct ib_device *device);
@@ -589,6 +594,7 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
 {
         struct ib_uverbs_file *file = filp->private_data;
         struct ib_uverbs_cmd_hdr hdr;
+        __u32 flags;
 
         if (count < sizeof hdr)
                 return -EINVAL;
@@ -596,45 +602,108 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
         if (copy_from_user(&hdr, buf, sizeof hdr))
                 return -EFAULT;
 
-        if (hdr.command >= ARRAY_SIZE(uverbs_cmd_table) ||
-            !uverbs_cmd_table[hdr.command])
-                return -EINVAL;
+        flags = (hdr.command &
+                 IB_USER_VERBS_CMD_FLAGS_MASK) >> IB_USER_VERBS_CMD_FLAGS_SHIFT;
 
-        if (!file->ucontext &&
-            hdr.command != IB_USER_VERBS_CMD_GET_CONTEXT)
-                return -EINVAL;
+        if (!flags) {
+                __u32 command;
 
-        if (!(file->device->ib_dev->uverbs_cmd_mask & (1ull << hdr.command)))
-                return -ENOSYS;
+                if (hdr.command & ~(__u32)(IB_USER_VERBS_CMD_FLAGS_MASK |
+                                           IB_USER_VERBS_CMD_COMMAND_MASK))
+                        return -EINVAL;
 
-#ifdef CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING
-        if (hdr.command >= IB_USER_VERBS_CMD_THRESHOLD) {
-                struct ib_uverbs_cmd_hdr_ex hdr_ex;
+                command = hdr.command & IB_USER_VERBS_CMD_COMMAND_MASK;
 
-                if (copy_from_user(&hdr_ex, buf, sizeof(hdr_ex)))
-                        return -EFAULT;
+                if (command >= ARRAY_SIZE(uverbs_cmd_table) ||
+                    !uverbs_cmd_table[command])
+                        return -EINVAL;
 
-                if (((hdr_ex.in_words + hdr_ex.provider_in_words) * 4) != count)
+                if (!file->ucontext &&
+                    command != IB_USER_VERBS_CMD_GET_CONTEXT)
                         return -EINVAL;
 
-                return uverbs_cmd_table[hdr.command](file,
-                                                     buf + sizeof(hdr_ex),
-                                                     (hdr_ex.in_words +
-                                                      hdr_ex.provider_in_words) * 4,
-                                                     (hdr_ex.out_words +
-                                                      hdr_ex.provider_out_words) * 4);
-        } else {
-#endif /* CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING */
+                if (!(file->device->ib_dev->uverbs_cmd_mask & (1ull << command)))
+                        return -ENOSYS;
+
                 if (hdr.in_words * 4 != count)
                         return -EINVAL;
 
-                return uverbs_cmd_table[hdr.command](file,
-                                                     buf + sizeof(hdr),
-                                                     hdr.in_words * 4,
-                                                     hdr.out_words * 4);
+                return uverbs_cmd_table[command](file,
+                                                 buf + sizeof(hdr),
+                                                 hdr.in_words * 4,
+                                                 hdr.out_words * 4);
+
 #ifdef CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING
+
+        } else if (flags == IB_USER_VERBS_CMD_FLAG_EXTENDED) {
+                __u32 command;
+
+                struct ib_uverbs_ex_cmd_hdr ex_hdr;
+                struct ib_udata ucore;
+                struct ib_udata uhw;
+                int err;
+                size_t written_count = count;
+
+                if (hdr.command & ~(__u32)(IB_USER_VERBS_CMD_FLAGS_MASK |
+                                           IB_USER_VERBS_CMD_COMMAND_MASK))
+                        return -EINVAL;
+
+                command = hdr.command & IB_USER_VERBS_CMD_COMMAND_MASK;
+
+                if (command >= ARRAY_SIZE(uverbs_ex_cmd_table) ||
+                    !uverbs_ex_cmd_table[command])
+                        return -ENOSYS;
+
+                if (!file->ucontext)
+                        return -EINVAL;
+
+                if (!(file->device->ib_dev->uverbs_ex_cmd_mask & (1ull << command)))
+                        return -ENOSYS;
+
+                if (count < (sizeof(hdr) + sizeof(ex_hdr)))
+                        return -EINVAL;
+
+                if (copy_from_user(&ex_hdr, buf + sizeof(hdr), sizeof(ex_hdr)))
+                        return -EFAULT;
+
+                count -= sizeof(hdr) + sizeof(ex_hdr);
+                buf += sizeof(hdr) + sizeof(ex_hdr);
+
+                if ((hdr.in_words + ex_hdr.provider_in_words) * 8 != count)
+                        return -EINVAL;
+
+                if (ex_hdr.response) {
+                        if (!hdr.out_words && !ex_hdr.provider_out_words)
+                                return -EINVAL;
+                } else {
+                        if (hdr.out_words || ex_hdr.provider_out_words)
+                                return -EINVAL;
+                }
+
+                INIT_UDATA(&ucore,
+                           (hdr.in_words) ? buf : 0,
+                           (unsigned long)ex_hdr.response,
+                           hdr.in_words * 8,
+                           hdr.out_words * 8);
+
+                INIT_UDATA(&uhw,
+                           (ex_hdr.provider_in_words) ? buf + ucore.inlen : 0,
+                           (ex_hdr.provider_out_words) ? (unsigned long)ex_hdr.response + ucore.outlen : 0,
+                           ex_hdr.provider_in_words * 8,
+                           ex_hdr.provider_out_words * 8);
+
+                err = uverbs_ex_cmd_table[command](file,
+                                                   &ucore,
+                                                   &uhw);
+
+                if (err)
+                        return err;
+
+                return written_count;
         }
 #endif /* CONFIG_INFINIBAND_EXPERIMENTAL_UVERBS_FLOW_STEERING */
+
+        return -ENOSYS;
 }
 
 static int ib_uverbs_mmap(struct file *filp, struct vm_area_struct *vma)