lustre/include/uapi/linux/lustre/lustre_fid.h

   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, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  *
  28  * Copyright 2016 Cray Inc, all rights reserved.
  29  * Author: Ben Evans.
  30  *
  31  * all fid manipulation functions go here
  32  *
  33  * FIDS are globally unique within a Lustre filessytem, and are made up
  34  * of three parts: sequence, Object ID, and version.
  35  *
  36  */
  37 #ifndef _UAPI_LUSTRE_FID_H_
  38 #define _UAPI_LUSTRE_FID_H_
  39
  40 #include <linux/types.h>
  41 /*
  42  * This is due to us being out of kernel and the way the OpenSFS branch
  43  * handles CFLAGS.
  44  */
  45 #ifdef __KERNEL__
  46 # include <uapi/linux/lustre/lustre_idl.h>
  47 #else
  48 # include <linux/lustre/lustre_idl.h>
  49 #endif
  50
  51 /** returns fid object sequence */
  52 static inline __u64 fid_seq(const struct lu_fid *fid)
  53 {
  54         return fid->f_seq;
  55 }
  56
  57 /** returns fid object id */
  58 static inline __u32 fid_oid(const struct lu_fid *fid)
  59 {
  60         return fid->f_oid;
  61 }
  62
  63 /** returns fid object version */
  64 static inline __u32 fid_ver(const struct lu_fid *fid)
  65 {
  66         return fid->f_ver;
  67 }
  68
  69 static inline void fid_zero(struct lu_fid *fid)
  70 {
  71         memset(fid, 0, sizeof(*fid));
  72 }
  73
  74 static inline __u64 fid_ver_oid(const struct lu_fid *fid)
  75 {
  76         return (__u64)fid_ver(fid) << 32 | fid_oid(fid);
  77 }
  78
  79 static inline bool fid_seq_is_mdt0(__u64 seq)
  80 {
  81         return seq == FID_SEQ_OST_MDT0;
  82 }
  83
  84 static inline bool fid_seq_is_mdt(__u64 seq)
  85 {
  86         return seq == FID_SEQ_OST_MDT0 || seq >= FID_SEQ_NORMAL;
  87 };
  88
  89 static inline bool fid_seq_is_echo(__u64 seq)
  90 {
  91         return seq == FID_SEQ_ECHO;
  92 }
  93
  94 static inline bool fid_is_echo(const struct lu_fid *fid)
  95 {
  96         return fid_seq_is_echo(fid_seq(fid));
  97 }
  98
  99 static inline bool fid_seq_is_llog(__u64 seq)
 100 {
 101         return seq == FID_SEQ_LLOG;
 102 }
 103
 104 static inline bool fid_is_llog(const struct lu_fid *fid)
 105 {
 106         /* file with OID == 0 is not llog but contains last oid */
 107         return fid_seq_is_llog(fid_seq(fid)) && fid_oid(fid) > 0;
 108 }
 109
 110 static inline bool fid_seq_is_rsvd(__u64 seq)
 111 {
 112         return seq > FID_SEQ_OST_MDT0 && seq <= FID_SEQ_RSVD;
 113 };
 114
 115 static inline bool fid_seq_is_special(__u64 seq)
 116 {
 117         return seq == FID_SEQ_SPECIAL;
 118 };
 119
 120 static inline bool fid_seq_is_local_file(__u64 seq)
 121 {
 122         return seq == FID_SEQ_LOCAL_FILE ||
 123                seq == FID_SEQ_LOCAL_NAME;
 124 };
 125
 126 static inline bool fid_seq_is_root(__u64 seq)
 127 {
 128         return seq == FID_SEQ_ROOT;
 129 }
 130
 131 static inline bool fid_seq_is_dot(__u64 seq)
 132 {
 133         return seq == FID_SEQ_DOT_LUSTRE;
 134 }
 135
 136 static inline bool fid_seq_is_default(__u64 seq)
 137 {
 138         return seq == FID_SEQ_LOV_DEFAULT;
 139 }
 140
 141 static inline bool fid_is_mdt0(const struct lu_fid *fid)
 142 {
 143         return fid_seq_is_mdt0(fid_seq(fid));
 144 }
 145
 146 static inline void lu_root_fid(struct lu_fid *fid)
 147 {
 148         fid->f_seq = FID_SEQ_ROOT;
 149         fid->f_oid = FID_OID_ROOT;
 150         fid->f_ver = 0;
 151 }
 152
 153 static inline void lu_echo_root_fid(struct lu_fid *fid)
 154 {
 155         fid->f_seq = FID_SEQ_ROOT;
 156         fid->f_oid = FID_OID_ECHO_ROOT;
 157         fid->f_ver = 0;
 158 }
 159
 160 static inline void lu_update_log_fid(struct lu_fid *fid, __u32 index)
 161 {
 162         fid->f_seq = FID_SEQ_UPDATE_LOG;
 163         fid->f_oid = index;
 164         fid->f_ver = 0;
 165 }
 166
 167 static inline void lu_update_log_dir_fid(struct lu_fid *fid, __u32 index)
 168 {
 169         fid->f_seq = FID_SEQ_UPDATE_LOG_DIR;
 170         fid->f_oid = index;
 171         fid->f_ver = 0;
 172 }
 173
 174 /**
 175  * Check if a fid is igif or not.
 176  * \param fid the fid to be tested.
 177  * \return true if the fid is an igif; otherwise false.
 178  */
 179 static inline bool fid_seq_is_igif(__u64 seq)
 180 {
 181         return seq >= FID_SEQ_IGIF && seq <= FID_SEQ_IGIF_MAX;
 182 }
 183
 184 static inline bool fid_is_igif(const struct lu_fid *fid)
 185 {
 186         return fid_seq_is_igif(fid_seq(fid));
 187 }
 188
 189 /**
 190  * Check if a fid is idif or not.
 191  * \param fid the fid to be tested.
 192  * \return true if the fid is an idif; otherwise false.
 193  */
 194 static inline bool fid_seq_is_idif(__u64 seq)
 195 {
 196         return seq >= FID_SEQ_IDIF && seq <= FID_SEQ_IDIF_MAX;
 197 }
 198
 199 static inline bool fid_is_idif(const struct lu_fid *fid)
 200 {
 201         return fid_seq_is_idif(fid_seq(fid));
 202 }
 203
 204 static inline bool fid_is_local_file(const struct lu_fid *fid)
 205 {
 206         return fid_seq_is_local_file(fid_seq(fid));
 207 }
 208
 209 static inline bool fid_seq_is_norm(__u64 seq)
 210 {
 211         return (seq >= FID_SEQ_NORMAL);
 212 }
 213
 214 static inline bool fid_is_norm(const struct lu_fid *fid)
 215 {
 216         return fid_seq_is_norm(fid_seq(fid));
 217 }
 218
 219 static inline int fid_is_layout_rbtree(const struct lu_fid *fid)
 220 {
 221         return fid_seq(fid) == FID_SEQ_LAYOUT_RBTREE;
 222 }
 223
 224 static inline bool fid_seq_is_update_log(__u64 seq)
 225 {
 226         return seq == FID_SEQ_UPDATE_LOG;
 227 }
 228
 229 static inline bool fid_is_update_log(const struct lu_fid *fid)
 230 {
 231         return fid_seq_is_update_log(fid_seq(fid));
 232 }
 233
 234 static inline bool fid_seq_is_update_log_dir(__u64 seq)
 235 {
 236         return seq == FID_SEQ_UPDATE_LOG_DIR;
 237 }
 238
 239 static inline bool fid_is_update_log_dir(const struct lu_fid *fid)
 240 {
 241         return fid_seq_is_update_log_dir(fid_seq(fid));
 242 }
 243
 244 /* convert an OST objid into an IDIF FID SEQ number */
 245 static inline __u64 fid_idif_seq(__u64 id, __u32 ost_idx)
 246 {
 247         return FID_SEQ_IDIF | (ost_idx << 16) | ((id >> 32) & 0xffff);
 248 }
 249
 250 /* convert a packed IDIF FID into an OST objid */
 251 static inline __u64 fid_idif_id(__u64 seq, __u32 oid, __u32 ver)
 252 {
 253         return ((__u64)ver << 48) | ((seq & 0xffff) << 32) | oid;
 254 }
 255
 256 static inline __u32 idif_ost_idx(__u64 seq)
 257 {
 258         return (seq >> 16) & 0xffff;
 259 }
 260
 261 /* extract ost index from IDIF FID */
 262 static inline __u32 fid_idif_ost_idx(const struct lu_fid *fid)
 263 {
 264         return idif_ost_idx(fid_seq(fid));
 265 }
 266
 267 /* Check whether the fid is for LAST_ID */
 268 static inline bool fid_is_last_id(const struct lu_fid *fid)
 269 {
 270         if (fid_oid(fid) != 0)
 271                 return false;
 272
 273         if (fid_is_idif(fid) && ((fid_seq(fid) & 0xFFFF) != 0))
 274                 return false;
 275
 276         if (fid_seq(fid) == FID_SEQ_UPDATE_LOG ||
 277             fid_seq(fid) == FID_SEQ_UPDATE_LOG_DIR ||
 278             fid_seq_is_igif(fid_seq(fid)))
 279                 return false;
 280
 281         return true;
 282 }
 283
 284 /**
 285  * Get inode number from an igif.
 286  * \param fid an igif to get inode number from.
 287  * \return inode number for the igif.
 288  */
 289 static inline ino_t lu_igif_ino(const struct lu_fid *fid)
 290 {
 291         return fid_seq(fid);
 292 }
 293
 294 /**
 295  * Get inode generation from an igif.
 296  * \param fid an igif to get inode generation from.
 297  * \return inode generation for the igif.
 298  */
 299 static inline __u32 lu_igif_gen(const struct lu_fid *fid)
 300 {
 301         return fid_oid(fid);
 302 }
 303
 304 /**
 305  * Build igif from the inode number/generation.
 306  */
 307 static inline void lu_igif_build(struct lu_fid *fid, __u32 ino, __u32 gen)
 308 {
 309         fid->f_seq = ino;
 310         fid->f_oid = gen;
 311         fid->f_ver = 0;
 312 }
 313
 314 /*
 315  * Fids are transmitted across network (in the sender byte-ordering),
 316  * and stored on disk in big-endian order.
 317  */
 318 static inline void fid_cpu_to_le(struct lu_fid *dst, const struct lu_fid *src)
 319 {
 320         dst->f_seq = __cpu_to_le64(fid_seq(src));
 321         dst->f_oid = __cpu_to_le32(fid_oid(src));
 322         dst->f_ver = __cpu_to_le32(fid_ver(src));
 323 }
 324
 325 static inline void fid_le_to_cpu(struct lu_fid *dst, const struct lu_fid *src)
 326 {
 327         dst->f_seq = __le64_to_cpu(fid_seq(src));
 328         dst->f_oid = __le32_to_cpu(fid_oid(src));
 329         dst->f_ver = __le32_to_cpu(fid_ver(src));
 330 }
 331
 332 static inline void fid_cpu_to_be(struct lu_fid *dst, const struct lu_fid *src)
 333 {
 334         dst->f_seq = __cpu_to_be64(fid_seq(src));
 335         dst->f_oid = __cpu_to_be32(fid_oid(src));
 336         dst->f_ver = __cpu_to_be32(fid_ver(src));
 337 }
 338
 339 static inline void fid_be_to_cpu(struct lu_fid *dst, const struct lu_fid *src)
 340 {
 341         dst->f_seq = __be64_to_cpu(fid_seq(src));
 342         dst->f_oid = __be32_to_cpu(fid_oid(src));
 343         dst->f_ver = __be32_to_cpu(fid_ver(src));
 344 }
 345
 346 static inline bool fid_is_sane(const struct lu_fid *fid)
 347 {
 348         return fid && ((fid_seq(fid) >= FID_SEQ_START && !fid_ver(fid)) ||
 349                         fid_is_igif(fid) || fid_is_idif(fid) ||
 350                         fid_seq_is_rsvd(fid_seq(fid)));
 351 }
 352
 353 static inline bool lu_fid_eq(const struct lu_fid *f0, const struct lu_fid *f1)
 354 {
 355         return !memcmp(f0, f1, sizeof(*f0));
 356 }
 357
 358 static inline int lu_fid_cmp(const struct lu_fid *f0,
 359                              const struct lu_fid *f1)
 360 {
 361         if (fid_seq(f0) != fid_seq(f1))
 362                 return fid_seq(f0) > fid_seq(f1) ? 1 : -1;
 363
 364         if (fid_oid(f0) != fid_oid(f1))
 365                 return fid_oid(f0) > fid_oid(f1) ? 1 : -1;
 366
 367         if (fid_ver(f0) != fid_ver(f1))
 368                 return fid_ver(f0) > fid_ver(f1) ? 1 : -1;
 369
 370         return 0;
 371 }
 372 #endif