lustre/obdclass/local_storage.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 (c) 2012, 2015, Intel Corporation.
  24  */
  25 /*
  26  * lustre/obdclass/local_storage.c
  27  *
  28  * Local storage for file/objects with fid generation. Works on top of OSD.
  29  *
  30  * Author: Mikhail Pershin <mike.pershin@intel.com>
  31  */
  32
  33 #define DEBUG_SUBSYSTEM S_CLASS
  34
  35 #include "local_storage.h"
  36
  37 /* all initialized local storages on this node are linked on this */
  38 static struct list_head ls_list_head = LIST_HEAD_INIT(ls_list_head);
  39 static DEFINE_MUTEX(ls_list_mutex);
  40
  41 static int ls_object_init(const struct lu_env *env, struct lu_object *o,
  42                           const struct lu_object_conf *unused)
  43 {
  44         struct ls_device        *ls;
  45         struct lu_object        *below;
  46         struct lu_device        *under;
  47
  48         ENTRY;
  49
  50         ls = container_of0(o->lo_dev, struct ls_device, ls_top_dev.dd_lu_dev);
  51         under = &ls->ls_osd->dd_lu_dev;
  52         below = under->ld_ops->ldo_object_alloc(env, o->lo_header, under);
  53         if (below == NULL)
  54                 RETURN(-ENOMEM);
  55
  56         lu_object_add(o, below);
  57
  58         RETURN(0);
  59 }
  60
  61 static void ls_object_free(const struct lu_env *env, struct lu_object *o)
  62 {
  63         struct ls_object        *obj = lu2ls_obj(o);
  64         struct lu_object_header *h = o->lo_header;
  65
  66         dt_object_fini(&obj->ls_obj);
  67         lu_object_header_fini(h);
  68         OBD_FREE_PTR(obj);
  69 }
  70
  71 static struct lu_object_operations ls_lu_obj_ops = {
  72         .loo_object_init  = ls_object_init,
  73         .loo_object_free  = ls_object_free,
  74 };
  75
  76 static struct lu_object *ls_object_alloc(const struct lu_env *env,
  77                                          const struct lu_object_header *_h,
  78                                          struct lu_device *d)
  79 {
  80         struct lu_object_header *h;
  81         struct ls_object        *o;
  82         struct lu_object        *l;
  83
  84         LASSERT(_h == NULL);
  85
  86         OBD_ALLOC_PTR(o);
  87         if (o != NULL) {
  88                 l = &o->ls_obj.do_lu;
  89                 h = &o->ls_header;
  90
  91                 lu_object_header_init(h);
  92                 dt_object_init(&o->ls_obj, h, d);
  93                 lu_object_add_top(h, l);
  94
  95                 l->lo_ops = &ls_lu_obj_ops;
  96
  97                 return l;
  98         } else {
  99                 return NULL;
 100         }
 101 }
 102
 103 static struct lu_device_operations ls_lu_dev_ops = {
 104         .ldo_object_alloc =     ls_object_alloc
 105 };
 106
 107 static struct ls_device *__ls_find_dev(struct dt_device *dev)
 108 {
 109         struct ls_device *ls, *ret = NULL;
 110
 111         list_for_each_entry(ls, &ls_list_head, ls_linkage) {
 112                 if (ls->ls_osd == dev) {
 113                         atomic_inc(&ls->ls_refcount);
 114                         ret = ls;
 115                         break;
 116                 }
 117         }
 118         return ret;
 119 }
 120
 121 struct ls_device *ls_find_dev(struct dt_device *dev)
 122 {
 123         struct ls_device *ls;
 124
 125         mutex_lock(&ls_list_mutex);
 126         ls = __ls_find_dev(dev);
 127         mutex_unlock(&ls_list_mutex);
 128
 129         return ls;
 130 }
 131
 132 static struct lu_device_type_operations ls_device_type_ops = {
 133         .ldto_start = NULL,
 134         .ldto_stop  = NULL,
 135 };
 136
 137 static struct lu_device_type ls_lu_type = {
 138         .ldt_name = "local_storage",
 139         .ldt_ops  = &ls_device_type_ops,
 140 };
 141
 142 struct ls_device *ls_device_get(struct dt_device *dev)
 143 {
 144         struct ls_device *ls;
 145
 146         ENTRY;
 147
 148         mutex_lock(&ls_list_mutex);
 149         ls = __ls_find_dev(dev);
 150         if (ls)
 151                 GOTO(out_ls, ls);
 152
 153         /* not found, then create */
 154         OBD_ALLOC_PTR(ls);
 155         if (ls == NULL)
 156                 GOTO(out_ls, ls = ERR_PTR(-ENOMEM));
 157
 158         atomic_set(&ls->ls_refcount, 1);
 159         INIT_LIST_HEAD(&ls->ls_los_list);
 160         mutex_init(&ls->ls_los_mutex);
 161
 162         ls->ls_osd = dev;
 163
 164         LASSERT(dev->dd_lu_dev.ld_site);
 165         lu_device_init(&ls->ls_top_dev.dd_lu_dev, &ls_lu_type);
 166         ls->ls_top_dev.dd_lu_dev.ld_ops = &ls_lu_dev_ops;
 167         ls->ls_top_dev.dd_lu_dev.ld_site = dev->dd_lu_dev.ld_site;
 168
 169         /* finally add ls to the list */
 170         list_add(&ls->ls_linkage, &ls_list_head);
 171 out_ls:
 172         mutex_unlock(&ls_list_mutex);
 173         RETURN(ls);
 174 }
 175
 176 void ls_device_put(const struct lu_env *env, struct ls_device *ls)
 177 {
 178         LASSERT(env);
 179         if (!atomic_dec_and_test(&ls->ls_refcount))
 180                 return;
 181
 182         mutex_lock(&ls_list_mutex);
 183         if (atomic_read(&ls->ls_refcount) == 0) {
 184                 LASSERT(list_empty(&ls->ls_los_list));
 185                 list_del(&ls->ls_linkage);
 186                 lu_site_purge(env, ls->ls_top_dev.dd_lu_dev.ld_site, ~0);
 187                 lu_device_fini(&ls->ls_top_dev.dd_lu_dev);
 188                 OBD_FREE_PTR(ls);
 189         }
 190         mutex_unlock(&ls_list_mutex);
 191 }
 192
 193 /**
 194  * local file fid generation
 195  */
 196 int local_object_fid_generate(const struct lu_env *env,
 197                               struct local_oid_storage *los,
 198                               struct lu_fid *fid)
 199 {
 200         LASSERT(los->los_dev);
 201         LASSERT(los->los_obj);
 202
 203         /* take next OID */
 204
 205         /* to make it unique after reboot we store
 206          * the latest generated fid atomically with
 207          * object creation see local_object_create() */
 208
 209         mutex_lock(&los->los_id_lock);
 210         fid->f_seq = los->los_seq;
 211         fid->f_oid = ++los->los_last_oid;
 212         fid->f_ver = 0;
 213         mutex_unlock(&los->los_id_lock);
 214
 215         return 0;
 216 }
 217
 218 int local_object_declare_create(const struct lu_env *env,
 219                                 struct local_oid_storage *los,
 220                                 struct dt_object *o, struct lu_attr *attr,
 221                                 struct dt_object_format *dof,
 222                                 struct thandle *th)
 223 {
 224         struct dt_thread_info   *dti = dt_info(env);
 225         int                      rc;
 226
 227         ENTRY;
 228
 229         /* update fid generation file */
 230         if (los != NULL) {
 231                 LASSERT(dt_object_exists(los->los_obj));
 232                 dti->dti_lb.lb_buf = NULL;
 233                 dti->dti_lb.lb_len = sizeof(struct los_ondisk);
 234                 rc = dt_declare_record_write(env, los->los_obj,
 235                                              &dti->dti_lb, 0, th);
 236                 if (rc)
 237                         RETURN(rc);
 238         }
 239
 240         rc = dt_declare_create(env, o, attr, NULL, dof, th);
 241         if (rc)
 242                 RETURN(rc);
 243
 244         dti->dti_lb.lb_buf = NULL;
 245         dti->dti_lb.lb_len = sizeof(dti->dti_lma);
 246         rc = dt_declare_xattr_set(env, o, &dti->dti_lb, XATTR_NAME_LMA, 0, th);
 247
 248         RETURN(rc);
 249 }
 250
 251 int local_object_create(const struct lu_env *env,
 252                         struct local_oid_storage *los,
 253                         struct dt_object *o, struct lu_attr *attr,
 254                         struct dt_object_format *dof, struct thandle *th)
 255 {
 256         struct dt_thread_info   *dti = dt_info(env);
 257         u64                      lastid;
 258         int                      rc;
 259
 260         ENTRY;
 261
 262         rc = dt_create(env, o, attr, NULL, dof, th);
 263         if (rc)
 264                 RETURN(rc);
 265
 266         if (los == NULL)
 267                 RETURN(rc);
 268
 269         LASSERT(los->los_obj);
 270         LASSERT(dt_object_exists(los->los_obj));
 271
 272         /* many threads can be updated this, serialize
 273          * them here to avoid the race where one thread
 274          * takes the value first, but writes it last */
 275         mutex_lock(&los->los_id_lock);
 276
 277         /* update local oid number on disk so that
 278          * we know the last one used after reboot */
 279         lastid = cpu_to_le64(los->los_last_oid);
 280
 281         dti->dti_off = 0;
 282         dti->dti_lb.lb_buf = &lastid;
 283         dti->dti_lb.lb_len = sizeof(lastid);
 284         rc = dt_record_write(env, los->los_obj, &dti->dti_lb, &dti->dti_off,
 285                              th);
 286         mutex_unlock(&los->los_id_lock);
 287
 288         RETURN(rc);
 289 }
 290
 291 /*
 292  * Create local named object (file, directory or index) in parent directory.
 293  */
 294 static struct dt_object *__local_file_create(const struct lu_env *env,
 295                                              const struct lu_fid *fid,
 296                                              struct local_oid_storage *los,
 297                                              struct ls_device *ls,
 298                                              struct dt_object *parent,
 299                                              const char *name,
 300                                              struct lu_attr *attr,
 301                                              struct dt_object_format *dof)
 302 {
 303         struct dt_thread_info   *dti    = dt_info(env);
 304         struct lu_object_conf   *conf   = &dti->dti_conf;
 305         struct dt_insert_rec    *rec    = &dti->dti_dt_rec;
 306         struct dt_object        *dto;
 307         struct thandle          *th;
 308         int                      rc;
 309
 310         /* We know that the target object does not exist, to be created,
 311          * then give some hints - LOC_F_NEW to help low layer to handle
 312          * that efficiently and properly. */
 313         memset(conf, 0, sizeof(*conf));
 314         conf->loc_flags = LOC_F_NEW;
 315         dto = ls_locate(env, ls, fid, conf);
 316         if (unlikely(IS_ERR(dto)))
 317                 RETURN(dto);
 318
 319         LASSERT(dto != NULL);
 320         if (dt_object_exists(dto))
 321                 GOTO(out, rc = -EEXIST);
 322
 323         th = dt_trans_create(env, ls->ls_osd);
 324         if (IS_ERR(th))
 325                 GOTO(out, rc = PTR_ERR(th));
 326
 327         rc = local_object_declare_create(env, los, dto, attr, dof, th);
 328         if (rc)
 329                 GOTO(trans_stop, rc);
 330
 331         if (dti->dti_dof.dof_type == DFT_DIR) {
 332                 rc = dt_declare_ref_add(env, dto, th);
 333                 if (rc < 0)
 334                         GOTO(trans_stop, rc);
 335
 336                 rc = dt_declare_ref_add(env, parent, th);
 337                 if (rc < 0)
 338                         GOTO(trans_stop, rc);
 339         }
 340
 341         rec->rec_fid = fid;
 342         rec->rec_type = dto->do_lu.lo_header->loh_attr;
 343         rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
 344                                (const struct dt_key *)name, th);
 345         if (rc)
 346                 GOTO(trans_stop, rc);
 347
 348         if (dti->dti_dof.dof_type == DFT_DIR) {
 349                 if (!dt_try_as_dir(env, dto))
 350                         GOTO(trans_stop, rc = -ENOTDIR);
 351
 352                 rc = dt_declare_insert(env, dto, (const struct dt_rec *)rec,
 353                                 (const struct dt_key *)".", th);
 354                 if (rc != 0)
 355                         GOTO(trans_stop, rc);
 356
 357                 rc = dt_declare_insert(env, dto, (const struct dt_rec *)rec,
 358                                 (const struct dt_key *)"..", th);
 359                 if (rc != 0)
 360                         GOTO(trans_stop, rc);
 361
 362                 rc = dt_declare_ref_add(env, dto, th);
 363                 if (rc != 0)
 364                         GOTO(trans_stop, rc);
 365         }
 366
 367         rc = dt_trans_start_local(env, ls->ls_osd, th);
 368         if (rc)
 369                 GOTO(trans_stop, rc);
 370
 371         dt_write_lock(env, dto, 0);
 372         if (dt_object_exists(dto))
 373                 GOTO(unlock, rc = 0);
 374
 375         CDEBUG(D_OTHER, "create new object "DFID"\n",
 376                PFID(lu_object_fid(&dto->do_lu)));
 377         rc = local_object_create(env, los, dto, attr, dof, th);
 378         if (rc)
 379                 GOTO(unlock, rc);
 380         LASSERT(dt_object_exists(dto));
 381
 382         if (dti->dti_dof.dof_type == DFT_DIR) {
 383
 384                 rec->rec_type = S_IFDIR;
 385                 rec->rec_fid = fid;
 386                 /* Add "." and ".." for newly created dir */
 387                 rc = dt_insert(env, dto, (const struct dt_rec *)rec,
 388                                (const struct dt_key *)".", th, 1);
 389                 if (rc != 0)
 390                         GOTO(destroy, rc);
 391
 392                 dt_ref_add(env, dto, th);
 393                 rec->rec_fid = lu_object_fid(&parent->do_lu);
 394                 rc = dt_insert(env, dto, (const struct dt_rec *)rec,
 395                                (const struct dt_key *)"..", th, 1);
 396                 if (rc != 0)
 397                         GOTO(destroy, rc);
 398         }
 399
 400         rec->rec_fid = fid;
 401         rec->rec_type = dto->do_lu.lo_header->loh_attr;
 402         dt_write_lock(env, parent, 0);
 403         rc = dt_insert(env, parent, (const struct dt_rec *)rec,
 404                        (const struct dt_key *)name, th, 1);
 405         if (dti->dti_dof.dof_type == DFT_DIR)
 406                 dt_ref_add(env, parent, th);
 407         dt_write_unlock(env, parent);
 408         if (rc)
 409                 GOTO(destroy, rc);
 410 destroy:
 411         if (rc)
 412                 dt_destroy(env, dto, th);
 413 unlock:
 414         dt_write_unlock(env, dto);
 415 trans_stop:
 416         dt_trans_stop(env, ls->ls_osd, th);
 417 out:
 418         if (rc) {
 419                 lu_object_put_nocache(env, &dto->do_lu);
 420                 dto = ERR_PTR(rc);
 421         }
 422         RETURN(dto);
 423 }
 424
 425 /*
 426  * Look up and create (if it does not exist) a local named file or directory in
 427  * parent directory.
 428  */
 429 struct dt_object *local_file_find_or_create(const struct lu_env *env,
 430                                             struct local_oid_storage *los,
 431                                             struct dt_object *parent,
 432                                             const char *name, __u32 mode)
 433 {
 434         struct dt_thread_info   *dti = dt_info(env);
 435         struct dt_object        *dto;
 436         int                      rc;
 437
 438         LASSERT(parent);
 439
 440         rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
 441         if (rc == 0)
 442                 /* name is found, get the object */
 443                 dto = ls_locate(env, dt2ls_dev(los->los_dev),
 444                                 &dti->dti_fid, NULL);
 445         else if (rc != -ENOENT)
 446                 dto = ERR_PTR(rc);
 447         else {
 448                 rc = local_object_fid_generate(env, los, &dti->dti_fid);
 449                 if (rc < 0) {
 450                         dto = ERR_PTR(rc);
 451                 } else {
 452                         /* create the object */
 453                         dti->dti_attr.la_valid  = LA_MODE;
 454                         dti->dti_attr.la_mode   = mode;
 455                         dti->dti_dof.dof_type   = dt_mode_to_dft(mode & S_IFMT);
 456                         dto = __local_file_create(env, &dti->dti_fid, los,
 457                                                   dt2ls_dev(los->los_dev),
 458                                                   parent, name, &dti->dti_attr,
 459                                                   &dti->dti_dof);
 460                 }
 461         }
 462         return dto;
 463 }
 464 EXPORT_SYMBOL(local_file_find_or_create);
 465
 466 struct dt_object *local_file_find_or_create_with_fid(const struct lu_env *env,
 467                                                      struct dt_device *dt,
 468                                                      const struct lu_fid *fid,
 469                                                      struct dt_object *parent,
 470                                                      const char *name,
 471                                                      __u32 mode)
 472 {
 473         struct dt_thread_info   *dti = dt_info(env);
 474         struct dt_object        *dto;
 475         int                      rc;
 476
 477         LASSERT(parent);
 478
 479         rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
 480         if (rc == 0) {
 481                 dto = dt_locate(env, dt, &dti->dti_fid);
 482         } else if (rc != -ENOENT) {
 483                 dto = ERR_PTR(rc);
 484         } else {
 485                 struct ls_device *ls;
 486
 487                 ls = ls_device_get(dt);
 488                 if (IS_ERR(ls)) {
 489                         dto = ERR_PTR(PTR_ERR(ls));
 490                 } else {
 491                         /* create the object */
 492                         dti->dti_attr.la_valid  = LA_MODE;
 493                         dti->dti_attr.la_mode   = mode;
 494                         dti->dti_dof.dof_type   = dt_mode_to_dft(mode & S_IFMT);
 495                         dto = __local_file_create(env, fid, NULL, ls, parent,
 496                                                   name, &dti->dti_attr,
 497                                                   &dti->dti_dof);
 498                         /* ls_device_put() will finalize the ls device, we
 499                          * have to open the object in other device stack */
 500                         if (!IS_ERR(dto)) {
 501                                 dti->dti_fid = dto->do_lu.lo_header->loh_fid;
 502                                 lu_object_put_nocache(env, &dto->do_lu);
 503                                 dto = dt_locate(env, dt, &dti->dti_fid);
 504                         }
 505                         ls_device_put(env, ls);
 506                 }
 507         }
 508         return dto;
 509 }
 510 EXPORT_SYMBOL(local_file_find_or_create_with_fid);
 511
 512 /*
 513  * Look up and create (if it does not exist) a local named index file in parent
 514  * directory.
 515  */
 516 struct dt_object *local_index_find_or_create(const struct lu_env *env,
 517                                              struct local_oid_storage *los,
 518                                              struct dt_object *parent,
 519                                              const char *name, __u32 mode,
 520                                              const struct dt_index_features *ft)
 521 {
 522         struct dt_thread_info   *dti = dt_info(env);
 523         struct dt_object        *dto;
 524         int                      rc;
 525
 526         LASSERT(parent);
 527
 528         rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
 529         if (rc == 0) {
 530                 /* name is found, get the object */
 531                 dto = ls_locate(env, dt2ls_dev(los->los_dev),
 532                                 &dti->dti_fid, NULL);
 533         } else if (rc != -ENOENT) {
 534                 dto = ERR_PTR(rc);
 535         } else {
 536                 rc = local_object_fid_generate(env, los, &dti->dti_fid);
 537                 if (rc < 0) {
 538                         dto = ERR_PTR(rc);
 539                 } else {
 540                         /* create the object */
 541                         dti->dti_attr.la_valid          = LA_MODE;
 542                         dti->dti_attr.la_mode           = mode;
 543                         dti->dti_dof.dof_type           = DFT_INDEX;
 544                         dti->dti_dof.u.dof_idx.di_feat  = ft;
 545                         dto = __local_file_create(env, &dti->dti_fid, los,
 546                                                   dt2ls_dev(los->los_dev),
 547                                                   parent, name, &dti->dti_attr,
 548                                                   &dti->dti_dof);
 549                 }
 550         }
 551         return dto;
 552
 553 }
 554 EXPORT_SYMBOL(local_index_find_or_create);
 555
 556 struct dt_object *
 557 local_index_find_or_create_with_fid(const struct lu_env *env,
 558                                     struct dt_device *dt,
 559                                     const struct lu_fid *fid,
 560                                     struct dt_object *parent,
 561                                     const char *name, __u32 mode,
 562                                     const struct dt_index_features *ft)
 563 {
 564         struct dt_thread_info   *dti = dt_info(env);
 565         struct dt_object        *dto;
 566         int                      rc;
 567
 568         LASSERT(parent);
 569
 570         rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
 571         if (rc == 0) {
 572                 /* name is found, get the object */
 573                 if (!lu_fid_eq(fid, &dti->dti_fid))
 574                         dto = ERR_PTR(-EINVAL);
 575                 else
 576                         dto = dt_locate(env, dt, fid);
 577         } else if (rc != -ENOENT) {
 578                 dto = ERR_PTR(rc);
 579         } else {
 580                 struct ls_device *ls;
 581
 582                 ls = ls_device_get(dt);
 583                 if (IS_ERR(ls)) {
 584                         dto = ERR_PTR(PTR_ERR(ls));
 585                 } else {
 586                         /* create the object */
 587                         dti->dti_attr.la_valid          = LA_MODE;
 588                         dti->dti_attr.la_mode           = mode;
 589                         dti->dti_dof.dof_type           = DFT_INDEX;
 590                         dti->dti_dof.u.dof_idx.di_feat  = ft;
 591                         dto = __local_file_create(env, fid, NULL, ls, parent,
 592                                                   name, &dti->dti_attr,
 593                                                   &dti->dti_dof);
 594                         /* ls_device_put() will finalize the ls device, we
 595                          * have to open the object in other device stack */
 596                         if (!IS_ERR(dto)) {
 597                                 dti->dti_fid = dto->do_lu.lo_header->loh_fid;
 598                                 lu_object_put_nocache(env, &dto->do_lu);
 599                                 dto = dt_locate(env, dt, &dti->dti_fid);
 600                         }
 601                         ls_device_put(env, ls);
 602                 }
 603         }
 604         return dto;
 605 }
 606 EXPORT_SYMBOL(local_index_find_or_create_with_fid);
 607
 608 static int local_object_declare_unlink(const struct lu_env *env,
 609                                        struct dt_device *dt,
 610                                        struct dt_object *p,
 611                                        struct dt_object *c, const char *name,
 612                                        struct thandle *th)
 613 {
 614         int rc;
 615
 616         rc = dt_declare_delete(env, p, (const struct dt_key *)name, th);
 617         if (rc < 0)
 618                 return rc;
 619
 620         rc = dt_declare_ref_del(env, c, th);
 621         if (rc < 0)
 622                 return rc;
 623
 624         return dt_declare_destroy(env, c, th);
 625 }
 626
 627 int local_object_unlink(const struct lu_env *env, struct dt_device *dt,
 628                         struct dt_object *parent, const char *name)
 629 {
 630         struct dt_thread_info   *dti = dt_info(env);
 631         struct dt_object        *dto;
 632         struct thandle          *th;
 633         int                      rc;
 634
 635         ENTRY;
 636
 637         rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
 638         if (rc == -ENOENT)
 639                 RETURN(0);
 640         else if (rc < 0)
 641                 RETURN(rc);
 642
 643         dto = dt_locate(env, dt, &dti->dti_fid);
 644         if (unlikely(IS_ERR(dto)))
 645                 RETURN(PTR_ERR(dto));
 646
 647         th = dt_trans_create(env, dt);
 648         if (IS_ERR(th))
 649                 GOTO(out, rc = PTR_ERR(th));
 650
 651         rc = local_object_declare_unlink(env, dt, parent, dto, name, th);
 652         if (rc < 0)
 653                 GOTO(stop, rc);
 654
 655         rc = dt_trans_start_local(env, dt, th);
 656         if (rc < 0)
 657                 GOTO(stop, rc);
 658
 659         dt_write_lock(env, dto, 0);
 660         rc = dt_delete(env, parent, (struct dt_key *)name, th);
 661         if (rc < 0)
 662                 GOTO(unlock, rc);
 663
 664         rc = dt_ref_del(env, dto, th);
 665         if (rc < 0) {
 666                 struct dt_insert_rec *rec = &dti->dti_dt_rec;
 667
 668                 rec->rec_fid = &dti->dti_fid;
 669                 rec->rec_type = dto->do_lu.lo_header->loh_attr;
 670                 rc = dt_insert(env, parent, (const struct dt_rec *)rec,
 671                                (const struct dt_key *)name, th, 1);
 672                 GOTO(unlock, rc);
 673         }
 674
 675         rc = dt_destroy(env, dto, th);
 676 unlock:
 677         dt_write_unlock(env, dto);
 678 stop:
 679         dt_trans_stop(env, dt, th);
 680 out:
 681         lu_object_put_nocache(env, &dto->do_lu);
 682         return rc;
 683 }
 684 EXPORT_SYMBOL(local_object_unlink);
 685
 686 struct local_oid_storage *dt_los_find(struct ls_device *ls, __u64 seq)
 687 {
 688         struct local_oid_storage *los, *ret = NULL;
 689
 690         list_for_each_entry(los, &ls->ls_los_list, los_list) {
 691                 if (los->los_seq == seq) {
 692                         atomic_inc(&los->los_refcount);
 693                         ret = los;
 694                         break;
 695                 }
 696         }
 697         return ret;
 698 }
 699
 700 void dt_los_put(struct local_oid_storage *los)
 701 {
 702         if (atomic_dec_and_test(&los->los_refcount))
 703                 /* should never happen, only local_oid_storage_fini should
 704                  * drop refcount to zero */
 705                 LBUG();
 706         return;
 707 }
 708
 709 /* after Lustre 2.3 release there may be old file to store last generated FID
 710  * If such file exists then we have to read its content
 711  */
 712 static int lastid_compat_check(const struct lu_env *env, struct dt_device *dev,
 713                                __u64 lastid_seq, __u32 *first_oid,
 714                                struct ls_device *ls)
 715 {
 716         struct dt_thread_info   *dti = dt_info(env);
 717         struct dt_object        *root = NULL;
 718         struct los_ondisk        losd;
 719         struct dt_object        *o = NULL;
 720         int                      rc = 0;
 721
 722         rc = dt_root_get(env, dev, &dti->dti_fid);
 723         if (rc)
 724                 return rc;
 725
 726         root = ls_locate(env, ls, &dti->dti_fid, NULL);
 727         if (IS_ERR(root))
 728                 return PTR_ERR(root);
 729
 730         /* find old last_id file */
 731         snprintf(dti->dti_buf, sizeof(dti->dti_buf), "seq-"LPX64"-lastid",
 732                  lastid_seq);
 733         rc = dt_lookup_dir(env, root, dti->dti_buf, &dti->dti_fid);
 734         lu_object_put_nocache(env, &root->do_lu);
 735         if (rc == -ENOENT) {
 736                 /* old llog lastid accessed by FID only */
 737                 if (lastid_seq != FID_SEQ_LLOG)
 738                         return 0;
 739                 dti->dti_fid.f_seq = FID_SEQ_LLOG;
 740                 dti->dti_fid.f_oid = 1;
 741                 dti->dti_fid.f_ver = 0;
 742                 o = ls_locate(env, ls, &dti->dti_fid, NULL);
 743                 if (IS_ERR(o))
 744                         return PTR_ERR(o);
 745
 746                 if (!dt_object_exists(o)) {
 747                         lu_object_put_nocache(env, &o->do_lu);
 748                         return 0;
 749                 }
 750                 CDEBUG(D_INFO, "Found old llog lastid file\n");
 751         } else if (rc < 0) {
 752                 return rc;
 753         } else {
 754                 CDEBUG(D_INFO, "Found old lastid file for sequence "LPX64"\n",
 755                        lastid_seq);
 756                 o = ls_locate(env, ls, &dti->dti_fid, NULL);
 757                 if (IS_ERR(o))
 758                         return PTR_ERR(o);
 759         }
 760         /* let's read seq-NNNNNN-lastid file value */
 761         LASSERT(dt_object_exists(o));
 762         dti->dti_off = 0;
 763         dti->dti_lb.lb_buf = &losd;
 764         dti->dti_lb.lb_len = sizeof(losd);
 765         dt_read_lock(env, o, 0);
 766         rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
 767         dt_read_unlock(env, o);
 768         if (rc == 0 && le32_to_cpu(losd.lso_magic) != LOS_MAGIC) {
 769                 CERROR("%s: wrong content of seq-"LPX64"-lastid file, magic %x\n",
 770                        o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq,
 771                        le32_to_cpu(losd.lso_magic));
 772                 rc = -EINVAL;
 773         } else if (rc < 0) {
 774                 CERROR("%s: failed to read seq-"LPX64"-lastid: rc = %d\n",
 775                        o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq, rc);
 776         }
 777         lu_object_put_nocache(env, &o->do_lu);
 778         if (rc == 0)
 779                 *first_oid = le32_to_cpu(losd.lso_next_oid);
 780         return rc;
 781 }
 782
 783 /**
 784  * Initialize local OID storage for required sequence.
 785  * That may be needed for services that uses local files and requires
 786  * dynamic OID allocation for them.
 787  *
 788  * Per each sequence we have an object with 'first_fid' identificator
 789  * containing the counter for OIDs of locally created files with that
 790  * sequence.
 791  *
 792  * It is used now by llog subsystem and MGS for NID tables
 793  *
 794  * Function gets first_fid to create counter object.
 795  * All dynamic fids will be generated with the same sequence and incremented
 796  * OIDs
 797  *
 798  * Returned local_oid_storage is in-memory representaion of OID storage
 799  */
 800 int local_oid_storage_init(const struct lu_env *env, struct dt_device *dev,
 801                            const struct lu_fid *first_fid,
 802                            struct local_oid_storage **los)
 803 {
 804         struct dt_thread_info   *dti = dt_info(env);
 805         struct ls_device        *ls;
 806         u64                      lastid;
 807         struct dt_object        *o = NULL;
 808         struct thandle          *th;
 809         __u32                    first_oid = fid_oid(first_fid);
 810         int                      rc = 0;
 811
 812         ENTRY;
 813
 814         ls = ls_device_get(dev);
 815         if (IS_ERR(ls))
 816                 RETURN(PTR_ERR(ls));
 817
 818         mutex_lock(&ls->ls_los_mutex);
 819         *los = dt_los_find(ls, fid_seq(first_fid));
 820         if (*los != NULL)
 821                 GOTO(out, rc = 0);
 822
 823         /* not found, then create */
 824         OBD_ALLOC_PTR(*los);
 825         if (*los == NULL)
 826                 GOTO(out, rc = -ENOMEM);
 827
 828         atomic_set(&(*los)->los_refcount, 1);
 829         mutex_init(&(*los)->los_id_lock);
 830         (*los)->los_dev = &ls->ls_top_dev;
 831         atomic_inc(&ls->ls_refcount);
 832         list_add(&(*los)->los_list, &ls->ls_los_list);
 833
 834         /* Use {seq, 0, 0} to create the LAST_ID file for every
 835          * sequence.  OIDs start at LUSTRE_FID_INIT_OID.
 836          */
 837         dti->dti_fid.f_seq = fid_seq(first_fid);
 838         dti->dti_fid.f_oid = LUSTRE_FID_LASTID_OID;
 839         dti->dti_fid.f_ver = 0;
 840         o = ls_locate(env, ls, &dti->dti_fid, NULL);
 841         if (IS_ERR(o))
 842                 GOTO(out_los, rc = PTR_ERR(o));
 843
 844         if (!dt_object_exists(o)) {
 845                 rc = lastid_compat_check(env, dev, fid_seq(first_fid),
 846                                          &first_oid, ls);
 847                 if (rc < 0)
 848                         GOTO(out_los, rc);
 849
 850                 th = dt_trans_create(env, dev);
 851                 if (IS_ERR(th))
 852                         GOTO(out_los, rc = PTR_ERR(th));
 853
 854                 dti->dti_attr.la_valid = LA_MODE | LA_TYPE;
 855                 dti->dti_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
 856                 dti->dti_dof.dof_type = dt_mode_to_dft(S_IFREG);
 857
 858                 rc = dt_declare_create(env, o, &dti->dti_attr, NULL,
 859                                        &dti->dti_dof, th);
 860                 if (rc)
 861                         GOTO(out_trans, rc);
 862
 863                 lastid = cpu_to_le64(first_oid);
 864
 865                 dti->dti_off = 0;
 866                 dti->dti_lb.lb_buf = &lastid;
 867                 dti->dti_lb.lb_len = sizeof(lastid);
 868                 rc = dt_declare_record_write(env, o, &dti->dti_lb, dti->dti_off,
 869                                              th);
 870                 if (rc)
 871                         GOTO(out_trans, rc);
 872
 873                 rc = dt_trans_start_local(env, dev, th);
 874                 if (rc)
 875                         GOTO(out_trans, rc);
 876
 877                 dt_write_lock(env, o, 0);
 878                 if (dt_object_exists(o))
 879                         GOTO(out_lock, rc = 0);
 880
 881                 rc = dt_create(env, o, &dti->dti_attr, NULL, &dti->dti_dof,
 882                                th);
 883                 if (rc)
 884                         GOTO(out_lock, rc);
 885
 886                 rc = dt_record_write(env, o, &dti->dti_lb, &dti->dti_off, th);
 887                 if (rc)
 888                         GOTO(out_lock, rc);
 889 out_lock:
 890                 dt_write_unlock(env, o);
 891 out_trans:
 892                 dt_trans_stop(env, dev, th);
 893         } else {
 894                 dti->dti_off = 0;
 895                 dti->dti_lb.lb_buf = &lastid;
 896                 dti->dti_lb.lb_len = sizeof(lastid);
 897                 dt_read_lock(env, o, 0);
 898                 rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
 899                 dt_read_unlock(env, o);
 900                 if (rc == 0 && le64_to_cpu(lastid) > OBIF_MAX_OID) {
 901                         CERROR("%s: bad oid "LPU64" is read from LAST_ID\n",
 902                                o->do_lu.lo_dev->ld_obd->obd_name,
 903                                le64_to_cpu(lastid));
 904                         rc = -EINVAL;
 905                 }
 906         }
 907 out_los:
 908         if (rc != 0) {
 909                 list_del(&(*los)->los_list);
 910                 atomic_dec(&ls->ls_refcount);
 911                 OBD_FREE_PTR(*los);
 912                 *los = NULL;
 913                 if (o != NULL && !IS_ERR(o))
 914                         lu_object_put_nocache(env, &o->do_lu);
 915         } else {
 916                 (*los)->los_seq = fid_seq(first_fid);
 917                 (*los)->los_last_oid = le64_to_cpu(lastid);
 918                 (*los)->los_obj = o;
 919                 /* Read value should not be less than initial one
 920                  * but possible after upgrade from older fs.
 921                  * In this case just switch to the first_oid in memory and
 922                  * it will be updated on disk with first object generated */
 923                 if ((*los)->los_last_oid < first_oid)
 924                         (*los)->los_last_oid = first_oid;
 925         }
 926 out:
 927         mutex_unlock(&ls->ls_los_mutex);
 928         ls_device_put(env, ls);
 929         return rc;
 930 }
 931 EXPORT_SYMBOL(local_oid_storage_init);
 932
 933 void local_oid_storage_fini(const struct lu_env *env,
 934                             struct local_oid_storage *los)
 935 {
 936         struct ls_device *ls;
 937
 938         LASSERT(env);
 939         LASSERT(los->los_dev);
 940         ls = dt2ls_dev(los->los_dev);
 941
 942         /* Take the mutex before decreasing the reference to avoid race
 943          * conditions as described in LU-4721. */
 944         mutex_lock(&ls->ls_los_mutex);
 945         if (!atomic_dec_and_test(&los->los_refcount)) {
 946                 mutex_unlock(&ls->ls_los_mutex);
 947                 return;
 948         }
 949
 950         if (los->los_obj)
 951                 lu_object_put_nocache(env, &los->los_obj->do_lu);
 952         list_del(&los->los_list);
 953         OBD_FREE_PTR(los);
 954         mutex_unlock(&ls->ls_los_mutex);
 955         ls_device_put(env, ls);
 956 }
 957 EXPORT_SYMBOL(local_oid_storage_fini);