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