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         bool                    fh_use_wgather; /* NFSv2 wgather option */
  92         bool                    fh_64bit_cookies;/* readdir cookie size */
  93         int                     fh_flags;       /* FH flags */
  94         bool                    fh_post_saved;  /* post-op attrs saved */
  95         bool                    fh_pre_saved;   /* pre-op attrs saved */
  96
  97         /* Pre-op attributes saved when inode is locked */
  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_fill_post_attrs() */
 108         struct kstat            fh_post_attr;   /* full attrs after operation */
 109         u64                     fh_post_change; /* nfsv4 change; see above */
 110 } svc_fh;
 111 #define NFSD4_FH_FOREIGN (1<<0)
 112 #define SET_FH_FLAG(c, f) ((c)->fh_flags |= (f))
 113 #define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f))
 114
 115 enum nfsd_fsid {
 116         FSID_DEV = 0,
 117         FSID_NUM,
 118         FSID_MAJOR_MINOR,
 119         FSID_ENCODE_DEV,
 120         FSID_UUID4_INUM,
 121         FSID_UUID8,
 122         FSID_UUID16,
 123         FSID_UUID16_INUM,
 124 };
 125
 126 enum fsid_source {
 127         FSIDSOURCE_DEV,
 128         FSIDSOURCE_FSID,
 129         FSIDSOURCE_UUID,
 130 };
 131 extern enum fsid_source fsid_source(const struct svc_fh *fhp);
 132
 133
 134 /*
 135  * This might look a little large to "inline" but in all calls except
 136  * one, 'vers' is constant so moste of the function disappears.
 137  *
 138  * In some cases the values are considered to be host endian and in
 139  * others, net endian. fsidv is always considered to be u32 as the
 140  * callers don't know which it will be. So we must use __force to keep
 141  * sparse from complaining. Since these values are opaque to the
 142  * client, that shouldn't be a problem.
 143  */
 144 static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino,
 145                            u32 fsid, unsigned char *uuid)
 146 {
 147         u32 *up;
 148         switch(vers) {
 149         case FSID_DEV:
 150                 fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) |
 151                                  MINOR(dev));
 152                 fsidv[1] = ino_t_to_u32(ino);
 153                 break;
 154         case FSID_NUM:
 155                 fsidv[0] = fsid;
 156                 break;
 157         case FSID_MAJOR_MINOR:
 158                 fsidv[0] = (__force __u32)htonl(MAJOR(dev));
 159                 fsidv[1] = (__force __u32)htonl(MINOR(dev));
 160                 fsidv[2] = ino_t_to_u32(ino);
 161                 break;
 162
 163         case FSID_ENCODE_DEV:
 164                 fsidv[0] = new_encode_dev(dev);
 165                 fsidv[1] = ino_t_to_u32(ino);
 166                 break;
 167
 168         case FSID_UUID4_INUM:
 169                 /* 4 byte fsid and inode number */
 170                 up = (u32*)uuid;
 171                 fsidv[0] = ino_t_to_u32(ino);
 172                 fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3];
 173                 break;
 174
 175         case FSID_UUID8:
 176                 /* 8 byte fsid  */
 177                 up = (u32*)uuid;
 178                 fsidv[0] = up[0] ^ up[2];
 179                 fsidv[1] = up[1] ^ up[3];
 180                 break;
 181
 182         case FSID_UUID16:
 183                 /* 16 byte fsid - NFSv3+ only */
 184                 memcpy(fsidv, uuid, 16);
 185                 break;
 186
 187         case FSID_UUID16_INUM:
 188                 /* 8 byte inode and 16 byte fsid */
 189                 *(u64*)fsidv = (u64)ino;
 190                 memcpy(fsidv+2, uuid, 16);
 191                 break;
 192         default: BUG();
 193         }
 194 }
 195
 196 static inline int key_len(int type)
 197 {
 198         switch(type) {
 199         case FSID_DEV:          return 8;
 200         case FSID_NUM:          return 4;
 201         case FSID_MAJOR_MINOR:  return 12;
 202         case FSID_ENCODE_DEV:   return 8;
 203         case FSID_UUID4_INUM:   return 8;
 204         case FSID_UUID8:        return 8;
 205         case FSID_UUID16:       return 16;
 206         case FSID_UUID16_INUM:  return 24;
 207         default: return 0;
 208         }
 209 }
 210
 211 /*
 212  * Shorthand for dprintk()'s
 213  */
 214 extern char * SVCFH_fmt(struct svc_fh *fhp);
 215
 216 /*
 217  * Function prototypes
 218  */
 219 __be32  fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int);
 220 __be32  fh_verify_local(struct net *, struct svc_cred *, struct auth_domain *,
 221                         struct svc_fh *, umode_t, int);
 222 __be32  fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *);
 223 __be32  fh_update(struct svc_fh *);
 224 void    fh_put(struct svc_fh *);
 225
 226 static __inline__ struct svc_fh *
 227 fh_copy(struct svc_fh *dst, const struct svc_fh *src)
 228 {
 229         WARN_ON(src->fh_dentry);
 230
 231         *dst = *src;
 232         return dst;
 233 }
 234
 235 static inline void
 236 fh_copy_shallow(struct knfsd_fh *dst, const struct knfsd_fh *src)
 237 {
 238         dst->fh_size = src->fh_size;
 239         memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);
 240 }
 241
 242 static __inline__ struct svc_fh *
 243 fh_init(struct svc_fh *fhp, int maxsize)
 244 {
 245         memset(fhp, 0, sizeof(*fhp));
 246         fhp->fh_maxsize = maxsize;
 247         return fhp;
 248 }
 249
 250 static inline bool fh_match(const struct knfsd_fh *fh1,
 251                             const struct knfsd_fh *fh2)
 252 {
 253         if (fh1->fh_size != fh2->fh_size)
 254                 return false;
 255         if (memcmp(fh1->fh_raw, fh2->fh_raw, fh1->fh_size) != 0)
 256                 return false;
 257         return true;
 258 }
 259
 260 static inline bool fh_fsid_match(const struct knfsd_fh *fh1,
 261                                  const struct knfsd_fh *fh2)
 262 {
 263         if (fh1->fh_fsid_type != fh2->fh_fsid_type)
 264                 return false;
 265         if (memcmp(fh1->fh_fsid, fh2->fh_fsid, key_len(fh1->fh_fsid_type)) != 0)
 266                 return false;
 267         return true;
 268 }
 269
 270 #ifdef CONFIG_CRC32
 271 /**
 272  * knfsd_fh_hash - calculate the crc32 hash for the filehandle
 273  * @fh - pointer to filehandle
 274  *
 275  * returns a crc32 hash for the filehandle that is compatible with
 276  * the one displayed by "wireshark".
 277  */
 278 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 279 {
 280         return ~crc32_le(0xFFFFFFFF, fh->fh_raw, fh->fh_size);
 281 }
 282 #else
 283 static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh)
 284 {
 285         return 0;
 286 }
 287 #endif
 288
 289 /**
 290  * fh_clear_pre_post_attrs - Reset pre/post attributes
 291  * @fhp: file handle to be updated
 292  *
 293  */
 294 static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
 295 {
 296         fhp->fh_post_saved = false;
 297         fhp->fh_pre_saved = false;
 298 }
 299
 300 u64 nfsd4_change_attribute(const struct kstat *stat);
 301 __be32 __must_check fh_fill_pre_attrs(struct svc_fh *fhp);
 302 __be32 fh_fill_post_attrs(struct svc_fh *fhp);
 303 __be32 __must_check fh_fill_both_attrs(struct svc_fh *fhp);
 304 #endif /* _LINUX_NFSD_NFSFH_H */