Ceph » rbd

The osd client currently maintains the ops array for an osd
request directly in its request message. It formats into
the message in ceph_osdc_build_request() and then keeps a
pointer to where the ops array ended up. This is only used
used in writepages_finish(), to determine what the length
of the written data was suppoed to be.

Also, since there's currently at most one data item in
each direction in use at any time in an array of ops, it
is sufficient to retain information about the single
incoming and/or single outgoing data item for a request.

In order to allow more than one op in an ops array to contain
data (and potentially more than one piece of data), we will
need to retain information about the data used by each op,
until that op (or all of them in the request) is complete.

Rather than just keep the data, we might as well keep
information all ops in the request. That way we can
have multiple data items incoming and/or outgoing in
a single request. We can even have more than one data
item for a single request.

I've had this underway for a while. But it ended up
being more work to finish than I expected--enough that
I thought I should break it off as a separate sub-task
to describe it now that it's done. This basic switch
to using source ops was not that hard, but...

Since we're storing an array of ops in the request
itself, I rearranged things so callers don't provide
an op or array of them to work on as before. Instead,
they just create an osd request and then provide the
request pointer and an op index to indicate which op
is being built up or referenced. When all is said
and done, the source array is then used in place to
format the message, in ceph_osdc_build_request().