Merge branch 'HEAD' of master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6] / fs / gfs2 / ops_export.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
17 #include <linux/lm_interface.h>
18
19 #include "gfs2.h"
20 #include "incore.h"
21 #include "dir.h"
22 #include "glock.h"
23 #include "glops.h"
24 #include "inode.h"
25 #include "ops_dentry.h"
26 #include "ops_export.h"
27 #include "rgrp.h"
28 #include "util.h"
29
30 static struct dentry *gfs2_decode_fh(struct super_block *sb,
31                                      __u32 *p,
32                                      int fh_len,
33                                      int fh_type,
34                                      int (*acceptable)(void *context,
35                                                        struct dentry *dentry),
36                                      void *context)
37 {
38         __be32 *fh = (__force __be32 *)p;
39         struct gfs2_fh_obj fh_obj;
40         struct gfs2_inum_host *this, parent;
41
42         if (fh_type != fh_len)
43                 return NULL;
44
45         this            = &fh_obj.this;
46         fh_obj.imode    = DT_UNKNOWN;
47         memset(&parent, 0, sizeof(struct gfs2_inum));
48
49         switch (fh_type) {
50         case GFS2_LARGE_FH_SIZE:
51                 parent.no_formal_ino = ((u64)be32_to_cpu(fh[4])) << 32;
52                 parent.no_formal_ino |= be32_to_cpu(fh[5]);
53                 parent.no_addr = ((u64)be32_to_cpu(fh[6])) << 32;
54                 parent.no_addr |= be32_to_cpu(fh[7]);
55                 fh_obj.imode = be32_to_cpu(fh[8]);
56         case GFS2_SMALL_FH_SIZE:
57                 this->no_formal_ino = ((u64)be32_to_cpu(fh[0])) << 32;
58                 this->no_formal_ino |= be32_to_cpu(fh[1]);
59                 this->no_addr = ((u64)be32_to_cpu(fh[2])) << 32;
60                 this->no_addr |= be32_to_cpu(fh[3]);
61                 break;
62         default:
63                 return NULL;
64         }
65
66         return gfs2_export_ops.find_exported_dentry(sb, &fh_obj, &parent,
67                                                     acceptable, context);
68 }
69
70 static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,
71                           int connectable)
72 {
73         __be32 *fh = (__force __be32 *)p;
74         struct inode *inode = dentry->d_inode;
75         struct super_block *sb = inode->i_sb;
76         struct gfs2_inode *ip = GFS2_I(inode);
77
78         if (*len < GFS2_SMALL_FH_SIZE ||
79             (connectable && *len < GFS2_LARGE_FH_SIZE))
80                 return 255;
81
82         fh[0] = cpu_to_be32(ip->i_num.no_formal_ino >> 32);
83         fh[1] = cpu_to_be32(ip->i_num.no_formal_ino & 0xFFFFFFFF);
84         fh[2] = cpu_to_be32(ip->i_num.no_addr >> 32);
85         fh[3] = cpu_to_be32(ip->i_num.no_addr & 0xFFFFFFFF);
86         *len = GFS2_SMALL_FH_SIZE;
87
88         if (!connectable || inode == sb->s_root->d_inode)
89                 return *len;
90
91         spin_lock(&dentry->d_lock);
92         inode = dentry->d_parent->d_inode;
93         ip = GFS2_I(inode);
94         igrab(inode);
95         spin_unlock(&dentry->d_lock);
96
97         fh[4] = cpu_to_be32(ip->i_num.no_formal_ino >> 32);
98         fh[5] = cpu_to_be32(ip->i_num.no_formal_ino & 0xFFFFFFFF);
99         fh[6] = cpu_to_be32(ip->i_num.no_addr >> 32);
100         fh[7] = cpu_to_be32(ip->i_num.no_addr & 0xFFFFFFFF);
101
102         fh[8]  = cpu_to_be32(inode->i_mode);
103         fh[9]  = 0;     /* pad to double word */
104         *len = GFS2_LARGE_FH_SIZE;
105
106         iput(inode);
107
108         return *len;
109 }
110
111 struct get_name_filldir {
112         struct gfs2_inum_host inum;
113         char *name;
114 };
115
116 static int get_name_filldir(void *opaque, const char *name, int length,
117                             loff_t offset, u64 inum, unsigned int type)
118 {
119         struct get_name_filldir *gnfd = opaque;
120
121         if (inum != gnfd->inum.no_addr)
122                 return 0;
123
124         memcpy(gnfd->name, name, length);
125         gnfd->name[length] = 0;
126
127         return 1;
128 }
129
130 static int gfs2_get_name(struct dentry *parent, char *name,
131                          struct dentry *child)
132 {
133         struct inode *dir = parent->d_inode;
134         struct inode *inode = child->d_inode;
135         struct gfs2_inode *dip, *ip;
136         struct get_name_filldir gnfd;
137         struct gfs2_holder gh;
138         u64 offset = 0;
139         int error;
140
141         if (!dir)
142                 return -EINVAL;
143
144         if (!S_ISDIR(dir->i_mode) || !inode)
145                 return -EINVAL;
146
147         dip = GFS2_I(dir);
148         ip = GFS2_I(inode);
149
150         *name = 0;
151         gnfd.inum = ip->i_num;
152         gnfd.name = name;
153
154         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh);
155         if (error)
156                 return error;
157
158         error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir);
159
160         gfs2_glock_dq_uninit(&gh);
161
162         if (!error && !*name)
163                 error = -ENOENT;
164
165         return error;
166 }
167
168 static struct dentry *gfs2_get_parent(struct dentry *child)
169 {
170         struct qstr dotdot;
171         struct inode *inode;
172         struct dentry *dentry;
173
174         gfs2_str2qstr(&dotdot, "..");
175         inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL);
176
177         if (!inode)
178                 return ERR_PTR(-ENOENT);
179         /*
180          * In case of an error, @inode carries the error value, and we
181          * have to return that as a(n invalid) pointer to dentry.
182          */
183         if (IS_ERR(inode))
184                 return ERR_PTR(PTR_ERR(inode));
185
186         dentry = d_alloc_anon(inode);
187         if (!dentry) {
188                 iput(inode);
189                 return ERR_PTR(-ENOMEM);
190         }
191
192         dentry->d_op = &gfs2_dops;
193         return dentry;
194 }
195
196 static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_obj)
197 {
198         struct gfs2_sbd *sdp = sb->s_fs_info;
199         struct gfs2_fh_obj *fh_obj = (struct gfs2_fh_obj *)inum_obj;
200         struct gfs2_inum_host *inum = &fh_obj->this;
201         struct gfs2_holder i_gh, ri_gh, rgd_gh;
202         struct gfs2_rgrpd *rgd;
203         struct inode *inode;
204         struct dentry *dentry;
205         int error;
206
207         /* System files? */
208
209         inode = gfs2_ilookup(sb, inum);
210         if (inode) {
211                 if (GFS2_I(inode)->i_num.no_formal_ino != inum->no_formal_ino) {
212                         iput(inode);
213                         return ERR_PTR(-ESTALE);
214                 }
215                 goto out_inode;
216         }
217
218         error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops,
219                                   LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
220         if (error)
221                 return ERR_PTR(error);
222
223         error = gfs2_rindex_hold(sdp, &ri_gh);
224         if (error)
225                 goto fail;
226
227         error = -EINVAL;
228         rgd = gfs2_blk2rgrpd(sdp, inum->no_addr);
229         if (!rgd)
230                 goto fail_rindex;
231
232         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
233         if (error)
234                 goto fail_rindex;
235
236         error = -ESTALE;
237         if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE)
238                 goto fail_rgd;
239
240         gfs2_glock_dq_uninit(&rgd_gh);
241         gfs2_glock_dq_uninit(&ri_gh);
242
243         inode = gfs2_inode_lookup(sb, inum, fh_obj->imode);
244         if (!inode)
245                 goto fail;
246         if (IS_ERR(inode)) {
247                 error = PTR_ERR(inode);
248                 goto fail;
249         }
250
251         error = gfs2_inode_refresh(GFS2_I(inode));
252         if (error) {
253                 iput(inode);
254                 goto fail;
255         }
256
257         error = -EIO;
258         if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) {
259                 iput(inode);
260                 goto fail;
261         }
262
263         gfs2_glock_dq_uninit(&i_gh);
264
265 out_inode:
266         dentry = d_alloc_anon(inode);
267         if (!dentry) {
268                 iput(inode);
269                 return ERR_PTR(-ENOMEM);
270         }
271
272         dentry->d_op = &gfs2_dops;
273         return dentry;
274
275 fail_rgd:
276         gfs2_glock_dq_uninit(&rgd_gh);
277
278 fail_rindex:
279         gfs2_glock_dq_uninit(&ri_gh);
280
281 fail:
282         gfs2_glock_dq_uninit(&i_gh);
283         return ERR_PTR(error);
284 }
285
286 struct export_operations gfs2_export_ops = {
287         .decode_fh = gfs2_decode_fh,
288         .encode_fh = gfs2_encode_fh,
289         .get_name = gfs2_get_name,
290         .get_parent = gfs2_get_parent,
291         .get_dentry = gfs2_get_dentry,
292 };
293