Whamcloud - gitweb
d052b2d655819ee6c708e7d2f599c68353239bb8
[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  *   NFS export of Lustre Light File System 
5  *
6  *   Copyright (c) 2002, 2003 Cluster File Systems, Inc.
7  *
8  *   This file is part of Lustre, http://www.lustre.org.
9  *
10  *   Lustre is free software; you can redistribute it and/or
11  *   modify it under the terms of version 2 of the GNU General Public
12  *   License as published by the Free Software Foundation.
13  *
14  *   Lustre is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with Lustre; if not, write to the Free Software
21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #define DEBUG_SUBSYSTEM S_LLITE
25 #include <linux/lustre_lite.h>
26 #include "llite_internal.h"
27
28 __u32 get_uuid2int(const char *name, int len)
29 {
30         __u32 key0 = 0x12a3fe2d, key1 = 0x37abe8f9;
31         while (len--) {
32                 __u32 key = key1 + (key0 ^ (*name++ * 7152373));
33                 if (key & 0x80000000) key -= 0x7fffffff;
34                 key1 = key0;
35                 key0 = key;
36         }
37         return (key0 << 1);
38 }
39
40 static struct inode * search_inode_for_lustre(struct super_block *sb,
41                                               unsigned long ino,
42                                               unsigned long generation,
43                                               int mode)
44 {
45         struct ptlrpc_request *req = NULL;
46         struct ll_sb_info *sbi = ll_s2sbi(sb);
47         struct lustre_id id;
48         unsigned long valid = 0;
49         int eadatalen = 0, rc;
50         struct inode *inode = NULL;
51
52         inode = ILOOKUP(sb, ino, NULL, NULL);
53
54         if (inode)
55                 return inode;
56         if (S_ISREG(mode)) {
57                 eadatalen = obd_size_diskmd(sbi->ll_lov_exp, NULL);
58                 valid |= OBD_MD_FLEASIZE;
59         }
60         id.li_stc.u.e3s.l3s_type = mode;
61         id.li_stc.u.e3s.l3s_ino = (__u64)ino;
62         id.li_stc.u.e3s.l3s_gen = generation;
63
64         rc = md_getattr(sbi->ll_lmv_exp, &id, valid, eadatalen, &req);
65         if (rc) {
66                 CERROR("failure %d inode %lu\n", rc, ino);
67                 return ERR_PTR(rc);
68         }
69
70         rc = ll_prep_inode(sbi->ll_lov_exp, sbi->ll_lmv_exp,
71                            &inode, req, 0, sb);
72         if (rc) {
73                 ptlrpc_req_finished(req);
74                 return ERR_PTR(rc);
75         }
76         ptlrpc_req_finished(req);
77
78         return inode;
79 }
80
81 extern struct dentry_operations ll_d_ops;
82
83 static struct dentry *ll_iget_for_nfs(struct super_block *sb, unsigned long ino,
84                                       __u32 generation, umode_t mode)
85 {
86         struct inode *inode;
87         struct dentry *result;
88         struct list_head *lp;
89
90         if (ino == 0)
91                 return ERR_PTR(-ESTALE);
92
93         inode = search_inode_for_lustre(sb, ino, generation, mode);
94         if (IS_ERR(inode)) {
95                 return ERR_PTR(PTR_ERR(inode));
96         }
97         if (is_bad_inode(inode) 
98             || (generation && inode->i_generation != generation)
99             ){
100                 /* we didn't find the right inode.. */
101               CERROR(" Inode %lu, Bad count: %lu %d or version  %u %u\n",
102                         inode->i_ino, 
103                         (unsigned long)inode->i_nlink, 
104                         atomic_read(&inode->i_count), 
105                         inode->i_generation, 
106                         generation);
107                 iput(inode);
108                 return ERR_PTR(-ESTALE);
109         }
110         
111         /* now to find a dentry.
112          * If possible, get a well-connected one
113          */
114         spin_lock(&dcache_lock);
115         for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) {
116                 result = list_entry(lp,struct dentry, d_alias);
117                 if (!(result->d_flags & DCACHE_DISCONNECTED)) {
118                         dget_locked(result);
119                         ll_set_dflags(result, DCACHE_REFERENCED);
120                         spin_unlock(&dcache_lock);
121                         iput(inode);
122                         return result;
123                 }
124         }
125         spin_unlock(&dcache_lock);
126         result = d_alloc_root(inode);
127         if (result == NULL) {
128                 iput(inode);
129                 return ERR_PTR(-ENOMEM);
130         }
131         result->d_flags |= DCACHE_DISCONNECTED;
132         
133         ll_set_dd(result);
134         result->d_op = &ll_d_ops;
135         return result;
136 }
137
138 struct dentry *ll_fh_to_dentry(struct super_block *sb, __u32 *data, int len,
139                                int fhtype, int parent)
140 {
141         switch (fhtype) {
142                 case 2:
143                         if (len < 5)
144                                 break;
145                         if (parent)
146                                 return ll_iget_for_nfs(sb, data[3], 0, data[4]);
147                 case 1:
148                         if (len < 3)
149                                 break;
150                         if (parent)
151                                 break;
152                         return ll_iget_for_nfs(sb, data[0], data[1], data[2]);
153                 default: break;
154         }
155         return ERR_PTR(-EINVAL);
156 }
157
158 int ll_dentry_to_fh(struct dentry *dentry, __u32 *datap, int *lenp,
159                     int need_parent)
160 {
161         if (*lenp < 3)
162                 return 255;
163         *datap++ = dentry->d_inode->i_ino;
164         *datap++ = dentry->d_inode->i_generation;
165         *datap++ = (__u32)(S_IFMT & dentry->d_inode->i_mode);
166
167         if (*lenp == 3 || S_ISDIR(dentry->d_inode->i_mode)) {
168                 *lenp = 3;
169                 return 1;
170         }
171         if (dentry->d_parent) { 
172                 *datap++ = dentry->d_parent->d_inode->i_ino;
173                 *datap++ = (__u32)(S_IFMT & dentry->d_parent->d_inode->i_mode);
174          
175                 *lenp = 5;
176                 return 2;
177         }
178         *lenp = 3;
179         return 1;
180 }