blob: 29f9753ae5e5ba45c25eec7eaf26261ab6441b42 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/isofs/export.c
3 *
4 * (C) 2004 Paul Serice - The new inode scheme requires switching
5 * from iget() to iget5_locked() which means
6 * the NFS export operations have to be hand
7 * coded because the default routines rely on
8 * iget().
9 *
10 * The following files are helpful:
11 *
12 * Documentation/filesystems/Exporting
13 * fs/exportfs/expfs.c.
14 */
15
Al Viro94f2f712005-04-25 18:32:12 -070016#include "isofs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
18static struct dentry *
19isofs_export_iget(struct super_block *sb,
20 unsigned long block,
21 unsigned long offset,
22 __u32 generation)
23{
24 struct inode *inode;
25 struct dentry *result;
26 if (block == 0)
27 return ERR_PTR(-ESTALE);
28 inode = isofs_iget(sb, block, offset);
29 if (inode == NULL)
30 return ERR_PTR(-ENOMEM);
31 if (is_bad_inode(inode)
32 || (generation && inode->i_generation != generation))
33 {
34 iput(inode);
35 return ERR_PTR(-ESTALE);
36 }
37 result = d_alloc_anon(inode);
38 if (!result) {
39 iput(inode);
40 return ERR_PTR(-ENOMEM);
41 }
42 return result;
43}
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/* This function is surprisingly simple. The trick is understanding
46 * that "child" is always a directory. So, to find its parent, you
47 * simply need to find its ".." entry, normalize its block and offset,
48 * and return the underlying inode. See the comments for
49 * isofs_normalize_block_and_offset(). */
50static struct dentry *isofs_export_get_parent(struct dentry *child)
51{
52 unsigned long parent_block = 0;
53 unsigned long parent_offset = 0;
54 struct inode *child_inode = child->d_inode;
55 struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
56 struct inode *parent_inode = NULL;
57 struct iso_directory_record *de = NULL;
58 struct buffer_head * bh = NULL;
59 struct dentry *rv = NULL;
60
61 /* "child" must always be a directory. */
62 if (!S_ISDIR(child_inode->i_mode)) {
63 printk(KERN_ERR "isofs: isofs_export_get_parent(): "
64 "child is not a directory!\n");
65 rv = ERR_PTR(-EACCES);
66 goto out;
67 }
68
69 /* It is an invariant that the directory offset is zero. If
70 * it is not zero, it means the directory failed to be
71 * normalized for some reason. */
72 if (e_child_inode->i_iget5_offset != 0) {
73 printk(KERN_ERR "isofs: isofs_export_get_parent(): "
74 "child directory not normalized!\n");
75 rv = ERR_PTR(-EACCES);
76 goto out;
77 }
78
79 /* The child inode has been normalized such that its
80 * i_iget5_block value points to the "." entry. Fortunately,
81 * the ".." entry is located in the same block. */
82 parent_block = e_child_inode->i_iget5_block;
83
84 /* Get the block in question. */
85 bh = sb_bread(child_inode->i_sb, parent_block);
86 if (bh == NULL) {
87 rv = ERR_PTR(-EACCES);
88 goto out;
89 }
90
91 /* This is the "." entry. */
92 de = (struct iso_directory_record*)bh->b_data;
93
94 /* The ".." entry is always the second entry. */
95 parent_offset = (unsigned long)isonum_711(de->length);
96 de = (struct iso_directory_record*)(bh->b_data + parent_offset);
97
98 /* Verify it is in fact the ".." entry. */
99 if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) {
100 printk(KERN_ERR "isofs: Unable to find the \"..\" "
101 "directory for NFS.\n");
102 rv = ERR_PTR(-EACCES);
103 goto out;
104 }
105
106 /* Normalize */
107 isofs_normalize_block_and_offset(de, &parent_block, &parent_offset);
108
109 /* Get the inode. */
110 parent_inode = isofs_iget(child_inode->i_sb,
111 parent_block,
112 parent_offset);
113 if (parent_inode == NULL) {
114 rv = ERR_PTR(-EACCES);
115 goto out;
116 }
117
118 /* Allocate the dentry. */
119 rv = d_alloc_anon(parent_inode);
120 if (rv == NULL) {
121 rv = ERR_PTR(-ENOMEM);
122 goto out;
123 }
124
125 out:
126 if (bh) {
127 brelse(bh);
128 }
129 return rv;
130}
131
132static int
133isofs_export_encode_fh(struct dentry *dentry,
134 __u32 *fh32,
135 int *max_len,
136 int connectable)
137{
138 struct inode * inode = dentry->d_inode;
139 struct iso_inode_info * ei = ISOFS_I(inode);
140 int len = *max_len;
141 int type = 1;
142 __u16 *fh16 = (__u16*)fh32;
143
144 /*
145 * WARNING: max_len is 5 for NFSv2. Because of this
146 * limitation, we use the lower 16 bits of fh32[1] to hold the
147 * offset of the inode and the upper 16 bits of fh32[1] to
148 * hold the offset of the parent.
149 */
150
151 if (len < 3 || (connectable && len < 5))
152 return 255;
153
154 len = 3;
155 fh32[0] = ei->i_iget5_block;
156 fh16[2] = (__u16)ei->i_iget5_offset; /* fh16 [sic] */
157 fh32[2] = inode->i_generation;
158 if (connectable && !S_ISDIR(inode->i_mode)) {
159 struct inode *parent;
160 struct iso_inode_info *eparent;
161 spin_lock(&dentry->d_lock);
162 parent = dentry->d_parent->d_inode;
163 eparent = ISOFS_I(parent);
164 fh32[3] = eparent->i_iget5_block;
165 fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */
166 fh32[4] = parent->i_generation;
167 spin_unlock(&dentry->d_lock);
168 len = 5;
169 type = 2;
170 }
171 *max_len = len;
172 return type;
173}
174
Christoph Hellwig905251a2007-10-21 16:42:12 -0700175struct isofs_fid {
176 u32 block;
177 u16 offset;
178 u16 parent_offset;
179 u32 generation;
180 u32 parent_block;
181 u32 parent_generation;
182};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Christoph Hellwig905251a2007-10-21 16:42:12 -0700184static struct dentry *isofs_fh_to_dentry(struct super_block *sb,
185 struct fid *fid, int fh_len, int fh_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Christoph Hellwig905251a2007-10-21 16:42:12 -0700187 struct isofs_fid *ifid = (struct isofs_fid *)fid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Christoph Hellwig905251a2007-10-21 16:42:12 -0700189 if (fh_len < 3 || fh_type > 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 return NULL;
191
Christoph Hellwig905251a2007-10-21 16:42:12 -0700192 return isofs_export_iget(sb, ifid->block, ifid->offset,
193 ifid->generation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
Christoph Hellwig905251a2007-10-21 16:42:12 -0700196static struct dentry *isofs_fh_to_parent(struct super_block *sb,
197 struct fid *fid, int fh_len, int fh_type)
198{
199 struct isofs_fid *ifid = (struct isofs_fid *)fid;
200
201 if (fh_type != 2)
202 return NULL;
203
204 return isofs_export_iget(sb,
205 fh_len > 2 ? ifid->parent_block : 0,
206 ifid->parent_offset,
207 fh_len > 4 ? ifid->parent_generation : 0);
208}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Christoph Hellwig39655162007-10-21 16:42:17 -0700210const struct export_operations isofs_export_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 .encode_fh = isofs_export_encode_fh,
Christoph Hellwig905251a2007-10-21 16:42:12 -0700212 .fh_to_dentry = isofs_fh_to_dentry,
213 .fh_to_parent = isofs_fh_to_parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 .get_parent = isofs_export_get_parent,
215};