1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2015, Primary Data, Inc. All rights reserved. 4 * 5 * Tao Peng <bergwolf@primarydata.com> 6 */ 7 #include <linux/dcache.h> 8 #include <linux/exportfs.h> 9 #include <linux/nfs.h> 10 #include <linux/nfs_fs.h> 11 12 #include "internal.h" 13 #include "nfstrace.h" 14 15 #define NFSDBG_FACILITY NFSDBG_VFS 16 17 enum { 18 FILEID_HIGH_OFF = 0, /* inode fileid high */ 19 FILEID_LOW_OFF, /* inode fileid low */ 20 FILE_I_TYPE_OFF, /* inode type */ 21 EMBED_FH_OFF /* embeded server fh */ 22 }; 23 24 25 static struct nfs_fh *nfs_exp_embedfh(__u32 *p) 26 { 27 return (struct nfs_fh *)(p + EMBED_FH_OFF); 28 } 29 30 /* 31 * Let's break subtree checking for now... otherwise we'll have to embed parent fh 32 * but there might not be enough space. 33 */ 34 static int 35 nfs_encode_fh(struct inode *inode, __u32 *p, int *max_len, struct inode *parent) 36 { 37 struct nfs_fh *server_fh = NFS_FH(inode); 38 struct nfs_fh *clnt_fh = nfs_exp_embedfh(p); 39 size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size; 40 int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size); 41 42 dprintk("%s: max fh len %d inode %p parent %p", 43 __func__, *max_len, inode, parent); 44 45 if (*max_len < len || IS_AUTOMOUNT(inode)) { 46 dprintk("%s: fh len %d too small, required %d\n", 47 __func__, *max_len, len); 48 *max_len = len; 49 return FILEID_INVALID; 50 } 51 52 p[FILEID_HIGH_OFF] = NFS_FILEID(inode) >> 32; 53 p[FILEID_LOW_OFF] = NFS_FILEID(inode); 54 p[FILE_I_TYPE_OFF] = inode->i_mode & S_IFMT; 55 p[len - 1] = 0; /* Padding */ 56 nfs_copy_fh(clnt_fh, server_fh); 57 *max_len = len; 58 dprintk("%s: result fh fileid %llu mode %u size %d\n", 59 __func__, NFS_FILEID(inode), inode->i_mode, *max_len); 60 return *max_len; 61 } 62 63 static struct dentry * 64 nfs_fh_to_dentry(struct super_block *sb, struct fid *fid, 65 int fh_len, int fh_type) 66 { 67 struct nfs4_label *label = NULL; 68 struct nfs_fattr *fattr = NULL; 69 struct nfs_fh *server_fh = nfs_exp_embedfh(fid->raw); 70 size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size; 71 const struct nfs_rpc_ops *rpc_ops; 72 struct dentry *dentry; 73 struct inode *inode; 74 int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size); 75 u32 *p = fid->raw; 76 int ret; 77 78 /* NULL translates to ESTALE */ 79 if (fh_len < len || fh_type != len) 80 return NULL; 81 82 fattr = nfs_alloc_fattr(); 83 if (fattr == NULL) { 84 dentry = ERR_PTR(-ENOMEM); 85 goto out; 86 } 87 88 fattr->fileid = ((u64)p[FILEID_HIGH_OFF] << 32) + p[FILEID_LOW_OFF]; 89 fattr->mode = p[FILE_I_TYPE_OFF]; 90 fattr->valid |= NFS_ATTR_FATTR_FILEID | NFS_ATTR_FATTR_TYPE; 91 92 dprintk("%s: fileid %llu mode %d\n", __func__, fattr->fileid, fattr->mode); 93 94 inode = nfs_ilookup(sb, fattr, server_fh); 95 if (inode) 96 goto out_found; 97 98 label = nfs4_label_alloc(NFS_SB(sb), GFP_KERNEL); 99 if (IS_ERR(label)) { 100 dentry = ERR_CAST(label); 101 goto out_free_fattr; 102 } 103 104 rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops; 105 ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label, NULL); 106 if (ret) { 107 dprintk("%s: getattr failed %d\n", __func__, ret); 108 trace_nfs_fh_to_dentry(sb, server_fh, fattr->fileid, ret); 109 dentry = ERR_PTR(ret); 110 goto out_free_label; 111 } 112 113 inode = nfs_fhget(sb, server_fh, fattr, label); 114 115 out_found: 116 dentry = d_obtain_alias(inode); 117 118 out_free_label: 119 nfs4_label_free(label); 120 out_free_fattr: 121 nfs_free_fattr(fattr); 122 out: 123 return dentry; 124 } 125 126 static struct dentry * 127 nfs_get_parent(struct dentry *dentry) 128 { 129 int ret; 130 struct inode *inode = d_inode(dentry), *pinode; 131 struct super_block *sb = inode->i_sb; 132 struct nfs_server *server = NFS_SB(sb); 133 struct nfs_fattr *fattr = NULL; 134 struct nfs4_label *label = NULL; 135 struct dentry *parent; 136 struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops; 137 struct nfs_fh fh; 138 139 if (!ops->lookupp) 140 return ERR_PTR(-EACCES); 141 142 fattr = nfs_alloc_fattr(); 143 if (fattr == NULL) { 144 parent = ERR_PTR(-ENOMEM); 145 goto out; 146 } 147 148 label = nfs4_label_alloc(server, GFP_KERNEL); 149 if (IS_ERR(label)) { 150 parent = ERR_CAST(label); 151 goto out_free_fattr; 152 } 153 154 ret = ops->lookupp(inode, &fh, fattr, label); 155 if (ret) { 156 parent = ERR_PTR(ret); 157 goto out_free_label; 158 } 159 160 pinode = nfs_fhget(sb, &fh, fattr, label); 161 parent = d_obtain_alias(pinode); 162 out_free_label: 163 nfs4_label_free(label); 164 out_free_fattr: 165 nfs_free_fattr(fattr); 166 out: 167 return parent; 168 } 169 170 static u64 nfs_fetch_iversion(struct inode *inode) 171 { 172 struct nfs_server *server = NFS_SERVER(inode); 173 174 /* Is this the right call?: */ 175 nfs_revalidate_inode(server, inode); 176 /* 177 * Also, note we're ignoring any returned error. That seems to be 178 * the practice for cache consistency information elsewhere in 179 * the server, but I'm not sure why. 180 */ 181 if (server->nfs_client->rpc_ops->version >= 4) 182 return inode_peek_iversion_raw(inode); 183 else 184 return time_to_chattr(&inode->i_ctime); 185 } 186 187 const struct export_operations nfs_export_ops = { 188 .encode_fh = nfs_encode_fh, 189 .fh_to_dentry = nfs_fh_to_dentry, 190 .get_parent = nfs_get_parent, 191 .fetch_iversion = nfs_fetch_iversion, 192 .flags = EXPORT_OP_NOWCC|EXPORT_OP_NOSUBTREECHK| 193 EXPORT_OP_CLOSE_BEFORE_UNLINK|EXPORT_OP_REMOTE_FS| 194 EXPORT_OP_NOATOMIC_ATTR, 195 }; 196