/**************************************************************************** * mm/iob/iob_copyin.c * * SPDX-License-Identifier: Apache-2.0 * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. The * ASF licenses this file to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include "iob.h" /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: iob_copyin_internal * * Description: * Copy data 'len' bytes from a user buffer into the I/O buffer chain, * starting at 'offset', extending the chain as necessary. * * Returned Value: * The number of uncopied bytes left if >= 0 OR a negative error code. * ****************************************************************************/ static int iob_copyin_internal(FAR struct iob_s *iob, FAR const uint8_t *src, unsigned int len, int offset, bool throttled, bool can_block) { FAR struct iob_s *head = iob; FAR struct iob_s *next; FAR uint8_t *dest; unsigned int ncopy; unsigned int avail; unsigned int total = len; iobinfo("iob=%p len=%u offset=%d\n", iob, len, offset); DEBUGASSERT(iob && src); /* The offset must applied to data that is already in the I/O buffer * chain */ if ((int)(offset - iob->io_pktlen) > 0) { ioberr("ERROR: offset is past the end of data: %d > %u\n", offset, iob->io_pktlen); return -ESPIPE; } if ((int)(offset + iob->io_offset) < 0) { ioberr("ERROR: offset is before the start of data: %d < %d\n", offset, -(int)iob->io_offset); return -ESPIPE; } /* Skip to the I/O buffer containing the data offset */ while ((int)(offset - iob->io_len) > 0) { offset -= iob->io_len; iob = iob->io_flink; } /* Then loop until all of the I/O data is copied from the user buffer */ while (len > 0) { next = iob->io_flink; /* Get the destination I/O buffer address and the amount of data * available from that address. */ dest = &iob->io_data[iob->io_offset + offset]; avail = iob->io_len - offset; iobinfo("iob=%p avail=%u len=%u next=%p\n", iob, avail, len, next); /* Will the rest of the copy fit into this buffer, overwriting * existing data. */ if (len > avail) { /* No.. Is this the last buffer in the chain? */ if (next) { /* No.. clip to size that will overwrite. We cannot * extend the length of an I/O block in mid-chain. */ ncopy = avail; } else { unsigned int maxlen; unsigned int newlen; /* Yes.. We can extend this buffer to the up to the very end. */ maxlen = IOB_BUFSIZE(iob) - iob->io_offset; /* This is the new buffer length that we need. Of course, * clipped to the maximum possible size in this buffer. */ newlen = len + offset; if (newlen > maxlen) { newlen = maxlen; } /* Set the new length and increment the packet length */ head->io_pktlen += (newlen - iob->io_len); iob->io_len = newlen; /* Set the new number of bytes to copy */ ncopy = newlen - offset; } } else { /* Yes.. Copy all of the remaining bytes */ ncopy = len; } /* Copy from the user buffer to the I/O buffer. */ memcpy(dest, src, ncopy); iobinfo("iob=%p Copy %u bytes new len=%u\n", iob, ncopy, iob->io_len); /* Adjust the total length of the copy and the destination address in * the user buffer. */ len -= ncopy; src += ncopy; /* Skip to the next I/O buffer in the chain. First, check if we * are at the end of the buffer chain. */ if (len > 0 && !next) { /* Yes.. allocate a new buffer. * * Copy as many bytes as possible. Block if we're allowed. */ if (can_block) { next = iob_alloc(throttled); } else { next = iob_tryalloc(throttled); } if (next == NULL) { ioberr("ERROR: Failed to allocate I/O buffer\n"); return -ENOMEM; } /* Add the new, empty I/O buffer to the end of the buffer chain. */ iob->io_flink = next; iobinfo("iob=%p added to the chain\n", iob); } iob = next; offset = 0; } return total; } /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: iob_copyin * * Description: * Copy data 'len' bytes from a user buffer into the I/O buffer chain, * starting at 'offset', extending the chain as necessary. * ****************************************************************************/ int iob_copyin(FAR struct iob_s *iob, FAR const uint8_t *src, unsigned int len, int offset, bool throttled) { return iob_copyin_internal(iob, src, len, offset, throttled, true); } /**************************************************************************** * Name: iob_trycopyin * * Description: * Copy data 'len' bytes from a user buffer into the I/O buffer chain, * starting at 'offset', extending the chain as necessary BUT without * waiting if buffers are not available. * ****************************************************************************/ int iob_trycopyin(FAR struct iob_s *iob, FAR const uint8_t *src, unsigned int len, int offset, bool throttled) { return iob_copyin_internal(iob, src, len, offset, throttled, false); }