fs/nfsd/nfsfh.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <[email protected]>
   4  *
   5  * This file describes the layout of the file handles as passed
   6  * over the wire.
   7  */
   8 #ifndef _LINUX_NFSD_NFSFH_H
   9 #define _LINUX_NFSD_NFSFH_H
  10
  11 #include <linux/crc32.h>
  12 #include <linux/sunrpc/svc.h>
  13 #include <linux/iversion.h>
  14 #include <linux/exportfs.h>
  15 #include <linux/nfs4.h>
  16
  17 /*
  18  * The file handle starts with a sequence of four-byte words.
  19  * The first word contains a version number (1) and three descriptor bytes
  20  * that tell how the remaining 3 variable length fields should be handled.
  21  * These three bytes are auth_type, fsid_type and fileid_type.
  22  *
  23  * All four-byte values are in host-byte-order.
  24  *
  25  * The auth_type field is deprecated and must be set to 0.
  26  *
  27  * The fsid_type identifies how the filesystem (or export point) is
  28  *    encoded.
  29  *  Current values:
  30  *     0  - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number
  31  *        NOTE: we cannot use the kdev_t device id value, because kdev_t.h
  32  *              says we mustn't.  We must break it up and reassemble.
  33  *     1  - 4 byte user specified identifier
  34  *     2  - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED
  35  *     3  - 4 byte device id, encoded for user-space, 4 byte inode number
  36  *     4  - 4 byte inode number and 4 byte uuid
  37  *     5  - 8 byte uuid
  38  *     6  - 16 byte uuid
  39  *     7  - 8 byte inode number and 16 byte uuid
  40  *
  41  * The fileid_type identifies how the file within the filesystem is encoded.
  42  *   The values for this field are filesystem specific, exccept that
  43  *   filesystems must not use the values '0' or '0xff'. 'See enum fid_type'
  44  *   in include/linux/exportfs.h for currently registered values.
  45  */
  46
  47 struct knfsd_fh {
  48         unsigned int    fh_size;        /*
  49                                          * Points to the current size while
  50                                          * building a new file handle.
  51                                          */
  52         union {
  53                 char                    fh_raw[NFS4_FHSIZE];
  54                 struct {
  55                         u8              fh_version;     /* == 1 */
  56                         u8              fh_auth_type;   /* deprecated */
  57                         u8              fh_fsid_type;
  58                         u8              fh_fileid_type;
  59                         u32             fh_fsid[]; /* flexible-array member */
  60                 };
  61         };
  62 };
  63
  64 static inline __u32 ino_t_to_u32(ino_t ino)
  65 {
  66         return (__u32) ino;
  67 }
  68
  69 static inline ino_t u32_to_ino_t(__u32 uino)
  70 {
  71         return (ino_t) uino;
  72 }
  73
  74 /*
  75  * This is the internal representation of an NFS handle used in knfsd.
  76  * pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
  77  */
  78 typedef struct svc_fh {
  79         struct knfsd_fh         fh_handle;      /* FH data */
  80         int                     fh_maxsize;     /* max size for fh_handle */
  81         struct dentry *         fh_dentry;      /* validated dentry */
  82         struct svc_export *     fh_export;      /* export pointer */
  83
  84         bool                    fh_locked;      /* inode locked by us */
  85         bool                    fh_want_write;  /* remount protection taken */
  86         bool                    fh_no_wcc;      /* no wcc data needed */
  87         bool                    fh_no_atomic_attr;
  88                                                 /*
  89                                                  * wcc data is not atomic with
  90                                                  * operation
  91                                                  */
  92         int                     fh_flags;       /* FH flags */
  93 #ifdef CONFIG_NFSD_V3
  94         bool                    fh_post_saved;  /* post-op attrs saved */
  95         bool                    fh_pre_saved;   /* pre-op attrs saved */
  96
  97         /* Pre-op attributes saved during fh_lock */
  98         __u64                   fh_pre_size;    /* size before operation */
  99         struct timespec64       fh_pre_mtime;   /* mtime before oper */
 100         struct timespec64       fh_pre_ctime;   /* ctime before oper */
 101         /*
 102          * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
 103          *  to find out if it is valid.
 104          */
 105         u64                     fh_pre_change;
 106
 107         /* Post-op attributes saved in fh_unlock */
 108         struct kstat            fh_post_attr;   /* full attrs after operation */
 109         u64                     fh_post_change; /* nfsv4 change; see above */
 110 #endif /* CONFIG_NFSD_V3 */
 111 } svc_fh;
 112 #define NFSD4_FH_FOREIGN (1<<0)
 113 #define SET_FH_FLAG(c, f) ((c)->fh_flags |= (f))
 114 #define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
 115
 116 enum nfsd_fsid {
 117         FSID_DEV = 0,
 118         FSID_NUM,
 119         FSID_MAJOR_MINOR,
 120         FSID_ENCODE_DEV,
 121         FSID_UUID4_INUM,
 122         FSID_UUID8,
 123         FSID_UUID16,
 124         FSID_UUID16_INUM,
 125 };
 126
 127 enum fsid_source {
 128         FSIDSOURCE_DEV,
 129         FSIDSOURCE_FSID,
 130         FSIDSOURCE_UUID,
 131 };
 132 extern enum fsid_source fsid_source(const struct svc_fh *fhp);
 133
 134
 135 /*
 136  * This might look a little large to "inline" but in all calls except
 137  * one, 'vers' is constant so moste of the function disappears.
 138  *
 139  * In some cases the values are considered to be host endian and in
 140  * others, net endian. fsidv is always considered to be u32 as the
 141  * callers don't know which it will be. So we must use __force to keep
 142  * sparse from complaining. Since these values are opaque to the
 143  * client, that shouldn't be a problem.
 144  */
 145 static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
 146                            u32 fsid, unsigned char *uuid)
 147 {
 148         u32 *up;
 149         switch(vers) {
 150         case FSID_DEV:
 151                 fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) |
 152                                  MINOR(dev));
 153                 fsidv[1] = ino_t_to_u32(ino);
 154                 break;
 155         case FSID_NUM:
 156                 fsidv[0] = fsid;
 157                 break;
 158         case FSID_MAJOR_MINOR:
 159                 fsidv[0] = (__force __u32)htonl(MAJOR(dev));
 160                 fsidv[1] = (__force __u32)htonl(MINOR(dev));
 161                 fsidv[2] = ino_t_to_u32(ino);
 162                 break;
 163
 164         case FSID_ENCODE_DEV:
 165                 fsidv[0] = new_encode_dev(dev);
 166                 fsidv[1] = ino_t_to_u32(ino);
 167                 break;
 168
 169         case FSID_UUID4_INUM:
 170                 /* 4 byte fsid and inode number */
 171                 up = (u32*)uuid;
 172                 fsidv[0] = ino_t_to_u32(ino);
 173                 fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
 174                 break;
 175
 176         case FSID_UUID8:
 177                 /* 8 byte fsid  */
 178                 up = (u32*)uuid;
 179                 fsidv[0] = up[0] ^ up[2];
 180                 fsidv[1] = up[1] ^ up[3];
 181                 break;
 182
 183         case FSID_UUID16:
 184                 /* 16 byte fsid - NFSv3+ only */
 185                 memcpy(fsidv, uuid, 16);
 186                 break;
 187
 188         case FSID_UUID16_INUM:
 189                 /* 8 byte inode and 16 byte fsid */
 190                 *(u64*)fsidv = (u64)ino;
 191                 memcpy(fsidv+2, uuid, 16);
 192                 break;
 193         default: BUG();
 194         }
 195 }
 196
 197 static inline int key_len(int type)
 198 {
 199         switch(type) {
 200         case FSID_DEV:          return 8;
 201         case FSID_NUM:          return 4;
 202         case FSID_MAJOR_MINOR:  return 12;
 203         case FSID_ENCODE_DEV:   return 8;
 204         case FSID_UUID4_INUM:   return 8;
 205         case FSID_UUID8:        return 8;
 206         case FSID_UUID16:       return 16;
 207         case FSID_UUID16_INUM:  return 24;
 208         default: return 0;
 209         }
 210 }
 211
 212 /*
 213  * Shorthand for dprintk()'s
 214  */
 215 extern char * SVCFH_fmt(struct svc_fh *fhp);
 216
 217 /*
 218  * Function prototypes
 219  */
 220 __be32  fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int);
 221 __be32  fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
 222 __be32  fh_update(struct svc_fh *);
 223 void    fh_put(struct svc_fh *);
 224
 225 static __inline__ struct svc_fh *
 226 fh_copy(struct svc_fh *dst, struct svc_fh *src)
 227 {
 228         WARN_ON(src->fh_dentry || src->fh_locked);
 229
 230         *dst = *src;
 231         return dst;
 232 }
 233
 234 static inline void
 235 fh_copy_shallow(struct knfsd_fh *dst, struct knfsd_fh *src)
 236 {
 237         dst->fh_size = src->fh_size;
 238         memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);
 239 }
 240
 241 static __inline__ struct svc_fh *
 242 fh_init(struct svc_fh *fhp, int maxsize)
 243 {
 244         memset(fhp, 0, sizeof(*fhp));
 245         fhp->fh_maxsize = maxsize;
 246         return fhp;
 247 }
 248
 249 static inline bool fh_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
 250 {
 251         if (fh1->fh_size != fh2->fh_size)
 252                 return false;
 253         if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
 254                 return false;
 255         return true;
 256 }
 257
 258 static inline bool fh_fsid_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
 259 {
 260         if (fh1->fh_fsid_type != fh2->fh_fsid_type)
 261                 return false;
 262         if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
 263                 return false;
 264         return true;
 265 }
 266
 267 #ifdef CONFIG_CRC32
 268 /**
 269  * knfsd_fh_hash - calculate the crc32 hash for the filehandle
 270  * @fh - pointer to filehandle
 271  *
 272  * returns a crc32 hash for the filehandle that is compatible with
 273  * the one displayed by "wireshark".
 274  */
 275 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 276 {
 277         return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
 278 }
 279 #else
 280 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 281 {
 282         return 0;
 283 }
 284 #endif
 285
 286 #ifdef CONFIG_NFSD_V3
 287
 288 /**
 289  * fh_clear_pre_post_attrs - Reset pre/post attributes
 290  * @fhp: file handle to be updated
 291  *
 292  */
 293 static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
 294 {
 295         fhp->fh_post_saved = false;
 296         fhp->fh_pre_saved = false;
 297 }
 298
 299 /*
 300  * We could use i_version alone as the change attribute.  However,
 301  * i_version can go backwards after a reboot.  On its own that doesn't
 302  * necessarily cause a problem, but if i_version goes backwards and then
 303  * is incremented again it could reuse a value that was previously used
 304  * before boot, and a client who queried the two values might
 305  * incorrectly assume nothing changed.
 306  *
 307  * By using both ctime and the i_version counter we guarantee that as
 308  * long as time doesn't go backwards we never reuse an old value.
 309  */
 310 static inline u64 nfsd4_change_attribute(struct kstat *stat,
 311                                          struct inode *inode)
 312 {
 313         if (inode->i_sb->s_export_op->fetch_iversion)
 314                 return inode->i_sb->s_export_op->fetch_iversion(inode);
 315         else if (IS_I_VERSION(inode)) {
 316                 u64 chattr;
 317
 318                 chattr =  stat->ctime.tv_sec;
 319                 chattr <<= 30;
 320                 chattr += stat->ctime.tv_nsec;
 321                 chattr += inode_query_iversion(inode);
 322                 return chattr;
 323         } else
 324                 return time_to_chattr(&stat->ctime);
 325 }
 326
 327 extern void fh_fill_pre_attrs(struct svc_fh *fhp);
 328 extern void fh_fill_post_attrs(struct svc_fh *fhp);
 329
 330 #else /* !CONFIG_NFSD_V3 */
 331
 332 static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
 333 {
 334 }
 335
 336 static inline void fh_fill_pre_attrs(struct svc_fh *fhp)
 337 {
 338 }
 339
 340 static inline void fh_fill_post_attrs(struct svc_fh *fhp)
 341 {
 342 }
 343
 344 #endif /* !CONFIG_NFSD_V3 */
 345
 346
 347 /*
 348  * Lock a file handle/inode
 349  * NOTE: both fh_lock and fh_unlock are done "by hand" in
 350  * vfs.c:nfsd_rename as it needs to grab 2 i_mutex's at once
 351  * so, any changes here should be reflected there.
 352  */
 353
 354 static inline void
 355 fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
 356 {
 357         struct dentry   *dentry = fhp->fh_dentry;
 358         struct inode    *inode;
 359
 360         BUG_ON(!dentry);
 361
 362         if (fhp->fh_locked) {
 363                 printk(KERN_WARNING "fh_lock: %pd2 already locked!\n",
 364                         dentry);
 365                 return;
 366         }
 367
 368         inode = d_inode(dentry);
 369         inode_lock_nested(inode, subclass);
 370         fh_fill_pre_attrs(fhp);
 371         fhp->fh_locked = true;
 372 }
 373
 374 static inline void
 375 fh_lock(struct svc_fh *fhp)
 376 {
 377         fh_lock_nested(fhp, I_MUTEX_NORMAL);
 378 }
 379
 380 /*
 381  * Unlock a file handle/inode
 382  */
 383 static inline void
 384 fh_unlock(struct svc_fh *fhp)
 385 {
 386         if (fhp->fh_locked) {
 387                 fh_fill_post_attrs(fhp);
 388                 inode_unlock(d_inode(fhp->fh_dentry));
 389                 fhp->fh_locked = false;
 390         }
 391 }
 392
 393 #endif /* _LINUX_NFSD_NFSFH_H */