Btrfs: Remove unused xattr code
[linux-2.6.git] / fs / btrfs / xattr.c
1 /*
2  * Copyright (C) 2007 Red Hat.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #include <linux/init.h>
20 #include <linux/fs.h>
21 #include <linux/slab.h>
22 #include <linux/rwsem.h>
23 #include <linux/xattr.h>
24 #include "ctree.h"
25 #include "btrfs_inode.h"
26 #include "transaction.h"
27 #include "xattr.h"
28 #include "disk-io.h"
29 static struct xattr_handler *btrfs_xattr_handler_map[] = {
30         [BTRFS_XATTR_INDEX_USER]                = &btrfs_xattr_user_handler,
31 #ifdef CONFIG_FS_POSIX_ACL
32 //      [BTRFS_XATTR_INDEX_POSIX_ACL_ACCESS]    = &btrfs_xattr_acl_access_handler,
33 //      [BTRFS_XATTR_INDEX_POSIX_ACL_DEFAULT]   = &btrfs_xattr_acl_default_handler,
34 #endif
35         [BTRFS_XATTR_INDEX_TRUSTED]             = &btrfs_xattr_trusted_handler,
36         [BTRFS_XATTR_INDEX_SECURITY]            = &btrfs_xattr_security_handler,
37 //      [BTRFS_XATTR_INDEX_SYSTEM]              = &btrfs_xattr_system_handler,
38 };
39 struct xattr_handler *btrfs_xattr_handlers[] = {
40         &btrfs_xattr_user_handler,
41 #ifdef CONFIG_FS_POSIX_ACL
42 //      &btrfs_xattr_acl_access_handler,
43 //      &btrfs_xattr_acl_default_handler,
44 #endif
45         &btrfs_xattr_trusted_handler,
46         &btrfs_xattr_security_handler,
47 //      &btrfs_xattr_system_handler,
48         NULL,
49 };
50
51 /*
52  * @param name - the xattr name
53  * @return - the xattr_handler for the xattr, NULL if its not found
54  *
55  * use this with listxattr where we don't already know the type of xattr we
56  * have
57  */
58 static struct xattr_handler *find_btrfs_xattr_handler(struct extent_buffer *l,
59                                                       unsigned long name_ptr,
60                                                       u16 name_len)
61 {
62         struct xattr_handler *handler = NULL;
63         int i = 0;
64
65         for (handler = btrfs_xattr_handlers[i]; handler != NULL; i++,
66              handler = btrfs_xattr_handlers[i]) {
67                 u16 prefix_len = strlen(handler->prefix);
68
69                 if (name_len < prefix_len)
70                         continue;
71
72                 if (memcmp_extent_buffer(l, handler->prefix, name_ptr,
73                                          prefix_len) == 0)
74                         break;
75         }
76
77         return handler;
78 }
79
80 /*
81  * @param name_index - the index for the xattr handler
82  * @return the xattr_handler if we found it, NULL otherwise
83  *
84  * use this if we know the type of the xattr already
85  */
86 static struct xattr_handler *btrfs_xattr_handler(int name_index)
87 {
88         struct xattr_handler *handler = NULL;
89
90         if (name_index >= 0 &&
91             name_index < ARRAY_SIZE(btrfs_xattr_handler_map))
92                 handler = btrfs_xattr_handler_map[name_index];
93
94         return handler;
95 }
96
97 static inline char *get_name(const char *name, int name_index)
98 {
99         char *ret = NULL;
100         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
101         int prefix_len;
102
103         if (!handler)
104                 return ret;
105
106         prefix_len = strlen(handler->prefix);
107
108         ret = kmalloc(strlen(name) + prefix_len + 1, GFP_KERNEL);
109         if (!ret)
110                 return ret;
111
112         memcpy(ret, handler->prefix, prefix_len);
113         memcpy(ret+prefix_len, name, strlen(name));
114         ret[prefix_len + strlen(name)] = '\0';
115
116         return ret;
117 }
118
119 size_t btrfs_xattr_generic_list(struct inode *inode, char *list,
120                                 size_t list_size, const char *name,
121                                 size_t name_len)
122 {
123         if (list && (name_len+1) <= list_size) {
124                 memcpy(list, name, name_len);
125                 list[name_len] = '\0';
126         } else
127                 return -ERANGE;
128
129         return name_len+1;
130 }
131
132 ssize_t btrfs_xattr_get(struct inode *inode, int name_index,
133                         const char *attr_name, void *buffer, size_t size)
134 {
135         struct btrfs_dir_item *di;
136         struct btrfs_root *root = BTRFS_I(inode)->root;
137         struct btrfs_path *path;
138         struct extent_buffer *leaf;
139         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
140         int ret = 0;
141         unsigned long data_ptr;
142         char *name;
143
144         if (!handler)
145                 return -EOPNOTSUPP;
146         name = get_name(attr_name, name_index);
147         if (!name)
148                 return -ENOMEM;
149
150         path = btrfs_alloc_path();
151         if (!path) {
152                 kfree(name);
153                 return -ENOMEM;
154         }
155
156         /* lookup the xattr by name */
157         di = btrfs_lookup_xattr(NULL, root, path, inode->i_ino, name,
158                                 strlen(name), 0);
159         if (!di || IS_ERR(di)) {
160                 ret = -ENODATA;
161                 goto out;
162         }
163
164         leaf = path->nodes[0];
165         /* if size is 0, that means we want the size of the attr */
166         if (!size) {
167                 ret = btrfs_dir_data_len(leaf, di);
168                 goto out;
169         }
170
171         /* now get the data out of our dir_item */
172         if (btrfs_dir_data_len(leaf, di) > size) {
173                 ret = -ERANGE;
174                 goto out;
175         }
176         data_ptr = (unsigned long)((char *)(di + 1) +
177                                    btrfs_dir_name_len(leaf, di));
178         read_extent_buffer(leaf, buffer, data_ptr,
179                            btrfs_dir_data_len(leaf, di));
180         ret = btrfs_dir_data_len(leaf, di);
181
182 out:
183         kfree(name);
184         btrfs_free_path(path);
185         return ret;
186 }
187
188 int btrfs_xattr_set(struct inode *inode, int name_index,
189                     const char *attr_name, const void *value, size_t size,
190                     int flags)
191 {
192         struct btrfs_dir_item *di;
193         struct btrfs_root *root = BTRFS_I(inode)->root;
194         struct btrfs_trans_handle *trans;
195         struct btrfs_path *path;
196         struct xattr_handler *handler = btrfs_xattr_handler(name_index);
197         char *name;
198         int ret = 0, mod = 0;
199         if (!handler)
200                 return -EOPNOTSUPP;
201         name = get_name(attr_name, name_index);
202         if (!name)
203                 return -ENOMEM;
204
205         path = btrfs_alloc_path();
206         if (!path) {
207                 kfree(name);
208                 return -ENOMEM;
209         }
210
211         trans = btrfs_start_transaction(root, 1);
212         btrfs_set_trans_block_group(trans, inode);
213
214         /* first lets see if we already have this xattr */
215         di = btrfs_lookup_xattr(trans, root, path, inode->i_ino, name,
216                                 strlen(name), -1);
217         if (IS_ERR(di)) {
218                 ret = PTR_ERR(di);
219                 goto out;
220         }
221
222         /* ok we already have this xattr, lets remove it */
223         if (di) {
224                 /* if we want create only exit */
225                 if (flags & XATTR_CREATE) {
226                         ret = -EEXIST;
227                         goto out;
228                 }
229
230                 ret = btrfs_delete_one_dir_name(trans, root, path, di);
231                 if (ret)
232                         goto out;
233                 btrfs_release_path(root, path);
234
235                 /* if we don't have a value then we are removing the xattr */
236                 if (!value) {
237                         mod = 1;
238                         goto out;
239                 }
240         } else if (flags & XATTR_REPLACE) {
241                 /* we couldn't find the attr to replace, so error out */
242                 ret = -ENODATA;
243                 goto out;
244         }
245
246         /* ok we have to create a completely new xattr */
247         ret = btrfs_insert_xattr_item(trans, root, name, strlen(name),
248                                       value, size, inode->i_ino);
249         if (ret)
250                 goto out;
251         mod = 1;
252
253 out:
254         if (mod) {
255                 inode->i_ctime = CURRENT_TIME;
256                 ret = btrfs_update_inode(trans, root, inode);
257         }
258
259         btrfs_end_transaction(trans, root);
260         kfree(name);
261         btrfs_free_path(path);
262
263         return ret;
264 }
265
266 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
267 {
268         struct btrfs_key key, found_key;
269         struct inode *inode = dentry->d_inode;
270         struct btrfs_root *root = BTRFS_I(inode)->root;
271         struct btrfs_path *path;
272         struct btrfs_item *item;
273         struct extent_buffer *leaf;
274         struct btrfs_dir_item *di;
275         struct xattr_handler *handler;
276         int ret = 0, slot, advance;
277         size_t total_size = 0, size_left = size, written;
278         unsigned long name_ptr;
279         char *name;
280         u32 nritems;
281
282         /*
283          * ok we want all objects associated with this id.
284          * NOTE: we set key.offset = 0; because we want to start with the
285          * first xattr that we find and walk forward
286          */
287         key.objectid = inode->i_ino;
288         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
289         key.offset = 0;
290
291         path = btrfs_alloc_path();
292         if (!path)
293                 return -ENOMEM;
294         path->reada = 2;
295
296         /* search for our xattrs */
297         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
298         if (ret < 0)
299                 goto err;
300         ret = 0;
301         advance = 0;
302         while (1) {
303                 leaf = path->nodes[0];
304                 nritems = btrfs_header_nritems(leaf);
305                 slot = path->slots[0];
306
307                 /* this is where we start walking through the path */
308                 if (advance || slot >= nritems) {
309                         /*
310                          * if we've reached the last slot in this leaf we need
311                          * to go to the next leaf and reset everything
312                          */
313                         if (slot >= nritems-1) {
314                                 ret = btrfs_next_leaf(root, path);
315                                 if (ret)
316                                         break;
317                                 leaf = path->nodes[0];
318                                 nritems = btrfs_header_nritems(leaf);
319                                 slot = path->slots[0];
320                         } else {
321                                 /*
322                                  * just walking through the slots on this leaf
323                                  */
324                                 slot++;
325                                 path->slots[0]++;
326                         }
327                 }
328                 advance = 1;
329
330                 item = btrfs_item_nr(leaf, slot);
331                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
332
333                 /* check to make sure this item is what we want */
334                 if (found_key.objectid != key.objectid)
335                         break;
336                 if (btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY)
337                         break;
338
339                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
340
341                 total_size += btrfs_dir_name_len(leaf, di)+1;
342
343                 /* we are just looking for how big our buffer needs to be */
344                 if (!size)
345                         continue;
346
347                 /* find our handler for this xattr */
348                 name_ptr = (unsigned long)(di + 1);
349                 handler = find_btrfs_xattr_handler(leaf, name_ptr,
350                                                    btrfs_dir_name_len(leaf, di));
351                 if (!handler) {
352                         printk(KERN_ERR "btrfs: unsupported xattr found\n");
353                         continue;
354                 }
355
356                 name = kmalloc(btrfs_dir_name_len(leaf, di), GFP_KERNEL);
357                 read_extent_buffer(leaf, name, name_ptr,
358                                    btrfs_dir_name_len(leaf, di));
359
360                 /* call the list function associated with this xattr */
361                 written = handler->list(inode, buffer, size_left, name,
362                                         btrfs_dir_name_len(leaf, di));
363                 kfree(name);
364
365                 if (written < 0) {
366                         ret = -ERANGE;
367                         break;
368                 }
369
370                 size_left -= written;
371                 buffer += written;
372         }
373         ret = total_size;
374
375 err:
376         btrfs_free_path(path);
377
378         return ret;
379 }
380
381 /*
382  * Handler functions
383  */
384 #define BTRFS_XATTR_SETGET_FUNCS(name, index)                           \
385 static int btrfs_xattr_##name##_get(struct inode *inode,                \
386                                     const char *name, void *value,      \
387                                     size_t size)                        \
388 {                                                                       \
389         if (*name == '\0')                                              \
390                 return -EINVAL;                                         \
391         return btrfs_xattr_get(inode, index, name, value, size);        \
392 }                                                                       \
393 static int btrfs_xattr_##name##_set(struct inode *inode,                \
394                                     const char *name, const void *value,\
395                                     size_t size, int flags)             \
396 {                                                                       \
397         if (*name == '\0')                                              \
398                 return -EINVAL;                                         \
399         return btrfs_xattr_set(inode, index, name, value, size, flags); \
400 }
401
402 BTRFS_XATTR_SETGET_FUNCS(security, BTRFS_XATTR_INDEX_SECURITY);
403 BTRFS_XATTR_SETGET_FUNCS(system, BTRFS_XATTR_INDEX_SYSTEM);
404 BTRFS_XATTR_SETGET_FUNCS(user, BTRFS_XATTR_INDEX_USER);
405 BTRFS_XATTR_SETGET_FUNCS(trusted, BTRFS_XATTR_INDEX_TRUSTED);
406
407 struct xattr_handler btrfs_xattr_security_handler = {
408         .prefix = XATTR_SECURITY_PREFIX,
409         .list   = btrfs_xattr_generic_list,
410         .get    = btrfs_xattr_security_get,
411         .set    = btrfs_xattr_security_set,
412 };
413
414 struct xattr_handler btrfs_xattr_system_handler = {
415         .prefix = XATTR_SYSTEM_PREFIX,
416         .list   = btrfs_xattr_generic_list,
417         .get    = btrfs_xattr_system_get,
418         .set    = btrfs_xattr_system_set,
419 };
420
421 struct xattr_handler btrfs_xattr_user_handler = {
422         .prefix = XATTR_USER_PREFIX,
423         .list   = btrfs_xattr_generic_list,
424         .get    = btrfs_xattr_user_get,
425         .set    = btrfs_xattr_user_set,
426 };
427
428 struct xattr_handler btrfs_xattr_trusted_handler = {
429         .prefix = XATTR_TRUSTED_PREFIX,
430         .list   = btrfs_xattr_generic_list,
431         .get    = btrfs_xattr_trusted_get,
432         .set    = btrfs_xattr_trusted_set,
433 };