lustre/lod/lod_object.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License version 2 for more details.  A copy is
  14  * included in the COPYING file that accompanied this code.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright  2009 Sun Microsystems, Inc. All rights reserved
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2012, 2017, Intel Corporation.
  27  */
  28 /*
  29  * lustre/lod/lod_object.c
  30  *
  31  * This file contains implementations of methods for the OSD API
  32  * for the Logical Object Device (LOD) layer, which provides a virtual
  33  * local OSD object interface to the MDD layer, and abstracts the
  34  * addressing of local (OSD) and remote (OSP) objects. The API is
  35  * described in the file lustre/include/dt_object.h and in
  36  * Documentation/osd-api.txt.
  37  *
  38  * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
  39  */
  40
  41 #define DEBUG_SUBSYSTEM S_MDS
  42
  43 #include <linux/random.h>
  44
  45 #include <obd.h>
  46 #include <obd_class.h>
  47 #include <obd_support.h>
  48
  49 #include <lustre_fid.h>
  50 #include <lustre_linkea.h>
  51 #include <lustre_lmv.h>
  52 #include <uapi/linux/lustre/lustre_param.h>
  53 #include <lustre_swab.h>
  54 #include <uapi/linux/lustre/lustre_ver.h>
  55 #include <lprocfs_status.h>
  56 #include <md_object.h>
  57
  58 #include "lod_internal.h"
  59
  60 static const char dot[] = ".";
  61 static const char dotdot[] = "..";
  62
  63 /**
  64  * Implementation of dt_index_operations::dio_lookup
  65  *
  66  * Used with regular (non-striped) objects.
  67  *
  68  * \see dt_index_operations::dio_lookup() in the API description for details.
  69  */
  70 static int lod_lookup(const struct lu_env *env, struct dt_object *dt,
  71                       struct dt_rec *rec, const struct dt_key *key)
  72 {
  73         struct dt_object *next = dt_object_child(dt);
  74         return next->do_index_ops->dio_lookup(env, next, rec, key);
  75 }
  76
  77 /**
  78  * Implementation of dt_index_operations::dio_declare_insert.
  79  *
  80  * Used with regular (non-striped) objects.
  81  *
  82  * \see dt_index_operations::dio_declare_insert() in the API description
  83  * for details.
  84  */
  85 static int lod_declare_insert(const struct lu_env *env, struct dt_object *dt,
  86                               const struct dt_rec *rec,
  87                               const struct dt_key *key, struct thandle *th)
  88 {
  89         return lod_sub_declare_insert(env, dt_object_child(dt), rec, key, th);
  90 }
  91
  92 /**
  93  * Implementation of dt_index_operations::dio_insert.
  94  *
  95  * Used with regular (non-striped) objects
  96  *
  97  * \see dt_index_operations::dio_insert() in the API description for details.
  98  */
  99 static int lod_insert(const struct lu_env *env, struct dt_object *dt,
 100                       const struct dt_rec *rec, const struct dt_key *key,
 101                       struct thandle *th)
 102 {
 103         return lod_sub_insert(env, dt_object_child(dt), rec, key, th);
 104 }
 105
 106 /**
 107  * Implementation of dt_index_operations::dio_declare_delete.
 108  *
 109  * Used with regular (non-striped) objects.
 110  *
 111  * \see dt_index_operations::dio_declare_delete() in the API description
 112  * for details.
 113  */
 114 static int lod_declare_delete(const struct lu_env *env, struct dt_object *dt,
 115                               const struct dt_key *key, struct thandle *th)
 116 {
 117         return lod_sub_declare_delete(env, dt_object_child(dt), key, th);
 118 }
 119
 120 /**
 121  * Implementation of dt_index_operations::dio_delete.
 122  *
 123  * Used with regular (non-striped) objects.
 124  *
 125  * \see dt_index_operations::dio_delete() in the API description for details.
 126  */
 127 static int lod_delete(const struct lu_env *env, struct dt_object *dt,
 128                       const struct dt_key *key, struct thandle *th)
 129 {
 130         return lod_sub_delete(env, dt_object_child(dt), key, th);
 131 }
 132
 133 /**
 134  * Implementation of dt_it_ops::init.
 135  *
 136  * Used with regular (non-striped) objects.
 137  *
 138  * \see dt_it_ops::init() in the API description for details.
 139  */
 140 static struct dt_it *lod_it_init(const struct lu_env *env,
 141                                  struct dt_object *dt, __u32 attr)
 142 {
 143         struct dt_object        *next = dt_object_child(dt);
 144         struct lod_it           *it = &lod_env_info(env)->lti_it;
 145         struct dt_it            *it_next;
 146
 147         it_next = next->do_index_ops->dio_it.init(env, next, attr);
 148         if (IS_ERR(it_next))
 149                 return it_next;
 150
 151         /* currently we do not use more than one iterator per thread
 152          * so we store it in thread info. if at some point we need
 153          * more active iterators in a single thread, we can allocate
 154          * additional ones */
 155         LASSERT(it->lit_obj == NULL);
 156
 157         it->lit_it = it_next;
 158         it->lit_obj = next;
 159
 160         return (struct dt_it *)it;
 161 }
 162
 163 #define LOD_CHECK_IT(env, it)                                   \
 164 do {                                                            \
 165         LASSERT((it)->lit_obj != NULL);                         \
 166         LASSERT((it)->lit_it != NULL);                          \
 167 } while (0)
 168
 169 /**
 170  * Implementation of dt_index_operations::dio_it.fini.
 171  *
 172  * Used with regular (non-striped) objects.
 173  *
 174  * \see dt_index_operations::dio_it.fini() in the API description for details.
 175  */
 176 static void lod_it_fini(const struct lu_env *env, struct dt_it *di)
 177 {
 178         struct lod_it *it = (struct lod_it *)di;
 179
 180         LOD_CHECK_IT(env, it);
 181         it->lit_obj->do_index_ops->dio_it.fini(env, it->lit_it);
 182
 183         /* the iterator not in use any more */
 184         it->lit_obj = NULL;
 185         it->lit_it = NULL;
 186 }
 187
 188 /**
 189  * Implementation of dt_it_ops::get.
 190  *
 191  * Used with regular (non-striped) objects.
 192  *
 193  * \see dt_it_ops::get() in the API description for details.
 194  */
 195 static int lod_it_get(const struct lu_env *env, struct dt_it *di,
 196                       const struct dt_key *key)
 197 {
 198         const struct lod_it *it = (const struct lod_it *)di;
 199
 200         LOD_CHECK_IT(env, it);
 201         return it->lit_obj->do_index_ops->dio_it.get(env, it->lit_it, key);
 202 }
 203
 204 /**
 205  * Implementation of dt_it_ops::put.
 206  *
 207  * Used with regular (non-striped) objects.
 208  *
 209  * \see dt_it_ops::put() in the API description for details.
 210  */
 211 static void lod_it_put(const struct lu_env *env, struct dt_it *di)
 212 {
 213         struct lod_it *it = (struct lod_it *)di;
 214
 215         LOD_CHECK_IT(env, it);
 216         return it->lit_obj->do_index_ops->dio_it.put(env, it->lit_it);
 217 }
 218
 219 /**
 220  * Implementation of dt_it_ops::next.
 221  *
 222  * Used with regular (non-striped) objects
 223  *
 224  * \see dt_it_ops::next() in the API description for details.
 225  */
 226 static int lod_it_next(const struct lu_env *env, struct dt_it *di)
 227 {
 228         struct lod_it *it = (struct lod_it *)di;
 229
 230         LOD_CHECK_IT(env, it);
 231         return it->lit_obj->do_index_ops->dio_it.next(env, it->lit_it);
 232 }
 233
 234 /**
 235  * Implementation of dt_it_ops::key.
 236  *
 237  * Used with regular (non-striped) objects.
 238  *
 239  * \see dt_it_ops::key() in the API description for details.
 240  */
 241 static struct dt_key *lod_it_key(const struct lu_env *env,
 242                                  const struct dt_it *di)
 243 {
 244         const struct lod_it *it = (const struct lod_it *)di;
 245
 246         LOD_CHECK_IT(env, it);
 247         return it->lit_obj->do_index_ops->dio_it.key(env, it->lit_it);
 248 }
 249
 250 /**
 251  * Implementation of dt_it_ops::key_size.
 252  *
 253  * Used with regular (non-striped) objects.
 254  *
 255  * \see dt_it_ops::key_size() in the API description for details.
 256  */
 257 static int lod_it_key_size(const struct lu_env *env, const struct dt_it *di)
 258 {
 259         struct lod_it *it = (struct lod_it *)di;
 260
 261         LOD_CHECK_IT(env, it);
 262         return it->lit_obj->do_index_ops->dio_it.key_size(env, it->lit_it);
 263 }
 264
 265 /**
 266  * Implementation of dt_it_ops::rec.
 267  *
 268  * Used with regular (non-striped) objects.
 269  *
 270  * \see dt_it_ops::rec() in the API description for details.
 271  */
 272 static int lod_it_rec(const struct lu_env *env, const struct dt_it *di,
 273                       struct dt_rec *rec, __u32 attr)
 274 {
 275         const struct lod_it *it = (const struct lod_it *)di;
 276
 277         LOD_CHECK_IT(env, it);
 278         return it->lit_obj->do_index_ops->dio_it.rec(env, it->lit_it, rec,
 279                                                      attr);
 280 }
 281
 282 /**
 283  * Implementation of dt_it_ops::rec_size.
 284  *
 285  * Used with regular (non-striped) objects.
 286  *
 287  * \see dt_it_ops::rec_size() in the API description for details.
 288  */
 289 static int lod_it_rec_size(const struct lu_env *env, const struct dt_it *di,
 290                            __u32 attr)
 291 {
 292         const struct lod_it *it = (const struct lod_it *)di;
 293
 294         LOD_CHECK_IT(env, it);
 295         return it->lit_obj->do_index_ops->dio_it.rec_size(env, it->lit_it,
 296                                                           attr);
 297 }
 298
 299 /**
 300  * Implementation of dt_it_ops::store.
 301  *
 302  * Used with regular (non-striped) objects.
 303  *
 304  * \see dt_it_ops::store() in the API description for details.
 305  */
 306 static __u64 lod_it_store(const struct lu_env *env, const struct dt_it *di)
 307 {
 308         const struct lod_it *it = (const struct lod_it *)di;
 309
 310         LOD_CHECK_IT(env, it);
 311         return it->lit_obj->do_index_ops->dio_it.store(env, it->lit_it);
 312 }
 313
 314 /**
 315  * Implementation of dt_it_ops::load.
 316  *
 317  * Used with regular (non-striped) objects.
 318  *
 319  * \see dt_it_ops::load() in the API description for details.
 320  */
 321 static int lod_it_load(const struct lu_env *env, const struct dt_it *di,
 322                        __u64 hash)
 323 {
 324         const struct lod_it *it = (const struct lod_it *)di;
 325
 326         LOD_CHECK_IT(env, it);
 327         return it->lit_obj->do_index_ops->dio_it.load(env, it->lit_it, hash);
 328 }
 329
 330 /**
 331  * Implementation of dt_it_ops::key_rec.
 332  *
 333  * Used with regular (non-striped) objects.
 334  *
 335  * \see dt_it_ops::rec() in the API description for details.
 336  */
 337 static int lod_it_key_rec(const struct lu_env *env, const struct dt_it *di,
 338                           void *key_rec)
 339 {
 340         const struct lod_it *it = (const struct lod_it *)di;
 341
 342         LOD_CHECK_IT(env, it);
 343         return it->lit_obj->do_index_ops->dio_it.key_rec(env, it->lit_it,
 344                                                          key_rec);
 345 }
 346
 347 static const struct dt_index_operations lod_index_ops = {
 348         .dio_lookup             = lod_lookup,
 349         .dio_declare_insert     = lod_declare_insert,
 350         .dio_insert             = lod_insert,
 351         .dio_declare_delete     = lod_declare_delete,
 352         .dio_delete             = lod_delete,
 353         .dio_it = {
 354                 .init           = lod_it_init,
 355                 .fini           = lod_it_fini,
 356                 .get            = lod_it_get,
 357                 .put            = lod_it_put,
 358                 .next           = lod_it_next,
 359                 .key            = lod_it_key,
 360                 .key_size       = lod_it_key_size,
 361                 .rec            = lod_it_rec,
 362                 .rec_size       = lod_it_rec_size,
 363                 .store          = lod_it_store,
 364                 .load           = lod_it_load,
 365                 .key_rec        = lod_it_key_rec,
 366         }
 367 };
 368
 369 /**
 370  * Implementation of dt_index_operations::dio_lookup
 371  *
 372  * Used with striped directories.
 373  *
 374  * \see dt_index_operations::dio_lookup() in the API description for details.
 375  */
 376 static int lod_striped_lookup(const struct lu_env *env, struct dt_object *dt,
 377                       struct dt_rec *rec, const struct dt_key *key)
 378 {
 379         struct lod_object *lo = lod_dt_obj(dt);
 380         struct dt_object *next;
 381         const char *name = (const char *)key;
 382
 383         LASSERT(lo->ldo_dir_stripe_count > 0);
 384
 385         if (strcmp(name, dot) == 0) {
 386                 struct lu_fid *fid = (struct lu_fid *)rec;
 387
 388                 *fid = *lod_object_fid(lo);
 389                 return 1;
 390         }
 391
 392         if (strcmp(name, dotdot) == 0) {
 393                 next = dt_object_child(dt);
 394         } else {
 395                 int index;
 396
 397                 index = __lmv_name_to_stripe_index(lo->ldo_dir_hash_type,
 398                                                    lo->ldo_dir_stripe_count,
 399                                                    lo->ldo_dir_migrate_hash,
 400                                                    lo->ldo_dir_migrate_offset,
 401                                                    name, strlen(name), true);
 402                 if (index < 0)
 403                         return index;
 404
 405                 next = lo->ldo_stripe[index];
 406                 if (!next || !dt_object_exists(next))
 407                         return -ENODEV;
 408         }
 409
 410         return next->do_index_ops->dio_lookup(env, next, rec, key);
 411 }
 412
 413 /**
 414  * Implementation of dt_it_ops::init.
 415  *
 416  * Used with striped objects. Internally just initializes the iterator
 417  * on the first stripe.
 418  *
 419  * \see dt_it_ops::init() in the API description for details.
 420  */
 421 static struct dt_it *lod_striped_it_init(const struct lu_env *env,
 422                                          struct dt_object *dt, __u32 attr)
 423 {
 424         struct lod_object *lo = lod_dt_obj(dt);
 425         struct dt_object *next;
 426         struct lod_it *it = &lod_env_info(env)->lti_it;
 427         struct dt_it *it_next;
 428         __u16 index = 0;
 429
 430         LASSERT(lo->ldo_dir_stripe_count > 0);
 431
 432         do {
 433                 next = lo->ldo_stripe[index];
 434                 if (next && dt_object_exists(next))
 435                         break;
 436         } while (++index < lo->ldo_dir_stripe_count);
 437
 438         /* no valid stripe */
 439         if (!next || !dt_object_exists(next))
 440                 return ERR_PTR(-ENODEV);
 441
 442         LASSERT(next->do_index_ops != NULL);
 443
 444         it_next = next->do_index_ops->dio_it.init(env, next, attr);
 445         if (IS_ERR(it_next))
 446                 return it_next;
 447
 448         /* currently we do not use more than one iterator per thread
 449          * so we store it in thread info. if at some point we need
 450          * more active iterators in a single thread, we can allocate
 451          * additional ones */
 452         LASSERT(it->lit_obj == NULL);
 453
 454         it->lit_stripe_index = index;
 455         it->lit_attr = attr;
 456         it->lit_it = it_next;
 457         it->lit_obj = dt;
 458
 459         return (struct dt_it *)it;
 460 }
 461
 462 #define LOD_CHECK_STRIPED_IT(env, it, lo)                               \
 463 do {                                                                    \
 464         LASSERT((it)->lit_obj != NULL);                                 \
 465         LASSERT((it)->lit_it != NULL);                                  \
 466         LASSERT((lo)->ldo_dir_stripe_count > 0);                        \
 467         LASSERT((it)->lit_stripe_index < (lo)->ldo_dir_stripe_count);   \
 468 } while (0)
 469
 470 /**
 471  * Implementation of dt_it_ops::fini.
 472  *
 473  * Used with striped objects.
 474  *
 475  * \see dt_it_ops::fini() in the API description for details.
 476  */
 477 static void lod_striped_it_fini(const struct lu_env *env, struct dt_it *di)
 478 {
 479         struct lod_it           *it = (struct lod_it *)di;
 480         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 481         struct dt_object        *next;
 482
 483         /* If lit_it == NULL, then it means the sub_it has been finished,
 484          * which only happens in failure cases, see lod_striped_it_next() */
 485         if (it->lit_it != NULL) {
 486                 LOD_CHECK_STRIPED_IT(env, it, lo);
 487
 488                 next = lo->ldo_stripe[it->lit_stripe_index];
 489                 if (next) {
 490                         LASSERT(next->do_index_ops != NULL);
 491                         next->do_index_ops->dio_it.fini(env, it->lit_it);
 492                 }
 493         }
 494
 495         /* the iterator not in use any more */
 496         it->lit_obj = NULL;
 497         it->lit_it = NULL;
 498         it->lit_stripe_index = 0;
 499 }
 500
 501 /**
 502  * Implementation of dt_it_ops::get.
 503  *
 504  * Right now it's not used widely, only to reset the iterator to the
 505  * initial position. It should be possible to implement a full version
 506  * which chooses a correct stripe to be able to position with any key.
 507  *
 508  * \see dt_it_ops::get() in the API description for details.
 509  */
 510 static int lod_striped_it_get(const struct lu_env *env, struct dt_it *di,
 511                               const struct dt_key *key)
 512 {
 513         const struct lod_it *it = (const struct lod_it *)di;
 514         struct lod_object *lo = lod_dt_obj(it->lit_obj);
 515         struct dt_object *next;
 516
 517         LOD_CHECK_STRIPED_IT(env, it, lo);
 518
 519         next = lo->ldo_stripe[it->lit_stripe_index];
 520         LASSERT(next != NULL);
 521         LASSERT(dt_object_exists(next));
 522         LASSERT(next->do_index_ops != NULL);
 523
 524         return next->do_index_ops->dio_it.get(env, it->lit_it, key);
 525 }
 526
 527 /**
 528  * Implementation of dt_it_ops::put.
 529  *
 530  * Used with striped objects.
 531  *
 532  * \see dt_it_ops::put() in the API description for details.
 533  */
 534 static void lod_striped_it_put(const struct lu_env *env, struct dt_it *di)
 535 {
 536         struct lod_it *it = (struct lod_it *)di;
 537         struct lod_object *lo = lod_dt_obj(it->lit_obj);
 538         struct dt_object *next;
 539
 540         /*
 541          * If lit_it == NULL, then it means the sub_it has been finished,
 542          * which only happens in failure cases, see lod_striped_it_next()
 543          */
 544         if (!it->lit_it)
 545                 return;
 546
 547         LOD_CHECK_STRIPED_IT(env, it, lo);
 548
 549         next = lo->ldo_stripe[it->lit_stripe_index];
 550         LASSERT(next != NULL);
 551         LASSERT(next->do_index_ops != NULL);
 552
 553         return next->do_index_ops->dio_it.put(env, it->lit_it);
 554 }
 555
 556 /**
 557  * Implementation of dt_it_ops::next.
 558  *
 559  * Used with striped objects. When the end of the current stripe is
 560  * reached, the method takes the next stripe's iterator.
 561  *
 562  * \see dt_it_ops::next() in the API description for details.
 563  */
 564 static int lod_striped_it_next(const struct lu_env *env, struct dt_it *di)
 565 {
 566         struct lod_it *it = (struct lod_it *)di;
 567         struct lod_object *lo = lod_dt_obj(it->lit_obj);
 568         struct dt_object *next;
 569         struct dt_it *it_next;
 570         __u32 index;
 571         int rc;
 572
 573         ENTRY;
 574
 575         LOD_CHECK_STRIPED_IT(env, it, lo);
 576
 577         next = lo->ldo_stripe[it->lit_stripe_index];
 578         LASSERT(next != NULL);
 579         LASSERT(dt_object_exists(next));
 580         LASSERT(next->do_index_ops != NULL);
 581 again:
 582         rc = next->do_index_ops->dio_it.next(env, it->lit_it);
 583         if (rc < 0)
 584                 RETURN(rc);
 585
 586         if (rc == 0 && it->lit_stripe_index == 0)
 587                 RETURN(rc);
 588
 589         if (rc == 0 && it->lit_stripe_index > 0) {
 590                 struct lu_dirent *ent;
 591
 592                 ent = (struct lu_dirent *)lod_env_info(env)->lti_key;
 593
 594                 rc = next->do_index_ops->dio_it.rec(env, it->lit_it,
 595                                                     (struct dt_rec *)ent,
 596                                                     it->lit_attr);
 597                 if (rc != 0)
 598                         RETURN(rc);
 599
 600                 /* skip . and .. for slave stripe */
 601                 if ((strncmp(ent->lde_name, ".",
 602                              le16_to_cpu(ent->lde_namelen)) == 0 &&
 603                      le16_to_cpu(ent->lde_namelen) == 1) ||
 604                     (strncmp(ent->lde_name, "..",
 605                              le16_to_cpu(ent->lde_namelen)) == 0 &&
 606                      le16_to_cpu(ent->lde_namelen) == 2))
 607                         goto again;
 608
 609                 RETURN(rc);
 610         }
 611
 612         next->do_index_ops->dio_it.put(env, it->lit_it);
 613         next->do_index_ops->dio_it.fini(env, it->lit_it);
 614         it->lit_it = NULL;
 615
 616         /* go to next stripe */
 617         index = it->lit_stripe_index;
 618         while (++index < lo->ldo_dir_stripe_count) {
 619                 next = lo->ldo_stripe[index];
 620                 if (!next)
 621                         continue;
 622
 623                 if (!dt_object_exists(next))
 624                         continue;
 625
 626                 rc = next->do_ops->do_index_try(env, next,
 627                                                 &dt_directory_features);
 628                 if (rc != 0)
 629                         RETURN(rc);
 630
 631                 LASSERT(next->do_index_ops != NULL);
 632
 633                 it_next = next->do_index_ops->dio_it.init(env, next,
 634                                                           it->lit_attr);
 635                 if (IS_ERR(it_next))
 636                         RETURN(PTR_ERR(it_next));
 637
 638                 rc = next->do_index_ops->dio_it.get(env, it_next,
 639                                                     (const struct dt_key *)"");
 640                 if (rc <= 0)
 641                         RETURN(rc == 0 ? -EIO : rc);
 642
 643                 it->lit_it = it_next;
 644                 it->lit_stripe_index = index;
 645                 goto again;
 646
 647         }
 648
 649         RETURN(1);
 650 }
 651
 652 /**
 653  * Implementation of dt_it_ops::key.
 654  *
 655  * Used with striped objects.
 656  *
 657  * \see dt_it_ops::key() in the API description for details.
 658  */
 659 static struct dt_key *lod_striped_it_key(const struct lu_env *env,
 660                                          const struct dt_it *di)
 661 {
 662         const struct lod_it     *it = (const struct lod_it *)di;
 663         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 664         struct dt_object        *next;
 665
 666         LOD_CHECK_STRIPED_IT(env, it, lo);
 667
 668         next = lo->ldo_stripe[it->lit_stripe_index];
 669         LASSERT(next != NULL);
 670         LASSERT(next->do_index_ops != NULL);
 671
 672         return next->do_index_ops->dio_it.key(env, it->lit_it);
 673 }
 674
 675 /**
 676  * Implementation of dt_it_ops::key_size.
 677  *
 678  * Used with striped objects.
 679  *
 680  * \see dt_it_ops::size() in the API description for details.
 681  */
 682 static int lod_striped_it_key_size(const struct lu_env *env,
 683                                    const struct dt_it *di)
 684 {
 685         struct lod_it           *it = (struct lod_it *)di;
 686         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 687         struct dt_object        *next;
 688
 689         LOD_CHECK_STRIPED_IT(env, it, lo);
 690
 691         next = lo->ldo_stripe[it->lit_stripe_index];
 692         LASSERT(next != NULL);
 693         LASSERT(next->do_index_ops != NULL);
 694
 695         return next->do_index_ops->dio_it.key_size(env, it->lit_it);
 696 }
 697
 698 /**
 699  * Implementation of dt_it_ops::rec.
 700  *
 701  * Used with striped objects.
 702  *
 703  * \see dt_it_ops::rec() in the API description for details.
 704  */
 705 static int lod_striped_it_rec(const struct lu_env *env, const struct dt_it *di,
 706                               struct dt_rec *rec, __u32 attr)
 707 {
 708         const struct lod_it     *it = (const struct lod_it *)di;
 709         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 710         struct dt_object        *next;
 711
 712         LOD_CHECK_STRIPED_IT(env, it, lo);
 713
 714         next = lo->ldo_stripe[it->lit_stripe_index];
 715         LASSERT(next != NULL);
 716         LASSERT(next->do_index_ops != NULL);
 717
 718         return next->do_index_ops->dio_it.rec(env, it->lit_it, rec, attr);
 719 }
 720
 721 /**
 722  * Implementation of dt_it_ops::rec_size.
 723  *
 724  * Used with striped objects.
 725  *
 726  * \see dt_it_ops::rec_size() in the API description for details.
 727  */
 728 static int lod_striped_it_rec_size(const struct lu_env *env,
 729                                    const struct dt_it *di, __u32 attr)
 730 {
 731         struct lod_it           *it = (struct lod_it *)di;
 732         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 733         struct dt_object        *next;
 734
 735         LOD_CHECK_STRIPED_IT(env, it, lo);
 736
 737         next = lo->ldo_stripe[it->lit_stripe_index];
 738         LASSERT(next != NULL);
 739         LASSERT(next->do_index_ops != NULL);
 740
 741         return next->do_index_ops->dio_it.rec_size(env, it->lit_it, attr);
 742 }
 743
 744 /**
 745  * Implementation of dt_it_ops::store.
 746  *
 747  * Used with striped objects.
 748  *
 749  * \see dt_it_ops::store() in the API description for details.
 750  */
 751 static __u64 lod_striped_it_store(const struct lu_env *env,
 752                                   const struct dt_it *di)
 753 {
 754         const struct lod_it     *it = (const struct lod_it *)di;
 755         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 756         struct dt_object        *next;
 757
 758         LOD_CHECK_STRIPED_IT(env, it, lo);
 759
 760         next = lo->ldo_stripe[it->lit_stripe_index];
 761         LASSERT(next != NULL);
 762         LASSERT(next->do_index_ops != NULL);
 763
 764         return next->do_index_ops->dio_it.store(env, it->lit_it);
 765 }
 766
 767 /**
 768  * Implementation of dt_it_ops::load.
 769  *
 770  * Used with striped objects.
 771  *
 772  * \see dt_it_ops::load() in the API description for details.
 773  */
 774 static int lod_striped_it_load(const struct lu_env *env,
 775                                const struct dt_it *di, __u64 hash)
 776 {
 777         const struct lod_it     *it = (const struct lod_it *)di;
 778         struct lod_object       *lo = lod_dt_obj(it->lit_obj);
 779         struct dt_object        *next;
 780
 781         LOD_CHECK_STRIPED_IT(env, it, lo);
 782
 783         next = lo->ldo_stripe[it->lit_stripe_index];
 784         LASSERT(next != NULL);
 785         LASSERT(next->do_index_ops != NULL);
 786
 787         return next->do_index_ops->dio_it.load(env, it->lit_it, hash);
 788 }
 789
 790 static const struct dt_index_operations lod_striped_index_ops = {
 791         .dio_lookup             = lod_striped_lookup,
 792         .dio_declare_insert     = lod_declare_insert,
 793         .dio_insert             = lod_insert,
 794         .dio_declare_delete     = lod_declare_delete,
 795         .dio_delete             = lod_delete,
 796         .dio_it = {
 797                 .init           = lod_striped_it_init,
 798                 .fini           = lod_striped_it_fini,
 799                 .get            = lod_striped_it_get,
 800                 .put            = lod_striped_it_put,
 801                 .next           = lod_striped_it_next,
 802                 .key            = lod_striped_it_key,
 803                 .key_size       = lod_striped_it_key_size,
 804                 .rec            = lod_striped_it_rec,
 805                 .rec_size       = lod_striped_it_rec_size,
 806                 .store          = lod_striped_it_store,
 807                 .load           = lod_striped_it_load,
 808         }
 809 };
 810
 811 /**
 812  * Append the FID for each shard of the striped directory after the
 813  * given LMV EA header.
 814  *
 815  * To simplify striped directory and the consistency verification,
 816  * we only store the LMV EA header on disk, for both master object
 817  * and slave objects. When someone wants to know the whole LMV EA,
 818  * such as client readdir(), we can build the entrie LMV EA on the
 819  * MDT side (in RAM) via iterating the sub-directory entries that
 820  * are contained in the master object of the stripe directory.
 821  *
 822  * For the master object of the striped directroy, the valid name
 823  * for each shard is composed of the ${shard_FID}:${shard_idx}.
 824  *
 825  * There may be holes in the LMV EA if some shards' name entries
 826  * are corrupted or lost.
 827  *
 828  * \param[in] env       pointer to the thread context
 829  * \param[in] lo        pointer to the master object of the striped directory
 830  * \param[in] buf       pointer to the lu_buf which will hold the LMV EA
 831  * \param[in] resize    whether re-allocate the buffer if it is not big enough
 832  *
 833  * \retval              positive size of the LMV EA
 834  * \retval              0 for nothing to be loaded
 835  * \retval              negative error number on failure
 836  */
 837 int lod_load_lmv_shards(const struct lu_env *env, struct lod_object *lo,
 838                         struct lu_buf *buf, bool resize)
 839 {
 840         struct lu_dirent        *ent    =
 841                         (struct lu_dirent *)lod_env_info(env)->lti_key;
 842         struct lod_device       *lod    = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
 843         struct dt_object        *obj    = dt_object_child(&lo->ldo_obj);
 844         struct lmv_mds_md_v1    *lmv1   = buf->lb_buf;
 845         struct dt_it            *it;
 846         const struct dt_it_ops  *iops;
 847         __u32                    stripes;
 848         __u32                    magic  = le32_to_cpu(lmv1->lmv_magic);
 849         size_t                   lmv1_size;
 850         int                      rc;
 851         ENTRY;
 852
 853         if (magic != LMV_MAGIC_V1)
 854                 RETURN(0);
 855
 856         stripes = le32_to_cpu(lmv1->lmv_stripe_count);
 857         if (stripes < 1)
 858                 RETURN(0);
 859
 860         rc = lmv_mds_md_size(stripes, magic);
 861         if (rc < 0)
 862                 RETURN(rc);
 863         lmv1_size = rc;
 864         if (buf->lb_len < lmv1_size) {
 865                 struct lu_buf tbuf;
 866
 867                 if (!resize)
 868                         RETURN(-ERANGE);
 869
 870                 tbuf = *buf;
 871                 buf->lb_buf = NULL;
 872                 buf->lb_len = 0;
 873                 lu_buf_alloc(buf, lmv1_size);
 874                 lmv1 = buf->lb_buf;
 875                 if (lmv1 == NULL)
 876                         RETURN(-ENOMEM);
 877
 878                 memcpy(buf->lb_buf, tbuf.lb_buf, tbuf.lb_len);
 879         }
 880
 881         if (unlikely(!dt_try_as_dir(env, obj, true)))
 882                 RETURN(-ENOTDIR);
 883
 884         memset(&lmv1->lmv_stripe_fids[0], 0, stripes * sizeof(struct lu_fid));
 885         iops = &obj->do_index_ops->dio_it;
 886         it = iops->init(env, obj, LUDA_64BITHASH);
 887         if (IS_ERR(it))
 888                 RETURN(PTR_ERR(it));
 889
 890         rc = iops->load(env, it, 0);
 891         if (rc == 0)
 892                 rc = iops->next(env, it);
 893         else if (rc > 0)
 894                 rc = 0;
 895
 896         while (rc == 0) {
 897                 char             name[FID_LEN + 2] = "";
 898                 struct lu_fid    fid;
 899                 __u32            index;
 900                 int              len;
 901
 902                 rc = iops->rec(env, it, (struct dt_rec *)ent, LUDA_64BITHASH);
 903                 if (rc != 0)
 904                         break;
 905
 906                 rc = -EIO;
 907
 908                 fid_le_to_cpu(&fid, &ent->lde_fid);
 909                 ent->lde_namelen = le16_to_cpu(ent->lde_namelen);
 910                 if (ent->lde_name[0] == '.') {
 911                         if (ent->lde_namelen == 1)
 912                                 goto next;
 913
 914                         if (ent->lde_namelen == 2 && ent->lde_name[1] == '.')
 915                                 goto next;
 916                 }
 917
 918                 len = scnprintf(name, sizeof(name),
 919                                 DFID":", PFID(&ent->lde_fid));
 920                 /* The ent->lde_name is composed of ${FID}:${index} */
 921                 if (ent->lde_namelen < len + 1 ||
 922                     memcmp(ent->lde_name, name, len) != 0) {
 923                         CDEBUG_LIMIT(lod->lod_lmv_failout ? D_ERROR : D_INFO,
 924                                      "%s: invalid shard name %.*s with the FID "DFID" for the striped directory "DFID", %s\n",
 925                                      lod2obd(lod)->obd_name, ent->lde_namelen,
 926                                      ent->lde_name, PFID(&fid),
 927                                      PFID(lu_object_fid(&obj->do_lu)),
 928                                      lod->lod_lmv_failout ? "failout" : "skip");
 929
 930                         if (lod->lod_lmv_failout)
 931                                 break;
 932
 933                         goto next;
 934                 }
 935
 936                 index = 0;
 937                 do {
 938                         if (ent->lde_name[len] < '0' ||
 939                             ent->lde_name[len] > '9') {
 940                                 CDEBUG_LIMIT(lod->lod_lmv_failout ?
 941                                              D_ERROR : D_INFO,
 942                                              "%s: invalid shard name %.*s with the FID "DFID" for the striped directory "DFID", %s\n",
 943                                              lod2obd(lod)->obd_name,
 944                                              ent->lde_namelen,
 945                                              ent->lde_name, PFID(&fid),
 946                                              PFID(lu_object_fid(&obj->do_lu)),
 947                                              lod->lod_lmv_failout ?
 948                                              "failout" : "skip");
 949
 950                                 if (lod->lod_lmv_failout)
 951                                         break;
 952
 953                                 goto next;
 954                         }
 955
 956                         index = index * 10 + ent->lde_name[len++] - '0';
 957                 } while (len < ent->lde_namelen);
 958
 959                 if (len == ent->lde_namelen) {
 960                         /* Out of LMV EA range. */
 961                         if (index >= stripes) {
 962                                 CERROR("%s: the shard %.*s for the striped "
 963                                        "directory "DFID" is out of the known "
 964                                        "LMV EA range [0 - %u], failout\n",
 965                                        lod2obd(lod)->obd_name, ent->lde_namelen,
 966                                        ent->lde_name,
 967                                        PFID(lu_object_fid(&obj->do_lu)),
 968                                        stripes - 1);
 969
 970                                 break;
 971                         }
 972
 973                         /* The slot has been occupied. */
 974                         if (!fid_is_zero(&lmv1->lmv_stripe_fids[index])) {
 975                                 struct lu_fid fid0;
 976
 977                                 fid_le_to_cpu(&fid0,
 978                                         &lmv1->lmv_stripe_fids[index]);
 979                                 CERROR("%s: both the shard "DFID" and "DFID
 980                                        " for the striped directory "DFID
 981                                        " claim the same LMV EA slot at the "
 982                                        "index %d, failout\n",
 983                                        lod2obd(lod)->obd_name,
 984                                        PFID(&fid0), PFID(&fid),
 985                                        PFID(lu_object_fid(&obj->do_lu)), index);
 986
 987                                 break;
 988                         }
 989
 990                         /* stored as LE mode */
 991                         lmv1->lmv_stripe_fids[index] = ent->lde_fid;
 992
 993 next:
 994                         rc = iops->next(env, it);
 995                 }
 996         }
 997
 998         iops->put(env, it);
 999         iops->fini(env, it);
1000
1001         RETURN(rc > 0 ? lmv_mds_md_size(stripes, magic) : rc);
1002 }
1003
1004 /**
1005  * Implementation of dt_object_operations::do_index_try.
1006  *
1007  * \see dt_object_operations::do_index_try() in the API description for details.
1008  */
1009 static int lod_index_try(const struct lu_env *env, struct dt_object *dt,
1010                          const struct dt_index_features *feat)
1011 {
1012         struct lod_object       *lo = lod_dt_obj(dt);
1013         struct dt_object        *next = dt_object_child(dt);
1014         int                     rc;
1015         ENTRY;
1016
1017         LASSERT(next->do_ops);
1018         LASSERT(next->do_ops->do_index_try);
1019
1020         rc = lod_striping_load(env, lo);
1021         if (rc != 0)
1022                 RETURN(rc);
1023
1024         rc = next->do_ops->do_index_try(env, next, feat);
1025         if (rc != 0)
1026                 RETURN(rc);
1027
1028         if (lo->ldo_dir_stripe_count > 0) {
1029                 int i;
1030
1031                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
1032                         if (!lo->ldo_stripe[i])
1033                                 continue;
1034                         if (!dt_object_exists(lo->ldo_stripe[i]))
1035                                 continue;
1036                         rc = lo->ldo_stripe[i]->do_ops->do_index_try(env,
1037                                                 lo->ldo_stripe[i], feat);
1038                         if (rc != 0)
1039                                 RETURN(rc);
1040                 }
1041                 dt->do_index_ops = &lod_striped_index_ops;
1042         } else {
1043                 dt->do_index_ops = &lod_index_ops;
1044         }
1045
1046         RETURN(rc);
1047 }
1048
1049 /**
1050  * Implementation of dt_object_operations::do_read_lock.
1051  *
1052  * \see dt_object_operations::do_read_lock() in the API description for details.
1053  */
1054 static void lod_read_lock(const struct lu_env *env, struct dt_object *dt,
1055                           unsigned role)
1056 {
1057         dt_read_lock(env, dt_object_child(dt), role);
1058 }
1059
1060 /**
1061  * Implementation of dt_object_operations::do_write_lock.
1062  *
1063  * \see dt_object_operations::do_write_lock() in the API description for
1064  * details.
1065  */
1066 static void lod_write_lock(const struct lu_env *env, struct dt_object *dt,
1067                            unsigned role)
1068 {
1069         dt_write_lock(env, dt_object_child(dt), role);
1070 }
1071
1072 /**
1073  * Implementation of dt_object_operations::do_read_unlock.
1074  *
1075  * \see dt_object_operations::do_read_unlock() in the API description for
1076  * details.
1077  */
1078 static void lod_read_unlock(const struct lu_env *env, struct dt_object *dt)
1079 {
1080         dt_read_unlock(env, dt_object_child(dt));
1081 }
1082
1083 /**
1084  * Implementation of dt_object_operations::do_write_unlock.
1085  *
1086  * \see dt_object_operations::do_write_unlock() in the API description for
1087  * details.
1088  */
1089 static void lod_write_unlock(const struct lu_env *env, struct dt_object *dt)
1090 {
1091         dt_write_unlock(env, dt_object_child(dt));
1092 }
1093
1094 /**
1095  * Implementation of dt_object_operations::do_write_locked.
1096  *
1097  * \see dt_object_operations::do_write_locked() in the API description for
1098  * details.
1099  */
1100 static int lod_write_locked(const struct lu_env *env, struct dt_object *dt)
1101 {
1102         return dt_write_locked(env, dt_object_child(dt));
1103 }
1104
1105 /**
1106  * Implementation of dt_object_operations::do_attr_get.
1107  *
1108  * \see dt_object_operations::do_attr_get() in the API description for details.
1109  */
1110 static int lod_attr_get(const struct lu_env *env,
1111                         struct dt_object *dt,
1112                         struct lu_attr *attr)
1113 {
1114         /* Note: for striped directory, client will merge attributes
1115          * from all of the sub-stripes see lmv_merge_attr(), and there
1116          * no MDD logic depend on directory nlink/size/time, so we can
1117          * always use master inode nlink and size for now. */
1118         return dt_attr_get(env, dt_object_child(dt), attr);
1119 }
1120
1121 void lod_adjust_stripe_size(struct lod_layout_component *comp,
1122                             __u32 def_stripe_size)
1123 {
1124         __u64 comp_end = comp->llc_extent.e_end;
1125
1126         /* Choose stripe size if not set. Note that default stripe size can't
1127          * be used as is, because it must be multiplier of given component end.
1128          *  - first check if default stripe size can be used
1129          *  - if not than select the lowest set bit from component end and use
1130          *    that value as stripe size
1131          */
1132         if (!comp->llc_stripe_size) {
1133                 if (comp_end == LUSTRE_EOF || !(comp_end % def_stripe_size))
1134                         comp->llc_stripe_size = def_stripe_size;
1135                 else
1136                         comp->llc_stripe_size = comp_end & ~(comp_end - 1);
1137         } else {
1138                 if (comp_end != LUSTRE_EOF &&
1139                     comp_end & (LOV_MIN_STRIPE_SIZE - 1)) {
1140                         CWARN("Component end %llu is not a multiple of min size %u\n",
1141                               comp_end, LOV_MIN_STRIPE_SIZE);
1142                         comp_end = round_up(comp_end, LOV_MIN_STRIPE_SIZE);
1143                 }
1144                 /* check stripe size is multiplier of comp_end */
1145                 if (comp_end != LUSTRE_EOF &&
1146                     comp_end != comp->llc_extent.e_start &&
1147                     comp_end % comp->llc_stripe_size) {
1148                         /* fix that even for defined stripe size but warn
1149                          * about the problem, that must not happen
1150                          */
1151                         CWARN("Component end %llu is not aligned by the stripe size %u\n",
1152                               comp_end, comp->llc_stripe_size);
1153                         comp->llc_stripe_size = comp_end & ~(comp_end - 1);
1154                 }
1155         }
1156 }
1157
1158 static inline void lod_adjust_stripe_info(struct lod_layout_component *comp,
1159                                           struct lov_desc *desc,
1160                                           int append_stripes)
1161 {
1162         if (comp->llc_pattern != LOV_PATTERN_MDT) {
1163                 if (append_stripes) {
1164                         comp->llc_stripe_count = append_stripes;
1165                 } else if (!comp->llc_stripe_count) {
1166                         comp->llc_stripe_count =
1167                                 desc->ld_default_stripe_count;
1168                 }
1169         }
1170
1171         lod_adjust_stripe_size(comp, desc->ld_default_stripe_size);
1172 }
1173
1174 int lod_obj_for_each_stripe(const struct lu_env *env, struct lod_object *lo,
1175                             struct thandle *th,
1176                             struct lod_obj_stripe_cb_data *data)
1177 {
1178         struct lod_layout_component *lod_comp;
1179         int i, j, rc = 0;
1180         ENTRY;
1181
1182         mutex_lock(&lo->ldo_layout_mutex);
1183         for (i = 0; i < lo->ldo_comp_cnt; i++) {
1184                 lod_comp = &lo->ldo_comp_entries[i];
1185
1186                 if (lod_comp->llc_stripe == NULL)
1187                         continue;
1188
1189                 /* has stripe but not inited yet, this component has been
1190                  * declared to be created, but hasn't created yet.
1191                  */
1192                 if (!lod_comp_inited(lod_comp))
1193                         continue;
1194
1195                 if (data->locd_comp_skip_cb &&
1196                     data->locd_comp_skip_cb(env, lo, i, data))
1197                         continue;
1198
1199                 if (data->locd_comp_cb) {
1200                         rc = data->locd_comp_cb(env, lo, i, data);
1201                         if (rc)
1202                                 GOTO(unlock, rc);
1203                 }
1204
1205                 /* could used just to do sth about component, not each
1206                  * stripes
1207                  */
1208                 if (!data->locd_stripe_cb)
1209                         continue;
1210
1211                 LASSERT(lod_comp->llc_stripe_count > 0);
1212                 for (j = 0; j < lod_comp->llc_stripe_count; j++) {
1213                         struct dt_object *dt = lod_comp->llc_stripe[j];
1214
1215                         if (dt == NULL)
1216                                 continue;
1217                         rc = data->locd_stripe_cb(env, lo, dt, th, i, j, data);
1218                         if (rc != 0)
1219                                 GOTO(unlock, rc);
1220                 }
1221         }
1222 unlock:
1223         mutex_unlock(&lo->ldo_layout_mutex);
1224         RETURN(rc);
1225 }
1226
1227 static inline int
1228 lod_obj_stripe_attr_set_cb(const struct lu_env *env, struct lod_object *lo,
1229                            struct dt_object *dt, struct thandle *th,
1230                            int comp_idx, int stripe_idx,
1231                            struct lod_obj_stripe_cb_data *data)
1232 {
1233         if (data->locd_declare)
1234                 return lod_sub_declare_attr_set(env, dt, data->locd_attr, th);
1235
1236         if (data->locd_attr->la_valid & LA_LAYOUT_VERSION) {
1237                 CDEBUG(D_LAYOUT, DFID": set layout version: %u, comp_idx: %d\n",
1238                        PFID(lu_object_fid(&dt->do_lu)),
1239                        data->locd_attr->la_layout_version, comp_idx);
1240         }
1241
1242         return lod_sub_attr_set(env, dt, data->locd_attr, th);
1243 }
1244
1245 /**
1246  * Implementation of dt_object_operations::do_declare_attr_set.
1247  *
1248  * If the object is striped, then apply the changes to all the stripes.
1249  *
1250  * \see dt_object_operations::do_declare_attr_set() in the API description
1251  * for details.
1252  */
1253 static int lod_declare_attr_set(const struct lu_env *env,
1254                                 struct dt_object *dt,
1255                                 const struct lu_attr *attr,
1256                                 struct thandle *th)
1257 {
1258         struct dt_object  *next = dt_object_child(dt);
1259         struct lod_object *lo = lod_dt_obj(dt);
1260         int                rc, i;
1261         ENTRY;
1262
1263         /*
1264          * declare setattr on the local object
1265          */
1266         rc = lod_sub_declare_attr_set(env, next, attr, th);
1267         if (rc)
1268                 RETURN(rc);
1269
1270         /* osp_declare_attr_set() ignores all attributes other than
1271          * UID, GID, PROJID, and size, and osp_attr_set() ignores all
1272          * but UID, GID and PROJID. Declaration of size attr setting
1273          * happens through lod_declare_init_size(), and not through
1274          * this function. Therefore we need not load striping unless
1275          * ownership is changing.  This should save memory and (we hope)
1276          * speed up rename().
1277          */
1278         if (!S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
1279                 if (!(attr->la_valid & LA_REMOTE_ATTR_SET))
1280                         RETURN(rc);
1281
1282                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_OWNER))
1283                         RETURN(0);
1284         } else {
1285                 if (!(attr->la_valid & (LA_UID | LA_GID | LA_PROJID | LA_MODE |
1286                                         LA_ATIME | LA_MTIME | LA_CTIME |
1287                                         LA_FLAGS)))
1288                         RETURN(rc);
1289         }
1290         /*
1291          * load striping information, notice we don't do this when object
1292          * is being initialized as we don't need this information till
1293          * few specific cases like destroy, chown
1294          */
1295         rc = lod_striping_load(env, lo);
1296         if (rc)
1297                 RETURN(rc);
1298
1299         if (!lod_obj_is_striped(dt))
1300                 RETURN(0);
1301
1302         /*
1303          * if object is striped declare changes on the stripes
1304          */
1305         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
1306                 LASSERT(lo->ldo_stripe);
1307                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
1308                         if (lo->ldo_stripe[i] == NULL)
1309                                 continue;
1310                         if (!dt_object_exists(lo->ldo_stripe[i]))
1311                                 continue;
1312                         rc = lod_sub_declare_attr_set(env, lo->ldo_stripe[i],
1313                                                       attr, th);
1314                         if (rc != 0)
1315                                 RETURN(rc);
1316                 }
1317         } else {
1318                 struct lod_obj_stripe_cb_data data = { { 0 } };
1319
1320                 data.locd_attr = attr;
1321                 data.locd_declare = true;
1322                 data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
1323                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
1324         }
1325
1326         if (rc)
1327                 RETURN(rc);
1328
1329         if (!dt_object_exists(next) || dt_object_remote(next) ||
1330             !S_ISREG(attr->la_mode))
1331                 RETURN(0);
1332
1333         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_STRIPE)) {
1334                 rc = lod_sub_declare_xattr_del(env, next, XATTR_NAME_LOV, th);
1335                 RETURN(rc);
1336         }
1337
1338         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CHANGE_STRIPE) ||
1339             OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_PFL_RANGE)) {
1340                 struct lod_thread_info *info = lod_env_info(env);
1341                 struct lu_buf *buf = &info->lti_buf;
1342
1343                 buf->lb_buf = info->lti_ea_store;
1344                 buf->lb_len = info->lti_ea_store_size;
1345                 rc = lod_sub_declare_xattr_set(env, next, buf, XATTR_NAME_LOV,
1346                                                LU_XATTR_REPLACE, th);
1347         }
1348
1349         RETURN(rc);
1350 }
1351
1352 /**
1353  * Implementation of dt_object_operations::do_attr_set.
1354  *
1355  * If the object is striped, then apply the changes to all or subset of
1356  * the stripes depending on the object type and specific attributes.
1357  *
1358  * \see dt_object_operations::do_attr_set() in the API description for details.
1359  */
1360 static int lod_attr_set(const struct lu_env *env,
1361                         struct dt_object *dt,
1362                         const struct lu_attr *attr,
1363                         struct thandle *th)
1364 {
1365         struct dt_object        *next = dt_object_child(dt);
1366         struct lod_object       *lo = lod_dt_obj(dt);
1367         int                     rc, i;
1368         ENTRY;
1369
1370         /*
1371          * apply changes to the local object
1372          */
1373         rc = lod_sub_attr_set(env, next, attr, th);
1374         if (rc)
1375                 RETURN(rc);
1376
1377         if (!S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
1378                 if (!(attr->la_valid & LA_REMOTE_ATTR_SET))
1379                         RETURN(rc);
1380
1381                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_OWNER))
1382                         RETURN(0);
1383         } else {
1384                 if (!(attr->la_valid & (LA_UID | LA_GID | LA_MODE | LA_PROJID |
1385                                         LA_ATIME | LA_MTIME | LA_CTIME |
1386                                         LA_FLAGS)))
1387                         RETURN(rc);
1388         }
1389
1390         /* FIXME: a tricky case in the code path of mdd_layout_change():
1391          * the in-memory striping information has been freed in lod_xattr_set()
1392          * due to layout change. It has to load stripe here again. It only
1393          * changes flags of layout so declare_attr_set() is still accurate */
1394         rc = lod_striping_load(env, lo);
1395         if (rc)
1396                 RETURN(rc);
1397
1398         if (!lod_obj_is_striped(dt))
1399                 RETURN(0);
1400
1401         /*
1402          * if object is striped, apply changes to all the stripes
1403          */
1404         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
1405                 LASSERT(lo->ldo_stripe);
1406                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
1407                         if (unlikely(lo->ldo_stripe[i] == NULL))
1408                                 continue;
1409
1410                         if ((dt_object_exists(lo->ldo_stripe[i]) == 0))
1411                                 continue;
1412
1413                         rc = lod_sub_attr_set(env, lo->ldo_stripe[i], attr, th);
1414                         if (rc != 0)
1415                                 break;
1416                 }
1417         } else {
1418                 struct lod_obj_stripe_cb_data data = { { 0 } };
1419
1420                 data.locd_attr = attr;
1421                 data.locd_declare = false;
1422                 data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
1423                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
1424         }
1425
1426         if (rc)
1427                 RETURN(rc);
1428
1429         if (!dt_object_exists(next) || dt_object_remote(next) ||
1430             !S_ISREG(attr->la_mode))
1431                 RETURN(0);
1432
1433         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_STRIPE)) {
1434                 rc = lod_sub_xattr_del(env, next, XATTR_NAME_LOV, th);
1435                 RETURN(rc);
1436         }
1437
1438         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_CHANGE_STRIPE)) {
1439                 struct lod_thread_info *info = lod_env_info(env);
1440                 struct lu_buf *buf = &info->lti_buf;
1441                 struct ost_id *oi = &info->lti_ostid;
1442                 struct lu_fid *fid = &info->lti_fid;
1443                 struct lov_mds_md_v1 *lmm;
1444                 struct lov_ost_data_v1 *objs;
1445                 __u32 magic;
1446
1447                 rc = lod_get_lov_ea(env, lo);
1448                 if (rc <= 0)
1449                         RETURN(rc);
1450
1451                 buf->lb_buf = info->lti_ea_store;
1452                 buf->lb_len = info->lti_ea_store_size;
1453                 lmm = info->lti_ea_store;
1454                 magic = le32_to_cpu(lmm->lmm_magic);
1455                 if (magic == LOV_MAGIC_COMP_V1 || magic == LOV_MAGIC_SEL) {
1456                         struct lov_comp_md_v1 *lcm = buf->lb_buf;
1457                         struct lov_comp_md_entry_v1 *lcme =
1458                                                 &lcm->lcm_entries[0];
1459
1460                         lmm = buf->lb_buf + le32_to_cpu(lcme->lcme_offset);
1461                         magic = le32_to_cpu(lmm->lmm_magic);
1462                 }
1463
1464                 if (magic == LOV_MAGIC_V1)
1465                         objs = &(lmm->lmm_objects[0]);
1466                 else
1467                         objs = &((struct lov_mds_md_v3 *)lmm)->lmm_objects[0];
1468                 ostid_le_to_cpu(&objs->l_ost_oi, oi);
1469                 ostid_to_fid(fid, oi, le32_to_cpu(objs->l_ost_idx));
1470                 fid->f_oid--;
1471                 fid_to_ostid(fid, oi);
1472                 ostid_cpu_to_le(oi, &objs->l_ost_oi);
1473
1474                 rc = lod_sub_xattr_set(env, next, buf, XATTR_NAME_LOV,
1475                                        LU_XATTR_REPLACE, th);
1476         } else if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_PFL_RANGE)) {
1477                 struct lod_thread_info *info = lod_env_info(env);
1478                 struct lu_buf *buf = &info->lti_buf;
1479                 struct lov_comp_md_v1 *lcm;
1480                 struct lov_comp_md_entry_v1 *lcme;
1481
1482                 rc = lod_get_lov_ea(env, lo);
1483                 if (rc <= 0)
1484                         RETURN(rc);
1485
1486                 buf->lb_buf = info->lti_ea_store;
1487                 buf->lb_len = info->lti_ea_store_size;
1488                 lcm = buf->lb_buf;
1489                 if (le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_COMP_V1 &&
1490                     le32_to_cpu(lcm->lcm_magic) != LOV_MAGIC_SEL)
1491                         RETURN(-EINVAL);
1492
1493                 le32_add_cpu(&lcm->lcm_layout_gen, 1);
1494                 lcme = &lcm->lcm_entries[0];
1495                 le64_add_cpu(&lcme->lcme_extent.e_start, 1);
1496                 le64_add_cpu(&lcme->lcme_extent.e_end, -1);
1497
1498                 rc = lod_sub_xattr_set(env, next, buf, XATTR_NAME_LOV,
1499                                        LU_XATTR_REPLACE, th);
1500         }
1501
1502         RETURN(rc);
1503 }
1504
1505 /**
1506  * Implementation of dt_object_operations::do_xattr_get.
1507  *
1508  * If LOV EA is requested from the root object and it's not
1509  * found, then return default striping for the filesystem.
1510  *
1511  * \see dt_object_operations::do_xattr_get() in the API description for details.
1512  */
1513 static int lod_xattr_get(const struct lu_env *env, struct dt_object *dt,
1514                          struct lu_buf *buf, const char *name)
1515 {
1516         struct lod_thread_info *info = lod_env_info(env);
1517         struct lod_device *dev = lu2lod_dev(dt->do_lu.lo_dev);
1518         int is_root;
1519         int rc;
1520         ENTRY;
1521
1522         rc = dt_xattr_get(env, dt_object_child(dt), buf, name);
1523         if (strcmp(name, XATTR_NAME_LMV) == 0) {
1524                 struct lmv_mds_md_v1    *lmv1;
1525                 struct lmv_foreign_md   *lfm;
1526                 int                      rc1 = 0;
1527
1528                 if (rc > (typeof(rc))sizeof(*lmv1))
1529                         RETURN(rc);
1530
1531                 /* short (<= sizeof(struct lmv_mds_md_v1)) foreign LMV case */
1532                 /* XXX empty foreign LMV is not allowed */
1533                 if (rc <= offsetof(typeof(*lfm), lfm_value))
1534                         RETURN(rc = rc > 0 ? -EINVAL : rc);
1535
1536                 if (buf->lb_buf == NULL || buf->lb_len == 0) {
1537                         BUILD_BUG_ON(sizeof(*lmv1) > sizeof(info->lti_key));
1538
1539                         /* lti_buf is large enough for *lmv1 or a short
1540                          * (<= sizeof(struct lmv_mds_md_v1)) foreign LMV
1541                          */
1542                         info->lti_buf.lb_buf = info->lti_key;
1543                         info->lti_buf.lb_len = sizeof(*lmv1);
1544                         rc = dt_xattr_get(env, dt_object_child(dt),
1545                                           &info->lti_buf, name);
1546                         if (unlikely(rc <= offsetof(typeof(*lfm),
1547                                                     lfm_value)))
1548                                 RETURN(rc = rc > 0 ? -EINVAL : rc);
1549
1550                         lfm = info->lti_buf.lb_buf;
1551                         if (le32_to_cpu(lfm->lfm_magic) == LMV_MAGIC_FOREIGN)
1552                                 RETURN(rc);
1553
1554                         if (unlikely(rc != sizeof(*lmv1)))
1555                                 RETURN(rc = rc > 0 ? -EINVAL : rc);
1556
1557                         lmv1 = info->lti_buf.lb_buf;
1558                         /* The on-disk LMV EA only contains header, but the
1559                          * returned LMV EA size should contain the space for
1560                          * the FIDs of all shards of the striped directory. */
1561                         if (le32_to_cpu(lmv1->lmv_magic) == LMV_MAGIC_V1)
1562                                 rc = lmv_mds_md_size(
1563                                         le32_to_cpu(lmv1->lmv_stripe_count),
1564                                         le32_to_cpu(lmv1->lmv_magic));
1565                 } else {
1566                         lmv1 = buf->lb_buf;
1567                         if (le32_to_cpu(lmv1->lmv_magic) != LMV_MAGIC_V1)
1568                                 RETURN(rc);
1569
1570                         if (rc != sizeof(*lmv1))
1571                                 RETURN(rc = rc > 0 ? -EINVAL : rc);
1572
1573                         rc1 = lod_load_lmv_shards(env, lod_dt_obj(dt),
1574                                                   buf, false);
1575                 }
1576
1577                 RETURN(rc = rc1 != 0 ? rc1 : rc);
1578         }
1579
1580         if ((rc > 0) && buf->lb_buf && strcmp(name, XATTR_NAME_LOV) == 0) {
1581                 struct lov_comp_md_v1 *lcm = buf->lb_buf;
1582
1583                 if (lcm->lcm_magic == cpu_to_le32(LOV_MAGIC_SEL))
1584                         lcm->lcm_magic = cpu_to_le32(LOV_MAGIC_COMP_V1);
1585         }
1586
1587         if (rc != -ENODATA || !S_ISDIR(dt->do_lu.lo_header->loh_attr & S_IFMT))
1588                 RETURN(rc);
1589
1590         /*
1591          * XXX: Only used by lfsck
1592          *
1593          * lod returns default striping on the real root of the device
1594          * this is like the root stores default striping for the whole
1595          * filesystem. historically we've been using a different approach
1596          * and store it in the config.
1597          */
1598         dt_root_get(env, dev->lod_child, &info->lti_fid);
1599         is_root = lu_fid_eq(&info->lti_fid, lu_object_fid(&dt->do_lu));
1600
1601         if (is_root && strcmp(XATTR_NAME_LOV, name) == 0) {
1602                 struct lov_user_md *lum = buf->lb_buf;
1603                 struct lov_desc *desc = &dev->lod_ost_descs.ltd_lov_desc;
1604
1605                 if (buf->lb_buf == NULL) {
1606                         rc = sizeof(*lum);
1607                 } else if (buf->lb_len >= sizeof(*lum)) {
1608                         lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
1609                         lmm_oi_set_seq(&lum->lmm_oi, FID_SEQ_LOV_DEFAULT);
1610                         lmm_oi_set_id(&lum->lmm_oi, 0);
1611                         lmm_oi_cpu_to_le(&lum->lmm_oi, &lum->lmm_oi);
1612                         lum->lmm_pattern = cpu_to_le32(desc->ld_pattern);
1613                         lum->lmm_stripe_size = cpu_to_le32(
1614                                                 desc->ld_default_stripe_size);
1615                         lum->lmm_stripe_count = cpu_to_le16(
1616                                                 desc->ld_default_stripe_count);
1617                         lum->lmm_stripe_offset = cpu_to_le16(
1618                                                 desc->ld_default_stripe_offset);
1619                         rc = sizeof(*lum);
1620                 } else {
1621                         rc = -ERANGE;
1622                 }
1623         }
1624
1625         RETURN(rc);
1626 }
1627
1628 /**
1629  * Verify LVM EA.
1630  *
1631  * Checks that the magic of the stripe is sane.
1632  *
1633  * \param[in] lod       lod device
1634  * \param[in] lum       a buffer storing LMV EA to verify
1635  *
1636  * \retval              0 if the EA is sane
1637  * \retval              negative otherwise
1638  */
1639 static int lod_verify_md_striping(struct lod_device *lod,
1640                                   const struct lmv_user_md_v1 *lum)
1641 {
1642         if (unlikely(le32_to_cpu(lum->lum_magic) != LMV_USER_MAGIC)) {
1643                 CERROR("%s: invalid lmv_user_md: magic = %x, "
1644                        "stripe_offset = %d, stripe_count = %u: rc = %d\n",
1645                        lod2obd(lod)->obd_name, le32_to_cpu(lum->lum_magic),
1646                        (int)le32_to_cpu(lum->lum_stripe_offset),
1647                        le32_to_cpu(lum->lum_stripe_count), -EINVAL);
1648                 return -EINVAL;
1649         }
1650
1651         return 0;
1652 }
1653
1654 /**
1655  * Initialize LMV EA for a slave.
1656  *
1657  * Initialize slave's LMV EA from the master's LMV EA.
1658  *
1659  * \param[in] master_lmv        a buffer containing master's EA
1660  * \param[out] slave_lmv        a buffer where slave's EA will be stored
1661  *
1662  */
1663 static void lod_prep_slave_lmv_md(struct lmv_mds_md_v1 *slave_lmv,
1664                                   const struct lmv_mds_md_v1 *master_lmv)
1665 {
1666         *slave_lmv = *master_lmv;
1667         slave_lmv->lmv_magic = cpu_to_le32(LMV_MAGIC_STRIPE);
1668 }
1669
1670 /**
1671  * Generate LMV EA.
1672  *
1673  * Generate LMV EA from the object passed as \a dt. The object must have
1674  * the stripes created and initialized.
1675  *
1676  * \param[in] env       execution environment
1677  * \param[in] dt        object
1678  * \param[out] lmv_buf  buffer storing generated LMV EA
1679  *
1680  * \retval              0 on success
1681  * \retval              negative if failed
1682  */
1683 static int lod_prep_lmv_md(const struct lu_env *env, struct dt_object *dt,
1684                            struct lu_buf *lmv_buf)
1685 {
1686         struct lod_thread_info  *info = lod_env_info(env);
1687         struct lod_device       *lod = lu2lod_dev(dt->do_lu.lo_dev);
1688         struct lod_object       *lo = lod_dt_obj(dt);
1689         struct lmv_mds_md_v1    *lmm1;
1690         int                     stripe_count;
1691         int                     type = LU_SEQ_RANGE_ANY;
1692         int                     rc;
1693         __u32                   mdtidx;
1694         ENTRY;
1695
1696         LASSERT(lo->ldo_dir_striped != 0);
1697         LASSERT(lo->ldo_dir_stripe_count > 0);
1698         stripe_count = lo->ldo_dir_stripe_count;
1699         /* Only store the LMV EA heahder on the disk. */
1700         if (info->lti_ea_store_size < sizeof(*lmm1)) {
1701                 rc = lod_ea_store_resize(info, sizeof(*lmm1));
1702                 if (rc != 0)
1703                         RETURN(rc);
1704         } else {
1705                 memset(info->lti_ea_store, 0, sizeof(*lmm1));
1706         }
1707
1708         lmm1 = (struct lmv_mds_md_v1 *)info->lti_ea_store;
1709         memset(lmm1, 0, sizeof(*lmm1));
1710         lmm1->lmv_magic = cpu_to_le32(LMV_MAGIC);
1711         lmm1->lmv_stripe_count = cpu_to_le32(stripe_count);
1712         lmm1->lmv_hash_type = cpu_to_le32(lo->ldo_dir_hash_type);
1713         lmm1->lmv_layout_version = cpu_to_le32(lo->ldo_dir_layout_version);
1714         if (lod_is_layout_changing(lo)) {
1715                 lmm1->lmv_migrate_hash = cpu_to_le32(lo->ldo_dir_migrate_hash);
1716                 lmm1->lmv_migrate_offset =
1717                         cpu_to_le32(lo->ldo_dir_migrate_offset);
1718         }
1719         rc = lod_fld_lookup(env, lod, lu_object_fid(&dt->do_lu),
1720                             &mdtidx, &type);
1721         if (rc != 0)
1722                 RETURN(rc);
1723
1724         lmm1->lmv_master_mdt_index = cpu_to_le32(mdtidx);
1725         lmv_buf->lb_buf = info->lti_ea_store;
1726         lmv_buf->lb_len = sizeof(*lmm1);
1727
1728         RETURN(rc);
1729 }
1730
1731 /**
1732  * Create in-core represenation for a striped directory.
1733  *
1734  * Parse the buffer containing LMV EA and instantiate LU objects
1735  * representing the stripe objects. The pointers to the objects are
1736  * stored in ldo_stripe field of \a lo. This function is used when
1737  * we need to access an already created object (i.e. load from a disk).
1738  *
1739  * \param[in] env       execution environment
1740  * \param[in] lo        lod object
1741  * \param[in] buf       buffer containing LMV EA
1742  *
1743  * \retval              0 on success
1744  * \retval              negative if failed
1745  */
1746 int lod_parse_dir_striping(const struct lu_env *env, struct lod_object *lo,
1747                            const struct lu_buf *buf)
1748 {
1749         struct lod_thread_info  *info = lod_env_info(env);
1750         struct lod_device       *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
1751         struct lod_tgt_descs    *ltd = &lod->lod_mdt_descs;
1752         struct dt_object        **stripe;
1753         union lmv_mds_md        *lmm = buf->lb_buf;
1754         struct lmv_mds_md_v1    *lmv1 = &lmm->lmv_md_v1;
1755         struct lu_fid           *fid = &info->lti_fid;
1756         unsigned int            i;
1757         int                     rc = 0;
1758         ENTRY;
1759
1760         LASSERT(mutex_is_locked(&lo->ldo_layout_mutex));
1761
1762         /* XXX may be useless as not called for foreign LMV ?? */
1763         if (le32_to_cpu(lmv1->lmv_magic) == LMV_MAGIC_FOREIGN)
1764                 RETURN(0);
1765
1766         if (le32_to_cpu(lmv1->lmv_magic) == LMV_MAGIC_STRIPE) {
1767                 lo->ldo_dir_slave_stripe = 1;
1768                 RETURN(0);
1769         }
1770
1771         if (!lmv_is_sane(lmv1))
1772                 RETURN(-EINVAL);
1773
1774         LASSERT(lo->ldo_stripe == NULL);
1775         OBD_ALLOC_PTR_ARRAY(stripe, le32_to_cpu(lmv1->lmv_stripe_count));
1776         if (stripe == NULL)
1777                 RETURN(-ENOMEM);
1778
1779         for (i = 0; i < le32_to_cpu(lmv1->lmv_stripe_count); i++) {
1780                 struct dt_device        *tgt_dt;
1781                 struct dt_object        *dto;
1782                 int                     type = LU_SEQ_RANGE_ANY;
1783                 __u32                   idx;
1784
1785                 fid_le_to_cpu(fid, &lmv1->lmv_stripe_fids[i]);
1786                 if (!fid_is_sane(fid)) {
1787                         stripe[i] = NULL;
1788                         continue;
1789                 }
1790
1791                 rc = lod_fld_lookup(env, lod, fid, &idx, &type);
1792                 if (rc != 0)
1793                         GOTO(out, rc);
1794
1795                 if (idx == lod2lu_dev(lod)->ld_site->ld_seq_site->ss_node_id) {
1796                         tgt_dt = lod->lod_child;
1797                 } else {
1798                         struct lod_tgt_desc     *tgt;
1799
1800                         tgt = LTD_TGT(ltd, idx);
1801                         if (tgt == NULL)
1802                                 GOTO(out, rc = -ESTALE);
1803                         tgt_dt = tgt->ltd_tgt;
1804                 }
1805
1806                 dto = dt_locate_at(env, tgt_dt, fid,
1807                                   lo->ldo_obj.do_lu.lo_dev->ld_site->ls_top_dev,
1808                                   NULL);
1809                 if (IS_ERR(dto))
1810                         GOTO(out, rc = PTR_ERR(dto));
1811
1812                 stripe[i] = dto;
1813         }
1814 out:
1815         lo->ldo_stripe = stripe;
1816         lo->ldo_is_foreign = 0;
1817         lo->ldo_dir_stripe_count = le32_to_cpu(lmv1->lmv_stripe_count);
1818         lo->ldo_dir_stripes_allocated = le32_to_cpu(lmv1->lmv_stripe_count);
1819         lo->ldo_dir_layout_version = le32_to_cpu(lmv1->lmv_layout_version);
1820         lo->ldo_dir_migrate_offset = le32_to_cpu(lmv1->lmv_migrate_offset);
1821         lo->ldo_dir_migrate_hash = le32_to_cpu(lmv1->lmv_migrate_hash);
1822         lo->ldo_dir_hash_type = le32_to_cpu(lmv1->lmv_hash_type);
1823         if (rc != 0)
1824                 lod_striping_free_nolock(env, lo);
1825
1826         RETURN(rc);
1827 }
1828
1829 /**
1830  * Declare create a striped directory.
1831  *
1832  * Declare creating a striped directory with a given stripe pattern on the
1833  * specified MDTs. A striped directory is represented as a regular directory
1834  * - an index listing all the stripes. The stripes point back to the master
1835  * object with ".." and LinkEA. The master object gets LMV EA which
1836  * identifies it as a striped directory. The function allocates FIDs
1837  * for all stripes.
1838  *
1839  * \param[in] env       execution environment
1840  * \param[in] dt        object
1841  * \param[in] attr      attributes to initialize the objects with
1842  * \param[in] dof       type of objects to be created
1843  * \param[in] th        transaction handle
1844  *
1845  * \retval              0 on success
1846  * \retval              negative if failed
1847  */
1848 static int lod_dir_declare_create_stripes(const struct lu_env *env,
1849                                           struct dt_object *dt,
1850                                           struct lu_attr *attr,
1851                                           struct dt_object_format *dof,
1852                                           struct thandle *th)
1853 {
1854         struct lod_thread_info  *info = lod_env_info(env);
1855         struct lu_buf           lmv_buf;
1856         struct lu_buf           slave_lmv_buf;
1857         struct lmv_mds_md_v1    *lmm;
1858         struct lmv_mds_md_v1    *slave_lmm = NULL;
1859         struct dt_insert_rec    *rec = &info->lti_dt_rec;
1860         struct lod_object       *lo = lod_dt_obj(dt);
1861         int                     rc;
1862         __u32                   i;
1863         ENTRY;
1864
1865         rc = lod_prep_lmv_md(env, dt, &lmv_buf);
1866         if (rc != 0)
1867                 GOTO(out, rc);
1868         lmm = lmv_buf.lb_buf;
1869
1870         OBD_ALLOC_PTR(slave_lmm);
1871         if (slave_lmm == NULL)
1872                 GOTO(out, rc = -ENOMEM);
1873
1874         lod_prep_slave_lmv_md(slave_lmm, lmm);
1875         slave_lmv_buf.lb_buf = slave_lmm;
1876         slave_lmv_buf.lb_len = sizeof(*slave_lmm);
1877
1878         if (!dt_try_as_dir(env, dt_object_child(dt), false))
1879                 GOTO(out, rc = -EINVAL);
1880
1881         rec->rec_type = S_IFDIR;
1882         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
1883                 struct dt_object        *dto = lo->ldo_stripe[i];
1884                 char                    *stripe_name = info->lti_key;
1885                 struct lu_name          *sname;
1886                 struct linkea_data       ldata          = { NULL };
1887                 struct lu_buf           linkea_buf;
1888
1889                 /* OBD_FAIL_MDS_STRIPE_FID may leave stripe uninitialized */
1890                 if (!dto)
1891                         continue;
1892
1893                 /* directory split skip create for existing stripes */
1894                 if (!(lod_is_splitting(lo) && i < lo->ldo_dir_split_offset)) {
1895                         rc = lod_sub_declare_create(env, dto, attr, NULL, dof,
1896                                                     th);
1897                         if (rc != 0)
1898                                 GOTO(out, rc);
1899
1900                         if (!dt_try_as_dir(env, dto, false))
1901                                 GOTO(out, rc = -EINVAL);
1902
1903                         rc = lod_sub_declare_ref_add(env, dto, th);
1904                         if (rc != 0)
1905                                 GOTO(out, rc);
1906
1907                         rec->rec_fid = lu_object_fid(&dto->do_lu);
1908                         rc = lod_sub_declare_insert(env, dto,
1909                                                     (const struct dt_rec *)rec,
1910                                                     (const struct dt_key *)dot,
1911                                                     th);
1912                         if (rc != 0)
1913                                 GOTO(out, rc);
1914
1915                         /* master stripe FID will be put to .. */
1916                         rec->rec_fid = lu_object_fid(&dt->do_lu);
1917                         rc = lod_sub_declare_insert(env, dto,
1918                                                   (const struct dt_rec *)rec,
1919                                                   (const struct dt_key *)dotdot,
1920                                                   th);
1921                         if (rc != 0)
1922                                 GOTO(out, rc);
1923
1924                         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_SLAVE_NAME) &&
1925                             cfs_fail_val == i)
1926                                 snprintf(stripe_name, sizeof(info->lti_key),
1927                                          DFID":%u",
1928                                          PFID(lu_object_fid(&dto->do_lu)),
1929                                          i + 1);
1930                         else
1931                                 snprintf(stripe_name, sizeof(info->lti_key),
1932                                          DFID":%u",
1933                                          PFID(lu_object_fid(&dto->do_lu)), i);
1934
1935                         sname = lod_name_get(env, stripe_name,
1936                                              strlen(stripe_name));
1937                         rc = linkea_links_new(&ldata, &info->lti_linkea_buf,
1938                                               sname, lu_object_fid(&dt->do_lu));
1939                         if (rc != 0)
1940                                 GOTO(out, rc);
1941
1942                         linkea_buf.lb_buf = ldata.ld_buf->lb_buf;
1943                         linkea_buf.lb_len = ldata.ld_leh->leh_len;
1944                         rc = lod_sub_declare_xattr_set(env, dto, &linkea_buf,
1945                                                        XATTR_NAME_LINK, 0, th);
1946                         if (rc != 0)
1947                                 GOTO(out, rc);
1948
1949                         rec->rec_fid = lu_object_fid(&dto->do_lu);
1950                         rc = lod_sub_declare_insert(env, dt_object_child(dt),
1951                                         (const struct dt_rec *)rec,
1952                                         (const struct dt_key *)stripe_name, th);
1953                         if (rc != 0)
1954                                 GOTO(out, rc);
1955
1956                         rc = lod_sub_declare_ref_add(env, dt_object_child(dt),
1957                                                      th);
1958                         if (rc != 0)
1959                                 GOTO(out, rc);
1960                 }
1961
1962                 if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SLAVE_LMV) ||
1963                     cfs_fail_val != i) {
1964                         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_SLAVE_LMV) &&
1965                             cfs_fail_val == i)
1966                                 slave_lmm->lmv_master_mdt_index =
1967                                                         cpu_to_le32(i + 1);
1968                         else
1969                                 slave_lmm->lmv_master_mdt_index =
1970                                                         cpu_to_le32(i);
1971                         rc = lod_sub_declare_xattr_set(env, dto, &slave_lmv_buf,
1972                                                        XATTR_NAME_LMV, 0, th);
1973                         if (rc != 0)
1974                                 GOTO(out, rc);
1975                 }
1976         }
1977
1978         rc = lod_sub_declare_xattr_set(env, dt_object_child(dt),
1979                                        &lmv_buf, XATTR_NAME_LMV, 0, th);
1980         if (rc != 0)
1981                 GOTO(out, rc);
1982 out:
1983         if (slave_lmm != NULL)
1984                 OBD_FREE_PTR(slave_lmm);
1985
1986         RETURN(rc);
1987 }
1988
1989 /**
1990  * Allocate a striping on a predefined set of MDTs.
1991  *
1992  * Allocates new striping using the MDT index range provided by the data from
1993  * the lum_obejcts contained in the lmv_user_md passed to this method if
1994  * \a is_specific is true; or allocates new layout starting from MDT index in
1995  * lo->ldo_dir_stripe_offset. The exact order of MDTs is not important and
1996  * varies depending on MDT status. The number of stripes needed and stripe
1997  * offset are taken from the object. If that number cannot be met, then the
1998  * function returns an error and then it's the caller's responsibility to
1999  * release the stripes allocated. All the internal structures are protected,
2000  * but no concurrent allocation is allowed on the same objects.
2001  *
2002  * \param[in] env               execution environment for this thread
2003  * \param[in] lo                LOD object
2004  * \param[out] stripes          striping created
2005  * \param[out] mdt_indices      MDT indices of striping created
2006  * \param[in] is_specific       true if the MDTs are provided by lum; false if
2007  *                              only the starting MDT index is provided
2008  *
2009  * \retval positive     stripes allocated, including the first stripe allocated
2010  *                      outside
2011  * \retval negative     errno on failure
2012  */
2013 static int lod_mdt_alloc_specific(const struct lu_env *env,
2014                                   struct lod_object *lo,
2015                                   struct dt_object **stripes,
2016                                   __u32 *mdt_indices, bool is_specific)
2017 {
2018         struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
2019         struct lu_tgt_descs *ltd = &lod->lod_mdt_descs;
2020         struct lu_tgt_desc *tgt = NULL;
2021         struct lu_object_conf conf = { .loc_flags = LOC_F_NEW };
2022         struct dt_device *tgt_dt = NULL;
2023         struct lu_fid fid = { 0 };
2024         struct dt_object *dto;
2025         u32 master_index;
2026         u32 stripe_count = lo->ldo_dir_stripe_count;
2027         int stripe_idx = 1;
2028         int j;
2029         int idx;
2030         int rc;
2031
2032         master_index = lu_site2seq(lod2lu_dev(lod)->ld_site)->ss_node_id;
2033         if (!is_specific && stripe_count > 1)
2034                 /* Set the start index for the 2nd stripe allocation */
2035                 mdt_indices[1] = (mdt_indices[0] + 1) %
2036                                         (lod->lod_remote_mdt_count + 1);
2037
2038         for (; stripe_idx < stripe_count; stripe_idx++) {
2039                 /* Try to find next avaible target */
2040                 idx = mdt_indices[stripe_idx];
2041                 for (j = 0; j < lod->lod_remote_mdt_count;
2042                      j++, idx = (idx + 1) % (lod->lod_remote_mdt_count + 1)) {
2043                         bool already_allocated = false;
2044                         __u32 k;
2045
2046                         CDEBUG(D_INFO, "try idx %d, mdt cnt %u, allocated %u\n",
2047                                idx, lod->lod_remote_mdt_count + 1, stripe_idx);
2048
2049                         if (likely(!is_specific &&
2050                                    !OBD_FAIL_CHECK(OBD_FAIL_LARGE_STRIPE))) {
2051                                 /* check whether the idx already exists
2052                                  * in current allocated array */
2053                                 for (k = 0; k < stripe_idx; k++) {
2054                                         if (mdt_indices[k] == idx) {
2055                                                 already_allocated = true;
2056                                                 break;
2057                                         }
2058                                 }
2059
2060                                 if (already_allocated)
2061                                         continue;
2062                         }
2063
2064                         /* Sigh, this index is not in the bitmap, let's check
2065                          * next available target */
2066                         if (!test_bit(idx, ltd->ltd_tgt_bitmap) &&
2067                             idx != master_index)
2068                                 continue;
2069
2070                         if (idx == master_index) {
2071                                 /* Allocate the FID locally */
2072                                 tgt_dt = lod->lod_child;
2073                                 rc = dt_fid_alloc(env, tgt_dt, &fid, NULL,
2074                                                   NULL);
2075                                 if (rc < 0)
2076                                         continue;
2077                                 break;
2078                         }
2079
2080                         /* check the status of the OSP */
2081                         tgt = LTD_TGT(ltd, idx);
2082                         if (!tgt)
2083                                 continue;
2084
2085                         tgt_dt = tgt->ltd_tgt;
2086                         if (!tgt->ltd_active)
2087                                 /* this OSP doesn't feel well */
2088                                 continue;
2089
2090                         rc = dt_fid_alloc(env, tgt_dt, &fid, NULL, NULL);
2091                         if (rc < 0)
2092                                 continue;
2093
2094                         break;
2095                 }
2096
2097                 /* Can not allocate more stripes */
2098                 if (j == lod->lod_remote_mdt_count) {
2099                         CDEBUG(D_INFO, "%s: require stripes %u only get %d\n",
2100                                lod2obd(lod)->obd_name, stripe_count,
2101                                stripe_idx);
2102                         break;
2103                 }
2104
2105                 CDEBUG(D_INFO, "Get idx %d, for stripe %d "DFID"\n",
2106                        idx, stripe_idx, PFID(&fid));
2107                 mdt_indices[stripe_idx] = idx;
2108                 /* Set the start index for next stripe allocation */
2109                 if (!is_specific && stripe_idx < stripe_count - 1) {
2110                         /*
2111                          * for large dir test, put all other slaves on one
2112                          * remote MDT, otherwise we may save too many local
2113                          * slave locks which will exceed RS_MAX_LOCKS.
2114                          */
2115                         if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_LARGE_STRIPE)))
2116                                 idx = master_index;
2117                         mdt_indices[stripe_idx + 1] = (idx + 1) %
2118                                            (lod->lod_remote_mdt_count + 1);
2119                 }
2120                 /* tgt_dt and fid must be ready after search avaible OSP
2121                  * in the above loop */
2122                 LASSERT(tgt_dt != NULL);
2123                 LASSERT(fid_is_sane(&fid));
2124
2125                 /* fail a remote stripe FID allocation */
2126                 if (stripe_idx && OBD_FAIL_CHECK(OBD_FAIL_MDS_STRIPE_FID))
2127                         continue;
2128
2129                 dto = dt_locate_at(env, tgt_dt, &fid,
2130                                   lo->ldo_obj.do_lu.lo_dev->ld_site->ls_top_dev,
2131                                   &conf);
2132                 if (IS_ERR(dto)) {
2133                         rc = PTR_ERR(dto);
2134                         goto error;
2135                 }
2136
2137                 stripes[stripe_idx] = dto;
2138         }
2139
2140         return stripe_idx;
2141
2142 error:
2143         for (j = 1; j < stripe_idx; j++) {
2144                 LASSERT(stripes[j] != NULL);
2145                 dt_object_put(env, stripes[j]);
2146                 stripes[j] = NULL;
2147         }
2148         return rc;
2149 }
2150
2151 static int lod_prep_md_striped_create(const struct lu_env *env,
2152                                       struct dt_object *dt,
2153                                       struct lu_attr *attr,
2154                                       const struct lmv_user_md_v1 *lum,
2155                                       struct dt_object_format *dof,
2156                                       struct thandle *th)
2157 {
2158         struct lod_device *lod = lu2lod_dev(dt->do_lu.lo_dev);
2159         struct lod_object *lo = lod_dt_obj(dt);
2160         struct dt_object **stripes;
2161         struct lu_object_conf conf = { .loc_flags = LOC_F_NEW };
2162         struct lu_fid fid = { 0 };
2163         __u32 stripe_count;
2164         int i;
2165         int rc = 0;
2166
2167         ENTRY;
2168
2169         /* The lum has been verifed in lod_verify_md_striping */
2170         LASSERT(le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC ||
2171                 le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC_SPECIFIC);
2172
2173         stripe_count = lo->ldo_dir_stripe_count;
2174
2175         OBD_ALLOC_PTR_ARRAY(stripes, stripe_count);
2176         if (!stripes)
2177                 RETURN(-ENOMEM);
2178
2179         /* Allocate the first stripe locally */
2180         rc = dt_fid_alloc(env, lod->lod_child, &fid, NULL, NULL);
2181         if (rc < 0)
2182                 GOTO(out, rc);
2183
2184         stripes[0] = dt_locate_at(env, lod->lod_child, &fid,
2185                                   dt->do_lu.lo_dev->ld_site->ls_top_dev, &conf);
2186         if (IS_ERR(stripes[0]))
2187                 GOTO(out, rc = PTR_ERR(stripes[0]));
2188
2189         if (lo->ldo_dir_stripe_offset == LMV_OFFSET_DEFAULT) {
2190                 lod_qos_statfs_update(env, lod, &lod->lod_mdt_descs);
2191                 rc = lod_mdt_alloc_qos(env, lo, stripes, 1, stripe_count);
2192                 if (rc == -EAGAIN)
2193                         rc = lod_mdt_alloc_rr(env, lo, stripes, 1,
2194                                               stripe_count);
2195         } else {
2196                 int *idx_array;
2197                 bool is_specific = false;
2198
2199                 OBD_ALLOC_PTR_ARRAY(idx_array, stripe_count);
2200                 if (!idx_array)
2201                         GOTO(out, rc = -ENOMEM);
2202
2203                 if (le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC_SPECIFIC) {
2204                         is_specific = true;
2205                         for (i = 0; i < stripe_count; i++)
2206                                 idx_array[i] =
2207                                        le32_to_cpu(lum->lum_objects[i].lum_mds);
2208                 }
2209
2210                 /* stripe 0 is local */
2211                 idx_array[0] =
2212                         lu_site2seq(lod2lu_dev(lod)->ld_site)->ss_node_id;
2213                 rc = lod_mdt_alloc_specific(env, lo, stripes, idx_array,
2214                                             is_specific);
2215                 OBD_FREE_PTR_ARRAY(idx_array, stripe_count);
2216         }
2217
2218         if (rc < 0)
2219                 GOTO(out, rc);
2220
2221         LASSERT(rc > 0);
2222
2223         lo->ldo_dir_striped = 1;
2224         lo->ldo_stripe = stripes;
2225         lo->ldo_dir_stripe_count = rc;
2226         lo->ldo_dir_stripes_allocated = stripe_count;
2227         smp_mb();
2228         lo->ldo_dir_stripe_loaded = 1;
2229
2230         rc = lod_dir_declare_create_stripes(env, dt, attr, dof, th);
2231         if (rc < 0)
2232                 lod_striping_free(env, lo);
2233
2234         RETURN(rc);
2235
2236 out:
2237         LASSERT(rc < 0);
2238         if (!IS_ERR_OR_NULL(stripes[0]))
2239                 dt_object_put(env, stripes[0]);
2240         for (i = 1; i < stripe_count; i++)
2241                 LASSERT(!stripes[i]);
2242         OBD_FREE_PTR_ARRAY(stripes, stripe_count);
2243
2244         return rc;
2245 }
2246
2247 /**
2248  *
2249  * Alloc cached foreign LOV
2250  *
2251  * \param[in] lo        object
2252  * \param[in] size      size of foreign LOV
2253  *
2254  * \retval              0 on success
2255  * \retval              negative if failed
2256  */
2257 int lod_alloc_foreign_lov(struct lod_object *lo, size_t size)
2258 {
2259         OBD_ALLOC_LARGE(lo->ldo_foreign_lov, size);
2260         if (lo->ldo_foreign_lov == NULL)
2261                 return -ENOMEM;
2262         lo->ldo_foreign_lov_size = size;
2263         lo->ldo_is_foreign = 1;
2264         return 0;
2265 }
2266
2267 /**
2268  *
2269  * Free cached foreign LOV
2270  *
2271  * \param[in] lo        object
2272  */
2273 void lod_free_foreign_lov(struct lod_object *lo)
2274 {
2275         if (lo->ldo_foreign_lov != NULL)
2276                 OBD_FREE_LARGE(lo->ldo_foreign_lov, lo->ldo_foreign_lov_size);
2277         lo->ldo_foreign_lov = NULL;
2278         lo->ldo_foreign_lov_size = 0;
2279         lo->ldo_is_foreign = 0;
2280 }
2281
2282 /**
2283  *
2284  * Alloc cached foreign LMV
2285  *
2286  * \param[in] lo        object
2287  * \param[in] size      size of foreign LMV
2288  *
2289  * \retval              0 on success
2290  * \retval              negative if failed
2291  */
2292 int lod_alloc_foreign_lmv(struct lod_object *lo, size_t size)
2293 {
2294         OBD_ALLOC_LARGE(lo->ldo_foreign_lmv, size);
2295         if (lo->ldo_foreign_lmv == NULL)
2296                 return -ENOMEM;
2297         lo->ldo_foreign_lmv_size = size;
2298         lo->ldo_is_foreign = 1;
2299
2300         return 0;
2301 }
2302
2303 /**
2304  *
2305  * Free cached foreign LMV
2306  *
2307  * \param[in] lo        object
2308  */
2309 void lod_free_foreign_lmv(struct lod_object *lo)
2310 {
2311         if (lo->ldo_foreign_lmv != NULL)
2312                 OBD_FREE_LARGE(lo->ldo_foreign_lmv, lo->ldo_foreign_lmv_size);
2313         lo->ldo_foreign_lmv = NULL;
2314         lo->ldo_foreign_lmv_size = 0;
2315         lo->ldo_is_foreign = 0;
2316 }
2317
2318 /**
2319  * Declare create striped md object.
2320  *
2321  * The function declares intention to create a striped directory. This is a
2322  * wrapper for lod_prep_md_striped_create(). The only additional functionality
2323  * is to verify pattern \a lum_buf is good. Check that function for the details.
2324  *
2325  * \param[in] env       execution environment
2326  * \param[in] dt        object
2327  * \param[in] attr      attributes to initialize the objects with
2328  * \param[in] lum_buf   a pattern specifying the number of stripes and
2329  *                      MDT to start from
2330  * \param[in] dof       type of objects to be created
2331  * \param[in] th        transaction handle
2332  *
2333  * \retval              0 on success
2334  * \retval              negative if failed
2335  *
2336  */
2337 static int lod_declare_xattr_set_lmv(const struct lu_env *env,
2338                                      struct dt_object *dt,
2339                                      struct lu_attr *attr,
2340                                      const struct lu_buf *lum_buf,
2341                                      struct dt_object_format *dof,
2342                                      struct thandle *th)
2343 {
2344         struct lod_object *lo = lod_dt_obj(dt);
2345         struct lmv_user_md_v1 *lum = lum_buf->lb_buf;
2346         int rc;
2347
2348         ENTRY;
2349         LASSERT(lum != NULL);
2350
2351         CDEBUG(D_INFO,
2352                "lum magic=%x hash=%x count=%u offset=%d inherit=%u rr=%u\n",
2353                le32_to_cpu(lum->lum_magic), le32_to_cpu(lum->lum_hash_type),
2354                le32_to_cpu(lum->lum_stripe_count),
2355                (int)le32_to_cpu(lum->lum_stripe_offset),
2356                lum->lum_max_inherit, lum->lum_max_inherit_rr);
2357
2358         if (lo->ldo_dir_stripe_count == 0) {
2359                 if (lo->ldo_is_foreign) {
2360                         rc = lod_alloc_foreign_lmv(lo, lum_buf->lb_len);
2361                         if (rc != 0)
2362                                 GOTO(out, rc);
2363                         memcpy(lo->ldo_foreign_lmv, lum, lum_buf->lb_len);
2364                         lo->ldo_dir_stripe_loaded = 1;
2365                 }
2366                 GOTO(out, rc = 0);
2367         }
2368
2369         /* prepare dir striped objects */
2370         rc = lod_prep_md_striped_create(env, dt, attr, lum, dof, th);
2371         if (rc != 0) {
2372                 /* failed to create striping, let's reset
2373                  * config so that others don't get confused */
2374                 lod_striping_free(env, lo);
2375                 GOTO(out, rc);
2376         }
2377 out:
2378         RETURN(rc);
2379 }
2380
2381 /**
2382  * Set or replace striped directory layout, and LFSCK may set layout on a plain
2383  * directory, so don't check stripe count.
2384  *
2385  * \param[in] env       execution environment
2386  * \param[in] dt        target object
2387  * \param[in] lmv_buf   LMV buf which contains source stripe FIDs
2388  * \param[in] fl        set or replace
2389  * \param[in] th        transaction handle
2390  *
2391  * \retval              0 on success
2392  * \retval              negative if failed
2393  */
2394 static int lod_dir_layout_set(const struct lu_env *env,
2395                               struct dt_object *dt,
2396                               const struct lu_buf *lmv_buf,
2397                               int fl,
2398                               struct thandle *th)
2399 {
2400         struct dt_object *next = dt_object_child(dt);
2401         struct lod_object *lo = lod_dt_obj(dt);
2402         struct lod_device *lod = lu2lod_dev(lod2lu_obj(lo)->lo_dev);
2403         struct lmv_mds_md_v1 *lmv = lmv_buf->lb_buf;
2404         struct lmv_mds_md_v1 *slave_lmv;
2405         struct lu_buf slave_buf;
2406         int i;
2407         int rc;
2408
2409         ENTRY;
2410
2411         if (!lmv_is_sane2(lmv))
2412                 RETURN(-EINVAL);
2413
2414         /* adjust hash for dir merge, which may not be set in user command */
2415         if (lmv_is_merging(lmv) &&
2416             !(lmv->lmv_migrate_hash & LMV_HASH_TYPE_MASK))
2417                 lmv->lmv_merge_hash |=
2418                         lod->lod_mdt_descs.ltd_lmv_desc.ld_pattern &
2419                         LMV_HASH_TYPE_MASK;
2420
2421         LMV_DEBUG(D_INFO, lmv, "set");
2422
2423         rc = lod_sub_xattr_set(env, next, lmv_buf, XATTR_NAME_LMV, fl, th);
2424         if (rc)
2425                 RETURN(rc);
2426
2427         /* directory restripe may update stripe LMV directly */
2428         if (!lo->ldo_dir_stripe_count)
2429                 RETURN(0);
2430
2431         lo->ldo_dir_hash_type = le32_to_cpu(lmv->lmv_hash_type);
2432         lo->ldo_dir_migrate_offset = le32_to_cpu(lmv->lmv_migrate_offset);
2433         lo->ldo_dir_migrate_hash = le32_to_cpu(lmv->lmv_migrate_hash);
2434         lo->ldo_dir_layout_version = le32_to_cpu(lmv->lmv_layout_version);
2435
2436         OBD_ALLOC_PTR(slave_lmv);
2437         if (!slave_lmv)
2438                 RETURN(-ENOMEM);
2439
2440         lod_prep_slave_lmv_md(slave_lmv, lmv);
2441         slave_buf.lb_buf = slave_lmv;
2442         slave_buf.lb_len = sizeof(*slave_lmv);
2443
2444         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
2445                 if (!lo->ldo_stripe[i])
2446                         continue;
2447
2448                 if (!dt_object_exists(lo->ldo_stripe[i]))
2449                         continue;
2450
2451                 rc = lod_sub_xattr_set(env, lo->ldo_stripe[i], &slave_buf,
2452                                        XATTR_NAME_LMV, fl, th);
2453                 if (rc)
2454                         break;
2455         }
2456
2457         OBD_FREE_PTR(slave_lmv);
2458
2459         RETURN(rc);
2460 }
2461
2462 /**
2463  * Implementation of dt_object_operations::do_declare_xattr_set.
2464  *
2465  * Used with regular (non-striped) objects. Basically it
2466  * initializes the striping information and applies the
2467  * change to all the stripes.
2468  *
2469  * \see dt_object_operations::do_declare_xattr_set() in the API description
2470  * for details.
2471  */
2472 static int lod_dir_declare_xattr_set(const struct lu_env *env,
2473                                      struct dt_object *dt,
2474                                      const struct lu_buf *buf,
2475                                      const char *name, int fl,
2476                                      struct thandle *th)
2477 {
2478         struct dt_object        *next = dt_object_child(dt);
2479         struct lod_device       *d = lu2lod_dev(dt->do_lu.lo_dev);
2480         struct lod_object       *lo = lod_dt_obj(dt);
2481         int                     i;
2482         int                     rc;
2483         ENTRY;
2484
2485         if (strcmp(name, XATTR_NAME_DEFAULT_LMV) == 0) {
2486                 struct lmv_user_md_v1 *lum;
2487
2488                 LASSERT(buf != NULL && buf->lb_buf != NULL);
2489                 lum = buf->lb_buf;
2490                 rc = lod_verify_md_striping(d, lum);
2491                 if (rc != 0)
2492                         RETURN(rc);
2493         } else if (strcmp(name, XATTR_NAME_LOV) == 0) {
2494                 rc = lod_verify_striping(env, d, lo, buf, false);
2495                 if (rc != 0)
2496                         RETURN(rc);
2497         }
2498
2499         rc = lod_sub_declare_xattr_set(env, next, buf, name, fl, th);
2500         if (rc != 0)
2501                 RETURN(rc);
2502
2503         /* Note: Do not set LinkEA on sub-stripes, otherwise
2504          * it will confuse the fid2path process(see mdt_path_current()).
2505          * The linkEA between master and sub-stripes is set in
2506          * lod_xattr_set_lmv(). */
2507         if (strcmp(name, XATTR_NAME_LINK) == 0)
2508                 RETURN(0);
2509
2510         /* set xattr to each stripes, if needed */
2511         rc = lod_striping_load(env, lo);
2512         if (rc != 0)
2513                 RETURN(rc);
2514
2515         if (lo->ldo_dir_stripe_count == 0)
2516                 RETURN(0);
2517
2518         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
2519                 if (!lo->ldo_stripe[i])
2520                         continue;
2521
2522                 if (!dt_object_exists(lo->ldo_stripe[i]))
2523                         continue;
2524
2525                 rc = lod_sub_declare_xattr_set(env, lo->ldo_stripe[i],
2526                                                buf, name, fl, th);
2527                 if (rc != 0)
2528                         break;
2529         }
2530
2531         RETURN(rc);
2532 }
2533
2534 static int
2535 lod_obj_stripe_replace_parent_fid_cb(const struct lu_env *env,
2536                                      struct lod_object *lo,
2537                                      struct dt_object *dt, struct thandle *th,
2538                                      int comp_idx, int stripe_idx,
2539                                      struct lod_obj_stripe_cb_data *data)
2540 {
2541         struct lod_thread_info *info = lod_env_info(env);
2542         struct lod_layout_component *comp = &lo->ldo_comp_entries[comp_idx];
2543         struct filter_fid *ff = &info->lti_ff;
2544         struct lu_buf *buf = &info->lti_buf;
2545         int rc;
2546
2547         buf->lb_buf = ff;
2548         buf->lb_len = sizeof(*ff);
2549         rc = dt_xattr_get(env, dt, buf, XATTR_NAME_FID);
2550         if (rc < 0) {
2551                 if (rc == -ENODATA)
2552                         return 0;
2553                 return rc;
2554         }
2555
2556         /*
2557          * locd_buf is set if it's called by dir migration, which doesn't check
2558          * pfid and comp id.
2559          */
2560         if (data->locd_buf) {
2561                 memset(ff, 0, sizeof(*ff));
2562                 ff->ff_parent = *(struct lu_fid *)data->locd_buf->lb_buf;
2563         } else {
2564                 filter_fid_le_to_cpu(ff, ff, sizeof(*ff));
2565
2566                 if (lu_fid_eq(lod_object_fid(lo), &ff->ff_parent) &&
2567                     ff->ff_layout.ol_comp_id == comp->llc_id)
2568                         return 0;
2569
2570                 memset(ff, 0, sizeof(*ff));
2571                 ff->ff_parent = *lu_object_fid(&lo->ldo_obj.do_lu);
2572         }
2573
2574         /* rewrite filter_fid */
2575         ff->ff_parent.f_ver = stripe_idx;
2576         ff->ff_layout.ol_stripe_size = comp->llc_stripe_size;
2577         ff->ff_layout.ol_stripe_count = comp->llc_stripe_count;
2578         ff->ff_layout.ol_comp_id = comp->llc_id;
2579         ff->ff_layout.ol_comp_start = comp->llc_extent.e_start;
2580         ff->ff_layout.ol_comp_end = comp->llc_extent.e_end;
2581         filter_fid_cpu_to_le(ff, ff, sizeof(*ff));
2582
2583         if (data->locd_declare)
2584                 rc = lod_sub_declare_xattr_set(env, dt, buf, XATTR_NAME_FID,
2585                                                LU_XATTR_REPLACE, th);
2586         else
2587                 rc = lod_sub_xattr_set(env, dt, buf, XATTR_NAME_FID,
2588                                        LU_XATTR_REPLACE, th);
2589
2590         return rc;
2591 }
2592
2593 /**
2594  * Reset parent FID on OST object
2595  *
2596  * Replace parent FID with @dt object FID, which is only called during migration
2597  * to reset the parent FID after the MDT object is migrated to the new MDT, i.e.
2598  * the FID is changed.
2599  *
2600  * \param[in] env execution environment
2601  * \param[in] dt dt_object whose stripes's parent FID will be reset
2602  * \parem[in] th thandle
2603  * \param[in] declare if it is declare
2604  *
2605  * \retval      0 if reset succeeds
2606  * \retval      negative errno if reset fails
2607  */
2608 static int lod_replace_parent_fid(const struct lu_env *env,
2609                                   struct dt_object *dt,
2610                                   const struct lu_buf *buf,
2611                                   struct thandle *th, bool declare)
2612 {
2613         struct lod_object *lo = lod_dt_obj(dt);
2614         struct lod_thread_info  *info = lod_env_info(env);
2615         struct filter_fid *ff;
2616         struct lod_obj_stripe_cb_data data = { { 0 } };
2617         int rc;
2618         ENTRY;
2619
2620         LASSERT(S_ISREG(dt->do_lu.lo_header->loh_attr));
2621
2622         /* set xattr to each stripes, if needed */
2623         rc = lod_striping_load(env, lo);
2624         if (rc != 0)
2625                 RETURN(rc);
2626
2627         if (!lod_obj_is_striped(dt))
2628                 RETURN(0);
2629
2630         if (info->lti_ea_store_size < sizeof(*ff)) {
2631                 rc = lod_ea_store_resize(info, sizeof(*ff));
2632                 if (rc != 0)
2633                         RETURN(rc);
2634         }
2635
2636         data.locd_declare = declare;
2637         data.locd_stripe_cb = lod_obj_stripe_replace_parent_fid_cb;
2638         data.locd_buf = buf;
2639         rc = lod_obj_for_each_stripe(env, lo, th, &data);
2640
2641         RETURN(rc);
2642 }
2643
2644 __u16 lod_comp_entry_stripe_count(struct lod_object *lo,
2645                                   int comp_idx, bool is_dir)
2646 {
2647         struct lod_device *lod = lu2lod_dev(lod2lu_obj(lo)->lo_dev);
2648         struct lod_layout_component *entry;
2649
2650         if (is_dir)
2651                 return  0;
2652
2653         entry = &lo->ldo_comp_entries[comp_idx];
2654         if (lod_comp_inited(entry))
2655                 return entry->llc_stripe_count;
2656         else if ((__u16)-1 == entry->llc_stripe_count)
2657                 return lod->lod_ost_count;
2658         else
2659                 return lod_get_stripe_count(lod, lo, comp_idx,
2660                                             entry->llc_stripe_count,
2661                                             entry->llc_pattern &
2662                                             LOV_PATTERN_OVERSTRIPING);
2663 }
2664
2665 static int lod_comp_md_size(struct lod_object *lo, bool is_dir)
2666 {
2667         int magic, size = 0, i;
2668         struct lod_layout_component *comp_entries;
2669         __u16 comp_cnt;
2670         bool is_composite, is_foreign = false;
2671
2672         if (is_dir) {
2673                 comp_cnt = lo->ldo_def_striping->lds_def_comp_cnt;
2674                 comp_entries = lo->ldo_def_striping->lds_def_comp_entries;
2675                 is_composite =
2676                         lo->ldo_def_striping->lds_def_striping_is_composite;
2677         } else {
2678                 comp_cnt = lo->ldo_comp_cnt;
2679                 comp_entries = lo->ldo_comp_entries;
2680                 is_composite = lo->ldo_is_composite;
2681                 is_foreign = lo->ldo_is_foreign;
2682         }
2683
2684         if (is_foreign)
2685                 return lo->ldo_foreign_lov_size;
2686
2687         LASSERT(comp_cnt != 0 && comp_entries != NULL);
2688         if (is_composite) {
2689                 size = sizeof(struct lov_comp_md_v1) +
2690                        sizeof(struct lov_comp_md_entry_v1) * comp_cnt;
2691                 LASSERT(size % sizeof(__u64) == 0);
2692         }
2693
2694         for (i = 0; i < comp_cnt; i++) {
2695                 __u16 stripe_count;
2696
2697                 magic = comp_entries[i].llc_pool ? LOV_MAGIC_V3 : LOV_MAGIC_V1;
2698                 stripe_count = lod_comp_entry_stripe_count(lo, i, is_dir);
2699                 if (!is_dir && is_composite)
2700                         lod_comp_shrink_stripe_count(&comp_entries[i],
2701                                                      &stripe_count);
2702
2703                 size += lov_user_md_size(stripe_count, magic);
2704                 LASSERT(size % sizeof(__u64) == 0);
2705         }
2706         return size;
2707 }
2708
2709 /**
2710  * Declare component add. The xattr name is XATTR_LUSTRE_LOV.add, and
2711  * the xattr value is binary lov_comp_md_v1 which contains component(s)
2712  * to be added.
2713   *
2714  * \param[in] env       execution environment
2715  * \param[in] dt        dt_object to add components on
2716  * \param[in] buf       buffer contains components to be added
2717  * \parem[in] th        thandle
2718  *
2719  * \retval      0 on success
2720  * \retval      negative errno on failure
2721  */
2722 static int lod_declare_layout_add(const struct lu_env *env,
2723                                   struct dt_object *dt,
2724                                   const struct lu_buf *buf,
2725                                   struct thandle *th)
2726 {
2727         struct lod_thread_info  *info = lod_env_info(env);
2728         struct lod_layout_component *comp_array, *lod_comp, *old_array;
2729         struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
2730         struct dt_object *next = dt_object_child(dt);
2731         struct lov_desc *desc = &d->lod_ost_descs.ltd_lov_desc;
2732         struct lod_object *lo = lod_dt_obj(dt);
2733         struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
2734         __u32 magic;
2735         int i, rc, array_cnt, old_array_cnt;
2736         ENTRY;
2737
2738         LASSERT(lo->ldo_is_composite);
2739
2740         if (lo->ldo_flr_state != LCM_FL_NONE)
2741                 RETURN(-EBUSY);
2742
2743         rc = lod_verify_striping(env, d, lo, buf, false);
2744         if (rc != 0)
2745                 RETURN(rc);
2746
2747         magic = comp_v1->lcm_magic;
2748         if (magic == __swab32(LOV_USER_MAGIC_COMP_V1)) {
2749                 lustre_swab_lov_comp_md_v1(comp_v1);
2750                 magic = comp_v1->lcm_magic;
2751         }
2752
2753         if (magic != LOV_USER_MAGIC_COMP_V1)
2754                 RETURN(-EINVAL);
2755
2756         mutex_lock(&lo->ldo_layout_mutex);
2757
2758         array_cnt = lo->ldo_comp_cnt + comp_v1->lcm_entry_count;
2759         OBD_ALLOC_PTR_ARRAY(comp_array, array_cnt);
2760         if (comp_array == NULL) {
2761                 mutex_unlock(&lo->ldo_layout_mutex);
2762                 RETURN(-ENOMEM);
2763         }
2764
2765
2766         memcpy(comp_array, lo->ldo_comp_entries,
2767                sizeof(*comp_array) * lo->ldo_comp_cnt);
2768
2769         for (i = 0; i < comp_v1->lcm_entry_count; i++) {
2770                 struct lov_user_md_v1 *v1;
2771                 struct lu_extent *ext;
2772
2773                 v1 = (struct lov_user_md *)((char *)comp_v1 +
2774                                 comp_v1->lcm_entries[i].lcme_offset);
2775                 ext = &comp_v1->lcm_entries[i].lcme_extent;
2776
2777                 lod_comp = &comp_array[lo->ldo_comp_cnt + i];
2778                 lod_comp->llc_extent.e_start = ext->e_start;
2779                 lod_comp->llc_extent.e_end = ext->e_end;
2780                 lod_comp->llc_stripe_offset = v1->lmm_stripe_offset;
2781                 lod_comp->llc_flags = comp_v1->lcm_entries[i].lcme_flags;
2782
2783                 lod_comp->llc_stripe_count = v1->lmm_stripe_count;
2784                 lod_comp->llc_stripe_size = v1->lmm_stripe_size;
2785                 lod_adjust_stripe_info(lod_comp, desc, 0);
2786
2787                 if (v1->lmm_magic == LOV_USER_MAGIC_V3) {
2788                         struct lov_user_md_v3 *v3 = (typeof(*v3) *) v1;
2789
2790                         if (v3->lmm_pool_name[0] != '\0' &&
2791                             !lov_pool_is_ignored(v3->lmm_pool_name)) {
2792                                 rc = lod_set_pool(&lod_comp->llc_pool,
2793                                                   v3->lmm_pool_name);
2794                                 if (rc)
2795                                         GOTO(error, rc);
2796                         }
2797                 }
2798         }
2799
2800         old_array = lo->ldo_comp_entries;
2801         old_array_cnt = lo->ldo_comp_cnt;
2802
2803         lo->ldo_comp_entries = comp_array;
2804         lo->ldo_comp_cnt = array_cnt;
2805
2806         /* No need to increase layout generation here, it will be increased
2807          * later when generating component ID for the new components */
2808
2809         info->lti_buf.lb_len = lod_comp_md_size(lo, false);
2810         rc = lod_sub_declare_xattr_set(env, next, &info->lti_buf,
2811                                               XATTR_NAME_LOV, 0, th);
2812         if (rc) {
2813                 lo->ldo_comp_entries = old_array;
2814                 lo->ldo_comp_cnt = old_array_cnt;
2815                 GOTO(error, rc);
2816         }
2817
2818         OBD_FREE_PTR_ARRAY(old_array, old_array_cnt);
2819
2820         LASSERT(lo->ldo_mirror_count == 1);
2821         lo->ldo_mirrors[0].lme_end = array_cnt - 1;
2822
2823         mutex_unlock(&lo->ldo_layout_mutex);
2824
2825         RETURN(0);
2826
2827 error:
2828         for (i = lo->ldo_comp_cnt; i < array_cnt; i++) {
2829                 lod_comp = &comp_array[i];
2830                 if (lod_comp->llc_pool != NULL) {
2831                         OBD_FREE(lod_comp->llc_pool,
2832                                  strlen(lod_comp->llc_pool) + 1);
2833                         lod_comp->llc_pool = NULL;
2834                 }
2835         }
2836         OBD_FREE_PTR_ARRAY(comp_array, array_cnt);
2837         mutex_unlock(&lo->ldo_layout_mutex);
2838
2839         RETURN(rc);
2840 }
2841
2842 /**
2843  * lod_last_non_stale_mirror() - Check if a mirror is the last non-stale mirror.
2844  * @mirror_id: Mirror id to be checked.
2845  * @lo:        LOD object.
2846  *
2847  * This function checks if a mirror with specified @mirror_id is the last
2848  * non-stale mirror of a LOD object @lo.
2849  *
2850  * Return: true or false.
2851  */
2852 static inline
2853 bool lod_last_non_stale_mirror(__u16 mirror_id, struct lod_object *lo)
2854 {
2855         struct lod_layout_component *lod_comp;
2856         bool has_stale_flag;
2857         int i;
2858
2859         for (i = 0; i < lo->ldo_mirror_count; i++) {
2860                 if (lo->ldo_mirrors[i].lme_id == mirror_id ||
2861                     lo->ldo_mirrors[i].lme_stale)
2862                         continue;
2863
2864                 has_stale_flag = false;
2865                 lod_foreach_mirror_comp(lod_comp, lo, i) {
2866                         if (lod_comp->llc_flags & LCME_FL_STALE) {
2867                                 has_stale_flag = true;
2868                                 break;
2869                         }
2870                 }
2871                 if (!has_stale_flag)
2872                         return false;
2873         }
2874
2875         return true;
2876 }
2877
2878 /**
2879  * Declare component set. The xattr is name XATTR_LUSTRE_LOV.set.$field,
2880  * the '$field' can only be 'flags' now. The xattr value is binary
2881  * lov_comp_md_v1 which contains the component ID(s) and the value of
2882  * the field to be modified.
2883  * Please update allowed_lustre_lov macro if $field groks more values
2884  * in the future.
2885  *
2886  * \param[in] env       execution environment
2887  * \param[in] dt        dt_object to be modified
2888  * \param[in] op        operation string, like "set.flags"
2889  * \param[in] buf       buffer contains components to be set
2890  * \parem[in] th        thandle
2891  *
2892  * \retval      0 on success
2893  * \retval      negative errno on failure
2894  */
2895 static int lod_declare_layout_set(const struct lu_env *env,
2896                                   struct dt_object *dt,
2897                                   char *op, const struct lu_buf *buf,
2898                                   struct thandle *th)
2899 {
2900         struct lod_layout_component     *lod_comp;
2901         struct lod_thread_info  *info = lod_env_info(env);
2902         struct lod_device       *d = lu2lod_dev(dt->do_lu.lo_dev);
2903         struct lod_object       *lo = lod_dt_obj(dt);
2904         struct lov_comp_md_v1   *comp_v1 = buf->lb_buf;
2905         __u32   magic;
2906         int     i, j, rc;
2907         bool    changed = false;
2908         ENTRY;
2909
2910         /* Please update allowed_lustre_lov macro if op
2911          * groks more values in the future
2912          */
2913         if (strcmp(op, "set.flags") != 0) {
2914                 CDEBUG(D_LAYOUT, "%s: operation (%s) not supported.\n",
2915                        lod2obd(d)->obd_name, op);
2916                 RETURN(-ENOTSUPP);
2917         }
2918
2919         magic = comp_v1->lcm_magic;
2920         if (magic == __swab32(LOV_USER_MAGIC_COMP_V1)) {
2921                 lustre_swab_lov_comp_md_v1(comp_v1);
2922                 magic = comp_v1->lcm_magic;
2923         }
2924
2925         if (magic != LOV_USER_MAGIC_COMP_V1)
2926                 RETURN(-EINVAL);
2927
2928         if (comp_v1->lcm_entry_count == 0) {
2929                 CDEBUG(D_LAYOUT, "%s: entry count is zero.\n",
2930                        lod2obd(d)->obd_name);
2931                 RETURN(-EINVAL);
2932         }
2933
2934         mutex_lock(&lo->ldo_layout_mutex);
2935         for (i = 0; i < comp_v1->lcm_entry_count; i++) {
2936                 __u32 id = comp_v1->lcm_entries[i].lcme_id;
2937                 __u32 flags = comp_v1->lcm_entries[i].lcme_flags;
2938                 __u32 mirror_flag = flags & LCME_MIRROR_FLAGS;
2939                 __u16 mirror_id = mirror_id_of(id);
2940                 bool neg = flags & LCME_FL_NEG;
2941
2942                 if (flags & LCME_FL_INIT) {
2943                         if (changed)
2944                                 lod_striping_free_nolock(env, lo);
2945                         mutex_unlock(&lo->ldo_layout_mutex);
2946                         RETURN(-EINVAL);
2947                 }
2948
2949                 flags &= ~(LCME_MIRROR_FLAGS | LCME_FL_NEG);
2950                 for (j = 0; j < lo->ldo_comp_cnt; j++) {
2951                         lod_comp = &lo->ldo_comp_entries[j];
2952
2953                         /* lfs only put one flag in each entry */
2954                         if ((flags && id != lod_comp->llc_id) ||
2955                             (mirror_flag && mirror_id !=
2956                                             mirror_id_of(lod_comp->llc_id)))
2957                                 continue;
2958
2959                         if (neg) {
2960                                 if (flags)
2961                                         lod_comp->llc_flags &= ~flags;
2962                                 if (mirror_flag)
2963                                         lod_comp->llc_flags &= ~mirror_flag;
2964                         } else {
2965                                 if (flags) {
2966                                         if ((flags & LCME_FL_STALE) &&
2967                                             lod_last_non_stale_mirror(mirror_id,
2968                                                                       lo)) {
2969                                                 mutex_unlock(
2970                                                         &lo->ldo_layout_mutex);
2971                                                 RETURN(-EUCLEAN);
2972                                         }
2973                                         lod_comp->llc_flags |= flags;
2974                                 }
2975                                 if (mirror_flag) {
2976                                         lod_comp->llc_flags |= mirror_flag;
2977                                         if (mirror_flag & LCME_FL_NOSYNC)
2978                                                 lod_comp->llc_timestamp =
2979                                                        ktime_get_real_seconds();
2980                                 }
2981                         }
2982                         changed = true;
2983                 }
2984         }
2985         mutex_unlock(&lo->ldo_layout_mutex);
2986
2987         if (!changed) {
2988                 CDEBUG(D_LAYOUT, "%s: requested component(s) not found.\n",
2989                        lod2obd(d)->obd_name);
2990                 RETURN(-EINVAL);
2991         }
2992
2993         lod_obj_inc_layout_gen(lo);
2994
2995         info->lti_buf.lb_len = lod_comp_md_size(lo, false);
2996         rc = lod_sub_declare_xattr_set(env, dt_object_child(dt), &info->lti_buf,
2997                                        XATTR_NAME_LOV, LU_XATTR_REPLACE, th);
2998         RETURN(rc);
2999 }
3000
3001 /**
3002  * Declare component deletion. The xattr name is XATTR_LUSTRE_LOV.del,
3003  * and the xattr value is a unique component ID or a special lcme_id.
3004  *
3005  * \param[in] env       execution environment
3006  * \param[in] dt        dt_object to be operated on
3007  * \param[in] buf       buffer contains component ID or lcme_id
3008  * \parem[in] th        thandle
3009  *
3010  * \retval      0 on success
3011  * \retval      negative errno on failure
3012  */
3013 static int lod_declare_layout_del(const struct lu_env *env,
3014                                   struct dt_object *dt,
3015                                   const struct lu_buf *buf,
3016                                   struct thandle *th)
3017 {
3018         struct lod_thread_info  *info = lod_env_info(env);
3019         struct dt_object *next = dt_object_child(dt);
3020         struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
3021         struct lod_object *lo = lod_dt_obj(dt);
3022         struct lu_attr *attr = &lod_env_info(env)->lti_attr;
3023         struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
3024         __u32 magic, id, flags, neg_flags = 0;
3025         int rc, i, j, left;
3026         ENTRY;
3027
3028         LASSERT(lo->ldo_is_composite);
3029
3030         if (lo->ldo_flr_state != LCM_FL_NONE)
3031                 RETURN(-EBUSY);
3032
3033         magic = comp_v1->lcm_magic;
3034         if (magic == __swab32(LOV_USER_MAGIC_COMP_V1)) {
3035                 lustre_swab_lov_comp_md_v1(comp_v1);
3036                 magic = comp_v1->lcm_magic;
3037         }
3038
3039         if (magic != LOV_USER_MAGIC_COMP_V1)
3040                 RETURN(-EINVAL);
3041
3042         id = comp_v1->lcm_entries[0].lcme_id;
3043         flags = comp_v1->lcm_entries[0].lcme_flags;
3044
3045         if (id > LCME_ID_MAX || (flags & ~LCME_KNOWN_FLAGS)) {
3046                 CDEBUG(D_LAYOUT, "%s: invalid component id %#x, flags %#x\n",
3047                        lod2obd(d)->obd_name, id, flags);
3048                 RETURN(-EINVAL);
3049         }
3050
3051         if (id != LCME_ID_INVAL && flags != 0) {
3052                 CDEBUG(D_LAYOUT, "%s: specified both id and flags.\n",
3053                        lod2obd(d)->obd_name);
3054                 RETURN(-EINVAL);
3055         }
3056
3057         if (id == LCME_ID_INVAL && !flags) {
3058                 CDEBUG(D_LAYOUT, "%s: no id or flags specified.\n",
3059                        lod2obd(d)->obd_name);
3060                 RETURN(-EINVAL);
3061         }
3062
3063         if (flags & LCME_FL_NEG) {
3064                 neg_flags = flags & ~LCME_FL_NEG;
3065                 flags = 0;
3066         }
3067
3068         mutex_lock(&lo->ldo_layout_mutex);
3069
3070         left = lo->ldo_comp_cnt;
3071         if (left <= 0) {
3072                 mutex_unlock(&lo->ldo_layout_mutex);
3073                 RETURN(-EINVAL);
3074         }
3075
3076         for (i = (lo->ldo_comp_cnt - 1); i >= 0; i--) {
3077                 struct lod_layout_component *lod_comp;
3078
3079                 lod_comp = &lo->ldo_comp_entries[i];
3080
3081                 if (id != LCME_ID_INVAL && id != lod_comp->llc_id)
3082                         continue;
3083                 else if (flags && !(flags & lod_comp->llc_flags))
3084                         continue;
3085                 else if (neg_flags && (neg_flags & lod_comp->llc_flags))
3086                         continue;
3087
3088                 if (left != (i + 1)) {
3089                         CDEBUG(D_LAYOUT, "%s: this deletion will create "
3090                                "a hole.\n", lod2obd(d)->obd_name);
3091                         mutex_unlock(&lo->ldo_layout_mutex);
3092                         RETURN(-EINVAL);
3093                 }
3094                 left--;
3095
3096                 /* Mark the component as deleted */
3097                 lod_comp->llc_id = LCME_ID_INVAL;
3098
3099                 /* Not instantiated component */
3100                 if (lod_comp->llc_stripe == NULL)
3101                         continue;
3102
3103                 LASSERT(lod_comp->llc_stripe_count > 0);
3104                 for (j = 0; j < lod_comp->llc_stripe_count; j++) {
3105                         struct dt_object *obj = lod_comp->llc_stripe[j];
3106
3107                         if (obj == NULL)
3108                                 continue;
3109                         rc = lod_sub_declare_destroy(env, obj, th);
3110                         if (rc) {
3111                                 mutex_unlock(&lo->ldo_layout_mutex);
3112                                 RETURN(rc);
3113                         }
3114                 }
3115         }
3116
3117         LASSERTF(left >= 0, "left = %d\n", left);
3118         if (left == lo->ldo_comp_cnt) {
3119                 CDEBUG(D_LAYOUT, "%s: requested component id:%#x not found\n",
3120                        lod2obd(d)->obd_name, id);
3121                 mutex_unlock(&lo->ldo_layout_mutex);
3122                 RETURN(-EINVAL);
3123         }
3124
3125         mutex_unlock(&lo->ldo_layout_mutex);
3126
3127         memset(attr, 0, sizeof(*attr));
3128         attr->la_valid = LA_SIZE;
3129         rc = lod_sub_declare_attr_set(env, next, attr, th);
3130         if (rc)
3131                 RETURN(rc);
3132
3133         if (left > 0) {
3134                 info->lti_buf.lb_len = lod_comp_md_size(lo, false);
3135                 rc = lod_sub_declare_xattr_set(env, next, &info->lti_buf,
3136                                                XATTR_NAME_LOV, 0, th);
3137         } else {
3138                 rc = lod_sub_declare_xattr_del(env, next, XATTR_NAME_LOV, th);
3139         }
3140
3141         RETURN(rc);
3142 }
3143
3144 /**
3145  * Declare layout add/set/del operations issued by special xattr names:
3146  *
3147  * XATTR_LUSTRE_LOV.add         add component(s) to existing file
3148  * XATTR_LUSTRE_LOV.del         delete component(s) from existing file
3149  * XATTR_LUSTRE_LOV.set.$field  set specified field of certain component(s)
3150  *
3151  * \param[in] env       execution environment
3152  * \param[in] dt        object
3153  * \param[in] name      name of xattr
3154  * \param[in] buf       lu_buf contains xattr value
3155  * \param[in] th        transaction handle
3156  *
3157  * \retval              0 on success
3158  * \retval              negative if failed
3159  */
3160 static int lod_declare_modify_layout(const struct lu_env *env,
3161                                      struct dt_object *dt,
3162                                      const char *name,
3163                                      const struct lu_buf *buf,
3164                                      struct thandle *th)
3165 {
3166         struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
3167         struct lod_object *lo = lod_dt_obj(dt);
3168         char *op;
3169         int rc, len = strlen(XATTR_LUSTRE_LOV);
3170         ENTRY;
3171
3172         LASSERT(dt_object_exists(dt));
3173
3174         if (strlen(name) <= len || name[len] != '.') {
3175                 CDEBUG(D_LAYOUT, "%s: invalid xattr name: %s\n",
3176                        lod2obd(d)->obd_name, name);
3177                 RETURN(-EINVAL);
3178         }
3179         len++;
3180
3181         rc = lod_striping_load(env, lo);
3182         if (rc)
3183                 GOTO(unlock, rc);
3184
3185         /* the layout to be modified must be a composite layout */
3186         if (!lo->ldo_is_composite) {
3187                 CDEBUG(D_LAYOUT, "%s: object "DFID" isn't a composite file.\n",
3188                        lod2obd(d)->obd_name, PFID(lu_object_fid(&dt->do_lu)));
3189                 GOTO(unlock, rc = -EINVAL);
3190         }
3191
3192         op = (char *)name + len;
3193         if (strcmp(op, "add") == 0) {
3194                 rc = lod_declare_layout_add(env, dt, buf, th);
3195         } else if (strcmp(op, "del") == 0) {
3196                 rc = lod_declare_layout_del(env, dt, buf, th);
3197         } else if (strncmp(op, "set", strlen("set")) == 0) {
3198                 rc = lod_declare_layout_set(env, dt, op, buf, th);
3199         } else  {
3200                 CDEBUG(D_LAYOUT, "%s: unsupported xattr name:%s\n",
3201                        lod2obd(d)->obd_name, name);
3202                 GOTO(unlock, rc = -ENOTSUPP);
3203         }
3204 unlock:
3205         if (rc)
3206                 lod_striping_free(env, lo);
3207
3208         RETURN(rc);
3209 }
3210
3211 /**
3212  * Convert a plain file lov_mds_md to a composite layout.
3213  *
3214  * \param[in,out] info  the thread info::lti_ea_store buffer contains little
3215  *                      endian plain file layout
3216  *
3217  * \retval              0 on success, <0 on failure
3218  */
3219 static int lod_layout_convert(struct lod_thread_info *info)
3220 {
3221         struct lov_mds_md *lmm = info->lti_ea_store;
3222         struct lov_mds_md *lmm_save;
3223         struct lov_comp_md_v1 *lcm;
3224         struct lov_comp_md_entry_v1 *lcme;
3225         size_t size;
3226         __u32 blob_size;
3227         int rc = 0;
3228         ENTRY;
3229
3230         /* realloc buffer to a composite layout which contains one component */
3231         blob_size = lov_mds_md_size(le16_to_cpu(lmm->lmm_stripe_count),
3232                                     le32_to_cpu(lmm->lmm_magic));
3233         size = sizeof(*lcm) + sizeof(*lcme) + blob_size;
3234
3235         OBD_ALLOC_LARGE(lmm_save, blob_size);
3236         if (!lmm_save)
3237                 GOTO(out, rc = -ENOMEM);
3238
3239         memcpy(lmm_save, lmm, blob_size);
3240
3241         if (info->lti_ea_store_size < size) {
3242                 rc = lod_ea_store_resize(info, size);
3243                 if (rc)
3244                         GOTO(out, rc);
3245         }
3246
3247         lcm = info->lti_ea_store;
3248         memset(lcm, 0, sizeof(*lcm) + sizeof(*lcme));
3249         lcm->lcm_magic = cpu_to_le32(LOV_MAGIC_COMP_V1);
3250         lcm->lcm_size = cpu_to_le32(size);
3251         lcm->lcm_layout_gen = cpu_to_le32(le16_to_cpu(
3252                                                 lmm_save->lmm_layout_gen));
3253         lcm->lcm_flags = cpu_to_le16(LCM_FL_NONE);
3254         lcm->lcm_entry_count = cpu_to_le16(1);
3255
3256         lcme = &lcm->lcm_entries[0];
3257         lcme->lcme_flags = cpu_to_le32(LCME_FL_INIT);
3258         lcme->lcme_extent.e_start = 0;
3259         lcme->lcme_extent.e_end = cpu_to_le64(OBD_OBJECT_EOF);
3260         lcme->lcme_offset = cpu_to_le32(sizeof(*lcm) + sizeof(*lcme));
3261         lcme->lcme_size = cpu_to_le32(blob_size);
3262
3263         memcpy((char *)lcm + lcme->lcme_offset, (char *)lmm_save, blob_size);
3264
3265         EXIT;
3266 out:
3267         if (lmm_save)
3268                 OBD_FREE_LARGE(lmm_save, blob_size);
3269         return rc;
3270 }
3271
3272 /**
3273  * Merge layouts to form a mirrored file.
3274  */
3275 static int lod_declare_layout_merge(const struct lu_env *env,
3276                 struct dt_object *dt, const struct lu_buf *mbuf,
3277                 struct thandle *th)
3278 {
3279         struct lod_thread_info *info = lod_env_info(env);
3280         struct lu_attr *layout_attr = &info->lti_layout_attr;
3281         struct lu_buf *buf = &info->lti_buf;
3282         struct lod_object *lo = lod_dt_obj(dt);
3283         struct lov_comp_md_v1 *lcm;
3284         struct lov_comp_md_v1 *cur_lcm;
3285         struct lov_comp_md_v1 *merge_lcm;
3286         struct lov_comp_md_entry_v1 *lcme;
3287         struct lov_mds_md_v1 *lmm;
3288         size_t size = 0;
3289         size_t offset;
3290         __u16 cur_entry_count;
3291         __u16 merge_entry_count;
3292         __u32 id = 0;
3293         __u16 mirror_id = 0;
3294         __u32 mirror_count;
3295         int rc, i;
3296         bool merge_has_dom;
3297
3298         ENTRY;
3299
3300         merge_lcm = mbuf->lb_buf;
3301         if (mbuf->lb_len < sizeof(*merge_lcm))
3302                 RETURN(-EINVAL);
3303
3304         /* must be an existing layout from disk */
3305         if (le32_to_cpu(merge_lcm->lcm_magic) != LOV_MAGIC_COMP_V1)
3306                 RETURN(-EINVAL);
3307
3308         merge_entry_count = le16_to_cpu(merge_lcm->lcm_entry_count);
3309
3310         /* do not allow to merge two mirrored files */
3311         if (le16_to_cpu(merge_lcm->lcm_mirror_count))
3312                 RETURN(-EBUSY);
3313
3314         /* verify the target buffer */
3315         rc = lod_get_lov_ea(env, lo);
3316         if (rc <= 0)
3317                 RETURN(rc ? : -ENODATA);
3318
3319         cur_lcm = info->lti_ea_store;
3320         switch (le32_to_cpu(cur_lcm->lcm_magic)) {
3321         case LOV_MAGIC_V1:
3322         case LOV_MAGIC_V3:
3323                 rc = lod_layout_convert(info);
3324                 break;
3325         case LOV_MAGIC_COMP_V1:
3326         case LOV_MAGIC_SEL:
3327                 rc = 0;
3328                 break;
3329         default:
3330                 rc = -EINVAL;
3331         }
3332         if (rc)
3333                 RETURN(rc);
3334
3335         /* info->lti_ea_store could be reallocated in lod_layout_convert() */
3336         cur_lcm = info->lti_ea_store;
3337         cur_entry_count = le16_to_cpu(cur_lcm->lcm_entry_count);
3338
3339         /* 'lcm_mirror_count + 1' is the current # of mirrors the file has */
3340         mirror_count = le16_to_cpu(cur_lcm->lcm_mirror_count) + 1;
3341         if (mirror_count + 1 > LUSTRE_MIRROR_COUNT_MAX)
3342                 RETURN(-ERANGE);
3343
3344         /* size of new layout */
3345         size = le32_to_cpu(cur_lcm->lcm_size) +
3346                le32_to_cpu(merge_lcm->lcm_size) - sizeof(*cur_lcm);
3347
3348         memset(buf, 0, sizeof(*buf));
3349         lu_buf_alloc(buf, size);
3350         if (buf->lb_buf == NULL)
3351                 RETURN(-ENOMEM);
3352
3353         lcm = buf->lb_buf;
3354         memcpy(lcm, cur_lcm, sizeof(*lcm) + cur_entry_count * sizeof(*lcme));
3355
3356         offset = sizeof(*lcm) +
3357                  sizeof(*lcme) * (cur_entry_count + merge_entry_count);
3358         for (i = 0; i < cur_entry_count; i++) {
3359                 struct lov_comp_md_entry_v1 *cur_lcme;
3360
3361                 lcme = &lcm->lcm_entries[i];
3362                 cur_lcme = &cur_lcm->lcm_entries[i];
3363
3364                 lcme->lcme_offset = cpu_to_le32(offset);
3365                 memcpy((char *)lcm + offset,
3366                        (char *)cur_lcm + le32_to_cpu(cur_lcme->lcme_offset),
3367                        le32_to_cpu(lcme->lcme_size));
3368
3369                 offset += le32_to_cpu(lcme->lcme_size);
3370
3371                 if (mirror_count == 1 &&
3372                     mirror_id_of(le32_to_cpu(lcme->lcme_id)) == 0) {
3373                         /* Add mirror from a non-flr file, create new mirror ID.
3374                          * Otherwise, keep existing mirror's component ID, used
3375                          * for mirror extension.
3376                          */
3377                         id = pflr_id(1, i + 1);
3378                         lcme->lcme_id = cpu_to_le32(id);
3379                 }
3380
3381                 id = max(le32_to_cpu(lcme->lcme_id), id);
3382         }
3383
3384         mirror_id = mirror_id_of(id) + 1;
3385
3386         /* check if first entry in new layout is DOM */
3387         lmm = (struct lov_mds_md_v1 *)((char *)merge_lcm +
3388                                         merge_lcm->lcm_entries[0].lcme_offset);
3389         merge_has_dom = lov_pattern(le32_to_cpu(lmm->lmm_pattern)) ==
3390                         LOV_PATTERN_MDT;
3391
3392         for (i = 0; i < merge_entry_count; i++) {
3393                 struct lov_comp_md_entry_v1 *merge_lcme;
3394
3395                 merge_lcme = &merge_lcm->lcm_entries[i];
3396                 lcme = &lcm->lcm_entries[cur_entry_count + i];
3397
3398                 *lcme = *merge_lcme;
3399                 lcme->lcme_offset = cpu_to_le32(offset);
3400                 if (merge_has_dom && i == 0)
3401                         lcme->lcme_flags |= cpu_to_le32(LCME_FL_STALE);
3402
3403                 id = pflr_id(mirror_id, i + 1);
3404                 lcme->lcme_id = cpu_to_le32(id);
3405
3406                 memcpy((char *)lcm + offset,
3407                        (char *)merge_lcm + le32_to_cpu(merge_lcme->lcme_offset),
3408                        le32_to_cpu(lcme->lcme_size));
3409
3410                 offset += le32_to_cpu(lcme->lcme_size);
3411         }
3412
3413         /* fixup layout information */
3414         lcm->lcm_size = cpu_to_le32(size);
3415         lcm->lcm_entry_count = cpu_to_le16(cur_entry_count + merge_entry_count);
3416         lcm->lcm_mirror_count = cpu_to_le16(mirror_count);
3417         if ((le16_to_cpu(lcm->lcm_flags) & LCM_FL_FLR_MASK) == LCM_FL_NONE)
3418                 lcm->lcm_flags = cpu_to_le32(LCM_FL_RDONLY);
3419
3420         rc = lod_striping_reload(env, lo, buf, 0);
3421         if (rc)
3422                 GOTO(out, rc);
3423
3424         lod_obj_inc_layout_gen(lo);
3425         lcm->lcm_layout_gen = cpu_to_le32(lo->ldo_layout_gen);
3426
3427         /* transfer layout version to OST objects. */
3428         if (lo->ldo_mirror_count > 1) {
3429                 struct lod_obj_stripe_cb_data data = { {0} };
3430
3431                 layout_attr->la_valid = LA_LAYOUT_VERSION;
3432                 layout_attr->la_layout_version = 0;
3433                 data.locd_attr = layout_attr;
3434                 data.locd_declare = true;
3435                 data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
3436                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
3437                 if (rc)
3438                         GOTO(out, rc);
3439         }
3440
3441         rc = lod_sub_declare_xattr_set(env, dt_object_child(dt), buf,
3442                                         XATTR_NAME_LOV, LU_XATTR_REPLACE, th);
3443
3444 out:
3445         lu_buf_free(buf);
3446         RETURN(rc);
3447 }
3448
3449 /**
3450  * Split layouts, just set the LOVEA with the layout from mbuf.
3451  */
3452 static int lod_declare_layout_split(const struct lu_env *env,
3453                 struct dt_object *dt, const struct lu_buf *mbuf,
3454                 struct thandle *th)
3455 {
3456         struct lod_thread_info *info = lod_env_info(env);
3457         struct lu_attr *layout_attr = &info->lti_layout_attr;
3458         struct lod_object *lo = lod_dt_obj(dt);
3459         struct lov_comp_md_v1 *lcm = mbuf->lb_buf;
3460         int rc;
3461         ENTRY;
3462
3463         rc = lod_striping_reload(env, lo, mbuf, LVF_ALL_STALE);
3464         if (rc)
3465                 RETURN(rc);
3466
3467         lod_obj_inc_layout_gen(lo);
3468         /* fix on-disk layout gen */
3469         lcm->lcm_layout_gen = cpu_to_le32(lo->ldo_layout_gen);
3470
3471         /* transfer layout version to OST objects. */
3472         if (lo->ldo_mirror_count > 1) {
3473                 struct lod_obj_stripe_cb_data data = { {0} };
3474
3475                 layout_attr->la_valid = LA_LAYOUT_VERSION;
3476                 layout_attr->la_layout_version = 0;
3477                 data.locd_attr = layout_attr;
3478                 data.locd_declare = true;
3479                 data.locd_stripe_cb = lod_obj_stripe_attr_set_cb;
3480                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
3481                 if (rc)
3482                         RETURN(rc);
3483         }
3484
3485         rc = lod_sub_declare_xattr_set(env, dt_object_child(dt), mbuf,
3486                                        XATTR_NAME_LOV, LU_XATTR_REPLACE, th);
3487         RETURN(rc);
3488 }
3489
3490 static int lod_layout_declare_or_purge_mirror(const struct lu_env *env,
3491                         struct dt_object *dt, const struct lu_buf *buf,
3492                         struct thandle *th, bool declare)
3493 {
3494         struct lod_thread_info *info = lod_env_info(env);
3495         struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
3496         struct lod_object *lo = lod_dt_obj(dt);
3497         struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
3498         struct lov_comp_md_entry_v1 *entry;
3499         struct lov_mds_md_v1 *lmm;
3500         struct dt_object **sub_objs = NULL;
3501         int rc = 0, i, k, array_count = 0;
3502
3503         ENTRY;
3504
3505         /**
3506          * other ops (like lod_declare_destroy) could destroying sub objects
3507          * as well.
3508          */
3509         mutex_lock(&lo->ldo_layout_mutex);
3510
3511         if (!declare) {
3512                 /* prepare sub-objects array */
3513                 for (i = 0; i < comp_v1->lcm_entry_count; i++) {
3514                         entry = &comp_v1->lcm_entries[i];
3515
3516                         if (!(entry->lcme_flags & LCME_FL_INIT))
3517                                 continue;
3518
3519                         lmm = (struct lov_mds_md_v1 *)
3520                                         ((char *)comp_v1 + entry->lcme_offset);
3521                         array_count += lmm->lmm_stripe_count;
3522                 }
3523                 OBD_ALLOC_PTR_ARRAY(sub_objs, array_count);
3524                 if (sub_objs == NULL) {
3525                         mutex_unlock(&lo->ldo_layout_mutex);
3526                         RETURN(-ENOMEM);
3527                 }
3528         }
3529
3530         k = 0;  /* sub_objs index */
3531         for (i = 0; i < comp_v1->lcm_entry_count; i++) {
3532                 struct lov_ost_data_v1 *objs;
3533                 struct lu_object *o, *n;
3534                 struct dt_object *dto;
3535                 struct lu_device *nd;
3536                 struct lov_mds_md_v3 *v3;
3537                 __u32 idx;
3538                 int j;
3539
3540                 entry = &comp_v1->lcm_entries[i];
3541
3542                 if (!(entry->lcme_flags & LCME_FL_INIT))
3543                         continue;
3544
3545                 lmm = (struct lov_mds_md_v1 *)
3546                                 ((char *)comp_v1 + entry->lcme_offset);
3547                 v3 = (struct lov_mds_md_v3 *)lmm;
3548                 if (lmm->lmm_magic == LOV_MAGIC_V3)
3549                         objs = &v3->lmm_objects[0];
3550                 else
3551                         objs = &lmm->lmm_objects[0];
3552
3553                 for (j = 0; j < lmm->lmm_stripe_count; j++) {
3554                         idx = objs[j].l_ost_idx;
3555                         rc = ostid_to_fid(&info->lti_fid, &objs[j].l_ost_oi,
3556                                           idx);
3557                         if (rc)
3558                                 GOTO(out, rc);
3559
3560                         if (!fid_is_sane(&info->lti_fid)) {
3561                                 CERROR("%s: sub-object insane fid "DFID"\n",
3562                                        lod2obd(d)->obd_name,
3563                                        PFID(&info->lti_fid));
3564                                 GOTO(out, rc = -EINVAL);
3565                         }
3566
3567                         lod_getref(&d->lod_ost_descs);
3568
3569                         rc = validate_lod_and_idx(d, idx);
3570                         if (unlikely(rc)) {
3571                                 lod_putref(d, &d->lod_ost_descs);
3572                                 GOTO(out, rc);
3573                         }
3574
3575                         nd = &OST_TGT(d, idx)->ltd_tgt->dd_lu_dev;
3576                         lod_putref(d, &d->lod_ost_descs);
3577
3578                         o = lu_object_find_at(env, nd, &info->lti_fid, NULL);
3579                         if (IS_ERR(o))
3580                                 GOTO(out, rc = PTR_ERR(o));
3581
3582                         n = lu_object_locate(o->lo_header, nd->ld_type);
3583                         if (unlikely(!n)) {
3584                                 lu_object_put(env, n);
3585                                 GOTO(out, rc = -ENOENT);
3586                         }
3587
3588                         dto = container_of(n, struct dt_object, do_lu);
3589
3590                         if (declare) {
3591                                 rc = lod_sub_declare_destroy(env, dto, th);
3592                                 dt_object_put(env, dto);
3593                                 if (rc)
3594                                         GOTO(out, rc);
3595                         } else {
3596                                 /**
3597                                  * collect to-be-destroyed sub objects, the
3598                                  * reference would be released after actual
3599                                  * deletion.
3600                                  */
3601                                 sub_objs[k] = dto;
3602                                 k++;
3603                         }
3604                 } /* for each stripe */
3605         } /* for each component in the mirror */
3606 out:
3607         if (!declare) {
3608                 i = 0;
3609                 if (!rc) {
3610                         /* destroy the sub objects */
3611                         for (; i < k; i++) {
3612                                 rc = lod_sub_destroy(env, sub_objs[i], th);
3613                                 if (rc)
3614                                         break;
3615                                 dt_object_put(env, sub_objs[i]);
3616                         }
3617                 }
3618                 /**
3619                  * if a sub object destroy failed, we'd release sub objects
3620                  * reference get from above sub_objs collection.
3621                  */
3622                 for (; i < k; i++)
3623                         dt_object_put(env, sub_objs[i]);
3624
3625                 OBD_FREE_PTR_ARRAY(sub_objs, array_count);
3626         }
3627         mutex_unlock(&lo->ldo_layout_mutex);
3628
3629         RETURN(rc);
3630 }
3631
3632 /**
3633  * Purge layouts, delete sub objects in the mirror stored in the vic_buf,
3634  * and set the LOVEA with the layout from mbuf.
3635  */
3636 static int lod_declare_layout_purge(const struct lu_env *env,
3637                 struct dt_object *dt, const struct lu_buf *buf,
3638                 struct thandle *th)
3639 {
3640         struct lod_device *d = lu2lod_dev(dt->do_lu.lo_dev);
3641         struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
3642         int rc;
3643
3644         ENTRY;
3645
3646         if (le32_to_cpu(comp_v1->lcm_magic) != LOV_MAGIC_COMP_V1) {
3647                 CERROR("%s: invalid layout magic %#x != %#x\n",
3648                        lod2obd(d)->obd_name, le32_to_cpu(comp_v1->lcm_magic),
3649                        LOV_MAGIC_COMP_V1);
3650                 RETURN(-EINVAL);
3651         }
3652
3653         if (cpu_to_le32(LOV_MAGIC_COMP_V1) != LOV_MAGIC_COMP_V1)
3654                 lustre_swab_lov_comp_md_v1(comp_v1);
3655
3656         /* from now on, @buf contains cpu endian data */
3657
3658         if (comp_v1->lcm_mirror_count != 0) {
3659                 CERROR("%s: can only purge one mirror from "DFID"\n",
3660                        lod2obd(d)->obd_name, PFID(lu_object_fid(&dt->do_lu)));
3661                 RETURN(-EINVAL);
3662         }
3663
3664         /* delcare sub objects deletion in the mirror stored in @buf */
3665         rc = lod_layout_declare_or_purge_mirror(env, dt, buf, th, true);
3666         RETURN(rc);
3667 }
3668
3669 /* delete sub objects from the mirror stored in @buf */
3670 static int lod_layout_purge(const struct lu_env *env, struct dt_object *dt,
3671                             const struct lu_buf *buf, struct thandle *th)
3672 {
3673         int rc;
3674
3675         ENTRY;
3676         rc = lod_layout_declare_or_purge_mirror(env, dt, buf, th, false);
3677         RETURN(rc);
3678 }
3679
3680 /**
3681  * Implementation of dt_object_operations::do_declare_xattr_set.
3682  *
3683  * \see dt_object_operations::do_declare_xattr_set() in the API description
3684  * for details.
3685  *
3686  * the extension to the API:
3687  *   - declaring LOVEA requests striping creation
3688  *   - LU_XATTR_REPLACE means layout swap
3689  */
3690 static int lod_declare_xattr_set(const struct lu_env *env,
3691                                  struct dt_object *dt,
3692                                  const struct lu_buf *buf,
3693                                  const char *name, int fl,
3694                                  struct thandle *th)
3695 {
3696         struct dt_object *next = dt_object_child(dt);
3697         struct lu_attr   *attr = &lod_env_info(env)->lti_attr;
3698         __u32             mode;
3699         int               rc;
3700         ENTRY;
3701
3702         mode = dt->do_lu.lo_header->loh_attr & S_IFMT;
3703         if ((S_ISREG(mode) || mode == 0) &&
3704             !(fl & (LU_XATTR_REPLACE | LU_XATTR_MERGE | LU_XATTR_SPLIT |
3705                     LU_XATTR_PURGE)) &&
3706             (strcmp(name, XATTR_NAME_LOV) == 0 ||
3707              strcmp(name, XATTR_LUSTRE_LOV) == 0)) {
3708                 /*
3709                  * this is a request to create object's striping.
3710                  *
3711                  * allow to declare predefined striping on a new (!mode) object
3712                  * which is supposed to be replay of regular file creation
3713                  * (when LOV setting is declared)
3714                  *
3715                  * LU_XATTR_REPLACE is set to indicate a layout swap
3716                  */
3717                 if (dt_object_exists(dt)) {
3718                         rc = dt_attr_get(env, next, attr);
3719                         if (rc)
3720                                 RETURN(rc);
3721                 } else {
3722                         memset(attr, 0, sizeof(*attr));
3723                         attr->la_valid = LA_TYPE | LA_MODE;
3724                         attr->la_mode = S_IFREG;
3725                 }
3726                 rc = lod_declare_striped_create(env, dt, attr, buf, th);
3727         } else if (fl & LU_XATTR_MERGE) {
3728                 LASSERT(strcmp(name, XATTR_NAME_LOV) == 0 ||
3729                         strcmp(name, XATTR_LUSTRE_LOV) == 0);
3730                 rc = lod_declare_layout_merge(env, dt, buf, th);
3731         } else if (fl & LU_XATTR_SPLIT) {
3732                 LASSERT(strcmp(name, XATTR_NAME_LOV) == 0 ||
3733                         strcmp(name, XATTR_LUSTRE_LOV) == 0);
3734                 rc = lod_declare_layout_split(env, dt, buf, th);
3735         } else if (fl & LU_XATTR_PURGE) {
3736                 LASSERT(strcmp(name, XATTR_NAME_LOV) == 0 ||
3737                         strcmp(name, XATTR_LUSTRE_LOV) == 0);
3738                 rc = lod_declare_layout_purge(env, dt, buf, th);
3739         } else if (S_ISREG(mode) &&
3740                    strlen(name) >= sizeof(XATTR_LUSTRE_LOV) + 3 &&
3741                    allowed_lustre_lov(name)) {
3742                 /*
3743                  * this is a request to modify object's striping.
3744                  * add/set/del component(s).
3745                  */
3746                 if (!dt_object_exists(dt))
3747                         RETURN(-ENOENT);
3748
3749                 rc = lod_declare_modify_layout(env, dt, name, buf, th);
3750         } else if (S_ISDIR(mode)) {
3751                 rc = lod_dir_declare_xattr_set(env, dt, buf, name, fl, th);
3752         } else if (strcmp(name, XATTR_NAME_FID) == 0) {
3753                 rc = lod_replace_parent_fid(env, dt, buf, th, true);
3754         } else {
3755                 rc = lod_sub_declare_xattr_set(env, next, buf, name, fl, th);
3756         }
3757
3758         RETURN(rc);
3759 }
3760
3761 /**
3762  * Apply xattr changes to the object.
3763  *
3764  * Applies xattr changes to the object and the stripes if the latter exist.
3765  *
3766  * \param[in] env       execution environment
3767  * \param[in] dt        object
3768  * \param[in] buf       buffer pointing to the new value of xattr
3769  * \param[in] name      name of xattr
3770  * \param[in] fl        flags
3771  * \param[in] th        transaction handle
3772  *
3773  * \retval              0 on success
3774  * \retval              negative if failed
3775  */
3776 static int lod_xattr_set_internal(const struct lu_env *env,
3777                                   struct dt_object *dt,
3778                                   const struct lu_buf *buf,
3779                                   const char *name, int fl,
3780                                   struct thandle *th)
3781 {
3782         struct dt_object        *next = dt_object_child(dt);
3783         struct lod_object       *lo = lod_dt_obj(dt);
3784         int                     rc;
3785         int                     i;
3786         ENTRY;
3787
3788         rc = lod_sub_xattr_set(env, next, buf, name, fl, th);
3789         if (rc != 0 || !S_ISDIR(dt->do_lu.lo_header->loh_attr))
3790                 RETURN(rc);
3791
3792         /* Note: Do not set LinkEA on sub-stripes, otherwise
3793          * it will confuse the fid2path process(see mdt_path_current()).
3794          * The linkEA between master and sub-stripes is set in
3795          * lod_xattr_set_lmv(). */
3796         if (lo->ldo_dir_stripe_count == 0 || strcmp(name, XATTR_NAME_LINK) == 0)
3797                 RETURN(0);
3798
3799         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
3800                 if (!lo->ldo_stripe[i])
3801                         continue;
3802
3803                 if (!dt_object_exists(lo->ldo_stripe[i]))
3804                         continue;
3805
3806                 rc = lod_sub_xattr_set(env, lo->ldo_stripe[i], buf, name,
3807                                        fl, th);
3808                 if (rc != 0)
3809                         break;
3810         }
3811
3812         RETURN(rc);
3813 }
3814
3815 /**
3816  * Delete an extended attribute.
3817  *
3818  * Deletes specified xattr from the object and the stripes if the latter exist.
3819  *
3820  * \param[in] env       execution environment
3821  * \param[in] dt        object
3822  * \param[in] name      name of xattr
3823  * \param[in] th        transaction handle
3824  *
3825  * \retval              0 on success
3826  * \retval              negative if failed
3827  */
3828 static int lod_xattr_del_internal(const struct lu_env *env,
3829                                   struct dt_object *dt,
3830                                   const char *name, struct thandle *th)
3831 {
3832         struct dt_object *next = dt_object_child(dt);
3833         struct lod_object *lo = lod_dt_obj(dt);
3834         int i;
3835         int rc;
3836
3837         ENTRY;
3838
3839         rc = lod_sub_xattr_del(env, next, name, th);
3840         if (rc != 0 || !S_ISDIR(dt->do_lu.lo_header->loh_attr))
3841                 RETURN(rc);
3842
3843         if (lo->ldo_dir_stripe_count == 0)
3844                 RETURN(rc);
3845
3846         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
3847                 if (!lo->ldo_stripe[i])
3848                         continue;
3849
3850                 if (!dt_object_exists(lo->ldo_stripe[i]))
3851                         continue;
3852
3853                 rc = lod_sub_xattr_del(env, lo->ldo_stripe[i], name, th);
3854                 if (rc != 0)
3855                         break;
3856         }
3857
3858         RETURN(rc);
3859 }
3860
3861 /**
3862  * Set default striping on a directory.
3863  *
3864  * Sets specified striping on a directory object unless it matches the default
3865  * striping (LOVEA_DELETE_VALUES() macro). In the latter case remove existing
3866  * EA. This striping will be used when regular file is being created in this
3867  * directory.
3868  *
3869  * \param[in] env       execution environment
3870  * \param[in] dt        the striped object
3871  * \param[in] buf       buffer with the striping
3872  * \param[in] name      name of EA
3873  * \param[in] fl        xattr flag (see OSD API description)
3874  * \param[in] th        transaction handle
3875  *
3876  * \retval              0 on success
3877  * \retval              negative if failed
3878  */
3879 static int lod_xattr_set_lov_on_dir(const struct lu_env *env,
3880                                     struct dt_object *dt,
3881                                     const struct lu_buf *buf,
3882                                     const char *name, int fl,
3883                                     struct thandle *th)
3884 {
3885         struct lov_user_md_v1   *lum;
3886         struct lov_user_md_v3   *v3 = NULL;
3887         const char              *pool_name = NULL;
3888         int                      rc;
3889         bool                     is_del;
3890         ENTRY;
3891
3892         LASSERT(buf != NULL && buf->lb_buf != NULL);
3893         lum = buf->lb_buf;
3894
3895         switch (lum->lmm_magic) {
3896         case LOV_USER_MAGIC_SPECIFIC:
3897         case LOV_USER_MAGIC_V3:
3898                 v3 = buf->lb_buf;
3899                 if (lov_pool_is_reserved(v3->lmm_pool_name))
3900                         memset(v3->lmm_pool_name, 0, sizeof(v3->lmm_pool_name));
3901                 else if (v3->lmm_pool_name[0] != '\0')
3902                         pool_name = v3->lmm_pool_name;
3903                 fallthrough;
3904         case LOV_USER_MAGIC_V1:
3905                 /* if { size, offset, count } = { 0, -1, 0 } and no pool
3906                  * (i.e. all default values specified) then delete default
3907                  * striping from dir. */
3908                 CDEBUG(D_LAYOUT,
3909                        "set default striping: sz %u # %u offset %d %s %s\n",
3910                        (unsigned)lum->lmm_stripe_size,
3911                        (unsigned)lum->lmm_stripe_count,
3912                        (int)lum->lmm_stripe_offset,
3913                        v3 ? "from" : "", v3 ? v3->lmm_pool_name : "");
3914
3915                 is_del = LOVEA_DELETE_VALUES(lum->lmm_stripe_size,
3916                                              lum->lmm_stripe_count,
3917                                              lum->lmm_stripe_offset,
3918                                              pool_name);
3919                 break;
3920         case LOV_USER_MAGIC_COMP_V1:
3921         {
3922                 struct lov_comp_md_v1 *lcm = (struct lov_comp_md_v1 *)lum;
3923                 struct lov_comp_md_entry_v1 *lcme;
3924                 int i, comp_cnt;
3925
3926                 comp_cnt = le16_to_cpu(lcm->lcm_entry_count);
3927                 for (i = 0; i < comp_cnt; i++) {
3928                         lcme = &lcm->lcm_entries[i];
3929                         if (lcme->lcme_flags & cpu_to_le32(LCME_FL_EXTENSION)) {
3930                                 lcm->lcm_magic = cpu_to_le32(LOV_MAGIC_SEL);
3931                                 break;
3932                         }
3933                 }
3934
3935                 is_del = false;
3936                 break;
3937         }
3938         default:
3939                 CERROR("Invalid magic %x\n", lum->lmm_magic);
3940                 RETURN(-EINVAL);
3941         }
3942
3943         if (is_del) {
3944                 rc = lod_xattr_del_internal(env, dt, name, th);
3945                 if (rc == -ENODATA)
3946                         rc = 0;
3947         } else {
3948                 rc = lod_xattr_set_internal(env, dt, buf, name, fl, th);
3949         }
3950
3951         RETURN(rc);
3952 }
3953
3954 static int lod_get_default_lov_striping(const struct lu_env *env,
3955                                        struct lod_object *lo,
3956                                        struct lod_default_striping *lds,
3957                                        struct dt_allocation_hint *ah);
3958
3959 /**
3960  * Helper function to convert compound layout to compound layout with
3961  * pool
3962  *
3963  * Copy lcm_entries array of \a src to \a tgt. Replace lov_user_md_v1
3964  * components of \a src with lov_user_md_v3 using \a pool.
3965  *
3966  * \param[in] src       source layout
3967  * \param[in] pool      pool to use in \a tgt
3968  * \param[out] tgt      target layout
3969  */
3970 static void embed_pool_to_comp_v1(const struct lov_comp_md_v1 *src,
3971                                   const char *pool,
3972                                   struct lov_comp_md_v1 *tgt)
3973 {
3974         size_t shift;
3975         struct lov_user_md_v1 *lum;
3976         struct lov_user_md_v3 *lum3;
3977         struct lov_comp_md_entry_v1 *entry;
3978         int i;
3979         __u32 offset;
3980
3981         entry = tgt->lcm_entries;
3982         shift = 0;
3983         for (i = 0; i < le16_to_cpu(src->lcm_entry_count); i++, entry++) {
3984                 *entry = src->lcm_entries[i];
3985                 offset = le32_to_cpu(src->lcm_entries[i].lcme_offset);
3986                 entry->lcme_offset = cpu_to_le32(offset + shift);
3987
3988                 lum = (struct lov_user_md_v1 *)((char *)src + offset);
3989                 lum3 = (struct lov_user_md_v3 *)((char *)tgt + offset + shift);
3990                 *(struct lov_user_md_v1 *)lum3 = *lum;
3991                 if (lum->lmm_pattern == cpu_to_le32(LOV_PATTERN_MDT)) {
3992                         lum3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
3993                 } else {
3994                         lum3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
3995                         entry->lcme_size = cpu_to_le32(sizeof(*lum3));
3996                         strlcpy(lum3->lmm_pool_name, pool,
3997                                 sizeof(lum3->lmm_pool_name));
3998                         shift += sizeof(*lum3) - sizeof(*lum);
3999                 }
4000         }
4001 }
4002
4003 /**
4004  * Set default striping on a directory.
4005  *
4006  * Sets specified striping on a directory object unless it matches the default
4007  * striping (LOVEA_DELETE_VALUES() macro). In the latter case remove existing
4008  * EA. This striping will be used when regular file is being created in this
4009  * directory.
4010  * If current default striping includes a pool but specifed striping
4011  * does not - retain the pool if it exists.
4012  *
4013  * \param[in] env       execution environment
4014  * \param[in] dt        the striped object
4015  * \param[in] buf       buffer with the striping
4016  * \param[in] name      name of EA
4017  * \param[in] fl        xattr flag (see OSD API description)
4018  * \param[in] th        transaction handle
4019  *
4020  * \retval              0 on success
4021  * \retval              negative if failed
4022  */
4023 static int lod_xattr_set_default_lov_on_dir(const struct lu_env *env,
4024                                             struct dt_object *dt,
4025                                             const struct lu_buf *buf,
4026                                             const char *name, int fl,
4027                                             struct thandle *th)
4028 {
4029         struct lod_default_striping     *lds = lod_lds_buf_get(env);
4030         struct lov_user_md_v1           *v1 = buf->lb_buf;
4031         char                             pool[LOV_MAXPOOLNAME + 1];
4032         bool                             is_del;
4033         int                              rc;
4034
4035         ENTRY;
4036
4037         /* get existing striping config */
4038         rc = lod_get_default_lov_striping(env, lod_dt_obj(dt), lds, NULL);
4039         if (rc)
4040                 RETURN(rc);
4041
4042         memset(pool, 0, sizeof(pool));
4043         if (lds->lds_def_striping_set == 1)
4044                 lod_layout_get_pool(lds->lds_def_comp_entries,
4045                                     lds->lds_def_comp_cnt, pool,
4046                                     sizeof(pool));
4047
4048         is_del = LOVEA_DELETE_VALUES(v1->lmm_stripe_size,
4049                                      v1->lmm_stripe_count,
4050                                      v1->lmm_stripe_offset,
4051                                      NULL);
4052
4053         /* Retain the pool name if it is not given */
4054         if (v1->lmm_magic == LOV_USER_MAGIC_V1 && pool[0] != '\0' &&
4055             !is_del) {
4056                 struct lod_thread_info *info = lod_env_info(env);
4057                 struct lov_user_md_v3 *v3  = info->lti_ea_store;
4058
4059                 memset(v3, 0, sizeof(*v3));
4060                 v3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
4061                 v3->lmm_pattern = cpu_to_le32(v1->lmm_pattern);
4062                 v3->lmm_stripe_count = cpu_to_le32(v1->lmm_stripe_count);
4063                 v3->lmm_stripe_offset = cpu_to_le32(v1->lmm_stripe_offset);
4064                 v3->lmm_stripe_size = cpu_to_le32(v1->lmm_stripe_size);
4065
4066                 strlcpy(v3->lmm_pool_name, pool, sizeof(v3->lmm_pool_name));
4067
4068                 info->lti_buf.lb_buf = v3;
4069                 info->lti_buf.lb_len = sizeof(*v3);
4070                 rc = lod_xattr_set_lov_on_dir(env, dt, &info->lti_buf,
4071                                               name, fl, th);
4072         } else if (v1->lmm_magic == LOV_USER_MAGIC_COMP_V1 &&
4073                    pool[0] != '\0' && !is_del) {
4074                 /*
4075                  * try to retain the pool from default layout if the
4076                  * specified component layout does not provide pool
4077                  * info explicitly
4078                  */
4079                 struct lod_thread_info *info = lod_env_info(env);
4080                 struct lov_comp_md_v1 *comp_v1 = buf->lb_buf;
4081                 struct lov_comp_md_v1 *comp_v1p;
4082                 struct lov_user_md_v1 *lum;
4083                 int entry_count;
4084                 int i;
4085                 __u32 offset;
4086                 struct lov_comp_md_entry_v1 *entry;
4087                 int size;
4088
4089                 entry_count = le16_to_cpu(comp_v1->lcm_entry_count);
4090                 size = sizeof(*comp_v1) +
4091                         entry_count * sizeof(comp_v1->lcm_entries[0]);
4092                 entry = comp_v1->lcm_entries;
4093                 for (i = 0; i < entry_count; i++, entry++) {
4094                         offset = le32_to_cpu(entry->lcme_offset);
4095                         lum = (struct lov_user_md_v1 *)((char *)comp_v1 +
4096                                                         offset);
4097                         if (le32_to_cpu(lum->lmm_magic) != LOV_USER_MAGIC_V1)
4098                                 /* the i-th component includes pool info */
4099                                 break;
4100                         if (lum->lmm_pattern == cpu_to_le32(LOV_PATTERN_MDT))
4101                                 size += sizeof(struct lov_user_md_v1);
4102                         else
4103                                 size += sizeof(struct lov_user_md_v3);
4104                 }
4105
4106                 if (i == entry_count) {
4107                         /*
4108                          * re-compose the layout to include the pool for
4109                          * each component
4110                          */
4111                         if (info->lti_ea_store_size < size)
4112                                 rc = lod_ea_store_resize(info, size);
4113
4114                         if (rc == 0) {
4115                                 comp_v1p = info->lti_ea_store;
4116                                 *comp_v1p = *comp_v1;
4117                                 comp_v1p->lcm_size = cpu_to_le32(size);
4118                                 embed_pool_to_comp_v1(comp_v1, pool, comp_v1p);
4119
4120                                 info->lti_buf.lb_buf = comp_v1p;
4121                                 info->lti_buf.lb_len = size;
4122                                 rc = lod_xattr_set_lov_on_dir(env, dt,
4123                                                               &info->lti_buf,
4124                                                               name, fl, th);
4125                         }
4126                 } else {
4127                         rc = lod_xattr_set_lov_on_dir(env, dt, buf, name, fl,
4128                                                       th);
4129                 }
4130         } else {
4131                 rc = lod_xattr_set_lov_on_dir(env, dt, buf, name, fl, th);
4132         }
4133
4134         if (lds->lds_def_striping_set == 1 && lds->lds_def_comp_entries != NULL)
4135                 lod_free_def_comp_entries(lds);
4136
4137         RETURN(rc);
4138 }
4139
4140 /**
4141  * Set default striping on a directory object.
4142  *
4143  * Sets specified striping on a directory object unless it matches the default
4144  * striping (LOVEA_DELETE_VALUES() macro). In the latter case remove existing
4145  * EA. This striping will be used when a new directory is being created in the
4146  * directory.
4147  *
4148  * \param[in] env       execution environment
4149  * \param[in] dt        the striped object
4150  * \param[in] buf       buffer with the striping
4151  * \param[in] name      name of EA
4152  * \param[in] fl        xattr flag (see OSD API description)
4153  * \param[in] th        transaction handle
4154  *
4155  * \retval              0 on success
4156  * \retval              negative if failed
4157  */
4158 static int lod_xattr_set_default_lmv_on_dir(const struct lu_env *env,
4159                                             struct dt_object *dt,
4160                                             const struct lu_buf *buf,
4161                                             const char *name, int fl,
4162                                             struct thandle *th)
4163 {
4164         struct lmv_user_md_v1 *lum;
4165         int rc;
4166
4167         ENTRY;
4168
4169         LASSERT(buf != NULL && buf->lb_buf != NULL);
4170         lum = buf->lb_buf;
4171
4172         CDEBUG(D_INFO,
4173                "set default stripe_count # %u stripe_offset %d hash %u\n",
4174               le32_to_cpu(lum->lum_stripe_count),
4175               (int)le32_to_cpu(lum->lum_stripe_offset),
4176               le32_to_cpu(lum->lum_hash_type));
4177
4178         if (LMVEA_DELETE_VALUES((le32_to_cpu(lum->lum_stripe_count)),
4179                                  le32_to_cpu(lum->lum_stripe_offset)) &&
4180             le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC) {
4181                 rc = lod_xattr_del_internal(env, dt, name, th);
4182                 if (rc == -ENODATA)
4183                         rc = 0;
4184         } else {
4185                 rc = lod_xattr_set_internal(env, dt, buf, name, fl, th);
4186                 if (rc != 0)
4187                         RETURN(rc);
4188         }
4189
4190         RETURN(rc);
4191 }
4192
4193 /**
4194  * Turn directory into a striped directory.
4195  *
4196  * During replay the client sends the striping created before MDT
4197  * failure, then the layer above LOD sends this defined striping
4198  * using ->do_xattr_set(), so LOD uses this method to replay creation
4199  * of the stripes. Notice the original information for the striping
4200  * (#stripes, FIDs, etc) was transferred in declare path.
4201  *
4202  * \param[in] env       execution environment
4203  * \param[in] dt        the striped object
4204  * \param[in] buf       not used currently
4205  * \param[in] name      not used currently
4206  * \param[in] fl        xattr flag (see OSD API description)
4207  * \param[in] th        transaction handle
4208  *
4209  * \retval              0 on success
4210  * \retval              negative if failed
4211  */
4212 static int lod_xattr_set_lmv(const struct lu_env *env, struct dt_object *dt,
4213                              const struct lu_buf *buf, const char *name,
4214                              int fl, struct thandle *th)
4215 {
4216         struct lod_object       *lo = lod_dt_obj(dt);
4217         struct lod_thread_info  *info = lod_env_info(env);
4218         struct lu_attr          *attr = &info->lti_attr;
4219         struct dt_object_format *dof = &info->lti_format;
4220         struct lu_buf           lmv_buf;
4221         struct lu_buf           slave_lmv_buf;
4222         struct lmv_mds_md_v1    *lmm;
4223         struct lmv_mds_md_v1    *slave_lmm = NULL;
4224         struct dt_insert_rec    *rec = &info->lti_dt_rec;
4225         int                     i;
4226         int                     rc;
4227         ENTRY;
4228
4229         if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
4230                 RETURN(-ENOTDIR);
4231
4232         /* The stripes are supposed to be allocated in declare phase,
4233          * if there are no stripes being allocated, it will skip */
4234         if (lo->ldo_dir_stripe_count == 0) {
4235                 if (lo->ldo_is_foreign) {
4236                         rc = lod_sub_xattr_set(env, dt_object_child(dt), buf,
4237                                                XATTR_NAME_LMV, fl, th);
4238                         if (rc != 0)
4239                                 RETURN(rc);
4240                 }
4241                 RETURN(0);
4242         }
4243
4244         rc = dt_attr_get(env, dt_object_child(dt), attr);
4245         if (rc != 0)
4246                 RETURN(rc);
4247
4248         attr->la_valid = LA_ATIME | LA_MTIME | LA_CTIME | LA_FLAGS |
4249                          LA_MODE | LA_UID | LA_GID | LA_TYPE | LA_PROJID;
4250         dof->dof_type = DFT_DIR;
4251
4252         rc = lod_prep_lmv_md(env, dt, &lmv_buf);
4253         if (rc != 0)
4254                 RETURN(rc);
4255         lmm = lmv_buf.lb_buf;
4256
4257         OBD_ALLOC_PTR(slave_lmm);
4258         if (slave_lmm == NULL)
4259                 RETURN(-ENOMEM);
4260
4261         lod_prep_slave_lmv_md(slave_lmm, lmm);
4262         slave_lmv_buf.lb_buf = slave_lmm;
4263         slave_lmv_buf.lb_len = sizeof(*slave_lmm);
4264
4265         rec->rec_type = S_IFDIR;
4266         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
4267                 struct dt_object *dto = lo->ldo_stripe[i];
4268                 char *stripe_name = info->lti_key;
4269                 struct lu_name *sname;
4270                 struct linkea_data ldata = { NULL };
4271                 struct lu_buf linkea_buf;
4272
4273                 /* OBD_FAIL_MDS_STRIPE_FID may leave stripe uninitialized */
4274                 if (!dto)
4275                         continue;
4276
4277                 /* fail a remote stripe creation */
4278                 if (i && OBD_FAIL_CHECK(OBD_FAIL_MDS_STRIPE_CREATE))
4279                         continue;
4280
4281                 /* don't create stripe if:
4282                  * 1. it's source stripe of migrating directory
4283                  * 2. it's existed stripe of splitting directory
4284                  */
4285                 if ((lod_is_migrating(lo) && i >= lo->ldo_dir_migrate_offset) ||
4286                     (lod_is_splitting(lo) && i < lo->ldo_dir_split_offset)) {
4287                         if (!dt_object_exists(dto))
4288                                 GOTO(out, rc = -EINVAL);
4289                 } else {
4290                         dt_write_lock(env, dto, DT_TGT_CHILD);
4291                         rc = lod_sub_create(env, dto, attr, NULL, dof, th);
4292                         if (rc != 0) {
4293                                 dt_write_unlock(env, dto);
4294                                 GOTO(out, rc);
4295                         }
4296
4297                         rc = lod_sub_ref_add(env, dto, th);
4298                         dt_write_unlock(env, dto);
4299                         if (rc != 0)
4300                                 GOTO(out, rc);
4301
4302                         rec->rec_fid = lu_object_fid(&dto->do_lu);
4303                         rc = lod_sub_insert(env, dto,
4304                                             (const struct dt_rec *)rec,
4305                                             (const struct dt_key *)dot, th);
4306                         if (rc != 0)
4307                                 GOTO(out, rc);
4308                 }
4309
4310                 if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SLAVE_LMV) ||
4311                     cfs_fail_val != i) {
4312                         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_SLAVE_LMV) &&
4313                             cfs_fail_val == i)
4314                                 slave_lmm->lmv_master_mdt_index =
4315                                                         cpu_to_le32(i + 1);
4316                         else
4317                                 slave_lmm->lmv_master_mdt_index =
4318                                                         cpu_to_le32(i);
4319
4320                         rc = lod_sub_xattr_set(env, dto, &slave_lmv_buf,
4321                                                XATTR_NAME_LMV, 0, th);
4322                         if (rc != 0)
4323                                 GOTO(out, rc);
4324                 }
4325
4326                 /* don't insert stripe if it's existed stripe of splitting
4327                  * directory (this directory is striped).
4328                  * NB, plain directory will insert itself as the first
4329                  * stripe in target.
4330                  */
4331                 if (lod_is_splitting(lo) && lo->ldo_dir_split_offset > 1 &&
4332                     lo->ldo_dir_split_offset > i)
4333                         continue;
4334
4335                 rec->rec_fid = lu_object_fid(&dt->do_lu);
4336                 rc = lod_sub_insert(env, dto, (struct dt_rec *)rec,
4337                                     (const struct dt_key *)dotdot, th);
4338                 if (rc != 0)
4339                         GOTO(out, rc);
4340
4341                 if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_SLAVE_NAME) &&
4342                     cfs_fail_val == i)
4343                         snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
4344                                  PFID(lu_object_fid(&dto->do_lu)), i + 1);
4345                 else
4346                         snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
4347                                  PFID(lu_object_fid(&dto->do_lu)), i);
4348
4349                 sname = lod_name_get(env, stripe_name, strlen(stripe_name));
4350                 rc = linkea_links_new(&ldata, &info->lti_linkea_buf,
4351                                       sname, lu_object_fid(&dt->do_lu));
4352                 if (rc != 0)
4353                         GOTO(out, rc);
4354
4355                 linkea_buf.lb_buf = ldata.ld_buf->lb_buf;
4356                 linkea_buf.lb_len = ldata.ld_leh->leh_len;
4357                 rc = lod_sub_xattr_set(env, dto, &linkea_buf,
4358                                        XATTR_NAME_LINK, 0, th);
4359                 if (rc != 0)
4360                         GOTO(out, rc);
4361
4362                 rec->rec_fid = lu_object_fid(&dto->do_lu);
4363                 rc = lod_sub_insert(env, dt_object_child(dt),
4364                                     (const struct dt_rec *)rec,
4365                                     (const struct dt_key *)stripe_name, th);
4366                 if (rc != 0)
4367                         GOTO(out, rc);
4368
4369                 rc = lod_sub_ref_add(env, dt_object_child(dt), th);
4370                 if (rc != 0)
4371                         GOTO(out, rc);
4372         }
4373
4374         if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MASTER_LMV))
4375                 rc = lod_sub_xattr_set(env, dt_object_child(dt),
4376                                        &lmv_buf, XATTR_NAME_LMV, fl, th);
4377 out:
4378         if (slave_lmm != NULL)
4379                 OBD_FREE_PTR(slave_lmm);
4380
4381         RETURN(rc);
4382 }
4383
4384 /**
4385  * Helper function to declare/execute creation of a striped directory
4386  *
4387  * Called in declare/create object path, prepare striping for a directory
4388  * and prepare defaults data striping for the objects to be created in
4389  * that directory. Notice the function calls "declaration" or "execution"
4390  * methods depending on \a declare param. This is a consequence of the
4391  * current approach while we don't have natural distributed transactions:
4392  * we basically execute non-local updates in the declare phase. So, the
4393  * arguments for the both phases are the same and this is the reason for
4394  * this function to exist.
4395  *
4396  * \param[in] env       execution environment
4397  * \param[in] dt        object
4398  * \param[in] attr      attributes the stripes will be created with
4399  * \param[in] lmu       lmv_user_md if MDT indices are specified
4400  * \param[in] dof       format of stripes (see OSD API description)
4401  * \param[in] th        transaction handle
4402  * \param[in] declare   where to call "declare" or "execute" methods
4403  *
4404  * \retval              0 on success
4405  * \retval              negative if failed
4406  */
4407 static int lod_dir_striping_create_internal(const struct lu_env *env,
4408                                             struct dt_object *dt,
4409                                             struct lu_attr *attr,
4410                                             const struct lu_buf *lmu,
4411                                             struct dt_object_format *dof,
4412                                             struct thandle *th,
4413                                             bool declare)
4414 {
4415         struct lod_thread_info *info = lod_env_info(env);
4416         struct lod_object *lo = lod_dt_obj(dt);
4417         const struct lod_default_striping *lds = lo->ldo_def_striping;
4418         int rc;
4419         ENTRY;
4420
4421         LASSERT(ergo(lds != NULL,
4422                      lds->lds_def_striping_set ||
4423                      lds->lds_dir_def_striping_set));
4424
4425         if (!LMVEA_DELETE_VALUES(lo->ldo_dir_stripe_count,
4426                                  lo->ldo_dir_stripe_offset)) {
4427                 if (!lmu) {
4428                         struct lmv_user_md_v1 *v1 = info->lti_ea_store;
4429                         int stripe_count = lo->ldo_dir_stripe_count;
4430
4431                         if (info->lti_ea_store_size < sizeof(*v1)) {
4432                                 rc = lod_ea_store_resize(info, sizeof(*v1));
4433                                 if (rc != 0)
4434                                         RETURN(rc);
4435                                 v1 = info->lti_ea_store;
4436                         }
4437
4438                         memset(v1, 0, sizeof(*v1));
4439                         v1->lum_magic = cpu_to_le32(LMV_USER_MAGIC);
4440                         v1->lum_stripe_count = cpu_to_le32(stripe_count);
4441                         v1->lum_stripe_offset =
4442                                         cpu_to_le32(lo->ldo_dir_stripe_offset);
4443
4444                         info->lti_buf.lb_buf = v1;
4445                         info->lti_buf.lb_len = sizeof(*v1);
4446                         lmu = &info->lti_buf;
4447                 }
4448
4449                 if (declare)
4450                         rc = lod_declare_xattr_set_lmv(env, dt, attr, lmu, dof,
4451                                                        th);
4452                 else
4453                         rc = lod_xattr_set_lmv(env, dt, lmu, XATTR_NAME_LMV, 0,
4454                                                th);
4455                 if (rc != 0)
4456                         RETURN(rc);
4457         } else {
4458                 /* foreign LMV EA case */
4459                 if (lmu) {
4460                         struct lmv_foreign_md *lfm = lmu->lb_buf;
4461
4462                         if (lfm->lfm_magic == LMV_MAGIC_FOREIGN) {
4463                                 rc = lod_declare_xattr_set_lmv(env, dt, attr,
4464                                                                lmu, dof, th);
4465                         }
4466                 } else {
4467                         if (lo->ldo_is_foreign) {
4468                                 LASSERT(lo->ldo_foreign_lmv != NULL &&
4469                                         lo->ldo_foreign_lmv_size > 0);
4470                                 info->lti_buf.lb_buf = lo->ldo_foreign_lmv;
4471                                 info->lti_buf.lb_len = lo->ldo_foreign_lmv_size;
4472                                 lmu = &info->lti_buf;
4473                                 rc = lod_xattr_set_lmv(env, dt, lmu,
4474                                                        XATTR_NAME_LMV, 0, th);
4475                         }
4476                 }
4477         }
4478
4479         /* Transfer default LMV striping from the parent */
4480         if (lds != NULL && lds->lds_dir_def_striping_set &&
4481             lds->lds_dir_def_max_inherit != LMV_INHERIT_END &&
4482             lds->lds_dir_def_max_inherit != LMV_INHERIT_NONE &&
4483             !(LMVEA_DELETE_VALUES(lds->lds_dir_def_stripe_count,
4484                                  lds->lds_dir_def_stripe_offset) &&
4485               le32_to_cpu(lds->lds_dir_def_hash_type) !=
4486               LMV_HASH_TYPE_UNKNOWN)) {
4487                 struct lmv_user_md_v1 *v1 = info->lti_ea_store;
4488
4489                 if (info->lti_ea_store_size < sizeof(*v1)) {
4490                         rc = lod_ea_store_resize(info, sizeof(*v1));
4491                         if (rc != 0)
4492                                 RETURN(rc);
4493                         v1 = info->lti_ea_store;
4494                 }
4495
4496                 memset(v1, 0, sizeof(*v1));
4497                 v1->lum_magic = cpu_to_le32(LMV_USER_MAGIC);
4498                 v1->lum_stripe_count =
4499                         cpu_to_le32(lds->lds_dir_def_stripe_count);
4500                 v1->lum_stripe_offset =
4501                         cpu_to_le32(lds->lds_dir_def_stripe_offset);
4502                 v1->lum_hash_type =
4503                         cpu_to_le32(lds->lds_dir_def_hash_type);
4504                 v1->lum_max_inherit =
4505                         lmv_inherit_next(lds->lds_dir_def_max_inherit);
4506                 v1->lum_max_inherit_rr =
4507                         lmv_inherit_rr_next(lds->lds_dir_def_max_inherit_rr);
4508
4509                 info->lti_buf.lb_buf = v1;
4510                 info->lti_buf.lb_len = sizeof(*v1);
4511                 if (declare)
4512                         rc = lod_dir_declare_xattr_set(env, dt, &info->lti_buf,
4513                                                        XATTR_NAME_DEFAULT_LMV,
4514                                                        0, th);
4515                 else
4516                         rc = lod_xattr_set_default_lmv_on_dir(env, dt,
4517                                                   &info->lti_buf,
4518                                                   XATTR_NAME_DEFAULT_LMV, 0,
4519                                                   th);
4520                 if (rc != 0)
4521                         RETURN(rc);
4522         }
4523
4524         /* Transfer default LOV striping from the parent */
4525         if (lds != NULL && lds->lds_def_striping_set &&
4526             lds->lds_def_comp_cnt != 0) {
4527                 struct lov_mds_md *lmm;
4528                 int lmm_size = lod_comp_md_size(lo, true);
4529
4530                 if (info->lti_ea_store_size < lmm_size) {
4531                         rc = lod_ea_store_resize(info, lmm_size);
4532                         if (rc != 0)
4533                                 RETURN(rc);
4534                 }
4535                 lmm = info->lti_ea_store;
4536
4537                 rc = lod_generate_lovea(env, lo, lmm, &lmm_size, true);
4538                 if (rc != 0)
4539                         RETURN(rc);
4540
4541                 info->lti_buf.lb_buf = lmm;
4542                 info->lti_buf.lb_len = lmm_size;
4543
4544                 if (declare)
4545                         rc = lod_dir_declare_xattr_set(env, dt, &info->lti_buf,
4546                                                        XATTR_NAME_LOV, 0, th);
4547                 else
4548                         rc = lod_xattr_set_lov_on_dir(env, dt, &info->lti_buf,
4549                                                       XATTR_NAME_LOV, 0, th);
4550                 if (rc != 0)
4551                         RETURN(rc);
4552         }
4553
4554         /* ldo_def_striping is not allocated, clear after use, in case directory
4555          * layout is changed later.
4556          */
4557         if (!declare)
4558                 lo->ldo_def_striping = NULL;
4559
4560         RETURN(0);
4561 }
4562
4563 static int lod_declare_dir_striping_create(const struct lu_env *env,
4564                                            struct dt_object *dt,
4565                                            struct lu_attr *attr,
4566                                            struct lu_buf *lmu,
4567                                            struct dt_object_format *dof,
4568                                            struct thandle *th)
4569 {
4570         return lod_dir_striping_create_internal(env, dt, attr, lmu, dof, th,
4571                                                 true);
4572 }
4573
4574 static int lod_dir_striping_create(const struct lu_env *env,
4575                                    struct dt_object *dt,
4576                                    struct lu_attr *attr,
4577                                    struct dt_object_format *dof,
4578                                    struct thandle *th)
4579 {
4580         return lod_dir_striping_create_internal(env, dt, attr, NULL, dof, th,
4581                                                 false);
4582 }
4583
4584 /**
4585  * Make LOV EA for striped object.
4586  *
4587  * Generate striping information and store it in the LOV EA of the given
4588  * object. The caller must ensure nobody else is calling the function
4589  * against the object concurrently. The transaction must be started.
4590  * FLDB service must be running as well; it's used to map FID to the target,
4591  * which is stored in LOV EA.
4592  *
4593  * \param[in] env               execution environment for this thread
4594  * \param[in] lo                LOD object
4595  * \param[in] th                transaction handle
4596  *
4597  * \retval                      0 if LOV EA is stored successfully
4598  * \retval                      negative error number on failure
4599  */
4600 static int lod_generate_and_set_lovea(const struct lu_env *env,
4601                                       struct lod_object *lo,
4602                                       struct thandle *th)
4603 {
4604         struct lod_thread_info  *info = lod_env_info(env);
4605         struct dt_object        *next = dt_object_child(&lo->ldo_obj);
4606         struct lov_mds_md_v1    *lmm;
4607         int                      rc, lmm_size;
4608         ENTRY;
4609
4610         LASSERT(lo);
4611
4612         if (lo->ldo_comp_cnt == 0 && !lo->ldo_is_foreign) {
4613                 lod_striping_free_nolock(env, lo);
4614                 rc = lod_sub_xattr_del(env, next, XATTR_NAME_LOV, th);
4615                 RETURN(rc);
4616         }
4617
4618         lmm_size = lod_comp_md_size(lo, false);
4619         if (info->lti_ea_store_size < lmm_size) {
4620                 rc = lod_ea_store_resize(info, lmm_size);
4621                 if (rc)
4622                         RETURN(rc);
4623         }
4624         lmm = info->lti_ea_store;
4625
4626         rc = lod_generate_lovea(env, lo, lmm, &lmm_size, false);
4627         if (rc)
4628                 RETURN(rc);
4629
4630         info->lti_buf.lb_buf = lmm;
4631         info->lti_buf.lb_len = lmm_size;
4632         rc = lod_sub_xattr_set(env, next, &info->lti_buf,
4633                                XATTR_NAME_LOV, 0, th);
4634         RETURN(rc);
4635 }
4636
4637 static __u32 lod_gen_component_id(struct lod_object *lo,
4638                                   int mirror_id, int comp_idx);
4639
4640 /**
4641  * Repeat an existing component
4642  *
4643  * Creates a new layout by replicating an existing component.  Uses striping
4644  * policy from previous component as a template for the striping for the new
4645  * new component.
4646  *
4647  * New component starts with zero length, will be extended (or removed) before
4648  * returning layout to client.
4649  *
4650  * NB: Reallocates layout components array (lo->ldo_comp_entries), invalidating
4651  * any pre-existing pointers to components.  Handle with care.
4652  *
4653  * \param[in] env       execution environment for this thread
4654  * \param[in,out] lo    object to update the layout of
4655  * \param[in] index     index of component to copy
4656  *
4657  * \retval      0 on success
4658  * \retval      negative errno on error
4659  */
4660 static int lod_layout_repeat_comp(const struct lu_env *env,
4661                                   struct lod_object *lo, int index)
4662 {
4663         struct lod_layout_component *lod_comp;
4664         struct lod_layout_component *new_comp = NULL;
4665         struct lod_layout_component *comp_array;
4666         int rc = 0, i, new_cnt = lo->ldo_comp_cnt + 1;
4667         __u16 mirror_id;
4668         int offset = 0;
4669         ENTRY;
4670
4671         lod_comp = &lo->ldo_comp_entries[index];
4672         LASSERT(lod_comp_inited(lod_comp) && lod_comp->llc_id != LCME_ID_INVAL);
4673
4674         CDEBUG(D_LAYOUT, "repeating component %d\n", index);
4675
4676         OBD_ALLOC_PTR_ARRAY(comp_array, new_cnt);
4677         if (comp_array == NULL)
4678                 GOTO(out, rc = -ENOMEM);
4679
4680         for (i = 0; i < lo->ldo_comp_cnt; i++) {
4681                 memcpy(&comp_array[i + offset], &lo->ldo_comp_entries[i],
4682                        sizeof(*comp_array));
4683
4684                 /* Duplicate this component in to the next slot */
4685                 if (i == index) {
4686                         new_comp = &comp_array[i + 1];
4687                         memcpy(&comp_array[i + 1], &lo->ldo_comp_entries[i],
4688                                sizeof(*comp_array));
4689                         /* We must now skip this new component when copying */
4690                         offset = 1;
4691                 }
4692         }
4693
4694         /* Set up copied component */
4695         new_comp->llc_flags &= ~LCME_FL_INIT;
4696         new_comp->llc_stripe = NULL;
4697         new_comp->llc_stripes_allocated = 0;
4698         new_comp->llc_ost_indices = NULL;
4699         new_comp->llc_stripe_offset = LOV_OFFSET_DEFAULT;
4700         /* for uninstantiated components, layout gen stores default stripe
4701          * offset */
4702         new_comp->llc_layout_gen = lod_comp->llc_stripe_offset;
4703         /* This makes the repeated component zero-length, placed at the end of
4704          * the preceding component */
4705         new_comp->llc_extent.e_start = new_comp->llc_extent.e_end;
4706         new_comp->llc_timestamp = lod_comp->llc_timestamp;
4707         new_comp->llc_pool = NULL;
4708
4709         rc = lod_set_pool(&new_comp->llc_pool, lod_comp->llc_pool);
4710         if (rc)
4711                 GOTO(out, rc);
4712
4713         if (new_comp->llc_ostlist.op_array) {
4714                 __u32 *op_array = NULL;
4715
4716                 OBD_ALLOC(op_array, new_comp->llc_ostlist.op_size);
4717                 if (!op_array)
4718                         GOTO(out, rc = -ENOMEM);
4719                 memcpy(op_array, &new_comp->llc_ostlist.op_array,
4720                        new_comp->llc_ostlist.op_size);
4721                 new_comp->llc_ostlist.op_array = op_array;
4722         }
4723
4724         OBD_FREE_PTR_ARRAY(lo->ldo_comp_entries, lo->ldo_comp_cnt);
4725         lo->ldo_comp_entries = comp_array;
4726         lo->ldo_comp_cnt = new_cnt;
4727
4728         /* Generate an id for the new component */
4729         mirror_id = mirror_id_of(new_comp->llc_id);
4730         new_comp->llc_id = LCME_ID_INVAL;
4731         new_comp->llc_id = lod_gen_component_id(lo, mirror_id, index + 1);
4732         if (new_comp->llc_id == LCME_ID_INVAL)
4733                 GOTO(out, rc = -ERANGE);
4734
4735         EXIT;
4736 out:
4737         if (rc)
4738                 OBD_FREE_PTR_ARRAY(comp_array, new_cnt);
4739
4740         return rc;
4741 }
4742
4743 static int lod_layout_data_init(struct lod_thread_info *info, __u32 comp_cnt)
4744 {
4745         ENTRY;
4746
4747         /* clear memory region that will be used for layout change */
4748         memset(&info->lti_layout_attr, 0, sizeof(struct lu_attr));
4749         info->lti_count = 0;
4750
4751         if (info->lti_comp_size >= comp_cnt)
4752                 RETURN(0);
4753
4754         if (info->lti_comp_size > 0) {
4755                 OBD_FREE_PTR_ARRAY(info->lti_comp_idx, info->lti_comp_size);
4756                 info->lti_comp_size = 0;
4757         }
4758
4759         OBD_ALLOC_PTR_ARRAY(info->lti_comp_idx, comp_cnt);
4760         if (!info->lti_comp_idx)
4761                 RETURN(-ENOMEM);
4762
4763         info->lti_comp_size = comp_cnt;
4764         RETURN(0);
4765 }
4766
4767 /**
4768  * Prepare new layout minus deleted components
4769  *
4770  * Removes components marked for deletion (LCME_ID_INVAL) by copying to a new
4771  * layout and skipping those components.  Removes stripe objects if any exist.
4772  *
4773  * NB:
4774  * Reallocates layout components array (lo->ldo_comp_entries), invalidating
4775  * any pre-existing pointers to components.
4776  *
4777  * Caller is responsible for updating mirror end (ldo_mirror[].lme_end).
4778  *
4779  * \param[in] env       execution environment for this thread
4780  * \param[in,out] lo    object to update the layout of
4781  * \param[in] th        transaction handle for this operation
4782  *
4783  * \retval      # of components deleted
4784  * \retval      negative errno on error
4785  */
4786 static int lod_layout_del_prep_layout(const struct lu_env *env,
4787                                       struct lod_object *lo,
4788                                       struct thandle *th)
4789 {
4790         struct lod_layout_component     *lod_comp;
4791         struct lod_thread_info  *info = lod_env_info(env);
4792         int rc = 0, i, j, deleted = 0;
4793
4794         ENTRY;
4795
4796         LASSERT(lo->ldo_is_composite);
4797         LASSERT(lo->ldo_comp_cnt > 0 && lo->ldo_comp_entries != NULL);
4798
4799         rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
4800         if (rc)
4801                 RETURN(rc);
4802
4803         for (i = 0; i < lo->ldo_comp_cnt; i++) {
4804                 lod_comp = &lo->ldo_comp_entries[i];
4805
4806                 if (lod_comp->llc_id != LCME_ID_INVAL) {
4807                         /* Build array of things to keep */
4808                         info->lti_comp_idx[info->lti_count++] = i;
4809                         continue;
4810                 }
4811
4812                 lod_obj_set_pool(lo, i, NULL);
4813                 if (lod_comp->llc_ostlist.op_array) {
4814                         OBD_FREE(lod_comp->llc_ostlist.op_array,
4815                                  lod_comp->llc_ostlist.op_size);
4816                         lod_comp->llc_ostlist.op_array = NULL;
4817                         lod_comp->llc_ostlist.op_size = 0;
4818                 }
4819
4820                 deleted++;
4821                 CDEBUG(D_LAYOUT, "deleting comp %d, left %d\n", i,
4822                        lo->ldo_comp_cnt - deleted);
4823
4824                 /* No striping info for this component */
4825                 if (lod_comp->llc_stripe == NULL)
4826                         continue;
4827
4828                 LASSERT(lod_comp->llc_stripe_count > 0);
4829                 for (j = 0; j < lod_comp->llc_stripe_count; j++) {
4830                         struct dt_object *obj = lod_comp->llc_stripe[j];
4831
4832                         if (obj == NULL)
4833                                 continue;
4834
4835                         /* components which are not init have no sub objects
4836                          * to destroy */
4837                         if (lod_comp_inited(lod_comp)) {
4838                                 rc = lod_sub_destroy(env, obj, th);
4839                                 if (rc)
4840                                         GOTO(out, rc);
4841                         }
4842
4843                         lu_object_put(env, &obj->do_lu);
4844                         lod_comp->llc_stripe[j] = NULL;
4845                 }
4846                 OBD_FREE_PTR_ARRAY(lod_comp->llc_stripe,
4847                                    lod_comp->llc_stripes_allocated);
4848                 lod_comp->llc_stripe = NULL;
4849                 OBD_FREE_PTR_ARRAY(lod_comp->llc_ost_indices,
4850                                    lod_comp->llc_stripes_allocated);
4851                 lod_comp->llc_ost_indices = NULL;
4852                 lod_comp->llc_stripes_allocated = 0;
4853         }
4854
4855         /* info->lti_count has the amount of left components */
4856         LASSERTF(info->lti_count >= 0 && info->lti_count < lo->ldo_comp_cnt,
4857                  "left = %d, lo->ldo_comp_cnt %d\n", (int)info->lti_count,
4858                  (int)lo->ldo_comp_cnt);
4859
4860         if (info->lti_count > 0) {
4861                 struct lod_layout_component *comp_array;
4862
4863                 OBD_ALLOC_PTR_ARRAY(comp_array, info->lti_count);
4864                 if (comp_array == NULL)
4865                         GOTO(out, rc = -ENOMEM);
4866
4867                 for (i = 0; i < info->lti_count; i++) {
4868                         memcpy(&comp_array[i],
4869                                &lo->ldo_comp_entries[info->lti_comp_idx[i]],
4870                                sizeof(*comp_array));
4871                 }
4872
4873                 OBD_FREE_PTR_ARRAY(lo->ldo_comp_entries, lo->ldo_comp_cnt);
4874                 lo->ldo_comp_entries = comp_array;
4875                 lo->ldo_comp_cnt = info->lti_count;
4876         } else {
4877                 lod_free_comp_entries(lo);
4878         }
4879
4880         EXIT;
4881 out:
4882         return rc ? rc : deleted;
4883 }
4884
4885 /**
4886  * Delete layout component(s)
4887  *
4888  * This function sets up the layout data in the env and does the setattrs
4889  * required to write out the new layout.  The layout itself is modified in
4890  * lod_layout_del_prep_layout.
4891  *
4892  * \param[in] env       execution environment for this thread
4893  * \param[in] dt        object
4894  * \param[in] th        transaction handle
4895  *
4896  * \retval      0 on success
4897  * \retval      negative error number on failure
4898  */
4899 static int lod_layout_del(const struct lu_env *env, struct dt_object *dt,
4900                           struct thandle *th)
4901 {
4902         struct lod_object *lo = lod_dt_obj(dt);
4903         struct dt_object *next = dt_object_child(dt);
4904         struct lu_attr *attr = &lod_env_info(env)->lti_attr;
4905         int rc;
4906
4907         LASSERT(lo->ldo_mirror_count == 1);
4908
4909         mutex_lock(&lo->ldo_layout_mutex);
4910
4911         rc = lod_layout_del_prep_layout(env, lo, th);
4912         if (rc < 0)
4913                 GOTO(out, rc);
4914
4915         /* Only do this if we didn't delete all components */
4916         if (lo->ldo_comp_cnt > 0) {
4917                 lo->ldo_mirrors[0].lme_end = lo->ldo_comp_cnt - 1;
4918                 lod_obj_inc_layout_gen(lo);
4919         }
4920
4921         LASSERT(dt_object_exists(dt));
4922         rc = dt_attr_get(env, next, attr);
4923         if (rc)
4924                 GOTO(out, rc);
4925
4926         if (attr->la_size > 0) {
4927                 attr->la_size = 0;
4928                 attr->la_valid = LA_SIZE;
4929                 rc = lod_sub_attr_set(env, next, attr, th);
4930                 if (rc)
4931                         GOTO(out, rc);
4932         }
4933
4934         rc = lod_generate_and_set_lovea(env, lo, th);
4935         EXIT;
4936 out:
4937         if (rc)
4938                 lod_striping_free_nolock(env, lo);
4939
4940         mutex_unlock(&lo->ldo_layout_mutex);
4941
4942         return rc;
4943 }
4944
4945
4946 /**
4947  * Implementation of dt_object_operations::do_xattr_set.
4948  *
4949  * Sets specified extended attribute on the object. Three types of EAs are
4950  * special:
4951  *   LOV EA - stores striping for a regular file or default striping (when set
4952  *            on a directory)
4953  *   LMV EA - stores a marker for the striped directories
4954  *   DMV EA - stores default directory striping
4955  *
4956  * When striping is applied to a non-striped existing object (this is called
4957  * late striping), then LOD notices the caller wants to turn the object into a
4958  * striped one. The stripe objects are created and appropriate EA is set:
4959  * LOV EA storing all the stripes directly or LMV EA storing just a small header
4960  * with striping configuration.
4961  *
4962  * \see dt_object_operations::do_xattr_set() in the API description for details.
4963  */
4964 static int lod_xattr_set(const struct lu_env *env,
4965                          struct dt_object *dt, const struct lu_buf *buf,
4966                          const char *name, int fl, struct thandle *th)
4967 {
4968         struct dt_object *next = dt_object_child(dt);
4969         struct lu_attr *layout_attr = &lod_env_info(env)->lti_layout_attr;
4970         struct lod_object *lo = lod_dt_obj(dt);
4971         struct lod_obj_stripe_cb_data data = { {0} };
4972         int rc = 0;
4973
4974         ENTRY;
4975
4976         if (S_ISDIR(dt->do_lu.lo_header->loh_attr) &&
4977             !strcmp(name, XATTR_NAME_LMV)) {
4978                 switch (fl) {
4979                 case LU_XATTR_CREATE:
4980                         rc = lod_dir_striping_create(env, dt, NULL, NULL, th);
4981                         break;
4982                 case 0:
4983                 case LU_XATTR_REPLACE:
4984                         rc = lod_dir_layout_set(env, dt, buf, fl, th);
4985                         break;
4986                 default:
4987                         LBUG();
4988                 }
4989
4990                 RETURN(rc);
4991         } else if (S_ISDIR(dt->do_lu.lo_header->loh_attr) &&
4992                    strcmp(name, XATTR_NAME_LOV) == 0) {
4993                 rc = lod_xattr_set_default_lov_on_dir(env, dt, buf, name, fl,
4994                                                       th);
4995                 RETURN(rc);
4996         } else if (S_ISDIR(dt->do_lu.lo_header->loh_attr) &&
4997                    strcmp(name, XATTR_NAME_DEFAULT_LMV) == 0) {
4998                 /* default LMVEA */
4999                 rc = lod_xattr_set_default_lmv_on_dir(env, dt, buf, name, fl,
5000                                                       th);
5001                 RETURN(rc);
5002         } else if (S_ISREG(dt->do_lu.lo_header->loh_attr) &&
5003                    (strcmp(name, XATTR_NAME_LOV) == 0 ||
5004                     strcmp(name, XATTR_LUSTRE_LOV) == 0 ||
5005                     allowed_lustre_lov(name))) {
5006                 /* in case of lov EA swap, just set it
5007                  * if not, it is a replay so check striping match what we
5008                  * already have during req replay, declare_xattr_set()
5009                  * defines striping, then create() does the work */
5010                 if (fl & LU_XATTR_REPLACE) {
5011                         /* free stripes, then update disk */
5012                         lod_striping_free(env, lod_dt_obj(dt));
5013
5014                         rc = lod_sub_xattr_set(env, next, buf, name, fl, th);
5015                 } else if (fl & LU_XATTR_SPLIT) {
5016                         rc = lod_sub_xattr_set(env, next, buf, name, fl, th);
5017                         if (rc)
5018                                 RETURN(rc);
5019
5020                         rc = lod_striping_reload(env, lo, buf, LVF_ALL_STALE);
5021                         if (rc)
5022                                 RETURN(rc);
5023
5024                         if (lo->ldo_mirror_count > 1 &&
5025                             layout_attr->la_valid & LA_LAYOUT_VERSION) {
5026                                 /* mirror split */
5027                                 layout_attr->la_layout_version =
5028                                                 lo->ldo_layout_gen;
5029                                 data.locd_attr = layout_attr;
5030                                 data.locd_declare = false;
5031                                 data.locd_stripe_cb =
5032                                                 lod_obj_stripe_attr_set_cb;
5033                                 rc = lod_obj_for_each_stripe(env, lo, th,
5034                                                              &data);
5035                                 if (rc)
5036                                         RETURN(rc);
5037                         }
5038                 } else if (fl & LU_XATTR_PURGE) {
5039                         rc = lod_layout_purge(env, dt, buf, th);
5040                 } else if (dt_object_remote(dt)) {
5041                         /* This only happens during migration, see
5042                          * mdd_migrate_create(), in which Master MDT will
5043                          * create a remote target object, and only set
5044                          * (migrating) stripe EA on the remote object,
5045                          * and does not need creating each stripes. */
5046                         rc = lod_sub_xattr_set(env, next, buf, name,
5047                                                       fl, th);
5048                 } else if (strcmp(name, XATTR_LUSTRE_LOV".del") == 0) {
5049                         /* delete component(s) */
5050                         LASSERT(lod_dt_obj(dt)->ldo_comp_cached);
5051                         rc = lod_layout_del(env, dt, th);
5052                 } else {
5053                         /*
5054                          * When 'name' is XATTR_LUSTRE_LOV or XATTR_NAME_LOV,
5055                          * it's going to create create file with specified
5056                          * component(s), the striping must have not being
5057                          * cached in this case;
5058                          *
5059                          * Otherwise, it's going to add/change component(s) to
5060                          * an existing file, the striping must have been cached
5061                          * in this case.
5062                          */
5063                         LASSERT(equi(!strcmp(name, XATTR_LUSTRE_LOV) ||
5064                                      !strcmp(name, XATTR_NAME_LOV),
5065                                 !lod_dt_obj(dt)->ldo_comp_cached));
5066
5067                         rc = lod_striped_create(env, dt, NULL, NULL, th);
5068                         if (rc)
5069                                 RETURN(rc);
5070
5071                         if (fl & LU_XATTR_MERGE && lo->ldo_mirror_count > 1 &&
5072                             layout_attr->la_valid & LA_LAYOUT_VERSION) {
5073                                 /* mirror merge exec phase */
5074                                 layout_attr->la_layout_version =
5075                                                 lo->ldo_layout_gen;
5076                                 data.locd_attr = layout_attr;
5077                                 data.locd_declare = false;
5078                                 data.locd_stripe_cb =
5079                                                 lod_obj_stripe_attr_set_cb;
5080                                 rc = lod_obj_for_each_stripe(env, lo, th,
5081                                                              &data);
5082                                 if (rc)
5083                                         RETURN(rc);
5084                         }
5085                 }
5086                 RETURN(rc);
5087         } else if (strcmp(name, XATTR_NAME_FID) == 0) {
5088                 rc = lod_replace_parent_fid(env, dt, buf, th, false);
5089
5090                 RETURN(rc);
5091         }
5092
5093         /* then all other xattr */
5094         rc = lod_xattr_set_internal(env, dt, buf, name, fl, th);
5095
5096         RETURN(rc);
5097 }
5098
5099 /**
5100  * Implementation of dt_object_operations::do_declare_xattr_del.
5101  *
5102  * \see dt_object_operations::do_declare_xattr_del() in the API description
5103  * for details.
5104  */
5105 static int lod_declare_xattr_del(const struct lu_env *env,
5106                                  struct dt_object *dt, const char *name,
5107                                  struct thandle *th)
5108 {
5109         struct lod_object *lo = lod_dt_obj(dt);
5110         struct dt_object *next = dt_object_child(dt);
5111         int i;
5112         int rc;
5113         ENTRY;
5114
5115         rc = lod_sub_declare_xattr_del(env, next, name, th);
5116         if (rc != 0)
5117                 RETURN(rc);
5118
5119         if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
5120                 RETURN(0);
5121
5122         /* NB: don't delete stripe LMV, because when we do this, normally we
5123          * will remove stripes, besides, if directory LMV is corrupt, this will
5124          * prevent deleting its LMV and fixing it (via LFSCK).
5125          */
5126         if (!strcmp(name, XATTR_NAME_LMV))
5127                 RETURN(0);
5128
5129         rc = lod_striping_load(env, lo);
5130         if (rc != 0)
5131                 RETURN(rc);
5132
5133         if (lo->ldo_dir_stripe_count == 0)
5134                 RETURN(0);
5135
5136         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
5137                 struct dt_object *dto = lo->ldo_stripe[i];
5138
5139                 if (!dto)
5140                         continue;
5141
5142                 if (!dt_object_exists(dto))
5143                         continue;
5144
5145                 rc = lod_sub_declare_xattr_del(env, dto, name, th);
5146                 if (rc != 0)
5147                         break;
5148         }
5149
5150         RETURN(rc);
5151 }
5152
5153 /**
5154  * Implementation of dt_object_operations::do_xattr_del.
5155  *
5156  * If EA storing a regular striping is being deleted, then release
5157  * all the references to the stripe objects in core.
5158  *
5159  * \see dt_object_operations::do_xattr_del() in the API description for details.
5160  */
5161 static int lod_xattr_del(const struct lu_env *env, struct dt_object *dt,
5162                          const char *name, struct thandle *th)
5163 {
5164         int rc;
5165
5166         ENTRY;
5167
5168         if (!strcmp(name, XATTR_NAME_LOV) || !strcmp(name, XATTR_NAME_LMV))
5169                 lod_striping_free(env, lod_dt_obj(dt));
5170
5171         rc = lod_xattr_del_internal(env, dt, name, th);
5172
5173         RETURN(rc);
5174 }
5175
5176 /**
5177  * Implementation of dt_object_operations::do_xattr_list.
5178  *
5179  * \see dt_object_operations::do_xattr_list() in the API description
5180  * for details.
5181  */
5182 static int lod_xattr_list(const struct lu_env *env,
5183                           struct dt_object *dt, const struct lu_buf *buf)
5184 {
5185         return dt_xattr_list(env, dt_object_child(dt), buf);
5186 }
5187
5188 static inline int lod_object_will_be_striped(int is_reg, const struct lu_fid *fid)
5189 {
5190         return (is_reg && fid_seq(fid) != FID_SEQ_LOCAL_FILE);
5191 }
5192
5193 /**
5194  * Copy OST list from layout provided by user.
5195  *
5196  * \param[in] lod_comp          layout_component to be filled
5197  * \param[in] v3                LOV EA V3 user data
5198  *
5199  * \retval              0 on success
5200  * \retval              negative if failed
5201  */
5202 int lod_comp_copy_ost_lists(struct lod_layout_component *lod_comp,
5203                             struct lov_user_md_v3 *v3)
5204 {
5205         int j;
5206
5207         ENTRY;
5208
5209         if (v3->lmm_stripe_offset == LOV_OFFSET_DEFAULT)
5210                 v3->lmm_stripe_offset = v3->lmm_objects[0].l_ost_idx;
5211
5212         if (lod_comp->llc_ostlist.op_array) {
5213                 if (lod_comp->llc_ostlist.op_size >=
5214                     v3->lmm_stripe_count * sizeof(__u32))  {
5215                         lod_comp->llc_ostlist.op_count =
5216                                         v3->lmm_stripe_count;
5217                         goto skip;
5218                 }
5219                 OBD_FREE(lod_comp->llc_ostlist.op_array,
5220                          lod_comp->llc_ostlist.op_size);
5221         }
5222
5223         /* copy ost list from lmm */
5224         lod_comp->llc_ostlist.op_count = v3->lmm_stripe_count;
5225         lod_comp->llc_ostlist.op_size = v3->lmm_stripe_count * sizeof(__u32);
5226         OBD_ALLOC(lod_comp->llc_ostlist.op_array,
5227                   lod_comp->llc_ostlist.op_size);
5228         if (!lod_comp->llc_ostlist.op_array)
5229                 RETURN(-ENOMEM);
5230 skip:
5231         for (j = 0; j < v3->lmm_stripe_count; j++) {
5232                 lod_comp->llc_ostlist.op_array[j] =
5233                         v3->lmm_objects[j].l_ost_idx;
5234         }
5235
5236         RETURN(0);
5237 }
5238
5239
5240 /**
5241  * Get default striping.
5242  *
5243  * \param[in] env               execution environment
5244  * \param[in] lo                object
5245  * \param[out] lds              default striping
5246  *
5247  * \retval              0 on success
5248  * \retval              negative if failed
5249  */
5250 static int lod_get_default_lov_striping(const struct lu_env *env,
5251                                         struct lod_object *lo,
5252                                         struct lod_default_striping *lds,
5253                                         struct dt_allocation_hint *dah)
5254 {
5255         struct lod_thread_info *info = lod_env_info(env);
5256         struct lov_user_md_v1 *v1 = NULL;
5257         struct lov_user_md_v3 *v3 = NULL;
5258         struct lov_comp_md_v1 *lcm = NULL;
5259         __u32 magic;
5260         int append_stripe_count = dah != NULL ? dah->dah_append_stripe_count : 0;
5261         const char *append_pool = (dah != NULL &&
5262                                    dah->dah_append_pool != NULL &&
5263                                    dah->dah_append_pool[0] != '\0') ?
5264                                   dah->dah_append_pool : NULL;
5265         __u16 entry_count = 1;
5266         __u16 mirror_count = 0;
5267         bool want_composite = false;
5268         int rc, i, j;
5269
5270         ENTRY;
5271
5272         lds->lds_def_striping_set = 0;
5273
5274         rc = lod_get_lov_ea(env, lo);
5275         if (rc < 0)
5276                 RETURN(rc);
5277
5278         if (rc < (typeof(rc))sizeof(struct lov_user_md))
5279                 RETURN(0);
5280
5281         magic = *(__u32 *)info->lti_ea_store;
5282         if (magic == __swab32(LOV_USER_MAGIC_V1)) {
5283                 lustre_swab_lov_user_md_v1(info->lti_ea_store);
5284         } else if (magic == __swab32(LOV_USER_MAGIC_V3)) {
5285                 lustre_swab_lov_user_md_v3(info->lti_ea_store);
5286         } else if (magic == __swab32(LOV_USER_MAGIC_SPECIFIC)) {
5287                 v3 = (struct lov_user_md_v3 *)info->lti_ea_store;
5288                 lustre_swab_lov_user_md_v3(v3);
5289                 lustre_swab_lov_user_md_objects(v3->lmm_objects,
5290                                                 v3->lmm_stripe_count);
5291         } else if (magic == __swab32(LOV_USER_MAGIC_COMP_V1) ||
5292                    magic == __swab32(LOV_USER_MAGIC_SEL)) {
5293                 lustre_swab_lov_comp_md_v1(info->lti_ea_store);
5294         }
5295
5296         switch (magic) {
5297         case LOV_MAGIC_V1:
5298         case LOV_MAGIC_V3:
5299         case LOV_USER_MAGIC_SPECIFIC:
5300                 v1 = info->lti_ea_store;
5301                 break;
5302         case LOV_MAGIC_COMP_V1:
5303         case LOV_MAGIC_SEL:
5304                 lcm = info->lti_ea_store;
5305                 entry_count = lcm->lcm_entry_count;
5306                 if (entry_count == 0)
5307                         RETURN(-EINVAL);
5308
5309                 mirror_count = lcm->lcm_mirror_count + 1;
5310                 want_composite = true;
5311                 break;
5312         default:
5313                 RETURN(-ENOTSUPP);
5314         }
5315
5316         if (append_stripe_count != 0 || append_pool != NULL) {
5317                 entry_count = 1;
5318                 mirror_count = 0;
5319                 want_composite = false;
5320         }
5321
5322         /* realloc default comp entries if necessary */
5323         rc = lod_def_striping_comp_resize(lds, entry_count);
5324         if (rc < 0)
5325                 RETURN(rc);
5326
5327         lds->lds_def_comp_cnt = entry_count;
5328         lds->lds_def_striping_is_composite = want_composite;
5329         lds->lds_def_mirror_cnt = mirror_count;
5330
5331         for (i = 0; i < entry_count; i++) {
5332                 struct lod_layout_component *llc = &lds->lds_def_comp_entries[i];
5333                 const char *pool;
5334
5335                 /*
5336                  * reset llc values, llc_stripes is always NULL in the
5337                  * default striping template, llc_pool will be reset
5338                  * later below using lod_set_pool().
5339                  *
5340                  * XXX At this point llc_pool may point to valid (!)
5341                  * kmalloced strings from previous RPCs.
5342                  */
5343                 memset(llc, 0, offsetof(typeof(*llc), llc_pool));
5344
5345                 if (lcm != NULL) {
5346                         v1 = (struct lov_user_md *)((char *)lcm +
5347                                                     lcm->lcm_entries[i].lcme_offset);
5348
5349                         if (want_composite) {
5350                                 llc->llc_extent = lcm->lcm_entries[i].lcme_extent;
5351                                 /* We only inherit certain flags from the layout */
5352                                 llc->llc_flags = lcm->lcm_entries[i].lcme_flags &
5353                                         LCME_TEMPLATE_FLAGS;
5354                         }
5355                 }
5356
5357                 CDEBUG(D_LAYOUT, DFID" magic = %#08x, pattern = %#x, stripe_count = %hu, stripe_size = %u, stripe_offset = %hu, append_pool = '%s', append_stripe_count = %d\n",
5358                        PFID(lu_object_fid(&lo->ldo_obj.do_lu)),
5359                        v1->lmm_magic,
5360                        v1->lmm_pattern,
5361                        v1->lmm_stripe_count,
5362                        v1->lmm_stripe_size,
5363                        v1->lmm_stripe_offset,
5364                        append_pool ?: "",
5365                        append_stripe_count);
5366
5367                 if (!lov_pattern_supported(v1->lmm_pattern) &&
5368                     !(v1->lmm_pattern & LOV_PATTERN_F_RELEASED)) {
5369                         lod_free_def_comp_entries(lds);
5370                         RETURN(-EINVAL);
5371                 }
5372
5373                 llc->llc_stripe_count = v1->lmm_stripe_count;
5374                 llc->llc_stripe_size = v1->lmm_stripe_size;
5375                 llc->llc_stripe_offset = v1->lmm_stripe_offset;
5376                 llc->llc_pattern = v1->lmm_pattern;
5377
5378                 if (append_stripe_count != 0 || append_pool != NULL)
5379                         llc->llc_pattern = LOV_PATTERN_RAID0;
5380
5381                 if (append_stripe_count != 0)
5382                         llc->llc_stripe_count = append_stripe_count;
5383
5384                 pool = NULL;
5385                 if (append_pool != NULL) {
5386                         pool = append_pool;
5387                 } else if (v1->lmm_magic == LOV_USER_MAGIC_V3) {
5388                         /* XXX: sanity check here */
5389                         v3 = (struct lov_user_md_v3 *)v1;
5390                         if (v3->lmm_pool_name[0] != '\0')
5391                                 pool = v3->lmm_pool_name;
5392                 }
5393
5394                 lod_set_pool(&llc->llc_pool, pool);
5395
5396                 if (append_stripe_count != 0 || append_pool != NULL) {
5397                         /* Ignore specific striping for append. */
5398                 } else if (v1->lmm_magic == LOV_USER_MAGIC_SPECIFIC) {
5399                         v3 = (struct lov_user_md_v3 *)v1;
5400                         rc = lod_comp_copy_ost_lists(llc, v3);
5401                         if (rc)
5402                                 RETURN(rc);
5403                 } else if (llc->llc_ostlist.op_array &&
5404                            llc->llc_ostlist.op_count) {
5405                         for (j = 0; j < llc->llc_ostlist.op_count; j++)
5406                                 llc->llc_ostlist.op_array[j] = -1;
5407                         llc->llc_ostlist.op_count = 0;
5408                 }
5409         }
5410
5411         lds->lds_def_striping_set = 1;
5412         RETURN(rc);
5413 }
5414
5415 /**
5416  * Get default directory striping.
5417  *
5418  * \param[in] env               execution environment
5419  * \param[in] lo                object
5420  * \param[out] lds              default striping
5421  *
5422  * \retval              0 on success
5423  * \retval              negative if failed
5424  */
5425 static int lod_get_default_lmv_striping(const struct lu_env *env,
5426                                         struct lod_object *lo,
5427                                         struct lod_default_striping *lds)
5428 {
5429         struct lmv_user_md *lmu;
5430         int rc;
5431
5432         lds->lds_dir_def_striping_set = 0;
5433
5434         rc = lod_get_default_lmv_ea(env, lo);
5435         if (rc < 0)
5436                 return rc;
5437
5438         if (rc >= (int)sizeof(*lmu)) {
5439                 struct lod_thread_info *info = lod_env_info(env);
5440
5441                 lmu = info->lti_ea_store;
5442
5443                 lds->lds_dir_def_stripe_count =
5444                                 le32_to_cpu(lmu->lum_stripe_count);
5445                 lds->lds_dir_def_stripe_offset =
5446                                 le32_to_cpu(lmu->lum_stripe_offset);
5447                 lds->lds_dir_def_hash_type =
5448                                 le32_to_cpu(lmu->lum_hash_type);
5449                 lds->lds_dir_def_max_inherit = lmu->lum_max_inherit;
5450                 lds->lds_dir_def_max_inherit_rr = lmu->lum_max_inherit_rr;
5451                 lds->lds_dir_def_striping_set = 1;
5452         }
5453
5454         return 0;
5455 }
5456
5457 /**
5458  * Get default striping in the object.
5459  *
5460  * Get object default striping and default directory striping.
5461  *
5462  * \param[in] env               execution environment
5463  * \param[in] lo                object
5464  * \param[out] lds              default striping
5465  *
5466  * \retval              0 on success
5467  * \retval              negative if failed
5468  */
5469 static int lod_get_default_striping(const struct lu_env *env,
5470                                     struct lod_object *lo,
5471                                     struct lod_default_striping *lds)
5472 {
5473         int rc, rc1;
5474
5475         rc = lod_get_default_lov_striping(env, lo, lds, NULL);
5476         if (lds->lds_def_striping_set) {
5477                 struct lod_thread_info *info = lod_env_info(env);
5478                 struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
5479
5480                 rc = lod_verify_striping(env, d, lo, &info->lti_buf, false);
5481                 if (rc)
5482                         lds->lds_def_striping_set = 0;
5483         }
5484
5485         rc1 = lod_get_default_lmv_striping(env, lo, lds);
5486         if (rc == 0 && rc1 < 0)
5487                 rc = rc1;
5488
5489         return rc;
5490 }
5491
5492 /**
5493  * Apply default striping on object.
5494  *
5495  * If object striping pattern is not set, set to the one in default striping.
5496  * The default striping is from parent or fs.
5497  *
5498  * \param[in] lo                new object
5499  * \param[in] lds               default striping
5500  * \param[in] mode              new object's mode
5501  */
5502 static void lod_striping_from_default(struct lod_object *lo,
5503                                       const struct lod_default_striping *lds,
5504                                       umode_t mode)
5505 {
5506         struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
5507         int i, rc;
5508
5509         if (lds->lds_def_striping_set && S_ISREG(mode)) {
5510                 struct lov_desc *desc = &d->lod_ost_descs.ltd_lov_desc;
5511
5512                 rc = lod_alloc_comp_entries(lo, lds->lds_def_mirror_cnt,
5513                                             lds->lds_def_comp_cnt);
5514                 if (rc != 0)
5515                         return;
5516
5517                 lo->ldo_is_composite = lds->lds_def_striping_is_composite;
5518                 if (lds->lds_def_mirror_cnt > 1)
5519                         lo->ldo_flr_state = LCM_FL_RDONLY;
5520
5521                 for (i = 0; i < lo->ldo_comp_cnt; i++) {
5522                         struct lod_layout_component *obj_comp =
5523                                                 &lo->ldo_comp_entries[i];
5524                         struct lod_layout_component *def_comp =
5525                                                 &lds->lds_def_comp_entries[i];
5526
5527                         CDEBUG(D_LAYOUT,
5528                                "inherit "DFID" file layout from default: flags=%#x size=%hu nr=%u offset=%u pattern=%#x pool=%s\n",
5529                                PFID(lu_object_fid(&lo->ldo_obj.do_lu)),
5530                                def_comp->llc_flags,
5531                                def_comp->llc_stripe_size,
5532                                def_comp->llc_stripe_count,
5533                                def_comp->llc_stripe_offset,
5534                                def_comp->llc_pattern,
5535                                def_comp->llc_pool ?: "");
5536
5537                         *obj_comp = *def_comp;
5538                         if (def_comp->llc_pool != NULL) {
5539                                 /* pointer was copied from def_comp */
5540                                 obj_comp->llc_pool = NULL;
5541                                 lod_obj_set_pool(lo, i, def_comp->llc_pool);
5542                         }
5543
5544                         /* copy ost list */
5545                         if (def_comp->llc_ostlist.op_array &&
5546                             def_comp->llc_ostlist.op_count) {
5547                                 OBD_ALLOC(obj_comp->llc_ostlist.op_array,
5548                                           obj_comp->llc_ostlist.op_size);
5549                                 if (!obj_comp->llc_ostlist.op_array)
5550                                         return;
5551                                 memcpy(obj_comp->llc_ostlist.op_array,
5552                                        def_comp->llc_ostlist.op_array,
5553                                        obj_comp->llc_ostlist.op_size);
5554                         } else if (def_comp->llc_ostlist.op_array) {
5555                                 obj_comp->llc_ostlist.op_array = NULL;
5556                         }
5557
5558                         /*
5559                          * Don't initialize these fields for plain layout
5560                          * (v1/v3) here, they are inherited in the order of
5561                          * 'parent' -> 'fs default (root)' -> 'global default
5562                          * values for stripe_count & stripe_size'.
5563                          *
5564                          * see lod_ah_init().
5565                          */
5566                         if (!lo->ldo_is_composite)
5567                                 continue;
5568
5569                         lod_adjust_stripe_info(obj_comp, desc, 0);
5570                 }
5571         } else if (lds->lds_dir_def_striping_set && S_ISDIR(mode)) {
5572                 if (lo->ldo_dir_stripe_count == 0)
5573                         lo->ldo_dir_stripe_count =
5574                                 lds->lds_dir_def_stripe_count;
5575                 if (lo->ldo_dir_stripe_offset == -1)
5576                         lo->ldo_dir_stripe_offset =
5577                                 lds->lds_dir_def_stripe_offset;
5578                 if (lo->ldo_dir_hash_type == LMV_HASH_TYPE_UNKNOWN)
5579                         lo->ldo_dir_hash_type = lds->lds_dir_def_hash_type;
5580
5581                 CDEBUG(D_LAYOUT,
5582                        "inherit "DFID" dir layout from default: count=%hu offset=%u hash_type=%x\n",
5583                        PFID(lu_object_fid(&lo->ldo_obj.do_lu)),
5584                        lo->ldo_dir_stripe_count, lo->ldo_dir_stripe_offset,
5585                        lo->ldo_dir_hash_type);
5586         }
5587 }
5588
5589 static inline bool lod_need_inherit_more(struct lod_object *lo, bool from_root,
5590                                          const char *append_pool)
5591 {
5592         struct lod_layout_component *lod_comp;
5593
5594         if (lo->ldo_comp_cnt == 0)
5595                 return true;
5596
5597         if (lo->ldo_is_composite)
5598                 return false;
5599
5600         lod_comp = &lo->ldo_comp_entries[0];
5601
5602         if (lod_comp->llc_stripe_count <= 0 ||
5603             lod_comp->llc_stripe_size <= 0)
5604                 return true;
5605
5606         if (from_root && (lod_comp->llc_pool == NULL ||
5607                           lod_comp->llc_stripe_offset == LOV_OFFSET_DEFAULT))
5608                 return true;
5609
5610         if (append_pool && append_pool[0])
5611                 return true;
5612
5613         return false;
5614 }
5615
5616 /**
5617  * Implementation of dt_object_operations::do_ah_init.
5618  *
5619  * This method is used to make a decision on the striping configuration for the
5620  * object being created. It can be taken from the \a parent object if it exists,
5621  * or filesystem's default. The resulting configuration (number of stripes,
5622  * stripe size/offset, pool name, hash_type, etc.) is stored in the object
5623  * itself and will be used by the methods like ->doo_declare_create().
5624  *
5625  * \see dt_object_operations::do_ah_init() in the API description for details.
5626  */
5627 static void lod_ah_init(const struct lu_env *env,
5628                         struct dt_allocation_hint *ah,
5629                         struct dt_object *parent,
5630                         struct dt_object *child,
5631                         umode_t child_mode)
5632 {
5633         struct lod_device *d = lu2lod_dev(child->do_lu.lo_dev);
5634         struct lod_thread_info *info = lod_env_info(env);
5635         struct lod_default_striping *lds = lod_lds_buf_get(env);
5636         struct dt_object *nextp = NULL;
5637         struct dt_object *nextc;
5638         struct lod_object *lp = NULL;
5639         struct lod_object *lc;
5640         struct lov_desc *desc;
5641         struct lod_layout_component *lod_comp;
5642         int rc;
5643         ENTRY;
5644
5645         LASSERT(child);
5646
5647         if (ah->dah_append_stripe_count == -1)
5648                 ah->dah_append_stripe_count =
5649                         d->lod_ost_descs.ltd_lov_desc.ld_tgt_count;
5650
5651         if (likely(parent)) {
5652                 nextp = dt_object_child(parent);
5653                 lp = lod_dt_obj(parent);
5654         }
5655
5656         nextc = dt_object_child(child);
5657         lc = lod_dt_obj(child);
5658
5659         LASSERT(!lod_obj_is_striped(child));
5660         /* default layout template may have been set on the regular file
5661          * when this is called from mdd_create_data() */
5662         if (S_ISREG(child_mode))
5663                 lod_free_comp_entries(lc);
5664
5665         if (!dt_object_exists(nextc))
5666                 nextc->do_ops->do_ah_init(env, ah, nextp, nextc, child_mode);
5667
5668         if (S_ISDIR(child_mode)) {
5669                 const struct lmv_user_md_v1 *lum1 = ah->dah_eadata;
5670
5671                 /* other default values are 0 */
5672                 lc->ldo_dir_stripe_offset = -1;
5673
5674                 /* no default striping configuration is needed for
5675                  * foreign dirs
5676                  */
5677                 if (ah->dah_eadata != NULL && ah->dah_eadata_len != 0 &&
5678                     le32_to_cpu(lum1->lum_magic) == LMV_MAGIC_FOREIGN) {
5679                         lc->ldo_is_foreign = true;
5680                         /* keep stripe_count 0 and stripe_offset -1 */
5681                         CDEBUG(D_INFO, "no default striping for foreign dir\n");
5682                         RETURN_EXIT;
5683                 }
5684
5685                 if (likely(lp != NULL))
5686                         lod_get_default_striping(env, lp, lds);
5687
5688                 /* It should always honour the specified stripes */
5689                 /* Note: old client (< 2.7)might also do lfs mkdir, whose EA
5690                  * will have old magic. In this case, we should ignore the
5691                  * stripe count and try to create dir by default stripe.
5692                  */
5693                 if (ah->dah_eadata != NULL && ah->dah_eadata_len != 0 &&
5694                     (le32_to_cpu(lum1->lum_magic) == LMV_USER_MAGIC ||
5695                      le32_to_cpu(lum1->lum_magic) == LMV_USER_MAGIC_SPECIFIC)) {
5696                         lc->ldo_dir_stripe_count =
5697                                 le32_to_cpu(lum1->lum_stripe_count);
5698                         lc->ldo_dir_stripe_offset =
5699                                 le32_to_cpu(lum1->lum_stripe_offset);
5700                         lc->ldo_dir_hash_type =
5701                                 le32_to_cpu(lum1->lum_hash_type);
5702                         CDEBUG(D_INFO,
5703                                "set dirstripe: count %hu, offset %d, hash %x\n",
5704                                 lc->ldo_dir_stripe_count,
5705                                 (int)lc->ldo_dir_stripe_offset,
5706                                 lc->ldo_dir_hash_type);
5707
5708                         if (d->lod_mdt_descs.ltd_lmv_desc.ld_active_tgt_count &&
5709                             lc->ldo_dir_stripe_count < 2 &&
5710                             lum1->lum_max_inherit != LMV_INHERIT_NONE) {
5711                                 /* when filesystem-wide default LMV is set, dirs
5712                                  * will be created on MDT by space usage, but if
5713                                  * dir is created with "lfs mkdir -c 1 ...", its
5714                                  * subdirs should be kept on the same MDT. To
5715                                  * guarantee this, set default LMV for such dir.
5716                                  */
5717                                 lds->lds_dir_def_stripe_count =
5718                                         le32_to_cpu(lum1->lum_stripe_count);
5719                                 /* if "-1" stripe offset is set, save current
5720                                  * MDT index in default LMV.
5721                                  */
5722                                 if (le32_to_cpu(lum1->lum_stripe_offset) ==
5723                                     LMV_OFFSET_DEFAULT)
5724                                         lds->lds_dir_def_stripe_offset =
5725                                                 lod2lu_dev(d)->ld_site->ld_seq_site->ss_node_id;
5726                                 else
5727                                         lds->lds_dir_def_stripe_offset =
5728                                                 le32_to_cpu(lum1->lum_stripe_offset);
5729                                 lds->lds_dir_def_hash_type =
5730                                         le32_to_cpu(lum1->lum_hash_type);
5731                                 lds->lds_dir_def_max_inherit =
5732                                         lum1->lum_max_inherit;
5733                                 /* it will be decreased by 1 later in setting */
5734                                 if (lum1->lum_max_inherit >= LMV_INHERIT_END &&
5735                                     lum1->lum_max_inherit < LMV_INHERIT_MAX)
5736                                         lds->lds_dir_def_max_inherit++;
5737                                 lds->lds_dir_def_max_inherit_rr =
5738                                         lum1->lum_max_inherit_rr;
5739                                 lds->lds_dir_def_striping_set = 1;
5740                                 /* don't inherit LOV from ROOT */
5741                                 if (lds->lds_def_striping_set &&
5742                                     fid_is_root(lod_object_fid(lp)))
5743                                         lds->lds_def_striping_set = 0;
5744                                 lc->ldo_def_striping = lds;
5745                         } else if (lds->lds_def_striping_set &&
5746                                    !fid_is_root(lod_object_fid(lp))) {
5747                                 /* don't inherit default LMV for "lfs mkdir" */
5748                                 lds->lds_dir_def_striping_set = 0;
5749                                 lc->ldo_def_striping = lds;
5750                         }
5751                 } else {
5752                         /* inherit default striping except ROOT */
5753                         if ((lds->lds_def_striping_set ||
5754                              lds->lds_dir_def_striping_set) &&
5755                             !fid_is_root(lod_object_fid(lp)))
5756                                 lc->ldo_def_striping = lds;
5757
5758                         /* transfer defaults LMV to new directory */
5759                         lod_striping_from_default(lc, lds, child_mode);
5760
5761                         /* set count 0 to create normal directory */
5762                         if (lc->ldo_dir_stripe_count == 1)
5763                                 lc->ldo_dir_stripe_count = 0;
5764                 }
5765
5766                 /* shrink the stripe count to max_mdt_stripecount if it is -1
5767                  * and max_mdt_stripecount is not 0
5768                  */
5769                 if (lc->ldo_dir_stripe_count == (__u16)(-1) &&
5770                     d->lod_max_mdt_stripecount)
5771                         lc->ldo_dir_stripe_count = d->lod_max_mdt_stripecount;
5772
5773                 /* shrink the stripe_count to the avaible MDT count */
5774                 if (lc->ldo_dir_stripe_count > d->lod_remote_mdt_count + 1 &&
5775                     !OBD_FAIL_CHECK(OBD_FAIL_LARGE_STRIPE)) {
5776                         lc->ldo_dir_stripe_count = d->lod_remote_mdt_count + 1;
5777                         if (lc->ldo_dir_stripe_count == 1)
5778                                 lc->ldo_dir_stripe_count = 0;
5779                 }
5780
5781                 if (!lmv_is_known_hash_type(lc->ldo_dir_hash_type))
5782                         lc->ldo_dir_hash_type =
5783                                 (lc->ldo_dir_hash_type & LMV_HASH_FLAG_KNOWN) |
5784                                 d->lod_mdt_descs.ltd_lmv_desc.ld_pattern;
5785
5786                 CDEBUG(D_INFO, "final dir stripe_count=%hu offset=%d hash=%u\n",
5787                        lc->ldo_dir_stripe_count,
5788                        (int)lc->ldo_dir_stripe_offset, lc->ldo_dir_hash_type);
5789
5790                 RETURN_EXIT;
5791         }
5792
5793         /* child object regular file*/
5794
5795         if (!lod_object_will_be_striped(S_ISREG(child_mode),
5796                                         lu_object_fid(&child->do_lu)))
5797                 RETURN_EXIT;
5798
5799         /* If object is going to be striped over OSTs, transfer default
5800          * striping information to the child, so that we can use it
5801          * during declaration and creation.
5802          *
5803          * Try from the parent first.
5804          */
5805         if (likely(lp != NULL)) {
5806                 rc = lod_get_default_lov_striping(env, lp, lds, ah);
5807                 if (rc == 0 && lds->lds_def_striping_set) {
5808                         rc = lod_verify_striping(env, d, lp, &info->lti_buf,
5809                                                  false);
5810                         if (rc == 0)
5811                                 lod_striping_from_default(lc, lds, child_mode);
5812                 }
5813         }
5814
5815         /* Initialize lod_device::lod_md_root object reference */
5816         if (d->lod_md_root == NULL) {
5817                 struct dt_object *root;
5818                 struct lod_object *lroot;
5819
5820                 lu_root_fid(&info->lti_fid);
5821                 root = dt_locate(env, &d->lod_dt_dev, &info->lti_fid);
5822                 if (!IS_ERR(root)) {
5823                         lroot = lod_dt_obj(root);
5824
5825                         spin_lock(&d->lod_lock);
5826                         if (d->lod_md_root != NULL)
5827                                 dt_object_put(env, &d->lod_md_root->ldo_obj);
5828                         d->lod_md_root = lroot;
5829                         spin_unlock(&d->lod_lock);
5830                 }
5831         }
5832
5833         /* try inherit layout from the root object (fs default) when:
5834          *  - parent does not have default layout; or
5835          *  - parent has plain(v1/v3) default layout, and some attributes
5836          *    are not specified in the default layout;
5837          */
5838         if (d->lod_md_root != NULL &&
5839             lod_need_inherit_more(lc, true, ah->dah_append_pool)) {
5840                 rc = lod_get_default_lov_striping(env, d->lod_md_root, lds,
5841                                                   ah);
5842                 if (rc || !lds->lds_def_striping_set)
5843                         goto out;
5844
5845                 rc = lod_verify_striping(env, d, d->lod_md_root, &info->lti_buf,
5846                                          false);
5847                 if (rc)
5848                         goto out;
5849
5850                 if (lc->ldo_comp_cnt == 0) {
5851                         lod_striping_from_default(lc, lds, child_mode);
5852                 } else if (!lds->lds_def_striping_is_composite) {
5853                         struct lod_layout_component *def_comp;
5854
5855                         LASSERT(!lc->ldo_is_composite);
5856                         lod_comp = &lc->ldo_comp_entries[0];
5857                         def_comp = &lds->lds_def_comp_entries[0];
5858
5859                         if (lod_comp->llc_stripe_count <= 0)
5860                                 lod_comp->llc_stripe_count =
5861                                         def_comp->llc_stripe_count;
5862                         if (lod_comp->llc_stripe_size <= 0)
5863                                 lod_comp->llc_stripe_size =
5864                                         def_comp->llc_stripe_size;
5865                         if (lod_comp->llc_stripe_offset == LOV_OFFSET_DEFAULT &&
5866                             (!lod_comp->llc_pool || !lod_comp->llc_pool[0]))
5867                                 lod_comp->llc_stripe_offset =
5868                                         def_comp->llc_stripe_offset;
5869                         if (lod_comp->llc_pool == NULL)
5870                                 lod_obj_set_pool(lc, 0, def_comp->llc_pool);
5871                 }
5872         }
5873 out:
5874         /*
5875          * fs default striping may not be explicitly set, or historically set
5876          * in config log, use them.
5877          */
5878         if (lod_need_inherit_more(lc, false, ah->dah_append_pool)) {
5879                 if (lc->ldo_comp_cnt == 0) {
5880                         rc = lod_alloc_comp_entries(lc, 0, 1);
5881                         if (rc)
5882                                 /* fail to allocate memory, will create a
5883                                  * non-striped file. */
5884                                 RETURN_EXIT;
5885                         lc->ldo_is_composite = 0;
5886                         lod_comp = &lc->ldo_comp_entries[0];
5887                         lod_comp->llc_stripe_offset = LOV_OFFSET_DEFAULT;
5888                 }
5889                 LASSERT(!lc->ldo_is_composite);
5890                 lod_comp = &lc->ldo_comp_entries[0];
5891                 desc = &d->lod_ost_descs.ltd_lov_desc;
5892                 lod_adjust_stripe_info(lod_comp, desc,
5893                                        ah->dah_append_stripe_count);
5894                 if (ah->dah_append_pool && ah->dah_append_pool[0])
5895                         lod_obj_set_pool(lc, 0, ah->dah_append_pool);
5896         }
5897
5898         EXIT;
5899 }
5900
5901 /**
5902  * Size initialization on late striping.
5903  *
5904  * Propagate the size of a truncated object to a deferred striping.
5905  * This function handles a special case when truncate was done on a
5906  * non-striped object and now while the striping is being created
5907  * we can't lose that size, so we have to propagate it to the stripes
5908  * being created.
5909  *
5910  * \param[in] env       execution environment
5911  * \param[in] dt        object
5912  * \param[in] th        transaction handle
5913  *
5914  * \retval              0 on success
5915  * \retval              negative if failed
5916  */
5917 static int lod_declare_init_size(const struct lu_env *env,
5918                                  struct dt_object *dt, struct thandle *th)
5919 {
5920         struct dt_object        *next = dt_object_child(dt);
5921         struct lod_object       *lo = lod_dt_obj(dt);
5922         struct dt_object        **objects = NULL;
5923         struct lu_attr  *attr = &lod_env_info(env)->lti_attr;
5924         uint64_t        size, offs;
5925         int     i, rc, stripe, stripe_count = 0, stripe_size = 0;
5926         struct lu_extent size_ext;
5927         ENTRY;
5928
5929         if (!lod_obj_is_striped(dt))
5930                 RETURN(0);
5931
5932         rc = dt_attr_get(env, next, attr);
5933         LASSERT(attr->la_valid & LA_SIZE);
5934         if (rc)
5935                 RETURN(rc);
5936
5937         size = attr->la_size;
5938         if (size == 0)
5939                 RETURN(0);
5940
5941         size_ext = (typeof(size_ext)){ .e_start = size - 1, .e_end = size };
5942         for (i = 0; i < lo->ldo_comp_cnt; i++) {
5943                 struct lod_layout_component *lod_comp;
5944                 struct lu_extent *extent;
5945
5946                 lod_comp = &lo->ldo_comp_entries[i];
5947
5948                 if (lod_comp->llc_stripe == NULL)
5949                         continue;
5950
5951                 extent = &lod_comp->llc_extent;
5952                 CDEBUG(D_INFO, "%lld "DEXT"\n", size, PEXT(extent));
5953                 if (!lo->ldo_is_composite ||
5954                     lu_extent_is_overlapped(extent, &size_ext)) {
5955                         objects = lod_comp->llc_stripe;
5956                         stripe_count = lod_comp->llc_stripe_count;
5957                         stripe_size = lod_comp->llc_stripe_size;
5958
5959                         /* next mirror */
5960                         if (stripe_count == 0)
5961                                 continue;
5962
5963                         LASSERT(objects != NULL && stripe_size != 0);
5964                         do_div(size, stripe_size);
5965                         stripe = do_div(size, stripe_count);
5966                         LASSERT(objects[stripe] != NULL);
5967
5968                         size = size * stripe_size;
5969                         offs = attr->la_size;
5970                         size += do_div(offs, stripe_size);
5971
5972                         attr->la_valid = LA_SIZE;
5973                         attr->la_size = size;
5974
5975                         rc = lod_sub_declare_attr_set(env, objects[stripe],
5976                                                       attr, th);
5977                 }
5978         }
5979
5980         RETURN(rc);
5981 }
5982
5983 /**
5984  * Declare creation of striped object.
5985  *
5986  * The function declares creation stripes for a regular object. The function
5987  * also declares whether the stripes will be created with non-zero size if
5988  * previously size was set non-zero on the master object. If object \a dt is
5989  * not local, then only fully defined striping can be applied in \a lovea.
5990  * Otherwise \a lovea can be in the form of pattern, see lod_qos_parse_config()
5991  * for the details.
5992  *
5993  * \param[in] env       execution environment
5994  * \param[in] dt        object
5995  * \param[in] attr      attributes the stripes will be created with
5996  * \param[in] lovea     a buffer containing striping description
5997  * \param[in] th        transaction handle
5998  *
5999  * \retval              0 on success
6000  * \retval              negative if failed
6001  */
6002 int lod_declare_striped_create(const struct lu_env *env, struct dt_object *dt,
6003                                struct lu_attr *attr,
6004                                const struct lu_buf *lovea, struct thandle *th)
6005 {
6006         struct lod_thread_info  *info = lod_env_info(env);
6007         struct dt_object        *next = dt_object_child(dt);
6008         struct lod_object       *lo = lod_dt_obj(dt);
6009         int                      rc;
6010         ENTRY;
6011
6012         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_ALLOC_OBDO))
6013                 GOTO(out, rc = -ENOMEM);
6014
6015         if (!dt_object_remote(next)) {
6016                 /* choose OST and generate appropriate objects */
6017                 rc = lod_prepare_create(env, lo, attr, lovea, th);
6018                 if (rc)
6019                         GOTO(out, rc);
6020
6021                 /*
6022                  * declare storage for striping data
6023                  */
6024                 info->lti_buf.lb_len = lod_comp_md_size(lo, false);
6025         } else {
6026                 /* LOD can not choose OST objects for remote objects, i.e.
6027                  * stripes must be ready before that. Right now, it can only
6028                  * happen during migrate, i.e. migrate process needs to create
6029                  * remote regular file (mdd_migrate_create), then the migrate
6030                  * process will provide stripeEA. */
6031                 LASSERT(lovea != NULL);
6032                 info->lti_buf = *lovea;
6033         }
6034
6035         rc = lod_sub_declare_xattr_set(env, next, &info->lti_buf,
6036                                        XATTR_NAME_LOV, 0, th);
6037         if (rc)
6038                 GOTO(out, rc);
6039
6040         /*
6041          * if striping is created with local object's size > 0,
6042          * we have to propagate this size to specific object
6043          * the case is possible only when local object was created previously
6044          */
6045         if (dt_object_exists(next))
6046                 rc = lod_declare_init_size(env, dt, th);
6047
6048 out:
6049         /* failed to create striping or to set initial size, let's reset
6050          * config so that others don't get confused */
6051         if (rc)
6052                 lod_striping_free(env, lo);
6053
6054         RETURN(rc);
6055 }
6056
6057 /*
6058  * Whether subdirectories under \a dt should be created on MDTs by space QoS
6059  *
6060  * If LMV_HASH_FLAG_SPACE is set on directory default layout, its subdirectories
6061  * should be created on MDT by space QoS.
6062  *
6063  * \param[in] env       execution environment
6064  * \param[in] dev       lu device
6065  * \param[in] dt        object
6066  *
6067  * \retval              1 if directory should create subdir by space usage
6068  * \retval              0 if not
6069  * \retval              -ev if failed
6070  */
6071 static inline int dt_object_qos_mkdir(const struct lu_env *env,
6072                                       struct lu_device *dev,
6073                                       struct dt_object *dt)
6074 {
6075         struct lod_thread_info *info = lod_env_info(env);
6076         struct lu_object *obj;
6077         struct lod_object *lo;
6078         struct lmv_user_md *lmu;
6079         int rc;
6080
6081         obj = lu_object_find_slice(env, dev, lu_object_fid(&dt->do_lu), NULL);
6082         if (IS_ERR(obj))
6083                 return PTR_ERR(obj);
6084
6085         lo = lu2lod_obj(obj);
6086
6087         rc = lod_get_default_lmv_ea(env, lo);
6088         dt_object_put(env, dt);
6089         if (rc <= 0)
6090                 return rc;
6091
6092         if (rc < (int)sizeof(*lmu))
6093                 return -EINVAL;
6094
6095         lmu = info->lti_ea_store;
6096         return le32_to_cpu(lmu->lum_stripe_offset) == LMV_OFFSET_DEFAULT;
6097 }
6098
6099 /**
6100  * Implementation of dt_object_operations::do_declare_create.
6101  *
6102  * The method declares creation of a new object. If the object will be striped,
6103  * then helper functions are called to find FIDs for the stripes, declare
6104  * creation of the stripes and declare initialization of the striping
6105  * information to be stored in the master object.
6106  *
6107  * \see dt_object_operations::do_declare_create() in the API description
6108  * for details.
6109  */
6110 static int lod_declare_create(const struct lu_env *env, struct dt_object *dt,
6111                               struct lu_attr *attr,
6112                               struct dt_allocation_hint *hint,
6113                               struct dt_object_format *dof, struct thandle *th)
6114 {
6115         struct dt_object   *next = dt_object_child(dt);
6116         struct lod_object  *lo = lod_dt_obj(dt);
6117         int                 rc;
6118         ENTRY;
6119
6120         LASSERT(dof);
6121         LASSERT(attr);
6122         LASSERT(th);
6123
6124         /*
6125          * first of all, we declare creation of local object
6126          */
6127         rc = lod_sub_declare_create(env, next, attr, hint, dof, th);
6128         if (rc != 0)
6129                 GOTO(out, rc);
6130
6131         /*
6132          * it's lod_ah_init() that has decided the object will be striped
6133          */
6134         if (dof->dof_type == DFT_REGULAR) {
6135                 /* callers don't want stripes */
6136                 /* XXX: all tricky interactions with ->ah_make_hint() decided
6137                  * to use striping, then ->declare_create() behaving differently
6138                  * should be cleaned */
6139                 if (dof->u.dof_reg.striped != 0)
6140                         rc = lod_declare_striped_create(env, dt, attr,
6141                                                         NULL, th);
6142         } else if (dof->dof_type == DFT_DIR) {
6143                 struct seq_server_site *ss;
6144                 struct lu_buf buf = { NULL };
6145                 struct lu_buf *lmu = NULL;
6146
6147                 ss = lu_site2seq(dt->do_lu.lo_dev->ld_site);
6148
6149                 /* If the parent has default stripeEA, and client
6150                  * did not find it before sending create request,
6151                  * then MDT will return -EREMOTE, and client will
6152                  * retrieve the default stripeEA and re-create the
6153                  * sub directory.
6154                  *
6155                  * Note: if dah_eadata != NULL, it means creating the
6156                  * striped directory with specified stripeEA, then it
6157                  * should ignore the default stripeEA */
6158                 if (hint != NULL && hint->dah_eadata == NULL) {
6159                         if (OBD_FAIL_CHECK(OBD_FAIL_MDS_STALE_DIR_LAYOUT))
6160                                 GOTO(out, rc = -EREMOTE);
6161
6162                         if (lo->ldo_dir_stripe_offset != LMV_OFFSET_DEFAULT &&
6163                             lo->ldo_dir_stripe_offset != ss->ss_node_id) {
6164                                 struct lod_device *lod;
6165                                 struct lu_tgt_desc *mdt = NULL;
6166                                 bool found_mdt = false;
6167
6168                                 lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
6169                                 lod_foreach_mdt(lod, mdt) {
6170                                         if (mdt->ltd_index ==
6171                                                 lo->ldo_dir_stripe_offset) {
6172                                                 found_mdt = true;
6173                                                 break;
6174                                         }
6175                                 }
6176
6177                                 /* If the MDT indicated by stripe_offset can be
6178                                  * found, then tell client to resend the create
6179                                  * request to the correct MDT, otherwise return
6180                                  * error to client */
6181                                 if (found_mdt)
6182                                         GOTO(out, rc = -EREMOTE);
6183                                 else
6184                                         GOTO(out, rc = -EINVAL);
6185                         }
6186                 } else if (hint && hint->dah_eadata) {
6187                         lmu = &buf;
6188                         lmu->lb_buf = (void *)hint->dah_eadata;
6189                         lmu->lb_len = hint->dah_eadata_len;
6190                 }
6191
6192                 rc = lod_declare_dir_striping_create(env, dt, attr, lmu, dof,
6193                                                      th);
6194         }
6195 out:
6196         /* failed to create striping or to set initial size, let's reset
6197          * config so that others don't get confused */
6198         if (rc)
6199                 lod_striping_free(env, lo);
6200         RETURN(rc);
6201 }
6202
6203 /**
6204  * Generate component ID for new created component.
6205  *
6206  * \param[in] lo                LOD object
6207  * \param[in] comp_idx          index of ldo_comp_entries
6208  *
6209  * \retval                      component ID on success
6210  * \retval                      LCME_ID_INVAL on failure
6211  */
6212 static __u32 lod_gen_component_id(struct lod_object *lo,
6213                                   int mirror_id, int comp_idx)
6214 {
6215         struct lod_layout_component *lod_comp;
6216         __u32   id, start, end;
6217         int     i;
6218
6219         LASSERT(lo->ldo_comp_entries[comp_idx].llc_id == LCME_ID_INVAL);
6220
6221         lod_obj_inc_layout_gen(lo);
6222         id = lo->ldo_layout_gen;
6223         if (likely(id <= SEQ_ID_MAX))
6224                 RETURN(pflr_id(mirror_id, id & SEQ_ID_MASK));
6225
6226         /* Layout generation wraps, need to check collisions. */
6227         start = id & SEQ_ID_MASK;
6228         end = SEQ_ID_MAX;
6229 again:
6230         for (id = start; id <= end; id++) {
6231                 for (i = 0; i < lo->ldo_comp_cnt; i++) {
6232                         lod_comp = &lo->ldo_comp_entries[i];
6233                         if (pflr_id(mirror_id, id) == lod_comp->llc_id)
6234                                 break;
6235                 }
6236                 /* Found the ununsed ID */
6237                 if (i == lo->ldo_comp_cnt)
6238                         RETURN(pflr_id(mirror_id, id));
6239         }
6240         if (end == LCME_ID_MAX) {
6241                 start = 1;
6242                 end = min(lo->ldo_layout_gen & LCME_ID_MASK,
6243                           (__u32)(LCME_ID_MAX - 1));
6244                 goto again;
6245         }
6246
6247         RETURN(LCME_ID_INVAL);
6248 }
6249
6250 /**
6251  * Creation of a striped regular object.
6252  *
6253  * The function is called to create the stripe objects for a regular
6254  * striped file. This can happen at the initial object creation or
6255  * when the caller asks LOD to do so using ->do_xattr_set() method
6256  * (so called late striping). Notice all the information are already
6257  * prepared in the form of the list of objects (ldo_stripe field).
6258  * This is done during declare phase.
6259  *
6260  * \param[in] env       execution environment
6261  * \param[in] dt        object
6262  * \param[in] attr      attributes the stripes will be created with
6263  * \param[in] dof       format of stripes (see OSD API description)
6264  * \param[in] th        transaction handle
6265  *
6266  * \retval              0 on success
6267  * \retval              negative if failed
6268  */
6269 int lod_striped_create(const struct lu_env *env, struct dt_object *dt,
6270                        struct lu_attr *attr, struct dt_object_format *dof,
6271                        struct thandle *th)
6272 {
6273         struct lod_layout_component     *lod_comp;
6274         struct lod_object       *lo = lod_dt_obj(dt);
6275         __u16   mirror_id;
6276         int     rc = 0, i, j;
6277         ENTRY;
6278
6279         mutex_lock(&lo->ldo_layout_mutex);
6280
6281         LASSERT((lo->ldo_comp_cnt != 0 && lo->ldo_comp_entries != NULL) ||
6282                 lo->ldo_is_foreign);
6283
6284         mirror_id = 0; /* non-flr file's mirror_id is 0 */
6285         if (lo->ldo_mirror_count > 1) {
6286                 for (i = 0; i < lo->ldo_comp_cnt; i++) {
6287                         lod_comp = &lo->ldo_comp_entries[i];
6288                         if (lod_comp->llc_id != LCME_ID_INVAL &&
6289                             mirror_id_of(lod_comp->llc_id) > mirror_id)
6290                                 mirror_id = mirror_id_of(lod_comp->llc_id);
6291                 }
6292         }
6293
6294         /* create all underlying objects */
6295         for (i = 0; i < lo->ldo_comp_cnt; i++) {
6296                 lod_comp = &lo->ldo_comp_entries[i];
6297
6298                 if (lod_comp->llc_id == LCME_ID_INVAL) {
6299                         /* only the component of FLR layout with more than 1
6300                          * mirror has mirror ID in its component ID.
6301                          */
6302                         if (lod_comp->llc_extent.e_start == 0 &&
6303                             lo->ldo_mirror_count > 1)
6304                                 ++mirror_id;
6305
6306                         lod_comp->llc_id = lod_gen_component_id(lo,
6307                                                                 mirror_id, i);
6308                         if (lod_comp->llc_id == LCME_ID_INVAL)
6309                                 GOTO(out, rc = -ERANGE);
6310                 }
6311
6312                 if (lod_comp_inited(lod_comp))
6313                         continue;
6314
6315                 if (lod_comp->llc_pattern & LOV_PATTERN_F_RELEASED)
6316                         lod_comp_set_init(lod_comp);
6317
6318                 if (lov_pattern(lod_comp->llc_pattern) == LOV_PATTERN_MDT)
6319                         lod_comp_set_init(lod_comp);
6320
6321                 if (lod_comp->llc_stripe == NULL)
6322                         continue;
6323
6324                 LASSERT(lod_comp->llc_stripe_count);
6325                 for (j = 0; j < lod_comp->llc_stripe_count; j++) {
6326                         struct dt_object *object = lod_comp->llc_stripe[j];
6327                         LASSERT(object != NULL);
6328                         rc = lod_sub_create(env, object, attr, NULL, dof, th);
6329                         if (rc)
6330                                 GOTO(out, rc);
6331                 }
6332                 lod_comp_set_init(lod_comp);
6333         }
6334
6335         rc = lod_fill_mirrors(lo);
6336         if (rc)
6337                 GOTO(out, rc);
6338
6339         lo->ldo_comp_cached = 1;
6340
6341         rc = lod_generate_and_set_lovea(env, lo, th);
6342         if (rc)
6343                 GOTO(out, rc);
6344
6345         mutex_unlock(&lo->ldo_layout_mutex);
6346
6347         RETURN(0);
6348
6349 out:
6350         lod_striping_free_nolock(env, lo);
6351         mutex_unlock(&lo->ldo_layout_mutex);
6352
6353         RETURN(rc);
6354 }
6355
6356 static inline bool lod_obj_is_dom(struct dt_object *dt)
6357 {
6358         struct lod_object *lo = lod_dt_obj(dt);
6359
6360         if (!dt_object_exists(dt_object_child(dt)))
6361                 return false;
6362
6363         if (S_ISDIR(dt->do_lu.lo_header->loh_attr))
6364                 return false;
6365
6366         if (!lo->ldo_comp_cnt)
6367                 return false;
6368
6369         return (lov_pattern(lo->ldo_comp_entries[0].llc_pattern) ==
6370                 LOV_PATTERN_MDT);
6371 }
6372
6373 /**
6374  * Implementation of dt_object_operations::do_create.
6375  *
6376  * If any of preceeding methods (like ->do_declare_create(),
6377  * ->do_ah_init(), etc) chose to create a striped object,
6378  * then this method will create the master and the stripes.
6379  *
6380  * \see dt_object_operations::do_create() in the API description for details.
6381  */
6382 static int lod_create(const struct lu_env *env, struct dt_object *dt,
6383                       struct lu_attr *attr, struct dt_allocation_hint *hint,
6384                       struct dt_object_format *dof, struct thandle *th)
6385 {
6386         int                 rc;
6387         ENTRY;
6388
6389         /* create local object */
6390         rc = lod_sub_create(env, dt_object_child(dt), attr, hint, dof, th);
6391         if (rc != 0)
6392                 RETURN(rc);
6393
6394         if (S_ISREG(dt->do_lu.lo_header->loh_attr) &&
6395             (lod_obj_is_striped(dt) || lod_obj_is_dom(dt)) &&
6396             dof->u.dof_reg.striped != 0) {
6397                 LASSERT(lod_dt_obj(dt)->ldo_comp_cached == 0);
6398                 rc = lod_striped_create(env, dt, attr, dof, th);
6399         }
6400
6401         RETURN(rc);
6402 }
6403
6404 static inline int
6405 lod_obj_stripe_destroy_cb(const struct lu_env *env, struct lod_object *lo,
6406                           struct dt_object *dt, struct thandle *th,
6407                           int comp_idx, int stripe_idx,
6408                           struct lod_obj_stripe_cb_data *data)
6409 {
6410         if (data->locd_declare)
6411                 return lod_sub_declare_destroy(env, dt, th);
6412
6413         if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
6414             stripe_idx == cfs_fail_val)
6415                 return lod_sub_destroy(env, dt, th);
6416
6417         return 0;
6418 }
6419
6420 /**
6421  * Implementation of dt_object_operations::do_declare_destroy.
6422  *
6423  * If the object is a striped directory, then the function declares reference
6424  * removal from the master object (this is an index) to the stripes and declares
6425  * destroy of all the stripes. In all the cases, it declares an intention to
6426  * destroy the object itself.
6427  *
6428  * \see dt_object_operations::do_declare_destroy() in the API description
6429  * for details.
6430  */
6431 static int lod_declare_destroy(const struct lu_env *env, struct dt_object *dt,
6432                                struct thandle *th)
6433 {
6434         struct dt_object *next = dt_object_child(dt);
6435         struct lod_object *lo = lod_dt_obj(dt);
6436         struct lod_thread_info *info = lod_env_info(env);
6437         struct dt_object *stripe;
6438         char *stripe_name = info->lti_key;
6439         int rc, i;
6440
6441         ENTRY;
6442
6443         /*
6444          * load striping information, notice we don't do this when object
6445          * is being initialized as we don't need this information till
6446          * few specific cases like destroy, chown
6447          */
6448         rc = lod_striping_load(env, lo);
6449         if (rc)
6450                 RETURN(rc);
6451
6452         /* declare destroy for all underlying objects */
6453         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
6454                 rc = next->do_ops->do_index_try(env, next,
6455                                                 &dt_directory_features);
6456                 if (rc != 0)
6457                         RETURN(rc);
6458
6459                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6460                         stripe = lo->ldo_stripe[i];
6461                         if (!stripe)
6462                                 continue;
6463
6464                         rc = lod_sub_declare_ref_del(env, next, th);
6465                         if (rc != 0)
6466                                 RETURN(rc);
6467
6468                         snprintf(stripe_name, sizeof(info->lti_key),
6469                                  DFID":%d",
6470                                  PFID(lu_object_fid(&stripe->do_lu)), i);
6471                         rc = lod_sub_declare_delete(env, next,
6472                                         (const struct dt_key *)stripe_name, th);
6473                         if (rc != 0)
6474                                 RETURN(rc);
6475                 }
6476         }
6477
6478         /*
6479          * we declare destroy for the local object
6480          */
6481         rc = lod_sub_declare_destroy(env, next, th);
6482         if (rc)
6483                 RETURN(rc);
6484
6485         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ) ||
6486             OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ2))
6487                 RETURN(0);
6488
6489         if (!lod_obj_is_striped(dt))
6490                 RETURN(0);
6491
6492         /* declare destroy all striped objects */
6493         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
6494                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6495                         stripe = lo->ldo_stripe[i];
6496                         if (!stripe)
6497                                 continue;
6498
6499                         if (!dt_object_exists(stripe))
6500                                 continue;
6501
6502                         rc = lod_sub_declare_ref_del(env, stripe, th);
6503                         if (rc != 0)
6504                                 break;
6505
6506                         rc = lod_sub_declare_destroy(env, stripe, th);
6507                         if (rc != 0)
6508                                 break;
6509                 }
6510         } else {
6511                 struct lod_obj_stripe_cb_data data = { { 0 } };
6512
6513                 data.locd_declare = true;
6514                 data.locd_stripe_cb = lod_obj_stripe_destroy_cb;
6515                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
6516         }
6517
6518         RETURN(rc);
6519 }
6520
6521 /**
6522  * Implementation of dt_object_operations::do_destroy.
6523  *
6524  * If the object is a striped directory, then the function removes references
6525  * from the master object (this is an index) to the stripes and destroys all
6526  * the stripes. In all the cases, the function destroys the object itself.
6527  *
6528  * \see dt_object_operations::do_destroy() in the API description for details.
6529  */
6530 static int lod_destroy(const struct lu_env *env, struct dt_object *dt,
6531                        struct thandle *th)
6532 {
6533         struct dt_object  *next = dt_object_child(dt);
6534         struct lod_object *lo = lod_dt_obj(dt);
6535         struct lod_thread_info *info = lod_env_info(env);
6536         char *stripe_name = info->lti_key;
6537         struct dt_object *stripe;
6538         unsigned int i;
6539         int rc;
6540
6541         ENTRY;
6542
6543         /* destroy sub-stripe of master object */
6544         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
6545                 rc = next->do_ops->do_index_try(env, next,
6546                                                 &dt_directory_features);
6547                 if (rc != 0)
6548                         RETURN(rc);
6549
6550                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6551                         stripe = lo->ldo_stripe[i];
6552                         if (!stripe)
6553                                 continue;
6554
6555                         rc = lod_sub_ref_del(env, next, th);
6556                         if (rc != 0)
6557                                 RETURN(rc);
6558
6559                         snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
6560                                 PFID(lu_object_fid(&stripe->do_lu)), i);
6561
6562                         CDEBUG(D_INFO, DFID" delete stripe %s "DFID"\n",
6563                                PFID(lu_object_fid(&dt->do_lu)), stripe_name,
6564                                PFID(lu_object_fid(&stripe->do_lu)));
6565
6566                         rc = lod_sub_delete(env, next,
6567                                        (const struct dt_key *)stripe_name, th);
6568                         if (rc != 0)
6569                                 RETURN(rc);
6570                 }
6571         }
6572
6573         rc = lod_sub_destroy(env, next, th);
6574         if (rc != 0)
6575                 RETURN(rc);
6576
6577         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ) ||
6578             OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_MDTOBJ2))
6579                 RETURN(0);
6580
6581         if (!lod_obj_is_striped(dt))
6582                 RETURN(0);
6583
6584         /* destroy all striped objects */
6585         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
6586                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6587                         stripe = lo->ldo_stripe[i];
6588                         if (!stripe)
6589                                 continue;
6590
6591                         if (!dt_object_exists(stripe))
6592                                 continue;
6593
6594                         if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LOST_SPEOBJ) ||
6595                             i == cfs_fail_val) {
6596                                 dt_write_lock(env, stripe, DT_TGT_CHILD);
6597                                 rc = lod_sub_ref_del(env, stripe, th);
6598                                 dt_write_unlock(env, stripe);
6599                                 if (rc != 0)
6600                                         break;
6601
6602                                 rc = lod_sub_destroy(env, stripe, th);
6603                                 if (rc != 0)
6604                                         break;
6605                         }
6606                 }
6607         } else {
6608                 struct lod_obj_stripe_cb_data data = { { 0 } };
6609
6610                 data.locd_declare = false;
6611                 data.locd_stripe_cb = lod_obj_stripe_destroy_cb;
6612                 rc = lod_obj_for_each_stripe(env, lo, th, &data);
6613         }
6614
6615         RETURN(rc);
6616 }
6617
6618 /**
6619  * Implementation of dt_object_operations::do_declare_ref_add.
6620  *
6621  * \see dt_object_operations::do_declare_ref_add() in the API description
6622  * for details.
6623  */
6624 static int lod_declare_ref_add(const struct lu_env *env,
6625                                struct dt_object *dt, struct thandle *th)
6626 {
6627         return lod_sub_declare_ref_add(env, dt_object_child(dt), th);
6628 }
6629
6630 /**
6631  * Implementation of dt_object_operations::do_ref_add.
6632  *
6633  * \see dt_object_operations::do_ref_add() in the API description for details.
6634  */
6635 static int lod_ref_add(const struct lu_env *env,
6636                        struct dt_object *dt, struct thandle *th)
6637 {
6638         return lod_sub_ref_add(env, dt_object_child(dt), th);
6639 }
6640
6641 /**
6642  * Implementation of dt_object_operations::do_declare_ref_del.
6643  *
6644  * \see dt_object_operations::do_declare_ref_del() in the API description
6645  * for details.
6646  */
6647 static int lod_declare_ref_del(const struct lu_env *env,
6648                                struct dt_object *dt, struct thandle *th)
6649 {
6650         return lod_sub_declare_ref_del(env, dt_object_child(dt), th);
6651 }
6652
6653 /**
6654  * Implementation of dt_object_operations::do_ref_del
6655  *
6656  * \see dt_object_operations::do_ref_del() in the API description for details.
6657  */
6658 static int lod_ref_del(const struct lu_env *env,
6659                        struct dt_object *dt, struct thandle *th)
6660 {
6661         return lod_sub_ref_del(env, dt_object_child(dt), th);
6662 }
6663
6664 /**
6665  * Implementation of dt_object_operations::do_object_sync.
6666  *
6667  * \see dt_object_operations::do_object_sync() in the API description
6668  * for details.
6669  */
6670 static int lod_object_sync(const struct lu_env *env, struct dt_object *dt,
6671                            __u64 start, __u64 end)
6672 {
6673         return dt_object_sync(env, dt_object_child(dt), start, end);
6674 }
6675
6676 /**
6677  * Implementation of dt_object_operations::do_object_unlock.
6678  *
6679  * Used to release LDLM lock(s).
6680  *
6681  * \see dt_object_operations::do_object_unlock() in the API description
6682  * for details.
6683  */
6684 static int lod_object_unlock(const struct lu_env *env, struct dt_object *dt,
6685                              struct ldlm_enqueue_info *einfo,
6686                              union ldlm_policy_data *policy)
6687 {
6688         struct lod_object *lo = lod_dt_obj(dt);
6689         struct lustre_handle_array *slave_locks = einfo->ei_cbdata;
6690         int slave_locks_size;
6691         int i;
6692         ENTRY;
6693
6694         if (slave_locks == NULL)
6695                 RETURN(0);
6696
6697         LASSERT(S_ISDIR(dt->do_lu.lo_header->loh_attr));
6698         /* Note: for remote lock for single stripe dir, MDT will cancel
6699          * the lock by lockh directly */
6700         LASSERT(!dt_object_remote(dt_object_child(dt)));
6701
6702         /* locks were unlocked in MDT layer */
6703         for (i = 0; i < slave_locks->ha_count; i++)
6704                 LASSERT(!lustre_handle_is_used(&slave_locks->ha_handles[i]));
6705
6706         /*
6707          * NB, ha_count may not equal to ldo_dir_stripe_count, because dir
6708          * layout may change, e.g., shrink dir layout after migration.
6709          */
6710         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6711                 if (lo->ldo_stripe[i])
6712                         dt_invalidate(env, lo->ldo_stripe[i]);
6713         }
6714
6715         slave_locks_size = offsetof(typeof(*slave_locks),
6716                                     ha_handles[slave_locks->ha_count]);
6717         OBD_FREE(slave_locks, slave_locks_size);
6718         einfo->ei_cbdata = NULL;
6719
6720         RETURN(0);
6721 }
6722
6723 /**
6724  * Implementation of dt_object_operations::do_object_lock.
6725  *
6726  * Used to get LDLM lock on the non-striped and striped objects.
6727  *
6728  * \see dt_object_operations::do_object_lock() in the API description
6729  * for details.
6730  */
6731 static int lod_object_lock(const struct lu_env *env,
6732                            struct dt_object *dt,
6733                            struct lustre_handle *lh,
6734                            struct ldlm_enqueue_info *einfo,
6735                            union ldlm_policy_data *policy)
6736 {
6737         struct lod_object *lo = lod_dt_obj(dt);
6738         int slave_locks_size;
6739         struct lustre_handle_array *slave_locks = NULL;
6740         int i;
6741         int rc;
6742         ENTRY;
6743
6744         /* remote object lock */
6745         if (!einfo->ei_enq_slave) {
6746                 LASSERT(dt_object_remote(dt));
6747                 return dt_object_lock(env, dt_object_child(dt), lh, einfo,
6748                                       policy);
6749         }
6750
6751         if (!S_ISDIR(dt->do_lu.lo_header->loh_attr))
6752                 RETURN(-ENOTDIR);
6753
6754         rc = lod_striping_load(env, lo);
6755         if (rc != 0)
6756                 RETURN(rc);
6757
6758         /* No stripes */
6759         if (lo->ldo_dir_stripe_count <= 1)
6760                 RETURN(0);
6761
6762         slave_locks_size = offsetof(typeof(*slave_locks),
6763                                     ha_handles[lo->ldo_dir_stripe_count]);
6764         /* Freed in lod_object_unlock */
6765         OBD_ALLOC(slave_locks, slave_locks_size);
6766         if (!slave_locks)
6767                 RETURN(-ENOMEM);
6768         slave_locks->ha_count = lo->ldo_dir_stripe_count;
6769
6770         /* striped directory lock */
6771         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
6772                 struct lustre_handle lockh;
6773                 struct ldlm_res_id *res_id;
6774                 struct dt_object *stripe;
6775
6776                 stripe = lo->ldo_stripe[i];
6777                 if (!stripe)
6778                         continue;
6779
6780                 res_id = &lod_env_info(env)->lti_res_id;
6781                 fid_build_reg_res_name(lu_object_fid(&stripe->do_lu), res_id);
6782                 einfo->ei_res_id = res_id;
6783
6784                 if (dt_object_remote(stripe)) {
6785                         set_bit(i, (void *)slave_locks->ha_map);
6786                         rc = dt_object_lock(env, stripe, &lockh, einfo, policy);
6787                 } else {
6788                         struct ldlm_namespace *ns = einfo->ei_namespace;
6789                         ldlm_blocking_callback blocking = einfo->ei_cb_local_bl;
6790                         ldlm_completion_callback completion = einfo->ei_cb_cp;
6791                         __u64 dlmflags = LDLM_FL_ATOMIC_CB;
6792
6793                         if (einfo->ei_mode == LCK_PW ||
6794                             einfo->ei_mode == LCK_EX)
6795                                 dlmflags |= LDLM_FL_COS_INCOMPAT;
6796
6797                         LASSERT(ns != NULL);
6798                         rc = ldlm_cli_enqueue_local(env, ns, res_id, LDLM_IBITS,
6799                                                     policy, einfo->ei_mode,
6800                                                     &dlmflags, blocking,
6801                                                     completion, NULL,
6802                                                     NULL, 0, LVB_T_NONE,
6803                                                     NULL, &lockh);
6804                 }
6805                 if (rc) {
6806                         while (i--)
6807                                 ldlm_lock_decref_and_cancel(
6808                                                 &slave_locks->ha_handles[i],
6809                                                 einfo->ei_mode);
6810                         OBD_FREE(slave_locks, slave_locks_size);
6811                         RETURN(rc);
6812                 }
6813                 slave_locks->ha_handles[i] = lockh;
6814         }
6815         einfo->ei_cbdata = slave_locks;
6816
6817         RETURN(0);
6818 }
6819
6820 /**
6821  * Implementation of dt_object_operations::do_invalidate.
6822  *
6823  * \see dt_object_operations::do_invalidate() in the API description for details
6824  */
6825 static int lod_invalidate(const struct lu_env *env, struct dt_object *dt)
6826 {
6827         return dt_invalidate(env, dt_object_child(dt));
6828 }
6829
6830 static int lod_declare_instantiate_components(const struct lu_env *env,
6831                                               struct lod_object *lo,
6832                                               struct thandle *th,
6833                                               __u64 reserve)
6834 {
6835         struct lod_thread_info *info = lod_env_info(env);
6836         int i;
6837         int rc = 0;
6838         ENTRY;
6839
6840         LASSERT(info->lti_count < lo->ldo_comp_cnt);
6841
6842         for (i = 0; i < info->lti_count; i++) {
6843                 rc = lod_qos_prep_create(env, lo, NULL, th,
6844                                          info->lti_comp_idx[i], reserve);
6845                 if (rc)
6846                         break;
6847         }
6848
6849         if (!rc) {
6850                 info->lti_buf.lb_len = lod_comp_md_size(lo, false);
6851                 rc = lod_sub_declare_xattr_set(env, lod_object_child(lo),
6852                                 &info->lti_buf, XATTR_NAME_LOV, 0, th);
6853         }
6854
6855         RETURN(rc);
6856 }
6857
6858 /**
6859  * Check OSTs for an existing component for further extension
6860  *
6861  * Checks if OSTs are still healthy and not out of space.  Gets free space
6862  * on OSTs (relative to allocation watermark rmb_low) and compares to
6863  * the proposed new_end for this component.
6864  *
6865  * Decides whether or not to extend a component on its current OSTs.
6866  *
6867  * \param[in] env               execution environment for this thread
6868  * \param[in] lo                object we're checking
6869  * \param[in] index             index of this component
6870  * \param[in] extension_size    extension size for this component
6871  * \param[in] extent            layout extent for requested operation
6872  * \param[in] comp_extent       extension component extent
6873  * \param[in] write             if this is write operation
6874  *
6875  * \retval      true - OK to extend on current OSTs
6876  * \retval      false - do not extend on current OSTs
6877  */
6878 static bool lod_sel_osts_allowed(const struct lu_env *env,
6879                                  struct lod_object *lo,
6880                                  int index, __u64 reserve,
6881                                  struct lu_extent *extent,
6882                                  struct lu_extent *comp_extent, int write)
6883 {
6884         struct lod_layout_component *lod_comp = &lo->ldo_comp_entries[index];
6885         struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
6886         struct lod_thread_info *tinfo = lod_env_info(env);
6887         struct obd_statfs *sfs = &tinfo->lti_osfs;
6888         __u64 available = 0;
6889         bool ret = true;
6890         int i, rc;
6891
6892         ENTRY;
6893
6894         LASSERT(lod_comp->llc_stripe_count != 0);
6895
6896         lod_getref(&lod->lod_ost_descs);
6897         for (i = 0; i < lod_comp->llc_stripe_count; i++) {
6898                 int index = lod_comp->llc_ost_indices[i];
6899                 struct lod_tgt_desc *ost = OST_TGT(lod, index);
6900                 struct obd_statfs_info info = { 0 };
6901                 int j, repeated = 0;
6902
6903                 LASSERT(ost);
6904
6905                 /* Get the number of times this OST repeats in this component.
6906                  * Note: inter-component repeats are not counted as this is
6907                  * considered as a rare case: we try to not repeat OST in other
6908                  * components if possible. */
6909                 for (j = 0; j < lod_comp->llc_stripe_count; j++) {
6910                         if (index != lod_comp->llc_ost_indices[j])
6911                                 continue;
6912
6913                         /* already handled */
6914                         if (j < i)
6915                                 break;
6916
6917                         repeated++;
6918                 }
6919                 if (j < lod_comp->llc_stripe_count)
6920                         continue;
6921
6922                 if (!test_bit(index, lod->lod_ost_bitmap)) {
6923                         CDEBUG(D_LAYOUT, "ost %d no longer present\n", index);
6924                         ret = false;
6925                         break;
6926                 }
6927
6928                 rc = dt_statfs_info(env, ost->ltd_tgt, sfs, &info);
6929                 if (rc) {
6930                         CDEBUG(D_LAYOUT, "statfs failed for ost %d, error %d\n",
6931                                index, rc);
6932                         ret = false;
6933                         break;
6934                 }
6935
6936                 if (sfs->os_state & OS_STATFS_ENOSPC ||
6937                     sfs->os_state & OS_STATFS_READONLY ||
6938                     sfs->os_state & OS_STATFS_DEGRADED) {
6939                         CDEBUG(D_LAYOUT, "ost %d is not availble for SEL "
6940                                "extension, state %u\n", index, sfs->os_state);
6941                         ret = false;
6942                         break;
6943                 }
6944
6945                 /* In bytes */
6946                 available = sfs->os_bavail * sfs->os_bsize;
6947                 /* 'available' is relative to the allocation threshold */
6948                 available -= (__u64) info.os_reserved_mb_low << 20;
6949
6950                 CDEBUG(D_LAYOUT, "ost %d lowwm: %d highwm: %d, "
6951                        "%llu %% blocks available, %llu %% blocks free\n",
6952                        index, info.os_reserved_mb_low, info.os_reserved_mb_high,
6953                        (100ull * sfs->os_bavail) / sfs->os_blocks,
6954                        (100ull * sfs->os_bfree) / sfs->os_blocks);
6955
6956                 if (reserve * repeated > available) {
6957                         ret = false;
6958                         CDEBUG(D_LAYOUT, "low space on ost %d, available %llu "
6959                                "< extension size %llu repeated %d\n", index,
6960                                available, reserve, repeated);
6961                         break;
6962                 }
6963         }
6964         lod_putref(lod, &lod->lod_ost_descs);
6965
6966         RETURN(ret);
6967 }
6968
6969 /**
6970  * Adjust extents after component removal
6971  *
6972  * When we remove an extension component, we move the start of the next
6973  * component to match the start of the extension component, so no space is left
6974  * without layout.
6975  *
6976  * \param[in] env       execution environment for this thread
6977  * \param[in] lo        object
6978  * \param[in] max_comp  layout component
6979  * \param[in] index     index of this component
6980  *
6981  * \retval              0 on success
6982  * \retval              negative errno on error
6983  */
6984 static void lod_sel_adjust_extents(const struct lu_env *env,
6985                                    struct lod_object *lo,
6986                                    int max_comp, int index)
6987 {
6988         struct lod_layout_component *lod_comp = NULL;
6989         struct lod_layout_component *next = NULL;
6990         struct lod_layout_component *prev = NULL;
6991         __u64 new_start = 0;
6992         __u64 start;
6993         int i;
6994
6995         /* Extension space component */
6996         lod_comp = &lo->ldo_comp_entries[index];
6997         next = &lo->ldo_comp_entries[index + 1];
6998         prev = &lo->ldo_comp_entries[index - 1];
6999
7000         LASSERT(lod_comp != NULL && prev != NULL && next != NULL);
7001         LASSERT(lod_comp->llc_flags & LCME_FL_EXTENSION);
7002
7003         /* Previous is being removed */
7004         if (prev && prev->llc_id == LCME_ID_INVAL)
7005                 new_start = prev->llc_extent.e_start;
7006         else
7007                 new_start = lod_comp->llc_extent.e_start;
7008
7009         for (i = index + 1; i < max_comp; i++) {
7010                 lod_comp = &lo->ldo_comp_entries[i];
7011
7012                 start = lod_comp->llc_extent.e_start;
7013                 lod_comp->llc_extent.e_start = new_start;
7014
7015                 /* We only move zero length extendable components */
7016                 if (!(start == lod_comp->llc_extent.e_end))
7017                         break;
7018
7019                 LASSERT(!(lod_comp->llc_flags & LCME_FL_INIT));
7020
7021                 lod_comp->llc_extent.e_end = new_start;
7022         }
7023 }
7024
7025 /* Calculate the proposed 'new end' for a component we're extending */
7026 static __u64 lod_extension_new_end(__u64 extension_size, __u64 extent_end,
7027                                    __u32 stripe_size, __u64 component_end,
7028                                    __u64 extension_end)
7029 {
7030         __u64 new_end;
7031
7032         LASSERT(extension_size != 0 && stripe_size != 0);
7033
7034         /* Round up to extension size */
7035         if (extent_end == OBD_OBJECT_EOF) {
7036                 new_end = OBD_OBJECT_EOF;
7037         } else {
7038                 /* Add at least extension_size to the previous component_end,
7039                  * covering the req layout extent */
7040                 new_end = max(extent_end - component_end, extension_size);
7041                 new_end = roundup(new_end, extension_size);
7042                 new_end += component_end;
7043
7044                 /* Component end must be min stripe size aligned */
7045                 if (new_end % stripe_size) {
7046                         CDEBUG(D_LAYOUT, "new component end is not aligned "
7047                                "by the stripe size %u: [%llu, %llu) ext size "
7048                                "%llu new end %llu, aligning\n",
7049                                stripe_size, component_end, extent_end,
7050                                extension_size, new_end);
7051                         new_end = roundup(new_end, stripe_size);
7052                 }
7053
7054                 /* Overflow */
7055                 if (new_end < extent_end)
7056                         new_end = OBD_OBJECT_EOF;
7057         }
7058
7059         /* Don't extend past the end of the extension component */
7060         if (new_end > extension_end)
7061                 new_end = extension_end;
7062
7063         return new_end;
7064 }
7065
7066 /**
7067  * Calculate the exact reservation (per-OST extension_size) on the OSTs being
7068  * instantiated. It needs to be calculated in advance and taken into account at
7069  * the instantiation time, because otherwise lod_statfs_and_check() may consider
7070  * an OST as OK, but SEL needs its extension_size to fit the free space and the
7071  * OST may turn out to be low-on-space, thus inappropriate OST may be used and
7072  * ENOSPC occurs.
7073  *
7074  * \param[in] lod_comp          lod component we are checking
7075  *
7076  * \retval      size to reserved on each OST of lod_comp's stripe.
7077  */
7078 static __u64 lod_sel_stripe_reserved(struct lod_layout_component *lod_comp)
7079 {
7080         /* extension_size is file level, so we must divide by stripe count to
7081          * compare it to available space on a single OST */
7082         return  lod_comp->llc_stripe_size * SEL_UNIT_SIZE /
7083                 lod_comp->llc_stripe_count;
7084 }
7085
7086 /* As lod_sel_handler() could be re-entered for the same component several
7087  * times, this is the data for the next call. Fields could be changed to
7088  * component indexes when needed, (e.g. if there is no need to instantiate
7089  * all the previous components up to the current position) to tell the caller
7090  * where to start over from. */
7091 struct sel_data {
7092         int sd_force;
7093         int sd_repeat;
7094 };
7095
7096 /**
7097  * Process extent updates for a particular layout component
7098  *
7099  * Handle layout updates for a particular extension space component touched by
7100  * a layout update operation.  Core function of self-extending PFL feature.
7101  *
7102  * In general, this function processes exactly *one* stage of an extension
7103  * operation, modifying the layout accordingly, then returns to the caller.
7104  * The caller is responsible for restarting processing with the new layout,
7105  * which may repeatedly return to this function until the extension updates
7106  * are complete.
7107  *
7108  * This function does one of a few things to the layout:
7109  * 1. Extends the component before the current extension space component to
7110  * allow it to accomodate the requested operation (if space/policy permit that
7111  * component to continue on its current OSTs)
7112  *
7113  * 2. If extension of the existing component fails, we do one of two things:
7114  *    a. If there is a component after the extension space, we remove the
7115  *       extension space component, move the start of the next component down
7116  *       accordingly, then notify the caller to restart processing w/the new
7117  *       layout.
7118  *    b. If there is no following component, we try repeating the current
7119  *       component, creating a new component using the current one as a
7120  *       template (keeping its stripe properties but not specific striping),
7121  *       and try assigning striping for this component.  If there is sufficient
7122  *       free space on the OSTs chosen for this component, it is instantiated
7123  *       and i/o continues there.
7124  *
7125  *       If there is not sufficient space on the new OSTs, we remove this new
7126  *       component & extend the current component.
7127  *
7128  * Note further that uninited components followed by extension space can be zero
7129  * length meaning that we will try to extend them before initializing them, and
7130  * if that fails, they will be removed without initialization.
7131  *
7132  * 3. If we extend to/beyond the end of an extension space component, that
7133  * component is exhausted (all of its range has been given to real components),
7134  * so we remove it and restart processing.
7135  *
7136  * \param[in] env               execution environment for this thread
7137  * \param[in,out] lo            object to update the layout of
7138  * \param[in] extent            layout extent for requested operation, update
7139  *                              layout to fit this operation
7140  * \param[in] th                transaction handle for this operation
7141  * \param[in,out] max_comp      the highest comp for the portion of the layout
7142  *                              we are operating on (For FLR, the chosen
7143  *                              replica).  Updated because we may remove
7144  *                              components.
7145  * \param[in] index             index of the extension space component we're
7146  *                              working on
7147  * \param[in] write             if this is write op
7148  * \param[in,out] force         if the extension is to be forced; set here
7149                                 to force it on the 2nd call for the same
7150                                 extension component
7151  *
7152  * \retval      0 on success
7153  * \retval      negative errno on error
7154  */
7155 static int lod_sel_handler(const struct lu_env *env,
7156                           struct lod_object *lo,
7157                           struct lu_extent *extent,
7158                           struct thandle *th, int *max_comp,
7159                           int index, int write,
7160                           struct sel_data *sd)
7161 {
7162         struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
7163         struct lod_thread_info *info = lod_env_info(env);
7164         struct lod_layout_component *lod_comp;
7165         struct lod_layout_component *prev;
7166         struct lod_layout_component *next = NULL;
7167         __u64 extension_size, reserve;
7168         __u64 new_end = 0;
7169         bool repeated;
7170         int change = 0;
7171         int rc = 0;
7172         ENTRY;
7173
7174         /* First component cannot be extension space */
7175         if (index == 0) {
7176                 CERROR("%s: "DFID" first component cannot be extension space\n",
7177                        lod2obd(d)->obd_name, PFID(lod_object_fid(lo)));
7178                 RETURN(-EINVAL);
7179         }
7180
7181         lod_comp = &lo->ldo_comp_entries[index];
7182         prev = &lo->ldo_comp_entries[index - 1];
7183         if ((index + 1) < *max_comp)
7184                 next = &lo->ldo_comp_entries[index + 1];
7185
7186         /* extension size uses the stripe size field as KiB */
7187         extension_size = lod_comp->llc_stripe_size * SEL_UNIT_SIZE;
7188
7189         CDEBUG(D_LAYOUT, "prev start %llu, extension start %llu, extension end"
7190                " %llu, extension size %llu\n", prev->llc_extent.e_start,
7191                lod_comp->llc_extent.e_start, lod_comp->llc_extent.e_end,
7192                extension_size);
7193
7194         /* Two extension space components cannot be adjacent & extension space
7195          * components cannot be init */
7196         if ((prev->llc_flags & LCME_FL_EXTENSION) ||
7197             !(ergo(next, !(next->llc_flags & LCME_FL_EXTENSION))) ||
7198              lod_comp_inited(lod_comp)) {
7199                 CERROR("%s: "DFID" invalid extension space components\n",
7200                        lod2obd(d)->obd_name, PFID(lod_object_fid(lo)));
7201                 RETURN(-EINVAL);
7202         }
7203
7204         reserve = lod_sel_stripe_reserved(lod_comp);
7205
7206         if (!prev->llc_stripe) {
7207                 CDEBUG(D_LAYOUT, "Previous component not inited\n");
7208                 info->lti_count = 1;
7209                 info->lti_comp_idx[0] = index - 1;
7210                 rc = lod_declare_instantiate_components(env, lo, th, reserve);
7211                 /* ENOSPC tells us we can't use this component.  If there is
7212                  * a next or we are repeating, we either spill over (next) or
7213                  * extend the original comp (repeat).  Otherwise, return the
7214                  * error to the user. */
7215                 if (rc == -ENOSPC && (next || sd->sd_repeat))
7216                         rc = 1;
7217                 if (rc < 0)
7218                         RETURN(rc);
7219         }
7220
7221         if (sd->sd_force == 0 && rc == 0)
7222                 rc = !lod_sel_osts_allowed(env, lo, index - 1, reserve, extent,
7223                                            &lod_comp->llc_extent, write);
7224
7225         repeated = !!(sd->sd_repeat);
7226         sd->sd_repeat = 0;
7227         sd->sd_force = 0;
7228
7229         /* Extend previous component */
7230         if (rc == 0) {
7231                 new_end = lod_extension_new_end(extension_size, extent->e_end,
7232                                                 prev->llc_stripe_size,
7233                                                 prev->llc_extent.e_end,
7234                                                 lod_comp->llc_extent.e_end);
7235
7236                 CDEBUG(D_LAYOUT, "new end %llu\n", new_end);
7237                 lod_comp->llc_extent.e_start = new_end;
7238                 prev->llc_extent.e_end = new_end;
7239
7240                 if (prev->llc_extent.e_end == lod_comp->llc_extent.e_end) {
7241                         CDEBUG(D_LAYOUT, "Extension component exhausted\n");
7242                         lod_comp->llc_id = LCME_ID_INVAL;
7243                         change--;
7244                 }
7245         } else {
7246                 /* rc == 1, failed to extend current component */
7247                 LASSERT(rc == 1);
7248                 if (next) {
7249                         /* Normal 'spillover' case - Remove the extension
7250                          * space component & bring down the start of the next
7251                          * component. */
7252                         lod_comp->llc_id = LCME_ID_INVAL;
7253                         change--;
7254                         if (!(prev->llc_flags & LCME_FL_INIT)) {
7255                                 prev->llc_id = LCME_ID_INVAL;
7256                                 change--;
7257                         }
7258                         lod_sel_adjust_extents(env, lo, *max_comp, index);
7259                 } else if (lod_comp_inited(prev)) {
7260                         /* If there is no next, and the previous component is
7261                          * INIT'ed, try repeating the previous component. */
7262                         LASSERT(repeated == 0);
7263                         rc = lod_layout_repeat_comp(env, lo, index - 1);
7264                         if (rc < 0)
7265                                 RETURN(rc);
7266                         change++;
7267                         /* The previous component is a repeated component.
7268                          * Record this so we don't keep trying to repeat it. */
7269                         sd->sd_repeat = 1;
7270                 } else {
7271                         /* If the previous component is not INIT'ed, this may
7272                          * be a component we have just instantiated but failed
7273                          * to extend. Or even a repeated component we failed
7274                          * to prepare a striping for. Do not repeat but instead
7275                          * remove the repeated component & force the extention
7276                          * of the original one */
7277                         sd->sd_force = 1;
7278                         if (repeated) {
7279                                 prev->llc_id = LCME_ID_INVAL;
7280                                 change--;
7281                         }
7282                 }
7283         }
7284
7285         if (change < 0) {
7286                 rc = lod_layout_del_prep_layout(env, lo, NULL);
7287                 if (rc < 0)
7288                         RETURN(rc);
7289                 LASSERTF(-rc == change,
7290                          "number deleted %d != requested %d\n", -rc,
7291                          change);
7292         }
7293         *max_comp = *max_comp + change;
7294
7295         /* lod_del_prep_layout reallocates ldo_comp_entries, so we must
7296          * refresh these pointers before using them */
7297         lod_comp = &lo->ldo_comp_entries[index];
7298         prev = &lo->ldo_comp_entries[index - 1];
7299         CDEBUG(D_LAYOUT, "After extent updates: prev start %llu, current start "
7300                "%llu, current end %llu max_comp %d ldo_comp_cnt %d\n",
7301                prev->llc_extent.e_start, lod_comp->llc_extent.e_start,
7302                lod_comp->llc_extent.e_end, *max_comp, lo->ldo_comp_cnt);
7303
7304         /* Layout changed successfully */
7305         RETURN(0);
7306 }
7307
7308 /**
7309  * Declare layout extent updates
7310  *
7311  * Handles extensions.  Identifies extension components touched by current
7312  * operation and passes them to processing function.
7313  *
7314  * Restarts with updated layouts from the processing function until the current
7315  * operation no longer touches an extension space component.
7316  *
7317  * \param[in] env       execution environment for this thread
7318  * \param[in,out] lo    object to update the layout of
7319  * \param[in] extent    layout extent for requested operation, update layout to
7320  *                      fit this operation
7321  * \param[in] th        transaction handle for this operation
7322  * \param[in] pick      identifies chosen mirror for FLR layouts
7323  * \param[in] write     if this is write op
7324  *
7325  * \retval      1 on layout changed, 0 on no change
7326  * \retval      negative errno on error
7327  */
7328 static int lod_declare_update_extents(const struct lu_env *env,
7329                 struct lod_object *lo, struct lu_extent *extent,
7330                 struct thandle *th, int pick, int write)
7331 {
7332         struct lod_thread_info *info = lod_env_info(env);
7333         struct lod_layout_component *lod_comp;
7334         bool layout_changed = false;
7335         struct sel_data sd = { 0 };
7336         int start_index;
7337         int i = 0;
7338         int max_comp = 0;
7339         int rc = 0, rc2;
7340         int change = 0;
7341         ENTRY;
7342
7343         /* This makes us work on the components of the chosen mirror */
7344         start_index = lo->ldo_mirrors[pick].lme_start;
7345         max_comp = lo->ldo_mirrors[pick].lme_end + 1;
7346         if (lo->ldo_flr_state == LCM_FL_NONE)
7347                 LASSERT(start_index == 0 && max_comp == lo->ldo_comp_cnt);
7348
7349         CDEBUG(D_LAYOUT, "extent->e_start %llu, extent->e_end %llu\n",
7350                extent->e_start, extent->e_end);
7351         for (i = start_index; i < max_comp; i++) {
7352                 lod_comp = &lo->ldo_comp_entries[i];
7353
7354                 /* We've passed all components of interest */
7355                 if (lod_comp->llc_extent.e_start >= extent->e_end)
7356                         break;
7357
7358                 if (lod_comp->llc_flags & LCME_FL_EXTENSION) {
7359                         layout_changed = true;
7360                         rc = lod_sel_handler(env, lo, extent, th, &max_comp,
7361                                              i, write, &sd);
7362                         if (rc < 0)
7363                                 GOTO(out, rc);
7364
7365                         /* Nothing has changed behind the prev one */
7366                         i -= 2;
7367                         continue;
7368                 }
7369         }
7370
7371         /* We may have added or removed components.  If so, we must update the
7372          * start & ends of all the mirrors after the current one, and the end
7373          * of the current mirror. */
7374         change = max_comp - 1 - lo->ldo_mirrors[pick].lme_end;
7375         if (change) {
7376                 lo->ldo_mirrors[pick].lme_end += change;
7377                 for (i = pick + 1; i < lo->ldo_mirror_count; i++) {
7378                         lo->ldo_mirrors[i].lme_start += change;
7379                         lo->ldo_mirrors[i].lme_end += change;
7380                 }
7381         }
7382
7383         EXIT;
7384 out:
7385         /* The amount of components has changed, adjust the lti_comp_idx */
7386         rc2 = lod_layout_data_init(info, lo->ldo_comp_cnt);
7387
7388         return rc < 0 ? rc : rc2 < 0 ? rc2 : layout_changed;
7389 }
7390
7391 /* If striping is already instantiated or INIT'ed DOM? */
7392 static bool lod_is_instantiation_needed(struct lod_layout_component *comp)
7393 {
7394         return !(((lov_pattern(comp->llc_pattern) == LOV_PATTERN_MDT) &&
7395                   lod_comp_inited(comp)) || comp->llc_stripe);
7396 }
7397
7398 /**
7399  * Declare layout update for a non-FLR layout.
7400  *
7401  * \param[in] env       execution environment for this thread
7402  * \param[in,out] lo    object to update the layout of
7403  * \param[in] layout    layout intent for requested operation, "update" is
7404  *                      a process of reacting to this
7405  * \param[in] buf       buffer containing lov ea (see comment on usage inline)
7406  * \param[in] th        transaction handle for this operation
7407  *
7408  * \retval      0 on success
7409  * \retval      negative errno on error
7410  */
7411 static int lod_declare_update_plain(const struct lu_env *env,
7412                 struct lod_object *lo, struct layout_intent *layout,
7413                 const struct lu_buf *buf, struct thandle *th)
7414 {
7415         struct lod_thread_info *info = lod_env_info(env);
7416         struct lod_device *d = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
7417         struct lod_layout_component *lod_comp;
7418         struct lov_comp_md_v1 *comp_v1 = NULL;
7419         bool layout_changed = false;
7420         bool replay = false;
7421         int i, rc;
7422         ENTRY;
7423
7424         LASSERT(lo->ldo_flr_state == LCM_FL_NONE);
7425
7426         /*
7427          * In case the client is passing lovea, which only happens during
7428          * the replay of layout intent write RPC for now, we may need to
7429          * parse the lovea and apply new layout configuration.
7430          */
7431         if (buf && buf->lb_len)  {
7432                 struct lov_user_md_v1 *v1 = buf->lb_buf;
7433
7434                 if (v1->lmm_magic != (LOV_MAGIC_DEFINED | LOV_MAGIC_COMP_V1) &&
7435                     v1->lmm_magic != __swab32(LOV_MAGIC_DEFINED |
7436                                               LOV_MAGIC_COMP_V1)) {
7437                         CERROR("%s: the replay buffer of layout extend "
7438                                "(magic %#x) does not contain expected "
7439                                "composite layout.\n",
7440                                lod2obd(d)->obd_name, v1->lmm_magic);
7441                         GOTO(out, rc = -EINVAL);
7442                 }
7443
7444                 rc = lod_use_defined_striping(env, lo, buf);
7445                 if (rc)
7446                         GOTO(out, rc);
7447                 lo->ldo_comp_cached = 1;
7448
7449                 rc = lod_get_lov_ea(env, lo);
7450                 if (rc <= 0)
7451                         GOTO(out, rc);
7452                 /* old on-disk EA is stored in info->lti_buf */
7453                 comp_v1 = (struct lov_comp_md_v1 *)info->lti_buf.lb_buf;
7454                 replay = true;
7455                 layout_changed = true;
7456
7457                 rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
7458                 if (rc)
7459                         GOTO(out, rc);
7460         } else {
7461                 /* non replay path */
7462                 rc = lod_striping_load(env, lo);
7463                 if (rc)
7464                         GOTO(out, rc);
7465         }
7466
7467         /* Make sure defined layout covers the requested write range. */
7468         lod_comp = &lo->ldo_comp_entries[lo->ldo_comp_cnt - 1];
7469         if (lo->ldo_comp_cnt > 1 &&
7470             lod_comp->llc_extent.e_end != OBD_OBJECT_EOF &&
7471             lod_comp->llc_extent.e_end < layout->li_extent.e_end) {
7472                 CDEBUG_LIMIT(replay ? D_ERROR : D_LAYOUT,
7473                              "%s: the defined layout [0, %#llx) does not "
7474                              "covers the write range "DEXT"\n",
7475                              lod2obd(d)->obd_name, lod_comp->llc_extent.e_end,
7476                              PEXT(&layout->li_extent));
7477                 GOTO(out, rc = -EINVAL);
7478         }
7479
7480         CDEBUG(D_LAYOUT, "%s: "DFID": update components "DEXT"\n",
7481                lod2obd(d)->obd_name, PFID(lod_object_fid(lo)),
7482                PEXT(&layout->li_extent));
7483
7484         if (!replay) {
7485                 rc = lod_declare_update_extents(env, lo, &layout->li_extent,
7486                                 th, 0, layout->li_opc == LAYOUT_INTENT_WRITE);
7487                 if (rc < 0)
7488                         GOTO(out, rc);
7489                 else if (rc)
7490                         layout_changed = true;
7491         }
7492
7493         /*
7494          * Iterate ld->ldo_comp_entries, find the component whose extent under
7495          * the write range and not instantianted.
7496          */
7497         for (i = 0; i < lo->ldo_comp_cnt; i++) {
7498                 lod_comp = &lo->ldo_comp_entries[i];
7499
7500                 if (lod_comp->llc_extent.e_start >= layout->li_extent.e_end)
7501                         break;
7502
7503                 if (!replay) {
7504                         /* If striping is instantiated or INIT'ed DOM skip */
7505                         if (!lod_is_instantiation_needed(lod_comp))
7506                                 continue;
7507                 } else {
7508                         /**
7509                          * In replay path, lod_comp is the EA passed by
7510                          * client replay buffer,  comp_v1 is the pre-recovery
7511                          * on-disk EA, we'd sift out those components which
7512                          * were init-ed in the on-disk EA.
7513                          */
7514                         if (le32_to_cpu(comp_v1->lcm_entries[i].lcme_flags) &
7515                             LCME_FL_INIT)
7516                                 continue;
7517                 }
7518                 /*
7519                  * this component hasn't instantiated in normal path, or during
7520                  * replay it needs replay the instantiation.
7521                  */
7522
7523                 /* A released component is being extended */
7524                 if (lod_comp->llc_pattern & LOV_PATTERN_F_RELEASED)
7525                         GOTO(out, rc = -EINVAL);
7526
7527                 LASSERT(info->lti_comp_idx != NULL);
7528                 info->lti_comp_idx[info->lti_count++] = i;
7529                 layout_changed = true;
7530         }
7531
7532         if (!layout_changed)
7533                 RETURN(-EALREADY);
7534
7535         lod_obj_inc_layout_gen(lo);
7536         rc = lod_declare_instantiate_components(env, lo, th, 0);
7537         EXIT;
7538 out:
7539         if (rc)
7540                 lod_striping_free(env, lo);
7541         return rc;
7542 }
7543
7544 static inline int lod_comp_index(struct lod_object *lo,
7545                                  struct lod_layout_component *lod_comp)
7546 {
7547         LASSERT(lod_comp >= lo->ldo_comp_entries &&
7548                 lod_comp <= &lo->ldo_comp_entries[lo->ldo_comp_cnt - 1]);
7549
7550         return lod_comp - lo->ldo_comp_entries;
7551 }
7552
7553 /**
7554  * Stale other mirrors by writing extent.
7555  */
7556 static int lod_stale_components(const struct lu_env *env, struct lod_object *lo,
7557                                 int primary, struct lu_extent *extent,
7558                                 struct thandle *th)
7559 {
7560         struct lod_layout_component *pri_comp, *lod_comp;
7561         struct lu_extent pri_extent;
7562         int rc = 0;
7563         int i;
7564         ENTRY;
7565
7566         /* The writing extent decides which components in the primary
7567          * are affected... */
7568         CDEBUG(D_LAYOUT, "primary mirror %d, "DEXT"\n", primary, PEXT(extent));
7569
7570 restart:
7571         lod_foreach_mirror_comp(pri_comp, lo, primary) {
7572                 if (!lu_extent_is_overlapped(extent, &pri_comp->llc_extent))
7573                         continue;
7574
7575                 CDEBUG(D_LAYOUT, "primary comp %u "DEXT"\n",
7576                        lod_comp_index(lo, pri_comp),
7577                        PEXT(&pri_comp->llc_extent));
7578
7579                 pri_extent.e_start = pri_comp->llc_extent.e_start;
7580                 pri_extent.e_end = pri_comp->llc_extent.e_end;
7581
7582                 for (i = 0; i < lo->ldo_mirror_count; i++) {
7583                         if (i == primary)
7584                                 continue;
7585                         rc = lod_declare_update_extents(env, lo, &pri_extent,
7586                                                         th, i, 0);
7587                         /* if update_extents changed the layout, it may have
7588                          * reallocated the component array, so start over to
7589                          * avoid using stale pointers */
7590                         if (rc == 1)
7591                                 goto restart;
7592                         if (rc < 0)
7593                                 RETURN(rc);
7594
7595                         /* ... and then stale other components that are
7596                          * overlapping with primary components */
7597                         lod_foreach_mirror_comp(lod_comp, lo, i) {
7598                                 if (!lu_extent_is_overlapped(
7599                                                         &pri_extent,
7600                                                         &lod_comp->llc_extent))
7601                                         continue;
7602
7603                                 CDEBUG(D_LAYOUT, "stale: %u / %u\n",
7604                                       i, lod_comp_index(lo, lod_comp));
7605
7606                                 lod_comp->llc_flags |= LCME_FL_STALE;
7607                                 lo->ldo_mirrors[i].lme_stale = 1;
7608                         }
7609                 }
7610         }
7611
7612         RETURN(rc);
7613 }
7614
7615 /**
7616  * check an OST's availability
7617  * \param[in] env       execution environment
7618  * \param[in] lo        lod object
7619  * \param[in] dt        dt object
7620  * \param[in] index     mirror index
7621  *
7622  * \retval      negative if failed
7623  * \retval      1 if \a dt is available
7624  * \retval      0 if \a dt is not available
7625  */
7626 static inline int lod_check_ost_avail(const struct lu_env *env,
7627                                       struct lod_object *lo,
7628                                       struct dt_object *dt, int index)
7629 {
7630         struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
7631         struct lod_tgt_desc *ost;
7632         __u32 idx;
7633         int type = LU_SEQ_RANGE_OST;
7634         int rc;
7635
7636         rc = lod_fld_lookup(env, lod, lu_object_fid(&dt->do_lu), &idx, &type);
7637         if (rc < 0) {
7638                 CERROR("%s: can't locate "DFID":rc = %d\n",
7639                        lod2obd(lod)->obd_name, PFID(lu_object_fid(&dt->do_lu)),
7640                        rc);
7641                 return rc;
7642         }
7643
7644         ost = OST_TGT(lod, idx);
7645         if (ost->ltd_statfs.os_state &
7646                 (OS_STATFS_READONLY | OS_STATFS_ENOSPC | OS_STATFS_ENOINO |
7647                  OS_STATFS_NOPRECREATE) ||
7648             ost->ltd_active == 0) {
7649                 CDEBUG(D_LAYOUT, DFID ": mirror %d OST%d unavail, rc = %d\n",
7650                        PFID(lod_object_fid(lo)), index, idx, rc);
7651                 return 0;
7652         }
7653
7654         return 1;
7655 }
7656
7657 /**
7658  * Pick primary mirror for write
7659  * \param[in] env       execution environment
7660  * \param[in] lo        object
7661  * \param[in] extent    write range
7662  */
7663 static int lod_primary_pick(const struct lu_env *env, struct lod_object *lo,
7664                             struct lu_extent *extent)
7665 {
7666         struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
7667         unsigned int seq = 0;
7668         struct lod_layout_component *lod_comp;
7669         int i, j, rc;
7670         int picked = -1, second_pick = -1, third_pick = -1;
7671         ENTRY;
7672
7673         if (OBD_FAIL_CHECK(OBD_FAIL_FLR_RANDOM_PICK_MIRROR)) {
7674                 get_random_bytes(&seq, sizeof(seq));
7675                 seq %= lo->ldo_mirror_count;
7676         }
7677
7678         /**
7679          * Pick a mirror as the primary, and check the availability of OSTs.
7680          *
7681          * This algo can be revised later after knowing the topology of
7682          * cluster.
7683          */
7684         lod_qos_statfs_update(env, lod, &lod->lod_ost_descs);
7685
7686         rc = lod_fill_mirrors(lo);
7687         if (rc)
7688                 RETURN(rc);
7689
7690         for (i = 0; i < lo->ldo_mirror_count; i++) {
7691                 bool ost_avail = true;
7692                 int index = (i + seq) % lo->ldo_mirror_count;
7693
7694                 if (lo->ldo_mirrors[index].lme_stale) {
7695                         CDEBUG(D_LAYOUT, DFID": mirror %d stale\n",
7696                                PFID(lod_object_fid(lo)), index);
7697                         continue;
7698                 }
7699
7700                 /* 2nd pick is for the primary mirror containing unavail OST */
7701                 if (lo->ldo_mirrors[index].lme_prefer && second_pick < 0)
7702                         second_pick = index;
7703
7704                 /* 3rd pick is for non-primary mirror containing unavail OST */
7705                 if (second_pick < 0 && third_pick < 0)
7706                         third_pick = index;
7707
7708                 /**
7709                  * we found a non-primary 1st pick, we'd like to find a
7710                  * potential pirmary mirror.
7711                  */
7712                 if (picked >= 0 && !lo->ldo_mirrors[index].lme_prefer)
7713                         continue;
7714
7715                 /* check the availability of OSTs */
7716                 lod_foreach_mirror_comp(lod_comp, lo, index) {
7717                         if (!lod_comp_inited(lod_comp) || !lod_comp->llc_stripe)
7718                                 continue;
7719
7720                         for (j = 0; j < lod_comp->llc_stripe_count; j++) {
7721                                 struct dt_object *dt = lod_comp->llc_stripe[j];
7722
7723                                 rc = lod_check_ost_avail(env, lo, dt, index);
7724                                 if (rc < 0)
7725                                         RETURN(rc);
7726
7727                                 ost_avail = !!rc;
7728                                 if (!ost_avail)
7729                                         break;
7730                         } /* for all dt object in one component */
7731                         if (!ost_avail)
7732                                 break;
7733                 } /* for all components in a mirror */
7734
7735                 /**
7736                  * the OSTs where allocated objects locates in the components
7737                  * of the mirror are available.
7738                  */
7739                 if (!ost_avail)
7740                         continue;
7741
7742                 /* this mirror has all OSTs available */
7743                 picked = index;
7744
7745                 /**
7746                  * primary with all OSTs are available, this is the perfect
7747                  * 1st pick.
7748                  */
7749                 if (lo->ldo_mirrors[index].lme_prefer)
7750                         break;
7751         } /* for all mirrors */
7752
7753         /* failed to pick a sound mirror, lower our expectation */
7754         if (picked < 0)
7755                 picked = second_pick;
7756         if (picked < 0)
7757                 picked = third_pick;
7758         if (picked < 0)
7759                 RETURN(-ENODATA);
7760
7761         RETURN(picked);
7762 }
7763
7764 static int lod_prepare_resync_mirror(const struct lu_env *env,
7765                                      struct lod_object *lo,
7766                                      __u16 mirror_id)
7767 {
7768         struct lod_thread_info *info = lod_env_info(env);
7769         struct lod_layout_component *lod_comp;
7770         bool neg = !!(MIRROR_ID_NEG & mirror_id);
7771         int i;
7772
7773         mirror_id &= ~MIRROR_ID_NEG;
7774
7775         for (i = 0; i < lo->ldo_mirror_count; i++) {
7776                 if ((!neg && lo->ldo_mirrors[i].lme_id != mirror_id) ||
7777                     (neg && lo->ldo_mirrors[i].lme_id == mirror_id))
7778                         continue;
7779
7780                 lod_foreach_mirror_comp(lod_comp, lo, i) {
7781                         if (lod_comp_inited(lod_comp))
7782                                 continue;
7783
7784                         info->lti_comp_idx[info->lti_count++] =
7785                                 lod_comp_index(lo, lod_comp);
7786                 }
7787         }
7788
7789         return 0;
7790 }
7791
7792 /**
7793  * figure out the components should be instantiated for resync.
7794  */
7795 static int lod_prepare_resync(const struct lu_env *env, struct lod_object *lo,
7796                               struct lu_extent *extent)
7797 {
7798         struct lod_thread_info *info = lod_env_info(env);
7799         struct lod_layout_component *lod_comp;
7800         unsigned int need_sync = 0;
7801         int i;
7802
7803         CDEBUG(D_LAYOUT,
7804                DFID": instantiate all stale components in "DEXT"\n",
7805                PFID(lod_object_fid(lo)), PEXT(extent));
7806
7807         /**
7808          * instantiate all components within this extent, even non-stale
7809          * components.
7810          */
7811         for (i = 0; i < lo->ldo_mirror_count; i++) {
7812                 if (!lo->ldo_mirrors[i].lme_stale)
7813                         continue;
7814
7815                 lod_foreach_mirror_comp(lod_comp, lo, i) {
7816                         if (!lu_extent_is_overlapped(extent,
7817                                                 &lod_comp->llc_extent))
7818                                 break;
7819
7820                         need_sync++;
7821
7822                         if (lod_comp_inited(lod_comp))
7823                                 continue;
7824
7825                         CDEBUG(D_LAYOUT, "resync instantiate %d / %d\n",
7826                                i, lod_comp_index(lo, lod_comp));
7827                         info->lti_comp_idx[info->lti_count++] =
7828                                         lod_comp_index(lo, lod_comp);
7829                 }
7830         }
7831
7832         return need_sync ? 0 : -EALREADY;
7833 }
7834
7835 static int lod_declare_update_rdonly(const struct lu_env *env,
7836                 struct lod_object *lo, struct md_layout_change *mlc,
7837                 struct thandle *th)
7838 {
7839         struct lod_thread_info *info = lod_env_info(env);
7840         struct lu_attr *layout_attr = &info->lti_layout_attr;
7841         struct lod_layout_component *lod_comp;
7842         struct lu_extent extent = { 0 };
7843         int rc;
7844         ENTRY;
7845
7846         LASSERT(lo->ldo_flr_state == LCM_FL_RDONLY);
7847         LASSERT(mlc->mlc_opc == MD_LAYOUT_WRITE ||
7848                 mlc->mlc_opc == MD_LAYOUT_RESYNC);
7849         LASSERT(lo->ldo_mirror_count > 0);
7850
7851         if (mlc->mlc_opc == MD_LAYOUT_WRITE) {
7852                 struct layout_intent *layout = mlc->mlc_intent;
7853                 int write = layout->li_opc == LAYOUT_INTENT_WRITE;
7854                 int picked;
7855
7856                 extent = layout->li_extent;
7857                 CDEBUG(D_LAYOUT, DFID": trying to write :"DEXT"\n",
7858                        PFID(lod_object_fid(lo)), PEXT(&extent));
7859
7860                 picked = lod_primary_pick(env, lo, &extent);
7861                 if (picked < 0)
7862                         RETURN(picked);
7863
7864                 CDEBUG(D_LAYOUT, DFID": picked mirror id %u as primary\n",
7865                        PFID(lod_object_fid(lo)),
7866                        lo->ldo_mirrors[picked].lme_id);
7867
7868                 /* Update extents of primary before staling */
7869                 rc = lod_declare_update_extents(env, lo, &extent, th, picked,
7870                                                 write);
7871                 if (rc < 0)
7872                         GOTO(out, rc);
7873
7874                 if (layout->li_opc == LAYOUT_INTENT_TRUNC) {
7875                         /**
7876                          * trunc transfers [0, size) in the intent extent, we'd
7877                          * stale components overlapping [size, eof).
7878                          */
7879                         extent.e_start = extent.e_end;
7880                         extent.e_end = OBD_OBJECT_EOF;
7881                 }
7882
7883                 /* stale overlapping components from other mirrors */
7884                 rc = lod_stale_components(env, lo, picked, &extent, th);
7885                 if (rc < 0)
7886                         GOTO(out, rc);
7887
7888                 /* restore truncate intent extent */
7889                 if (layout->li_opc == LAYOUT_INTENT_TRUNC)
7890                         extent.e_end = extent.e_start;
7891
7892                 /* instantiate components for the picked mirror, start from 0 */
7893                 extent.e_start = 0;
7894
7895                 lod_foreach_mirror_comp(lod_comp, lo, picked) {
7896                         if (!lu_extent_is_overlapped(&extent,
7897                                                      &lod_comp->llc_extent))
7898                                 break;
7899
7900                         if (!lod_is_instantiation_needed(lod_comp))
7901                                 continue;
7902
7903                         info->lti_comp_idx[info->lti_count++] =
7904                                                 lod_comp_index(lo, lod_comp);
7905                 }
7906
7907                 lo->ldo_flr_state = LCM_FL_WRITE_PENDING;
7908         } else { /* MD_LAYOUT_RESYNC */
7909                 int i;
7910
7911                 /**
7912                  * could contain multiple non-stale mirrors, so we need to
7913                  * prep uninited all components assuming any non-stale mirror
7914                  * could be picked as the primary mirror.
7915                  */
7916                 if (mlc->mlc_mirror_id == 0) {
7917                         /* normal resync */
7918                         for (i = 0; i < lo->ldo_mirror_count; i++) {
7919                                 if (lo->ldo_mirrors[i].lme_stale)
7920                                         continue;
7921
7922                                 lod_foreach_mirror_comp(lod_comp, lo, i) {
7923                                         if (!lod_comp_inited(lod_comp))
7924                                                 break;
7925
7926                                         if (extent.e_end <
7927                                                 lod_comp->llc_extent.e_end)
7928                                                 extent.e_end =
7929                                                      lod_comp->llc_extent.e_end;
7930                                 }
7931                         }
7932                         rc = lod_prepare_resync(env, lo, &extent);
7933                         if (rc)
7934                                 GOTO(out, rc);
7935                 } else {
7936                         /* mirror write, try to init its all components */
7937                         rc = lod_prepare_resync_mirror(env, lo,
7938                                                        mlc->mlc_mirror_id);
7939                         if (rc)
7940                                 GOTO(out, rc);
7941                 }
7942
7943                 /* change the file state to SYNC_PENDING */
7944                 lo->ldo_flr_state = LCM_FL_SYNC_PENDING;
7945         }
7946
7947         /* Reset the layout version once it's becoming too large.
7948          * This way it can make sure that the layout version is
7949          * monotonously increased in this writing era. */
7950         lod_obj_inc_layout_gen(lo);
7951
7952         rc = lod_declare_instantiate_components(env, lo, th, 0);
7953         if (rc)
7954                 GOTO(out, rc);
7955
7956         layout_attr->la_valid = LA_LAYOUT_VERSION;
7957         layout_attr->la_layout_version = 0;
7958         if (mlc->mlc_opc == MD_LAYOUT_RESYNC)
7959                 layout_attr->la_layout_version = LU_LAYOUT_RESYNC;
7960         rc = lod_declare_attr_set(env, &lo->ldo_obj, layout_attr, th);
7961         if (rc)
7962                 GOTO(out, rc);
7963
7964 out:
7965         if (rc)
7966                 lod_striping_free(env, lo);
7967         RETURN(rc);
7968 }
7969
7970 static int lod_declare_update_write_pending(const struct lu_env *env,
7971                 struct lod_object *lo, struct md_layout_change *mlc,
7972                 struct thandle *th)
7973 {
7974         struct lod_thread_info *info = lod_env_info(env);
7975         struct lu_attr *layout_attr = &info->lti_layout_attr;
7976         struct lod_layout_component *lod_comp;
7977         struct lu_extent extent = { 0 };
7978         int primary = -1;
7979         int i;
7980         int rc;
7981         ENTRY;
7982
7983         LASSERT(lo->ldo_flr_state == LCM_FL_WRITE_PENDING);
7984         LASSERT(mlc->mlc_opc == MD_LAYOUT_WRITE ||
7985                 mlc->mlc_opc == MD_LAYOUT_RESYNC);
7986
7987         /* look for the first preferred mirror */
7988         for (i = 0; i < lo->ldo_mirror_count; i++) {
7989                 if (lo->ldo_mirrors[i].lme_stale)
7990                         continue;
7991                 if (lo->ldo_mirrors[i].lme_prefer == 0)
7992                         continue;
7993
7994                 primary = i;
7995                 break;
7996         }
7997         if (primary < 0) {
7998                 /* no primary, use any in-sync */
7999                 for (i = 0; i < lo->ldo_mirror_count; i++) {
8000                         if (lo->ldo_mirrors[i].lme_stale)
8001                                 continue;
8002                         primary = i;
8003                         break;
8004                 }
8005                 if (primary < 0) {
8006                         CERROR(DFID ": doesn't have a primary mirror\n",
8007                                PFID(lod_object_fid(lo)));
8008                         GOTO(out, rc = -ENODATA);
8009                 }
8010         }
8011
8012         CDEBUG(D_LAYOUT, DFID": found primary %u\n",
8013                PFID(lod_object_fid(lo)), lo->ldo_mirrors[primary].lme_id);
8014
8015         LASSERT(!lo->ldo_mirrors[primary].lme_stale);
8016
8017         /* for LAYOUT_WRITE opc, it has to do the following operations:
8018          * 1. stale overlapping componets from stale mirrors;
8019          * 2. instantiate components of the primary mirror;
8020          * 3. transfter layout version to all objects of the primary;
8021          *
8022          * for LAYOUT_RESYNC opc, it will do:
8023          * 1. instantiate components of all stale mirrors;
8024          * 2. transfer layout version to all objects to close write era. */
8025
8026         if (mlc->mlc_opc == MD_LAYOUT_WRITE) {
8027                 struct layout_intent *layout = mlc->mlc_intent;
8028                 int write = layout->li_opc == LAYOUT_INTENT_WRITE;
8029
8030                 LASSERT(mlc->mlc_intent != NULL);
8031
8032                 extent = mlc->mlc_intent->li_extent;
8033
8034                 CDEBUG(D_LAYOUT, DFID": intent to write: "DEXT"\n",
8035                        PFID(lod_object_fid(lo)), PEXT(&extent));
8036
8037                 /* 1. Update extents of primary before staling */
8038                 rc = lod_declare_update_extents(env, lo, &extent, th, primary,
8039                                                 write);
8040                 if (rc < 0)
8041                         GOTO(out, rc);
8042
8043                 if (mlc->mlc_intent->li_opc == LAYOUT_INTENT_TRUNC) {
8044                         /**
8045                          * trunc transfers [0, size) in the intent extent, we'd
8046                          * stale components overlapping [size, eof).
8047                          */
8048                         extent.e_start = extent.e_end;
8049                         extent.e_end = OBD_OBJECT_EOF;
8050                 }
8051
8052                 /* 2. stale overlapping components */
8053                 rc = lod_stale_components(env, lo, primary, &extent, th);
8054                 if (rc < 0)
8055                         GOTO(out, rc);
8056
8057                 /* 3. find the components which need instantiating.
8058                  * instantiate [0, mlc->mlc_intent->e_end) */
8059
8060                 /* restore truncate intent extent */
8061                 if (mlc->mlc_intent->li_opc == LAYOUT_INTENT_TRUNC)
8062                         extent.e_end = extent.e_start;
8063                 extent.e_start = 0;
8064
8065                 lod_foreach_mirror_comp(lod_comp, lo, primary) {
8066                         if (!lu_extent_is_overlapped(&extent,
8067                                                      &lod_comp->llc_extent))
8068                                 break;
8069
8070                         if (!lod_is_instantiation_needed(lod_comp))
8071                                 continue;
8072
8073                         CDEBUG(D_LAYOUT, "write instantiate %d / %d\n",
8074                                primary, lod_comp_index(lo, lod_comp));
8075                         info->lti_comp_idx[info->lti_count++] =
8076                                                 lod_comp_index(lo, lod_comp);
8077                 }
8078         } else { /* MD_LAYOUT_RESYNC */
8079                 if (mlc->mlc_mirror_id == 0) {
8080                         /* normal resync */
8081                         lod_foreach_mirror_comp(lod_comp, lo, primary) {
8082                                 if (!lod_comp_inited(lod_comp))
8083                                         break;
8084
8085                                 extent.e_end = lod_comp->llc_extent.e_end;
8086                         }
8087
8088                         rc = lod_prepare_resync(env, lo, &extent);
8089                         if (rc)
8090                                 GOTO(out, rc);
8091                 } else {
8092                         /* mirror write, try to init its all components */
8093                         rc = lod_prepare_resync_mirror(env, lo,
8094                                                        mlc->mlc_mirror_id);
8095                         if (rc)
8096                                 GOTO(out, rc);
8097                 }
8098
8099                 /* change the file state to SYNC_PENDING */
8100                 lo->ldo_flr_state = LCM_FL_SYNC_PENDING;
8101         }
8102
8103         rc = lod_declare_instantiate_components(env, lo, th, 0);
8104         if (rc)
8105                 GOTO(out, rc);
8106
8107         lod_obj_inc_layout_gen(lo);
8108
8109         /* 3. transfer layout version to OST objects.
8110          * transfer new layout version to OST objects so that stale writes
8111          * can be denied. It also ends an era of writing by setting
8112          * LU_LAYOUT_RESYNC. Normal client can never use this bit to
8113          * send write RPC; only resync RPCs could do it. */
8114         layout_attr->la_valid = LA_LAYOUT_VERSION;
8115         layout_attr->la_layout_version = 0;
8116         if (mlc->mlc_opc == MD_LAYOUT_RESYNC)
8117                 layout_attr->la_layout_version = LU_LAYOUT_RESYNC;
8118         rc = lod_declare_attr_set(env, &lo->ldo_obj, layout_attr, th);
8119         if (rc)
8120                 GOTO(out, rc);
8121 out:
8122         if (rc)
8123                 lod_striping_free(env, lo);
8124         RETURN(rc);
8125 }
8126
8127 static int lod_declare_update_sync_pending(const struct lu_env *env,
8128                 struct lod_object *lo, struct md_layout_change *mlc,
8129                 struct thandle *th)
8130 {
8131         struct lod_thread_info  *info = lod_env_info(env);
8132         struct lu_attr *layout_attr = &info->lti_layout_attr;
8133         unsigned sync_components = 0;
8134         unsigned resync_components = 0;
8135         int i;
8136         int rc;
8137         ENTRY;
8138
8139         LASSERT(lo->ldo_flr_state == LCM_FL_SYNC_PENDING);
8140         LASSERT(mlc->mlc_opc == MD_LAYOUT_RESYNC_DONE ||
8141                 mlc->mlc_opc == MD_LAYOUT_WRITE);
8142
8143         CDEBUG(D_LAYOUT, DFID ": received op %d in sync pending\n",
8144                PFID(lod_object_fid(lo)), mlc->mlc_opc);
8145
8146         if (mlc->mlc_opc == MD_LAYOUT_WRITE) {
8147                 CDEBUG(D_LAYOUT, DFID": cocurrent write to sync pending\n",
8148                        PFID(lod_object_fid(lo)));
8149
8150                 lo->ldo_flr_state = LCM_FL_WRITE_PENDING;
8151                 return lod_declare_update_write_pending(env, lo, mlc, th);
8152         }
8153
8154         /* MD_LAYOUT_RESYNC_DONE */
8155
8156         for (i = 0; i < lo->ldo_comp_cnt; i++) {
8157                 struct lod_layout_component *lod_comp;
8158                 int j;
8159
8160                 lod_comp = &lo->ldo_comp_entries[i];
8161
8162                 if (!(lod_comp->llc_flags & LCME_FL_STALE)) {
8163                         sync_components++;
8164                         continue;
8165                 }
8166
8167                 for (j = 0; j < mlc->mlc_resync_count; j++) {
8168                         if (lod_comp->llc_id != mlc->mlc_resync_ids[j])
8169                                 continue;
8170
8171                         mlc->mlc_resync_ids[j] = LCME_ID_INVAL;
8172                         lod_comp->llc_flags &= ~LCME_FL_STALE;
8173                         resync_components++;
8174                         break;
8175                 }
8176         }
8177
8178         /* valid check */
8179         for (i = 0; i < mlc->mlc_resync_count; i++) {
8180                 if (mlc->mlc_resync_ids[i] == LCME_ID_INVAL)
8181                         continue;
8182
8183                 CDEBUG(D_LAYOUT, DFID": lcme id %u (%d / %zd) not exist "
8184                        "or already synced\n", PFID(lod_object_fid(lo)),
8185                        mlc->mlc_resync_ids[i], i, mlc->mlc_resync_count);
8186                 GOTO(out, rc = -EINVAL);
8187         }
8188
8189         if (!sync_components || (mlc->mlc_resync_count && !resync_components)) {
8190                 CDEBUG(D_LAYOUT, DFID": no mirror in sync\n",
8191                        PFID(lod_object_fid(lo)));
8192
8193                 /* tend to return an error code here to prevent
8194                  * the MDT from setting SoM attribute */
8195                 GOTO(out, rc = -EINVAL);
8196         }
8197
8198         CDEBUG(D_LAYOUT, DFID": synced %u resynced %u/%zu components\n",
8199                PFID(lod_object_fid(lo)),
8200                sync_components, resync_components, mlc->mlc_resync_count);
8201
8202         lo->ldo_flr_state = LCM_FL_RDONLY;
8203         lod_obj_inc_layout_gen(lo);
8204
8205         layout_attr->la_valid = LA_LAYOUT_VERSION;
8206         layout_attr->la_layout_version = 0;
8207         rc = lod_declare_attr_set(env, &lo->ldo_obj, layout_attr, th);
8208         if (rc)
8209                 GOTO(out, rc);
8210
8211         info->lti_buf.lb_len = lod_comp_md_size(lo, false);
8212         rc = lod_sub_declare_xattr_set(env, lod_object_child(lo),
8213                                        &info->lti_buf, XATTR_NAME_LOV, 0, th);
8214         EXIT;
8215
8216 out:
8217         if (rc)
8218                 lod_striping_free(env, lo);
8219         RETURN(rc);
8220 }
8221
8222 typedef int (*mlc_handler)(const struct lu_env *env, struct dt_object *dt,
8223                            const struct md_layout_change *mlc,
8224                            struct thandle *th);
8225
8226 /**
8227  * Attach stripes after target's for migrating directory. NB, we
8228  * only need to declare this, the actual work is done inside
8229  * lod_xattr_set_lmv().
8230  *
8231  * \param[in] env       execution environment
8232  * \param[in] dt        target object
8233  * \param[in] mlc       layout change data
8234  * \param[in] th        transaction handle
8235  *
8236  * \retval              0 on success
8237  * \retval              negative if failed
8238  */
8239 static int lod_dir_declare_layout_attach(const struct lu_env *env,
8240                                          struct dt_object *dt,
8241                                          const struct md_layout_change *mlc,
8242                                          struct thandle *th)
8243 {
8244         struct lod_thread_info *info = lod_env_info(env);
8245         struct lod_device *lod = lu2lod_dev(dt->do_lu.lo_dev);
8246         struct lod_tgt_descs *ltd = &lod->lod_mdt_descs;
8247         struct lod_object *lo = lod_dt_obj(dt);
8248         struct dt_object *next = dt_object_child(dt);
8249         struct dt_object_format *dof = &info->lti_format;
8250         struct lmv_mds_md_v1 *lmv = mlc->mlc_buf.lb_buf;
8251         struct dt_object **stripes;
8252         __u32 stripe_count = le32_to_cpu(lmv->lmv_stripe_count);
8253         struct lu_fid *fid = &info->lti_fid;
8254         struct lod_tgt_desc *tgt;
8255         struct dt_object *dto;
8256         struct dt_device *tgt_dt;
8257         int type = LU_SEQ_RANGE_ANY;
8258         struct dt_insert_rec *rec = &info->lti_dt_rec;
8259         char *stripe_name = info->lti_key;
8260         struct lu_name *sname;
8261         struct linkea_data ldata = { NULL };
8262         struct lu_buf linkea_buf;
8263         __u32 idx;
8264         int i;
8265         int rc;
8266
8267         ENTRY;
8268
8269         if (!lmv_is_sane(lmv))
8270                 RETURN(-EINVAL);
8271
8272         if (!dt_try_as_dir(env, dt, false))
8273                 RETURN(-ENOTDIR);
8274
8275         dof->dof_type = DFT_DIR;
8276
8277         OBD_ALLOC_PTR_ARRAY(stripes, (lo->ldo_dir_stripe_count + stripe_count));
8278         if (!stripes)
8279                 RETURN(-ENOMEM);
8280
8281         for (i = 0; i < lo->ldo_dir_stripe_count; i++)
8282                 stripes[i] = lo->ldo_stripe[i];
8283
8284         rec->rec_type = S_IFDIR;
8285
8286         for (i = 0; i < stripe_count; i++) {
8287                 fid_le_to_cpu(fid,
8288                         &lmv->lmv_stripe_fids[i]);
8289                 if (!fid_is_sane(fid))
8290                         continue;
8291
8292                 rc = lod_fld_lookup(env, lod, fid, &idx, &type);
8293                 if (rc)
8294                         GOTO(out, rc);
8295
8296                 if (idx == lod2lu_dev(lod)->ld_site->ld_seq_site->ss_node_id) {
8297                         tgt_dt = lod->lod_child;
8298                 } else {
8299                         tgt = LTD_TGT(ltd, idx);
8300                         if (tgt == NULL)
8301                                 GOTO(out, rc = -ESTALE);
8302                         tgt_dt = tgt->ltd_tgt;
8303                 }
8304
8305                 dto = dt_locate_at(env, tgt_dt, fid,
8306                                   lo->ldo_obj.do_lu.lo_dev->ld_site->ls_top_dev,
8307                                   NULL);
8308                 if (IS_ERR(dto))
8309                         GOTO(out, rc = PTR_ERR(dto));
8310
8311                 stripes[i + lo->ldo_dir_stripe_count] = dto;
8312
8313                 if (!dt_try_as_dir(env, dto, true))
8314                         GOTO(out, rc = -ENOTDIR);
8315
8316                 rc = lod_sub_declare_ref_add(env, dto, th);
8317                 if (rc)
8318                         GOTO(out, rc);
8319
8320                 rec->rec_fid = lu_object_fid(&dto->do_lu);
8321                 rc = lod_sub_declare_insert(env, dto,
8322                                             (const struct dt_rec *)rec,
8323                                             (const struct dt_key *)dot, th);
8324                 if (rc)
8325                         GOTO(out, rc);
8326
8327                 rc = lod_sub_declare_insert(env, dto,
8328                                             (const struct dt_rec *)rec,
8329                                             (const struct dt_key *)dotdot, th);
8330                 if (rc)
8331                         GOTO(out, rc);
8332
8333                 rc = lod_sub_declare_xattr_set(env, dto, &mlc->mlc_buf,
8334                                                 XATTR_NAME_LMV, 0, th);
8335                 if (rc)
8336                         GOTO(out, rc);
8337
8338                 snprintf(stripe_name, sizeof(info->lti_key), DFID":%u",
8339                          PFID(lu_object_fid(&dto->do_lu)),
8340                          i + lo->ldo_dir_stripe_count);
8341
8342                 sname = lod_name_get(env, stripe_name, strlen(stripe_name));
8343                 rc = linkea_links_new(&ldata, &info->lti_linkea_buf,
8344                                       sname, lu_object_fid(&dt->do_lu));
8345                 if (rc)
8346                         GOTO(out, rc);
8347
8348                 linkea_buf.lb_buf = ldata.ld_buf->lb_buf;
8349                 linkea_buf.lb_len = ldata.ld_leh->leh_len;
8350                 rc = lod_sub_declare_xattr_set(env, dto, &linkea_buf,
8351                                                XATTR_NAME_LINK, 0, th);
8352                 if (rc)
8353                         GOTO(out, rc);
8354
8355                 rc = lod_sub_declare_insert(env, next,
8356                                             (const struct dt_rec *)rec,
8357                                             (const struct dt_key *)stripe_name,
8358                                             th);
8359                 if (rc)
8360                         GOTO(out, rc);
8361
8362                 rc = lod_sub_declare_ref_add(env, next, th);
8363                 if (rc)
8364                         GOTO(out, rc);
8365         }
8366
8367         if (lo->ldo_stripe)
8368                 OBD_FREE_PTR_ARRAY(lo->ldo_stripe,
8369                                    lo->ldo_dir_stripes_allocated);
8370         lo->ldo_stripe = stripes;
8371         lo->ldo_is_foreign = 0;
8372         lo->ldo_dir_migrate_offset = lo->ldo_dir_stripe_count;
8373         lo->ldo_dir_migrate_hash = le32_to_cpu(lmv->lmv_hash_type);
8374         lo->ldo_dir_stripe_count += stripe_count;
8375         lo->ldo_dir_stripes_allocated += stripe_count;
8376
8377         /* plain directory split creates target as a plain directory, while
8378          * after source attached as the first stripe, it becomes a striped
8379          * directory, set correct do_index_ops, otherwise it can't be unlinked.
8380          */
8381         dt->do_index_ops = &lod_striped_index_ops;
8382
8383         RETURN(0);
8384 out:
8385         i = lo->ldo_dir_stripe_count;
8386         while (i < lo->ldo_dir_stripe_count + stripe_count && stripes[i])
8387                 dt_object_put(env, stripes[i++]);
8388
8389         OBD_FREE_PTR_ARRAY(stripes, stripe_count + lo->ldo_dir_stripe_count);
8390         return rc;
8391 }
8392
8393 static int lod_dir_declare_layout_detach(const struct lu_env *env,
8394                                          struct dt_object *dt,
8395                                          const struct md_layout_change *unused,
8396                                          struct thandle *th)
8397 {
8398         struct lod_thread_info *info = lod_env_info(env);
8399         struct lod_object *lo = lod_dt_obj(dt);
8400         struct dt_object *next = dt_object_child(dt);
8401         char *stripe_name = info->lti_key;
8402         struct dt_object *dto;
8403         int i;
8404         int rc = 0;
8405
8406         if (!dt_try_as_dir(env, dt, true))
8407                 return -ENOTDIR;
8408
8409         if (!lo->ldo_dir_stripe_count)
8410                 return lod_sub_declare_delete(env, next,
8411                                         (const struct dt_key *)dotdot, th);
8412
8413         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
8414                 dto = lo->ldo_stripe[i];
8415                 if (!dto)
8416                         continue;
8417
8418                 if (!dt_try_as_dir(env, dto, true))
8419                         return -ENOTDIR;
8420
8421                 rc = lod_sub_declare_delete(env, dto,
8422                                         (const struct dt_key *)dotdot, th);
8423                 if (rc)
8424                         return rc;
8425
8426                 snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
8427                          PFID(lu_object_fid(&dto->do_lu)), i);
8428
8429                 rc = lod_sub_declare_delete(env, next,
8430                                         (const struct dt_key *)stripe_name, th);
8431                 if (rc)
8432                         return rc;
8433
8434                 rc = lod_sub_declare_ref_del(env, next, th);
8435                 if (rc)
8436                         return rc;
8437         }
8438
8439         return 0;
8440 }
8441
8442 static int dt_dir_is_empty(const struct lu_env *env,
8443                            struct dt_object *obj)
8444 {
8445         struct dt_it *it;
8446         const struct dt_it_ops *iops;
8447         int rc;
8448
8449         ENTRY;
8450
8451         if (!dt_try_as_dir(env, obj, true))
8452                 RETURN(-ENOTDIR);
8453
8454         iops = &obj->do_index_ops->dio_it;
8455         it = iops->init(env, obj, LUDA_64BITHASH);
8456         if (IS_ERR(it))
8457                 RETURN(PTR_ERR(it));
8458
8459         rc = iops->get(env, it, (const struct dt_key *)"");
8460         if (rc > 0) {
8461                 int i;
8462
8463                 for (rc = 0, i = 0; rc == 0 && i < 3; ++i)
8464                         rc = iops->next(env, it);
8465                 if (!rc)
8466                         rc = -ENOTEMPTY;
8467                 else if (rc == 1)
8468                         rc = 0;
8469         } else if (!rc) {
8470                 /* Huh? Index contains no zero key? */
8471                 rc = -EIO;
8472         }
8473
8474         iops->put(env, it);
8475         iops->fini(env, it);
8476
8477         RETURN(rc);
8478 }
8479
8480 static int lod_dir_declare_layout_shrink(const struct lu_env *env,
8481                                          struct dt_object *dt,
8482                                          const struct md_layout_change *mlc,
8483                                          struct thandle *th)
8484 {
8485         struct lod_thread_info *info = lod_env_info(env);
8486         struct lod_object *lo = lod_dt_obj(dt);
8487         struct dt_object *next = dt_object_child(dt);
8488         struct lmv_user_md *lmu = mlc->mlc_buf.lb_buf;
8489         char *stripe_name = info->lti_key;
8490         struct lu_buf *lmv_buf = &info->lti_buf;
8491         __u32 final_stripe_count;
8492         struct dt_object *dto;
8493         int i;
8494         int rc;
8495
8496         LASSERT(lmu);
8497
8498         if (!dt_try_as_dir(env, dt, true))
8499                 return -ENOTDIR;
8500
8501         /* shouldn't be called on plain directory */
8502         LASSERT(lo->ldo_dir_stripe_count);
8503
8504         lmv_buf->lb_buf = &info->lti_lmv.lmv_md_v1;
8505         lmv_buf->lb_len = sizeof(info->lti_lmv.lmv_md_v1);
8506
8507         final_stripe_count = le32_to_cpu(lmu->lum_stripe_count);
8508         LASSERT(final_stripe_count &&
8509                 final_stripe_count < lo->ldo_dir_stripe_count);
8510
8511         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
8512                 dto = lo->ldo_stripe[i];
8513                 if (!dto)
8514                         continue;
8515
8516                 if (i < final_stripe_count) {
8517                         rc = lod_sub_declare_xattr_set(env, dto, lmv_buf,
8518                                                        XATTR_NAME_LMV,
8519                                                        LU_XATTR_REPLACE, th);
8520                         if (rc)
8521                                 return rc;
8522
8523                         continue;
8524                 }
8525
8526                 rc = dt_dir_is_empty(env, dto);
8527                 if (rc < 0)
8528                         return rc;
8529
8530                 rc = lod_sub_declare_ref_del(env, dto, th);
8531                 if (rc)
8532                         return rc;
8533
8534                 rc = lod_sub_declare_destroy(env, dto, th);
8535                 if (rc)
8536                         return rc;
8537
8538                 snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
8539                          PFID(lu_object_fid(&dto->do_lu)), i);
8540
8541                 rc = lod_sub_declare_delete(env, next,
8542                                         (const struct dt_key *)stripe_name, th);
8543                 if (rc)
8544                         return rc;
8545
8546                 rc = lod_sub_declare_ref_del(env, next, th);
8547                 if (rc)
8548                         return rc;
8549         }
8550
8551         rc = lod_sub_declare_xattr_set(env, next, lmv_buf, XATTR_NAME_LMV,
8552                                        LU_XATTR_REPLACE, th);
8553         return rc;
8554 }
8555
8556 /**
8557  * Allocate stripes for split directory.
8558  *
8559  * \param[in] env       execution environment
8560  * \param[in] dt        target object
8561  * \param[in] mlc       layout change data
8562  * \param[in] th        transaction handle
8563  *
8564  * \retval              0 on success
8565  * \retval              negative if failed
8566  */
8567 static int lod_dir_declare_layout_split(const struct lu_env *env,
8568                                         struct dt_object *dt,
8569                                         const struct md_layout_change *mlc,
8570                                         struct thandle *th)
8571 {
8572         struct lod_thread_info *info = lod_env_info(env);
8573         struct lod_device *lod = lu2lod_dev(dt->do_lu.lo_dev);
8574         struct lod_object *lo = lod_dt_obj(dt);
8575         struct dt_object_format *dof = &info->lti_format;
8576         struct lmv_user_md_v1 *lum = mlc->mlc_spec->u.sp_ea.eadata;
8577         struct dt_object **stripes;
8578         u32 stripe_count;
8579         u32 saved_count;
8580         int i;
8581         int rc;
8582
8583         ENTRY;
8584
8585         LASSERT(le32_to_cpu(lum->lum_magic) == LMV_USER_MAGIC);
8586         LASSERT(le32_to_cpu(lum->lum_stripe_offset) == LMV_OFFSET_DEFAULT);
8587
8588         saved_count = lo->ldo_dir_stripes_allocated;
8589         stripe_count = le32_to_cpu(lum->lum_stripe_count);
8590         if (stripe_count <= saved_count)
8591                 RETURN(-EINVAL);
8592
8593         dof->dof_type = DFT_DIR;
8594
8595         OBD_ALLOC(stripes, sizeof(*stripes) * stripe_count);
8596         if (!stripes)
8597                 RETURN(-ENOMEM);
8598
8599         for (i = 0; i < lo->ldo_dir_stripes_allocated; i++)
8600                 stripes[i] = lo->ldo_stripe[i];
8601
8602         lod_qos_statfs_update(env, lod, &lod->lod_mdt_descs);
8603         rc = lod_mdt_alloc_qos(env, lo, stripes, saved_count, stripe_count);
8604         if (rc == -EAGAIN)
8605                 rc = lod_mdt_alloc_rr(env, lo, stripes, saved_count,
8606                                       stripe_count);
8607         if (rc < 0) {
8608                 OBD_FREE(stripes, sizeof(*stripes) * stripe_count);
8609                 RETURN(rc);
8610         }
8611
8612         LASSERT(rc > saved_count);
8613         OBD_FREE(lo->ldo_stripe,
8614                  sizeof(*stripes) * lo->ldo_dir_stripes_allocated);
8615         lo->ldo_stripe = stripes;
8616         lo->ldo_is_foreign = 0;
8617         lo->ldo_dir_striped = 1;
8618         lo->ldo_dir_stripe_count = rc;
8619         lo->ldo_dir_stripes_allocated = stripe_count;
8620         lo->ldo_dir_split_hash = lo->ldo_dir_hash_type;
8621         lo->ldo_dir_hash_type = le32_to_cpu(lum->lum_hash_type);
8622         if (!lmv_is_known_hash_type(lo->ldo_dir_hash_type))
8623                 lo->ldo_dir_hash_type =
8624                         lod->lod_mdt_descs.ltd_lmv_desc.ld_pattern;
8625         lo->ldo_dir_hash_type |= LMV_HASH_FLAG_SPLIT | LMV_HASH_FLAG_MIGRATION;
8626         lo->ldo_dir_split_offset = saved_count;
8627         lo->ldo_dir_layout_version++;
8628         lo->ldo_dir_stripe_loaded = 1;
8629
8630         rc = lod_dir_declare_create_stripes(env, dt, mlc->mlc_attr, dof, th);
8631         if (rc)
8632                 lod_striping_free(env, lo);
8633
8634         RETURN(rc);
8635 }
8636
8637 /*
8638  * detach all stripes from dir master object, NB, stripes are not destroyed, but
8639  * deleted from it's parent namespace, this function is called in two places:
8640  * 1. mdd_migrate_mdt() detach stripes from source, and attach them to
8641  *    target.
8642  * 2. mdd_dir_layout_update() detach stripe before turning 1-stripe directory to
8643  *    a plain directory.
8644  *
8645  * \param[in] env       execution environment
8646  * \param[in] dt        target object
8647  * \param[in] mlc       layout change data
8648  * \param[in] th        transaction handle
8649  *
8650  * \retval              0 on success
8651  * \retval              negative if failed
8652  */
8653 static int lod_dir_layout_detach(const struct lu_env *env,
8654                                  struct dt_object *dt,
8655                                  const struct md_layout_change *mlc,
8656                                  struct thandle *th)
8657 {
8658         struct lod_thread_info *info = lod_env_info(env);
8659         struct lod_object *lo = lod_dt_obj(dt);
8660         struct dt_object *next = dt_object_child(dt);
8661         char *stripe_name = info->lti_key;
8662         struct dt_object *dto;
8663         int i;
8664         int rc = 0;
8665
8666         ENTRY;
8667
8668         if (!lo->ldo_dir_stripe_count) {
8669                 /* plain directory delete .. */
8670                 rc = lod_sub_delete(env, next,
8671                                     (const struct dt_key *)dotdot, th);
8672                 RETURN(rc);
8673         }
8674
8675         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
8676                 dto = lo->ldo_stripe[i];
8677                 if (!dto)
8678                         continue;
8679
8680                 rc = lod_sub_delete(env, dto,
8681                                     (const struct dt_key *)dotdot, th);
8682                 if (rc)
8683                         break;
8684
8685                 snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
8686                          PFID(lu_object_fid(&dto->do_lu)), i);
8687
8688                 rc = lod_sub_delete(env, next,
8689                                     (const struct dt_key *)stripe_name, th);
8690                 if (rc)
8691                         break;
8692
8693                 rc = lod_sub_ref_del(env, next, th);
8694                 if (rc)
8695                         break;
8696         }
8697
8698         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
8699                 dto = lo->ldo_stripe[i];
8700                 if (dto)
8701                         dt_object_put(env, dto);
8702         }
8703         OBD_FREE_PTR_ARRAY(lo->ldo_stripe, lo->ldo_dir_stripes_allocated);
8704         lo->ldo_stripe = NULL;
8705         lo->ldo_dir_stripes_allocated = 0;
8706         lo->ldo_dir_stripe_count = 0;
8707         dt->do_index_ops = &lod_index_ops;
8708
8709         RETURN(rc);
8710 }
8711
8712 static int lod_dir_layout_shrink(const struct lu_env *env,
8713                                  struct dt_object *dt,
8714                                  const struct md_layout_change *mlc,
8715                                  struct thandle *th)
8716 {
8717         struct lod_thread_info *info = lod_env_info(env);
8718         struct lod_object *lo = lod_dt_obj(dt);
8719         struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
8720         struct dt_object *next = dt_object_child(dt);
8721         struct lmv_user_md *lmu = mlc->mlc_buf.lb_buf;
8722         __u32 final_stripe_count;
8723         char *stripe_name = info->lti_key;
8724         struct dt_object *dto;
8725         struct lu_buf *lmv_buf = &info->lti_buf;
8726         struct lmv_mds_md_v1 *lmv = &info->lti_lmv.lmv_md_v1;
8727         u32 mdtidx;
8728         int type = LU_SEQ_RANGE_ANY;
8729         int i;
8730         int rc;
8731
8732         ENTRY;
8733
8734         final_stripe_count = le32_to_cpu(lmu->lum_stripe_count);
8735
8736         lmv_buf->lb_buf = lmv;
8737         lmv_buf->lb_len = sizeof(*lmv);
8738         lmv->lmv_magic = cpu_to_le32(LMV_MAGIC_STRIPE);
8739         lmv->lmv_stripe_count = cpu_to_le32(final_stripe_count);
8740         lmv->lmv_hash_type = cpu_to_le32(lo->ldo_dir_hash_type) &
8741                              cpu_to_le32(LMV_HASH_TYPE_MASK |
8742                                          LMV_HASH_FLAG_FIXED);
8743         lmv->lmv_layout_version =
8744                         cpu_to_le32(lo->ldo_dir_layout_version + 1);
8745         lmv->lmv_migrate_offset = 0;
8746         lmv->lmv_migrate_hash = 0;
8747
8748         for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
8749                 dto = lo->ldo_stripe[i];
8750                 if (!dto)
8751                         continue;
8752
8753                 if (i < final_stripe_count) {
8754                         rc = lod_fld_lookup(env, lod,
8755                                             lu_object_fid(&dto->do_lu),
8756                                             &mdtidx, &type);
8757                         if (rc)
8758                                 RETURN(rc);
8759
8760                         lmv->lmv_master_mdt_index = cpu_to_le32(mdtidx);
8761                         rc = lod_sub_xattr_set(env, dto, lmv_buf,
8762                                                XATTR_NAME_LMV,
8763                                                LU_XATTR_REPLACE, th);
8764                         if (rc)
8765                                 RETURN(rc);
8766
8767                         continue;
8768                 }
8769
8770                 dt_write_lock(env, dto, DT_TGT_CHILD);
8771                 rc = lod_sub_ref_del(env, dto, th);
8772                 dt_write_unlock(env, dto);
8773                 if (rc)
8774                         RETURN(rc);
8775
8776                 rc = lod_sub_destroy(env, dto, th);
8777                 if (rc)
8778                         RETURN(rc);
8779
8780                 snprintf(stripe_name, sizeof(info->lti_key), DFID":%d",
8781                          PFID(lu_object_fid(&dto->do_lu)), i);
8782
8783                 rc = lod_sub_delete(env, next,
8784                                     (const struct dt_key *)stripe_name, th);
8785                 if (rc)
8786                         RETURN(rc);
8787
8788                 rc = lod_sub_ref_del(env, next, th);
8789                 if (rc)
8790                         RETURN(rc);
8791         }
8792
8793         rc = lod_fld_lookup(env, lod, lu_object_fid(&dt->do_lu), &mdtidx,
8794                             &type);
8795         if (rc)
8796                 RETURN(rc);
8797
8798         lmv->lmv_magic = cpu_to_le32(LMV_MAGIC_V1);
8799         lmv->lmv_master_mdt_index = cpu_to_le32(mdtidx);
8800         rc = lod_sub_xattr_set(env, next, lmv_buf, XATTR_NAME_LMV,
8801                                LU_XATTR_REPLACE, th);
8802         if (rc)
8803                 RETURN(rc);
8804
8805         for (i = final_stripe_count; i < lo->ldo_dir_stripe_count; i++) {
8806                 dto = lo->ldo_stripe[i];
8807                 if (dto)
8808                         dt_object_put(env, dto);
8809         }
8810         lo->ldo_dir_stripe_count = final_stripe_count;
8811
8812         RETURN(rc);
8813 }
8814
8815 static mlc_handler dir_mlc_declare_ops[MD_LAYOUT_MAX] = {
8816         [MD_LAYOUT_ATTACH] = lod_dir_declare_layout_attach,
8817         [MD_LAYOUT_DETACH] = lod_dir_declare_layout_detach,
8818         [MD_LAYOUT_SHRINK] = lod_dir_declare_layout_shrink,
8819         [MD_LAYOUT_SPLIT]  = lod_dir_declare_layout_split,
8820 };
8821
8822 static mlc_handler dir_mlc_ops[MD_LAYOUT_MAX] = {
8823         [MD_LAYOUT_DETACH] = lod_dir_layout_detach,
8824         [MD_LAYOUT_SHRINK] = lod_dir_layout_shrink,
8825 };
8826
8827 static int lod_declare_layout_change(const struct lu_env *env,
8828                 struct dt_object *dt, struct md_layout_change *mlc,
8829                 struct thandle *th)
8830 {
8831         struct lod_thread_info  *info = lod_env_info(env);
8832         struct lod_object *lo = lod_dt_obj(dt);
8833         int rc;
8834
8835         ENTRY;
8836
8837         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
8838                 LASSERT(dir_mlc_declare_ops[mlc->mlc_opc]);
8839                 rc = dir_mlc_declare_ops[mlc->mlc_opc](env, dt, mlc, th);
8840                 RETURN(rc);
8841         }
8842
8843         if (!S_ISREG(dt->do_lu.lo_header->loh_attr) || !dt_object_exists(dt) ||
8844             dt_object_remote(dt_object_child(dt)))
8845                 RETURN(-EINVAL);
8846
8847         rc = lod_striping_load(env, lo);
8848         if (rc)
8849                 GOTO(out, rc);
8850
8851         LASSERT(lo->ldo_comp_cnt > 0);
8852
8853         rc = lod_layout_data_init(info, lo->ldo_comp_cnt);
8854         if (rc)
8855                 GOTO(out, rc);
8856
8857         switch (lo->ldo_flr_state) {
8858         case LCM_FL_NONE:
8859                 rc = lod_declare_update_plain(env, lo, mlc->mlc_intent,
8860                                               &mlc->mlc_buf, th);
8861                 break;
8862         case LCM_FL_RDONLY:
8863                 rc = lod_declare_update_rdonly(env, lo, mlc, th);
8864                 break;
8865         case LCM_FL_WRITE_PENDING:
8866                 rc = lod_declare_update_write_pending(env, lo, mlc, th);
8867                 break;
8868         case LCM_FL_SYNC_PENDING:
8869                 rc = lod_declare_update_sync_pending(env, lo, mlc, th);
8870                 break;
8871         default:
8872                 rc = -ENOTSUPP;
8873                 break;
8874         }
8875 out:
8876         RETURN(rc);
8877 }
8878
8879 /**
8880  * Instantiate layout component objects which covers the intent write offset.
8881  */
8882 static int lod_layout_change(const struct lu_env *env, struct dt_object *dt,
8883                              struct md_layout_change *mlc, struct thandle *th)
8884 {
8885         struct lu_attr *attr = &lod_env_info(env)->lti_attr;
8886         struct lu_attr *layout_attr = &lod_env_info(env)->lti_layout_attr;
8887         struct lod_object *lo = lod_dt_obj(dt);
8888         int rc;
8889
8890         ENTRY;
8891
8892         if (S_ISDIR(dt->do_lu.lo_header->loh_attr)) {
8893                 LASSERT(dir_mlc_ops[mlc->mlc_opc]);
8894                 rc = dir_mlc_ops[mlc->mlc_opc](env, dt, mlc, th);
8895                 RETURN(rc);
8896         }
8897
8898         rc = lod_striped_create(env, dt, attr, NULL, th);
8899         if (!rc && layout_attr->la_valid & LA_LAYOUT_VERSION) {
8900                 layout_attr->la_layout_version |= lo->ldo_layout_gen;
8901                 rc = lod_attr_set(env, dt, layout_attr, th);
8902         }
8903
8904         RETURN(rc);
8905 }
8906
8907 const struct dt_object_operations lod_obj_ops = {
8908         .do_read_lock           = lod_read_lock,
8909         .do_write_lock          = lod_write_lock,
8910         .do_read_unlock         = lod_read_unlock,
8911         .do_write_unlock        = lod_write_unlock,
8912         .do_write_locked        = lod_write_locked,
8913         .do_attr_get            = lod_attr_get,
8914         .do_declare_attr_set    = lod_declare_attr_set,
8915         .do_attr_set            = lod_attr_set,
8916         .do_xattr_get           = lod_xattr_get,
8917         .do_declare_xattr_set   = lod_declare_xattr_set,
8918         .do_xattr_set           = lod_xattr_set,
8919         .do_declare_xattr_del   = lod_declare_xattr_del,
8920         .do_xattr_del           = lod_xattr_del,
8921         .do_xattr_list          = lod_xattr_list,
8922         .do_ah_init             = lod_ah_init,
8923         .do_declare_create      = lod_declare_create,
8924         .do_create              = lod_create,
8925         .do_declare_destroy     = lod_declare_destroy,
8926         .do_destroy             = lod_destroy,
8927         .do_index_try           = lod_index_try,
8928         .do_declare_ref_add     = lod_declare_ref_add,
8929         .do_ref_add             = lod_ref_add,
8930         .do_declare_ref_del     = lod_declare_ref_del,
8931         .do_ref_del             = lod_ref_del,
8932         .do_object_sync         = lod_object_sync,
8933         .do_object_lock         = lod_object_lock,
8934         .do_object_unlock       = lod_object_unlock,
8935         .do_invalidate          = lod_invalidate,
8936         .do_declare_layout_change = lod_declare_layout_change,
8937         .do_layout_change       = lod_layout_change,
8938 };
8939
8940 /**
8941  * Implementation of dt_body_operations::dbo_read.
8942  *
8943  * \see dt_body_operations::dbo_read() in the API description for details.
8944  */
8945 static ssize_t lod_read(const struct lu_env *env, struct dt_object *dt,
8946                         struct lu_buf *buf, loff_t *pos)
8947 {
8948         struct dt_object *next = dt_object_child(dt);
8949
8950         LASSERT(S_ISREG(dt->do_lu.lo_header->loh_attr) ||
8951                 S_ISLNK(dt->do_lu.lo_header->loh_attr));
8952         return next->do_body_ops->dbo_read(env, next, buf, pos);
8953 }
8954
8955 /**
8956  * Implementation of dt_body_operations::dbo_declare_write.
8957  *
8958  * \see dt_body_operations::dbo_declare_write() in the API description
8959  * for details.
8960  */
8961 static ssize_t lod_declare_write(const struct lu_env *env,
8962                                  struct dt_object *dt,
8963                                  const struct lu_buf *buf, loff_t pos,
8964                                  struct thandle *th)
8965 {
8966         return lod_sub_declare_write(env, dt_object_child(dt), buf, pos, th);
8967 }
8968
8969 /**
8970  * Implementation of dt_body_operations::dbo_write.
8971  *
8972  * \see dt_body_operations::dbo_write() in the API description for details.
8973  */
8974 static ssize_t lod_write(const struct lu_env *env, struct dt_object *dt,
8975                          const struct lu_buf *buf, loff_t *pos,
8976                          struct thandle *th)
8977 {
8978         LASSERT(S_ISREG(dt->do_lu.lo_header->loh_attr) ||
8979                 S_ISLNK(dt->do_lu.lo_header->loh_attr));
8980         return lod_sub_write(env, dt_object_child(dt), buf, pos, th);
8981 }
8982
8983 static int lod_declare_punch(const struct lu_env *env, struct dt_object *dt,
8984                              __u64 start, __u64 end, struct thandle *th)
8985 {
8986         if (dt_object_remote(dt))
8987                 return -ENOTSUPP;
8988
8989         return lod_sub_declare_punch(env, dt_object_child(dt), start, end, th);
8990 }
8991
8992 static int lod_punch(const struct lu_env *env, struct dt_object *dt,
8993                      __u64 start, __u64 end, struct thandle *th)
8994 {
8995         if (dt_object_remote(dt))
8996                 return -ENOTSUPP;
8997
8998         LASSERT(S_ISREG(dt->do_lu.lo_header->loh_attr));
8999         return lod_sub_punch(env, dt_object_child(dt), start, end, th);
9000 }
9001
9002 /*
9003  * different type of files use the same body_ops because object may be created
9004  * in OUT, where there is no chance to set correct body_ops for each type, so
9005  * body_ops themselves will check file type inside, see lod_read/write/punch for
9006  * details.
9007  */
9008 static const struct dt_body_operations lod_body_ops = {
9009         .dbo_read               = lod_read,
9010         .dbo_declare_write      = lod_declare_write,
9011         .dbo_write              = lod_write,
9012         .dbo_declare_punch      = lod_declare_punch,
9013         .dbo_punch              = lod_punch,
9014 };
9015
9016 /**
9017  * Implementation of lu_object_operations::loo_object_init.
9018  *
9019  * The function determines the type and the index of the target device using
9020  * sequence of the object's FID. Then passes control down to the
9021  * corresponding device:
9022  *  OSD for the local objects, OSP for remote
9023  *
9024  * \see lu_object_operations::loo_object_init() in the API description
9025  * for details.
9026  */
9027 static int lod_object_init(const struct lu_env *env, struct lu_object *lo,
9028                            const struct lu_object_conf *conf)
9029 {
9030         struct lod_device       *lod    = lu2lod_dev(lo->lo_dev);
9031         struct lu_device        *cdev   = NULL;
9032         struct lu_object        *cobj;
9033         struct lod_tgt_descs    *ltd    = NULL;
9034         struct lod_tgt_desc     *tgt;
9035         u32                      idx    = 0;
9036         int                      type   = LU_SEQ_RANGE_ANY;
9037         int                      rc;
9038         ENTRY;
9039
9040         rc = lod_fld_lookup(env, lod, lu_object_fid(lo), &idx, &type);
9041         if (rc != 0)
9042                 RETURN(rc);
9043
9044         if (type == LU_SEQ_RANGE_MDT &&
9045             idx == lu_site2seq(lo->lo_dev->ld_site)->ss_node_id) {
9046                 cdev = &lod->lod_child->dd_lu_dev;
9047         } else if (type == LU_SEQ_RANGE_MDT) {
9048                 ltd = &lod->lod_mdt_descs;
9049                 lod_getref(ltd);
9050         } else if (type == LU_SEQ_RANGE_OST) {
9051                 ltd = &lod->lod_ost_descs;
9052                 lod_getref(ltd);
9053         } else {
9054                 LBUG();
9055         }
9056
9057         if (ltd != NULL) {
9058                 if (ltd->ltd_tgts_size > idx &&
9059                     test_bit(idx, ltd->ltd_tgt_bitmap)) {
9060                         tgt = LTD_TGT(ltd, idx);
9061
9062                         LASSERT(tgt != NULL);
9063                         LASSERT(tgt->ltd_tgt != NULL);
9064
9065                         cdev = &(tgt->ltd_tgt->dd_lu_dev);
9066                 }
9067                 lod_putref(lod, ltd);
9068         }
9069
9070         if (unlikely(cdev == NULL))
9071                 RETURN(-ENOENT);
9072
9073         cobj = cdev->ld_ops->ldo_object_alloc(env, lo->lo_header, cdev);
9074         if (unlikely(cobj == NULL))
9075                 RETURN(-ENOMEM);
9076
9077         lu2lod_obj(lo)->ldo_obj.do_body_ops = &lod_body_ops;
9078
9079         lu_object_add(lo, cobj);
9080
9081         RETURN(0);
9082 }
9083
9084 /**
9085  *
9086  * Release resources associated with striping.
9087  *
9088  * If the object is striped (regular or directory), then release
9089  * the stripe objects references and free the ldo_stripe array.
9090  *
9091  * \param[in] env       execution environment
9092  * \param[in] lo        object
9093  */
9094 void lod_striping_free_nolock(const struct lu_env *env, struct lod_object *lo)
9095 {
9096         struct lod_layout_component *lod_comp;
9097         __u32 obj_attr = lo->ldo_obj.do_lu.lo_header->loh_attr;
9098         int i, j;
9099
9100         if (unlikely(lo->ldo_is_foreign)) {
9101                 if (S_ISREG(obj_attr)) {
9102                         lod_free_foreign_lov(lo);
9103                         lo->ldo_comp_cached = 0;
9104                 } else if (S_ISDIR(obj_attr)) {
9105                         lod_free_foreign_lmv(lo);
9106                         lo->ldo_dir_stripe_loaded = 0;
9107                 }
9108         } else if (lo->ldo_stripe != NULL) {
9109                 LASSERT(lo->ldo_comp_entries == NULL);
9110                 LASSERT(lo->ldo_dir_stripes_allocated > 0);
9111
9112                 for (i = 0; i < lo->ldo_dir_stripe_count; i++) {
9113                         if (lo->ldo_stripe[i])
9114                                 dt_object_put(env, lo->ldo_stripe[i]);
9115                 }
9116
9117                 j = sizeof(struct dt_object *) * lo->ldo_dir_stripes_allocated;
9118                 OBD_FREE(lo->ldo_stripe, j);
9119                 lo->ldo_stripe = NULL;
9120                 lo->ldo_dir_stripes_allocated = 0;
9121                 lo->ldo_dir_stripe_loaded = 0;
9122                 lo->ldo_dir_stripe_count = 0;
9123                 lo->ldo_obj.do_index_ops = NULL;
9124         } else if (lo->ldo_comp_entries != NULL) {
9125                 for (i = 0; i < lo->ldo_comp_cnt; i++) {
9126                         /* free lod_layout_component::llc_stripe array */
9127                         lod_comp = &lo->ldo_comp_entries[i];
9128
9129                         if (lod_comp->llc_stripe == NULL)
9130                                 continue;
9131                         LASSERT(lod_comp->llc_stripes_allocated != 0);
9132                         for (j = 0; j < lod_comp->llc_stripes_allocated; j++) {
9133                                 if (lod_comp->llc_stripe[j] != NULL)
9134                                         lu_object_put(env,
9135                                                &lod_comp->llc_stripe[j]->do_lu);
9136                         }
9137                         OBD_FREE_PTR_ARRAY(lod_comp->llc_stripe,
9138                                            lod_comp->llc_stripes_allocated);
9139                         lod_comp->llc_stripe = NULL;
9140                         OBD_FREE_PTR_ARRAY(lod_comp->llc_ost_indices,
9141                                            lod_comp->llc_stripes_allocated);
9142                         lod_comp->llc_ost_indices = NULL;
9143                         lod_comp->llc_stripes_allocated = 0;
9144                 }
9145                 lod_free_comp_entries(lo);
9146                 lo->ldo_comp_cached = 0;
9147         }
9148 }
9149
9150 void lod_striping_free(const struct lu_env *env, struct lod_object *lo)
9151 {
9152         mutex_lock(&lo->ldo_layout_mutex);
9153         lod_striping_free_nolock(env, lo);
9154         mutex_unlock(&lo->ldo_layout_mutex);
9155 }
9156
9157 /**
9158  * Implementation of lu_object_operations::loo_object_free.
9159  *
9160  * \see lu_object_operations::loo_object_free() in the API description
9161  * for details.
9162  */
9163 static void lod_object_free(const struct lu_env *env, struct lu_object *o)
9164 {
9165         struct lod_object *lo = lu2lod_obj(o);
9166
9167         /* release all underlying object pinned */
9168         lod_striping_free(env, lo);
9169         lu_object_fini(o);
9170         /* lo doesn't contain a lu_object_header, so we don't need call_rcu */
9171         OBD_SLAB_FREE_PTR(lo, lod_object_kmem);
9172 }
9173
9174 /**
9175  * Implementation of lu_object_operations::loo_object_release.
9176  *
9177  * \see lu_object_operations::loo_object_release() in the API description
9178  * for details.
9179  */
9180 static void lod_object_release(const struct lu_env *env, struct lu_object *o)
9181 {
9182         /* XXX: shouldn't we release everything here in case if object
9183          * creation failed before? */
9184 }
9185
9186 /**
9187  * Implementation of lu_object_operations::loo_object_print.
9188  *
9189  * \see lu_object_operations::loo_object_print() in the API description
9190  * for details.
9191  */
9192 static int lod_object_print(const struct lu_env *env, void *cookie,
9193                             lu_printer_t p, const struct lu_object *l)
9194 {
9195         struct lod_object *o = lu2lod_obj((struct lu_object *) l);
9196
9197         return (*p)(env, cookie, LUSTRE_LOD_NAME"-object@%p", o);
9198 }
9199
9200 const struct lu_object_operations lod_lu_obj_ops = {
9201         .loo_object_init        = lod_object_init,
9202         .loo_object_free        = lod_object_free,
9203         .loo_object_release     = lod_object_release,
9204         .loo_object_print       = lod_object_print,
9205 };