--- /dev/null
+/*
+ * This Cplant(TM) source code is the property of Sandia National
+ * Laboratories.
+ *
+ * This Cplant(TM) source code is copyrighted by Sandia National
+ * Laboratories.
+ *
+ * The redistribution of this Cplant(TM) source code is subject to the
+ * terms of the GNU Lesser General Public License
+ * (see cit/LGPL or http://www.gnu.org/licenses/lgpl.html)
+ *
+ * Cplant(TM) Copyright 1998-2004 Sandia Corporation.
+ * Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
+ * license for use of this work by or on behalf of the US Government.
+ * Export of this program may require a license from the United States
+ * Government.
+ */
+
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Questions or comments about this library should be sent to:
+ *
+ * Lee Ward
+ * Sandia National Laboratories, New Mexico
+ * P.O. Box 5800
+ * Albuquerque, NM 87185-1110
+ *
+ * lee@sandia.gov
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/uio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/queue.h>
+
+#include "sysio.h"
+#include "xtio.h"
+
+/*
+ * Extent-vector IO support.
+ */
+
+/*
+ * Arguments to IO vector enumerator callback when used by _sysio_doio().
+ */
+struct doio_helper_args {
+ ssize_t (*f)(void *, size_t, _SYSIO_OFF_T, void *); /* base func */
+ void *arg; /* caller arg */
+};
+
+/*
+ * General help validating strided-IO vectors.
+ *
+ * A driver may call this to make sure underflow/overflow of an off_t can't
+ * occur and overflow of a ssize_t can't occur when writing. The sum
+ * of the reconciled transfer length is returned or some appropriate
+ * error depending on underflow/overflow.
+ *
+ * The following algorithm assumes:
+ *
+ * a) sizeof(size_t) >= sizeof(ssize_t)
+ * b) 2's complement arithmetic
+ * c) The compiler won't optimize away code because it's developers
+ * believed that something with an undefined result in `C' can't happen.
+ */
+ssize_t
+_sysio_validx(const struct intnl_xtvec *xtv, size_t xtvlen,
+ const struct iovec *iov, size_t iovlen,
+ _SYSIO_OFF_T limit)
+{
+ ssize_t acc, cc;
+ struct iovec iovec;
+ struct intnl_xtvec xtvec;
+ _SYSIO_OFF_T off;
+
+ if (!(xtvlen && iovlen))
+ return -EINVAL;
+
+ acc = 0;
+ xtvec.xtv_len = iovec.iov_len = 0;
+ do {
+ while (!xtvec.xtv_len) {
+ if (!xtvlen--)
+ break;
+ if (!xtv->xtv_len) {
+ xtv++;
+ continue;
+ }
+ xtvec = *xtv++;
+ if (xtvec.xtv_off < 0)
+ return -EINVAL;
+ }
+ if (!xtvec.xtv_len)
+ break;
+ do {
+ while (!iovec.iov_len) {
+ if (!iovlen--)
+ break;
+ if (!iov->iov_len) {
+ iov++;
+ continue;
+ }
+ iovec = *iov++;
+ }
+ if (!iovec.iov_len)
+ break;
+ cc = iovec.iov_len;
+ if (cc < 0)
+ return -EINVAL;
+ if ((size_t )cc > xtvec.xtv_len)
+ cc = xtvec.xtv_len;
+ xtvec.xtv_len -= cc;
+ iovec.iov_len -= cc;
+ off = xtvec.xtv_off + cc;
+ if (xtvec.xtv_off && off <= xtvec.xtv_off)
+ return off < 0 ? -EINVAL : -EOVERFLOW;
+ if (off > limit)
+ return -EFBIG;
+ xtvec.xtv_off = off;
+ cc += acc;
+ if (acc && (cc <= acc))
+ return -EINVAL;
+ acc = cc;
+ } while (xtvec.xtv_len && iovlen);
+ } while ((xtvlen || xtvec.xtv_len) && iovlen);
+ return acc;
+}
+
+/*
+ */
+ssize_t
+_sysio_enumerate_extents(const struct intnl_xtvec *xtv, size_t xtvlen,
+ const struct iovec *iov, size_t iovlen,
+ ssize_t (*f)(const struct iovec *, int,
+ _SYSIO_OFF_T,
+ ssize_t,
+ void *),
+ void *arg)
+{
+ ssize_t acc, tmp, cc;
+ struct iovec iovec;
+ struct intnl_xtvec xtvec;
+ const struct iovec *start;
+ _SYSIO_OFF_T off;
+ size_t n;
+ size_t remain;
+
+ acc = 0;
+ iovec.iov_len = 0;
+ while (xtvlen) {
+ /*
+ * Coalesce contiguous extent vector entries.
+ */
+ off = xtvec.xtv_off = xtv->xtv_off;
+ off += xtvec.xtv_len = xtv->xtv_len;
+ while (++xtv, --xtvlen) {
+ if (off != xtv->xtv_off) {
+ /*
+ * Not contiguous.
+ */
+ break;
+ }
+ if (!xtv->xtv_len) {
+ /*
+ * Zero length.
+ */
+ continue;
+ }
+ off += xtv->xtv_len;
+ xtvec.xtv_len += xtv->xtv_len;
+ }
+ while (xtvec.xtv_len) {
+ if (iovec.iov_len) {
+ tmp = iovec.iov_len;
+ if (iovec.iov_len > xtvec.xtv_len)
+ iovec.iov_len = xtvec.xtv_len;
+ cc =
+ (*f)(&iovec, 1,
+ xtvec.xtv_off,
+ xtvec.xtv_len,
+ arg);
+ if (cc <= 0) {
+ if (acc)
+ return acc;
+ return cc;
+ }
+ iovec.iov_base = (char *)iovec.iov_base + cc;
+ iovec.iov_len = tmp - cc;
+ tmp = cc + acc;
+ if (acc && tmp <= acc)
+ abort(); /* paranoia */
+ acc = tmp;
+ } else if (iovlen) {
+ start = iov;
+ n = xtvec.xtv_len;
+ do {
+ if (iov->iov_len > n) {
+ /*
+ * That'll do.
+ */
+ break;
+ }
+ n -= iov->iov_len;
+ iov++;
+ } while (--iovlen);
+ if (iov == start) {
+ iovec = *iov++;
+ iovlen--;
+ continue;
+ }
+ remain = xtvec.xtv_len - n;
+ cc =
+ (*f)(start, iov - start,
+ xtvec.xtv_off,
+ remain,
+ arg);
+ if (cc <= 0) {
+ if (acc)
+ return acc;
+ return cc;
+ }
+
+ tmp = cc + acc;
+ if (acc && tmp <= acc)
+ abort(); /* paranoia */
+ acc = tmp;
+
+ remain -= cc;
+ if (remain)
+ return acc; /* short */
+ } else
+ return acc; /* short out */
+ xtvec.xtv_off += cc;
+ xtvec.xtv_len -= cc;
+ }
+ }
+ return acc;
+}
+
+ssize_t
+_sysio_enumerate_iovec(const struct iovec *iov, size_t count,
+ _SYSIO_OFF_T off,
+ ssize_t limit,
+ ssize_t (*f)(void *, size_t, _SYSIO_OFF_T, void *),
+ void *arg)
+{
+ ssize_t acc, cc;
+ size_t n;
+ unsigned indx;
+ size_t remain;
+
+ if (!count)
+ return -EINVAL;
+ assert(limit >= 0);
+ acc = 0;
+ n = limit;
+ for (indx = 0; n && indx < count; indx++) {
+ if (iov[indx].iov_len < n) {
+ cc = (ssize_t )iov[indx].iov_len;
+ if (cc < 0)
+ return -EINVAL;
+ } else
+ cc = (ssize_t )n;
+ if (!cc)
+ continue;
+ n -= cc;
+ cc += acc;
+ if (acc && cc <= acc)
+ return -EINVAL;
+ acc = cc;
+ }
+ if (!acc)
+ return 0;
+ acc = 0;
+ do {
+ if (!iov->iov_len) {
+ iov++;
+ continue;
+ }
+ n =
+ iov->iov_len < (size_t )limit
+ ? iov->iov_len
+ : (size_t )limit;
+ cc = (*f)(iov->iov_base, n, off, arg);
+ if (cc <= 0) {
+ if (acc)
+ return acc;
+ return cc;
+ }
+ off += cc;
+ limit -= cc;
+ remain = iov->iov_len - cc;
+ cc += acc;
+ if (acc && cc <= acc)
+ abort(); /* bad driver! */
+ acc = cc;
+ if (remain || !limit)
+ break; /* short/limited read */
+ iov++;
+ } while (--count);
+ return acc;
+}
+
+static ssize_t
+_sysio_doio_helper(const struct iovec *iov, int count,
+ _SYSIO_OFF_T off,
+ ssize_t limit,
+ struct doio_helper_args *args)
+{
+
+ return _sysio_enumerate_iovec(iov, count,
+ off, limit,
+ args->f,
+ args->arg);
+}
+
+/*
+ * A meta-driver for the whole strided-io process. Appropriate when
+ * the driver can't handle anything but simple p{read,write}-like
+ * interface.
+ */
+ssize_t
+_sysio_doio(const struct intnl_xtvec *xtv, size_t xtvlen,
+ const struct iovec *iov, size_t iovlen,
+ ssize_t (*f)(void *, size_t, _SYSIO_OFF_T, void *),
+ void *arg)
+{
+ struct doio_helper_args arguments;
+
+ arguments.f = f;
+ arguments.arg = arg;
+ return _sysio_enumerate_extents(xtv, xtvlen,
+ iov, iovlen,
+ (ssize_t (*)(const struct iovec *, int,
+ _SYSIO_OFF_T,
+ ssize_t,
+ void *))_sysio_doio_helper,
+ &arguments);
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff