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