fs/nfsd/nfsfh.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
   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_want_write;  /* remount protection taken */
  85         bool                    fh_no_wcc;      /* no wcc data needed */
  86         bool                    fh_no_atomic_attr;
  87                                                 /*
  88                                                  * wcc data is not atomic with
  89                                                  * operation
  90                                                  */
  91         int                     fh_flags;       /* FH flags */
  92         bool                    fh_post_saved;  /* post-op attrs saved */
  93         bool                    fh_pre_saved;   /* pre-op attrs saved */
  94
  95         /* Pre-op attributes saved when inode is locked */
  96         __u64                   fh_pre_size;    /* size before operation */
  97         struct timespec64       fh_pre_mtime;   /* mtime before oper */
  98         struct timespec64       fh_pre_ctime;   /* ctime before oper */
  99         /*
 100          * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
 101          *  to find out if it is valid.
 102          */
 103         u64                     fh_pre_change;
 104
 105         /* Post-op attributes saved in fh_fill_post_attrs() */
 106         struct kstat            fh_post_attr;   /* full attrs after operation */
 107         u64                     fh_post_change; /* nfsv4 change; see above */
 108 } svc_fh;
 109 #define NFSD4_FH_FOREIGN (1<<0)
 110 #define SET_FH_FLAG(c, f) ((c)->fh_flags |= (f))
 111 #define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
 112
 113 enum nfsd_fsid {
 114         FSID_DEV = 0,
 115         FSID_NUM,
 116         FSID_MAJOR_MINOR,
 117         FSID_ENCODE_DEV,
 118         FSID_UUID4_INUM,
 119         FSID_UUID8,
 120         FSID_UUID16,
 121         FSID_UUID16_INUM,
 122 };
 123
 124 enum fsid_source {
 125         FSIDSOURCE_DEV,
 126         FSIDSOURCE_FSID,
 127         FSIDSOURCE_UUID,
 128 };
 129 extern enum fsid_source fsid_source(const struct svc_fh *fhp);
 130
 131
 132 /*
 133  * This might look a little large to "inline" but in all calls except
 134  * one, 'vers' is constant so moste of the function disappears.
 135  *
 136  * In some cases the values are considered to be host endian and in
 137  * others, net endian. fsidv is always considered to be u32 as the
 138  * callers don't know which it will be. So we must use __force to keep
 139  * sparse from complaining. Since these values are opaque to the
 140  * client, that shouldn't be a problem.
 141  */
 142 static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
 143                            u32 fsid, unsigned char *uuid)
 144 {
 145         u32 *up;
 146         switch(vers) {
 147         case FSID_DEV:
 148                 fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) |
 149                                  MINOR(dev));
 150                 fsidv[1] = ino_t_to_u32(ino);
 151                 break;
 152         case FSID_NUM:
 153                 fsidv[0] = fsid;
 154                 break;
 155         case FSID_MAJOR_MINOR:
 156                 fsidv[0] = (__force __u32)htonl(MAJOR(dev));
 157                 fsidv[1] = (__force __u32)htonl(MINOR(dev));
 158                 fsidv[2] = ino_t_to_u32(ino);
 159                 break;
 160
 161         case FSID_ENCODE_DEV:
 162                 fsidv[0] = new_encode_dev(dev);
 163                 fsidv[1] = ino_t_to_u32(ino);
 164                 break;
 165
 166         case FSID_UUID4_INUM:
 167                 /* 4 byte fsid and inode number */
 168                 up = (u32*)uuid;
 169                 fsidv[0] = ino_t_to_u32(ino);
 170                 fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
 171                 break;
 172
 173         case FSID_UUID8:
 174                 /* 8 byte fsid  */
 175                 up = (u32*)uuid;
 176                 fsidv[0] = up[0] ^ up[2];
 177                 fsidv[1] = up[1] ^ up[3];
 178                 break;
 179
 180         case FSID_UUID16:
 181                 /* 16 byte fsid - NFSv3+ only */
 182                 memcpy(fsidv, uuid, 16);
 183                 break;
 184
 185         case FSID_UUID16_INUM:
 186                 /* 8 byte inode and 16 byte fsid */
 187                 *(u64*)fsidv = (u64)ino;
 188                 memcpy(fsidv+2, uuid, 16);
 189                 break;
 190         default: BUG();
 191         }
 192 }
 193
 194 static inline int key_len(int type)
 195 {
 196         switch(type) {
 197         case FSID_DEV:          return 8;
 198         case FSID_NUM:          return 4;
 199         case FSID_MAJOR_MINOR:  return 12;
 200         case FSID_ENCODE_DEV:   return 8;
 201         case FSID_UUID4_INUM:   return 8;
 202         case FSID_UUID8:        return 8;
 203         case FSID_UUID16:       return 16;
 204         case FSID_UUID16_INUM:  return 24;
 205         default: return 0;
 206         }
 207 }
 208
 209 /*
 210  * Shorthand for dprintk()'s
 211  */
 212 extern char * SVCFH_fmt(struct svc_fh *fhp);
 213
 214 /*
 215  * Function prototypes
 216  */
 217 __be32  fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int);
 218 __be32  fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
 219 __be32  fh_update(struct svc_fh *);
 220 void    fh_put(struct svc_fh *);
 221
 222 static __inline__ struct svc_fh *
 223 fh_copy(struct svc_fh *dst, struct svc_fh *src)
 224 {
 225         WARN_ON(src->fh_dentry);
 226
 227         *dst = *src;
 228         return dst;
 229 }
 230
 231 static inline void
 232 fh_copy_shallow(struct knfsd_fh *dst, struct knfsd_fh *src)
 233 {
 234         dst->fh_size = src->fh_size;
 235         memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);
 236 }
 237
 238 static __inline__ struct svc_fh *
 239 fh_init(struct svc_fh *fhp, int maxsize)
 240 {
 241         memset(fhp, 0, sizeof(*fhp));
 242         fhp->fh_maxsize = maxsize;
 243         return fhp;
 244 }
 245
 246 static inline bool fh_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
 247 {
 248         if (fh1->fh_size != fh2->fh_size)
 249                 return false;
 250         if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
 251                 return false;
 252         return true;
 253 }
 254
 255 static inline bool fh_fsid_match(struct knfsd_fh *fh1, struct knfsd_fh *fh2)
 256 {
 257         if (fh1->fh_fsid_type != fh2->fh_fsid_type)
 258                 return false;
 259         if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
 260                 return false;
 261         return true;
 262 }
 263
 264 #ifdef CONFIG_CRC32
 265 /**
 266  * knfsd_fh_hash - calculate the crc32 hash for the filehandle
 267  * @fh - pointer to filehandle
 268  *
 269  * returns a crc32 hash for the filehandle that is compatible with
 270  * the one displayed by "wireshark".
 271  */
 272 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 273 {
 274         return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
 275 }
 276 #else
 277 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 278 {
 279         return 0;
 280 }
 281 #endif
 282
 283 /**
 284  * fh_clear_pre_post_attrs - Reset pre/post attributes
 285  * @fhp: file handle to be updated
 286  *
 287  */
 288 static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
 289 {
 290         fhp->fh_post_saved = false;
 291         fhp->fh_pre_saved = false;
 292 }
 293
 294 /*
 295  * We could use i_version alone as the change attribute.  However,
 296  * i_version can go backwards after a reboot.  On its own that doesn't
 297  * necessarily cause a problem, but if i_version goes backwards and then
 298  * is incremented again it could reuse a value that was previously used
 299  * before boot, and a client who queried the two values might
 300  * incorrectly assume nothing changed.
 301  *
 302  * By using both ctime and the i_version counter we guarantee that as
 303  * long as time doesn't go backwards we never reuse an old value.
 304  */
 305 static inline u64 nfsd4_change_attribute(struct kstat *stat,
 306                                          struct inode *inode)
 307 {
 308         if (inode->i_sb->s_export_op->fetch_iversion)
 309                 return inode->i_sb->s_export_op->fetch_iversion(inode);
 310         else if (IS_I_VERSION(inode)) {
 311                 u64 chattr;
 312
 313                 chattr =  stat->ctime.tv_sec;
 314                 chattr <<= 30;
 315                 chattr += stat->ctime.tv_nsec;
 316                 chattr += inode_query_iversion(inode);
 317                 return chattr;
 318         } else
 319                 return time_to_chattr(&stat->ctime);
 320 }
 321
 322 extern void fh_fill_pre_attrs(struct svc_fh *fhp);
 323 extern void fh_fill_post_attrs(struct svc_fh *fhp);
 324 extern void fh_fill_both_attrs(struct svc_fh *fhp);
 325 #endif /* _LINUX_NFSD_NFSFH_H */