Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
20fa1902 PT |
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 | } | |
20fa1902 PT |
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; | |
20fa1902 PT |
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; | |
a841b54d | 105 | ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label, NULL); |
20fa1902 PT |
106 | if (ret) { |
107 | dprintk("%s: getattr failed %d\n", __func__, ret); | |
43622eab | 108 | trace_nfs_fh_to_dentry(sb, server_fh, fattr->fileid, ret); |
20fa1902 PT |
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 | const struct export_operations nfs_export_ops = { | |
171 | .encode_fh = nfs_encode_fh, | |
172 | .fh_to_dentry = nfs_fh_to_dentry, | |
173 | .get_parent = nfs_get_parent, | |
174 | }; |