Lines Matching refs:sub

33 sub-buffers.  Messages are written to the first sub-buffer until it is
35 the next (if available).  Messages are never split across sub-buffers.
37 sub-buffer, while the kernel continues writing to the next.
39 When notified that a sub-buffer is full, the kernel knows how many
41 message couldn't fit into a sub-buffer.  Userspace can use this
44 After copying it, userspace can notify the kernel that a sub-buffer
57 read sub-buffers; thus in cases where read(2) is being used to drain
95 consumes the read sub-buffers; thus in cases where read(2) is being
134 	    notified when sub-buffer boundaries are crossed.
260 number of sub-buffers by the sub-buffer size passed into relay_open().
261 The idea behind sub-buffers is that they're basically an extension of
265 of sub-buffers is completely dependent on the application and even for
269 though, it's safe to assume that having only 1 sub-buffer is a bad
322 be lost, if the number of unconsumed sub-buffers equals the total
323 number of sub-buffers in the channel.  It should be clear that if
324 there is no consumer or if the consumer can't consume sub-buffers fast
330 subdivided into one or more sub-buffers.  Messages are written into
331 the current sub-buffer of the channel's current per-cpu buffer via the
333 the current sub-buffer, because there's no room left for it, the
335 new sub-buffer is about to occur.  The client uses this callback to 1)
336 initialize the next sub-buffer if appropriate 2) finalize the previous
337 sub-buffer if appropriate and 3) return a boolean value indicating
338 whether or not to actually move on to the next sub-buffer.
360 If the current buffer is full, i.e. all sub-buffers remain unconsumed,
363 current set of ready sub-buffers.  For the relay_buf_full() function
365 interface when sub-buffers have been consumed via
369 ready sub-buffers will relay_buf_full() return 0, in which case the
399 Header information can be reserved at the beginning of each sub-buffer
403 reserved in each sub-buffer to store the padding count for that
404 sub-buffer.  This is filled in for the previous sub-buffer in the
406 sub-buffer is passed into the subbuf_start() callback along with a
407 pointer to the previous sub-buffer, since the padding value isn't
408 known until a sub-buffer is filled.  The subbuf_start() callback is
409 also called for the first sub-buffer when the channel is opened, to
411 previous sub-buffer pointer passed into the callback will be NULL, so
413 writing into the previous sub-buffer.
437 written, either in space reserved in the sub-buffers themselves or as
451 forces a sub-buffer switch on all the channel buffers, and can be used
452 to finalize and process the last sub-buffers before the channel is