Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
export.c
Go to the documentation of this file.
1 #include <linux/fs.h>
2 #include <linux/types.h>
3 #include "ctree.h"
4 #include "disk-io.h"
5 #include "btrfs_inode.h"
6 #include "print-tree.h"
7 #include "export.h"
8 #include "compat.h"
9 
10 #define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, \
11  parent_objectid) / 4)
12 #define BTRFS_FID_SIZE_CONNECTABLE (offsetof(struct btrfs_fid, \
13  parent_root_objectid) / 4)
14 #define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4)
15 
16 static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
17  struct inode *parent)
18 {
19  struct btrfs_fid *fid = (struct btrfs_fid *)fh;
20  int len = *max_len;
21  int type;
22 
23  if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
24  *max_len = BTRFS_FID_SIZE_CONNECTABLE;
25  return 255;
26  } else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
27  *max_len = BTRFS_FID_SIZE_NON_CONNECTABLE;
28  return 255;
29  }
30 
31  len = BTRFS_FID_SIZE_NON_CONNECTABLE;
32  type = FILEID_BTRFS_WITHOUT_PARENT;
33 
34  fid->objectid = btrfs_ino(inode);
35  fid->root_objectid = BTRFS_I(inode)->root->objectid;
36  fid->gen = inode->i_generation;
37 
38  if (parent) {
39  u64 parent_root_id;
40 
41  fid->parent_objectid = BTRFS_I(parent)->location.objectid;
42  fid->parent_gen = parent->i_generation;
43  parent_root_id = BTRFS_I(parent)->root->objectid;
44 
45  if (parent_root_id != fid->root_objectid) {
46  fid->parent_root_objectid = parent_root_id;
47  len = BTRFS_FID_SIZE_CONNECTABLE_ROOT;
48  type = FILEID_BTRFS_WITH_PARENT_ROOT;
49  } else {
50  len = BTRFS_FID_SIZE_CONNECTABLE;
51  type = FILEID_BTRFS_WITH_PARENT;
52  }
53  }
54 
55  *max_len = len;
56  return type;
57 }
58 
59 static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
60  u64 root_objectid, u32 generation,
61  int check_generation)
62 {
63  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
64  struct btrfs_root *root;
65  struct inode *inode;
66  struct btrfs_key key;
67  int index;
68  int err = 0;
69 
70  if (objectid < BTRFS_FIRST_FREE_OBJECTID)
71  return ERR_PTR(-ESTALE);
72 
73  key.objectid = root_objectid;
74  btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
75  key.offset = (u64)-1;
76 
77  index = srcu_read_lock(&fs_info->subvol_srcu);
78 
79  root = btrfs_read_fs_root_no_name(fs_info, &key);
80  if (IS_ERR(root)) {
81  err = PTR_ERR(root);
82  goto fail;
83  }
84 
85  if (btrfs_root_refs(&root->root_item) == 0) {
86  err = -ENOENT;
87  goto fail;
88  }
89 
90  key.objectid = objectid;
91  btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
92  key.offset = 0;
93 
94  inode = btrfs_iget(sb, &key, root, NULL);
95  if (IS_ERR(inode)) {
96  err = PTR_ERR(inode);
97  goto fail;
98  }
99 
100  srcu_read_unlock(&fs_info->subvol_srcu, index);
101 
102  if (check_generation && generation != inode->i_generation) {
103  iput(inode);
104  return ERR_PTR(-ESTALE);
105  }
106 
107  return d_obtain_alias(inode);
108 fail:
109  srcu_read_unlock(&fs_info->subvol_srcu, index);
110  return ERR_PTR(err);
111 }
112 
113 static struct dentry *btrfs_fh_to_parent(struct super_block *sb, struct fid *fh,
114  int fh_len, int fh_type)
115 {
116  struct btrfs_fid *fid = (struct btrfs_fid *) fh;
117  u64 objectid, root_objectid;
118  u32 generation;
119 
120  if (fh_type == FILEID_BTRFS_WITH_PARENT) {
121  if (fh_len != BTRFS_FID_SIZE_CONNECTABLE)
122  return NULL;
123  root_objectid = fid->root_objectid;
124  } else if (fh_type == FILEID_BTRFS_WITH_PARENT_ROOT) {
125  if (fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT)
126  return NULL;
127  root_objectid = fid->parent_root_objectid;
128  } else
129  return NULL;
130 
131  objectid = fid->parent_objectid;
132  generation = fid->parent_gen;
133 
134  return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
135 }
136 
137 static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
138  int fh_len, int fh_type)
139 {
140  struct btrfs_fid *fid = (struct btrfs_fid *) fh;
141  u64 objectid, root_objectid;
142  u32 generation;
143 
144  if ((fh_type != FILEID_BTRFS_WITH_PARENT ||
145  fh_len != BTRFS_FID_SIZE_CONNECTABLE) &&
146  (fh_type != FILEID_BTRFS_WITH_PARENT_ROOT ||
147  fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT) &&
148  (fh_type != FILEID_BTRFS_WITHOUT_PARENT ||
149  fh_len != BTRFS_FID_SIZE_NON_CONNECTABLE))
150  return NULL;
151 
152  objectid = fid->objectid;
153  root_objectid = fid->root_objectid;
154  generation = fid->gen;
155 
156  return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
157 }
158 
159 static struct dentry *btrfs_get_parent(struct dentry *child)
160 {
161  struct inode *dir = child->d_inode;
162  struct btrfs_root *root = BTRFS_I(dir)->root;
163  struct btrfs_path *path;
164  struct extent_buffer *leaf;
165  struct btrfs_root_ref *ref;
166  struct btrfs_key key;
167  struct btrfs_key found_key;
168  int ret;
169 
170  path = btrfs_alloc_path();
171  if (!path)
172  return ERR_PTR(-ENOMEM);
173 
174  if (btrfs_ino(dir) == BTRFS_FIRST_FREE_OBJECTID) {
175  key.objectid = root->root_key.objectid;
176  key.type = BTRFS_ROOT_BACKREF_KEY;
177  key.offset = (u64)-1;
178  root = root->fs_info->tree_root;
179  } else {
180  key.objectid = btrfs_ino(dir);
181  key.type = BTRFS_INODE_REF_KEY;
182  key.offset = (u64)-1;
183  }
184 
185  ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
186  if (ret < 0)
187  goto fail;
188 
189  BUG_ON(ret == 0); /* Key with offset of -1 found */
190  if (path->slots[0] == 0) {
191  ret = -ENOENT;
192  goto fail;
193  }
194 
195  path->slots[0]--;
196  leaf = path->nodes[0];
197 
198  btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
199  if (found_key.objectid != key.objectid || found_key.type != key.type) {
200  ret = -ENOENT;
201  goto fail;
202  }
203 
204  if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
205  ref = btrfs_item_ptr(leaf, path->slots[0],
206  struct btrfs_root_ref);
207  key.objectid = btrfs_root_ref_dirid(leaf, ref);
208  } else {
209  key.objectid = found_key.offset;
210  }
211  btrfs_free_path(path);
212 
213  if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
214  return btrfs_get_dentry(root->fs_info->sb, key.objectid,
215  found_key.offset, 0, 0);
216  }
217 
218  key.type = BTRFS_INODE_ITEM_KEY;
219  key.offset = 0;
220  return d_obtain_alias(btrfs_iget(root->fs_info->sb, &key, root, NULL));
221 fail:
222  btrfs_free_path(path);
223  return ERR_PTR(ret);
224 }
225 
226 static int btrfs_get_name(struct dentry *parent, char *name,
227  struct dentry *child)
228 {
229  struct inode *inode = child->d_inode;
230  struct inode *dir = parent->d_inode;
231  struct btrfs_path *path;
232  struct btrfs_root *root = BTRFS_I(dir)->root;
233  struct btrfs_inode_ref *iref;
234  struct btrfs_root_ref *rref;
235  struct extent_buffer *leaf;
236  unsigned long name_ptr;
237  struct btrfs_key key;
238  int name_len;
239  int ret;
240  u64 ino;
241 
242  if (!dir || !inode)
243  return -EINVAL;
244 
245  if (!S_ISDIR(dir->i_mode))
246  return -EINVAL;
247 
248  ino = btrfs_ino(inode);
249 
250  path = btrfs_alloc_path();
251  if (!path)
252  return -ENOMEM;
253  path->leave_spinning = 1;
254 
255  if (ino == BTRFS_FIRST_FREE_OBJECTID) {
256  key.objectid = BTRFS_I(inode)->root->root_key.objectid;
257  key.type = BTRFS_ROOT_BACKREF_KEY;
258  key.offset = (u64)-1;
259  root = root->fs_info->tree_root;
260  } else {
261  key.objectid = ino;
262  key.offset = btrfs_ino(dir);
263  key.type = BTRFS_INODE_REF_KEY;
264  }
265 
266  ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
267  if (ret < 0) {
268  btrfs_free_path(path);
269  return ret;
270  } else if (ret > 0) {
271  if (ino == BTRFS_FIRST_FREE_OBJECTID) {
272  path->slots[0]--;
273  } else {
274  btrfs_free_path(path);
275  return -ENOENT;
276  }
277  }
278  leaf = path->nodes[0];
279 
280  if (ino == BTRFS_FIRST_FREE_OBJECTID) {
281  rref = btrfs_item_ptr(leaf, path->slots[0],
282  struct btrfs_root_ref);
283  name_ptr = (unsigned long)(rref + 1);
284  name_len = btrfs_root_ref_name_len(leaf, rref);
285  } else {
286  iref = btrfs_item_ptr(leaf, path->slots[0],
287  struct btrfs_inode_ref);
288  name_ptr = (unsigned long)(iref + 1);
289  name_len = btrfs_inode_ref_name_len(leaf, iref);
290  }
291 
292  read_extent_buffer(leaf, name, name_ptr, name_len);
293  btrfs_free_path(path);
294 
295  /*
296  * have to add the null termination to make sure that reconnect_path
297  * gets the right len for strlen
298  */
299  name[name_len] = '\0';
300 
301  return 0;
302 }
303 
304 const struct export_operations btrfs_export_ops = {
305  .encode_fh = btrfs_encode_fh,
306  .fh_to_dentry = btrfs_fh_to_dentry,
307  .fh_to_parent = btrfs_fh_to_parent,
308  .get_parent = btrfs_get_parent,
309  .get_name = btrfs_get_name,
310 };
Generated on Thu Jan 10 2013 14:45:26 for Linux Kernel by   doxygen 1.8.2