Merge git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next
[linux-2.6-microblaze.git] / fs / nfs / export.c
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 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 };