lustre/utils/liblustreapi_mirror.c

   1 /*
   2  * LGPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * All rights reserved. This program and the accompanying materials
   7  * are made available under the terms of the GNU Lesser General Public License
   8  * (LGPL) version 2.1 or (at your discretion) any later version.
   9  * (LGPL) version 2.1 accompanies this distribution, and is available at
  10  * http://www.gnu.org/licenses/lgpl-2.1.html
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * LGPL HEADER END
  18  */
  19 /*
  20  * This file is part of Lustre, http://www.lustre.org/
  21  *
  22  * lustre/utils/liblustreapi_mirror.c
  23  *
  24  * Copyright (c) 2017, Intel Corporation.
  25  *
  26  * Author: Jinshan Xiong <jinshan.xiong@intel.com>
  27  */
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stddef.h>
  33 #include <sys/ioctl.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <errno.h>
  37 #include <dirent.h>
  38 #include <stdarg.h>
  39 #include <sys/stat.h>
  40 #include <sys/types.h>
  41 #include <sys/xattr.h>
  42 #include <assert.h>
  43 #include <sys/param.h>
  44
  45 #include <libcfs/util/ioctl.h>
  46 #include <lustre/lustreapi.h>
  47 #include <linux/lustre/lustre_ioctl.h>
  48
  49 /**
  50  * Set the mirror id for the opening file pointed by @fd, once the mirror
  51  * is set successfully, the policy to choose mirrors will be disabed and the
  52  * following I/O from this file descriptor will be led to this dedicated
  53  * mirror @id.
  54  * If @id is zero, it will clear the mirror id setting.
  55  *
  56  * \param fd    file descriptor, must be opened with O_DIRECT
  57  * \param id    mirror id
  58  *
  59  * \retval      0 on success.
  60  * \retval      -errno on failure.
  61  */
  62 int llapi_mirror_set(int fd, unsigned int id)
  63 {
  64         struct stat stbuf;
  65         int rc;
  66
  67         rc = ioctl(fd, LL_IOC_FLR_SET_MIRROR, id);
  68         if (rc < 0) {
  69                 rc = -errno;
  70                 return rc;
  71         }
  72
  73         if (!id)
  74                 return 0;
  75
  76         /* in the current implementation, llite doesn't verify if the mirror
  77          * id is valid, it has to be verified in an I/O context so the fstat()
  78          * call is to verify that the mirror id is correct. */
  79         rc = fstat(fd, &stbuf);
  80         if (rc < 0) {
  81                 rc = -errno;
  82
  83                 (void) ioctl(fd, LL_IOC_FLR_SET_MIRROR, 0);
  84         }
  85
  86         return rc;
  87 }
  88
  89 /**
  90  * Clear mirror id setting.
  91  *
  92  * \See llapi_mirror_set() for details.
  93  */
  94 int llapi_mirror_clear(int fd)
  95 {
  96         return llapi_mirror_set(fd, 0);
  97 }
  98
  99 /**
 100  * Read data from a specified mirror with @id. This function won't read
 101  * partial read result; either file end is reached, or number of @count bytes
 102  * is read, or an error will be returned.
 103  *
 104  * \param fd    file descriptor, should be opened with O_DIRECT
 105  * \param id    mirror id to be read from
 106  * \param buf   read buffer
 107  * \param count number of bytes to be read
 108  * \param pos   file postion where the read starts
 109  *
 110  * \result >= 0 Number of bytes has been read
 111  * \result < 0  The last seen error
 112  */
 113 ssize_t llapi_mirror_read(int fd, unsigned int id, void *buf, size_t count,
 114                           off_t pos)
 115 {
 116         size_t page_size = sysconf(_SC_PAGESIZE);
 117         ssize_t result = 0;
 118         int rc;
 119
 120         rc = llapi_mirror_set(fd, id);
 121         if (rc < 0)
 122                 return rc;
 123
 124         while (count > 0) {
 125                 ssize_t bytes_read;
 126
 127                 bytes_read = pread(fd, buf, count, pos);
 128                 if (!bytes_read) /* end of file */
 129                         break;
 130
 131                 if (bytes_read < 0) {
 132                         result = -errno;
 133                         break;
 134                 }
 135
 136                 result += bytes_read;
 137                 pos += bytes_read;
 138                 buf += bytes_read;
 139                 count -= bytes_read;
 140
 141                 if (bytes_read & (page_size - 1)) /* end of file */
 142                         break;
 143         }
 144
 145         (void) llapi_mirror_clear(fd);
 146
 147         return result;
 148 }
 149
 150 static ssize_t llapi_mirror_write(int fd, unsigned int id,
 151                                    const void *buf, size_t count, off_t pos)
 152 {
 153         size_t page_size = sysconf(_SC_PAGESIZE);
 154         ssize_t result = 0;
 155         int rc;
 156
 157         if (((unsigned long)buf & (page_size - 1)) || pos & (page_size - 1))
 158                 return -EINVAL;
 159
 160         rc = llapi_mirror_set(fd, id);
 161         if (rc < 0)
 162                 return rc;
 163
 164         while (count > 0) {
 165                 ssize_t bytes_written;
 166
 167                 if (pos & (page_size - 1)) {
 168                         result = -EINVAL;
 169                         break;
 170                 }
 171
 172                 bytes_written = pwrite(fd, buf, count, pos);
 173                 if (bytes_written < 0) {
 174                         result = -errno;
 175                         break;
 176                 }
 177
 178                 result += bytes_written;
 179                 pos += bytes_written;
 180                 buf += bytes_written;
 181                 count -= bytes_written;
 182         }
 183
 184         (void) llapi_mirror_clear(fd);
 185
 186         return result;
 187 }
 188
 189 static int llapi_mirror_truncate(int fd, unsigned int id, off_t length)
 190 {
 191         int rc;
 192
 193         rc = llapi_mirror_set(fd, id);
 194         if (rc < 0)
 195                 return rc;
 196
 197         rc = ftruncate(fd, length);
 198         if (rc < 0)
 199                 rc = -errno;
 200
 201         (void) llapi_mirror_clear(fd);
 202
 203         return rc;
 204 }
 205
 206 /**
 207  * Copy data contents from source mirror @src to multiple destinations
 208  * pointed by @dst. The destination array @dst will be altered to store
 209  * successfully copied mirrors.
 210  *
 211  * \param fd    file descriptor, should be opened with O_DIRECT
 212  * \param src   source mirror id, usually a valid mirror
 213  * \param dst   an array of destination mirror ids
 214  * \param count number of elements in array @dst
 215  *
 216  * \result > 0  Number of mirrors successfully copied
 217  * \result < 0  The last seen error
 218  */
 219 ssize_t llapi_mirror_copy_many(int fd, unsigned int src, unsigned int *dst,
 220                                 size_t count)
 221 {
 222         const size_t buflen = 4 * 1024 * 1024; /* 4M */
 223         void *buf;
 224         loff_t pos = 0;
 225         size_t page_size = sysconf(_SC_PAGESIZE);
 226         ssize_t result = 0;
 227         bool eof = false;
 228         int nr;
 229         int i;
 230         int rc;
 231
 232         if (!count)
 233                 return 0;
 234
 235         rc = posix_memalign(&buf, page_size, buflen);
 236         if (rc) /* error code is returned directly */
 237                 return -rc;
 238
 239         nr = count;
 240         while (!eof) {
 241                 ssize_t bytes_read;
 242                 size_t to_write;
 243
 244                 bytes_read = llapi_mirror_read(fd, src, buf, buflen, pos);
 245                 if (!bytes_read) { /* end of file */
 246                         break;
 247                 } else if (bytes_read < 0) {
 248                         result = bytes_read;
 249                         nr = 0;
 250                         break;
 251                 }
 252
 253                 /* round up to page align to make direct IO happy.
 254                  * this implies the last segment to write. */
 255                 to_write = (bytes_read + page_size - 1) & ~(page_size - 1);
 256
 257                 for (i = 0; i < nr; i++) {
 258                         ssize_t written;
 259
 260                         written = llapi_mirror_write(fd, dst[i], buf,
 261                                                       to_write, pos);
 262                         if (written < 0) {
 263                                 result = written;
 264
 265                                 /* this mirror is not written succesfully,
 266                                  * get rid of it from the array */
 267                                 dst[i] = dst[--nr];
 268                                 i--;
 269                                 continue;
 270                         }
 271
 272                         assert(written == to_write);
 273                 }
 274
 275                 pos += bytes_read;
 276                 eof = bytes_read < buflen;
 277         }
 278
 279         free(buf);
 280
 281         if (nr > 0) {
 282                 for (i = 0; i < nr; i++) {
 283                         rc = llapi_mirror_truncate(fd, dst[i], pos);
 284                         if (rc < 0) {
 285                                 result = rc;
 286
 287                                 /* exclude the failed one */
 288                                 dst[i] = dst[--nr];
 289                                 --i;
 290                                 continue;
 291                         }
 292                 }
 293         }
 294
 295         return nr > 0 ? nr : result;
 296 }
 297
 298 /**
 299  * Copy data contents from source mirror @src to target mirror @dst.
 300  *
 301  * \param fd    file descriptor, should be opened with O_DIRECT
 302  * \param src   source mirror id, usually a valid mirror
 303  * \param dst   mirror id of copy destination
 304  * \param pos   start file pos
 305  * \param count number of bytes to be copied
 306  *
 307  * \result > 0  Number of mirrors successfully copied
 308  * \result < 0  The last seen error
 309  */
 310 int llapi_mirror_copy(int fd, unsigned int src, unsigned int dst, off_t pos,
 311                       size_t count)
 312 {
 313         const size_t buflen = 4 * 1024 * 1024; /* 4M */
 314         void *buf;
 315         size_t page_size = sysconf(_SC_PAGESIZE);
 316         ssize_t result = 0;
 317         int rc;
 318
 319         if (!count)
 320                 return 0;
 321
 322         if (pos & (page_size - 1) || !dst)
 323                 return -EINVAL;
 324
 325         if (count != OBD_OBJECT_EOF && count & (page_size - 1))
 326                 return -EINVAL;
 327
 328         rc = posix_memalign(&buf, page_size, buflen);
 329         if (rc) /* error code is returned directly */
 330                 return -rc;
 331
 332         while (result < count) {
 333                 ssize_t bytes_read, bytes_written;
 334                 size_t to_read, to_write;
 335
 336                 to_read = MIN(buflen, count - result);
 337                 if (src == 0)
 338                         bytes_read = pread(fd, buf, to_read, pos);
 339                 else
 340                         bytes_read = llapi_mirror_read(fd, src, buf, to_read,
 341                                                         pos);
 342                 if (!bytes_read) { /* end of file */
 343                         break;
 344                 } else if (bytes_read < 0) {
 345                         result = bytes_read;
 346                         break;
 347                 }
 348
 349                 /* round up to page align to make direct IO happy.
 350                  * this implies the last segment to write. */
 351                 to_write = (bytes_read + page_size - 1) & ~(page_size - 1);
 352
 353                 bytes_written = llapi_mirror_write(fd, dst, buf, to_write,
 354                                                     pos);
 355                 if (bytes_written < 0) {
 356                         result = bytes_written;
 357                         break;
 358                 }
 359
 360                 assert(bytes_written == to_write);
 361
 362                 pos += bytes_read;
 363                 result += bytes_read;
 364
 365                 if (bytes_read < to_read) /* short read occurred */
 366                         break;
 367         }
 368
 369         free(buf);
 370
 371         if (result > 0 && pos & (page_size - 1)) {
 372                 rc = llapi_mirror_truncate(fd, dst, pos);
 373                 if (rc < 0)
 374                         result = rc;
 375         }
 376
 377         return result;
 378 }