Branch data Line data Source code
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 : 0 : static struct nfs_fh *nfs_exp_embedfh(__u32 *p)
26 : : {
27 : 0 : 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 : 0 : nfs_encode_fh(struct inode *inode, __u32 *p, int *max_len, struct inode *parent)
36 : : {
37 [ # # ]: 0 : struct nfs_fh *server_fh = NFS_FH(inode);
38 : 0 : struct nfs_fh *clnt_fh = nfs_exp_embedfh(p);
39 : 0 : size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
40 : 0 : int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
41 : :
42 : 0 : dprintk("%s: max fh len %d inode %p parent %p",
43 : : __func__, *max_len, inode, parent);
44 : :
45 [ # # # # ]: 0 : if (*max_len < len || IS_AUTOMOUNT(inode)) {
46 : 0 : dprintk("%s: fh len %d too small, required %d\n",
47 : : __func__, *max_len, len);
48 : 0 : *max_len = len;
49 : 0 : return FILEID_INVALID;
50 : : }
51 : :
52 : 0 : p[FILEID_HIGH_OFF] = NFS_FILEID(inode) >> 32;
53 : 0 : p[FILEID_LOW_OFF] = NFS_FILEID(inode);
54 : 0 : p[FILE_I_TYPE_OFF] = inode->i_mode & S_IFMT;
55 : 0 : p[len - 1] = 0; /* Padding */
56 : 0 : nfs_copy_fh(clnt_fh, server_fh);
57 : 0 : *max_len = len;
58 : 0 : dprintk("%s: result fh fileid %llu mode %u size %d\n",
59 : : __func__, NFS_FILEID(inode), inode->i_mode, *max_len);
60 : 0 : return *max_len;
61 : : }
62 : :
63 : : static struct dentry *
64 : 0 : nfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
65 : : int fh_len, int fh_type)
66 : : {
67 : 0 : struct nfs4_label *label = NULL;
68 : 0 : struct nfs_fattr *fattr = NULL;
69 : 0 : struct nfs_fh *server_fh = nfs_exp_embedfh(fid->raw);
70 : 0 : size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
71 : 0 : const struct nfs_rpc_ops *rpc_ops;
72 : 0 : struct dentry *dentry;
73 : 0 : struct inode *inode;
74 : 0 : int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
75 : 0 : u32 *p = fid->raw;
76 : 0 : int ret;
77 : :
78 : : /* NULL translates to ESTALE */
79 [ # # ]: 0 : if (fh_len < len || fh_type != len)
80 : : return NULL;
81 : :
82 : 0 : fattr = nfs_alloc_fattr();
83 [ # # ]: 0 : if (fattr == NULL) {
84 : 0 : dentry = ERR_PTR(-ENOMEM);
85 : 0 : goto out;
86 : : }
87 : :
88 : 0 : fattr->fileid = ((u64)p[FILEID_HIGH_OFF] << 32) + p[FILEID_LOW_OFF];
89 : 0 : fattr->mode = p[FILE_I_TYPE_OFF];
90 : 0 : fattr->valid |= NFS_ATTR_FATTR_FILEID | NFS_ATTR_FATTR_TYPE;
91 : :
92 : 0 : dprintk("%s: fileid %llu mode %d\n", __func__, fattr->fileid, fattr->mode);
93 : :
94 : 0 : inode = nfs_ilookup(sb, fattr, server_fh);
95 [ # # ]: 0 : if (inode)
96 : 0 : goto out_found;
97 : :
98 : 0 : label = nfs4_label_alloc(NFS_SB(sb), GFP_KERNEL);
99 : 0 : if (IS_ERR(label)) {
100 : : dentry = ERR_CAST(label);
101 : : goto out_free_fattr;
102 : : }
103 : :
104 : 0 : rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops;
105 : 0 : ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label, NULL);
106 [ # # ]: 0 : if (ret) {
107 : 0 : dprintk("%s: getattr failed %d\n", __func__, ret);
108 : 0 : trace_nfs_fh_to_dentry(sb, server_fh, fattr->fileid, ret);
109 : 0 : dentry = ERR_PTR(ret);
110 : 0 : goto out_free_label;
111 : : }
112 : :
113 : 0 : inode = nfs_fhget(sb, server_fh, fattr, label);
114 : :
115 : 0 : out_found:
116 : 0 : dentry = d_obtain_alias(inode);
117 : :
118 : 0 : out_free_label:
119 : 0 : nfs4_label_free(label);
120 : : out_free_fattr:
121 : 0 : nfs_free_fattr(fattr);
122 : : out:
123 : : return dentry;
124 : : }
125 : :
126 : : static struct dentry *
127 : 0 : nfs_get_parent(struct dentry *dentry)
128 : : {
129 : 0 : int ret;
130 [ # # ]: 0 : struct inode *inode = d_inode(dentry), *pinode;
131 : 0 : struct super_block *sb = inode->i_sb;
132 [ # # ]: 0 : struct nfs_server *server = NFS_SB(sb);
133 : 0 : struct nfs_fattr *fattr = NULL;
134 : 0 : struct nfs4_label *label = NULL;
135 : 0 : struct dentry *parent;
136 : 0 : struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;
137 : 0 : struct nfs_fh fh;
138 : :
139 [ # # ]: 0 : if (!ops->lookupp)
140 : : return ERR_PTR(-EACCES);
141 : :
142 : 0 : fattr = nfs_alloc_fattr();
143 [ # # ]: 0 : if (fattr == NULL) {
144 : 0 : parent = ERR_PTR(-ENOMEM);
145 : 0 : goto out;
146 : : }
147 : :
148 : 0 : label = nfs4_label_alloc(server, GFP_KERNEL);
149 : 0 : if (IS_ERR(label)) {
150 : : parent = ERR_CAST(label);
151 : : goto out_free_fattr;
152 : : }
153 : :
154 : 0 : ret = ops->lookupp(inode, &fh, fattr, label);
155 [ # # ]: 0 : if (ret) {
156 : 0 : parent = ERR_PTR(ret);
157 : 0 : goto out_free_label;
158 : : }
159 : :
160 : 0 : pinode = nfs_fhget(sb, &fh, fattr, label);
161 : 0 : parent = d_obtain_alias(pinode);
162 : 0 : out_free_label:
163 : 0 : nfs4_label_free(label);
164 : : out_free_fattr:
165 : 0 : 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 : : };
|
