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, const 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, const 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(const struct knfsd_fh *fh1,
 247                             const struct knfsd_fh *fh2)
 248 {
 249         if (fh1->fh_size != fh2->fh_size)
 250                 return false;
 251         if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
 252                 return false;
 253         return true;
 254 }
 255
 256 static inline bool fh_fsid_match(const struct knfsd_fh *fh1,
 257                                  const struct knfsd_fh *fh2)
 258 {
 259         if (fh1->fh_fsid_type != fh2->fh_fsid_type)
 260                 return false;
 261         if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
 262                 return false;
 263         return true;
 264 }
 265
 266 #ifdef CONFIG_CRC32
 267 /**
 268  * knfsd_fh_hash - calculate the crc32 hash for the filehandle
 269  * @fh - pointer to filehandle
 270  *
 271  * returns a crc32 hash for the filehandle that is compatible with
 272  * the one displayed by "wireshark".
 273  */
 274 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 275 {
 276         return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
 277 }
 278 #else
 279 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 280 {
 281         return 0;
 282 }
 283 #endif
 284
 285 /**
 286  * fh_clear_pre_post_attrs - Reset pre/post attributes
 287  * @fhp: file handle to be updated
 288  *
 289  */
 290 static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
 291 {
 292         fhp->fh_post_saved = false;
 293         fhp->fh_pre_saved = false;
 294 }
 295
 296 u64 nfsd4_change_attribute(struct kstat *stat, struct inode *inode);
 297 extern void fh_fill_pre_attrs(struct svc_fh *fhp);
 298 extern void fh_fill_post_attrs(struct svc_fh *fhp);
 299 extern void fh_fill_both_attrs(struct svc_fh *fhp);
 300 #endif /* _LINUX_NFSD_NFSFH_H */