4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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.
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
23 * Copyright (c) 2012, 2017, Intel Corporation.
26 * lustre/obdclass/local_storage.c
28 * Local storage for file/objects with fid generation. Works on top of OSD.
30 * Author: Mikhail Pershin <mike.pershin@intel.com>
33 #define DEBUG_SUBSYSTEM S_CLASS
35 #include "local_storage.h"
37 /* all initialized local storages on this node are linked on this */
38 static LIST_HEAD(ls_list_head);
39 static DEFINE_MUTEX(ls_list_mutex);
41 static int ls_object_init(const struct lu_env *env, struct lu_object *o,
42 const struct lu_object_conf *unused)
45 struct lu_object *below;
46 struct lu_device *under;
50 ls = container_of(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);
56 lu_object_add(o, below);
61 static void ls_object_free(const struct lu_env *env, struct lu_object *o)
63 struct ls_object *obj = lu2ls_obj(o);
64 struct lu_object_header *h = o->lo_header;
66 dt_object_fini(&obj->ls_obj);
67 lu_object_header_fini(h);
68 OBD_FREE_PRE(obj, sizeof(*obj), "kfreed");
69 kfree_rcu(obj, ls_header.loh_rcu);
72 static const struct lu_object_operations ls_lu_obj_ops = {
73 .loo_object_init = ls_object_init,
74 .loo_object_free = ls_object_free,
77 static struct lu_object *ls_object_alloc(const struct lu_env *env,
78 const struct lu_object_header *_h,
81 struct lu_object_header *h;
92 lu_object_header_init(h);
93 dt_object_init(&o->ls_obj, h, d);
94 lu_object_add_top(h, l);
96 l->lo_ops = &ls_lu_obj_ops;
104 static const struct lu_device_operations ls_lu_dev_ops = {
105 .ldo_object_alloc = ls_object_alloc
108 static const struct lu_device_type_operations ls_device_type_ops = {
113 static struct lu_device_type ls_lu_type = {
114 .ldt_name = "local_storage",
115 .ldt_ops = &ls_device_type_ops,
119 struct ls_device *ls_device_init(struct dt_device *dev)
121 struct ls_device *ls;
127 GOTO(out_ls, ls = ERR_PTR(-ENOMEM));
129 kref_init(&ls->ls_refcount);
130 INIT_LIST_HEAD(&ls->ls_los_list);
131 mutex_init(&ls->ls_los_mutex);
135 LASSERT(dev->dd_lu_dev.ld_site);
136 lu_device_init(&ls->ls_top_dev.dd_lu_dev, &ls_lu_type);
137 ls->ls_top_dev.dd_lu_dev.ld_ops = &ls_lu_dev_ops;
138 ls->ls_top_dev.dd_lu_dev.ld_site = dev->dd_lu_dev.ld_site;
140 /* finally add ls to the list */
141 list_add(&ls->ls_linkage, &ls_list_head);
146 struct ls_device *ls_device_find_or_init(struct dt_device *dev)
148 struct ls_device *ls, *ret = NULL;
152 mutex_lock(&ls_list_mutex);
154 list_for_each_entry(ls, &ls_list_head, ls_linkage) {
155 if (ls->ls_osd == dev) {
156 kref_get(&ls->ls_refcount);
165 /* not found, then create */
166 ls = ls_device_init(dev);
168 mutex_unlock(&ls_list_mutex);
172 static void ls_device_put_free(struct kref *kref)
174 struct ls_device *ls = container_of(kref, struct ls_device,
177 LASSERT(list_empty(&ls->ls_los_list));
178 list_del(&ls->ls_linkage);
179 mutex_unlock(&ls_list_mutex);
182 void ls_device_put(const struct lu_env *env, struct ls_device *ls)
185 if (kref_put_mutex(&ls->ls_refcount, ls_device_put_free,
187 lu_site_purge(env, ls->ls_top_dev.dd_lu_dev.ld_site, ~0);
188 lu_device_fini(&ls->ls_top_dev.dd_lu_dev);
194 * local file fid generation
196 int local_object_fid_generate(const struct lu_env *env,
197 struct local_oid_storage *los,
200 LASSERT(los->los_dev);
201 LASSERT(los->los_obj);
205 /* to make it unique after reboot we store
206 * the latest generated fid atomically with
207 * object creation see local_object_create() */
209 mutex_lock(&los->los_id_lock);
210 fid->f_seq = los->los_seq;
211 fid->f_oid = ++los->los_last_oid;
213 mutex_unlock(&los->los_id_lock);
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,
224 struct dt_thread_info *dti = dt_info(env);
229 /* update fid generation file */
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);
240 rc = dt_declare_create(env, o, attr, NULL, dof, th);
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);
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)
256 struct dt_thread_info *dti = dt_info(env);
262 rc = dt_create(env, o, attr, NULL, dof, th);
269 LASSERT(los->los_obj);
270 LASSERT(dt_object_exists(los->los_obj));
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);
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);
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,
286 mutex_unlock(&los->los_id_lock);
292 * Create local named object (file, directory or index) in parent directory.
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,
300 struct lu_attr *attr,
301 struct dt_object_format *dof)
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;
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)))
319 LASSERT(dto != NULL);
320 if (dt_object_exists(dto))
321 GOTO(out, rc = -EEXIST);
323 th = dt_trans_create(env, ls->ls_osd);
325 GOTO(out, rc = PTR_ERR(th));
327 rc = local_object_declare_create(env, los, dto, attr, dof, th);
329 GOTO(trans_stop, rc);
331 if (dti->dti_dof.dof_type == DFT_DIR) {
332 rc = dt_declare_ref_add(env, dto, th);
334 GOTO(trans_stop, rc);
336 rc = dt_declare_ref_add(env, parent, th);
338 GOTO(trans_stop, rc);
342 rec->rec_type = attr->la_mode & S_IFMT;
343 rc = dt_declare_insert(env, parent, (const struct dt_rec *)rec,
344 (const struct dt_key *)name, th);
346 GOTO(trans_stop, rc);
348 if (dti->dti_dof.dof_type == DFT_DIR) {
349 if (!dt_try_as_dir(env, dto, false))
350 GOTO(trans_stop, rc = -ENOTDIR);
352 rec->rec_type = S_IFDIR;
354 rc = dt_declare_insert(env, dto, (const struct dt_rec *)rec,
355 (const struct dt_key *)".", th);
357 GOTO(trans_stop, rc);
359 rec->rec_fid = lu_object_fid(&parent->do_lu);
360 rc = dt_declare_insert(env, dto, (const struct dt_rec *)rec,
361 (const struct dt_key *)"..", th);
363 GOTO(trans_stop, rc);
365 rc = dt_declare_ref_add(env, dto, th);
367 GOTO(trans_stop, rc);
370 rc = dt_trans_start_local(env, ls->ls_osd, th);
372 GOTO(trans_stop, rc);
374 dt_write_lock(env, dto, DT_SRC_CHILD);
375 if (dt_object_exists(dto))
376 GOTO(unlock, rc = 0);
378 CDEBUG(D_OTHER, "create new object "DFID"\n",
379 PFID(lu_object_fid(&dto->do_lu)));
380 rc = local_object_create(env, los, dto, attr, dof, th);
383 LASSERT(dt_object_exists(dto));
385 if (dti->dti_dof.dof_type == DFT_DIR) {
387 rec->rec_type = S_IFDIR;
389 /* Add "." and ".." for newly created dir */
390 rc = dt_insert(env, dto, (const struct dt_rec *)rec,
391 (const struct dt_key *)".", th);
395 dt_ref_add(env, dto, th);
396 rec->rec_fid = lu_object_fid(&parent->do_lu);
397 rc = dt_insert(env, dto, (const struct dt_rec *)rec,
398 (const struct dt_key *)"..", th);
404 rec->rec_type = dto->do_lu.lo_header->loh_attr;
405 dt_write_lock(env, parent, DT_SRC_PARENT);
406 rc = dt_insert(env, parent, (const struct dt_rec *)rec,
407 (const struct dt_key *)name, th);
408 if (dti->dti_dof.dof_type == DFT_DIR)
409 dt_ref_add(env, parent, th);
410 dt_write_unlock(env, parent);
415 dt_destroy(env, dto, th);
417 dt_write_unlock(env, dto);
419 dt_trans_stop(env, ls->ls_osd, th);
422 dt_object_put_nocache(env, dto);
428 struct dt_object *local_file_find(const struct lu_env *env,
429 struct local_oid_storage *los,
430 struct dt_object *parent,
433 struct dt_thread_info *dti = dt_info(env);
434 struct dt_object *dto;
439 rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
441 dto = ls_locate(env, dt2ls_dev(los->los_dev),
442 &dti->dti_fid, NULL);
448 EXPORT_SYMBOL(local_file_find);
451 * Look up and create (if it does not exist) a local named file or directory in
454 struct dt_object *local_file_find_or_create(const struct lu_env *env,
455 struct local_oid_storage *los,
456 struct dt_object *parent,
457 const char *name, __u32 mode)
459 struct dt_thread_info *dti = dt_info(env);
460 struct dt_object *dto;
463 dto = local_file_find(env, los, parent, name);
464 if (!IS_ERR(dto) || PTR_ERR(dto) != -ENOENT)
467 rc = local_object_fid_generate(env, los, &dti->dti_fid);
471 /* create the object */
472 dti->dti_attr.la_valid = LA_MODE;
473 dti->dti_attr.la_mode = mode;
474 dti->dti_dof.dof_type = dt_mode_to_dft(mode & S_IFMT);
475 dto = __local_file_create(env, &dti->dti_fid, los,
476 dt2ls_dev(los->los_dev), parent, name,
477 &dti->dti_attr, &dti->dti_dof);
480 EXPORT_SYMBOL(local_file_find_or_create);
482 struct dt_object *local_file_find_or_create_with_fid(const struct lu_env *env,
483 struct dt_device *dt,
484 const struct lu_fid *fid,
485 struct dt_object *parent,
489 struct dt_thread_info *dti = dt_info(env);
490 struct dt_object *dto;
495 rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
497 dto = dt_locate(env, dt, &dti->dti_fid);
498 } else if (rc != -ENOENT) {
501 struct ls_device *ls;
503 ls = ls_device_find_or_init(dt);
507 /* create the object */
508 dti->dti_attr.la_valid = LA_MODE;
509 dti->dti_attr.la_mode = mode;
510 dti->dti_dof.dof_type = dt_mode_to_dft(mode & S_IFMT);
511 dto = __local_file_create(env, fid, NULL, ls, parent,
512 name, &dti->dti_attr,
514 /* ls_device_put() will finalize the ls device, we
515 * have to open the object in other device stack */
517 dti->dti_fid = dto->do_lu.lo_header->loh_fid;
518 dt_object_put_nocache(env, dto);
519 dto = dt_locate(env, dt, &dti->dti_fid);
521 ls_device_put(env, ls);
526 EXPORT_SYMBOL(local_file_find_or_create_with_fid);
529 * Look up and create (if it does not exist) a local named index file in parent
532 struct dt_object *local_index_find_or_create(const struct lu_env *env,
533 struct local_oid_storage *los,
534 struct dt_object *parent,
535 const char *name, __u32 mode,
536 const struct dt_index_features *ft)
538 struct dt_thread_info *dti = dt_info(env);
539 struct dt_object *dto;
544 rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
546 /* name is found, get the object */
547 dto = ls_locate(env, dt2ls_dev(los->los_dev),
548 &dti->dti_fid, NULL);
549 } else if (rc != -ENOENT) {
552 rc = local_object_fid_generate(env, los, &dti->dti_fid);
556 /* create the object */
557 dti->dti_attr.la_valid = LA_MODE;
558 dti->dti_attr.la_mode = mode;
559 dti->dti_dof.dof_type = DFT_INDEX;
560 dti->dti_dof.u.dof_idx.di_feat = ft;
561 dto = __local_file_create(env, &dti->dti_fid, los,
562 dt2ls_dev(los->los_dev),
563 parent, name, &dti->dti_attr,
570 EXPORT_SYMBOL(local_index_find_or_create);
573 local_index_find_or_create_with_fid(const struct lu_env *env,
574 struct dt_device *dt,
575 const struct lu_fid *fid,
576 struct dt_object *parent,
577 const char *name, __u32 mode,
578 const struct dt_index_features *ft)
580 struct dt_thread_info *dti = dt_info(env);
581 struct dt_object *dto;
586 rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
588 /* name is found, get the object */
589 if (!lu_fid_eq(fid, &dti->dti_fid))
590 dto = ERR_PTR(-EINVAL);
592 dto = dt_locate(env, dt, fid);
593 } else if (rc != -ENOENT) {
596 struct ls_device *ls;
598 ls = ls_device_find_or_init(dt);
602 /* create the object */
603 dti->dti_attr.la_valid = LA_MODE;
604 dti->dti_attr.la_mode = mode;
605 dti->dti_dof.dof_type = DFT_INDEX;
606 dti->dti_dof.u.dof_idx.di_feat = ft;
607 dto = __local_file_create(env, fid, NULL, ls, parent,
608 name, &dti->dti_attr,
610 /* ls_device_put() will finalize the ls device, we
611 * have to open the object in other device stack */
613 dti->dti_fid = dto->do_lu.lo_header->loh_fid;
614 dt_object_put_nocache(env, dto);
615 dto = dt_locate(env, dt, &dti->dti_fid);
617 ls_device_put(env, ls);
622 EXPORT_SYMBOL(local_index_find_or_create_with_fid);
624 static int local_object_declare_unlink(const struct lu_env *env,
625 struct dt_device *dt,
627 struct dt_object *c, const char *name,
632 rc = dt_declare_delete(env, p, (const struct dt_key *)name, th);
636 if (S_ISDIR(p->do_lu.lo_header->loh_attr)) {
637 rc = dt_declare_ref_del(env, p, th);
642 rc = dt_declare_ref_del(env, c, th);
646 return dt_declare_destroy(env, c, th);
649 int local_object_unlink(const struct lu_env *env, struct dt_device *dt,
650 struct dt_object *parent, const char *name)
652 struct dt_thread_info *dti = dt_info(env);
653 struct dt_object *dto;
659 rc = dt_lookup_dir(env, parent, name, &dti->dti_fid);
665 dto = dt_locate(env, dt, &dti->dti_fid);
666 if (unlikely(IS_ERR(dto)))
667 RETURN(PTR_ERR(dto));
669 th = dt_trans_create(env, dt);
671 GOTO(out, rc = PTR_ERR(th));
673 rc = local_object_declare_unlink(env, dt, parent, dto, name, th);
677 rc = dt_trans_start_local(env, dt, th);
681 if (S_ISDIR(dto->do_lu.lo_header->loh_attr)) {
682 dt_write_lock(env, parent, 0);
683 rc = dt_ref_del(env, parent, th);
684 dt_write_unlock(env, parent);
689 dt_write_lock(env, dto, 0);
690 rc = dt_delete(env, parent, (struct dt_key *)name, th);
694 rc = dt_ref_del(env, dto, th);
696 struct dt_insert_rec *rec = &dti->dti_dt_rec;
698 rec->rec_fid = &dti->dti_fid;
699 rec->rec_type = dto->do_lu.lo_header->loh_attr;
700 rc = dt_insert(env, parent, (const struct dt_rec *)rec,
701 (const struct dt_key *)name, th);
705 rc = dt_destroy(env, dto, th);
707 dt_write_unlock(env, dto);
709 dt_trans_stop(env, dt, th);
711 dt_object_put_nocache(env, dto);
714 EXPORT_SYMBOL(local_object_unlink);
716 struct local_oid_storage *dt_los_find(struct ls_device *ls, __u64 seq)
718 struct local_oid_storage *los, *ret = NULL;
720 list_for_each_entry(los, &ls->ls_los_list, los_list) {
721 if (los->los_seq == seq) {
722 atomic_inc(&los->los_refcount);
730 void dt_los_put(struct local_oid_storage *los)
732 if (atomic_dec_and_test(&los->los_refcount))
733 /* should never happen, only local_oid_storage_fini should
734 * drop refcount to zero */
738 /* after Lustre 2.3 release there may be old file to store last generated FID
739 * If such file exists then we have to read its content
741 static int lastid_compat_check(const struct lu_env *env, struct dt_device *dev,
742 __u64 lastid_seq, __u32 *first_oid,
743 struct ls_device *ls)
745 struct dt_thread_info *dti = dt_info(env);
746 struct dt_object *root = NULL;
747 struct los_ondisk losd;
748 struct dt_object *o = NULL;
751 rc = dt_root_get(env, dev, &dti->dti_fid);
755 root = ls_locate(env, ls, &dti->dti_fid, NULL);
757 return PTR_ERR(root);
759 /* find old last_id file */
760 snprintf(dti->dti_buf, sizeof(dti->dti_buf), "seq-%#llx-lastid",
762 rc = dt_lookup_dir(env, root, dti->dti_buf, &dti->dti_fid);
763 dt_object_put_nocache(env, root);
765 /* old llog lastid accessed by FID only */
766 if (lastid_seq != FID_SEQ_LLOG)
768 dti->dti_fid.f_seq = FID_SEQ_LLOG;
769 dti->dti_fid.f_oid = 1;
770 dti->dti_fid.f_ver = 0;
771 o = ls_locate(env, ls, &dti->dti_fid, NULL);
775 if (!dt_object_exists(o)) {
776 dt_object_put_nocache(env, o);
779 CDEBUG(D_INFO, "Found old llog lastid file\n");
783 CDEBUG(D_INFO, "Found old lastid file for sequence %#llx\n",
785 o = ls_locate(env, ls, &dti->dti_fid, NULL);
789 /* let's read seq-NNNNNN-lastid file value */
790 LASSERT(dt_object_exists(o));
792 dti->dti_lb.lb_buf = &losd;
793 dti->dti_lb.lb_len = sizeof(losd);
794 dt_read_lock(env, o, 0);
795 rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
796 dt_read_unlock(env, o);
797 if (rc == 0 && le32_to_cpu(losd.lso_magic) != LOS_MAGIC) {
798 CERROR("%s: wrong content of seq-%#llx-lastid file, magic %x\n",
799 o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq,
800 le32_to_cpu(losd.lso_magic));
803 CERROR("%s: failed to read seq-%#llx-lastid: rc = %d\n",
804 o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq, rc);
806 dt_object_put_nocache(env, o);
808 *first_oid = le32_to_cpu(losd.lso_next_oid);
814 * Initialize local OID storage for required sequence.
815 * That may be needed for services that uses local files and requires
816 * dynamic OID allocation for them.
818 * Per each sequence we have an object with 'first_fid' identificator
819 * containing the counter for OIDs of locally created files with that
822 * It is used now by llog subsystem and MGS for NID tables
824 * Function gets first_fid to create counter object.
825 * All dynamic fids will be generated with the same sequence and incremented
828 * Returned local_oid_storage is in-memory representaion of OID storage
830 int local_oid_storage_init(const struct lu_env *env, struct dt_device *dev,
831 const struct lu_fid *first_fid,
832 struct local_oid_storage **los)
834 struct dt_thread_info *dti = dt_info(env);
835 struct ls_device *ls;
837 struct dt_object *o = NULL;
839 __u32 first_oid = fid_oid(first_fid);
844 ls = ls_device_find_or_init(dev);
848 mutex_lock(&ls->ls_los_mutex);
849 *los = dt_los_find(ls, fid_seq(first_fid));
853 /* not found, then create */
856 GOTO(out, rc = -ENOMEM);
858 atomic_set(&(*los)->los_refcount, 1);
859 mutex_init(&(*los)->los_id_lock);
860 (*los)->los_dev = &ls->ls_top_dev;
861 kref_get(&ls->ls_refcount);
862 list_add(&(*los)->los_list, &ls->ls_los_list);
864 /* Use {seq, 0, 0} to create the LAST_ID file for every
865 * sequence. OIDs start at LUSTRE_FID_INIT_OID.
867 dti->dti_fid.f_seq = fid_seq(first_fid);
868 dti->dti_fid.f_oid = LUSTRE_FID_LASTID_OID;
869 dti->dti_fid.f_ver = 0;
870 o = ls_locate(env, ls, &dti->dti_fid, NULL);
872 GOTO(out_los, rc = PTR_ERR(o));
874 if (!dt_object_exists(o)) {
875 rc = lastid_compat_check(env, dev, fid_seq(first_fid),
880 th = dt_trans_create(env, dev);
882 GOTO(out_los, rc = PTR_ERR(th));
884 dti->dti_attr.la_valid = LA_MODE | LA_TYPE;
885 dti->dti_attr.la_mode = S_IFREG | S_IRUGO | S_IWUSR;
886 dti->dti_dof.dof_type = dt_mode_to_dft(S_IFREG);
888 rc = dt_declare_create(env, o, &dti->dti_attr, NULL,
893 lastid = cpu_to_le64(first_oid);
896 dti->dti_lb.lb_buf = &lastid;
897 dti->dti_lb.lb_len = sizeof(lastid);
898 rc = dt_declare_record_write(env, o, &dti->dti_lb, dti->dti_off,
903 rc = dt_trans_start_local(env, dev, th);
907 dt_write_lock(env, o, 0);
908 if (dt_object_exists(o))
909 GOTO(out_lock, rc = 0);
911 rc = dt_create(env, o, &dti->dti_attr, NULL, &dti->dti_dof,
916 rc = dt_record_write(env, o, &dti->dti_lb, &dti->dti_off, th);
920 dt_write_unlock(env, o);
922 dt_trans_stop(env, dev, th);
925 dti->dti_lb.lb_buf = &lastid;
926 dti->dti_lb.lb_len = sizeof(lastid);
927 dt_read_lock(env, o, 0);
928 rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
929 dt_read_unlock(env, o);
930 if (rc == 0 && le64_to_cpu(lastid) > OBIF_MAX_OID) {
931 CERROR("%s: bad oid %llu is read from LAST_ID\n",
932 o->do_lu.lo_dev->ld_obd->obd_name,
933 le64_to_cpu(lastid));
939 list_del(&(*los)->los_list);
940 ls_device_put(env, ls);
943 if (o != NULL && !IS_ERR(o))
944 dt_object_put_nocache(env, o);
946 (*los)->los_seq = fid_seq(first_fid);
947 (*los)->los_last_oid = le64_to_cpu(lastid);
949 /* Read value should not be less than initial one
950 * but possible after upgrade from older fs.
951 * In this case just switch to the first_oid in memory and
952 * it will be updated on disk with first object generated */
953 if ((*los)->los_last_oid < first_oid)
954 (*los)->los_last_oid = first_oid;
957 mutex_unlock(&ls->ls_los_mutex);
958 ls_device_put(env, ls);
961 EXPORT_SYMBOL(local_oid_storage_init);
963 void local_oid_storage_fini(const struct lu_env *env,
964 struct local_oid_storage *los)
966 struct ls_device *ls;
969 LASSERT(los->los_dev);
970 ls = dt2ls_dev(los->los_dev);
972 /* Take the mutex before decreasing the reference to avoid race
973 * conditions as described in LU-4721. */
974 mutex_lock(&ls->ls_los_mutex);
975 if (!atomic_dec_and_test(&los->los_refcount)) {
976 mutex_unlock(&ls->ls_los_mutex);
981 dt_object_put_nocache(env, los->los_obj);
982 list_del(&los->los_list);
984 mutex_unlock(&ls->ls_los_mutex);
985 ls_device_put(env, ls);
987 EXPORT_SYMBOL(local_oid_storage_fini);