Whamcloud - gitweb
25352ae847db5e88ce0b63457318f7292a3d16bb
[fs/lustre-release.git] / lustre / llite / llite_nfs.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/lustre/llite/llite_nfs.c
37  *
38  * NFS export of Lustre Light File System
39  *
40  * Author: Yury Umanets <umka@clusterfs.com>
41  * Author: Huang Hua <huanghua@clusterfs.com>
42  */
43
44 #define DEBUG_SUBSYSTEM S_LLITE
45 #include <lustre_lite.h>
46 #include "llite_internal.h"
47 #ifdef HAVE_LINUX_EXPORTFS_H
48 #include <linux/exportfs.h>
49 #endif
50
51 __u32 get_uuid2int(const char *name, int len)
52 {
53         __u32 key0 = 0x12a3fe2d, key1 = 0x37abe8f9;
54         while (len--) {
55                 __u32 key = key1 + (key0 ^ (*name++ * 7152373));
56                 if (key & 0x80000000) key -= 0x7fffffff;
57                 key1 = key0;
58                 key0 = key;
59         }
60         return (key0 << 1);
61 }
62
63 static int ll_nfs_test_inode(struct inode *inode, void *opaque)
64 {
65         return lu_fid_eq(&ll_i2info(inode)->lli_fid,
66                          (struct lu_fid *)opaque);
67 }
68
69 static struct inode *search_inode_for_lustre(struct super_block *sb,
70                                              const struct lu_fid *fid)
71 {
72         struct ll_sb_info     *sbi = ll_s2sbi(sb);
73         struct ptlrpc_request *req = NULL;
74         struct inode          *inode = NULL;
75         int                   eadatalen = 0;
76         unsigned long         hash = (unsigned long) cl_fid_build_ino(fid);
77         struct  md_op_data    *op_data;
78         int                   rc;
79         ENTRY;
80
81         CDEBUG(D_INFO, "searching inode for:(%lu,"DFID")\n", hash, PFID(fid));
82
83         inode = ilookup5(sb, hash, ll_nfs_test_inode, (void *)fid);
84         if (inode)
85                 RETURN(inode);
86
87         rc = ll_get_max_mdsize(sbi, &eadatalen);
88         if (rc)
89                 RETURN(ERR_PTR(rc));
90
91         /* Because inode is NULL, ll_prep_md_op_data can not
92          * be used here. So we allocate op_data ourselves */
93         OBD_ALLOC_PTR(op_data);
94         if (op_data == NULL)
95                 return ERR_PTR(-ENOMEM);
96
97         op_data->op_fid1 = *fid;
98         op_data->op_mode = eadatalen;
99         op_data->op_valid = OBD_MD_FLEASIZE;
100
101         /* mds_fid2dentry ignores f_type */
102         rc = md_getattr(sbi->ll_md_exp, op_data, &req);
103         OBD_FREE_PTR(op_data);
104         if (rc) {
105                 CERROR("can't get object attrs, fid "DFID", rc %d\n",
106                        PFID(fid), rc);
107                 RETURN(ERR_PTR(rc));
108         }
109         rc = ll_prep_inode(&inode, req, sb);
110         ptlrpc_req_finished(req);
111         if (rc)
112                 RETURN(ERR_PTR(rc));
113
114         RETURN(inode);
115 }
116
117 static struct dentry *ll_iget_for_nfs(struct super_block *sb,
118                                       const struct lu_fid *fid)
119 {
120         struct inode  *inode;
121         struct dentry *result;
122         ENTRY;
123
124         CDEBUG(D_INFO, "Get dentry for fid: "DFID"\n", PFID(fid));
125         if (!fid_is_sane(fid))
126                 RETURN(ERR_PTR(-ESTALE));
127
128         inode = search_inode_for_lustre(sb, fid);
129         if (IS_ERR(inode))
130                 RETURN(ERR_PTR(PTR_ERR(inode)));
131
132         if (is_bad_inode(inode)) {
133                 /* we didn't find the right inode.. */
134                 CERROR("can't get inode by fid "DFID"\n",
135                        PFID(fid));
136                 iput(inode);
137                 RETURN(ERR_PTR(-ESTALE));
138         }
139
140         result = d_obtain_alias(inode);
141         if (!result) {
142                 iput(inode);
143                 RETURN(ERR_PTR(-ENOMEM));
144         }
145
146         ll_dops_init(result, 1);
147
148         RETURN(result);
149 }
150
151 #define LUSTRE_NFS_FID          0x97
152
153 struct lustre_nfs_fid {
154         struct lu_fid   lnf_child;
155         struct lu_fid   lnf_parent;
156 };
157
158 /**
159  * \a connectable - is nfsd will connect himself or this should be done
160  *                  at lustre
161  *
162  * The return value is file handle type:
163  * 1 -- contains child file handle;
164  * 2 -- contains child file handle and parent file handle;
165  * 255 -- error.
166  */
167 static int ll_encode_fh(struct dentry *de, __u32 *fh, int *plen,
168                         int connectable)
169 {
170         struct inode *inode = de->d_inode;
171         struct inode *parent = de->d_parent->d_inode;
172         struct lustre_nfs_fid *nfs_fid = (void *)fh;
173         ENTRY;
174
175         CDEBUG(D_INFO, "encoding for (%lu,"DFID") maxlen=%d minlen=%d\n",
176               inode->i_ino, PFID(ll_inode2fid(inode)), *plen,
177               (int)sizeof(struct lustre_nfs_fid));
178
179         if (*plen < sizeof(struct lustre_nfs_fid)/4)
180                 RETURN(255);
181
182         nfs_fid->lnf_child = *ll_inode2fid(inode);
183         nfs_fid->lnf_parent = *ll_inode2fid(parent);
184         *plen = sizeof(struct lustre_nfs_fid)/4;
185
186         RETURN(LUSTRE_NFS_FID);
187 }
188
189 #ifdef HAVE_FH_TO_DENTRY
190 static struct dentry *ll_fh_to_dentry(struct super_block *sb, struct fid *fid,
191                                       int fh_len, int fh_type)
192 {
193         struct lustre_nfs_fid *nfs_fid = (struct lustre_nfs_fid *)fid;
194
195         if (fh_type != LUSTRE_NFS_FID)
196                 RETURN(ERR_PTR(-EPROTO));
197
198         RETURN(ll_iget_for_nfs(sb, &nfs_fid->lnf_child));
199 }
200
201 static struct dentry *ll_fh_to_parent(struct super_block *sb, struct fid *fid,
202                                       int fh_len, int fh_type)
203 {
204         struct lustre_nfs_fid *nfs_fid = (struct lustre_nfs_fid *)fid;
205
206         if (fh_type != LUSTRE_NFS_FID)
207                 RETURN(ERR_PTR(-EPROTO));
208
209         RETURN(ll_iget_for_nfs(sb, &nfs_fid->lnf_parent));
210 }
211
212 #else
213
214 /*
215  * This length is counted as amount of __u32,
216  *  It is composed of a fid and a mode
217  */
218 static struct dentry *ll_decode_fh(struct super_block *sb, __u32 *fh, int fh_len,
219                                    int fh_type,
220                                    int (*acceptable)(void *, struct dentry *),
221                                    void *context)
222 {
223         struct lustre_nfs_fid *nfs_fid = (void *)fh;
224         struct dentry *entry;
225         ENTRY;
226
227         CDEBUG(D_INFO, "decoding for "DFID" fh_len=%d fh_type=%x\n", 
228                 PFID(&nfs_fid->lnf_child), fh_len, fh_type);
229
230         if (fh_type != LUSTRE_NFS_FID)
231                 RETURN(ERR_PTR(-EPROTO));
232
233         entry = sb->s_export_op->find_exported_dentry(sb, &nfs_fid->lnf_child,
234                                                       &nfs_fid->lnf_parent,
235                                                       acceptable, context);
236         RETURN(entry);
237 }
238
239 static struct dentry *ll_get_dentry(struct super_block *sb, void *data)
240 {
241         struct lustre_nfs_fid *fid = data;
242         struct dentry      *entry;
243         ENTRY;
244
245         entry = ll_iget_for_nfs(sb, &fid->lnf_child);
246         RETURN(entry);
247 }
248 #endif
249 static struct dentry *ll_get_parent(struct dentry *dchild)
250 {
251         struct ptlrpc_request *req = NULL;
252         struct inode          *dir = dchild->d_inode;
253         struct ll_sb_info     *sbi;
254         struct dentry         *result = NULL;
255         struct mdt_body       *body;
256         static char           dotdot[] = "..";
257         struct md_op_data     *op_data;
258         int                   rc;
259         ENTRY;
260
261         LASSERT(dir && S_ISDIR(dir->i_mode));
262
263         sbi = ll_s2sbi(dir->i_sb);
264
265         CDEBUG(D_INFO, "getting parent for (%lu,"DFID")\n",
266                         dir->i_ino, PFID(ll_inode2fid(dir)));
267
268         op_data = ll_prep_md_op_data(NULL, dir, NULL, dotdot,
269                                      strlen(dotdot), 0,
270                                      LUSTRE_OPC_ANY, NULL);
271         if (op_data == NULL)
272                 RETURN(ERR_PTR(-ENOMEM));
273
274         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
275         ll_finish_md_op_data(op_data);
276         if (rc) {
277                 CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino);
278                 RETURN(ERR_PTR(rc));
279         }
280         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
281         LASSERT(body->valid & OBD_MD_FLID);
282
283         CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n",
284                 PFID(ll_inode2fid(dir)), PFID(&body->fid1));
285
286         result = ll_iget_for_nfs(dir->i_sb, &body->fid1);
287
288         ptlrpc_req_finished(req);
289         RETURN(result);
290 }
291
292 struct export_operations lustre_export_operations = {
293        .get_parent = ll_get_parent,
294        .encode_fh  = ll_encode_fh,
295 #ifdef HAVE_FH_TO_DENTRY
296         .fh_to_dentry = ll_fh_to_dentry,
297         .fh_to_parent = ll_fh_to_parent,
298 #else
299        .get_dentry = ll_get_dentry,
300        .decode_fh  = ll_decode_fh,
301 #endif
302 };